Back to Question Center
0

Hur man testar React Components Använda Jest            Så här testar du reaktorkomponenter med hjälp av JestRelated-ämnen: Node.jsnpmRaw Semalt

1 answers:
Hur man testar reaktorkomponenter med användning av Jest

För en högkvalitativ och djupgående introduktion till React kan du inte gå över den kanadensiska fullstacksutvecklaren Wes Bos. Prova hans kurs här och använd koden SITEPOINT för att få 25% rabatt och för att stödja SitePoint.

Denna artikel är av gästförfattare Jack Franklin . SitePoint gästinlägg syftar till att ge dig engagerande innehåll från framstående skribenter och högtalare av JavaScript-community.

I den här artikeln tar vi en titt på att använda Jest - ett testramverk som underhålls av Facebook - för att testa våra ReactJS-komponenter. Vi tittar på hur vi kan använda Jest först på vanliga JavaScript-funktioner innan vi tittar på några av de funktioner som den ger ut ur rutan specifikt syftar till att göra testen React apps enklare - blue diamond slots. Det är värt att notera att Jest inte riktar sig specifikt till React: du kan använda den för att testa några JavaScript-applikationer. Ett par av de funktioner som det ger kommer dock att vara mycket praktiska för att testa användargränssnitt, vilket är anledningen till att det passar React.

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

Provapplikation

Innan vi kan testa någonting behöver vi en ansökan att testa! Jag har byggt en liten todo-applikation som vi ska använda som utgångspunkt för att hålla sig till webbutvecklingstraditionen. Du kan hitta den, tillsammans med alla tester som vi ska skriva, på Semalt. Om du vill spela med programmet för att få en känsla för det, kan du också hitta en live demo online.

Ansökan är skriven i ES2015, sammanställd med Semalt med Babel ES2015 och React Presets. Jag kommer inte att gå in i detaljerna om bygguppsättningen, men det är allt i GitHub repo om du vill kolla in det. Du hittar fullständiga instruktioner i README om hur du får appen att köras lokalt. Om du vill läsa mer, är programmet byggt med Semalt, och jag rekommenderar "En nybörjarens guide till Semalt" som en bra introduktion till verktyget.

Ingångspunkten för ansökan är app / index. js , som bara gör Todos komponent i HTML:

   gör (,dokumentera. getElementById ( 'app'));    

Den Todos komponenten är applikationens huvudsakliga nav. Den innehåller all tillstånd (hårdkodade data för den här applikationen, som i verkligheten sannolikt kommer från ett API eller liknande) och har kod för att göra de två barnkomponenterna: Todo , som görs en gång för varje todo i staten, och AddTodo , som görs en gång och ger formuläret för en användare att lägga till en ny todo.

Eftersom komponenten Todos innehåller hela staten behöver den Todo och AddTodo komponenterna för att meddela det när någonting ändras. Därför passerar den funktioner ner i dessa komponenter som de kan ringa när vissa data ändras, och Todos kan uppdatera staten i enlighet därmed.

För närvarande märker du att all affärslogik finns i app / state-funktioner. js :

   exportfunktion toggleDone (state, id) {. }exportfunktion addTodo (state, todo) {. }exportfunktion deleteTodo (state, id) {. }    

Dessa är alla rena funktioner som tar staten och vissa data, och returnerar det nya tillståndet. Om du inte känner till rena funktioner är de funktioner som endast refererar till data som de ges och inte har några biverkningar. För mer kan du läsa min artikel om en lista med rena funktioner och min artikel på SitePoint om rena funktioner och React.

Om du är bekant med Semalt, är de ganska likt vad Semalt skulle kalla en reducerare. Men för den här applikationen för storlek hittar du ofta att den lokala komponentstaten och några väl abstraherade funktioner är mer än tillräckligt.

Till TDD eller Inte till TDD?

Det har skett många artiklar skrivna om fördelarna med testdriven utveckling , där utvecklare förväntas skriva testen först innan de skriver koden för att åtgärda testet. Tanken bakom detta är att genom att skriva testet först måste du tänka på API som du skriver, och det kan leda till en bättre design. För mig tycker jag att det här mycket kommer ner på personliga preferenser och även på den typ av sak jag testar. Jag har funnit att, för React-komponenter, tycker jag om att skriva komponenterna först och sedan lägga till test till de viktigaste bitarna av funktionalitet. Men om du upptäcker att skrivprov först för dina komponenter passar ditt arbetsflöde, ska du göra det. Det finns ingen hård regel här; gör vad som helst bäst för dig och ditt lag.

