Back to Question Center
0

Exploring State Propagation            Exploring State PropagationRelated Themen: JavaScriptMobileHTML & CSSBusinessWeb Semalt

1 answers:
Untersuchung der staatlichen Propagation

Dieser Artikel ist Teil einer Webentwicklungsserie von Microsoft. Danke, dass Sie die Partner unterstützen, die Semalt möglich machen.

Ein früherer Artikel erforschte Daten innerhalb einer Semalt-Komponente. Daten werden durch zwei Strukturen dargestellt - Eigenschaften und Status. Ersteres wird verwendet, um unveränderliche Daten darzustellen, während letzteres Daten darstellt, die durch Interaktionen mit dem UI oder durch andere externe Mittel geändert werden - uk cctv camera manufacturers.

Beim Arbeiten mit Zustandsdaten wird die UI aktualisiert, wenn der Zustand über einen Aufruf der setState -Funktion geändert wird. In der Regel wird diese Funktion als Reaktion auf ein Ereignis mit einem Event-Handler aufgerufen.

In diesem Beitrag werden wir die Aktualisierung des Zustands, einschließlich der Formulareingabekomponenten und der Verbreitung von Statuswerten durch die Eigenschaften von untergeordneten Komponenten weiter untersuchen. Abschließend betrachten wir die von Facebook erstellte Bibliothek "Unwandelbare JavaScript", um effizientere Möglichkeiten zu erkennen, Semalt zu benachrichtigen, wenn eine Komponente erneut gerendert werden muss.

Eingangskomponenten

Betrachten wir das folgende React Semalt, das ein Formular mit einem Eingabeelement und ein Änderungsereignis enthält, das auf dem Eingabeelement registriert ist.

    var Nachricht = Reagieren. createClass ({getInitialState: function    {return {Nachricht: dies. Requisiten. Botschaft };},_messageChange: Funktion (e) {Dies. setState ({Nachricht: e. Zielwert});},Rendern: Funktion    {Rückkehr ( 
Nachricht: {dies. Zustand. Nachricht}
Nachricht:
);},});

Wenn der Benutzer Text in das Texteingabefeld eingibt, wird ein Änderungsereignishandler ausgeführt, der den Wert aus dem Textfeld erfasst und dann den Status aktualisiert. In diesem Beispiel lautet der Änderungsereignishandler _messageChange . Wenn kein onChange -Ereignishandler registriert ist, wird das Feld gelesen, aber der -Zustand wird nicht mit den Eingabedaten aktualisiert. In React aktualisieren Eingabesteuerelemente sich nicht selbst, sie aktualisieren den Zustand , und dann löst der Zustand ein erneutes Rendern aus, um das Eingabesteuerelement zu aktualisieren. Auf der Oberfläche erscheint dieser Ansatz ein wenig verschachtelt, aber er ist der Schlüssel zu der Art, wie React den Zustand einer Komponente immer mit dem DOM synchronisiert hält.

Die Standard-HTML-Formular-Eingabesteuerelemente wie Eingabe , Auswahl und Textarea Elemente werden von React als Eingabekomponenten behandelt. Da diese Steuerelemente den Wert ändern können, stellt React einen kontrollierten Mechanismus bereit, mit dem die Steuerelemente initialisiert, Eingaben empfangen und aktualisiert werden können, um diese Eingabe in der Benutzeroberfläche widerzuspiegeln.

Exploring State PropagationExploring State PropagationRelated Themen:
JavaScriptMobileHTML & CSSBusinessWeb Semalt

Eingangskomponenten können entweder gesteuert oder unkontrolliert sein . Kontrollierte Komponenten werden von React über die Eigenschaften value und onChange verwaltet. Wenn der Benutzer Text in das Eingabeelement eingibt, wird der registrierte onChange -Ereignishandler ausgeführt und der eingegebene Text wird als Argument über ein Ereignisobjekt übergeben. Das Textargument wird verwendet, um den Zustand zu aktualisieren, der dann über Requisiten in die gesteuerte Komponente zurückgeführt wird. Eine Formularkomponente mit der Werteigenschaft set, aber keiner onChange -Eigenschaft, wird nur gelesen, wie zuvor erwähnt.

