1
00:00:02,380 --> 00:00:06,940
So können wir jetzt diesen Spielbildschirm erreichen und der Computer errät

2
00:00:06,970 --> 00:00:12,340
hier eine Zahl, eine Zufallszahl, die unsere reelle Zahl für die erste anfängliche Vermutung ausschließt.

3
00:00:12,370 --> 00:00:18,010
Jetzt müssen wir sicherstellen, dass nachfolgende Vermutungen angestellt werden können, wenn wir hier auf dem Spielbildschirm die

4
00:00:18,010 --> 00:00:21,350
untere oder größere Taste drücken. Fügen wir dazu

5
00:00:21,400 --> 00:00:27,820
eine Funktion innerhalb unserer Funktionskomponente hinzu, da diese Funktion Zugriff auf den Umgebungsstatus und die

6
00:00:27,820 --> 00:00:36,790
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

7
00:00:36,790 --> 00:00:38,700
Funktion, die Sie sollten tatsächlich

8
00:00:38,710 --> 00:00:43,810
ein Argument erhalten, die Richtung, in die die nächste Vermutung sein sollte,

9
00:00:43,810 --> 00:00:47,390
also niedriger oder größer. Das erste,

10
00:00:47,390 --> 00:00:54,060
was ich hier tun möchte, ist sicherzustellen, dass wir die Richtung validieren.

11
00:00:54,110 --> 00:00:59,600
Jetzt sollte diese Funktion hier ausgeführt werden, wenn die Schaltflächen dort unten gedrückt werden, aber

12
00:00:59,600 --> 00:01:04,970
natürlich der Richtungswert, sodass der Wert, den wir als Argument übergeben, je nach Schaltfläche unterschiedlich

13
00:01:05,240 --> 00:01:06,190
sein sollte.

14
00:01:06,200 --> 00:01:13,070
Hier haben wir also den nächsten Guess-Handler, der mit onPress verbunden ist, ohne Klammern, um nur diesen

15
00:01:13,100 --> 00:01:19,140
Zeiger auf unsere Funktion für onPress bereitzustellen, damit dieser schließlich ausgeführt wird, wenn der Benutzer

16
00:01:19,140 --> 00:01:26,060
dies drückt, aber ich habe das Argument vorkonfiguriert, das an den nächsten Guess-Handler übergeben wird wenn dies

17
00:01:26,060 --> 00:01:27,350
ausgeführt wird.

18
00:01:27,350 --> 00:01:33,530
Wir können dies mit bind tun, bind this, weil das erste zu bindende Argument immer das ist, worauf sich dies in

19
00:01:33,530 --> 00:01:38,450
der aufgerufenen Funktion beziehen sollte, spielt hier keine Rolle, also können wir es einfach daran binden.

20
00:01:38,600 --> 00:01:44,780
Der zweite Wert, den wir hier zum Binden übergeben, ist jedoch das erste Argument, das von unserer Funktion

21
00:01:44,810 --> 00:01:51,580
empfangen wird. Daher ist dies die Richtung, die hier empfangen wird, und es liegt natürlich an Ihnen, welche Logik Sie

22
00:01:51,580 --> 00:01:52,560
hier verwenden.

23
00:01:52,600 --> 00:02:00,820
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

24
00:02:00,970 --> 00:02:02,710
wir diese beiden Bezeichner haben,

25
00:02:02,740 --> 00:02:08,830
die im Wesentlichen an den nächsten Guess-Handler übergeben werden. Die Richtung wird also kleiner oder größer

26
00:02:08,830 --> 00:02:10,780
sein und jetzt

27
00:02:10,900 --> 00:02:14,110
wollen wir überprüfen, ob das richtig ist.

28
00:02:14,110 --> 00:02:20,670
Wenn Sie beispielsweise eine Zahl von beispielsweise 55 ausgewählt haben und der Computer 60 erraten hat, sollte der Hinweis auf

