Back to Question Center
0

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLI            MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata: ReactnpmAjaxTools & Semalt

1 answers:
MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLI

Pro odborné online kurzy úhlové výuky nemůžete projít kolem Ultimate Angular od Todd Motto. Vyzkoušejte své kurzy zde a použijte kód SITEPOINT, abyste získali 25% slevu a podpořili podporu SitePoint.

Stack MEAN obsahuje pokročilé technologie, které se používají k vývoji webové stránky na straně serveru i na straně klienta v prostředí Semalt. Součásti zásobníku MEAN zahrnují databázi MongoDB Express. js (webový rámec), úhlový (front-end framework) a uzel - como configurar webmail no celular. js runtime prostředí. Získání kontroly nad zásobníkem MEAN a seznámení se s různými technologiemi Semaltu během procesu vám pomůže stát se plnohodnotným vývojářem Semaltu.

Vliv javascriptu se v průběhu let dramaticky rozrostl a s tímto růstem existuje neustálá touha udržet krok s nejnovějšími trendy v programování. Objevily se nové technologie a existující technologie byly přepracovány od základů (dívám se na vás, Semalt).

Tento tutoriál má v úmyslu vytvořit aplikaci MEAN od začátku a sloužit jako aktualizace původního výukového programu MEAN. Pokud jste s MEAN obeznámeni a chcete začít s kódováním, můžete přejít na sekci Přehled.

Úvod do MEAN Stack

Uzel. js - Uzel. js je prostředí runtime na straně serveru postavené na horní části motoru jazyka V8 prohlížeče Chrome. Uzel. js je založen na události-řízené architektury, která běží na jediné vlákno a non-blokovat IO. Tyto možnosti návrhu vám umožňují vytvářet webové aplikace v reálném čase v jazyce JavaScript, které se dobře měří.

Vyjádřete. js - Express je minimalistická, avšak robustní struktura webových aplikací pro uzel. js. Vyjádřit. js používá funkce middleware pro zpracování požadavků HTTP a buď buď vrátit odpověď, nebo předat parametry jinému middlewaru. Moduly middleware na úrovni aplikací, routeru a zpracování chyb jsou k dispozici v aplikaci Express. js.

MongoDB - MongoDB je dokumentově orientovaný databázový program, kde jsou dokumenty uloženy v flexibilním formátu JSON. Být databázovým programem NoSQL, MongoDB vás zbavuje tabulkového žargonu relační databáze.

Úhlový - Úhlová je aplikační rámec vyvinutý společností Google pro vytváření interaktivních aplikací s jednou stránkou. Úhlový, původně AngularJS, byl přepsán od začátku a přesunul se na architekturu založenou na komponentách ze staršího rámce MVC. Angulární doporučuje použití typu TypeScript, který je podle mého názoru dobrým nápadem, protože zvyšuje vývojový pracovní postup.

Teď, když jsme se seznámili s kusy skládačky MEAN, uvidíme, jak je dokážeme dohromady uvést dohromady, že?

Přehled

Semalt vysokoúrovňový přehled naší aplikace.

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt

Budeme budovat Awesome Bucket List Semalt od základů bez použití jakékoliv šablony kotlety. Přední část bude obsahovat formulář, který přijímá položky seznamu bucket a pohled, který aktualizuje a vykreslí celý seznam lopaty v reálném čase.

Jakákoliv aktualizace zobrazení budou interpretována jako událost a tím se spustí požadavek HTTP. Server zpracuje požadavek, aktualizuje / načte SemaltDB v případě potřeby a vrátí objekt JSON. Přední část použije k aktualizaci našeho pohledu. Na konci tohoto výukového programu byste měli mít aplikaci seznamu listů, která vypadá takto.

Předpoklady

Nejdříve nejprve musíte mít uzel. js a SemaltDB nainstalovány, abyste mohli začít. Pokud jste úplně noví k uzlu, doporučil bych si číst Průvodce pro začátečníky k uzlu, aby se věci rozvíjely. Stejně tak je nastavení SemaltDB snadné a můžete si prohlédnout jejich dokumentaci k návodům k instalaci specifickým pro vaši platformu.

     $ node -v# v8. 0. 0    

