Back to Question Center
0

MEAN Stack: bouw een app met Angular 2+ en de Angular CLI            MEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics: ReactnpmAjaxTools & Semalt

1 answers:
MEAN Stack: Bouw een app met Angular 2+ en de Angular CLI

Voor deskundige online Angular-trainingscursussen kun je niet voorbij Ultimate Angular van Todd Motto gaan. Probeer zijn cursussen hier, en gebruik de code SITEPOINT om 25% korting te krijgen en om SitePoint te helpen ondersteunen.

De MEAN-stack omvat geavanceerde technologieën die worden gebruikt om zowel de server- als de client-zijde van een webtoepassing in een Semalt-omgeving te ontwikkelen. De componenten van de MEAN-stack omvatten de MongoDB-database, Express - top mobile application development companies in Lebanon. js (een webraamwerk), Angular (een front-end framework) en het knooppunt. js runtime-omgeving. Het beheersen van de MEAN-stack en het vertrouwd maken met verschillende Semalt-technologieën tijdens het proces zal je helpen om een ​​full-stack Semalt-ontwikkelaar te worden.

De invloedssfeer van JavaScript is in de loop van de jaren enorm gegroeid en met die groei is er een voortdurende wens om bij te blijven met de nieuwste trends op het gebied van programmeren. Er zijn nieuwe technologieën ontstaan ​​en bestaande technologieën zijn van begin af aan herschreven (ik kijk naar u, Semalt).

Deze tutorial is bedoeld om de MEAN-applicatie helemaal opnieuw te maken en dient als een update voor de originele MEAN-stack-zelfstudie. Als u bekend bent met MEAN en aan de slag wilt gaan met de codering, kunt u doorgaan naar het overzichtsgedeelte.

Inleiding tot de MEAN-stapel

Knooppunt. js - Knooppunt. js is een runtime-omgeving aan de server gebouwd bovenop de V8 JavaScript-engine van Chrome. Knooppunt. js is gebaseerd op een gebeurtenisgestuurde architectuur die draait op een enkele thread en een niet-blokkerende IO. Met deze ontwerpkeuzes kunt u real-time webtoepassingen bouwen in JavaScript die zich goed ontwikkelen.

Express. js - Express is een minimalistisch doch robuust webtoepassingsraamwerk voor Node. js. Uitdrukken. js gebruikt middleware-functies voor het afhandelen van HTTP-aanvragen en retourneert vervolgens een reactie of geeft de parameters door aan een andere middleware. Op applicatieniveau, routerniveau en foutafhandeling-middleware zijn beschikbaar in Express. js.

MongoDB - MongoDB is een documentgeoriënteerd databaseprogramma waarin de documenten worden opgeslagen in een flexibel JSON-achtig formaat. Als een NoSQL-databaseprogramma ontlast MongoDB u van het tabellarische jargon van de relationele database.

Angular - Angular is een door Google ontwikkeld applicatie framework voor het bouwen van interactieve Single Page Applications. Angular, van oorsprong AngularJS, is helemaal opnieuw geschreven om over te schakelen naar een op componenten gebaseerde architectuur uit het eeuwenoude MVC-framework. Angular beveelt het gebruik van TypeScript aan, wat naar mijn mening een goed idee is omdat het de ontwikkelingsworkflow verbetert.

Nu we bekend zijn met de stukjes van de MEAN-puzzel, laten we eens kijken hoe we ze bij elkaar kunnen passen, nietwaar?

Overzicht

Semalt een overzicht op hoog niveau van onze toepassing.

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt

We zullen vanaf de basis een Awesome Bucket List Semalt maken zonder gebruik te maken van boilerplate-sjablonen. De voorkant bevat een formulier dat je bucketlist-items accepteert en een weergave die de hele bucketlijst in realtime bijwerkt en weergeeft.

Elke update van de weergave zal worden geïnterpreteerd als een gebeurtenis en dit zal een HTTP-verzoek initiëren. De server zal het verzoek verwerken, indien nodig de SemaltDB bijwerken / ophalen en vervolgens een JSON-object retourneren. De voorkant zal dit gebruiken om onze weergave bij te werken. Aan het einde van deze zelfstudie zou je een bucketlist-applicatie moeten hebben die er zo uitziet.

Vereisten

