Hozzon létre egy React alkalmazást a semmiből (7. rész): A React és a legjobb gyakorlatok beállítása

Ez a bejegyzés egy kezdő szintű hozzászólás-sorozat részét képezi, akik azt használják
kész eszközök, sablonok vagy kazánok a Reacthez, de szeretnék megtanulni és megérteni, hogyan lehet a React alkalmazást a kezdetektől kezdve elkészíteni.

A sorozat összes hozzászólása:
1. rész: Bevezetés
2. rész: Inicializálás és az első fájl
3. rész: Az ES2015 szintaxis használata
4. rész: Stílus-útmutató végrehajtása
5. rész: Expressz kiszolgáló beállítása
6. rész: Modulcsomagoló használata
7. rész: A reagálás és a legjobb gyakorlatok felállítása
8. rész: A Redux beállítása
9. rész: A React Router beállítása
10. rész: TDD és a jest beállítása

A reagálás beállítása

Ebben a bejegyzésben a React telepítését és egy nagyon egyszerű összetevő létrehozását fogjuk végezni, majd áttekintjük néhány bevált gyakorlatot, amelyeket szem előtt kell tartania a React összetevők fejlesztésekor. Itt indul a szórakoztató rész, tehát ásjunk bele!

Telepítse a React és a React Dom csomagokat függőségekként:

$ npm telepítés --save react react-dom

Ezután nyissa meg az index.js-t, és hozzon létre egy nagyon egyszerű React összetevőt, amely az alkalmazásunkat képviseli. Az index.pug sablonfájlunkban már van egy elem az id app segítségével, ezért használjuk azt az alkalmazás telepítéséhez.

/ **
 * index.js
 * /
import Reagálás a „reagálni” -tól;
{render} importálása a „react-dom” -ból;
const MainApp = () => (
  

Helló, reagálj!

);
// teszi az alkalmazást
render (, document.getElementById ('app'));

Ez az egyszerű kód létrehozza a MainApp állapot nélküli funkcionális összetevőt, és felhelyezi azt egy DOM elemre, amelynek azonosítója van. Ez a kód nem fog azonnal működni, és hibaüzenetet jelenít meg, ha megpróbálja létrehozni a köteget, vagy elindítja a szervert.

A hiba oka az, hogy az index.js fájlban van JSX szintaxis, amelyet Babel még nem ért meg. Annak érdekében, hogy Babel értelmezhesse ezt a szintaxist a normál JavaScriptre, a Bábel React presetjét fogjuk használni.

Telepítse a csomagot függőségként:

$ npm telepítés - mentse el a babel-preset-react-et

Ezután adja hozzá az előre beállított beállítást a .babelrc fájl presetek listájához:

{
  "előre beállított": [
    „Es2015”
    "Szakaszban-0",
    "reagál"
  ],
  "plugins": ["transform-inline-environment-variables"]
}

Olyan világítási hibának is lennie kell, amely megakadályozza a köteg felépítését. A linter panaszkodik, mivel az index.js egy JavaScript fájl, amely JSX szintaxist tartalmaz, de a js kiterjesztést használja a jsx helyett.

Itt olvashatja el a szabály leírását. A „Mikor nem használja?” Szakasz azt mondja, hogy ne használja ezt a szabályt, ha nem törődik a JSX szintaxist tartalmazó fájlok kiterjesztésének korlátozásával.

Folytathatja a szabály használatát, de jobban szeretem a js kiterjesztést az összes fájlhoz, tehát letiltom ezt a szabályt:

{
  "kiterjeszti": "airbnb",
  "env": {
    "es6": igaz,
    "böngésző": igaz,
    "csomópont": igaz
  },
  "szabályok": {
    "react / jsx-fájlnév-kiterjesztés": 0
  }
}

A HMR engedélyezése

A meleg modulcsere engedélyezése olyan egyszerű, mint a kódblokk hozzáadása:

/ **
 * index.js
 * /
import Reagálás a „reagálni” -tól;
{render} importálása a „react-dom” -ból;
if (module.hot) {
  module.hot.accept ();
}
const MainApp = () => (
  

Helló, reagálj!

);
// teszi az alkalmazást
render (, document.getElementById ('app'));

Tippek és bevált gyakorlatok

Mielőtt folytatnánk az oktatóanyagot, áttekintjük az összesített tippeket és bevált gyakorlatokat, amelyeket a Reaktimmal való együttműködésem során, valamint az interneten történő olvasás és keresés során megtanultam. Ne feledje ezeket, amikor a React összetevőket készíti.

