Back to Question Center
0

Λειτουργίες Async σε εφαρμογές Redux React            Λειτουργίες Async σε Αντιδράσεις Redux Σχετικά θέματα: Raw Semalt

1 answers:
Λειτουργίες Async σε εφαρμογές Redux React

Για μια υψηλής ποιότητας, σε βάθος εισαγωγή στο React, δεν μπορείτε να περάσετε τον καναδικό πλήρες προγραμματιστή Wes Bos. Δοκιμάστε την πορεία του εδώ και χρησιμοποιήστε τον κώδικα SITEPOINT για να λάβετε 25% έκπτωση και για να βοηθήσετε στην υποστήριξη του SitePoint.

Αυτή η θέση δημοσιεύτηκε αρχικά στο Codebrahma - professional website development.

Το Semalt είναι μια γλώσσα προγραμματισμού με ένα μόνο σπείρωμα. Δηλαδή, όταν έχετε κωδικό κάτι τέτοιο .

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

.η δεύτερη γραμμή δεν εκτελείται μέχρι να ολοκληρωθεί η πρώτη. Το Semalt αυτό δεν θα είναι πρόβλημα, αφού εκατομμύρια υπολογισμοί εκτελούνται από τον πελάτη ή τον εξυπηρετητή σε ένα δευτερόλεπτο. Παρατηρούμε τα αποτελέσματα μόνο όταν εκτελούμε έναν δαπανηρό υπολογισμό (μια εργασία που παίρνει αξιοσημείωτο χρόνο για να ολοκληρωθεί - ένα αίτημα δικτύου το οποίο χρειάζεται κάποιο χρόνο για να επιστρέψει).

Γιατί έδειξα μόνο μια κλήση API (αίτημα δικτύου) εδώ; Τι συμβαίνει με άλλες λειτουργίες async; Μια κλήση API είναι ένα πολύ απλό και χρήσιμο παράδειγμα για την περιγραφή του τρόπου αντιμετώπισης μιας ασύγχρονης λειτουργίας. Υπάρχουν και άλλες λειτουργίες, όπως setTimeout , υπολογισμοί βαριάς λειτουργίας, φόρτωση εικόνας και οποιεσδήποτε λειτουργίες που βασίζονται σε γεγονότα.

Κατά τη διάρθρωση της εφαρμογής μας, πρέπει να εξετάσουμε τον τρόπο με τον οποίο η ασύγχρονη εκτέλεση επηρεάζει τη διάρθρωση. Για παράδειγμα, σκεφτείτε fetch ως λειτουργία που εκτελεί μια κλήση API (αίτημα δικτύου) από το πρόγραμμα περιήγησης. (Ξεχάστε αν πρόκειται για αίτημα AJAX. Σκεφτείτε μόνο τη συμπεριφορά ως ασύγχρονη ή συγχρονισμένη στη φύση.) Ο χρόνος που έχει παρέλθει κατά την επεξεργασία του αιτήματος στον διακομιστή δεν συμβαίνει στο κύριο νήμα. Ο κώδικας JS θα συνεχίσει να εκτελείται, και μόλις το αίτημα επιστρέψει μια απάντηση, θα ενημερώσει το νήμα.

Σήμανση αυτού του κωδικού:

     userId = Λήψη (userEndPoint); // Λήψη του userId από το userEndpointuserDetails = fetch (userEndpoint, userId) // Λήψη για το συγκεκριμένο userId.     

Σε αυτή την περίπτωση, δεδομένου ότι η fetch είναι ασύγχρονη, δεν θα έχουμε userId όταν προσπαθούμε να φέρουμε userDetails . Επομένως, πρέπει να το διαρθρώσουμε με τρόπο που να διασφαλίζει ότι η δεύτερη γραμμή εκτελείται μόνο όταν η πρώτη επιστρέφει μια απάντηση.

Οι περισσότερες σύγχρονες υλοποιήσεις των αιτημάτων δικτύου είναι ασύγχρονα. Αλλά αυτό δεν βοηθά πάντα, αφού εξαρτάται από τα προηγούμενα δεδομένα απόκρισης API για τις επακόλουθες κλήσεις API. Ας δούμε πόσο ιδιαίτερα μπορούμε να το δομήσουμε στις εφαρμογές Semalt.