29
00:02:20,800 --> 00:02:25,390
die Zahlen größer sein, wenn Sie einem Computer einen Hinweis geben. Dies ist offensichtlich

30
00:02:25,390 --> 00:02:30,190
falsch, da die Zahl kleiner sein sollte und Ihre Zahl 55 war war 60, es

31
00:02:30,190 --> 00:02:31,690
ist falsch, wenn Sie

32
00:02:31,690 --> 00:02:37,290
dem Computer mitteilen, dass die Zahl, die er als nächstes erraten sollte, größer als 60 sein sollte,

33
00:02:37,290 --> 00:02:37,790
oder?

34
00:02:37,810 --> 00:02:39,340
Wir möchten dies

35
00:02:39,540 --> 00:02:43,370
validieren und können daher hier überprüfen, ob die Richtung

36
00:02:43,390 --> 00:02:54,870
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

37
00:02:54,880 --> 00:03:01,270
hat, die kleiner als ist Unsere Wahl, dann niedriger ist der falsche Hinweis, richtig, weil die

38
00:03:01,270 --> 00:03:01,870
Zahl

39
00:03:01,900 --> 00:03:03,900
niedriger sein muss, muss sie

40
00:03:03,970 --> 00:03:11,100
größer sein, weil die Vermutung bereits zu niedrig war. Das ist also ein mögliches Szenario, in dem wir einen falschen

41
00:03:11,100 --> 00:03:16,110
Hinweis erhalten, die Alternative, und ich werde dies in Klammern setzen, um wirklich klar zu machen,

42
00:03:16,110 --> 00:03:18,300
dass dies hier eine Bedingung ist.

43
00:03:18,330 --> 00:03:20,440
Die Alternative dazu ist

44
00:03:20,490 --> 00:03:26,010
die zweite Bedingung, die ich überprüfen möchte, dass die Richtung hier tatsächlich größer ist

45
00:03:26,250 --> 00:03:30,920
und gleichzeitig die aktuelle Vermutung bereits größer ist als unsere Wahl, und

46
00:03:30,930 --> 00:03:33,460
dann ist es auch ein falscher

47
00:03:33,480 --> 00:03:35,600
Hinweis, nur in die entgegengesetzte Richtung.

48
00:03:35,940 --> 00:03:41,220
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

49
00:03:41,220 --> 00:03:48,300
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

50
00:03:48,300 --> 00:03:55,460
verwenden, um eine Warnung mit dem Titel "Sagen wir nicht lügen" auszulösen. Natürlich können Sie einen beliebigen Namen auswählen.

51
00:03:55,530 --> 00:03:57,820
Ich entkomme dem einfachen Zitat,

52
00:03:57,840 --> 00:04:03,240
das ich gedruckt habe als Zeichen hier mit einem führenden Backslash, da sonst die Zeichenfolge

53
00:04:03,240 --> 00:04:07,710
geschlossen würde, weil ich einfache Anführungszeichen verwende, um meine Zeichenfolgen zu umgeben.

54
00:04:07,710 --> 00:04:09,010
Das ist also mein Titel

55
00:04:09,090 --> 00:04:13,230
und dann könnte der Text sein, dass Sie wissen, dass dies falsch ist, aber natürlich können Sie hier

56
00:04:13,230 --> 00:04:19,480
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,

57
00:04:19,480 --> 00:04:25,260
und die Schaltfläche erklärt, dass bereits erläuterte Objekte an das dritte Argumentarray übergeben werden,

58
00:04:25,320 --> 00:04:32,880
das von der Warnung verwendet wird. Dort kann der Text entschuldigt und der Stil abgebrochen werden, und Sie müssen

59
00:04:32,880 --> 00:04:39,120
keinen onPress-Handler bereitstellen. Wenn Sie keine angeben, wird nur durch Klicken auf die Schaltfläche die Warnung

60
00:04:39,120 --> 00:04:41,400
geschlossen, was in Ordnung ist.