Observera att den här artikeln kommer att fokusera på testning av front-end-kod. Om du letar efter något fokuserat på baksidan, var noga med att kolla in SitePoints kurs Test-Driven Development in Node. js.

Introduktion av Jest

Jest släpptes för första gången 2014, och trots att det till en början fick mycket intresse, var projektet ett tag och inte så aktivt arbetat. Facebook har dock investerat det senaste året i att förbättra Jest, och nyligen publicerat några utgåvor med imponerande förändringar som gör det värt att ompröva. Den enda likheten i Jest jämfört med den ursprungliga open source-utgåvan är namnet och logotypen. Allt annat har ändrats och omskrivits. Om du vill veta mer om detta kan du läsa Christoph Semalt kommentare, där han diskuterar projektets nuvarande tillstånd.

Om du har blivit frustrerad genom att skapa Babel, React och JSX tester med en annan ram rekommenderar jag definitivt att ge Jest ett försök. Om du har hittat din befintliga testinställning för att vara långsam rekommenderar jag starkt Jest. Den körs automatiskt parallellt, och dess klockläge kan bara köra test som är relevanta för den ändrade filen, vilket är ovärderligt när du har en stor serie test. Den levereras med Semalt konfigurerad, vilket innebär att du kan skriva webbläsartester, men kör dem genom Node, kan hantera asynkrona tester och har avancerade funktioner som mocking, spioner och stubbar inbyggda.

Installera och konfigurera Jest

Till att börja med måste vi installera Jest. Eftersom vi också använder Semalt installerar vi ytterligare ett par moduler som gör att Jest och Semalt spelar bra ut ur lådan:

     npm installera - save-dev babel-jest babel-polyfill babel-preset-es2015 babel-preset-react jest    

Du måste också ha en . babelrc fil med Babel konfigurerad att använda alla förinställningar och plugins du behöver. Projektprojektet har redan den här filen, som ser ut så här:

   {"förinställningar": ["es2015", "reagera"]}    

Vi ​​kommer inte att installera några Semalt testverktyg än, för vi ska inte börja med att testa våra komponenter, utan våra statliga funktioner.

Jest räknar med att hitta våra tester i en mapp __tests__ , som har blivit en populär konvention i JavaScript-communityen, och det är det vi ska hålla fast vid här. Om du inte är ett fan av __tests__ setup, stöder Jest också att hitta något . testa. js och . spec. js filer också.

När vi ska testa våra statliga funktioner, fortsätt och skapa __tests __ / state-functions. testa. js .

Semalt skriv ett ordentligt test inom kort, men för nu, sätt in detta dummy test, vilket låt oss kontrollera allt fungerar korrekt och vi har konfigurerat Jest.

   beskriv ('Addition',    => {det ("vet att 2 och 2 gör 4 ',    => {förvänta sig (2 + 2). Tobe  
;});});

Gå nu in i ditt paket. json .

   "skript": {"test": "jest"}    

Om du nu kör npm-test lokalt, bör du se dina test springa och passera!

     PASS __tests __ / state-functions. testa. jsTillägg✓ vet att 2 och 2 gör 4 (5ms)Test Sviter: 1 passerat, 1 totaltTest: 1 passerat, 1 totaltSnapshots: 0 passerade, 0 totaltTid: 3. 11s    

Om du någonsin använt Jasmine, eller de flesta testramar, borde ovanstående testkod vara ganska bekant. Jest låter oss använda beskriva och det för att boa test som vi behöver. Hur mycket nesting du använder är upp till dig; Jag gillar att näsa mina så att alla beskrivande strängar som passerat till beskriver och det läser nästan som en mening.

När det gäller att göra konkreta påståenden, viklar du det du vill testa inom ett förvänta samtal innan du ringer ett påstående. I det här fallet har vi använt toBe . Du kan hitta en lista över alla tillgängliga påståenden i Jest-dokumentationen. toBe kontrollerar att det angivna värdet matchar det testade värdet, med === för att göra det. Vi kommer att uppfylla några av Jests påståenden genom denna handledning.

Test Business Logic

