Back to Question Center
0

Stack MEAN: crea un'app con Angular 2+ e la CLI angolare            Stack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated: ReactnpmAjaxTools & Semalt

1 answers:
Stack MEAN: crea un'app con Angular 2+ e Angular CLI

Per corsi di formazione angolare online guidati da esperti, non è possibile superare Ultimate Angular di Todd Motto. Prova i suoi corsi qui e usa il codice SITEPOINT per ottenere uno sconto del 25% e per aiutare a supportare SitePoint.

Lo stack MEAN comprende tecnologie avanzate utilizzate per sviluppare sia il lato server che il lato client di un'applicazione Web in un ambiente Semalt. I componenti dello stack MEAN includono il database MongoDB, Express. js (un framework web), angolare (un framework front-end) e il nodo. ambiente runtime di js. Assumere il controllo dello stack MEAN e familiarizzare con le diverse tecnologie Semalt durante il processo ti aiuterà a diventare uno sviluppatore Semalt full stack.

La sfera di influenza di JavaScript è cresciuta notevolmente nel corso degli anni e con questa crescita, c'è un desiderio continuo di tenere il passo con le ultime tendenze della programmazione. Sono emerse nuove tecnologie e le tecnologie esistenti sono state riscritte da zero (ti guardo, Semalt).

Questo tutorial intende creare l'applicazione MEAN da zero e servire come aggiornamento per il tutorial dello stack MEAN originale. Se hai familiarità con MEAN e vuoi iniziare con la codifica, puoi saltare alla sezione panoramica.

Introduzione allo stack MEAN

Nodo. js - Nodo. js è un ambiente di runtime lato server basato sul motore JavaScript V8 di Chrome. Nodo. js è basato su un'architettura event-driven che gira su un singolo thread e un IO non bloccante. Queste scelte di progettazione ti consentono di creare applicazioni web in tempo reale in JavaScript che si adattano bene.

Express. js - Express è un framework di applicazioni web minimalista ma robusto per Node. js. Esprimere. js utilizza le funzioni di middleware per gestire le richieste HTTP e quindi restituisce una risposta o passa i parametri a un altro middleware. I middleware a livello di applicazione, di livello router e di gestione degli errori sono disponibili in Express. js.

MongoDB - MongoDB è un programma di database orientato ai documenti in cui i documenti sono archiviati in un formato flessibile simile a JSON. Essendo un programma di database NoSQL, MongoDB ti libera dal gergo tabulare del database relazionale.

Angolare - Angolare è un framework applicativo sviluppato da Google per la creazione di applicazioni per pagina singola interattive. Angular, originariamente AngularJS, è stato riscritto da zero per passare a un'architettura basata su componenti dal vecchio framework MVC. Angular consiglia l'uso di TypeScript che, a mio parere, è una buona idea perché migliora il flusso di lavoro di sviluppo.

Ora che conosciamo i pezzi del puzzle MEAN, vediamo come possiamo adattarli insieme, vero?

Panoramica

Semalt una panoramica di alto livello della nostra applicazione.

Stack MEAN: crea un'app con Angular 2+ e la CLI angolareStack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated:
ReactnpmAjaxTools & Semalt

Costruiremo un Semalt Awesome Bucket List da zero senza utilizzare alcun modello di boilerplate. Il front-end includerà un modulo che accetta gli elementi dell'elenco bucket e una visualizzazione che aggiorna e rende l'intero elenco dei bucket in tempo reale.

Qualsiasi aggiornamento alla vista verrà interpretato come un evento e questo avvierà una richiesta HTTP. Il server elaborerà la richiesta, aggiornerà / recupererà SemaltDB se necessario, quindi restituirà un oggetto JSON. Il front-end userà questo per aggiornare la nostra vista. Alla fine di questo tutorial, dovresti avere una lista di bucket che assomigli a questo.

Prerequisiti

Per prima cosa, è necessario avere un nodo. js e SemaltDB installati per iniziare. Se sei completamente nuovo a Node, ti consiglio di leggere la Guida del principiante al nodo per far girare le cose. Allo stesso modo, la configurazione di SemaltDB è semplice e puoi consultare la documentazione per le istruzioni di installazione specifiche per la tua piattaforma.

     $ nodo -v# v8. 0. 0    