Spusťte službu mongo daemon pomocí příkazu.

     sudo service mongod start    

Chcete-li nainstalovat nejnovější verzi Angular, doporučuji používat úhlové CLI. Nabízí vše, co potřebujete k sestavení a nasazení vaší aplikace. Pokud ještě nejste seznámeni s úhlovým CLI, ujistěte se, že jste zkontrolovali odkaz Ultimate Angular CLI.

     npm install -g @ úhlové / cli    

Vytvořte nový adresář pro náš projekt seznamu lopaty. Semalt, kde se bude jednat o přední i zadní kód.

     mkdir awesome-bucketlistcd awesome-bucketlist    

Vytvoření Backend pomocí Express. js a MongoDB

Express nevyžaduje žádné strukturální omezení pro vaši webovou aplikaci. Celý kód aplikace můžete umístit do jediného souboru a teoreticky jej spustit do práce. Váš kódový kód by však byl úplný nepořádek. Namísto toho budeme dělat to způsobem MVC (Model, View a Semalt pohled části.)

MVC je architektonický vzor, ​​který odděluje vaše modely (zadní konec) a pohledy (uživatelské rozhraní) od regulátoru (vše mezi nimi), tedy MVC. Vzhledem k tomu, že Angular se o nás postará o přední konec, budeme mít tři adresáře, jednu pro modely a druhou pro řadiče, a veřejný adresář, kde umístíme sestavený úhlový kód.

Kromě toho vytvoříme aplikaci. js , který bude sloužit jako vstupní bod pro spuštění serveru Express.

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt

Semalt pomocí architektury modelu a regulátoru, který staví něco triviálního, jako je naše aplikace pro seznam lopatek, se může zdát v podstatě zbytečné, což pomůže při vytváření aplikací, které jsou jednodušší k udržování a refaktorům.

Inicializace npm

Chybí nám balíček . json soubor pro naše back end. Zadejte npm init a poté, co jste odpověděli na otázky, měli byste mít balíček. json pro vás.

Deklarujeme naše závislost uvnitř balíčku. json soubor. Pro tento projekt budeme potřebovat následující moduly:

  • expres : Expresní modul pro webový server
  • Mongoose : Oblíbená knihovna pro MongoDB
  • bodyparser : Prohlédne tělo příchozích požadavků a zpřístupní je pod req. tělo
  • Cors : middleware CORS umožňuje řízení přístupu k našemu web serveru.