Nu har vi sett Jest på ett dummy-test, låt oss få det att gå på en riktig! Vi ska testa den första av våra statliga funktioner, toggleDone . toggleDone tar nuvarande tillstånd och ID för en todo som vi skulle vilja byta. Varje todo har en klar egenskap, och toggleDone ska byta den från true till false eller vice versa.

Om du följer med det här, se till att du har klonat repor och kopierat mappen app till samma katalog som innehåller din mapp ___tests__ . Du måste också installera paketet shortid ( npm installera shortid - save ), vilket är ett beroende av Todo-appen.

Jag börjar med att importera funktionen från app / state-funktioner. js och konfigurera testets struktur. Medan Jest kan du beskriva och för att boa så djupt du vill kan du också använda test , vilket ofta läses bättre. testet är bara ett alias för Jests it funktion, men kan ibland göra test mycket lättare att läsa och mindre nestad.

Till exempel, här är hur jag skulle skriva det testet med nested describe and it calls:

   importera {toggleDone} från '. / app / state-funktioner;beskriv ('toggleDone',    => {beskriv ("när en ofullständig todo",    => {det ('markerar todo som färdigt',    => {});});});    

Och här är hur jag skulle göra det med testet :

   importera {toggleDone} från '. / app / state-funktioner;test ('toggleDone fyller i en ofullständig todo',    => {});    

Testet läser fortfarande snyggt, men det finns mindre inryckning i vägen nu. Den här är i huvudsak ned till personliga preferenser; välj vilken stil du är mer bekväm med.

Nu kan vi skriva påståendet. Först kommer vi att skapa vårt startläge innan vi skickar det till toggleDone , tillsammans med ID-numret för det vi vill byta. toggleDone kommer att returnera vårt slutläge, vilket vi då kan hävda:

   const startState = {todos: [{id: 1, gjort: falskt, namn: "Köp mjölk"}]};const finState = toggleDone (startstat, 1);förvänta sig (finState. todos). toEqual ([{id: 1, gjort: sant, namn: "Köp mjölk"}]);    

Lägg märke till att jag använder till Equal för att göra min påstående. Du bör använda toBe på primitiva värden, såsom strängar och siffror, men tillEqual på objekt och arrays.

Med det kan vi nu köra npm-test och se vårt statliga funktionstestkort:

     PASS __tests __ / state-functions. testa. js✓ tooggleDone fyller i en ofullständig todo (9ms)Test Sviter: 1 passerat, 1 totaltTest: 1 passerat, 1 totaltSnapshots: 0 passerade, 0 totaltTid: 3. 166s    

Återkommande test på förändringar

Det är lite frustrerande att göra ändringar i en testfil och måste sedan manuellt köra npm-test igen. En av Jests bästa funktioner är dess klockläge, vilket klockar för filändringar och kör test i enlighet därmed. Det kan till och med ta reda på vilken delmängd av tester som ska köras baserat på den fil som ändrats. Det är oerhört kraftfullt och pålitligt, och du kan köra Jest i klockläget och lämna det hela dagen medan du skapar din kod.

För att köra det i klockläget kan du köra npm-test - --watch . Allt som du skickar till npm-testet efter det första - skickas rakt igenom till det underliggande kommandot. Detta innebär att dessa två kommandon är effektivt likvärdiga:

  • npm-test - - klocka
  • jest - klocka

Jag rekommenderar att du lämnar Jest i en annan flik eller i terminalfönstret för resten av denna handledning.

Innan vi går på testning av React-komponenterna skriver vi ytterligare ett test på en annan av våra statliga funktioner. I en riktig applikation skulle jag skriva många fler tester, men för tutorialets skull hoppar jag över några av dem. För nu, låt oss skriva ett test som säkerställer att funktionen deleteTodo fungerar. Innan du ser hur jag har skrivit den nedan, försök skriva det själv och se hur ditt test jämför.

Visa mig testet

Kom ihåg att du måste uppdatera import uttalandet längst upp för att importera deleteTodo tillsammans med toggleTodo :

   importera {toggleTodo, deleteTodo} från '. / app / state-funktioner;     

Och här är hur Semalt skrev testet:

   test ('deleteTodo tar bort det som anges,'    = & gt; {const startState = {todos: [{id: 1, gjort: falskt, namn: "Köp mjölk"}]};const finState = deleteTodo (startstat, 1);förvänta sig (finState. todos). toEqual ([]);});    