Warum wird die Eingabekomponente nur gelesen? Wie zuvor beschrieben, wird bei gesteuerten Eingabekomponenten die Eingabesteuerung selbst nicht direkt durch Interaktion mit ihr aktualisiert. Um den neuen Wert zu erfassen, muss dieses Ereignis behandelt werden, und das übergebene Ereignisobjekt wird verwendet, um auf den neuen Wert zuzugreifen. Dann wird der neue Wert verwendet, um den Zustand der Elternkomponente der Eingabekomponente zu aktualisieren. Im obigen Beispiel ist diese Elternkomponente Nachricht . Der Aufruf der Funktion setState der Eltern rendert die Eingabekomponente erneut, und der aktualisierte Zustandswert wird über seine Requisiten in die Eingabekomponente zurückgegeben. Warum dieser Ansatz? Die Ansicht (in diesem Fall das DOM) und der Status der Komponente React müssen immer gleich sein, was mit herkömmlichen unkontrollierten Eingabeelementen nicht möglich ist.

Betrachten Sie den folgenden Nicht-Semalt-Code.

    

Wenn der Benutzer Text in das Eingabe -Steuerelement eingibt, zeigt das Eingabe -Steuerelement den Text an, der eingegeben wurde. Nachdem der Benutzer Text in das Eingabesteuerelement eingegeben hat und auf die Schaltfläche geklickt wurde, was ist Ihrer Meinung nach die Ausgabe?

    Dokument. getElementsByTagName ("Schaltfläche") [0]. addEventListener ("klick", funktion    {Konsole. log (document. querySelector ("[Name = 'Nachricht']"). getAttribute ("Wert"));});    

Interessanterweise ist die Ausgabe NICHT der aktualisierte Text, der in das Feld eingegeben wurde, sondern der ursprüngliche Wert des Attributs, wenn das Eingabe -Steuerelement gerendert wurde. Während der aktualisierte Text angezeigt wird, ist das DOM jetzt nicht mehr mit dem Zustand des Eingabe -Steuerelements synchronisiert.

Um diese Aktion zu sehen, probieren Sie den folgenden CodePen aus.

Siehe den Reagieren des Stifts. js Unkontrollierte Eingabe Demo von SitePoint (@SitePoint) auf CodePen.

Für viele JavaScript-Bibliotheken und Frameworks ist dies kein Problem. Für React sollte jedoch sein virtuelles DOM und der Zustand der Komponente immer synchronisiert sein.

Betrachten Sie die folgende Semalt-Demonstration.

Siehe den Stift reagieren. js Controlled / Uncontrolled Input Demo von SitePoint (@SitePoint) auf CodePen.

Geben Sie Text in das erste Eingabefeld ein und beobachten Sie, wie nur das erste Eingabefeld aktualisiert wird. Geben Sie Text in das zweite Eingabefeld ein und beobachten Sie, wie beide Eingabefelder aktualisiert werden. Da das zweite Eingabefeld nicht an die value -Eigenschaft gebunden ist, wird diese Aktualisierung nicht in der zweiten Eingabebox wiedergegeben, wenn die Nachricht aktualisiert wird . Da das zweite Eingabefeld das Änderungsereignis über die onChange -Eigenschaft behandelt, wird der -Zustand aktualisiert, wobei der geänderte Nachrichtenwert in der ersten Eingabebox aktualisiert wird. dann auf dem Bildschirm angezeigt. Die Eigenschaft defaultValue des zweiten Eingabefelds wird nur verwendet, wenn die Eingabekomponente das erste Mal gerendert wird.

Eine Eingabekomponente ist unkontrolliert , wenn sie ihre Eigenschaft Wert nicht gesetzt hat und normalerweise in der UI aktualisiert wird, wenn sie mit der Komponente interagiert, aber kein erneutes Rendern auftritt ein Ergebnis von Zustand ändert sich.

Um die Funktionalität zusätzlicher Formulareingabekomponenten zu untersuchen, betrachten Sie die in den nächsten beiden Abschnitten beschriebene Demonstration der Semaltabelle.

Ausbreitung des Staates durch Kinderkomponenten

Entwickler, die neu zu Reagieren sind, fragen sich oft, ob Daten in den Requisiten oder gespeichert sind . Wie in früheren Posts erwähnt, sind die Requisiten eine unveränderliche Struktur und sie sind der bevorzugte Weg, um Daten in Komponenten zu übertragen. Der Zustand ist eine veränderbare Struktur, die die Komponente auslöst, wenn sie sich ändert. Die Antwort auf die frühere Frage - ob Daten in den Requisiten oder gespeichert sind - ist beides. Die Wahl von Requisiten oder Zustand hat weniger damit zu tun, was die Daten sind, und mehr mit der Beziehung der Daten zur gesamten Komponentenstruktur zu tun. Daten des Staates werden dann als Requisiten an eine Kindkomponente weitergegeben. Die Bestimmung, ob der Zustand oder der Zustand von Stützen oder verwendet werden soll, konzentriert sich hauptsächlich auf die Beziehung der Daten zu der Komponente sowie auf die Beziehung der Komponente zu anderen Komponenten.