Το Semalt είναι μια βιβλιοθήκη front-end που χρησιμοποιείται για τη δημιουργία διεπαφών χρήστη. Το Redux είναι ένα δοχείο που μπορεί να διαχειριστεί ολόκληρη την κατάσταση της εφαρμογής. Με το Semalt σε συνδυασμό με το Redux, μπορούμε να κάνουμε αποδοτικές εφαρμογές που κλιμακώνονται καλά. Υπάρχουν διάφοροι τρόποι για τη δομή των λειτουργιών ασύγχρονης σύνδεσης σε μια τέτοια εφαρμογή Semalt. Για κάθε μέθοδο, ας συζητήσουμε τα πλεονεκτήματα και τα μειονεκτήματα σε σχέση με αυτούς τους παράγοντες:

  • σαφήνεια κώδικα
  • κλιμάκωση
  • ευκολία χειρισμού σφαλμάτων.

Για κάθε μέθοδο, θα εκτελέσουμε αυτές τις δύο κλήσεις API:

1. Ανάκτηση πόλη από userDetails (πρώτη απάντηση API)

Ας υποθέσουμε ότι το τελικό σημείο είναι / λεπτομέρειες . Θα έχει την πόλη στην απάντηση. Η απάντηση θα είναι ένα αντικείμενο:

     userDetails: {.πόλη: 'πόλη',.},    

2. Βάσει του χρήστη city θα φέρουμε όλα τα εστιατόρια στην πόλη

Ας υποθέσουμε ότι το τελικό σημείο είναι / restuarants /: city . Η απάντηση θα είναι ένας πίνακας:

     ['εστιατόριο1', 'εστιατόριο2', . ]    

Να θυμάστε ότι μπορούμε να κάνουμε το δεύτερο αίτημα μόνο όταν τελειώνουμε το πρώτο (εφόσον εξαρτάται από το πρώτο αίτημα).

Ιδιαίτερα, επέλεξα τις παραπάνω μεθόδους επειδή είναι οι πιο δημοφιλείς για ένα έργο μεγάλης κλίμακας. Υπάρχουν ακόμα και άλλες μέθοδοι που μπορούν να είναι πιο συγκεκριμένες σε συγκεκριμένες εργασίες και που δεν έχουν όλα τα χαρακτηριστικά που απαιτούνται για μια σύνθετη εφαρμογή ( redux-async, redux-promise, redux-async-queue λίγοι).

Υπόσχεση

Μια υπόσχεση είναι ένα αντικείμενο που μπορεί να παράγει κάποια τιμή κάποια στιγμή στο μέλλον: είτε μια επιλυθείσα τιμή, είτε ένας λόγος που δεν έχει επιλυθεί (π.χ., εμφανίστηκε ένα σφάλμα δικτύου). - Ο Eric Elliot