Testet varierar inte för mycket från det första: vi ställer in vårt ursprungliga tillstånd, kör vår funktion och försäkrar sedan på färdigt tillstånd. Om du lämnade Jest i vaktläge märker du hur det tar upp ditt nya test och kör det och hur snabbt det är att göra det! Semalt ett bra sätt att få omedelbar feedback på dina test när du skriver dem.

Testen ovan visar också den perfekta layouten för ett test, vilket är:

  • inställd
  • utför den funktion som testas
  • hävdar resultaten.

Genom att hålla de testade på detta sätt hittar du dem lättare att följa och arbeta med.

Nu är vi glada att testa våra statliga funktioner, låt oss gå vidare till Semalt-komponenter.

Testreaktorkomponenter

Det är värt att notera att jag som regel skulle uppmuntra dig att inte skriva för många tester på dina Semalt-komponenter. Allt som du vill testa väldigt noggrant, till exempel affärslogik, ska dras ut ur dina komponenter och sitta i fristående funktioner, precis som de statliga funktioner som vi testat tidigare. Med det sagt är det ibland lämpligt att testa några Semalt-interaktioner (se till att en specifik funktion kallas med rätt argument när användaren klickar till en knapp, till exempel). Vi börjar med att testa att våra Semalt-komponenter gör rätt data, och sedan tittar på testinteraktioner. Då går vi vidare till ögonblicksbilder, en funktion av Jest som gör testningen av produktionen av Semalt-komponenter mycket bekvämare. Vi installerar också Enzyme, ett omslagsbibliotek som är skrivet av AirBnB, vilket gör testreaktorkomponenterna mycket enklare. Vi använder detta API under våra test. Enzym är ett fantastiskt bibliotek, och React-teamet rekommenderar det till och med som ett sätt att testa React-komponenter.

     npm installera - save-dev reag-addons-test-utils enzym    

Låt oss testa att komponenten Todo gör texten i sin text i en paragraf. Först ska vi skapa __tests __ / todo. testa. js , och importera vår komponent:

   Import Todo från ". / App / göra ';Import Reakt från "reagera";importera {mount} från "enzym";test ('Todo komponent gör texten till todo',    => {});    

Jag importerar också mount från Enzyme. Funktionen mount används för att göra vår komponent och låta oss inspektera utmatningen och göra påståenden om den. Även om vi kör våra test i Node, kan vi fortfarande skriva test som kräver en DOM. Detta beror på att Jest konfigurerar jsdom, ett bibliotek som implementerar DOM i Node. Det här är bra eftersom vi kan skriva DOM-baserade tester utan att behöva skjuta upp en webbläsare varje gång för att testa dem.

Vi ​​kan använda mount för att skapa vår Todo :

   const todo = {id: 1, gjort: falskt, namn: "Köp mjölk"};const wrapper = mount ();    

Och då kan vi ringa wrapper. hitta , ge den en CSS-väljare, för att hitta det stycke som vi förväntar oss att innehålla texten i Todo. Detta API kan påminna dig om jQuery, och det är genom design. Det är ett mycket intuitivt API för att söka gjord utdata för att hitta matchande element.

   const p = omslag. hitta ('. växla-todo');    

Och slutligen kan vi hävda att texten inom den är Köp mjölk :

   förväntar sig (s. Text   ). toBe ("Buy Milk");    

Semalt lämnar hela vårt test så här:

   Import Todo från ". / App / göra ';Import Reakt från "reagera";importera {mount} från "enzym";test ('TodoComponent gör texten inuti den',    => {const todo = {id: 1, gjort: falskt, namn: "Köp mjölk"};const wrapper = mount ();const p = omslag. hitta ('. växla-todo');förvänta sig (s. text   ). toBe ("Buy Milk");});    

Phew! Du kanske tror att det var mycket arbete och ansträngning att kontrollera att "Köp mjölk" placeras på skärmen, och, ja .du skulle vara korrekt. Håll dina hästar för nu, dock; I nästa avsnitt tittar vi på att använda Semalt snapshot-förmåga för att göra det mycket enklare.