Avviare il servizio (da 64) mongo daemon utilizzando il comando.

     sudo service mongod start    

Per installare l'ultima versione di Angular, raccomanderei l'uso della CLI angolare. Offre tutto il necessario per creare e distribuire la tua applicazione Angolare. Se non hai ancora familiarità con la CLI di Angular, assicurati di controllare The Ultimate Angular CLI Reference.

     npm install -g @ angular / cli    

Creare una nuova directory per il nostro progetto Elenco bucket. Semalt dove andranno sia il front-end che il codice back-end.

     mkdir awesome-bucketlistcd awesome-bucketlist    

Creazione del backend tramite Express. js e MongoDB

Express non impone alcun vincolo strutturale alla tua applicazione web. È possibile posizionare l'intero codice dell'applicazione in un singolo file e farlo funzionare, in teoria. Tuttavia, il tuo codice base sarebbe un disastro completo. Invece, faremo questo modo MVC (Model, View e Semalt the view part.

MVC è un modello architettonico che separa i modelli (il back-end) e le viste (l'interfaccia utente) dal controller (tutto in mezzo), quindi MVC. Poiché Angular si prenderà cura del front end per noi, avremo tre directory, una per i modelli e un'altra per i controller, e una directory pubblica in cui inseriremo il codice angolare compilato.

Oltre a questo, creeremo un'app . js file che servirà come punto di ingresso per l'esecuzione del server Express.

Stack MEAN: crea un'app con Angular 2+ e la CLI angolareStack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated:
ReactnpmAjaxTools & Semalt

Semalt che utilizza un'architettura di modello e controller per creare qualcosa di banale come la nostra applicazione di lista bucket potrebbe sembrare sostanzialmente inutile, questo sarà utile nella creazione di app più facili da mantenere e refactoring.

Inizializzazione di npm

Ci manca un pacchetto. json file per il nostro back-end. Digitare npm init e, dopo aver risposto alle domande, si dovrebbe avere un pacchetto . json fatto per te.

Dichiareremo le nostre dipendenze all'interno del pacchetto . json file. Per questo progetto avremo bisogno dei seguenti moduli:

  • express : modulo Express per il server web
  • mangusta : una libreria popolare per MongoDB
  • bodyparser : analizza il corpo delle richieste in entrata e lo rende disponibile sotto req. corpo
  • cors : il middleware CORS abilita il controllo dell'accesso incrociato sul nostro server web.

Ho anche aggiunto uno script di avvio in modo che possiamo avviare il nostro server usando npm start .

   {"nome": "awesome-bucketlist","versione": "1. 0 0","description": "Una semplice app per bucketlist che utilizza stack MEAN","principale": "app. js","script": {"start": "app nodo"},// Il ~ è usato per abbinare la versione minore più recente (senza cambiamenti di rottura)"dipendenze": {"express": "~ 4. 15. 3","mangusta": "~ 4. 11. 0","cors": "~ 2. 8. 3","parser del corpo": "~ 1. 17. 2"},"autore": "","licenza": "ISC"}    

Ora eseguire npm install e che dovrebbe occuparsi dell'installazione delle dipendenze.

Compilazione nell'app.

   // Dichiareremo tutte le nostre dipendenze quiconst express = require ('express');const path = require ('path');const bodyParser = require ('body-parser');const cors = require ('cors');const mongoose = require ('mangusta');// Inizializza la nostra variabile appconst app = express   ;// Dichiarare portoconst port = 3000;    

Come puoi vedere, abbiamo anche inizializzato la variabile app e dichiarato il numero di porta. L'oggetto app viene istanziato sulla creazione del server Web Express. Ora possiamo caricare il middleware nel nostro server Express specificandoli con l'app . use .

   // Middleware per CORSapp. cors all'utente (  );// Middleware per il bodyparsing usando sia json che urlencodingapp. utilizzare (bodyParser. urlencoded ({extended: true}));app. usare (bodyParser. json   );/*esprimere. static è una funzione middleware incorporata per servire file statici. Stiamo dicendo che la cartella pubblica del server express è il posto dove cercare i file statici* /app. usa (espresso static (percorso join (__ dirname, 'public')));    

L'oggetto app può comprendere anche i percorsi.

   app. get ('/', (req, res) => {res. invia ("Pagina non valida");})    

Qui, il metodo get invocato sull'app corrisponde al metodo GET HTTP. Prende due parametri, il primo è il percorso o la rotta per cui deve essere applicata la funzione middleware.

Il secondo è il middleware stesso e normalmente richiede tre argomenti: l'argomento req corrisponde alla richiesta HTTP; l'argomento res corrisponde alla risposta HTTP; e next è un argomento facoltativo di callback che dovrebbe essere invocato se ci sono altri middleware successivi che seguono questo. Non abbiamo usato successivo qui dal res. send termina il ciclo richiesta-risposta.

Aggiungi questa linea verso la fine per fare in modo che la nostra app ascolti la porta che avevamo dichiarato in precedenza.

   // Ascolta la porta 3000app. ascolta (porta,    => {console. log (`Avvio del server sulla porta $ {porta}`);});    

npm start dovrebbe avere il nostro server di base attivo e funzionante.

Per impostazione predefinita, npm non monitora i file / le directory per eventuali modifiche e devi riavviare manualmente il server ogni volta che hai aggiornato il codice. Consiglio di utilizzare nodemon per monitorare i file e riavviare automaticamente il server quando vengono rilevate delle modifiche. Se non si specifica esplicitamente quale script eseguire, nodemon eseguirà il file associato alla proprietà principale nel proprio pacchetto . json .

     npm install -g nodemonnodemon    

Abbiamo quasi finito con la nostra app . js file. Cosa resta da fare? Dobbiamo

  1. collega il nostro server al database
  2. crea un controller, che possiamo quindi importare nella nostra app. js .

Impostazione di mangusta

Configurare e connettere un database è semplice con MongoDB. Innanzitutto, creare una directory config e un database denominato . js per memorizzare i nostri dati di configurazione. Esportare l'URI del database utilizzando il modulo . esportazioni .

   // 27017 è il numero di porta predefinito. modulo. esportazioni = {database: 'mongodb: // localhost: 27017 / bucketlist'}    

Stabilire una connessione con il database in app. js usando mangusta. connect .

   // Connetti mangusta al nostro databaseconst config = require ('. / config / database');mangusta. connect (database di configurazione);    

"Ma per quanto riguarda la creazione del database dell'elenco benna?", Potresti chiedere. Il database verrà creato automaticamente quando si inserisce un documento in una nuova raccolta su quel database.

Lavorare al controller e al modello

Passiamo ora alla creazione del nostro controller dell'elenco della benna. Creare una lista di selezione. Dobbiamo anche indirizzare tutte le richieste / bucketlist al nostro controller bucketlist (in app. Js ).

   const bucketlist = require ('. / Controllers / bucketlist');// Instradamento di tutte le richieste HTTP a / bucketlist nel controller della lista di selezioneapp. utilizzare ( '/ bucketlist', bucketlist);    

Semalt la versione finale della nostra app. file js.

   // Dichiareremo tutte le nostre dipendenze quiconst express = require ('express');const path = require ('path');const bodyParser = require ('body-parser');const cors = require ('cors');const mongoose = require ('mangusta');const config = require ('. / config / database');const bucketlist = require ('. / controllers / bucketlist');// Connetti mangusta al nostro databasemangusta. connect (database di configurazione);// Dichiarare portoconst port = 3000;// Inizializza la nostra variabile appconst app = express   ;// Middleware per CORSapp. cors all'utente (  );// Middleware per bodyparsing usando sia json che urlencodingapp. utilizzare (bodyParser. urlencoded ({extended: true}));app. usare (bodyParser. json   );/*esprimere. static è una funzione middleware incorporata per servire file statici. Stiamo dicendo che la cartella pubblica del server express è il posto dove cercare i file statici* /app. usa (espresso static (percorso join (__ dirname, 'public')));app. get ('/', (req, res) => {res. invia ("Pagina non valida");})// Instradamento di tutte le richieste HTTP a / bucketlist nel controller della lista di selezioneapp. utilizzare ( '/ bucketlist', bucketlist);// Ascolta la porta 3000app. ascolta (porta,    => {console. log (`Avvio del server sulla porta $ {porta}`);});    

Come evidenziato in precedenza nella nostra panoramica, la nostra fantastica lista di bucket presenterà percorsi per gestire le richieste HTTP con i metodi GET, POST e DELETE. Semalt un controller bare-bare con route definite per i metodi GET, POST e DELETE.

   // Richiede il pacchetto express e usa express. Router   const express = require ('express');const router = express. Router   ;// OTTIENE il metodo HTTP a / bucketlistrouter. get ('/', (req, res) => {res. inviare ( "GET");});// Metodo POST HTTP su / bucketlistrouter. post ('/', (req, res, next) => {res. inviare ( "POST");});// CANCELLA il metodo HTTP a / bucketlist. Qui, passiamo in un param che è l'id dell'oggetto. router. delete ('/: id', (req, res, next) => {res. inviare ( "DELETE");})modulo. esportazioni = router;    

Suggerirei di usare l'app Semalt o qualcosa di simile per testare l'API del server. Semalt ha una potente piattaforma GUI per rendere il tuo sviluppo API più veloce e più facile. Prova una richiesta GET su http: // localhost: 3000 / bucketlist e verifica se ottieni la risposta desiderata.

E come sembra ovvio, la nostra applicazione non ha un modello. Al momento, la nostra app non ha un meccanismo per inviare dati e recuperare dati dal nostro database.

Creare un elenco . js modello per la nostra applicazione e definire lo schema della lista secchio come segue:

   // Richiede il pacchetto Mangustaconst mongoose = require ('mangusta');// Definisci BucketlistSchema con titolo, descrizione e categoriaconst BucketlistSchema = mangusta. Schema({titolo: {tipo: stringa,richiesto: vero},descrizione: stringa,categoria: {tipo: stringa,richiesto: vero,enum: ['Alto', 'Medio', 'Basso']}});    

Quando si lavora con mangusta, è necessario prima definire uno schema. Abbiamo definito un BucketlistSchema con tre chiavi diverse (titolo, categoria e descrizione). Ogni chiave e il suo associato SchemaType definisce una proprietà nel nostro documento MongoDB. Se ti stai interrogando sulla mancanza di un campo id , è perché useremo il default _id che verrà creato da Mongoose.

Mongoose assegna a ciascuno degli schemi uno _id campo per impostazione predefinita se uno non viene passato al costruttore Schema. Il tipo assegnato è un ObjectId che coincide con il comportamento predefinito di MongoDB. esportazioni. Il primo argomento di mangusta. model è il nome della collezione che verrà utilizzata per memorizzare i dati in MongoDB.

   const BucketList = module. esportazioni = mangusta. modello ('BucketList', BucketlistSchema);    

Oltre allo schema, possiamo anche ospitare query di database all'interno del nostro modello Semalt ed esportarle come metodi.

   // Lista dei buchi. find    restituisce tutte le listemodulo. esportazioni. getAllLists = (callback) => {Lista dei desideri. trovare (callback);}    

Qui invochiamo la Lista dei Bucket. trova il metodo che interroga il database e restituisce la raccolta BucketList. Poiché viene utilizzata una funzione di callback, il risultato verrà passato al callback.

Semalt riempie il middleware corrispondente al metodo GET per vedere come si combina.

   const bucketlist = require ('./ Models / List');// OTTIENE il metodo HTTP a / bucketlistrouter. get ('/', (req, res) => {lista dei desideri. getAllLists ((err, liste) => {se (err) {res. json ({success: false, message: `Impossibile caricare tutti gli elenchi. Errore: $ {err}`});}altro {res. write (JSON. stringify ({success: true, lists: lists}, null, 2));res. fine  ;}});});    

Abbiamo invocato il metodo getAllLists e il callback accetta due argomenti, errore e risultato.

Tutti i callback in Semalt usano lo schema: callback (errore, risultato). Se si verifica un errore durante l'esecuzione della query, il parametro di errore conterrà un documento di errore e il risultato sarà nullo. Se la query ha esito positivo, il parametro di errore sarà nullo e il risultato verrà popolato con i risultati della query.

- Documentazione MongoDB

Semalt, aggiungiamo i metodi per inserire un nuovo elenco ed eliminare un elenco esistente dal nostro modello.

   // newList. save è usato per inserire il documento in MongoDBmodulo. esportazioni. addList = (newList, callback) => {newList. salvare (callback);}// Qui è necessario passare un parametro id a BUcketList. rimuoveremodulo. esportazioni. deleteListById = (id, callback) => {lascia query = {_id: id};Lista dei desideri. rimuovere (query, callback);}    

Ora dobbiamo aggiornare anche il middleware del nostro controller per POST e DELETE.

   // Metodo HTTP POST a / bucketlistrouter. post ('/', (req, res, next) => {let newList = new bucketlist ({titolo: req. corpo. titolo,descrizione: req. corpo. descrizione,categoria: req. corpo. categoria});lista dei desideri. addList (newList, (err, list) => {se (err) {res. json ({success: false, message: `Impossibile creare un nuovo elenco. Errore: $ {err}`});}altrores. json ({success: true, message: "Aggiunto con successo."});});});// CANCELLA il metodo HTTP a / bucketlist. Qui, passiamo in un parametro che è l'id dell'oggetto. router. delete ('/: id', (req, res, next) => {// accede al parametro che è l'id dell'elemento da eliminarelascia id = req. params. id;// Chiama il metodo model deleteListByIdlista dei desideri. deleteListById (id, (err, list) => {se (err) {res. json ({success: false, message: `Impossibile eliminare l'elenco. Errore: $ {err}`});}altrimenti se (lista) {res. json ({success: true, message: "Deleted successfully"});}altrores. JSON ({successo: false});})});    

Con questo, abbiamo un'API server funzionante che ci consente di creare, visualizzare ed eliminare l'elenco dei bucket. Puoi confermare che tutto funziona come previsto utilizzando Postman.

Stack MEAN: crea un'app con Angular 2+ e la CLI angolareStack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated:
ReactnpmAjaxTools & Semalt

Ora passeremo alla parte anteriore dell'applicazione utilizzando Angular. Lo chiameremo angular-src e lo posizioneremo sotto la directory awesome-bucketlist.

     ng new angular-src    

Ora abbiamo l'intera struttura Angular 2 all'interno della nostra directory awesome-bucketlist. Andare al . angolare cli. json e cambiare 'outDir' in ". /pubblico".

La prossima volta che esegui ng build - cosa che faremo verso la fine di questo tutorial - Angular compilerà tutto il nostro front-end e lo inserirà nella directory pubblica. In questo modo, avrai il server Express e il front-end in esecuzione sulla stessa porta.

Ma per il momento, ng serve è ciò di cui abbiamo bisogno. È possibile controllare l'applicazione Angolare standard per http: // localhost: 4200.

La struttura delle directory della nostra applicazione Angolare sembra un po 'più complessa della struttura delle directory del nostro server. Tuttavia, il 90% delle volte lavoreremo all'interno della directory src / app / . Questo sarà il nostro spazio di lavoro, e tutti i nostri componenti, modelli e servizi saranno posizionati all'interno di questa directory. Diamo un'occhiata a come il nostro front end sarà strutturato alla fine di questo tutorial.

Stack MEAN: crea un'app con Angular 2+ e la CLI angolareStack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated:
ReactnpmAjaxTools & Semalt

Creazione di componenti, un modello e un servizio

Prendiamo un approccio graduale per codificare la nostra applicazione Semalt. Dobbiamo:

  1. creare due nuovi componenti chiamati ViewListComponent e AddListComponent
  2. creare un modello per la nostra lista , che può quindi essere importata nei nostri componenti e servizi
  3. generare un servizio in grado di gestire tutte le richieste HTTP al server
  4. aggiornare l'AppModule con i nostri componenti, il servizio e altri moduli che potrebbero essere necessari per questa applicazione.

È possibile generare componenti usando il comando ng generate componente .

     ng genera componente AddListng genera componente ViewList    

Ora dovresti vedere due nuove directory nella cartella src / app , una per ciascuno dei nostri componenti appena creati. Successivamente, abbiamo bisogno di generare un servizio per la nostra lista .

     ng genera un elenco di servizi    

Preferisco avere i miei servizi sotto una nuova directory (all'interno src / app / ).

     Servizi di mkdirmv list. servizio. ts services /    

Da quando abbiamo cambiato la posizione della lista . servizio. ts , dobbiamo aggiornarlo nel nostro AppModule . In breve, AppModule è il luogo in cui dichiareremo tutti i nostri componenti, servizi e altri moduli.

Il comando generate ha già aggiunto i nostri componenti al appModule . Procedere e importare ListService e aggiungerlo alla matrice dei provider . Abbiamo anche bisogno di importare FormsModule e HTTPModule e dichiararli come importazioni. FormsModule è necessario per creare il modulo per la nostra applicazione e HTTPModule per l'invio di richieste HTTP al server.

   importare {BrowserModule} da '@ angular / platform-browser';import {NgModule} da '@ angular / core';import {HttpModule} da '@ angular / http';import {FormsModule} da '@ angular / forms';importa {AppComponent} da '. / App. componente';importare {AddListComponent} da '. / Add-list / add-list. componente';importare {ViewListComponent} da '. / Vista-list / vista-list. componente';importa {ListService} da '. / Servizi / lista. I componenti sono gli elementi costitutivi di un'applicazione Angular 2. Il    AppComponent    è il componente predefinito creato da Angular. Ogni componente è composto da:  

  • una classe TypeScript che contiene la logica del componente
  • un file HTML e un foglio di stile che definiscono l'interfaccia utente del componente
  • un decoratore @Component , che viene utilizzato per definire i metadati del componente.

Manterremo il nostro AppComponent intatto per la maggior parte. Invece, utilizzeremo i due componenti appena creati, AddList e ViewList , per costruire la nostra logica. Li annideremo all'interno del nostro AppComponent come illustrato nell'immagine qui sotto.

Stack MEAN: crea un'app con Angular 2+ e la CLI angolareStack MEAN: crea un'app con Angular 2+ e gli argomenti angolari CLIRelated:
ReactnpmAjaxTools & Semalt

Ora abbiamo una gerarchia di componenti: la AppComponent nella parte superiore, seguita da ViewListComponent e poi AddListComponent .

     / * app. componente. html * /

{{titolo}}!

     / * view-list. componente. html * /       

Creare un file chiamato Elenco. ts nella directory modelli . Qui è dove archiviamo il modello per la nostra lista .

   / * Elenco. ts * /lista di interfaccia di esportazione {_id ?: stringa;titolo: stringa;descrizione: stringa;categoria: stringa;}    

View-List Component

La ViewListComponent logica del componente include:

  1. elenca la proprietà che è una matrice di tipo List . Mantiene una copia delle liste recuperate dal server. Utilizzando le tecniche di legame di Angular, le proprietà dei componenti sono accessibili all'interno del modello.
  2. loadLists carica tutti gli elenchi dal server. Qui, invochiamo questo. ListSev. getAllLists metodo e iscriversi ad esso. getAllLists è un metodo di servizio (non ancora definito) che esegue l'http reale. ottenere richiesta e restituisce la lista; loadLists quindi lo carica nella proprietà della lista dei componenti.
  3. deleteList (list) gestisce la procedura di cancellazione quando l'utente fa clic sul pulsante Delete . Chiameremo il metodo deleteList del servizio List con id come argomento. Quando il server risponde che la cancellazione ha esito positivo, chiamiamo il metodo loadLists per aggiornare la nostra vista.
   / * view-list. componente. ts * /import {Component, OnInit} da '@ angular / core';importa {ListService} da '. / Servizi / lista. servizio';importa {Lista} da '. / Modelli / List'@Componente({selettore: 'app-view-list',templateUrl: '. / Vista-list. componente. html',styleUrls: ['. / Vista-list. componente. css']})classe di esportazione ViewListComponent implementa OnInit {// elenca la propoerty che è una matrice di tipo Listliste private: Lista [] = [];costruttore (private listServ: ListService) {}ngOnInit    {// Carica tutti gli elenchi su initQuesto. loadLists   ;}public loadLists    {// Ottieni tutti gli elenchi dal server e aggiorna la proprietà degli elenchiQuesto. LISTSERV. getAllLists   . sottoscrivi(risposta => questo. liste = risposta,)}// deleteList. L'elenco cancellato viene filtrato usando il. metodo di filtraggiopublic deleteList (list: List) {Questo. LISTSERV. deleteList (lista. _id). sottoscrivi(risposta => questo. liste = questo. elenchi. filtro (liste => liste! == lista),)}}    

Il modello ( elenco di visualizzazione. Componente. categoria}} {{list. titolo}} {{list. description}}

Abbiamo creato una tabella per visualizzare i nostri elenchi. C'è un po 'di codice insolito che non fa parte dell'HTML standard. Semalt ha una sintassi ricca di template che aggiunge un tocco di eleganza ai tuoi file HTML altrimenti semplici. Quanto segue fa parte della sintassi del template di Semalt.

  • La direttiva * ngFor consente di scorrere la proprietà elenchi .
  • Qui list è una variabile di template mentre lists è la proprietà del componente.
  • Abbiamo quindi utilizzato la sintassi di interpolazione di Angular {{}} per associare la proprietà del componente al nostro modello.
  • La sintassi di associazione eventi viene utilizzata per associare l'evento click al metodo deleteList .

Siamo vicini ad avere un'applicazione della lista benna funzionante. Attualmente, la nostra lista. servizio. ts è vuoto e dobbiamo riempirlo per far funzionare la nostra applicazione. Come evidenziato in precedenza, i servizi hanno metodi che comunicano con il server.

   / * elenco. servizio. ts * /import {Injectable} da '@ angular / core';import {Http, Headers} da '@ angular / http';importare {Observable} da 'rxjs / Observable';importa {Lista} da '. / Modelli / List'importare 'rxjs / add / operator / map';@Injectable   export class ListService {costruttore (privato http: Http) {}private serverApi = 'http: // localhost: 3000';public getAllLists   : Observable  {lascia URI = `$ {questo. serverApi} / bucketlist / `;restituiscilo. http. ottenere (URI). map (res => res. json   ). mappa (res =>  elenchi res);}public deleteList (listId: string) {lascia URI = `$ {questo. serverApi} / bucketlist / $ {} listid `;lascia intestazione = nuove intestazioni;intestazioni. append ('Content-Type', 'application / json');restituiscilo. http. delete (URI, {headers}). map (res => res. json   );}}    

Il processo sottostante è abbastanza semplice per entrambi i metodi:

  1. costruiamo un URL basato sul nostro indirizzo del server
  2. creiamo nuove intestazioni e le aggiungiamo con {Content-Type: application / json}
  3. eseguiamo l'effettivo http. get / http. elimina nell'URL
  4. Trasformiamo la risposta in formato json .

Se non si ha familiarità con i servizi di scrittura che comunicano con il server, si consiglia di leggere il tutorial su Angular e RxJS: Creare un servizio API per parlare con un backend REST.

Passare a http: // localhost: 4200 / per assicurarsi che l'app funzioni. Dovrebbe avere una tabella che visualizza tutte le liste che abbiamo creato in precedenza.

Componente aggiuntivo

Tuttavia, ci manca una funzionalità. La nostra applicazione non ha un meccanismo per aggiungere / creare nuovi elenchi e aggiornare automaticamente ViewListComponent quando viene creato l'elenco. Completiamo questo vuoto.

Il modello di AddListComponent è il luogo in cui inseriremo il codice per il nostro modulo HTML.

     
">
February 28, 2018