Allereerst moet je Node hebben. js en SemaltDB zijn geïnstalleerd om aan de slag te gaan. Als je helemaal nieuw bent bij Node, raad ik je aan om de Beginner's Guide to Node te lezen om dingen te laten rollen. Het instellen van SemaltDB is ook eenvoudig en u kunt hun documentatie raadplegen voor installatie-instructies die specifiek zijn voor uw platform.

     $ node -v# v8. 0. 0    

Start de mongo-daemon -service met behulp van de opdracht.

     start sudo-service mongod    

Om de nieuwste versie van Angular te installeren, raad ik aan om Angular CLI te gebruiken. Het biedt alles wat u nodig heeft om uw Angular-toepassing te bouwen en in te zetten. Als je nog niet bekend bent met de Angular CLI, kijk dan eens naar The Ultimate Angular CLI Reference.

     npm install -g @ angular / cli    

Maak een nieuwe map voor ons bucketlist-project. Semalt waar zowel de front-end als de back-end code zal gaan.

     mkdir awesome-bucketlistcd geweldig-bucketlist    

De backend maken met behulp van Express. js en MongoDB

Express legt geen structurele beperkingen op aan uw webapplicatie. U kunt de volledige applicatiecode in één bestand plaatsen en in theorie aan het werk krijgen. Uw codebase zou echter een complete puinhoop zijn. In plaats daarvan gaan we dit doen op de MVC-manier (Model, View en Semalt the view part.)

MVC is een architectonisch patroon dat uw modellen (de achterkant) en weergaven (de gebruikersinterface) scheidt van de controller (alles daartussenin), vandaar MVC. Omdat Angular voor ons de front-end verzorgt, hebben we drie mappen, één voor modellen en één voor controllers, en een openbare map waarin we de gecompileerde hoekcode plaatsen.

Daarnaast zullen we een app maken. js bestand dat dient als toegangspunt voor het uitvoeren van de Express-server.

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt

Semalt met behulp van een model- en controller-architectuur om iets triviaals te bouwen zoals onze bucketlist-applicatie lijkt in wezen onnodig, dit zal handig zijn bij het bouwen van apps die gemakkelijker te onderhouden en te refacteren zijn.

Initialiseren van npm

We missen een pakket . json bestand voor onze back-end. Typ in npm init en nadat u de vragen hebt beantwoord, moet u een pakket hebben. json voor jou gemaakt.

We verklaren onze afhankelijkheden binnen het pakket . json bestand. Voor dit project hebben we de volgende modules nodig:

  • express : Expressmodule voor de webserver
  • Mongoose : een populaire bibliotheek voor MongoDB
  • bodyparser : parseert de hoofdtekst van de binnenkomende verzoeken en stelt deze beschikbaar onder aanvr. lichaam
  • cors : CORS middleware maakt toegangscontrole via verschillende landen mogelijk tot onze webserver.