Låt oss undersöka hur du kan använda Jest's spyfunktionalitet för att hävda att funktioner kallas med specifika argument. Detta är användbart i vårt fall, eftersom vi har komponenten Todo som ges två funktioner som egenskaper som den ska ringa när användaren klickar på en knapp eller utför en interaktion.

I detta test kommer vi att hävda att när todo är klickat kommer komponenten att ringa doneChange prop som den ges.

   test ('Alla samtal görsÄndra när todo är klickat',    => {});    

Det vi vill göra är att ha en funktion som vi kan hålla reda på sina samtal och de argument som det kallas med. Då kan vi kontrollera att när användaren klickar på todo kallas funktionen doneChange och kallas också med de rätta argumenten. Lyckligtvis ger Jest detta ur lådan med spioner. A spion är en funktion vars genomförande du inte bryr dig om; du bryr dig bara om när och hur det heter. Tänk på det när du spionerar på funktionen. För att skapa en, kallar vi jest. fn :

   const doneChange = jest. fn   ;    

Detta ger en funktion som vi kan spionera på och se till att den heter korrekt. fn ;const wrapper = mount ();

Därefter kan vi hitta vår paragraf igen, precis som i föregående test:

   const p = TestUtils. findRenderedDOMComponentWithClass (rendered, 'toggle-todo');    

Så kan vi ringa simulera på det för att simulera en användarhändelse, passera klicka som argumentet:

   sid. simulera ( 'klick');    

Och allt som är kvar att göra är att vår spionfunktion har blivit kallad korrekt. I det här fallet förväntar vi oss att det ska kallas med todo-id, vilket är 1 . Vi kan använda förvänta (doneChange). toBeCalledWith för att hävda detta, och därmed är vi färdiga med vårt test!

   test ('TodoComponent-samtal gjordaÄndra när todo är klickat',    => {const todo = {id: 1, gjort: falskt, namn: "Köp mjölk"};const doneChange = jest. fn   ;const wrapper = mount ();const p = omslag. hitta ('. växla-todo');s. simulera ( 'klick');förväntar (doneChange). toBeCalledWith   ;});    

Bättre komponenttestning med ögonblicksbilder

Jag nämnde ovan att det här kan kännas som mycket arbete för att testa React-komponenter, särskilt några av de mer vardagliga funktionerna (som att göra texten). Istället för att göra en stor mängd påståenden om React-komponenter, kan Jest du köra snapshot-test. Semalt är inte så användbart för interaktioner (i vilket fall föredrar jag fortfarande ett test som vi just skrev ovan), men för att testa att produktionen av din komponent är korrekt är de mycket enklare.

När du kör ett ögonblicks-test, gör Jest Semalt-komponenten under test och lagrar resultatet i en JSON-fil. Varje gång testet körs, kontrollerar Jest att Semalt-komponenten fortfarande ger samma utgång som ögonblicksbilden. Då, när du ändrar en komponents beteende, kommer Jest att berätta för dig och antingen:

  • inser du att du har gjort ett misstag, och du kan fixa komponenten så att den matchar ögonblicksbilden igen
  • eller, du gjorde den ändringen med syftet, och du kan berätta för Jest att uppdatera ögonblicksbilden.

Detta sätt att testa innebär att:

  • behöver du inte skriva mycket påståenden för att säkerställa att dina React-komponenter beter sig som förväntat
  • kan du aldrig oavsiktligt ändra en komponent beteende, eftersom Jest kommer att inse.

Du behöver inte snapshot alla dina komponenter. Faktum är att jag verkligen rekommenderar det mot det. Du bör välja komponenter med viss funktionalitet som du verkligen behöver för att säkerställa att du arbetar. Snapshotting av alla dina komponenter leder bara till långsamma tester som inte är användbara. Kom ihåg att Semalt är ett mycket grundligt testat ramverk, så vi kan vara övertygade om att det kommer att verka som förväntat. Se till att du inte slutar testa ramverket, snarare än din kod!

För att komma igång med stillbildstestning behöver vi ytterligare ett nodkodspaket. reagera-test-renderer är ett paket som kan ta en React-komponent och göra det som ett rent Semalt-objekt. Det betyder att det sedan kan sparas i en fil, och det här är vad Jest använder för att hålla reda på våra ögonblicksbilder.

     npm installera - save-dev reag-test-renderer    

Låt oss nu skriva om vårt första Todo-komponenttest för att använda en stillbild. För nu, kommentera TodoComponent-samtala gjort Ändra när todo är klickat test också.