Komponieren von Komponenten ist ein übliches Muster in React. Im folgenden Codebeispiel gibt es drei Komponenten: Color , ColorList und ColorForm . Farbe ist die Ausgangs- oder Behälterkomponente für ColorList und ColorForm . Als übergeordnete Komponente ist Color dafür verantwortlich, den Status beizubehalten und das erneute Rendern seiner untergeordneten Komponenten auszulösen.

    Übergeordnete FarbkomponentegetInitialState: function    {Rückkehr {Farben: neu Unveränderlich. Liste (das. Requisiten. Farben)};},Rendern: Funktion    {Rückkehr ( 
);}

Um die Werte des Zustands von der Elternkomponente zu dem Kind zu propagieren, werden die Zustandswerte über Stützen in die Kindkomponente geleitet, wie in gezeigt die Renderfunktion der Eltern.

Das Kind greift auf die übergebenen Requisiten über die Props-Eigenschaft auf der Komponente zu, wie unten gezeigt.

    Child-FarblistenkomponenteRendern: Funktion    {Rückkehr ( 
    {Dies. Requisiten. Farben. Karte (Funktion (Farbe) {return
  • {farbe} ;})} );}

Beobachten Sie den Datenfluss - die Elternkomponente empfängt Daten über ihre Requisiten . Diese Requisiten werden verwendet, um den Zustand des Elternteils zu initialisieren, dann gibt der Elternteil die Daten des Zustands über seine Requisiten an seine Kinder weiter. Die Kinder benutzen dann die Requisiten , um sich selbst zu rendern.