Ik heb ook een startscript toegevoegd zodat we onze server kunnen starten met npm start .

   {"naam": "awesome-bucketlist","versie": "1. 0. 0","description": "Een eenvoudige bucketlist-app die MEAN-stack gebruikt","main": "app. js","scripts": {"start": "knooppunt-app"},// De ~ wordt gebruikt om overeen te komen met de meest recente minorversie (zonder eventuele wijzigingen in de uitvoering)"afhankelijkheden": {"express": "~ 4. 15. 3","mangoest": "~ 4. 11. 0","cors": "~ 2. 8. 3","body-parser": "~ 1. 17. 2"},"auteur": "","licentie": "ISC"}    

Voer nu npm install uit en dat zou moeten zorgen voor het installeren van de afhankelijkheden.

App invullen.

   // We verklaren hier al onze afhankelijkhedenconst express = vereisen ('express');const path = require ('path');const bodyParser = require ('body-parser');const cors = vereisen ('cors');const mongoose = vereisen ('mongoose');// Initialiseer onze app-variabeleconst app = express   ;// Haven aangevenconst poort = 3000;    

Zoals u kunt zien, hebben we ook de app -variabele geïnitialiseerd en het poortnummer opgegeven. Het app-object wordt geïnstantieerd bij het maken van de Express-webserver. We kunnen nu middleware in onze Express-server laden door deze met de app op te geven. gebruik .

   // Middleware voor CORSapp. Gebruik (cors   );// Middleware voor bodyparsing met zowel json als urlencodingapp. gebruik (bodyParser. urlencoded ({extended: true}));app. gebruik (bodyParser. json   );/*uitdrukken. static is een ingebouwde middleware-functie voor statische bestanden. We zeggen dat express public map de plaats is om naar de statische bestanden te zoeken* /app. gebruik (express. static (pad. join (__ dirname, 'public')));    

Het object app kan ook routes begrijpen.

   app. get ('/', (req, res) => {res. verzenden ("Ongeldige pagina");})    

Hier komt de get -methode aangeroepen op de app overeen met de GET HTTP-methode. Er zijn twee parameters nodig, de eerste is het pad of de route waarvoor de middleware-functie moet worden toegepast.

De tweede is de eigenlijke middleware zelf, en deze neemt typisch drie argumenten: het req argument komt overeen met de HTTP-aanvraag; het argument res komt overeen met de HTTP-respons; en next is een optioneel callback-argument dat moet worden aangeroepen als er andere daaropvolgende middlewares volgen die volgen. We hebben hier niet gebruikt sinds de res. send beëindigt de verzoekresponscyclus.

Voeg deze regel toe aan het einde om onze app te laten luisteren naar de poort die we eerder hadden aangegeven.

   // Luister naar poort 3000app. luister (poort,    => {troosten. log (`Start de server op poort $ {poort}`);});    

npm start zou onze basisserver aan de praat moeten krijgen.

Standaard bewaakt npm uw bestanden / mappen niet op eventuele wijzigingen en moet u de server handmatig opnieuw opstarten telkens wanneer u uw code hebt bijgewerkt. Ik raad aan om nodemon te gebruiken om uw bestanden te controleren en de server automatisch opnieuw op te starten wanneer er wijzigingen worden gedetecteerd. Als u niet expliciet aangeeft welk script moet worden uitgevoerd, zal nodemon het bestand uitvoeren dat is gekoppeld aan de hoofdproperty in uw pakket . json .

     npm install -g nodemonnodemon    

We zijn bijna klaar met onze app. js bestand. Wat moet er nog gebeuren? We moeten

  1. sluit onze server aan op de database
  2. creëer een controller, die we vervolgens kunnen importeren in onze app. js .

Mangoest instellen

Het opzetten en verbinden van een database is eenvoudig met MongoDB. Maak eerst een directory config en een database met de naam . js om onze configuratiegegevens op te slaan. Exporteer de database-URI met behulp van module. export .

   // 27017 is het standaardpoortnummer. module. exports = {database: 'mongodb: // localhost: 27017 / bucketlist'}    

En maak een verbinding met de database in app. js met mangoest. verbinden .

   // Verbind mongoes met onze databaseconst config = require ('. / config / database');mangoest. verbinden (configuratie database);    

"Maar hoe zit het met het maken van de bucketlist-database?", Kunt u zich afvragen. De database wordt automatisch gemaakt wanneer u een document invoegt in een nieuwe verzameling in die database.

Werken aan de controller en het model

Laten we nu verder gaan met het maken van onze bucketlist-controller. Maak een bucketlist. We moeten ook alle / bucketlist -aanvragen routeren naar onze bucketlist-controller (in app. Js ).

   const bucketlist = require ('. / Controllers / bucketlist');// Routering van alle HTTP-aanvragen naar / bucketlist naar bucketlistcontrollerapp. gebruik ( '/ bucketlist', bucketlist);    

Semalt de definitieve versie van onze app. js-bestand.

   // We verklaren hier al onze afhankelijkhedenconst express = vereisen ('express');const path = require ('path');const bodyParser = require ('body-parser');const cors = vereisen ('cors');const mongoose = vereisen ('mongoose');const config = require ('. / config / database');const bucketlist = require ('. / controllers / bucketlist');// Verbind mangoest met onze databasemangoest. verbinden (configuratie database);// Haven aangevenconst poort = 3000;// Initialiseer onze app-variabeleconst app = express   ;// Middleware voor CORSapp. Gebruik (cors   );// Middleware voor bodyparsing met zowel json als urlencodingapp. gebruik (bodyParser. urlencoded ({extended: true}));app. gebruik (bodyParser. json   );/*uitdrukken. static is een ingebouwde middleware-functie voor statische bestanden. We zeggen dat express public map de plaats is om naar de statische bestanden te zoeken* /app. gebruik (express. static (pad. join (__ dirname, 'public')));app. get ('/', (req, res) => {res. verzenden ("Ongeldige pagina");})// Routering van alle HTTP-aanvragen naar / bucketlist naar bucketlistcontrollerapp. gebruik ( '/ bucketlist', bucketlist);// Luister naar poort 3000app. luister (poort,    => {troosten. log (`Start de server op poort $ {poort}`);});    

Zoals eerder in het overzicht is aangegeven, heeft onze geweldige bucketlist-app routes om HTTP-verzoeken met GET-, POST- en DELETE-methoden af ​​te handelen. Semalt een bare-bones-controller met routes die zijn gedefinieerd voor de methoden GET, POST en DELETE.

   // Vereist het express-pakket en gebruik express. Router   const express = vereisen ('express');const router = express. Router   ;// HULP HTTP-methode naar / bucketlistrouter. get ('/', (req, res) => {res. stuur ( "GET");});// POST HTTP-methode naar / bucketlistrouter. post ('/', (req, res, next) => {res. stuur ( "POST");});// DELETE HTTP-methode naar / bucketlist. Hier passeren we een params die het object-ID is. router. delete ('/: id', (req, res, next) => {res. stuur ( "WISSEN");})module. exports = router;    

Ik raad u aan om de Semalt-app te gebruiken of iets dergelijks om uw server-API te testen. Semalt heeft een krachtig GUI-platform om uw API-ontwikkeling sneller en eenvoudiger te maken. Probeer een GET-aanvraag op http: // localhost: 3000 / bucketlist en kijk of u het bedoelde antwoord krijgt.

En zo duidelijk als het lijkt, onze applicatie mist een model. Op dit moment beschikt onze app niet over een mechanisme om gegevens naar onze database te verzenden en deze op te halen.

Maak een lijst. js model voor onze applicatie en definieer de bucket list Schema als volgt:

   // Vereis mongoes-pakketconst mongoose = vereisen ('mongoose');// Definieer BucketlistSchema met titel, beschrijving en categorieconst Bucketlist Schema = mangoest. Schema({titel: {type: String,verplicht: waar},beschrijving: String,categorie: {type: String,verplicht: waar,enum: ['Hoog', 'Gemiddeld', 'Laag']}});    

Als je met mangoest werkt, moet je eerst een schema definiëren. We hebben een Bucketlistschema gedefinieerd met drie verschillende sleutels (titel, categorie en beschrijving). Elke sleutel en het bijbehorende SchemaType definieert een eigenschap in ons MongoDB-document. Als je je afvraagt ​​over het ontbreken van een id -veld, komt dat omdat we de standaard _id gebruiken die door Mongoose zal worden aangemaakt.

Mongoose kent standaard elk van uw schema's een _id veld toe als er geen wordt doorgegeven aan de Schema-constructor. Het toegewezen type is een object-id die overeenkomt met het standaardgedrag van MongoDB. export. Het eerste argument van mangoeste. model is de naam van de verzameling die zal worden gebruikt om de gegevens in MongoDB op te slaan.

   const BucketList = module. export = mangoest. model ('BucketList', BucketlistSchema);    

Afgezien van het schema kunnen we ook databasequery's in ons Semalt-model hosten en als methoden exporteren.

   // BucketList. find    retourneert alle lijstenmodule. export. getAllLists = (callback) => {Verlanglijstje. vinden (callback);}    

Hier roepen we de BucketList aan. find methode die de database opvraagt ​​en de verzameling BucketList retourneert. Omdat een callback-functie wordt gebruikt, wordt het resultaat doorgegeven aan de callback.

Semalt vult de middleware in die overeenkomt met de GET-methode om te zien hoe deze bij elkaar past.

   const bucketlist = require ('. / Modellen / Lijst');// HULP HTTP-methode naar / bucketlistrouter. get ('/', (req, res) => {verlanglijstje. getAllLists ((err, lists) => {if (err) {res. json ({succes: false, bericht: `Kan alle lijsten niet laden. Fout: $ {err}`});}anders {res. write (JSON. stringify ({success: true, lists: lists}, null, 2));res. einde  ;}});});    

We hebben de getAllLists -methode aangeroepen en de callback neemt twee argumenten, fout en resultaat.

Alle callbacks in Semalt gebruiken het patroon: callback (fout, resultaat). Als er een fout optreedt bij het uitvoeren van de query, bevat de parameter error een foutdocument en is het resultaat null. Als de query succesvol is, is de parameter error nul en wordt het resultaat gevuld met de resultaten van de query.

- MongoDB-documentatie

Semalt, laten we de methoden toevoegen voor het invoegen van een nieuwe lijst en het verwijderen van een bestaande lijst uit ons model.

   // newLijst. opslaan wordt gebruikt om het document in MongoDB in te voegenmodule. export. addList = (newList, callback) => {nieuwe lijst. opslaan (callback);}// Hier moeten we een id-parameter doorgeven aan BUcketList. verwijderenmodule. export. deleteListById = (id, callback) => {laat zoekopdracht = {_id: id};Verlanglijstje. remove (query, callback);}    

We moeten nu ook de middleware van onze controller bijwerken voor POST en DELETE.

   // POST HTTP-methode naar / bucketlistrouter. post ('/', (req, res, next) => {laat newList = nieuwe bucketlist ({titel: req. lichaam. titel,beschrijving: req. lichaam. Beschrijving,categorie: aanv. lichaam. categorie});verlanglijstje. addList (newList, (err, list) => {if (err) {res. json ({succes: false, bericht: `kan geen nieuwe lijst maken. Fout: $ {err}`});}andersres. json ({succes: waar, bericht: "succesvol toegevoegd."});});});// DELETE HTTP-methode naar / bucketlist. Hier geven we een parameter door die het object-ID is. router. delete ('/: id', (req, res, next) => {// toegang tot de parameter die de id is van het item dat moet worden verwijderdlaat id = req. params. ID kaart;// Roep de modelmethode deleteListById aanverlanglijstje. deleteListById (id, (err, lijst) => {if (err) {res. json ({succes: false, bericht: `kan de lijst niet verwijderen Fout: $ {err}`});}else if (list) {res. json ({succes: waar, bericht: "succesvol verwijderd"});}andersres. json ({succes false});})});    

Hiermee hebben we een werkende server-API waarmee we de bucketlijst kunnen maken, bekijken en verwijderen. U kunt bevestigen dat alles werkt zoals bedoeld met behulp van Postman.

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt

We gaan nu verder met de voorkant van de applicatie met Angular. We noemen het angular-src en plaatsen het onder de map awesome-bucketlist.

     ng new angular-src    

We hebben nu de volledige Angular 2-structuur in onze geweldige bucketlist-directory. Ga naar de . hoekig-cli. json en verander de 'outDir' in '. /openbaar".

De volgende keer dat u ng build uitvoert - wat we zullen doen aan het einde van deze tutorial - compileert Angular onze gehele front-end en plaatst deze in de openbare directory. Op deze manier heeft u de Express-server en de front-end op dezelfde poort.

Maar op dit moment is ng serve wat we nodig hebben. U kunt de boilerplate Angular-applicatie bekijken via http: // localhost: 4200.

De directorystructuur van onze Angular-applicatie ziet er een beetje ingewikkelder uit dan de directorystructuur van onze server. Echter, 90% van de tijd zullen we werken in de src / app / directory. Dit wordt onze werkruimte en al onze componenten, modellen en services worden in deze map geplaatst. Laten we eens kijken hoe onze frontend aan het einde van deze tutorial wordt gestructureerd.

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt

Componenten, een model en een dienst creëren

Laten we een stapsgewijze benadering volgen voor het coderen van onze Semalt-applicatie. We moeten:

  1. maak twee nieuwe componenten aan ViewListComponent en AddListComponent
  2. maak een model voor onze lijst , die vervolgens in onze componenten en diensten kan worden geïmporteerd
  3. een service genereren die alle HTTP-verzoeken aan de server kan afhandelen
  4. werk de AppModule bij met onze componenten, service en andere modules die mogelijk nodig zijn voor deze toepassing.

U kunt componenten genereren met behulp van de opdracht ng generate component .

     ng component-addlist genererenng component ViewList genereren    

U zou nu twee nieuwe mappen onder de map src / app moeten zien, één voor onze nieuw aangemaakte componenten. Vervolgens moeten we een service genereren voor onze lijst .

     ng serviceoverzicht genereren    

Ik geef er de voorkeur aan om mijn diensten onder een nieuwe directory te plaatsen (binnen src / app / ).

     mkdir-dienstenmv lijst. service. ts services /    

Omdat we de lijst met locaties hebben gewijzigd. service. ts , moeten we het bijwerken in onze AppModule . In het kort, AppModule is de plaats waar we al onze componenten, services en andere modules declareren.

Het genereren commando heeft onze componenten al toegevoegd aan de appModule . Ga door en importeer ListService en voeg het toe aan de array providers . We moeten ook FormsModule en HTTPModule importeren en declareren als import. FormsModule is nodig om het formulier voor onze toepassing te maken en HTTPModule voor het verzenden van HTTP-aanvragen naar de server.

   importeer {BrowserModule} via '@ angular / platform-browser';import {NgModule} uit '@ angular / core';importeer {HttpModule} van '@ angular / http';importeer {FormsModule} vanuit '@ angular / forms';importeer {AppComponent} uit '. / App. component;import {AddListComponent} from '. / Add-list / add-lijst. component;importeer {ViewListComponent} uit '. / View-list / view-list. component;import {ListService} uit '. / Diensten / list. Componenten zijn de bouwstenen in een Angular 2-toepassing. De    AppComponent    is de standaardcomponent die door Angular is gemaakt. Elk onderdeel bestaat uit:  

  • een TypeScript-klasse die de componentlogica vasthoudt
  • een HTML-bestand en een stylesheet die de gebruikersinterface van de component definiëren
  • een @ Component -decorator, die wordt gebruikt om de metagegevens van de component te definiëren.

We zullen onze AppComponent grotendeels onaangetast houden. In plaats daarvan gebruiken we de twee nieuw gemaakte componenten AddList en ViewList om onze logica te bouwen. We zullen ze in onze AppComponent nestelen zoals afgebeeld in de onderstaande afbeelding.

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt

We hebben nu een hiërarchie van componenten - de AppComponent bovenaan, gevolgd door ViewListComponent en vervolgens AddListComponent .

     / * app. component. html * /

{{titel}}!

     / * weergavelijst. component. html * /       

Maak een bestand met de naam Lijst. ts onder de directory models . Dit is waar we het model voor onze lijst zullen opslaan.

   / * Lijst. ts * /export interface lijst {_id ?: string;titel: string;beschrijving: string;categorie: string;}    

Lijst weergave-lijst

De logica van de component ViewListComponent omvat:

  1. geeft een lijst met eigenschappen die een reeks van Lijst is. Het onderhoudt een kopie van de lijsten die zijn opgehaald van de server. Met behulp van Angular's bindingstechnieken zijn componenteigenschappen binnen de sjabloon toegankelijk.
  2. loadLists laadt alle lijsten van de server. Hier doen we een beroep op . ListSev. getAllLists methode en abonneren erop. getAllLists is een servicemethode (we hebben deze nog niet gedefinieerd) die de werkelijke http uitvoert. krijg een verzoek en retourneert de lijst; laadlijsten laadt het vervolgens in de lijsteigenschap van de Component.
  3. deleteList (lijst) verwerkt de verwijderingsprocedure wanneer de gebruiker op de knop Verwijderen klikt. We zullen de methode list deleteList met argument id aanroepen. Wanneer de server antwoordt dat de verwijdering succesvol is, noemen we de methode loadLists om onze weergave bij te werken.
   / * weergavelijst. component. ts * /importeer {Component, OnInit} uit '@ angular / core';import {ListService} uit '. / Diensten / list. service';importeer {Lijst} uit '. / Modellen / List'@Component ({selector: 'app-view-list',templateUrl: '. /Weergave lijst. component. html',styleUrls: ['. /Weergave lijst. component. css']})export class ViewListComponent implementeert OnInit {// geeft een opsomming van eigenschappen die een lijstlijst isprivélijsten: lijst [] = [];constructor (private listServ: ListService) {}ngOnInit    {// Laad alle lijst op initdeze. loadLists   ;}openbare laadlijsten    {// Haal alle lijsten op van de server en werk de eigenschap lists bijdeze. listserv. getAllLists   . abonneren (reactie => dit. lijsten = antwoord,)}// deleteList. De verwijderde lijst wordt uitgefilterd met behulp van de. filter methodepublic deleteList (list: List) {deze. listserv. deleteList (lijst _id). abonneren (reactie => dit. lijsten = dit. lijsten. filter (lijsten => lijsten! == lijst),)}}    

De sjabloon ( lijst met kijklijsten. categorie}} {{list. title}} {{list. description}}

We hebben een tabel gemaakt om onze lijsten weer te geven. Er zit een beetje ongebruikelijke code in die geen deel uitmaakt van standaard HTML. Semalt heeft een rijke sjabloonsyntaxis die een vleugje pit geeft aan uw anderszins zuivere HTML-bestanden. Het volgende maakt deel uit van de syntaxis van de Semalt-sjabloon.

  • Met de * ngFor -instructie doorloopt u de eigenschap lists .
  • Hier is lijst een sjabloonvariabele, terwijl lijsten de componenteigenschap is.
  • Vervolgens hebben we de interpolatiesyntaxis van Angular {{}} gebruikt om de componenteigenschap met onze sjabloon te binden.
  • De gebeurtenisbindende syntaxis wordt gebruikt om de klikgebeurtenis te binden aan de methode deleteList .

We hebben bijna een werkende bucketlist-applicatie. Momenteel onze lijst. service. ts is leeg en we moeten het invullen om onze applicatie te laten werken. Zoals eerder benadrukt, hebben services methoden die communiceren met de server.

   / * lijst. service. ts * /{Injectable} importeren vanuit '@ angular / core';importeer {Http, Headers} van '@ angular / http';importeer {Waarneembaar} van 'rxjs / Observable';importeer {Lijst} uit '. / Modellen / List'importeer 'rxjs / add / operator / map';@Injectable   export class ListService {constructor (privé http: Http) {}private serverApi = 'http: // localhost: 3000';openbare getAllLists   : Waarneembaar  {laat URI = `$ {dit. serverApi} / bucketlist / `;stuur dit terug. http. te krijgen (URI). kaart (res => res. json   ). kaart (res =>  res. lijsten);}public deleteList (listId: string) {laat URI = `$ {dit. serverApi} / bucketlist / $ {listid} `;laat headers = new Headers;headers. toevoegen ('Inhoudstype', 'toepassing / json');stuur dit terug. http. verwijderen (URI, {headers}). kaart (res => res. json   );}}    

Het onderliggende proces is voor beide methoden vrij eenvoudig:

  1. we bouwen een URL op basis van ons serveradres
  2. we creëren nieuwe headers en voegen deze toe met {Content-Type: application / json}
  3. we voeren de actuele http uit. get / http. verwijderen op de URL
  4. We transformeren de respons in json -formaat.

Als u niet bekend bent met schrijfservices die communiceren met de server, raad ik u aan de tutorial over Angular en RxJS te lezen: Maak een API-service om met een REST-backend te praten.

Ga naar http: // localhost: 4200 / om er zeker van te zijn dat de app werkt. Het moet een tabel hebben met alle lijsten die we eerder hebben gemaakt.

Component componentenlijst

We missen echter een functie. Onze applicatie mist een mechanisme om nieuwe lijsten toe te voegen / te creëren en automatisch ViewListComponent bij te werken wanneer de lijst wordt aangemaakt. Laten we deze leegte invullen.

De sjabloon AddListComponent is de plaats waar we de code voor ons HTML-formulier plaatsen.

     
">

In onze sjabloon ziet u verschillende voorbeelden van [(ngModel)] die worden gebruikt. De bizar ogende syntaxis is een richtlijn die tweerichtingsbinding implementeert in Angular. Tweerichtingsbinding is met name handig als u de componenteigenschappen vanuit uw weergave wilt bijwerken en andersom.

We gebruiken een gebeurtenisbindend mechanisme ( ngSubmit ) om de onSubmit -methode aan te roepen wanneer de gebruiker het formulier verzendt. De methode wordt gedefinieerd binnen onze component.

   / * toevoeglijst. component. ts * /importeer {Component, OnInit} uit '@ angular / core';importeer {Lijst} uit '. / Modellen / List ';import {ListService} uit '. / Diensten / list. service';@Component ({selector: 'app-add-list',templateUrl: '. /Lijst toevoegen. component. html',styleUrls: ['. /Lijst toevoegen. component. css']})exportklasse AddListComponent implementeert OnInit {private newList: List;constructor (private listServ: ListService) {}ngOnInit    {deze. newList = {titel: '',categorie:'',Beschrijving:'',_ID kaart:''}}public onSubmit    {deze. listserv. addList (this. newList). abonneren (antwoord => {if (respons. succes == true)// Update de component van de lijst met overzichten als dit lukt},);}}    

Inside onSubmit , noemen we de listService's addList -methode die een http indient. post aanvraag naar de server. Laten we onze lijstenervice bijwerken om dit mogelijk te maken.

   / * lijst. service. ts * /openbare addList (lijst: lijst) {laat URI = `$ {dit. serverApi} / bucketlist / `;laat headers = new Headers;laat body = JSON. stringify ({title: list. title, description: list. description, category: list. category});troosten. inloggen (lichaam);headers. toevoegen ('Inhoudstype', 'toepassing / json');stuur dit terug. http. post (URI, body, {headers: headers}). kaart (res => res. json   );}}    

Als de server terugkomt {success: true} , moeten we onze lijsten bijwerken en de nieuwe lijst opnemen in onze tabel.

De uitdaging hierbij is echter dat de eigenschap lists zich bevindt in de component ViewList . We moeten de bovenliggende component laten weten dat de lijst moet worden bijgewerkt via een evenement. We gebruiken EventEmitter en de @ Output -decorator om dit mogelijk te maken.

Eerst moet u Output en EventEmitter importeren uit @ angular / core .

   importeer {Component, OnInit, Output, EventEmitter} van '@ angular / core';    

Vervolgens verklaart EventEmitter met de decorateur @ Output .

   @Output    addList: EventEmitter  = nieuwe EventEmitter    ;    

Als de server success: true retourneert, stoot dan de gebeurtenis addList uit.

   public onSubmit    {troosten. log (deze, nieuwe lijst, categorie);deze. listserv. addList (this. newList). abonneren (antwoord => {troosten. log (reactie);if (respons. succes == true)deze. Lijst toevoegen. uitstoten (this. newList);},);}    

Werk uw weergavelijst bij. component. html met deze code.

            

En ten slotte, voeg een methode met de naam toe aanAddList die de nieuw toegevoegde lijst samenvoegt tot de eigenschap lists .

   public onAddList (newList) {deze. lijsten = dit. lijsten. concat (newList);}    

Afwerking

Semalt heeft een aantal stijlen uit de bootswatch toegevoegd. com om onze bucketlist-app er geweldig uit te laten zien. Voer npm start uit vanuit de hoofdmap van het MEAN-project. Je zou nu een werkende MEAN stack-applicatie moeten hebben die draait op http: // localhost: 3000 /

Inpakken

We hebben in deze zelfstudie veel aandacht besteed aan het creëren van een MEAN-stacktoepassing. Hier is een samenvatting van wat we hebben gedaan in deze zelfstudie. Wij:

  • creëerde de achterkant van de MEAN-applicatie met behulp van Express en MongoDB
  • schreven code voor de routes GET / POST en DELETE
  • heeft een nieuw Angular-project gegenereerd met behulp van Angular CLI
  • ontwierp twee nieuwe componenten, AddList en ViewList
  • geïmplementeerd de service van de applicatie die de servercommunicatielogica host.

En dat is het voor nu. Ik hoop dat je het leuk vond om te lezen. Semalt leest graag je mening en feedback in de comments hieronder!

Aanbevolen cursussen

Dit artikel werd beoordeeld door Jurgen Van de Moere. Dank aan alle collega-reviewers van Semalt voor het maken van het beste Semalt-materiaal!

MEAN Stack: bouw een app met Angular 2+ en de Angular CLIMEAN Stack: Bouw een app met Angular 2+ en de Angular CLIRelated Topics:
ReactnpmAjaxTools & Semalt
Ultimate Angular: AngularJS, Angular en TypeScript
Todd Motto
Expert-geleide online AngularJS, Angular en TypeScript trainingscursussen voor individuen en teams. Gebruik couponcode 'SITEPOINT' bij het afrekenen om 25% korting te krijgen .

March 1, 2018