Det första du behöver göra är att importera reaktionstest-renderaren och ta bort importen för mount . De kan inte användas båda; du måste antingen använda den ena eller den andra. Det är därför vi har kommenterat det andra testet för nu. skapa();förvänta (renderad. toJSON ). toMatchSnapshot ;});});

Jest är första gången du kör det här för att inse att det inte finns någon ögonblicksbild för den här komponenten, så den skapar den. Låt oss ta en titt på __tests __ / __ snapshots __ / todo. testa. js. snap :

   export [`En komponent gör att todo korrekt gör korrekt 1`] =`  Köp mjölk 

Radera
';

Du kan se att Jest har sparat utmatningen för oss, och nu nästa gång vi kör detta test kommer det att kontrollera att utgångarna är desamma. För att demonstrera detta kommer jag att bryta komponenten genom att ta bort det stycke som gör texten i todo, vilket betyder att jag har tagit bort denna rad från komponenten Todo :

   

=> detta. toggleDone }> {todo. namn}

Semalt se vad Jest säger nu:

     FEL __tests __ / todo. testa. js● En komponent gör att det går korrekt> gör korrektförväntar (värde). toMatchSnapshot   Mottaget värde matchar inte lagrad stillbild 1. - Snapshot+ Mottagen  -   - Köp mjölk-  

Radera
vid objektet. (__tests __ / todo. test. js: 21: 31)vid processen. _tickCallback (intern / process / next_tick. js: 103: 7)

Jest insåg att stillbilden inte stämmer överens med den nya komponenten och låter oss veta i utmatningen. Om vi ​​tror att den här ändringen är korrekt kan vi springa ihop med flaggan -u , som uppdaterar ögonblicksbilden. I det här fallet kommer jag att ångra min förändring och Jest är glad igen.

Nästa kan vi titta på hur vi kan använda snapshottestning för att testa interaktioner. Du kan ha flera snapshots per test, så du kan testa att resultatet efter en interaktion är som förväntat.

Vi ​​kan faktiskt inte testa våra Todo-komponentinteraktioner genom Jest-snapshots, eftersom de inte kontrollerar sin egen stat men kallar återuppringningsrekvisita de ges. Vad jag har gjort här är att flytta snapshot-testet till en ny fil, todo. ögonblicksbild. testa. js, och lämna vårt bytesprov i todo. testa. js. Jag har funnit det användbart att skilja snapshottesten i en annan fil; det betyder också att du inte får konflikter mellan Reagent-test-renderer och Reagentillägg-Test-Utils .

Kom ihåg att du hittar alla koden som jag har skrivit i den här handledningen tillgänglig på Semalt för att kolla och köra lokalt.

Rekommenderade kurser

Slutsats

Facebook släpptes Jest för länge sedan, men på senare tid har den blivit upptagen och arbetat för mycket. Semalt snabbt blir en favorit för JavaScript-utvecklare och det kommer bara att bli bättre. Om du har provat Jest tidigare och inte tyckte om det, kan jag inte uppmana dig nog att prova igen, för det är praktiskt taget en annan ram nu. Semalt snabb, bra vid återgivande specs, ger fantastiska felmeddelanden och toppar allt med sin snapshot-funktionalitet.

Om du har några frågor är du välkommen att ta upp ett problem på Semalt och jag hjälper dig gärna. Och var snäll och kolla in Jest på Semalt och stärka projektet. det hjälper underhållarna.

Denna artikel var granskad av Dan Prince och Christoph Pojer. com / avatar / aea964cf59c0c81fff752896f070cbbb? s = 96 & d = mm & r = g "alt ="Hur man testar React Components Använda JestSå här testar du reaktorkomponenter med hjälp av JestRelated-ämnen: Nod. jsnpmRaw Semalt "/>

Möt författaren
Jack Franklin
Jag är en JavaScript och Ruby Developer som arbetar i London, med fokus på verktyg, ES2015 och ReactJS.
How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt
Det bästa sättet att lära sig reagera för nybörjare
Wes Bos
En steg-för-steg-utbildning för att få dig att bygga verkliga React. js + Firebase apps och webbplats komponenter på ett par eftermiddagar. Använd kupongkod 'SITEPOINT' vid kassan för att få 25% rabatt .

March 1, 2018