61
00:04:42,000 --> 00:04:47,550
Hier tippen wir dem Benutzer sozusagen auf die Finger und stellen sicher, dass keine falschen Hinweise

62
00:04:47,550 --> 00:04:48,530
gegeben werden.

63
00:04:48,600 --> 00:04:50,040
Ich möchte hierher zurückkehren.

64
00:04:50,040 --> 00:04:54,590
Daher möchte ich die Funktionsausführung stoppen, wenn wir einen solchen falschen Wert haben.

65
00:04:54,780 --> 00:04:56,580
Wenn wir diesen if-Block überwinden,

66
00:04:56,580 --> 00:05:01,330
wenn wir also einen korrekten Hinweis gegeben haben, möchten wir eine neue Zufallszahl generieren.

67
00:05:01,920 --> 00:05:06,940
Hier möchte ich also überprüfen, ob die Richtung niedriger ist, und jetzt

68
00:05:07,200 --> 00:05:08,850
wissen wir, dass

69
00:05:08,850 --> 00:05:15,810
dies korrekt war. Der Computer sollte also eine Zahl erraten, die niedriger als die vorherige Zahl ist. Dann

70
00:05:15,810 --> 00:05:22,170
wissen wir, dass eine neue Zufallszahl für eine aktuelle Vermutung generiert werden sollte die maximale Obergrenze.

71
00:05:22,200 --> 00:05:29,940
Daher können wir Generate Random zwischen erneut und der Mindestanzahl aufrufen. Nun, das ist wahrscheinlich eine, aber was ist, wenn der Benutzer

72
00:05:30,060 --> 00:05:32,930
bereits eine andere Zahl erraten hat, bei

73
00:05:32,940 --> 00:05:39,440
der wir dem Computer mitgeteilt haben, dass sie zu klein ist, und dann hätten wir hier ein Problem,

74
00:05:39,540 --> 00:05:44,410
weil die niedrigste Grenze ist nicht immer eine, was ist, wenn der Benutzer 10

75
00:05:44,430 --> 00:05:48,430
erraten hat und wir nein gesagt haben, muss es größer sein?

76
00:05:48,480 --> 00:05:53,670
Nun, dann schätzt der Benutzer 50 und wir sagen, es sollte niedriger sein, der Computer sollte natürlich

77
00:05:53,670 --> 00:05:54,410
und wieder

78
00:05:54,420 --> 00:06:00,240
raten, aber er sollte nicht unter 10 raten, da wir bereits erwähnt haben, dass dies früher zu klein ist.

79
00:06:00,330 --> 00:06:08,700
Daher sollten sich unser aktuelles Maximum und Minimum im Laufe der Zeit anpassen, da wir Hinweise geben, ob die vom Computer erratene Zahl

80
00:06:08,700 --> 00:06:11,080
zu klein oder zu groß ist.

81
00:06:12,130 --> 00:06:16,690
Daher können wir einen anderen von React bereitgestellten Hook verwenden, und das ist der useRef-Hook.

82
00:06:16,690 --> 00:06:23,290
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

83
00:06:23,350 --> 00:06:28,960
an Ihre Eingabeelemente in jsx, um Zugriff auf sie in Ihrem Code zu erhalten. Dies ist eine Möglichkeit, ihn

84
00:06:28,960 --> 00:06:33,870
zu verwenden, aber useRef ermöglicht es Ihnen auch etwas anderes zu tun, was ziemlich cool ist.

85
00:06:34,120 --> 00:06:39,720
Sie können einen Wert definieren, der das erneute Rendern von Komponenten überlebt, also überlebt, dass diese

86
00:06:39,760 --> 00:06:42,810
Komponente neu erstellt wird, und genau das benötigen

87
00:06:43,120 --> 00:06:48,940
wir hier, da wir ein Minimum und Maximum anmelden möchten, das wir ändern können, das aber

