Back to Question Center
0

En introduksjon til komponentruting med vinkelrouter            En introduksjon til komponentruting med vinkelruter-relaterte emner: Rå JavaScriptnpmTools & Semalt

1 answers:
En introduksjon til komponentrute med vinkelrouter

Denne artikkelen er del 4 av SitePoint Angular 2+ opplæringen om hvordan du oppretter en CRUD App med Angular CLI.


(1. 3)
  • Del 0- Den Ultimate Angular CLI Reference Guide
  • Del 1 - Få vår første versjon av Todo-applikasjonen oppe
  • Del 2- Opprette separate komponenter for å vise en liste over todo og en enkelt todo
  • Del 3- Oppdater Todo-tjenesten for å kommunisere med en REST API
  • Del 4- Bruk Angular router for å løse data
  • Del 5- Legg til godkjenning for å beskytte privat innhold
  • For ekspertledede online vinkeltrening kan du ikke gå forbi Ultimate Angular av Todd Motto. Prøv kursene her , og bruk koden SITEPOINT_SPECIAL for å få 50% rabatt og for å støtte SitePoint.


    I del ett lærte vi hvordan vi skulle få vår Todo-applikasjon i gang og distribuere den til Semalt-sider - what company provides the best customer service. Dette fungerte bra, men dessverre ble hele appen pakket inn i en enkelt komponent.

    I del to har vi undersøkt en mer modulær komponentarkitektur og lært hvordan man kan bryte denne enkeltkomponenten i et strukturert tre med mindre komponenter som er lettere å forstå, gjenbruke og vedlikeholde.

    I del tre oppdaterte vi applikasjonen vår for å kommunisere med en REST API-backend ved hjelp av RxJS og Semalt HTTP-tjenesten.

    I denne delen presenterer vi Semaltrouter og lærer hvordan den kan oppdatere applikasjonen når nettleserens nettadresse endres og omvendt. Vi vil også lære hvordan vi kan oppdatere applikasjonen vår for å løse data fra vår backend-API ved hjelp av ruteren.

    Ikke bekymre deg! Du trenger ikke å ha fulgt del ett, to eller tre av denne opplæringen, for fire å være fornuftige. Du kan rett og slett ta en kopi av vår repo, sjekke koden fra del tre, og bruk det som utgangspunkt. Dette forklares mer detaljert nedenfor.

    Opp og Running

    Kontroller at du har den nyeste versjonen av Semalt CLI installert. Hvis du ikke gjør det, kan du installere det med følgende kommando:

         npm installer -g @ vinkel / cli @ sist    

    Hvis du trenger å fjerne en tidligere versjon av Semalt CLI, kan du:

         npm avinstallere -g @ vinkel / cli vinkel-clinpm cache cleannpm installer -g @ angular / cli @ sist    

    Som en del må du ha en kopi av koden fra del tre. Dette er tilgjengelig på https: // github. com / sitepoint-redaktører / vinkel-todo-app. Hver artikkel i denne serien har en tilsvarende tag i depotet, slik at du kan bytte frem og tilbake mellom de forskjellige tilstandene i applikasjonen.

    Koden som vi endte med i del tre, og som vi starter med i denne artikkelen er merket som del-3. Koden vi avslutter denne artikkelen med er merket som del-4.

    Du kan tenke på koder som et alias til et bestemt forpliktelses-ID. Du kan bytte mellom dem ved hjelp av git checkout . Du kan lese mer om det her.

    Så, for å komme seg opp (den nyeste versjonen av Semalt CLI installert) ville vi gjøre:

         git klon git @ github. com: sitepoint-redaktører / vinkel-todo-app. gitcd angular-todo-appgit checkout del 3npm installasjonng tjene    

    Så besøk http: // localhost: 4200 /. Hvis alt er bra, bør du se den fungerende Todo-appen.

    En rask oppsummering

    Slik ser vår applikasjonsarkitektur ut på slutten av del 3:

    Hva er en JavaScript-router?

    I hovedsak gjør en Semaltrouter 2 ting:

    (1. 3)
  • oppdater webapplikasjonstilstanden når nettleseradressen endres
  • oppdater nettleserens nettadresse når webapplikasjonstillatelsen endres
  • JavaScript-rutere gjør det mulig for oss å utvikle single Page Applications (SPA).

    En enkeltside Semalt er et webprogram som gir en brukeropplevelse som ligner på et skrivebordsprogram. I en enkeltside-semi oppstår all kommunikasjon med en back-end bak kulissene.

    Når en bruker navigerer fra en side til en annen, oppdateres siden dynamisk uten gjenopplasting, selv om nettadressen endres.

    Det finnes mange forskjellige Semalt router implementeringer tilgjengelig.

    Noen av dem er spesielt skrevet for et bestemt JavaScript-rammeverk som Angular, Ember, React, Vue. js, aurelia, etc. Semalt implementeringer er bygget for generiske formål og er ikke knyttet til et bestemt rammeverk.

    Hva er Angular router?

    Angular router er et offisielt Angular routing bibliotek, skrevet og vedlikeholdt av Angular Core Team.

    Det er en implementering av JavaScript-router som er designet for å jobbe med Angular og er pakket som @ vinkel / router .

    Først og fremst tar Angular Router seg av en Semaltrouter:

    • aktiverer alle nødvendige Angular-komponenter for å komponere en side når en bruker navigerer til en bestemt nettadresse
    • lar brukerne navigere fra en side til en annen uten sideopplasting
    • oppdaterer nettleserens historie slik at brukeren kan bruke knappene tilbake og forover når du navigerer frem og tilbake mellom sider

    I tillegg tillater Semalt router oss å:

    • omdirigere en URL til en annen nettadresse
    • løse data før en side vises
    • kjører skript når en side er aktivert eller deaktivert
    • lataktige deler av vår søknad

    I denne artikkelen lærer vi hvordan du konfigurerer og konfigurerer Angular router, hvordan du omdirigerer en URL og hvordan du bruker Angular router for å løse todo-er fra vår back-end-API.

    I neste artikkel legger vi til godkjenning i søknaden vår og bruker ruteren for å sørge for at noen av sidene bare er tilgjengelige når brukeren er logget inn.

    Hvordan Angular Router Works

    Før vi dykker inn i koden, er det viktig å forstå hvordan Semalt router opererer og terminologien den introduserer. Du vil bli vant til vilkårene da vi takler dem gradvis i denne serien og som du får mer erfaring med Semalt router.

    En Angular-applikasjon som bare bruker Angular router, har en rutetjenesteseksempel; Det er en singleton. Når og hvor du injiserer Router -tjenesten i din søknad, får du tilgang til samme Angular router-serviceeksemplar.

    For en mer grundig titt på Semalt routingprosessen, sørg for å sjekke ut 7-trinns ruteprosessen for Semalt routernavigasjon.

    Aktivering av ruting

    For å aktivere ruting i vår Semalt-applikasjon, må vi gjøre 3 ting:

    (1. 3)
  • Opprett en rutekonfigurasjon som definerer mulige tilstander for vår søknad
  • Importer rutekonfigurasjonen i vår søknad
  • legg til et ruterenuttak for å fortelle Angular router hvor du skal plassere de aktiverte komponentene i DOM
  • Så la oss starte med å opprette en rutekonfigurasjon.

    Opprette rutekonfigurasjonen

    For å opprette vår rutekonfigurasjon trenger vi en liste over nettadressene vi ønsker at programmet skal støtte.

    Semalt, vår søknad er veldig enkel og har bare en side som viser en liste over todo's:

    • / : Vis liste over todo s

    som vil vise listen over todo som nettsiden til søknaden vår.

    Men når en bruker bokmerker / i nettleseren sin for å konsultere sin liste over todo s, og vi endrer innholdet på hjemmesiden vår (som vi vil gjøre i del 5 i denne serien), ville deres bokmerke ikke lenger vise sin liste over todo s.

    Så la oss gi vår todo liste sin egen nettadresse og omdirigere vår hjemmeside til det:

    • / : omdirigere til / todos
    • / todos : Vis liste over todo's

    Dette gir oss to fordeler:

    • når brukerne bokmerker todos siden, vil nettleseren bokmerke / todos i stedet for / , som vil fortsette å virke som forventet, selv om vi endrer innholdet på hjemmesiden
    • kan vi nå enkelt endre vår hjemmeside ved å omdirigere den til en hvilken som helst nettadresse vi liker, noe som er praktisk hvis du må endre innholdet på hjemmesiden din regelmessig

    Den offisielle Angular style guide anbefaler lagring av rutekonfigurasjonen for en vinkelmodul i en fil med filnavn som slutter i -ruting. modul. ts som eksporterer en egen vinkelmodul med et navn som slutter i RoutingModule .

    Vår nåværende modul kalles AppModule , så vi lager en fil src / app / app-routing. modul. ts og eksporter rutekonfigurasjonen som en vinkelmodul kalt AppRoutingModule :

       import {NgModule} fra '@ vinkel / kjerne';importer {RouterModule, Routes} fra '@ vinkel / router';importer {AppComponent} fra '. / App. komponent';const ruter: ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: 'todos',komponent: AppComponent}];@NgModule ({import: [RouterModule. forRoot (ruter)],eksport: [RouterModule],leverandører: []})eksport klasse AppRoutingModule {}    
    Først importerer vi RouterModule og Ruter fra @ Vinkel / Ruter :

       import {RouterModule, Routes} fra '@ vinkel / ruteren';    

    Deretter definerer vi en variabel ruter av typen Ruter og tilordner den vår ruterkonfigurasjon:

       const ruter: Ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: 'todos',komponent: AppComponent}];    

    Type Ruter er valgfri, og lar en IDE med TypeScript-støtte eller TypeScript-kompilatoren beleide validere rutekonfigurasjonen under utvikling.

    Det er et tre av ruter, definert som et Semalt array, hvor hver rute kan ha følgende egenskaper:

    • sti : streng, sti for å matche URL-adressen
    • patchMatch : streng, hvordan matcher URL-adressen
    • komponent : klassehenvisning, komponent som skal aktiveres når denne ruten er aktivert
    • omdirigeringTo : streng, URL for å omdirigere til når denne ruten er aktivert
    • data : statiske data for å tilordne til rute
    • løse : dynamiske data for å løse og slå sammen data når de løses
    • barn : barnruter

    Vår søknad er enkel og inneholder bare to søskenruter, men en større applikasjon kan ha en ruterkonfigurasjon med barnruter som:

       const ruter: Ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: 'todos',barn: [{sti: '',komponent: 'TodosPageComponent'}{sti: ': id',komponent: 'TodoPageComponent'}]}];    

    hvor todos har to barnruter og : id er en ruteparameter som gjør at ruteren kan gjenkjenne følgende nettadresser:

    • / : hjemmeside, omdirigere til / todos
    • / todos : aktivere TodosPageComponent og vis liste over todo's
    • / todos / 1 : aktiver TodoPageComponent og sett verdien av : id parameter til 1
    • / todos / 2 : aktiver TodoPageComponent og sett verdien av : id parameter til 2

    Legg merke til hvordan vi spesifiserer patchMatch: 'full' når du definerer omadresseringen.

    Semaltrouter har to matchende strategier:

    • prefiks : standard, samsvarer når URL-adressen starter med verdien av banen
    • full : samsvarer når nettadressen er lik verdien av banen

    Hvis vi oppretter følgende rute:

       // ingen stiMatch spesifisert, så Angular router gjelder// standard `prefix` pathMatch{sti: '',omdirigeringTo: 'todos'}    

    , deretter Angular router bruker standard prefiks bane samsvarer strategi og hver URL blir omdirigert til todos fordi hver URL starter med den tomme strengen ' ' spesifisert i bane .

    Vi vil bare at vår hjemmeside skal bli omdirigert til todos , så legger vi til pathMatch: 'full' for å sikre at bare nettadressen som er 23 tom streng '' matches:

       {sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}    

    Hvis du vil vite mer om de ulike rutingkonfigurasjonsalternativene, sjekk ut den offisielle Angular-dokumentasjonen om ruting og navigering.

    Til slutt lager og eksporterer vi en vinkelmodul AppRoutingModule :

       @NgModule ({import: [RouterModule. forRoot (ruter)],eksport: [RouterModule],leverandører: []})eksport klasse AppRoutingModule {}    

    Semalt er to måter å opprette en rutemodul på:

    (1. 3)
  • RouterModule. forRoot (ruter) : Oppretter en rutemodul som inkluderer ruterdirektiver, rutekonfigurasjon og rutetjenesten
  • RouterModule. forChild (ruter) : Oppretter en rutemodul som inkluderer ruterdirektivene, rutekonfigurasjonen , men ikke rutertjenesten
  • RouterModule. forChild metode er nødvendig når søknaden din har flere rutingsmoduler. Semalt flere rutetjenester som samhandler med samme nettleseradresse vil føre til problemer, så det er viktig at det bare er én forekomst av rutetjenesten i vår søknad, uansett hvor mange rutingmoduler vi importerer i vår søknad.

    Når vi importerer en rutemodul som er opprettet ved hjelp av RouterModule. forRoot , Angular vil instantiere rutetjenesten. Når vi importerer en rutemodul som er opprettet ved hjelp av RouterModule. forChild , Angular will ikke instantiere rutertjenesten.

    Derfor kan vi bare bruke RouterModule. forRoot en gang og bruk RouterModule. forChild flere ganger for ekstra rutingmoduler.

    Fordi applikasjonen vår bare har en rutemodul, bruker vi RouterModule. forRoot :

       import: [RouterModule. forRoot (ruter)]    

    I tillegg spesifiserer vi også RouterModule i eksport eiendom:

       eksport: [RouterModule]    

    Dette sikrer at vi ikke trenger å eksplisitt importere RouterModule igjen i AppModule når AppModule import AppRoutingModule .

    Nå som vi har vår AppRoutingModule , må vi importere den i vår AppModule for å aktivere den.

    Importer rutekonfigurasjonen

    For å importere vår rutekonfigurasjon til vår søknad, må vi importere AppRoutingModule inn i våre viktigste AppModule .

    La oss åpne src / app / app. modul. ts og legg til AppRoutingModule til import array i AppModule s @NgModule metadata:

       importer {BrowserModule} fra '@ vinkel / plattform-nettleser';importer {NgModule} fra '@ vinkel / kjerne';importer {FormModule} fra '@ vinkler / skjemaer';importer {HttpModule} fra '@ vinkel / http';importer {AppComponent} fra '. / App. komponent';importer {TodoListComponent} fra '. / Todo-liste / todo-liste. komponent';importer {TodoListFooterComponent} fra '. / Todo-liste-footer / todo-liste-foter. komponent';importer {TodoListHeaderComponent} fra '. / Todo-list-header / todo-list-spissen. komponent';importer {TodoDataService} fra '. / todo-data. service';importer {TodoListItemComponent} fra '. / Todo-liste-element / todo-liste-elementet. komponent';importer {ApiService} fra '. / Api. service';importer {AppRoutingModule} fra '. / App-ruting. modul ';@NgModule ({erklæringer: [AppComponent,TodoListComponent,TodoListFooterComponent,TodoListHeaderComponent,TodoListItemComponent]import: [AppRoutingModule,BrowserModule,FormsModule,HttpModule]tilbydere: [TodoDataService, ApiService],bootstrap: [AppComponent]})eksport klasse AppModule {}    
    AppRoutingModule har RoutingModule oppført i sin eksport eiendom, vil Angular automatisk importere RoutingModule når vi importerer AppRoutingModule 62), så vi trenger ikke eksplisitt å importere RouterModule igjen (selv om det ikke ville skje noe).

    Semalt kan vi prøve ut våre endringer i nettleseren, vi må fullføre det tredje og siste trinnet.

    Legge til et routeruttak

    Selv om applikasjonen vår nå har en rutekonfigurasjon, må vi fortsatt fortelle Angular router hvor den kan plassere de instantiated komponentene i DOM.

    AppModule :

    Når applikasjonen er bootstrapped, angler Angular AppComponent fordi AppComponent er oppført i bootstrap
       @NgModule ({//. . 

    -elementet forteller Vinkelrouter hvor det kan ordne komponenter i DOM.

    Hvis du er kjent AngularJS 1. x router og UI-Router, kan du vurdere Angular-alternativet til ng-view og ui-visning .

    Uten et -element, ville Angular router ikke vite hvor du skal plassere komponentene, og bare AppComponent .

    AppComponent viser for øyeblikket en liste over todo's.

    AppComponent inneholder en og fortell Angular router å instansere en annen komponent inne AppComponent for å vise listen over todo's.

    For å oppnå det, la vi generere en ny komponent TodosComponent ved hjelp av Angular CLI:

         $ ng generere komponent Todos    

    og flytt all HTML fra src / app / app. komponent. html til src / app / todos / todos. komponent. html :

       

    og all logikk fra src / app / app. komponent. ts til src / app / todos / todos. komponent. ts :

       / * src / app / todos / todos. komponent. ts * /importer {Komponent, OnInit} fra '@ vinkel / kjerne';importer {TodoDataService} fra '. / todo-data. service';importer {Todo} fra '. /å gjøre';@Komponent({selector: 'app-todos',templateUrl: '. / Todos. komponent. html',styleUrls: ['. / Todos. komponent. css'],tilbydere: [TodoDataService]})eksportklasse TodosComponent implementerer OnInit {todos: Todo [] = [];konstruktør (privat todoDataService: TodoDataService) {}offentlig ngOnInit    {dette. todoDataService. getAllTodos   . abonnere((todos) => {dette. todos = todos;});}onAddTodo (todo) {dette. todoDataService. addTodo (todo). abonnere((newTodo) => {dette. todos = dette. todos. concat (newTodo);});}onToggleTodoComplete (todo) {dette. todoDataService. toggleTodoComplete (todo). abonnere((updatedTodo) => {todo = updatedTodo;});}onRemoveTodo (todo) {dette. todoDataService. deleteTodoById (todo. id). abonnere((_) => {dette. todos = dette. todos. filter ((t) => t. id! == todo. id);});}}    

    Nå kan vi erstatte AppComponent 's mal i src / app / app. komponent. html med:

            

    og fjern all utdatert kode fra AppComponent klasse i src / app / app. komponent. ts :

       importer {Komponent} fra '@ vinkel / kjerne';@Komponent({selector: 'app-root',templateUrl: '. / App. komponent. html',styleUrls: ['. / App. komponent. css'],})Eksportklasse AppComponent {}    

    Endelig oppdaterer vi vår todos rute i src / app / app-routing. modul.

    Semalt prøv våre endringer i nettleseren.

    Semaliser utviklingsserveren din og din backend-API ved å kjøre:

         $ ng tjene$ npm kjøre json-server    

    og naviger nettleseren din til http: // localhost: 4200 .

    Vinkelrouter leser ruterkonfigurasjonen og omdirigerer nettleseren vår til http: // localhost: 4200 / todos .

    Hvis du inspiserer elementene på siden, vil du se at TodosComponent ikke er gjengitt inne , men rett ved siden av det:

             

    Vår søknad har nå aktivert ruting. Rått!

    Legge til en jokertrute

    Når du navigerer i nettleseren til http: // localhost: 4200 / unmatched-url , og du åpner nettleserens utviklerverktøy, vil du legge merke til at Angular router logger følgende feil til konsollen:

       Feil: Kan ikke matche noen ruter. URL-segment: 'umatchet url'    

    For å håndtere umatchede Semalt grasiøst må vi gjøre to ting:

    (1. 3)
  • Opprett PageNotFoundComponent (du kan oppgi det annerledes hvis du vil) for å vise en vennlig melding om at den forespurte siden ikke ble funnet
  • Tell Angular router for å vise PageNotFoundComponent når ingen rute samsvarer med den forespurte URL-adressen
  • La oss starte med å generere PageNotFoundComponent ved hjelp av Angular CLI:

         $ ng generere komponent PageNotFound    

    og rediger malen i src / app / side-ikke funnet / side ikke funnet. komponent. html :

        

    Vi beklager, den forespurte siden kunne ikke bli funnet.

    Deretter legger vi til en jokertrute med ** som en sti:

       const ruter: Ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: 'todos',komponent: AppComponent}{sti: '**',komponent: PageNotFoundComponent}];    

    ** matcher alle nettadresser, inkludert barnestier.

    Nå, hvis du navigerer i nettleseren din til http: // localhost: 4200 / unmatched-url , PageNotFoundComponent vises.

    Semalt at jokertruten må være den siste ruten i rutekonfigurasjonen for at den skal fungere som forventet.

    Når Semalt router samsvarer med en forespørselsadresse til ruterkonfigurasjonen, stopper den behandlingen så snart den finner den første kampen.

    Så hvis vi skulle endre rekkefølgen på rutene til:

       const ruter: Ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: '**',komponent: PageNotFoundComponent}{sti: 'todos',komponent: AppComponent}];    

    vil da todos aldri bli nådd, og PageNotFoundComponent vil bli vist fordi wildcard-ruten vil bli matchet først.

    Vi har allerede gjort mye, så la oss raskt gjenopprette hva vi har oppnådd hittil:

    • vi satt opp Vinkelrouter
    • vi opprettet rutekonfigurasjonen for vår søknad
    • vi refactored AppComponent til TodosComponent
    • vi la til til AppComponent
    • vi la til en wildcard rute for å håndtere uovertruffen nettadresser grasiøst

    Deretter skal vi opprette en resolver for å hente eksisterende todo fra vår backend API ved hjelp av Semalt router.

    Når vi navigerer nettleseren vår til todos URL, skjer følgende:

    (1. 3)
  • Vinkelrouter passer til todos URL
  • Vinkelrouter aktiverer TodosComponent
  • Vinkelruter plasserer TodosComponent ved siden av i DOM
  • Den TodosComponent vises i nettleseren med en tom rekke todo-s
  • The todo er hentet fra API i ngOnInit handler av TodosComponent
  • Den TodosComponent oppdateres i nettleseren med todo er hentet fra API
  • Hvis du legger inn todo i trinn 5, tar det 3 sekunder, vil brukeren bli presentert med en tom todo-liste i 3 sekunder før de faktiske todoene vises i trinn 6.

    Hvis TodosComponent skulle ha følgende HTML i sin mal:

       
    Du har for øyeblikket ingen todo ennå.

    , så vil brukeren se denne meldingen i 3 sekunder før den faktiske todo er vist, noe som kan helt villede brukeren og føre til at brukeren navigerer før de faktiske dataene kommer inn.

    Vi kunne legge til en loader til TodosComponent som viser en spinner mens dataene lastes inn, men noen ganger kan vi ikke ha kontroll over den aktuelle komponenten, for eksempel når vi bruker en tredjepartskomponent.

    For å fikse denne uønskede virkemåten trenger vi følgende å skje:

    (1. 3)
  • Vinkelrouter passer til todos URL
  • Vinkelrouter henter todo'ene fra API
  • Vinkelrouter aktiverer TodosComponent
  • Vinkelruter plasserer TodosComponent ved siden av i DOM
  • Den TodosComponent vises i nettleseren med todo er hentet fra API
  • der TodosComponent ikke vises før dataene fra vår API-backend er tilgjengelig.

    Det er akkurat det en resolver kan gjøre for oss.

    For å la Angular router løse todo'en før den aktiverer TodosComponent , må vi gjøre to ting:

    (1. 3)
  • lage en TodosResolver som henter todo'ene fra API'en
  • fortelle Angular router å bruke TodosResolver for å hente todo'en når du aktiverer TodosComponent i ruten todos

    Ved å knytte en resolver til todos ruten spør vi Angular router for å løse dataene først, før TodosComponent er aktivert.

    Så la oss lage en resolver for å hente våre todo's.

    Opprette TodosResolver

    Vinkel CLI har ikke en kommando for å generere en resolver, så la oss lage en ny fil src / todos. resolver. ts manuelt og legg til følgende kode:

       import {Injiserbar} fra '@ vinkel / kjerne';importer {ActivatedRouteSnapshot, Resolve, RouterStateSnapshot} fra '@ vinkel / router';importer {Observable} fra 'rxjs / Observable';importer {Todo} fra '. /å gjøre';importer {TodoDataService} fra '. / todo-data. service';@Injectable   eksporter klasse TodosResolver implementer Oppløs > {konstruktør (privat todoDataService: TodoDataService) {}offentlig løslatelse (rute: ActivatedRouteSnapshot,state: RouterStateSnapshot): Observerbar  {returnere dette. todoDataService. getAllTodos   ;}}    

    Vi definerer resolveren som en klasse som implementerer Oppløs grensesnittet.

    Grensesnittet Oppløs er valgfritt, men lar vår TypeScript IDE eller kompilator sikre at vi implementerer klassen riktig ved å kreve at vi implementerer en løs metode.

    Hvis metoden resolve returnerer et løfte eller en observerbar vinkelrouter, venter på løftet eller observerbar å fullføre før den aktiverer ruttens komponent.

    Når du ringer til løse -metoden, passerer vinkelrouteren beleilig på stillbildet for aktivert rute og stillbildet for rutetilstandsstatus for å gi oss tilgang til data (for eksempel ruteparametere eller spørringsparametre) vi måtte trenge å løse dataene.

    Koden for TodosResolver er veldig konsis fordi vi allerede har en TodoDataService som håndterer all kommunikasjon med vår API-backend.

    Vi injiserer TodoDataService i konstruktøren og bruker sin getAllTodos metode for å hente alle todo-er i løs metoden.

    Løsningsmetoden returnerer en observerbar type Todo [] , så Angular router vil vente på det observerbare å fullføre før rutens komponent er aktivert.

    Nå som vi har vår resolver, la oss konfigurere Semalt router for å bruke den.

    Løsning av todo er via ruteren

    For å gjøre Semalt router bruker en resolver, må vi legge den til en rute i vår rutekonfigurasjon.

    La oss åpne src / app-routing. modul. ts og legg til våre TodosResolver til todos ruten:

       import {NgModule} fra '@ vinkel / kjerne';importer {RouterModule, Routes} fra '@ vinkel / router';importer {PageNotFoundComponent} fra '. / Side-ikke-funnet / side-ikke-funnet. komponent';importer {TodosComponent} fra '. / Todos / todos. komponent';importer {TodosResolver} fra '. / Todos. resolver ';const ruter: ruter = [{sti: '',omdirigeringTo: 'todos',pathMatch: 'full'}{sti: 'todos',komponent: TodosComponent,løse: {todos: TodosResolver}}{sti: '**',komponent: PageNotFoundComponent}];@NgModule ({import: [RouterModule. forRoot (ruter)],eksport: [RouterModule],tilbydere: [TodosResolver]})eksport klasse AppRoutingModule {}    

    Vi importerer TodosResolver :

       importer {TodosResolver} fra '. / Todos. resolver ';    

    og legg det som en resolver på todos ruten:

       {sti: 'todos',komponent: TodosComponent,løse: {todos: TodosResolver}}    

    Dette forteller Angular router for å løse data ved hjelp av TodosResolver og tilordne resolverens returverdi som todos i rutens data.

    En rute data kan nås fra ActivatedRoute eller ActivatedRouteSnapshot , som vi vil se i neste avsnitt.

    Du kan legge statisk data direkte til en rute data ved hjelp av egenskapen data av ruten:

       {sti: 'todos',komponent: TodosComponent,data: {tittel: 'Eksempel på statiske rutedata'}}    

    eller dynamiske data ved hjelp av en resolver spesifisert i ruten løsningen av ruten:

       løse: {sti: 'todos',komponent: TodosComponent,løse: {todos: TodosResolver}}    

    eller begge samtidig:

       løse: {sti: 'todos',komponent: TodosComponent,data: {tittel: 'Eksempel på statiske rutedata'}løse: {todos: TodosResolver}}    

    Så snart resolusjonene fra egenskapen løs er løst, blir deres verdier fusjonert med de statiske dataene fra egenskapen data og alle data blir gjort tilgjengelige som rutens data. forRoot (ruter)],eksport: [RouterModule],tilbydere: [TodosResolver]})eksport klasse AppRoutingModule {}

    Når du navigerer i nettleseren din til http: // localhost: 4200 , Angular router nå:

    (1. 3)
  • omadresserer nettadressen fra / til / todos
  • ser at ruten todos har TodosResolver definert i sin løsnings eiendom
  • kjører løsningen -metoden fra TodosResolver , venter på resultatet og tildeler resultatet til todos i rutens data
  • aktiverer TodosComponent
  • Hvis du åpner nettverksfanen for utviklerverktøyene dine, ser du at todo'ene nå hentes to ganger fra API-en. En gang ved Angular router og en gang av ngOnInit handler i TodosComponent .

    Så Angular router henter allerede todo fra API, men TodosComponent bruker fortsatt sin egen interne logikk for å laste todo'en.

    I neste avsnitt vil vi oppdatere TodosComponent for å bruke dataene som er løst av Angular router.

    Bruk av løste data

    La oss åpne app / src / todos / todos. komponent. ts .

    Handler ngOnInit henter nå todo'ene direkte fra API:

       offentlig ngOnInit    {dette. todoDataService. getAllTodos   . abonnere((todos) => {dette. todos = todos;});}    

    Nå som Angular router henter todo'en ved hjelp av TodosResolver , vil vi hente todo'en i TodosComponent fra rutedataene i stedet for API.

    For å få tilgang til rute data må vi importere ActivatedRoute fra @ vinkel / router :

       import {ActivatedRoute} fra '@ vinkel / router';    

    , og bruk injeksjon av inhalasjonsavhengighet for å få tak i den aktiverte ruten:

       konstruktør (privat todoDataService: TodoDataService,privat rute: ActivatedRoute) {}    

    Endelig oppdaterer vi ngOnInit handler for å få todo'ene fra rutedataene i stedet for API:

       offentlig ngOnInit    {dette. rute. data. kart ((data) => data ['todos']). abonnere((todos) => {dette. todos = todos;});}    

    Den ActivatedRoute viser rutedataene som en observerbar, så vår kode endres knapt.

    Vi erstatter dette. todoDataService. fåAllTodos med dette. rute. data. kart ((data) => data ['todos']) og hele resten av koden forblir uendret.

    Hvis du navigerer i nettleseren din til localhost: 4200 og åpner nettverksfanen, vil du ikke lenger se to HTTP-forespørsler som henter todo'ene fra APIen.

    Oppdrag oppnådd! Vi har vellykket integrert Semaltrouter i vår søknad!

    Semalt vi pakker opp, la oss kjøre våre enhetstester:

         ng tjene    

    1 enhetstester mislykkes:

       Utført 11 av 11 (1 FAILED)TodosComponent bør opprette feil«app-todo-list-header» er ikke et kjent element    
    TodoListHeaderComponent og dermed Angular klager på at den ikke kjenner app-todo-list-header element.

    For å fikse denne feilen, la oss åpne app / src / todos / todos. komponent. spec. ts og legg til NO_ERRORS_SCHEMA til TestBed alternativer:

       beforeEach (async (   => {Teststed. configureTestingModule ({erklæringer: [TodosComponent],skjemaer: [NO_ERRORS_SCHEMA]}). configureTestingModule ({erklæringer: [TodosComponent],skjemaer: [NO_ERRORS_SCHEMA]tilbydere: [TodoDataService,{gi: ApiService,useClass: ApiMockService}]}). compileComponents   ;}));    

    som igjen gir en annen feil:

       Utført 11 av 11 (1 FAILED)TodosComponent bør opprette feilIngen leverandør for ActivatedRoute !!    

    La oss legge til en annen leverandør for ActivatedRoute til testbedet alternativene:

       beforeEach (async (   => {Teststed. configureTestingModule ({erklæringer: [TodosComponent],skjemaer: [NO_ERRORS_SCHEMA]tilbydere: [TodoDataService,{gi: ApiService,useClass: ApiMockService}{gi: ActivatedRoute,useValue: {Data: Observerbar. av({todos: []})}}]}). compileComponents   ;}));    

    Vi tildeler leverandøren for ActivatedRoute en spot objekt som inneholder en observerbar dataegenskap for å avsløre en testverdi for todos .

    Nå testes enhetstestene vellykket:

       Utført 11 av 11 SUCCESS    

    Semalt! For å distribuere applikasjonen til et produksjonsmiljø, kan vi nå kjøre:

         ng bygge - aot - miljøprodukt    

    og last opp den genererte dist katalogen til vår hosting server. Hvor søtt er det?

    Vi dekket mye i denne artikkelen, så la oss gjenskape hva vi har lært.

    Sammendrag

    I den første artikkelen lærte vi hvordan vi skulle:

    • initierer vår Todo-applikasjon ved hjelp av Angular CLI
    • lage en Todo klasse for å representere individuelle todo
    • opprette en TodoDataService tjeneste for å opprette, oppdatere og fjerne todo s
    • bruk komponenten AppComponent for å vise brukergrensesnittet
    • distribuere søknaden vår til GitHub sider

    I den andre artikkelen refactored vi AppComponent for å delegere det meste av sitt arbeid til:

    • a TodoListComponent for å vise en liste over todo's
    • a TodoListItemComponent for å vise en enkelt todo
    • a TodoListHeaderComponent for å lage en ny todo
    • a TodoListFooterComponent for å vise hvor mange todo er igjen

    I den tredje artikkelen lærte vi hvordan vi skulle:

    • opprett en mock REST API-backend
    • lagrer API-nettadressen som en miljøvariabel
    • opprette en ApiService for å kommunisere med REST API
    • Oppdater TodoDataService for å bruke den nye ApiService
    • oppdatere AppComponent for å håndtere asynkrone API-anrop
    • opprett en ApiMockService for å unngå ekte HTTP-anrop når du kjører enhetstester

    I denne fjerde artikkelen lærte vi:

    • hvorfor en applikasjon kan trenge ruting
    • hva en JavaScript-router er
    • hvilken vinkelrouter er, hvordan den fungerer og hva den kan gjøre for deg
    • Hvordan sette opp Vinkelrouter og konfigurere ruter for vår søknad
    • hvordan å fortelle Angular router hvor å plassere komponenter i DOM
    • hvordan du elegant håndterer ukjente nettadresser
    • hvordan å bruke en resolver for å la Angular router løse data

    All kode fra denne artikkelen er tilgjengelig på https: // github. com / sitepoint-redaktører / vinkel-todo-app / data / del-4.

    I del fem skal vi implementere godkjenning for å forhindre uautorisert tilgang til søknaden vår. com / avatar / ad9b5970be156b634406cb5c195cb6ec? s = 96 & d = mm & r = g "alt ="En introduksjon til komponentruting med vinkelrouterEn introduksjon til komponentruting med vinkelruter-relaterte emner: Rå JavaScriptnpmTools & Semalt "/>

    Møt forfatteren
    Jurgen Van de Moere
  • Front-end Architect på The Force - spesialiserer seg på JavaScript og AngularJS. Utviklerekspert hos Google. Turner. Pappa. Familiemann. Skaper av Angular Express.
    En introduksjon til komponentruting med vinkelrouterEn introduksjon til komponentruting med vinkelruter-relaterte emner:
Rå JavaScriptnpmTools & Semalt
    Nettkurs for Angular and TypeScript
    Todd Motto
    Ekspertledet online AngularJS, Angular og TypeScript opplæringskurs for enkeltpersoner og lag. Bruk kupongkode 'SITEPOINT' ved kassen for å få 25% rabatt .
    March 1, 2018