WEBVTT

00:00.420 --> 00:02.740
Hallo und herzlich willkommen zu diesem Kampf und zu torero.

00:03.030 --> 00:07.490
Jetzt machen wir die Push-Funktion, die zwei Aufgaben erledigt.

00:07.620 --> 00:14.790
Erstens hängt es von einem neuen Übergang oder einem neuen Ereignis im Speicher ab und dann wird sichergestellt,

00:14.790 --> 00:18.150
dass der Speicher immer 100 Übergänge hat.

00:18.150 --> 00:23.670
Ich sehe 100, weil wir im vorherigen Tutorial das Beispiel von 100 Ereignissen angegeben haben. Tatsächlich werden dies jedoch weit

00:23.670 --> 00:25.050
mehr als 100 sein.

00:25.050 --> 00:29.330
Das werden eher zehntausendeinhunderttausend sein.

00:29.490 --> 00:32.430
Aber dieser Wert wird trotzdem die Kapazität sein.

00:32.850 --> 00:33.120
Gut.

00:33.120 --> 00:35.630
Also machen wir diese Push-Funktion.

00:35.670 --> 00:41.480
Wie üblich beginnen wir also mit dem Tod, um eine neue Funktion zu definieren, und geben dieser Funktion

00:41.500 --> 00:46.500
dann einen Namen, so dass wir sie Push nennen und diese Funktion zwei Argumente hat.

00:46.500 --> 00:51.140
Zuerst wie üblich bezieht sich das auf das Objekt und das nächste.

00:51.180 --> 00:52.710
Warum denkst du wird das sein?

00:52.930 --> 00:58.860
Denken Sie daran, dass diese Push-Funktion verwendet wird, um ein neues Ereignis an den Speicher anzuhängen.

00:58.920 --> 01:00.510
Wir haben bereits die Erinnerung.

01:00.510 --> 01:08.010
Was wir jetzt brauchen, ist eine Variable, ein Ereignis, das unsere Argumente oder Eingabe ist, und wir werden

01:08.010 --> 01:13.180
diese Eingabe in den Speicher biegen, der eine Variable des Objekts ist.

01:13.190 --> 01:13.490
Gut.

01:13.490 --> 01:17.900
Das Ereignis kann also Ereignis oder Übergang genannt werden.

01:17.900 --> 01:20.820
Das ist dasselbe und Sie werden in den nächsten Codeabschnitten sehen.

01:20.870 --> 01:22.680
Was genau ist dieses Ereignis?

01:22.700 --> 01:24.050
Welche Form hat es?

01:24.200 --> 01:29.810
Tatsächlich kann ich Ihnen jetzt sagen, dass dieser Übergang, den wir dem Speicher hinzufügen, insgesamt

01:29.810 --> 01:31.190
vier Elemente umfasst.

01:31.190 --> 01:34.050
Der erste ist der letzte Zustand, der esty ist.

01:34.160 --> 01:37.410
Der zweite ist der neue Staat, der uns gehört.

01:37.490 --> 01:41.000
Der dritte ist der letzte Abschnitt, der 80 ist.

01:41.180 --> 01:46.840
Die angezeigte Aktion und die vierte ist das letzte Wort, das das letzte Wort erhalten hat.

01:46.940 --> 01:47.960
Das ist unser.

01:48.200 --> 01:51.370
Das ist also genau die Form, die dieses Ereignis haben wird.

01:51.800 --> 01:52.490
Gut.

01:52.700 --> 01:57.830
Und das ist alles, was wir nur brauchen, um das Ereignis zu erreichen, weil wir das Ereignis nur

01:57.830 --> 02:01.270
an den Speicher binden und sicherstellen möchten, dass der Speicher Kapazitätselemente enthält.

02:01.280 --> 02:03.840
Nun gut, gehen wir jetzt in die Funktion.

02:03.860 --> 02:07.520
Das erste, was wir tun werden, ist, sich um Sie zu kümmern, dann um die Erinnerung.

02:07.640 --> 02:10.850
Und das ist sehr einfach, weil wir die Append-Funktion verwenden werden.

02:10.850 --> 02:12.220
Das wird also direkt sein.

02:12.350 --> 02:18.200
Und wenn wir die Append-Funktion verwenden, müssen wir mit der Liste beginnen, für die wir etwas ausgeben möchten,

02:18.710 --> 02:20.830
und diese Liste ist natürlich Speicher.

02:21.050 --> 02:27.350
Wir beginnen also mit dem Gedächtnis und da das Gedächtnis eine Variable des Objekts ist, beginnen wir hier mit dem

02:27.650 --> 02:35.060
selbstlernenden Gedächtnis, das wir zum Einrichten des Gedächtnisses verwenden, und dann müssen wir das tun und dann die offene Funktion, die die erste

02:35.060 --> 02:35.690
ist.