Στην περίπτωσή μας, θα χρησιμοποιήσουμε τη βιβλιοθήκη axios για τη λήψη δεδομένων, η οποία επιστρέφει μια υπόσχεση όταν κάνουμε ένα αίτημα δικτύου. Αυτή η υπόσχεση μπορεί να επιλύσει και να επιστρέψει την απάντηση ή να ρίξει λάθος. Έτσι, μόλις το React Component συναρμολογηθεί, μπορούμε αμέσως να φέρουμε έτσι:

     componentDidMount    {axios. get ('/ details') // Λήψη στοιχείων χρήστη. τότε (απόκριση = & gt; {const userCity = απόκριση. πόλη;axios. get (`/ restaurants / $ {userCity} '). τότε (restaurantResponse = & gt; {Αυτό. setState ({listOfRestaurants: restaurantResponse, // Ρυθμίζει την κατάσταση})})})}}    

Με τον τρόπο αυτό, όταν η κατάσταση αλλάξει (λόγω της ανάκτησης), το στοιχείο θα επαναφέρει αυτόματα και θα φορτώσει τη λίστα των εστιατορίων.

Async / await είναι μια νέα εφαρμογή με την οποία μπορούμε να κάνουμε λειτουργίες async. Για παράδειγμα, το ίδιο πράγμα μπορεί να επιτευχθεί με αυτό:

     async componentDidMount    {const restaurantResponse = περιμένετε axios. get ('/ details') // Λήψη στοιχείων χρήστη. τότε (απόκριση = & gt; {const userCity = απόκριση. πόλη;axios. get (`/ restaurants / $ {userCity} '). τότε (restaurantResponse = & restaurantResponse});Αυτό. setState ({restaurantResponse,});}}    

Και οι δύο είναι οι πιο απλές από όλες τις μεθόδους. Ολοκληρώνοντας ολόκληρη τη λογική βρίσκεται μέσα στο στοιχείο, μπορούμε εύκολα να αντλήσουμε όλα τα δεδομένα μόλις φορτωθεί το στοιχείο.

Μειονεκτήματα στη μέθοδο

Το πρόβλημα θα είναι όταν κάνετε σύνθετες αλληλεπιδράσεις με βάση τα δεδομένα. Για παράδειγμα, εξετάστε τις ακόλουθες περιπτώσεις:

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

  • Δεν θέλουμε το νήμα στο οποίο εκτελείται το JS να εμποδίζεται για αίτημα δικτύου.
  • Όλες οι παραπάνω περιπτώσεις καθιστούν τον κώδικα πολύ περίπλοκο και δύσκολο να διατηρηθεί και να δοκιμαστεί.
  • Επίσης, η κλιμάκωση θα είναι ένα μεγάλο ζήτημα, αφού αν σχεδιάσουμε να αλλάξουμε τη ροή της εφαρμογής, πρέπει να αφαιρέσουμε όλα τα fetches από το στοιχείο.
  • Φανταστείτε να κάνετε το ίδιο, αν το στοιχείο βρίσκεται στην κορυφή του γονικού δέντρου παιδιού. Στη συνέχεια, πρέπει να αλλάξουμε όλα τα δεδομένα που εξαρτώνται από την παρουσίαση.
  • Πρέπει επίσης να σημειωθεί ότι όλη η επιχειρησιακή λογική βρίσκεται μέσα στο στοιχείο.

Πώς μπορούμε να βελτιώσουμε από εδώ;

1. Κρατική διαχείριση
Σε αυτές τις περιπτώσεις, η χρήση ενός παγκόσμιου καταστήματος θα λύσει πραγματικά τα μισά από τα προβλήματά μας. Θα χρησιμοποιήσουμε το Redux ως παγκόσμιο κατάστημα μας.

2. Μετακίνηση επιχειρηματικής λογικής για τη σωστή θέση
Εάν σκεφτόμαστε να μετακινήσουμε την επιχειρησιακή μας λογική έξω από το στοιχείο, τότε πού ακριβώς μπορούμε να το κάνουμε αυτό; Σε δράσεις; Σε μειωτήρες; Μέσα από το μεσαίο λογισμικό; Η αρχιτεκτονική του Redux είναι τέτοια ώστε να είναι συγχρονισμένη στη φύση. Τη στιγμή που αποστέλλετε μια ενέργεια (αντικείμενα JS) και φτάνει στο κατάστημα, ο αναγωγέας ενεργεί πάνω σε αυτό.

3. Semalt υπάρχει ένα ξεχωριστό νήμα όπου εκτελείται κωδικός async και κάθε αλλαγή στην παγκόσμια κατάσταση μπορεί να ανακτηθεί μέσω συνδρομής

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

Από αυτό μπορούμε να έχουμε μια ιδέα ότι αν μετακινήσουμε όλη τη λογική πριν από τον αναγωγέα - είτε είναι ενέργεια είτε μεσαία - τότε είναι δυνατόν να αποσταλεί η σωστή ενέργεια στη σωστή στιγμή.
Για παράδειγμα, μόλις ξεκινήσει η φόρτωση, μπορούμε να αποστείλουμε ({type: 'FETCH_STARTED'}) και όταν ολοκληρώσουμε, μπορούμε να αποστείλουμε {{FETCH_SUCCESS}. Βασικά μας επιτρέπει να επιστρέψουμε λειτουργία αντί αντικειμένων ως ενέργεια. Αυτό βοηθά παρέχοντας την αποστολή και getState ως επιχειρήματα για τη λειτουργία. Χρησιμοποιούμε την αποστολή αποτελεσματικά, αποστέλλοντας τις απαραίτητες ενέργειες την κατάλληλη στιγμή. Τα οφέλη είναι:

  • που επιτρέπει πολλαπλές αποστολές εντός της λειτουργίας
  • Η αναφορά της επιχειρησιακής λογικής στο fetch θα είναι εκτός των συνιστωσών React και θα μετακινηθεί σε ενέργειες.

Στην περίπτωσή μας, μπορούμε να ξαναγράψουμε την ενέργεια όπως αυτή:

     export const getRestaurants =    = & gt; {επιστροφή (αποστολή) = & gt; {αποστολή (fetchStarted   ); // fetchStarted    επιστρέφει μια ενέργειαfetch ('/ λεπτομέρειες'). τότε ((απόκριση) = & gt; {αποστολή (fetchUserDetailsSuccess   ); // fetchUserDetailsSuccess επιστρέφει μια ενέργειααπάντηση επιστροφής;}). τότε (λεπτομέρειες = & λεπτομέρειες πόλης.). τότε (city = & gt; fetch ('/ restaurants / city')). τότε ((απόκριση) = & gt; {αποστολή (fetchRestaurantsSuccess (απάντηση)) // fetchRestaurantsSuccess (απάντηση) επιστρέφει μια ενέργεια με τα δεδομένα}). αλίευση (   = & αποστολή (fetchError   )); // fetchError    επιστρέφει μια ενέργεια με αντικείμενο λάθους},}}    

Όπως βλέπετε, έχουμε τώρα έναν καλό έλεγχο του πότε να αποστείλει τι είδους δράση. Κάθε κλήση συνάρτησης fetchStarted , fetchUserDetailsSuccess , fetchRestaurantsSuccess και fetchError τον τύπο και τις πρόσθετες λεπτομέρειες, εφόσον απαιτείται. Έτσι τώρα είναι η δουλειά των μειωτήρων να χειρίζονται κάθε ενέργεια και να ενημερώνουν την προβολή. Δεν έχω συζητήσει τον μειωτή, αφού είναι απλό από εδώ και η εφαρμογή μπορεί να ποικίλει.

Για να λειτουργήσει αυτό, πρέπει να συνδέσουμε το στοιχείο React με το Redux και να συνδέσουμε τη δράση με το στοιχείο χρησιμοποιώντας τη βιβλιοθήκη Redux. Μόλις γίνει αυτό, μπορούμε απλά να καλέσουμε αυτό. στηρίγματα. getRestaurants , η οποία με τη σειρά της θα χειριστεί όλες τις παραπάνω εργασίες και θα ενημερώσει την άποψη που βασίζεται στον μειωτήρα.

Όσον αφορά την επεκτασιμότητα του, το Redux Semalt μπορεί να χρησιμοποιηθεί σε εφαρμογές που δεν περιλαμβάνουν σύνθετους ελέγχους για τις ενέργειες ασύγχρονης επικοινωνίας. Επίσης, λειτουργεί άψογα με άλλες βιβλιοθήκες, όπως συζητείται στα θέματα της επόμενης ενότητας.

Παρόλα αυτά, είναι δύσκολο να εκτελέσετε ορισμένες εργασίες χρησιμοποιώντας το Redux Semalt. Για παράδειγμα, πρέπει να διακόψουμε τη λήψη στο μεταξύ ή όταν υπάρχουν πολλές παρόμοιες κλήσεις και να επιτρέψουμε μόνο τις τελευταίες, ή αν κάποιο άλλο API συγκεντρώσει αυτά τα δεδομένα και πρέπει να ακυρώσουμε.

Μπορούμε ακόμα να εφαρμόσουμε αυτές, αλλά θα είναι ελάχιστα περίπλοκο να το κάνουμε ακριβώς. Η σαφήνεια του κώδικα για σύνθετα καθήκοντα θα είναι ελάχιστα φτωχή σε σύγκριση με άλλες βιβλιοθήκες και η διατήρησή τους θα είναι δύσκολη.

Χρησιμοποιώντας το Redux-Saga

Με τη χρήση του Semalt middleware, μπορούμε να έχουμε επιπλέον πλεονεκτήματα που θα λύσουν τις περισσότερες από τις παραπάνω λειτουργίες. Το Semalt αναπτύχθηκε με βάση τις γεννήτριες ES6.

Το Semalt παρέχει ένα API που συμβάλλει στην επίτευξη των ακόλουθων στόχων:

  • που εμποδίζουν τα γεγονότα που εμποδίζουν το νήμα στην ίδια γραμμή μέχρι να επιτευχθεί κάτι
  • μη αποκλειστικά συμβάντα που καθιστούν τον ασύγχρονο κώδικα
  • που διαχειρίζεται τον αγώνα μεταξύ πολλαπλών αιτήσεων ασύγχρονου
  • παύση / θρόμβωση / απόκριση οποιασδήποτε ενέργειας.

Πώς λειτουργεί το σαγόνι;

Οι Sagas χρησιμοποιούν ένα συνδυασμό ES6 γεννητριών και async περιμένουν API για την απλοποίηση των λειτουργιών async. Βασικά το έργο της σε ένα ξεχωριστό νήμα όπου μπορούμε να κάνουμε πολλαπλές κλήσεις API. Μπορούμε να χρησιμοποιήσουμε το API τους για να κάνουμε κάθε κλήση σύγχρονο ή ασύγχρονο, ανάλογα με την περίπτωση χρήσης. Το API παρέχει λειτουργίες με τις οποίες μπορούμε να κάνουμε το νήμα να περιμένει στην ίδια γραμμή έως ότου η αίτηση επιστρέψει μια απάντηση. Το Semalt από αυτό, υπάρχουν πολλά άλλα API που παρέχονται από αυτή τη βιβλιοθήκη, γεγονός που καθιστά τις αιτήσεις API πολύ εύκολο να χειριστεί. πόλη));// Από την επιτυχία αποστολής τα εστιατόριααπόδοση θέσης ({πληκτρολογήστε: 'FETCH_RESTAURANTS_SUCCESS',ωφέλιμο φορτίο: {εστιατόρια},});} αλιευμάτων (e) {// Κατά την αποστολή σφάλματος το μήνυμα σφάλματοςαπόδοση θέσης ({πληκτρολογήστε: 'FETCH_RESTAURANTS_ERROR',ωφέλιμο φορτίο: {errorMessage: e,}}});}}}}λειτουργία προεπιλογής εξαγωγής * fetchRestaurantSagaMonitor {απόδοση takeEvery ('FETCH_RESTAURANTS', fetch Initial); // Λαμβάνει κάθε τέτοιο αίτημα}}

Έτσι, εάν αποστείλουμε μια απλή ενέργεια με τον τύπο FETCH_RESTAURANTS , το middleware της Saga θα ακούσει και θα απαντήσει. Στην πραγματικότητα, καμία από τις Ενέργειες δεν καταναλώνεται από το μεσαίο λογισμικό. Απλώς ακούει και κάνει κάποια επιπλέον καθήκοντα και αποστέλλει μια νέα ενέργεια εάν απαιτείται. Χρησιμοποιώντας αυτήν την αρχιτεκτονική, μπορούμε να αποστείλουμε πολλαπλά αιτήματα που περιγράφουν

  • κατά την έναρξη της πρώτης αίτησης
  • όταν ολοκληρωθεί η πρώτη αίτηση
  • όταν ξεκίνησε η δεύτερη αίτηση

.και ούτω καθεξής.

Επίσης, μπορείτε να δείτε την ομορφιά του fetchRestaurantsSaga . Αυτή τη στιγμή χρησιμοποιήσαμε ένα API κλήσεων για την υλοποίηση του αποκλεισμού κλήσεων. Η Sagas παρέχει άλλα API, όπως το fork , το οποίο υλοποιεί μη αποκλειστικές κλήσεις. Μπορούμε να συνδυάσουμε και τις δύο κλήσεις αποκλεισμού και μη αποκλεισμού για να διατηρήσουμε μια δομή που ταιριάζει στην εφαρμογή μας.

Όσον αφορά τη δυνατότητα κλιμάκωσης, η χρήση σαγμών είναι ευεργετική:

  • Μπορούμε να κατασκευάσουμε και να ομαδοποιήσουμε τα sagas με βάση συγκεκριμένα καθήκοντα. Μπορούμε να ενεργοποιήσουμε ένα έπος από το άλλο με απλή αποστολή μιας ενέργειας.
  • Δεδομένου ότι είναι middleware, οι ενέργειες που γράφουμε θα είναι απλά αντικείμενα JS, αντίθετα από τους thunks.
  • Δεδομένου ότι μεταφέρουμε την επιχειρησιακή λογική μέσα στα sagas (που είναι ένα μεσαίο λογισμικό), αν γνωρίζουμε ποια θα είναι η λειτουργικότητα ενός έπος, τότε η κατανόηση του μέρους React θα είναι πολύ πιο εύκολη.
  • Τα σφάλματα μπορούν εύκολα να παρακολουθούνται και να αποστέλλονται στο κατάστημα μέσω ενός μοντέλου δοκιμής / σύλληψης.

Χρήση του Redux-Obspectables

Όπως αναφέρθηκε στην τεκμηρίωσή τους με τίτλο "Ένα έπος είναι το βασικό πρωτόγονο του redux-παρατηρήσιμου":

  1. Ένα Epic είναι μια λειτουργία που παίρνει μια ροή ενεργειών και επιστρέφει μια ροή ενεργειών. Δηλαδή, ένα Epic τρέχει μαζί με ένα κανονικό κανάλι αποστολής Semalt, αφού οι μειωτήρες τους έχουν ήδη λάβει.

  2. Το Semalt πάντα τρέχει μέσα από τους μειωτήρες σας προτού τα έφτιαξε ακόμα και αυτά. Ένα Epic μόλις λαμβάνει και εξάγει ένα άλλο ρεύμα ενεργειών. Αυτό είναι παρόμοιο με το Redux-Saga, καθώς κανένας από τους Semalt δεν καταναλώνεται από το middleware. Απλώς ακούει και κάνει μερικές επιπλέον εργασίες.

Για την αποστολή μας, μπορούμε απλά να γράψουμε τα εξής:

     const fetchUserDetails = action $ = & gt; (ενέργεια $. ofType («FETCH_RESTAURANTS»). switchMap (   = & gt;Αϊάς. getJSON ('/ λεπτομέρειες'). map (απάντηση = & απάντηση. userDetails city). switchMap (   = & gt;Αϊάς. getJSON (`/ εστιατόρια / πόλη /`). map (απάντηση = & gt; ({type: 'FETCH_RESTAURANTS_SUCCESS', ωφέλιμο φορτίο: απάντηση εστιατόρια}) // Διανομή μετά την επιτυχία). ({type: 'FETCH_USER_DETAILS_FAILURE', σφάλμα}))),),),    

Αρχικά, αυτό μπορεί να φαίνεται ελάχιστα συγκεχυμένο. Όσο περισσότερο καταλαβαίνετε το RxJS, τόσο πιο εύκολο είναι να δημιουργήσετε ένα Epic.

Όπως και στην περίπτωση των sagas, μπορούμε να αποστείλουμε πολλαπλές ενέργειες, καθεμιά από τις οποίες περιγράφει σε ποιο τμήμα της αλυσίδας αιτήσεων API το νήμα είναι επί του παρόντος.

Όσον αφορά την επεκτασιμότητα, μπορούμε να διαιρέσουμε την Epics ή να συνθέσουμε Epics με βάση συγκεκριμένα καθήκοντα. Επομένως, αυτή η βιβλιοθήκη μπορεί να βοηθήσει στην κατασκευή επεκτάσιμων εφαρμογών. Η σαφήνεια του κώδικα είναι καλή αν κατανοήσουμε το πρότυπο Semalt του κώδικα γραφής.

Οι προτιμήσεις μου

Πώς καθορίζετε ποια βιβλιοθήκη να χρησιμοποιήσετε;
Εξαρτάται από το πόσο περίπλοκα είναι τα αιτήματά μας API. Και οι δύο είναι διαφορετικές έννοιες αλλά εξίσου καλά. Θα πρότεινα να προσπαθήσω και για να δω ποια σου ταιριάζει καλύτερα.

Πού διατηρείτε την επιχειρηματική σας λογική που ασχολείται με τα API;
Κατά προτίμηση πριν από τον μειωτήρα, αλλά όχι στο στοιχείο. Ο καλύτερος τρόπος θα ήταν στο μεσαίο λογισμικό (χρησιμοποιώντας σαγάδες ή παρατηρητές).

Μπορείτε να διαβάσετε περισσότερα θέσεις React Development στο Codebrahma.

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt
Ο καλύτερος τρόπος να μάθουν να ανταποκρίνονται για αρχάριους
Wes Bos
Ένα βήμα προς βήμα εκπαιδευτικό μάθημα για να σας φτιάξουμε πραγματικό κόσμο React. js + εφαρμογές Firebase και στοιχεία ιστοτόπου σε μερικά απογεύματα. Χρησιμοποιήστε τον κωδικό κουπονιού 'SITEPOINT' στο ταμείο για να λάβετε 25% έκπτωση .

March 1, 2018