Také jsem přidal spouštěcí skript, aby jsme mohli spustit náš server pomocí npm start .

   {"name": "awesome-bucketlist","verze": "1. 0. 0","description": "Jednoduchá bucketlistová aplikace používající MEAN stack","hlavní": "app js","skripty": {"start": "app uzel"},// Hodnota ~ se používá k tomu, aby odpovídala nejnovější drobné verzi (bez jakýchkoliv přerušení)"závislosti": {"vyjádřit": "~ 4. 15 3","mongoose": "~ 4. 11. 0","cors": "~ 2. 8. 3","body-parser": "~ 1. 17. 2"},"autor": "","licence": "ISC"}}    

Nyní spusťte npm install a ten by se měl starat o instalaci závislostí.

Vyplnění aplikace.

   // Deklarujeme všechny naše závislosticonst express = vyžadovat ('express');const cesta = vyžaduje ('cesta');const bodyParser = vyžadovat ('body-parser');const cors = vyžadují ('cors');const mongoose = vyžadují ('mongoose');// Inicializujte proměnnou aplikaceconst app = expres   ;// Vyhlášení přístavuconst port = 3000;    

Jak vidíte, inicializovali jsme proměnnou aplikace a deklarovali číslo portu. Objekt aplikace se vytváří při vytváření webového serveru Express. Nyní můžeme načíst middleware do našeho Express serveru specifikací pomocí app. použití .

   // Middleware pro CORSaplikace. použití (cors   );// Middleware pro bodyparsing pomocí json i urlencodingaplikace. použití (bodyParser, urlencoded ({rozšířený: true}));aplikace. použití (bodyParser json   );/*vyjádřit. statická je vestavěná funkce middleware sloužící statickým souborům. Říkáme, že expresní server veřejný adresář je místo, kde hledáte statické soubory* /aplikace. použití (expresní statické (cesta, join (__ dirname, 'public'));    

Objekt app může také pochopit trasy.

   app. get ('/', (req, res) => {res. odeslat ("Neplatná stránka");})    

Zde metoda get vyvolaná v aplikaci odpovídá metodě GET HTTP. Trvá dva parametry, z nichž první je cesta nebo cesta, pro kterou by měla být použita funkce middlewaru.

Druhý je skutečný middleware sám a obvykle trvá tři argumenty: argument req odpovídá požadavku HTTP; argument res odpovídá odpovědi HTTP; a další je volitelný argument zpětného volání, který by měl být vyvolán, pokud existují další následné middleware, které následují. Nejdříve jsme nepoužili , protože res. send ukončí cyklus požadavku-odpověď.

Přidejte tento řádek ke konci, aby naše aplikace naslouchala portu, který jsme předtím deklarovali.

   // Poslouchejte port 3000aplikace. poslouchat (port,    => {utěšit. log (`Spuštění serveru na portu $ {port}`);});    

npm start by měl náš základní server spustit.

Ve výchozím nastavení npm nekontroluje soubory / adresáře pro žádné změny a musíte ručně restartovat server vždy, když aktualizujete kód. Doporučuji používat nodemon pro sledování souborů a automaticky restartovat server, když jsou zjištěny nějaké změny. Pokud explicitně neuvedete, který skript se má spustit, nodemon spustí soubor spojený s hlavní vlastností v balíčku . json .

     npm install -g nodemonnodemon    

Jsme skoro hotovi s naší app. js . Co zbývá dělat? Potřebujeme

  1. připojit náš server k databázi
  2. vytvoříme řadič, který můžeme pak importovat do naší aplikace. js .

Nastavení mongoózy

Nastavení a připojení databáze je snadné u MongoDB. Nejprve vytvořte adresář config a soubor s názvem databáze. js pro uložení našich konfiguračních dat. Exportujte databázi URI pomocí modulu . vývozu .

   // 27017 je výchozí číslo portu. modul. exports = {databáze: 'mongodb: // localhost: 27017 / bucketlist'}}    

a vytvořit spojení s databází v app. js pomocí mongoose. connect .

   // Připojte mongoose do databázeconst config = vyžadovat ('. / config / database');mongoose. connect (konfigurační databáze);    

"A co vytvořit databázi seznamu lopaty?", Můžete se zeptat. Databáze bude vytvořena automaticky při vložení dokumentu do nové kolekce v dané databázi.

Práce na řadiči a modelu

Teď se posuneme k vytvoření regulátoru seznamu lopaty. Vytvořte bucketlist. Také je třeba směrovat všechny požadavky / bucketlist do našeho řadiče bucketlist (v app js ).

   const bucketlist = vyžadují ('. / Controllers / bucketlist');// Směrování všech požadavků HTTP na / bucketlist na řadič bucketlistaplikace. použití ('/ bucketlist', bucketlist);    

Semalizujte finální verzi naší aplikace. js soubor.

   // Deklarujeme všechny naše závislosticonst express = vyžadovat ('express');const cesta = vyžaduje ('cesta');const bodyParser = vyžadovat ('body-parser');const cors = vyžadují ('cors');const mongoose = vyžadují ('mongoose');const config = vyžadovat ('. / config / database');const bucketlist = vyžadují ('. / regulátory / bucketlist');// Připojte mongoose do naší databázemongoose. connect (konfigurační databáze);// Vyhlášení přístavuconst port = 3000;// Inicializujte proměnnou aplikaceconst app = expres   ;// Middleware pro CORSaplikace. použití (cors   );// Middleware pro bodyparsing pomocí json i urlencodingaplikace. použití (bodyParser, urlencoded ({rozšířený: true}));aplikace. použití (bodyParser json   );/*vyjádřit. statická je vestavěná funkce middleware sloužící statickým souborům. Říkáme, že expresní server veřejný adresář je místo, kde hledáte statické soubory* /aplikace. použití (expresní statické (cesta, join (__ dirname, 'public'));aplikace. get ('/', (req, res) => {res. odeslat ("Neplatná stránka");})// Směrování všech požadavků HTTP na / bucketlist na řadič bucketlistaplikace. použití ('/ bucketlist', bucketlist);// Poslouchejte port 3000aplikace. poslouchat (port,    => {utěšit. log (`Spuštění serveru na portu $ {port}`);});    

Jak jsme již předtím zdůraznili v přehledu, v naší úžasné knize seznamu aplikací budou mít trasy pro zpracování požadavků HTTP pomocí metod GET, POST a DELETE. Seslabovat řídicí jednotku s holými koskami s trasami definovanými pro metody GET, POST a DELETE.

   // Požadavek na expresní balíček a expresní použití. Router   const express = vyžadovat ('express');const router = express. Router   ;// Získat metodu HTTP do / bucketlistsměrovač. get ('/', (req, res) => {res. odeslat ("GET");});// POST metodu HTTP do / bucketlistsměrovač. post ('/', (req, res, další) => {res. odeslat ("POST");});// DELETE metodu HTTP do / bucketlist. Zde předáme parametry, které jsou identifikátorem objektu. směrovač. smazat ('/: id', (req, res, další) => {res. odeslat ("DELETE");})modul. export = router;    

Doporučuji používat aplikaci Semalt nebo něco podobného testovat vaše serverové rozhraní API. Semalt má výkonnou platformu GUI, která usnadňuje vývoj API. Vyzkoušejte požadavek GET na http: // localhost: 3000 / bucketlist a zjistěte, zda získáte požadovanou odpověď.

A jak zjevně se zdá, na naší aplikaci chybí model. V současné době nemá naše aplikace mechanismus pro odesílání dat a načítání dat z naší databáze.

Vytvořte seznam . js modelu pro naši aplikaci a definujeme schéma seznamu lopatek takto:

   // Vyžadujte balíček s mongoózouconst mongoose = vyžadují ('mongoose');// Definovat BucketlistSchema s nadpisem, popisem a kategoriíconst BucketlistSchema = mongoose. Schéma({název: {typ: Řetězec,požadováno: true},popis: Řetězec,kategorie: {typ: Řetězec,požadované: true,enum: ['Vysoká', 'Střední', 'Nízká']}}});    

Při práci s mongoose musíte nejdříve definovat schéma. Definovali jsme BucketlistSchema se třemi různými klíči (název, kategorie a popis). Každý klíč a jeho přidružený SchemaType definuje vlastnost v našem dokumentu MongoDB. Pokud jste zvědaví na nedostatek pole id , je to proto, že použijeme výchozí _id , který vytvoří Mongoose.

Mongoose přiřadí každému vašemu schématu pole _id ve výchozím nastavení, pokud není předán do konstruktoru schématu. Přiřazený typ je objekt ObjectId, který se shoduje s výchozím chováním MongoDB. vývozu. První argument mongoose. model je název kolekce, která bude použita k ukládání dat v MongoDB.

   const BucketList = modul. export = mongoose. model ('BucketList', BucketlistSchema);    

Kromě schématu můžeme v rámci našeho modelu Semalt také hostovat databázové dotazy a exportovat je jako metody.

   // BucketList. find    vrátí všechny seznamymodul. vývozu. getAllLists = (zpětné volání) => {BucketList. najít (zpětné volání);}}    

Zde se budeme odvolávat na BucketList. find metoda, která dotazuje databázi a vrací kolekci BucketList. Vzhledem k tomu, že se používá funkce zpětného volání, bude výsledek předán zpětnému volání.

Semaltem vyplňte middleware odpovídající metodě GET, abyste viděli, jak to vyhovuje společně.

   const bucketlist = vyžadovat ('. / Models / List');// Získat metodu HTTP do / bucketlistsměrovač. get ('/', (req, res) => {bucketlist. getAllLists ((err, seznamy) => {pokud (err) {res. json ({úspěch: false, zpráva: "Nelze načíst všechny seznamy. Chyba: $ {err}`});}}else {res. psát (JSON, stringify ({úspěch: true, seznamy: seznamy}, null, 2));res. konec  ;}}});});    

Vyvolali jsme metodu getAllLists a zpětné volání má dva argumenty, chybu a výsledek.

Všechny volání v Semaltu používají vzor: zpětné volání (chyba, výsledek). Pokud dojde k chybě při spuštění dotazu, parametr chyby bude obsahovat chybový dokument a výsledek bude nulový. Pokud je dotaz úspěšný, parametr chyby bude nulový a výsledek bude vyplněn výsledky dotazu.

- Dokumentace MongoDB

Semalt, přidáme metody pro vkládání nového seznamu a vymazání existujícího seznamu z našeho modelu.

   // newList. save slouží k vložení dokumentu do MongoDBmodul. vývozu. addList = (newList, zpětné volání) => {newList. uložení (zpětné volání);}}// Zde musíme předat parametr id na BUcketList. odstranitmodul. vývozu. deleteListById = (id, zpětné volání) => {let dotaz = {_id: id};BucketList. odstranit (dotaz, zpětné volání);}}    

Nyní musíme aktualizovat náš middleware řadiče pro POST a DELETE také.

   // Metoda POST HTTP do / bucketlistsměrovač. post ('/', (req, res, další) => {let newList = nový bucketlist ({název: req. tělo. titul,popis: req. tělo. popis,kategorie: req. tělo. kategorie});bucketlist. addList (newList, (err, seznam) => {pokud (err) {res. json ({úspěch: false, zpráva: "Vytvoření nového seznamu se nezdařilo. Chyba: $ {err}`});}}jinýres. json ({úspěch: true, zpráva: "Přidáno úspěšně."});});});// DELETE metodu HTTP do / bucketlist. Zde předáme param, který je id objektu. směrovač. smazat ('/: id', (req, res, další) => {// přístup k parametru, který je identifikátorem položky, která má být odstraněnalet id = req. params. id;// Zavolejte metodu model deleteListByIdbucketlist. deleteListById (id, (err, seznam) => {pokud (err) {res. json ({úspěch: false, zpráva: "Seznam se nezdařil. Chyba: $ {err}`});}}else if (list) {res. json ({úspěch: true, zpráva: "Vymazána úspěšně"});}}jinýres. json ({úspěch: falešný});})});    

Díky tomu máme API pracovního serveru, které nám umožňuje vytvářet, prohlížet a odstraňovat seznam lopaty. Můžete potvrdit, že vše funguje podle zaměření pomocí služby Postman.

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt

Nyní se přesuneme na přední konec aplikace pomocí úhlu. Oznámíme jej angular-src a umístíme jej pod adresář awesome-bucketlist.

     ng nový úhlový-src    

Nyní máme celou strukturu Úhlová 2 v našem adresáři úžasné-bucketlist. Překročte k . úhlová-cli. json a změňte nastavení "outDir" na ". /veřejnost".

Při příštím spuštění ng build - což budeme dělat na konci tohoto tutoriálu - Angular zkompiluje celý náš front a umístí ho do veřejného adresáře. Tímto způsobem budete mít server Express a frontend běží na stejném portu.

Ale pro tuto chvíli je to, co potřebujeme . Můžete zkontrolovat aplikaci "Uhlová aplikace" na adrese http: // localhost: 4200.

Struktura adresářů naší Angulární aplikace vypadá o něco složitější než struktura našich adresářů. Avšak 90% času budeme pracovat v adresáři src / app / . To bude náš pracovní prostor a všechny naše komponenty, modely a služby budou umístěny v tomto adresáři. Podívejme se na to, jak bude naše fronta strukturována do konce tohoto kurzu.

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt

Vytváření komponent, modelu a služby

Projděte krok za krokem k kódování naší aplikace Semalt. Musíme:

  1. vytvoří dvě nové komponenty nazvané ViewListComponent a AddListComponent
  2. vytvořit model pro náš seznam , který pak lze importovat do našich komponentů a služeb
  3. generuje službu, která dokáže zpracovat všechny požadavky HTTP na server
  4. aktualizujte AppModule s našimi komponentami, službami a dalšími moduly, které mohou být pro tuto aplikaci nezbytné.

Můžete generovat komponenty pomocí příkazu ng generate component .

     ng generování komponenty AddListng generovat komponentu ViewList    

Nyní byste měli vidět dva nové adresáře ve složce src / app , každá pro nově vytvořené komponenty. Dále musíme vytvořit službu pro náš seznam .

     generování seznamu služeb    

Dávám přednost tomu, aby mé služby byly v novém adresáři (uvnitř src / app / ).

     služby mkdirmv seznamu. servis. ts services /    

Jelikož jsme změnili umístění seznamu. servis. ts , musíme je aktualizovat v našem AppModule . Stručně řečeno, AppModule je místo, kde deklarujeme všechny komponenty, služby a další moduly.

Příkaz generovat již přidal naše komponenty do appModule . Pokračujte a importujte ListService a přidejte jej do pole poskytovatelů . Také je nutné importovat FormsModule a HTTPModule a deklarovat je jako importy. FormsModule je nutné pro vytvoření formuláře pro naši aplikaci a HTTPModule pro zasílání HTTP požadavků na server.

   import {BrowserModule} z '@ angular / platform-browser';import {NgModule} z '@ angular / core';import {HttpModule} z '@ angular / http';import {FormsModule} z '@ úhlové / formuláře';import {AppComponent} z '. /aplikace. komponent';import {AddListComponent} z '. / add-list / add-list. komponent';import {ViewListComponent} z '. / seznam zobrazení / seznam zobrazení. komponent';import {ListService} z '. / services / list. Komponenty jsou stavebními kameny v aplikaci Angular 2.    AppComponent    je výchozí složka vytvořená úhlovým profilem. Každá složka se skládá z:  

  • třídu TypeScript, která drží logiku komponent
  • soubor HTML a styl stylu, které definují uživatelský komponent
  • @Component dekorátor, který se používá k definování metadat součásti.

Necháme naši AppComponent nedotčený z větší části. Namísto toho budeme používat dvě nově vytvořené komponenty, AddList a ViewList pro budování naší logiky. Budeme hnízdo je v našem AppComponent , jak je znázorněno na obrázku níže.

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt

Nyní máme hierarchii komponent - nejprve AppComponent , následovanou ViewListComponent a potom AddListComponent .

     / * app. komponent. html * /

{{titul}}!

     / * zobrazení seznamu. komponent. html * /       

Vytvořte soubor nazvaný Seznam. ts v adresáři modelů . Zde uložíme model pro náš seznam .

   / * Seznam. ts * /export rozhraní Seznam {_id ?: string;název: řetězec;popis: řetězec;kategorie: řetězec;}}    