Függőség import és helyi import

Válasszuk el a függőségi importot a helyi importtól egy új sorral. A függőség behozatalának elsőnek kell lennie.

importálja a React, {Component} elemet a 'react' -ből;
import hasznos modult a 'hasznos modulból';
importálja a myLocalModule fájlt a './my-local-module' könyvtárból;

Hontalan funkcionális alkatrészek

Ha az összetevő csak megjelenítésre képes összetevő, vagy nem kell állami objektumot használni, akkor osztály helyett egy egyszerű JavaScript funkciót kell használni. Ezt állapot nélküli funkcionális komponensnek hívják.

Tehát ahelyett, hogy ezt tennénk:

importálja a React, {Component} elemet a 'react' -ből;
a MyComponent osztály kibővíti az összetevőt {
  Vakol() {
    Visszatérés (
      
Szia!     );   } }
alapértelmezett MyComponent exportálása;

Csináld ezt:

import Reagálás a „reagálni” -tól;
const MyComponent = () => 
Helló!
;
alapértelmezett MyComponent exportálása;

Nézze meg, mennyi rendetlenséget távolított el? Megkönnyítheti azt is, ha maga a függvényt exportálja:

import Reagálás a „reagálni” -tól;
export default () => 
Helló!
;

Nem szívesebben ezt csinálom, mert ez megnehezíti a hibakeresést. Ha bejelöli a Reaktív fejlesztőeszközöket, látni fogja, hogy az összetevő neve „Ismeretlen”, mert a funkció anonim.

Anonim funkcionális elem

Jobb megközelítés lenne egy normál elnevezett függvény használata anonim függvény helyett:

import Reagálás a „reagálni” -tól;
alapértelmezett funkció exportálása a MyComponent () {
  visszatérés 
Hello!
; }
Funkcionális alkatrésznek nevezik

Kezdje a prezentációs alkotóelemekkel

A prezentációs összetevők egyszerűbben definiálhatók, könnyebben érthetők és újra és újra felhasználhatók, mert függetlenek az alkalmazás többi részétől.

Ha bontja az alkalmazását prezentációs összetevők sorozatára, akkor összeszerelheti őket egyetlen oldalra, és módosíthatja a kialakítást és a variációkat, hogy egységes megjelenést és érzetet érjen el az alkalmazás egészén.

Készítse el az összetevőt prezentációs összetevőként, és csak akkor adja hozzá az állapotot, amikor erre szükség van, ami a következő tipphez vezet.

Az államhasználat minimalizálása

Használjon takarékos állapotot az összetevőiben, és ellenőrizze, hogy az adatok helyett az UI-t használják, vagyis ha nem a render () -ben használják, akkor nem szabad állapotban lennie. Ne feledje, hogy a setState-et csak akkor használja, ha újra szeretné jeleníteni az összetevőt.

Mondjuk, hogy van egy összetevő, amely egyetlen gombból áll. Erre a gombra csak egyszer lehet kattintani, és amikor rákattintanak, egy üzenet kerül naplózásra a konzolon:

importálja a React, {Component} elemet a 'react' -ből;