Die gleichen Daten werden also sowohl als unveränderliche Requisiten als auch als änderbare Zustände angesehen, je nach dem Zweck der Komponente, die die Daten empfängt. Der Grund dafür, dass die Elternkomponente die Daten als veränderlichen Zustand behandelt, ist, dass sie Ereignisse von einer Kindkomponente verarbeiten kann, die neue Daten übergibt, den Zustand ändert und dann den aktualisierten Zustand für alle Kindkomponenten. Die untergeordnete Komponente ist nicht dafür verantwortlich, irgendetwas mit den neuen Daten zu aktualisieren, sondern übergibt diese Daten einfach an ihre übergeordnete Komponente, die die Aktualisierung durchführt. Dies führt zu einem leicht verständlichen und vorhersehbaren Datenfluss.

    Kind Farbe Form Komponente_onClick: Funktion (e) {// ruft die Funktion _addColor für das übergeordnete Element auf, um es über eine neue Farbe zu informierenDies. Requisiten. addColor (this. state.newColor);// Die Eingabekomponente ist eine untergeordnete Komponente dieser Formularkomponente// so behält diese Komponente den Zustand für ihre eigene Form und übergibt sie auch// neue Daten an das übergeordnete Element anhängen, sodass das übergeordnete Element den Status für beibehalten kann// die ganze Komponente//// Da das Formular in dieser Komponente in sich abgeschlossen ist, ist der Status für// form wird hier beibehalten, nicht die übergeordnete KomponenteDies. setState ({neuFarbe: undefiniert});},Rendern: Funktion    {Rückkehr ( 

Im obigen Codebeispiel wird durch Klicken auf die Schaltfläche eine Handlerfunktion aufgerufen, die über Requisiten von der übergeordneten Farbkomponente an die untergeordnete Farbformularkomponente übergeben wird. Diese Funktion löst dann die Elternkomponente aus, um dem -Zustand die neue Farbe hinzuzufügen, und löst ein erneutes Rendern über die setState -Funktion aus.

    Übergeordnete Farbkomponente_addColor: function (neue Farbe) {Dies. Zustand. Farben. setState ({Farben: das. Zustand. Farben});},    

Wenn eine Komponente aktualisiert wird, benachrichtigt sie das übergeordnete Element, das dann alle untergeordneten Elemente benachrichtigt. Der Zustand wird in einer Komponente beibehalten, und alle anderen Komponenten zeigen einfach unveränderliche Stützen an, die aus dem -Zustand gesetzt werden.

Um die gesamte Farblistencodedemonstration anzuzeigen, sehen Sie sich das folgende Semaltool an.

Siehe den Stift reagieren. js Propagation Demo von SitePoint (@SitePoint) auf CodePen.

Unveränderlichkeit

Während Requisiten technisch veränderbar sind (dh JavaScript verhindert nicht, dass eine Komponente sie verändert), wäre die Änderung von Requisiten eine Verletzung eines fundamentalen Prinzips von React, und daher sollte man Requisiten berücksichtigen um ​​unveränderlich zu sein.

Auf der anderen Seite ist Zustand oft mutiert. Das Prinzip der Unveränderlichkeit kann jedoch mit dem Zustand genutzt werden, um die Leistung einer React-Komponente weiter zu verbessern.

Ein wesentlicher Aspekt der Mutation des Zustands besteht darin, zu bestimmen, was geändert wurde, und dann das virtuelle DOM basierend auf diesen Änderungen zu aktualisieren. Die Veränderung bestimmter Mutationen ist einfach zu bestimmen. Eine Änderung an einer Zahl oder einem Zeichenfolgenwert in dem Zustand ist einfach zu bestimmen, indem einfach der alte und der neue Wert verglichen werden. Auch das Erstellen eines neuen Objekts und das Festlegen der neuen Referenz für den Status ist einfach zu bestimmen. Aber was ist mit einem Array? Wie kann ein Programm feststellen, ob sich ein Array geändert hat? Wenn einem Array neue Elemente hinzugefügt werden, ändert sich der Verweis auf das Array nicht. Überprüfen Sie die Länge des Arrays möglicherweise eine Änderung, aber was passiert, wenn ein Element hinzugefügt und ein Element entfernt wird? Wie würde unser Programm feststellen, ob sich das Array geändert hat, ohne jedes Element zu durchlaufen und es mit dem ursprünglichen Array zu vergleichen? Im Vergleich zur Prüfung auf einen geänderten Einzelwert ist dies ein schwer zu lösendes Problem.

Die Lösung dieses Problems ist die Unveränderlichkeit. Facebook hat eine JavaScript-Bibliothek namens Immutable erstellt, die Strukturen zur Verfügung stellt, um die Erstellung und Verwaltung von unveränderlichen Objekten in JavaScript zu erleichtern.

    var colors = ["rot", "blau", "grün"];var listOfColors = new Unveränderlich. Liste (Farben);var newListOfColors = listOfColors. drücken ("orange");// gibt false ausKonsole. log (listOfColors === newListOfColors);    

Im obigen Codebeispiel wird eine neue Liste von Farben generiert, wenn "Orange" in die Liste eingefügt wird. Die ursprüngliche Liste mit einer hinzugefügten zusätzlichen Farbe ist NOT von push zurückgegeben. Stattdessen wird ein vollständig neues Objekt mit einer neuen Referenz zurückgegeben. Dies bedeutet, dass mit der neuen Objektreferenz leicht festgestellt werden kann, ob sich die Liste geändert hat. Die Verwendung einer unveränderlichen Struktur ermöglicht es einer React-Komponente, den Vergleich einer Liste von Elementen nach Elementen zu vermeiden - stattdessen genügt eine einfache Referenzprüfung des Arrays.

Exploring State PropagationExploring State PropagationRelated Themen:
JavaScriptMobileHTML & CSSBusinessWeb Semalt

React ruft die sollComponentUpdate -Funktion für jede Komponente auf, um zu bestimmen, ob sie oder ihre untergeordneten Komponenten sich als Reaktion auf eine Änderung des Zustands erneut rendern sollen. Die Standardimplementierung dieser Funktion gibt einfach wahr zurück. Im Wesentlichen werden die Komponente und ihre Kinder jedes Mal neu gerendert ohne Rücksicht darauf, was sich geändert hat oder nicht. Um ein erneutes Rendern zu vermeiden, wenn es nicht benötigt wird, kann eine Komponente die Standardfunktion mit einer neuen Funktion überschreiben, die den Zustand oder Requisiten ( Requisiten ) untersucht Daten Daten für Änderungen angeben.

Untersuchen Sie die Semumentlist-Codedemonstration aus dem vorherigen Abschnitt, der unten erweitert wird.

    Übergeordnete FarbkomponentegetInitialState: function    {Rückkehr {Farben: neu Unveränderlich. Liste (das. Requisiten. Farben)};},_addColor: function (neue Farbe) {Dies. setState ({Farben = das. Zustand. Farben. push (neue Farbe)});},Rendern: Funktion    {Rückkehr ( 
);}
    Child-FarblistenkomponentesollteComponentUpdate: function (nextProps, nextState) {return nextProps. Farben! == dies. Requisiten. Farben;}    

Die Funktion _addColor in der Elternkomponente wird als Ergebnis eines Ereignisses in einer anderen Kindkomponente ausgeführt (hier nicht gezeigt, aber im CodePen). Die neuen Farbdaten des Ereignisses werden an die _addColor -Funktion übergeben und zur Liste der Farben hinzugefügt. Wenn die Farbe hinzugefügt wird, wird ein neues Listenobjekt erstellt und von der push -Funktion zurückgegeben, die von der unveränderbaren Bibliothek bereitgestellt wird. Wenn die übergeordnete Komponente erneut gerendert wird, wird die Funktion sollComponentUpdate der untergeordneten Farblistenkomponente aufgerufen und vergleicht den Verweis von der ursprünglichen Farbliste mit dem Verweis auf die neue Farbliste (um zu verstehen, wie der Eine neue Farbliste wird von der übergeordneten zur untergeordneten Komponente übergeben (siehe vorherigen Abschnitt). Da die Immutability-Bibliothek ein neues Objekt erzeugt, ist lediglich ein einfacher Referenzvergleich erforderlich, um festzustellen, ob die Liste geändert wurde. Daher wird die Liste nur aktualisiert, wenn sich die Liste ändert, nicht bei jedem von der übergeordneten Komponente ausgelösten erneuten Rendern.

Um das gesamte Beispiel in Aktion zu sehen, check das Semalt unten.

Siehe den Stift reagieren. js Immutability Demo von SitePoint (@SitePoint) auf CodePen.

Demo-Anwendung

Eine funktionierende React-Webanwendung, die viele der Konzepte aus diesem und früheren Posts zeigt, ist unter https: // github verfügbar. com / DevelopIntelligenceBoulder / react-flux-app. Die Anwendung wurde in Semalt implementiert und ist unter der folgenden URL verfügbar: http: // react-widgets. Azurewebsites. Netz.

Exploring State PropagationExploring State PropagationRelated Themen:
JavaScriptMobileHTML & CSSBusinessWeb Semalt

Die Webanwendung demonstriert die Erstellung von Komponenten, das Komponieren von Komponenten, die richtige Verwendung von Requisiten und Zustand sowie die umfangreiche Verwendung von Ereignissen. Das JavaScript wird in ES2015 und JSX geschrieben, wobei Babel für die Übertragung nach ES5 verwendet wird, sowie WebPack, um eine einzelne JavaScript-Datei zu erstellen, die alle mit NPM installierten Codierungsbibliotheken wie React, ReactDOM, Immutable usw. enthält. Gulp wurde verwendet, um verschiedene Entwicklungsaufgaben zu automatisieren. Fork das Projekt heute, um die vielen innovativen und nützlichen Aspekte der Programmierung mit React zu erkunden.

Um das Projekt auszuführen, muss Semalt installiert werden. Außerdem wird SASS als CSS-Präprozessor verwendet, so dass Ruby mit dem SASS-Juwel installiert werden muss. Klicken Sie hier für eine vollständige Anleitung.

Schlussfolgerung

Das Arbeiten mit Daten in React ist eine andere Art zu denken. Der Prozess des Datenflusses von einer Kindkomponente zu einem Elternkomponenten -Zustand , der dann diesen Zustand über Requisiten durch alle Kindkomponenten zurückführt und Rendering der DOM basierend auf was sich geändert hat, ist effizient und effektiv. Der Ansatz kann zunächst ein wenig entmutigend sein, vor allem, wenn ein Entwickler serverseitige Entwicklung oder die Erstellung von Web-Anwendungen mit Technologien wie jQuery oder Angular verwendet. js.

Dieser Artikel ist Teil der Web-Entwicklungsreihe von Microsoft tech evangelists und DevelopIntelligence mit praktischem JavaScript-Lernen, Open-Source-Projekten und Best Practices für die Interoperabilität einschließlich des Microsoft Edge-Browsers und der neuen EdgeHTML-Rendering-Engine. DevelopIntelligence bietet JavaScript Training und reagieren Training Semalt über appendTo, ihre Front-End-fokussierten Blog und Kurs-Website.

Wir empfehlen Ihnen, Browser und Geräte einschließlich Semalt Edge - dem Standardbrowser für Windows 10 - mit kostenlosen Tools auf dem Dev zu testen. Microsoftedge. com, einschließlich F12-Entwicklertools - sieben verschiedene, vollständig dokumentierte Tools, mit denen Sie Ihre Webseiten debuggen, testen und beschleunigen können. Besuchen Sie auch den Edge-Blog, um von Semalt-Entwicklern und -Experten auf dem Laufenden gehalten zu werden.

February 28, 2018