So können wir jetzt diesen Spielbildschirm erreichen und der Computer errät
hier eine Zahl, eine Zufallszahl, die unsere reelle Zahl für die erste anfängliche Vermutung ausschließt.
Jetzt müssen wir sicherstellen, dass nachfolgende Vermutungen angestellt werden können, wenn wir hier auf dem Spielbildschirm die
untere oder größere Taste drücken. Fügen wir dazu
eine Funktion innerhalb unserer Funktionskomponente hinzu, da diese Funktion Zugriff auf den Umgebungsstatus und die
Umgebungskomponente benötigt und ihr einen beliebigen Namen gibt, wie z. B. den nächsten Rätselhandler, welchen Namen Sie bevorzugen, und dies ist eine
Funktion, die Sie sollten tatsächlich
ein Argument erhalten, die Richtung, in die die nächste Vermutung sein sollte,
also niedriger oder größer. Das erste,
was ich hier tun möchte, ist sicherzustellen, dass wir die Richtung validieren.
Jetzt sollte diese Funktion hier ausgeführt werden, wenn die Schaltflächen dort unten gedrückt werden, aber
natürlich der Richtungswert, sodass der Wert, den wir als Argument übergeben, je nach Schaltfläche unterschiedlich
sein sollte.
Hier haben wir also den nächsten Guess-Handler, der mit onPress verbunden ist, ohne Klammern, um nur diesen
Zeiger auf unsere Funktion für onPress bereitzustellen, damit dieser schließlich ausgeführt wird, wenn der Benutzer
dies drückt, aber ich habe das Argument vorkonfiguriert, das an den nächsten Guess-Handler übergeben wird wenn dies
ausgeführt wird.
Wir können dies mit bind tun, bind this, weil das erste zu bindende Argument immer das ist, worauf sich dies in
der aufgerufenen Funktion beziehen sollte, spielt hier keine Rolle, also können wir es einfach daran binden.
Der zweite Wert, den wir hier zum Binden übergeben, ist jedoch das erste Argument, das von unserer Funktion
empfangen wird. Daher ist dies die Richtung, die hier empfangen wird, und es liegt natürlich an Ihnen, welche Logik Sie
hier verwenden.
Für mich ist es sinnvoll, einfach a zu verwenden Zeichenfolge, bei der wir hier als Zeichenfolge niedriger und bei der anderen Schaltfläche größer übergeben, sodass
wir diese beiden Bezeichner haben,
die im Wesentlichen an den nächsten Guess-Handler übergeben werden. Die Richtung wird also kleiner oder größer
sein und jetzt
wollen wir überprüfen, ob das richtig ist.
Wenn Sie beispielsweise eine Zahl von beispielsweise 55 ausgewählt haben und der Computer 60 erraten hat, sollte der Hinweis auf
die Zahlen größer sein, wenn Sie einem Computer einen Hinweis geben. Dies ist offensichtlich
falsch, da die Zahl kleiner sein sollte und Ihre Zahl 55 war war 60, es
ist falsch, wenn Sie
dem Computer mitteilen, dass die Zahl, die er als nächstes erraten sollte, größer als 60 sein sollte,
oder?
Wir möchten dies
validieren und können daher hier überprüfen, ob die Richtung
gleich niedriger ist. Wenn Sie also die untere Taste gedrückt haben und die aktuelle Schätzung jedoch kleiner ist, wird die Benutzerauswahl gestützt, sodass der Computer tatsächlich eine Zahl erraten
hat, die kleiner als ist Unsere Wahl, dann niedriger ist der falsche Hinweis, richtig, weil die
Zahl
niedriger sein muss, muss sie
größer sein, weil die Vermutung bereits zu niedrig war. Das ist also ein mögliches Szenario, in dem wir einen falschen
Hinweis erhalten, die Alternative, und ich werde dies in Klammern setzen, um wirklich klar zu machen,
dass dies hier eine Bedingung ist.
Die Alternative dazu ist
die zweite Bedingung, die ich überprüfen möchte, dass die Richtung hier tatsächlich größer ist
und gleichzeitig die aktuelle Vermutung bereits größer ist als unsere Wahl, und
dann ist es auch ein falscher
Hinweis, nur in die entgegengesetzte Richtung.
In beiden Fällen, in denen wir einen falschen Hinweis geben, möchte ich eine Warnung auslösen, und Sie haben gelernt, dass Sie dies mit
der Warnungs-API tun können, der Warnungsklasse, die Sie am Ende aus React Native importieren können. Dann werde ich hier in unserem Scheck eine Warnmeldung
verwenden, um eine Warnung mit dem Titel "Sagen wir nicht lügen" auszulösen. Natürlich können Sie einen beliebigen Namen auswählen.
Ich entkomme dem einfachen Zitat,
das ich gedruckt habe als Zeichen hier mit einem führenden Backslash, da sonst die Zeichenfolge
geschlossen würde, weil ich einfache Anführungszeichen verwende, um meine Zeichenfolgen zu umgeben.
Das ist also mein Titel
und dann könnte der Text sein, dass Sie wissen, dass dies falsch ist, aber natürlich können Sie hier
jeden gewünschten Text haben, Sie können auch weniger moralisch sein, wenn Sie möchten. Jetzt möchte ich hier eine Schaltfläche präsentieren,
und die Schaltfläche erklärt, dass bereits erläuterte Objekte an das dritte Argumentarray übergeben werden,
das von der Warnung verwendet wird. Dort kann der Text entschuldigt und der Stil abgebrochen werden, und Sie müssen
keinen onPress-Handler bereitstellen. Wenn Sie keine angeben, wird nur durch Klicken auf die Schaltfläche die Warnung
geschlossen, was in Ordnung ist.
Hier tippen wir dem Benutzer sozusagen auf die Finger und stellen sicher, dass keine falschen Hinweise
gegeben werden.
Ich möchte hierher zurückkehren.
Daher möchte ich die Funktionsausführung stoppen, wenn wir einen solchen falschen Wert haben.
Wenn wir diesen if-Block überwinden,
wenn wir also einen korrekten Hinweis gegeben haben, möchten wir eine neue Zufallszahl generieren.
Hier möchte ich also überprüfen, ob die Richtung niedriger ist, und jetzt
wissen wir, dass
dies korrekt war. Der Computer sollte also eine Zahl erraten, die niedriger als die vorherige Zahl ist. Dann
wissen wir, dass eine neue Zufallszahl für eine aktuelle Vermutung generiert werden sollte die maximale Obergrenze.
Daher können wir Generate Random zwischen erneut und der Mindestanzahl aufrufen. Nun, das ist wahrscheinlich eine, aber was ist, wenn der Benutzer
bereits eine andere Zahl erraten hat, bei
der wir dem Computer mitgeteilt haben, dass sie zu klein ist, und dann hätten wir hier ein Problem,
weil die niedrigste Grenze ist nicht immer eine, was ist, wenn der Benutzer 10
erraten hat und wir nein gesagt haben, muss es größer sein?
Nun, dann schätzt der Benutzer 50 und wir sagen, es sollte niedriger sein, der Computer sollte natürlich
und wieder
raten, aber er sollte nicht unter 10 raten, da wir bereits erwähnt haben, dass dies früher zu klein ist.
Daher sollten sich unser aktuelles Maximum und Minimum im Laufe der Zeit anpassen, da wir Hinweise geben, ob die vom Computer erratene Zahl
zu klein oder zu groß ist.
Daher können wir einen anderen von React bereitgestellten Hook verwenden, und das ist der useRef-Hook.
Jetzt kennen Sie diesen Hook möglicherweise als Hook, mit dem Sie ein Objekt erstellen können, das Sie an Eingaben binden können, also
an Ihre Eingabeelemente in jsx, um Zugriff auf sie in Ihrem Code zu erhalten. Dies ist eine Möglichkeit, ihn
zu verwenden, aber useRef ermöglicht es Ihnen auch etwas anderes zu tun, was ziemlich cool ist.
Sie können einen Wert definieren, der das erneute Rendern von Komponenten überlebt, also überlebt, dass diese
Komponente neu erstellt wird, und genau das benötigen
wir hier, da wir ein Minimum und Maximum anmelden möchten, das wir ändern können, das aber
nicht nur neu generiert wird weil die Komponente erneut gerendert wird.
Hier oben in dieser Komponente können wir nach dem Initialisieren des Status eine neue Konstante
erstellen, currentLow, möglicherweise wo useRef eine ist, und dann eine andere Konstante, currentHigh, wo useRef 100 ist. Dies sind unsere anfänglichen Grenzen,
die wir für den Zufall verwenden Nummer und jetzt können wir diese Referenzen
hier aktualisieren.
Wir wissen also, dass die Richtung niedriger sein sollte. Was wir
in diesem Fall tun können, anstatt sofort eine neue Zahl zu generieren, können wir currentHigh einstellen. aktuell, da die von React generierten Referenzen
Objekte sind, die eine aktuelle Eigenschaft haben, in der der tatsächliche Wert gespeichert
ist. Daher setzen wir
den Strom gleich der aktuellen Schätzung.
Wir sagen also, wenn ich Ihnen sage, dass der Computer, den Sie erraten haben, zu groß ist und Sie einen
niedrigeren erraten sollten, dann weiß ich, dass diese Zahl, die ich vermutet habe, meine aktuelle Höhe ist. Die richtige Zahl kann ' t höher als dieser
sein, also speichere ich
die Zahl, die ich gerade erraten habe, als mein aktuelles Hoch.
Auch hier werden diese Referenzkonstanten nicht neu generiert, wenn diese Komponente erneut erstellt wird. Wenn
sie einmal initialisiert wurden, ähnlich wie der tatsächliche Status, werden sie getrennt von dieser Komponente
gespeichert und React erkennt, dass sie bereits initialisiert wurden und es werden sie
nicht neu generiert, sondern currentHigh mit dem zuvor gespeicherten Wert initialisiert.
Es ist also ein bisschen so, als ob Sie dies in einem Status verwalten würden. Der Unterschied zum Status, wenn Sie den dort
gespeicherten Wert ändern, wird die Komponente nicht erneut gerendert, da wir das hier nicht wollen.
Ich möchte die Komponente nicht erneut rendern, nur weil ich ein neues High speichere, das keine Auswirkungen auf
meine Ansicht und meinen JSX-Code
hat. Es hat nur Auswirkungen auf meine Logik, aber dafür nicht müssen die Komponente
neu rendern, deshalb verwende ich hier eine Referenz anstelle eines Status.
Das passiert also, wenn es niedriger ist, andernfalls, wenn
wir dem Computer gesagt haben, dass die Schätzung zu klein ist und die tatsächliche Anzahl
höher sein sollte,
sollte sie größer sein. In diesem Fall setzen wir den aktuellen Wert auf den aktuellen Wert, weil wir dann wissen Wir haben eine
untere Grenze.
Und jetzt ist das Ziel oder der Trick, eine neue Zufallszahl zu generieren, die diese Grenzen berücksichtigt, also
wo wir
das aktuelle Tief mit unserem Schiedsrichter verwenden und dann. Strom als Minimum und StromHoch. Maximal aktuell und ich möchte
die aktuelle Vermutung ausschließen, damit wir hier nicht wieder dieselbe Zahl erraten können, sodass wir für die
nächste Rolle definitiv eine andere Zahl erhalten. Das ist also etwas, das ich in einer konstanten nächsten Zahl
speichere. Dies wird hier
generiert, wenn der
nächste Guess-Handler ausgeführt wird, was passiert, wenn wir auf eine dieser Schaltflächen tippen.
Und jetzt ist die nächste Nummer die nächste Nummer,
die wir verwenden möchten. Was wir jetzt einfach tun können, indem wir die aktuelle Schätzung festlegen und die
nächste Nummer hinzufügen, wird die Komponente neu gerendert und die nächste Schätzung ausgegeben. Probieren wir es also aus, im Moment haben wir nicht,
dass das Spiel
überfordert ist, aber zumindest können wir hier versuchen, Zahlen zu erraten.
Also gebe ich 53 als meine Nummer
ein, jetzt starten wir und der Computer hat 85 erraten.
Wenn ich jetzt größer sage, bekommen wir diese Warnung, weil wir gelogen haben, wir hatten 53 als Zahl, also ist die Vermutung
zu
hoch, sie sollte niedriger sein. Jetzt ist es 28, nun, das
ist zu niedrig, es sollte größer sein.
Wenn ich also tiefer tippe, erhalte ich die Warnung, wenn ich größer tippe, steigen wir jetzt 78
und jetzt, in diesem Moment 23, ist die vorherige Vermutung unsere untere Grenze, und wenn ich
jetzt niedriger tippe, 78 ist die aktuelle Vermutung unsere obere Grenze, also wird
die nächste Vermutung sicherlich nicht über 78 und nicht unter 23 liegen, aber sie ist immer noch zu
niedrig, das ist zu groß, ich meine,
das ist zu niedrig, also
lasst uns
eine größere verwenden, eine niedrigere
und das wäre die richtige .
Im Moment haben wir nichts, was prüft, ob der Computer
richtig geraten hat.
Das ist das nächste, was wir hier implementieren müssen.