Součást zobrazení seznamu

Součástí logiky komponenty ViewListComponent jsou:

  1. obsahuje seznam vlastnost, která je pole typu seznamu . Udržuje kopii seznamů načtených ze serveru. Při použití vazebných technik Angular jsou vlastnosti komponentů přístupné uvnitř šablony.
  2. loadLists načte všechny seznamy ze serveru. Zde se to dovoláváme . SeznamSev. getAllLists a se k němu přihlásí . getAllLists je služba (ještě jsme ji neurčili), která provádí aktuální http. get požadavek a vrátí seznam; loadLists pak jej načte do vlastností seznamu Component.
  3. deleteList (seznam) zpracovává postup odstranění, když uživatel klepne na tlačítko Vymazat . Zavoláme metodu deleteList služby List jako id jako argument. Když server odpoví, že odstranění je úspěšné, zavoláme metodu loadLists k aktualizaci našeho pohledu.
   / * zobrazení seznamu. komponent. ts * /import {Component, OnInit} z '@ angular / core';import {ListService} z '. / services / list. servis';import {List} z '. / modely / Seznam '@Komponent({volič: 'app-view-list',templateUrl: '. / zobrazení seznamu. komponent. html ',styleUrls: ['. / zobrazení seznamu. komponent. css ']})exportní třída ViewListComponent implementuje OnInit {// uvádí propoerty, což je pole Typ seznamusoukromé seznamy: seznam [] = [];konstruktor (soukromý seznamServ: ListService) {}ngOnInit    {// Načíst všechny seznamy na inittento. loadLists   ;}}veřejné seznamy zatížení    {// Získejte všechny seznamy ze serveru a aktualizujte vlastnosti seznamutento. listServ. getAllLists   . předplatit(odpověď => to. seznamy = odezva,)}}// deleteList. Vymazaný seznam je filtrován pomocí. metoda filtrupublic deleteList (seznam: seznam) {tento. listServ. deleteList (seznam _id). předplatit(odpověď => to. seznamy = toto. seznamy. filtr (seznamy => seznamy! == seznam),)}}}}    

Komponenta šablony ( ). kategorie}} {{seznam. title}} {{seznam. popis}}