02:35.960 --> 02:43.310
Also gebogen und in die offene Funktion geben wir ein, was wir in Erinnerung behalten wollen, was natürlich unser

02:43.640 --> 02:44.750
Beweis ist.

02:44.780 --> 02:45.730
Also auch hier.

02:46.310 --> 02:53.300
Das neue Ereignis, bestehend aus den letzten acht neuen Status-Aktion und dem letzten Wort, wird an den

02:53.300 --> 02:54.580
Speicher angehängt.

02:54.590 --> 02:55.250
Gut.

02:55.250 --> 02:56.710
Das ist das Erste, was gemacht wurde.

02:56.870 --> 03:03.940
Und als Zweites müssen wir sicherstellen, dass der Speicher immer Kapazitätselemente enthält.

03:03.980 --> 03:07.360
Nehmen wir an, die Kapazität beträgt jetzt 100000.

03:07.520 --> 03:11.990
Das ist wahrscheinlich die Kapazität, die Sie wählen werden, weil dann eine Million Elemente den Zug langsam

03:11.990 --> 03:12.640
machen könnten.

03:12.710 --> 03:15.140
Sagen wir also 100000.

03:15.140 --> 03:22.150
Jetzt stellen wir sicher, dass unser Speicher immer 100000 Transitionen, 100000 Ereignisse und nie mehr

03:22.160 --> 03:22.630
enthält.

03:22.850 --> 03:29.180
Am Anfang wird es natürlich eins und dann zwei und drei geben, aber sobald 100000 Ereignisse

03:29.540 --> 03:32.400
erreicht sind, werden immer 100000 Ereignisse angezeigt.

03:32.420 --> 03:38.480
Um dies sicherzustellen, müssen wir lediglich eine IF-Bedingung mit dieser Obergrenze erstellen, die wir nicht

03:38.480 --> 03:39.560
überschreiten wollen.

03:39.590 --> 03:47.810
Wenn wir also auf die Idee kommen, die wir hier verwenden, ist, wenn wir die Grenze überschreiten, werden wir den

03:48.020 --> 03:54.530
ersten Übergang des ersten Ereignisses des Speichers löschen und daher die Lead-Funktion übernehmen, um die Länge

03:54.650 --> 03:58.480
des Speicher ist die Anzahl der Elemente im Speicher.

03:58.490 --> 04:04.390
Hier in der len-Funktion können wir also das Gedächtnis des Selbst speichern.

04:04.400 --> 04:12.920
Wenn also die Anzahl der Elemente dieses Speichers größer ist als die Kapazität in diesem Fall, entfernen wir das erste

04:13.070 --> 04:20.700
Element, um sicherzustellen, dass der Speicher immer die gleiche Anzahl von Kapazitätselementen aufweist, und um das erste

04:20.800 --> 04:25.450
Element auszuführen, ist nichts einfacher Wir werden eine andere Funktion verwenden,

04:25.460 --> 04:33.560
die das Tell-Byte zentrisch ist, und deshalb wollen wir den ersten Übergang entfernen, der den ältesten Übergang im

04:33.560 --> 04:38.490
Speicher darstellt, weil die letzten Übergänge diejenigen sind, die wir angespannt

04:38.570 --> 04:39.380
sind.

04:39.560 --> 04:41.970
Die ersten Übergänge sind also die ältesten.

04:42.380 --> 04:51.350
Und so wollen wir hier selbstlernender Speicher und Datensätze löschen und nehmen das

04:51.710 --> 04:59.000
erste Element des Speichers, das eine Null selbst hat, den

04:59.000 --> 05:00.740
Speicher Null.

05:01.010 --> 05:06.710
Das liegt daran, dass die Kapazität hier nicht die Eingabe ist, die die an das

05:06.710 --> 05:11.590
Objekt angehängte Kapazitätsvariable sein muss, und Sie müssen daher eine Kapazität hinzufügen.

05:11.660 --> 05:13.220
Und jetzt ist die Warnung gekommen.

05:13.310 --> 05:19.940
Jetzt verstehen Sie sogar noch mehr die Verwendung von "self", das sich wirklich auf das Objekt bezieht,

05:20.330 --> 05:26.180
um die Kapazität des Objekts zu nutzen, das als Instanz der Wiedergabespeicherklasse erstellt wird.

05:26.190 --> 05:26.550
Gut.

05:26.550 --> 05:29.250
Damit sind wir mit dieser Push-Funktion fertig.

05:29.250 --> 05:34.620
Nun können wir zur nächsten Funktion übergehen, der einfachen Funktion,

05:34.620 --> 05:40.440
die bei den letzten Kapazitätselementen einige zufällige Abtastwerte aus diesem Speicher entnimmt.

05:40.470 --> 05:42.510
Der Tiefenreinigungsprozess.

05:42.510 --> 05:42.790
Gut.

05:42.790 --> 05:44.540
Machen wir das im nächsten Tutorial.

05:44.580 --> 05:46.200
Und bis dahin ich