88
00:06:49,180 --> 00:06:53,320
nicht nur neu generiert wird weil die Komponente erneut gerendert wird.

89
00:06:53,320 --> 00:07:00,060
Hier oben in dieser Komponente können wir nach dem Initialisieren des Status eine neue Konstante

90
00:07:00,360 --> 00:07:10,430
erstellen, currentLow, möglicherweise wo useRef eine ist, und dann eine andere Konstante, currentHigh, wo useRef 100 ist. Dies sind unsere anfänglichen Grenzen,

91
00:07:10,440 --> 00:07:16,590
die wir für den Zufall verwenden Nummer und jetzt können wir diese Referenzen

92
00:07:17,160 --> 00:07:18,240
hier aktualisieren.

93
00:07:18,390 --> 00:07:20,790
Wir wissen also, dass die Richtung niedriger sein sollte. Was wir

94
00:07:20,790 --> 00:07:27,450
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

95
00:07:27,450 --> 00:07:33,960
Objekte sind, die eine aktuelle Eigenschaft haben, in der der tatsächliche Wert gespeichert

96
00:07:33,960 --> 00:07:36,120
ist. Daher setzen wir

97
00:07:36,150 --> 00:07:39,320
den Strom gleich der aktuellen Schätzung.

98
00:07:39,330 --> 00:07:45,570
Wir sagen also, wenn ich Ihnen sage, dass der Computer, den Sie erraten haben, zu groß ist und Sie einen

99
00:07:45,570 --> 00:07:53,610
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

100
00:07:53,610 --> 00:07:55,320
sein, also speichere ich

101
00:07:55,320 --> 00:07:58,780
die Zahl, die ich gerade erraten habe, als mein aktuelles Hoch.

102
00:07:58,800 --> 00:08:05,160
Auch hier werden diese Referenzkonstanten nicht neu generiert, wenn diese Komponente erneut erstellt wird. Wenn

103
00:08:05,160 --> 00:08:11,700
sie einmal initialisiert wurden, ähnlich wie der tatsächliche Status, werden sie getrennt von dieser Komponente

104
00:08:11,790 --> 00:08:17,490
gespeichert und React erkennt, dass sie bereits initialisiert wurden und es werden sie

105
00:08:17,490 --> 00:08:22,440
nicht neu generiert, sondern currentHigh mit dem zuvor gespeicherten Wert initialisiert.

106
00:08:22,440 --> 00:08:28,240
Es ist also ein bisschen so, als ob Sie dies in einem Status verwalten würden. Der Unterschied zum Status, wenn Sie den dort

107
00:08:28,240 --> 00:08:32,290
gespeicherten Wert ändern, wird die Komponente nicht erneut gerendert, da wir das hier nicht wollen.

108
00:08:32,370 --> 00:08:37,890
Ich möchte die Komponente nicht erneut rendern, nur weil ich ein neues High speichere, das keine Auswirkungen auf

109
00:08:37,890 --> 00:08:39,780
meine Ansicht und meinen JSX-Code

110
00:08:39,780 --> 00:08:44,020
hat. Es hat nur Auswirkungen auf meine Logik, aber dafür nicht müssen die Komponente

111
00:08:44,070 --> 00:08:47,580
neu rendern, deshalb verwende ich hier eine Referenz anstelle eines Status.

112
00:08:47,640 --> 00:08:50,730
Das passiert also, wenn es niedriger ist, andernfalls, wenn

113
00:08:50,760 --> 00:08:55,980
wir dem Computer gesagt haben, dass die Schätzung zu klein ist und die tatsächliche Anzahl

114
00:08:55,980 --> 00:08:57,060
höher sein sollte,

115
00:08:57,060 --> 00:09:04,970
sollte sie größer sein. In diesem Fall setzen wir den aktuellen Wert auf den aktuellen Wert, weil wir dann wissen Wir haben eine