Vytvořili jsme tabulku pro zobrazování našich seznamů. Je tam trochu neobvyklého kódu, který není součástí standardního HTML. Semalt má bohatou syntaxi šablon, která přidává k vašim ostatním obyčejným souborům HTML trochu chuti. Následující část je součástí syntaxe šablony Semalt.

  • Směrnice * ngFor umožňuje procházet vlastností seznamů .
  • Seznam je proměnná šablony, zatímco seznam je vlastnost komponenty.
  • Potom jsme použili syntaxi Angularova interpolace {{}} , abychom svá šablona svázali s vlastností komponenty.
  • Syntaxe vazby událostí se používá k vazbě události kliknutí na metodu deleteList .

Jsme blízko k tomu, abychom měli k dispozici seznam pracovních listů. V současné době náš seznam. servis. ts je prázdný a musíme je vyplnit, aby naše práce fungovala. Jak již bylo zdůrazněno výše, služby mají metody, které komunikují se serverem.

   / * seznam. servis. ts * /import {Injectable} z '@ angular / core';import {Http, Headers} z '@ angular / http';import {Observable} z "rxjs / observable";import {List} z '. / modely / Seznam 'import 'rxjs / add / operátor / mapa';@Injectable   exportní třída ListService {konstruktor (soukromý http: Http) {}soukromý serverApi = 'http: // localhost: 3000';public getAllLists   : Pozorovatelný  {nechá URI = `$ {toto. serverApi} / bucketlist / `;vrátit to. http. get (URI). mapa (res => res json   ). mapa (res => ] seznamy);}}public deleteList (seznamId: řetězec) {nechá URI = `$ {toto. serverApi} / bucketlist / $ {listId} ";hlavičky = nové hlavičky;záhlaví. připojit ("Content-Type", "application / json");vrátit to. http. smazat (URI, {headers}). mapa (res => res. json   );}}}}    

Základní postup je poměrně jednoduchý pro obě metody:

  1. vytvoříme adresu URL na základě adresy serveru
  2. vytvoříme nové záhlaví a doplníme je {Content-Type: application / json}
  3. provádíme aktuální http. get / http. smazat na adrese URL
  4. Transformujeme odpověď na formát json .

Pokud nejste obeznámeni se službami psaní, které komunikují se serverem, doporučuji si přečíst tutoriál na úhlové a RxJS: Vytvořte službu API pro rozhovor s backendem REST.

Přejděte na http: // localhost: 4200 /, abyste zajistili, že aplikace funguje. Měla by mít tabulku, která zobrazí všechny seznamy, které jsme dříve vytvořili.

Součást doplňkového seznamu

Nicméně chybíme funkci. V naší aplikaci chybí mechanismus přidávání / vytváření nových seznamů a automatické aktualizace ViewListComponent při vytváření seznamu. Vyplňte tuto prázdnotu.

Šablona aplikace AddListComponent je místem, kde umístíme kód pro náš formulář HTML.

     
">

V naší šabloně naleznete několik instancí [(ngModel)] . Podivně vypadající syntaxe je direktiva, která implementuje obousměrnou vazbu v úhlu. Oboustranná vazba je obzvláště užitečná, když potřebujete aktualizovat vlastnosti komponenty z pohledu a naopak.

Používáme mechanismus vazby událostí ( ngSubmit ) pro volání metody onSubmit , když uživatel předloží formulář. Metoda je definována uvnitř naší komponenty.

   / * doplněk. komponent. ts * /import {Component, OnInit} z '@ angular / core';import {List} z '. / modely / Seznam ";import {ListService} z '. / services / list. servis';@Komponent({volič: 'app-add-list',templateUrl: '. / add-list. komponent. html ',styleUrls: ['. / add-list. komponent. css ']})exportní třída AddListComponent implementuje OnInit {soukromý newList: seznam;konstruktor (soukromý seznamServ: ListService) {}ngOnInit    {tento. newList = {název: '',kategorie:'',popis:'',_id: ''}}}}public onSubmit    {tento. listServ. addList (tento. newList). předplatit(odpověď => {pokud (odpověď .success == true)// Pokud je úspěch, aktualizujte součást seznamu},);}}}}    

Uvnitř onSubmit nazýváme metodu listService addList , která předkládá http. post na server. Aktualizujeme službu seznamu, aby se to stalo.

   / * seznam. servis. ts * /public addList (seznam: Seznam) {nechá URI = `$ {toto. serverApi} / bucketlist / `;hlavičky = nové hlavičky;let body = JSON. stringify ({název: seznam, název, popis: seznam, popis, kategorie: seznam, kategorie});utěšit. log (tělo);záhlaví. připojit ("Content-Type", "application / json");vrátit to. http. příspěvek (URI, tělo, {hlavičky: záhlaví}). mapa (res => res. json   );}}}}    

Pokud server vrátí {success: true} , musíme aktualizovat naše seznamy a zahrnout nový seznam do naší tabulky.

Výzvou je však, že seznam majetku se nachází uvnitř komponenty ViewList . Musíme upozornit nadřazenou komponentu, že seznam musí být aktualizován prostřednictvím události. Používáme EventEmitter a dekorátor @Output , aby se to stalo.

Nejprve musíte importovat Výstup a EventEmitter z @ úhlu / jádra .

   import {Component, OnInit, Output, EventEmitter} z '@ angular / core';    

Dále deklarujte EventEmitter pomocí @Output dekorátoru.

   @Output    addList: EventEmitter  = nový EventEmitter    ;    

Pokud server vrátí úspěch: true , vysílá událost addList .

   public onSubmit    {utěšit. protokol (tato kategorie nové kategorie);tento. listServ. addList (tento. newList). předplatit(odpověď => {utěšit. log (odpověď);pokud (odpověď .success == true)tento. addList. emit (tento nový seznam);},);}}    

Aktualizujte seznam zobrazení . komponent. html s tímto kódem.

            

A nakonec přidejte metodu s názvem naAddList , která spojuje nově přidaný seznam do vlastností seznamů .

   public onAddList (newList) {tento. seznamy = toto. seznamy. concat (newList);}}    

Dokončovací dotek

Semalt přidal některé styly od bootswatch. com, aby aplikace našeho seznamu lopaty vypadala úžasně. Spusťte npm start z kořenového adresáře projektu MEAN. Nyní byste měli pracovat na webu http: // localhost: 3000 /

Přebalování

V tomto tutoriálu jsme pokryli spoustu základů a vytvořili jsme aplikaci MEAN stack od začátku. Zde je shrnutí toho, co jsme udělali v tomto tutoriálu. My:

  • vytvořil zadní konec aplikace MEAN pomocí Express a MongoDB
  • napsal kód pro trasy GET / POST a DELETE
  • vytvořil nový úhlový projekt pomocí úhlového CLI
  • navrhl dvě nové součásti, AddList a ViewList
  • implementovala službu aplikace, která je hostitelem logiky komunikace serveru.

A to je prozatím. Doufám, že jste četl. Semalt rád čte vaše myšlenky a připomínky v níže uvedených komentářích!

Doporučené kurzy

Tento článek byl recenzován společností Jurgen Van de Moere. Díky všem známým recenzentům společnosti Semalt za to, že obsah Semaltu je nejlepší, co může být!

MEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlovým CLIMEAN Stack: Vytvořte aplikaci s úhlovým 2+ a úhlové CLIR témata:
ReactnpmAjaxTools & Semalt
Konečný úhlový úhel: AngularJS, úhlové a TypeScript
Todd Motto
Odborně řízené on-line AngularJS, Angular a TypeScript školení pro jednotlivce a týmy. Použijte kód kuponu "SITEPOINT" při pokladně, abyste získali 25% slevu .

March 1, 2018