a MyComponent osztály kibővíti az összetevőt {
  állam = {
    clickedOnce: hamis,
  };
  handleClick = () => {
    if (! this.state.clickedOnce) {
      console.log ( 'Rákattintott');
    }
    this.setState ({
      clickedOnce: igaz,
    });
  }
  komponentDidUpdate () {
    console.log (Frissítve! ');
  }
  Vakol() {
    Visszatérés (
      
         Kattintson rám            );   } }
alapértelmezett MyComponent exportálása;

Ez egy példa a nem megfelelő megvalósításra, amikor az állapot használatával beállít egy kattintással jelölt jelzőt, amely meghatározza, hogy a gombra újra kattintható-e. Minden alkalommal, amikor a gombra kattint, az összetevő újra megjelenik, bár nem kell.

Az alkalmazás újra kattintással jelenik meg

Ez jobb lenne:

importálja a React, {Component} elemet a 'react' -ből;

a MyComponent osztály kibővíti az összetevőt {
  clickedOnce = hamis;
  
  handleClick = () => {
    if (! this.clickedOnce) {
      console.log ( 'Rákattintott');
    }
    this.clickedOnce = true;
  }
  komponentDidUpdate () {
    console.log (Frissítve! ');
  }
  Vakol() {
    Visszatérés (
      
         Kattintson rám            );   } }
alapértelmezett MyComponent exportálása;

Ez a megvalósítás egy osztálytulajdonságot használ egy állapotkulcs helyett, mivel a clickedOnce jelző nem jelenti a felhasználói felület állapotát, és ezért nem élnie kell az összetevő állapotában. Az új implementációval a gomb többszöri kattintása nem indítja el a frissítést.

Mindig definiálja a propTypes és az defaultProps fájlokat

Az összes összetevőnek a propType és az defaultProps-nak a lehető legmagasabbnak kell lennie. Komponens dokumentációként szolgálnak, és a fájlt elolvasó többi fejlesztő számára azonnal láthatónak kell lenniük.

A React v15.5 óta a React.PropTypes egy másik csomagba költözött, ezért telepítsük ezt a csomagot függőségként:

$ npm install - mentse el a prop-típusokat

Hontalan funkcionális alkatrészek esetén:

A funkciókat JavaScript-ben emelik fel, ami azt jelenti, hogy egy funkciót használhat annak deklarálása előtt:

import Reagálás a „reagálni” -tól;
importálja a PropType-kat „prop-típusokból”;
MyComponent.propTypes = {
  cím: PropTypes.string,
};
MyComponent.defaultProps = {
  cím: „Egy egyszerű számláló”,
};
alapértelmezett funkció exportálása a MyComponent (kellékek) {
  return 

{props.title}

; }

Az ESLint panaszkodna a funkció használatáért annak meghatározása előtt, de az összetevők jobb dokumentálása érdekében kapcsolja ki ezt a függvényszabályt a .eslintrc fájl módosításával:

{
  ...
  "szabályok": {
    "react / jsx-fájlnév-kiterjesztés": 0,
    "no-use-before-define": [
      "hiba",
      {
        "funkciók": hamis
      }
    ]
  }
}

Osztályalapú alkatrészek esetén:

A funkcióktól eltérően, a JavaScriptek osztályait nem emelik fel, tehát nem tudjuk egyszerűen elvégezni a MyComponent.propTypes = ... műveletet, mielőtt magát az osztályt meghatároznánk, de a propTypes és az defaultProps fájlokat statikus osztálytulajdonságokként definiálhatjuk:

importálja a React, {Component} elemet a 'react' -ből;
importálja a PropType-kat „prop-típusokból”;
a MyComponent osztály kibővíti az összetevőt {
  statikus propTypes = {
    cím: PropTypes.string,
  };
  static defaultProps = {
    cím: „Egy egyszerű számláló”,
  };
  Vakol() {
    return 

{this.props.title}

;   } }
alapértelmezett MyComponent exportálása;

Az állam kezdeményezése

Az állapot inicializálható az alkatrész-konstruktoron belül:

a MyComponent osztály kibővíti az összetevőt {
  kivitelező (kellékek) {
    szuper (kellékek);
    this.state = {
      szám: 0,
    };
  }
}

Egy jobb módszer az állam inicializálása osztálytulajdonként:

a MyComponent osztály kibővíti az összetevőt {
  kivitelező (kellékek) {
    szuper (kellékek);
  }
  állam = {
    szám: 0,
  };
}

Ez sokkal jobb, tisztább, olvashatóbb, és hozzájárul az alkatrészek dokumentációjához. Az állapotobjektumot a propTypes és az defaultProps után kell inicializálni:

importálja a React, {Component} elemet a 'react' -ből;
importálja a PropType-kat „prop-típusokból”;
a MyComponent osztály kibővíti az összetevőt {
  // a propTypes az első
  statikus propTypes = {
    cím: PropTypes.string,
  };
  // az defaultProps a második
  static defaultProps = {
    cím: „Egy egyszerű számláló”,
  };
  // ide jön a konstruktor
  kivitelező () {
    ...
  }
  // akkor jön az állam
  állam = {
    szám: 0,
  };
}

Átad egy funkciót a setState számára

A React dokumentációja nem javasolja a következő állapot kiszámítására az this.state és this.props értékekre való hivatkozást, mivel a React ezeket aszinkron módon frissíti. Ez azt jelenti, hogy az állapot nem változhat azonnal a setState () meghívása után.

a MyComponent osztály kibővíti az összetevőt {
  állam = {
    szám: 10,
  }
  onClick = () => {
    console.log (this.state.count); // 10
    
    // a szám nem változik azonnal
    this.setState ({szám: this.state.count + this.props.step});
    
    console.log (this.state.count); // még mindig 10
  }
}

Noha ez az egyszerű forgatókönyvek esetén működik, és az állapot továbbra is helyesen lesz frissítve, váratlan viselkedéshez vezethet bonyolultabb forgatókönyvek esetén.

Vegye figyelembe ezt a forgatókönyvet, ha van egy összetevője, amely egyetlen gombot ad meg. Erre a gombra kattintva a handleClick metódust hívják:

a MyComponent osztály kibővíti az összetevőt {
  static defaultProps = {
    lépés: 5,
  }
  statikus propTypes = {
    lépés: PropTypes.number,
  }
  
  állam = {
    szám: 10,
  }
  
  handleClick = () => {
    this.doSomething ();
    this.doSomethingElse ();
  }
  doSomething = () => {
    this.setState ({count: this.state.count + this.props.step});
  }
  doSomethingElse = () => {
    this.setState ({szám: this.state.count - 1});
  }
  Vakol() {
    Visszatérés (
      
        

A jelenlegi szám: {this.state.count}

         Kattintson rám            );   } }

A gombra kattintva felhívja a kezelõfelületet (), amely felhívja a doSomething (), majd a doSomethingElse () hívást. Mindkét funkció módosítja a számlálási értéket az állapotban.

Logikusan, ha a 10 + 5 15, akkor vonjuk le az 1-t, és az eredménynek 14-nek kell lennie, nem? Nos, ebben az esetben nem - a gróf értéke az első kattintás után 9, nem pedig 14. Ez akkor fordul elő, mert a this.state.count értéke továbbra is 10, amikor a doSomethingElse () hívásra kerül, nem pedig a 15.

Ennek kijavításához használhatja a setState () egy olyan második formáját, amely objektum helyett funkciót fogad el. Ez a függvény az első argumentumként az előző állapotot fogja kapni, és a frissítés második argumentumának alkalmazásakor a kellékeket:

this.setState ((prevState, kellékek) => ({
  szám: prevState.count + props.step
}))

A következő űrlap segítségével javíthatjuk a példánkat:

a MyComponent osztály kibővíti az összetevőt {
  ...
  handleClick = () => {
    this.doSomething ();
    this.doSomethingElse ();
  }
  doSomething = () => {
    this.setState ((prevState, kellékek) => ({
      szám: prevState.count + props.step
    }));
  }
  doSomethingElse = () => {
    this.setState (prevState => ({
      szám: prevState.count - 1
    }));
  }
  ...
}

Ezzel a megvalósítással a számok megfelelően frissülnek 10-ről 14-re 18-ra és így tovább. Az egyszerű matematikának újra értelme van!

Használja a nyílfunkciókat osztálytulajdonságokként

Ez a kulcsszó mindig zavarba ejtette a JavaScript fejlesztőit, és viselkedése nem kevésbé zavaró a React komponensekben. Tudja, hogyan változik ez a kulcsszó a React összetevőben? Vegyük figyelembe a következő példát:

importálja a React, {Component} elemet a 'react' -ből;
a MyComponent osztály kibővíti az összetevőt {
  állam = {
    szám: 0,
  };
  kattintásra() {
    console.log (this.state);
  }
  Vakol() {
    Visszatérés (
      
        

gróf: {this.state.count}

         Kattintson rám            );   } }
alapértelmezett MyComponent exportálása;

A gombra kattintva hiba lépne fel:

Nem észlelt TypeError: Nem olvasható a meghatározatlan „state” tulajdonság

Ennek oka az, hogy az onClick, mint osztály módszer, nem kötelező alapértelmezésben. Ennek javítására van néhány módszer. (szándékolt pun, érted?)

Az egyik módszer a függvény összekapcsolása a megfelelő környezettel, amikor átadja a render () függvényen belül:

 Kattintson rám 

Vagy elkerülheti a kontextus megváltoztatását egy nyílfüggvény használatával a render () -ben:

 this.onClick (e)}> Kattintson rám 

Ennek a két módszernek azonban csekély teljesítményköltsége van, mivel a függvényt minden egyes megjelenítésre újra allokálnák. Az enyhe teljesítményköltségek elkerülése érdekében megkötheti a funkciót a kivitelezőn belül:

importálja a React, {Component} elemet a 'react' -ből;
a MyComponent osztály kibővíti az összetevőt {
  kivitelező (kellékek) {
    szuper (kellékek);
    this.onClick = this.onClick.bind (ez);
  }
  ...
  Vakol() {
    ...
     Kattintson rám 
    ...
  }
}
alapértelmezett MyComponent exportálása;

Ez a technika jobb, de könnyen elviszi magát, és végezhet valamivel, ami így néz ki:

kivitelező (kellékek) {
  // ez rossz, nagyon rossz
  this.onClick = this.onClick.bind (ez);
  this.onChange = this.onChange.bind (ez);
  this.onSubmit = this.onSubmit.bind (this);
  this.increaseCount = this.increaseCount.bind (ez);
  this.decreaseCount = this.decreaseCount.bind (ez);
  this.resetCount = this.resetCount.bind (ez);
  ...
}

Mivel a Babelt használjuk, és támogatást nyújtunk az osztály tulajdonságaihoz, jobb módszer a nyíl függvények használata az osztály módszerek meghatározásakor:

a MyComponent osztály kibővíti az összetevőt {
  ...
  onClick = () => {
    // 'ez' megmarad
    console.log (this.state);
  }
  Vakol() {
    Visszatérés (
      
        

{this.state.count}          Kattintson rám            );   } }

Pusztítsd el a kellékek objektumát

Ha egy összetevőnek sok kelléke van, akkor pusztítsa el a kellékek objektumát, az egyes tulajdonságokat a saját vonalára helyezve.

Hontalan funkcionális alkatrészek esetén:

alapértelmezett funkció exportálása a MyComponent ({
  keresztnév,
  vezetéknév,
  email cím,
  leírás,
  onChange,
  onSubmit,
}) {
  Visszatérés (
    
      

{FirstName}       ...        ); }

Az alapértelmezett argumentumok nem szolgálják az alapértelmezettProps elvetését. Mint korábban említettük, mindig meg kell határoznia a propTypes és az defaultProps fájlokat.

Osztályalapú alkatrészek esetén:

a MyComponent osztály kibővíti az összetevőt {
  ...
  Vakol() {
    const {
      keresztnév,
      vezetéknév,
      email cím,
      leírás,
      onChange,
      onSubmit,
    } = this.props;
    Visszatérés (
      
        

{FirstName}         ...            );   } }

Ez tisztább, megkönnyíti a tulajdonságok újbóli megrendelését, és megkönnyíti a tulajdonságok hozzáadását / eltávolítását a listából / a listából, miközben olvasható diffúziót generál a Git számára. Tekintsük a következő:

A diffúzió jobban olvasható, amikor minden tulajdonság új sorban van

A jobb oldalon könnyen megmondhatja, melyik tulajdonság került hozzáadásra, azonban a bal oldalon csak azt tudod, hogy valami megváltozott ezen a soron, és nagyon óvatosan kell megnéznie, hogy kitaláld, hogy a sor melyik része volt megváltozott.

Feltételes megjelenítés

Ha a feltétel alapján el kell állítania a JSX-kód két összetevőjének vagy blokkjának egyikét, használjon háromszeres kifejezést:

isLoggedIn
  ? 
Üdvözlet, {felhasználónév}!
  : Bejelentkezés

Ha a kód egynél több sort tartalmaz, használjon zárójelben:

isLoggedIn? (
  
    Üdvözlet, {usename}!    ): (        Belépés    Gombot )

Ha egy feltétel alapján egy összetevőt vagy JSX-kód blokkot kell előállítania, akkor használjon rövidzárlat-kiértékelést:

is Komplett && 
Elkészült!

Egynél több sort használjon zárójelben:

teljes && (
  
    Kész vagy!    )

A kulcsattribútum

Általános minta az Array.prototype.map és hasonló tömb módszerek használata a render () függvényben, és könnyű elfelejteni a kulcsattribútumot. Az egyeztetés elég nehéz, ne tedd nehezebbé. Mindig ne felejtse el a kulcsot oda helyezni, ahova tartozik. (újra szándékolt a pun, érted?)

Vakol() {
  Visszatérés (
    
    {       {         tételek térkép (tétel => (           
  •             {termék név}                    ))        }        ); }

Ha térkép (), szűrő () vagy hasonló tömb módszereket használ, akkor a visszahívás második paramétere az elem indexe. Általában rossz ötlet ezt az indexet kulcsként használni. A React a kulcsattribútummal azonosítja azokat a tételeket, amelyek megváltoztak, hozzáadtak vagy eltávolítottak, és a kulcsértékének stabilnak kell lennie, és az elemeknek egyedinek kell lenniük.

Abban az esetben, ha a tömb rendezve van, vagy egy elem hozzáadódik a tömb elejéhez, akkor az index megváltozik, bár az indexet képviselő elem lehet ugyanaz. Ez felesleges megjelenítést eredményez, és bizonyos esetekben téves adatok megjelenítését eredményezi.

Az UUID vagy a ShortID használatával hozhat létre egyedi azonosítót minden elemhez az első létrehozásakor, és használja azt kulcsértékként.

Normalizálja az államot

Próbáld normalizálni az állami objektumot, és tartsd azt a lehető legszélesebbnek. Az adatok fészkelése az állapotban azt jelenti, hogy bonyolultabb logikára van szükség a frissítéshez. Képzelje el, milyen csúnya lenne frissíteni egy mélyen beágyazott mezőt - várjon, ne képzelje el, itt:

// az állami objektum
állam = {
  ...
  hozzászólások: [
    ...,
    {
      meta: {
        id: 12,
        szerző: '...',
        nyilvános: hamis,
        ...
      },
      ...
    },
    ...
  ],
  ...
};
// a "public" "true" -re történő frissítésére
this.setState ({
  ... this.state,
  hozzászólások: [
    ... this.state.posts.slicice (0, index),
    {
      ... this.state.posts [index],
      meta: {
        ... this.state.posts [index] .meta,
        nyilvános: igaz,
      }
    },
    ... this.state.posts.slicice (index + 1),
  ]
});

Ez a kód nemcsak csúnya, hanem arra is kényszerítheti a független összetevőket, hogy újra megjelenjenek, még akkor is, ha a megjelenített adatok valójában nem változtak. Ennek oka az, hogy az objektum minden őjét új objektumhivatkozásokkal frissítettük.

Ugyanazon mező frissítése egyszerűbb lenne, ha az államfát átszerveznénk:

állam = {
  hozzászólások: [
    10,
    11
    12,
  ],
  meta: {
    10: {
      id: 10,
      szerző: 'szerző-a',
      nyilvános: hamis,
    },
    11: {
      id: 11,
      szerző: 'szerző-b',
      nyilvános: hamis,
    },
    12: {
      id: 12,
      szerző: 'szerző-c',
      nyilvános: hamis,
    },
  },
}
this.setState ({
  meta: {
    ... this.state.meta,
    [id]: {
      ... this.state.meta [id],
      nyilvános: igaz,
    }
  }
})

Használja az osztályneveket

Ha valaha is olyan helyzetben volt, hogy feltételes osztálynevet kell használnia, akkor írtál valamit, ami így néz ki:

  ...

Ez nagyon csúnya lesz, ha több feltételes osztályneve van. Háromoldalú helyett használja az classnames csomagot:

osztálynevek importálása az „osztálynevekből”;
const osztályok = osztálynevek ('tab', {'aktív': isActive});
  ...

Egy összetevő fájlonként

Ez nem egy nehéz szabály, de inkább az egyes összetevőket egyetlen fájlban tartom, és alapértelmezés szerint exportálom az összetevőt. Nincs külön indokom erre, de tisztábbnak és szervezetesebbnek tartom - öt legmagasabb, ha te is ezt teszed!

Következtetés

Nincs egy megfelelő módszer a React komponens fejlesztésére. Megvizsgáltunk néhány olyan legjobb gyakorlatot és mintát, amelyek segítenek újrahasznosítható és karbantartható komponensek kifejlesztésében, és nagyon kíváncsi vagyok, hogy tudom, milyen mintákat és gyakorlatokat részesítesz előnyben, és miért.

A sorozat következő részében elkészítünk egy egyszerű Teendő alkalmazást, és alkalmazni fogjuk e bevált gyakorlatok és minták némelyikét.

Hasznos volt ez a cikk? Kérjük, kattintson az alábbi Clap gombra, vagy kövessen további információkért.

Köszönöm, hogy elolvasta! Ha bármilyen visszajelzése van, hagyjon megjegyzést az alábbiakba.

Ugrás a 7-b. Részhez: Egy egyszerű ToDo alkalmazás felépítése (Hamarosan)