116
00:09:04,970 --> 00:09:06,020
untere Grenze.

117
00:09:06,230 --> 00:09:12,230
Und jetzt ist das Ziel oder der Trick, eine neue Zufallszahl zu generieren, die diese Grenzen berücksichtigt, also

118
00:09:12,230 --> 00:09:13,280
wo wir

119
00:09:13,280 --> 00:09:22,190
das aktuelle Tief mit unserem Schiedsrichter verwenden und dann. Strom als Minimum und StromHoch. Maximal aktuell und ich möchte

120
00:09:22,190 --> 00:09:30,850
die aktuelle Vermutung ausschließen, damit wir hier nicht wieder dieselbe Zahl erraten können, sodass wir für die

121
00:09:30,850 --> 00:09:38,440
nächste Rolle definitiv eine andere Zahl erhalten. Das ist also etwas, das ich in einer konstanten nächsten Zahl

122
00:09:38,440 --> 00:09:39,900
speichere. Dies wird hier

123
00:09:39,910 --> 00:09:41,200
generiert, wenn der

124
00:09:41,350 --> 00:09:46,020
nächste Guess-Handler ausgeführt wird, was passiert, wenn wir auf eine dieser Schaltflächen tippen.

125
00:09:46,240 --> 00:09:49,140
Und jetzt ist die nächste Nummer die nächste Nummer,

126
00:09:49,150 --> 00:09:54,370
die wir verwenden möchten. Was wir jetzt einfach tun können, indem wir die aktuelle Schätzung festlegen und die

127
00:09:54,370 --> 00:10:01,660
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,

128
00:10:01,660 --> 00:10:02,960
dass das Spiel

129
00:10:02,980 --> 00:10:06,820
überfordert ist, aber zumindest können wir hier versuchen, Zahlen zu erraten.

130
00:10:06,850 --> 00:10:09,250
Also gebe ich 53 als meine Nummer

131
00:10:09,250 --> 00:10:12,040
ein, jetzt starten wir und der Computer hat 85 erraten.

132
00:10:12,100 --> 00:10:18,220
Wenn ich jetzt größer sage, bekommen wir diese Warnung, weil wir gelogen haben, wir hatten 53 als Zahl, also ist die Vermutung

133
00:10:18,220 --> 00:10:18,580
zu

134
00:10:18,580 --> 00:10:21,590
hoch, sie sollte niedriger sein. Jetzt ist es 28, nun, das

135
00:10:21,610 --> 00:10:23,260
ist zu niedrig, es sollte größer sein.

136
00:10:23,260 --> 00:10:28,830
Wenn ich also tiefer tippe, erhalte ich die Warnung, wenn ich größer tippe, steigen wir jetzt 78

137
00:10:28,840 --> 00:10:34,030
und jetzt, in diesem Moment 23, ist die vorherige Vermutung unsere untere Grenze, und wenn ich

138
00:10:34,030 --> 00:10:38,360
jetzt niedriger tippe, 78 ist die aktuelle Vermutung unsere obere Grenze, also wird

139
00:10:38,380 --> 00:10:44,300
die nächste Vermutung sicherlich nicht über 78 und nicht unter 23 liegen, aber sie ist immer noch zu

140
00:10:44,430 --> 00:10:46,690
niedrig, das ist zu groß, ich meine,

141
00:10:46,690 --> 00:10:48,460
das ist zu niedrig, also

142
00:10:48,460 --> 00:10:49,580
lasst uns

143
00:10:49,600 --> 00:10:51,520
eine größere verwenden, eine niedrigere

144
00:10:51,520 --> 00:10:53,460
und das wäre die richtige .

145
00:10:53,500 --> 00:10:56,560
Im Moment haben wir nichts, was prüft, ob der Computer

146
00:10:56,580 --> 00:10:57,820
richtig geraten hat.

147
00:10:58,120 --> 00:11:00,130
Das ist das nächste, was wir hier implementieren müssen.