WEBVTT

00:00.420 --> 00:02.740
Witam i zapraszam do tej walki i do rozprawy.

00:03.030 --> 00:07.490
W tej chwili mamy zamiar wykonać funkcję push, która wykona dwa zadania.

00:07.620 --> 00:14.790
Najpierw będzie to zależało od nowego przejścia lub nowego zdarzenia w pamięci, a po drugie upewni

00:14.790 --> 00:18.150
się, że pamięć zawsze ma 100 przejść.

00:18.150 --> 00:23.670
Widzę 100, ponieważ daliśmy przykład 100 wydarzeń z poprzedniego samouczka, ale w rzeczywistości będzie to znacznie

00:23.670 --> 00:25.050
więcej niż 100.

00:25.050 --> 00:29.330
To może być może dziesięć tysięcy sto tysięcy, które zobaczymy.

00:29.490 --> 00:32.430
Ale w każdym razie ta wartość będzie pojemnością.

00:32.850 --> 00:33.120
W porządku.

00:33.120 --> 00:35.630
Zróbmy więc tę funkcję wypychania.

00:35.670 --> 00:41.480
Tak jak zwykle zaczynamy od śmierci, aby zdefiniować nową funkcję, a następnie nadajemy tej funkcji

00:41.500 --> 00:46.500
nazwę, więc nazywamy ją push, a ta funkcja będzie miała dwa argumenty.

00:46.500 --> 00:51.140
Najpierw jak zwykle "ja", które odnosi się do przedmiotu i następnego.

00:51.180 --> 00:52.710
Jak myślisz, dlaczego tak się stanie.

00:52.930 --> 00:58.860
Pamiętajmy, że ta funkcja push będzie używana do dołączania nowego zdarzenia do pamięci.

00:58.920 --> 01:00.510
Mamy już pamięć.

01:00.510 --> 01:08.010
Tak więc potrzebujemy teraz zmiennej, która jest naszym argumentem lub wprowadzeniem, a my nagniemy

01:08.010 --> 01:13.180
to wejście do pamięci, która jest zmienną obiektu.

01:13.190 --> 01:13.490
W porządku.

01:13.490 --> 01:17.900
Więc wydarzenie możesz nazwać wydarzeniem lub przejściem.

01:17.900 --> 01:20.820
To jest to samo, a zobaczysz w następnych sekcjach kodu.

01:20.870 --> 01:22.680
Czym dokładnie jest to wydarzenie.

01:22.700 --> 01:24.050
Jaką ma formę.

01:24.200 --> 01:29.810
Właściwie mogę powiedzieć teraz, że to przejście, które dodajemy do pamięci, składa się w sumie

01:29.810 --> 01:31.190
z czterech elementów.

01:31.190 --> 01:34.050
Pierwszy to ostatni stan, który jest estem.

01:34.160 --> 01:37.410
Drugi to nowy stan, który jest nas jeden.

01:37.490 --> 01:41.000
Trzeci to ostatnia sekcja, która wynosi 80.

01:41.180 --> 01:46.840
Akcja, która była wyświetlana, a czwarta to ostatnie słowo, które uzyskało ostatnie słowo.

01:46.940 --> 01:47.960
To jest nasze.

01:48.200 --> 01:51.370
Taka jest właśnie forma tego wydarzenia.

01:51.800 --> 01:52.490
W porządku.

01:52.700 --> 01:57.830
I to wszystko, czego potrzebujemy, ponieważ chcemy tylko przypiąć zdarzenie do pamięci, a

01:57.830 --> 02:01.270
następnie upewnić się, że pamięć zawiera elementy pojemności.

02:01.280 --> 02:03.840
W porządku, więc teraz wejdźmy do funkcji.

02:03.860 --> 02:07.520
Więc pierwszą rzeczą, którą zrobimy, będzie zająć się tobą, a potem pamięcią.

02:07.640 --> 02:10.850
To bardzo proste, ponieważ zamierzamy użyć funkcji dołączania.

02:10.850 --> 02:12.220
To będzie bezpośrednie.

02:12.350 --> 02:18.200
A kiedy używamy funkcji append, musimy zacząć od listy, na którą chcemy wydać coś, a

02:18.710 --> 02:20.830
ta lista to oczywiście pamięć.

02:21.050 --> 02:27.350
Tak więc zaczynamy od pamięci, a ponieważ pamięć jest zmienną obiektu, zaczynamy tutaj od samouczącej

02:27.650 --> 02:35.060
się pamięci, którą przechodzimy do ustawiania pamięci, a następnie musimy to zrobić, a następnie funkcję otwartą, która jest

02:35.060 --> 02:35.690
pierwsza.

02:35.960 --> 02:43.310
Tak więc pochylił się i wewnątrz otwartej funkcji wkładamy to, co chcemy wydać na pamięć, co oczywiście jest

02:43.640 --> 02:44.750
naszym dowodem.

02:44.780 --> 02:45.730
Nawet tutaj.

02:46.310 --> 02:53.300
A to doda nowe wspomnienie do wydarzenia składającego się z ostatnich ośmiu nowych stanów ostatniej akcji i

02:53.300 --> 02:54.580
ostatniego słowa.

02:54.590 --> 02:55.250
W porządku.

02:55.250 --> 02:56.710
Więc to jest pierwsza rzecz.

02:56.870 --> 03:03.940
Drugą rzeczą, którą musimy zrobić, jest upewnienie się, że pamięć zawsze zawiera elementy pojemności.

03:03.980 --> 03:07.360
Powiedzmy, że pojemność wynosi teraz 100000.

03:07.520 --> 03:11.990
To pewnie pojemność, którą wybierzesz, bo wtedy milion elementów może spowolnić

03:11.990 --> 03:12.640
pociąg.

03:12.710 --> 03:15.140
Powiedzmy, że 100000.

03:15.140 --> 03:22.630
Teraz upewnimy się, że nasza pamięć zawsze zawiera 100000 przejść 100000 zdarzeń i nigdy więcej.

03:22.850 --> 03:29.180
Więc oczywiście na początku będzie miał jeden, potem dwa i trzy, ale gdy osiągnie 100000

03:29.540 --> 03:32.400
zdarzeń, zawsze będzie mieć 100000 zdarzeń.

03:32.420 --> 03:38.480
Aby się o tym przekonać, musimy po prostu stworzyć warunek IF z tą górną granicą, której nie

03:38.480 --> 03:39.560
chcemy przekroczyć.

03:39.590 --> 03:47.810
Więc jeśli wpadniemy na pomysł, że użyjemy tutaj, to to, że jeśli przekroczymy limit Cóż, usuniemy

03:48.020 --> 03:54.530
pierwsze przejście z pierwszego zdarzenia pamięci, a zatem przejmiemy funkcję wiodącą, aby

03:54.650 --> 03:58.480
pamięć, która jest liczbą elementów w pamięci.

03:58.490 --> 04:04.390
Więc tutaj w funkcji len możemy umieścić pamięć do pamięci.

04:04.400 --> 04:12.920
Jeśli więc liczba elementów tej pamięci jest większa niż pojemność w tym przypadku, usuniemy pierwszy element, aby upewnić się,

04:13.070 --> 04:20.700
że pamięć zawsze ma tę samą liczbę elementów pojemności i aby wykonać pierwszy element, nie ma

04:20.800 --> 04:25.450
nic prostszego, zamierzamy użyć innej funkcji, która jest tak dobrze

04:25.460 --> 04:33.560
zorientowana na bajt, i dlatego chcemy usunąć pierwsze przejście, które jest najstarszym przejściem w pamięci, ponieważ ostatnie przejścia

04:33.560 --> 04:38.490
są tymi, które są napięte i dlatego to są nowe

04:38.570 --> 04:39.380
przejścia.

04:39.560 --> 04:41.970
Więc pierwsze przejścia są najstarsze.

04:42.380 --> 04:51.350
I tak tutaj chcemy usunąć samouczącą się pamięć i zapisy i weźmiemy pierwszy element pamięci, który ma

04:51.710 --> 04:59.000
samo zero, które zeruje pamięć. Teraz interesujące, mam małe ostrzeżenie, które mówi, że

04:59.000 --> 05:00.740
istnieje niezdefiniowana pojemność.

05:01.010 --> 05:06.710
Dzieje się tak dlatego, że pojemność nie jest tu czynnikiem wejściowym, który musi być zmienną

05:06.710 --> 05:11.590
pojemności związaną z obiektem, a zatem konieczne będzie dodanie jej własnej pojemności.

05:11.660 --> 05:13.220
A teraz przyszło ostrzeżenie.

05:13.310 --> 05:19.940
Teraz rozumiesz jeszcze bardziej użycie siebie, które tak naprawdę ma odnosić się do obiektu, aby

05:20.330 --> 05:26.180
wziąć pojemność obiektu, który zostanie utworzony, który jest instancją klasy pamięci powtórki.

05:26.190 --> 05:26.550
W porządku.

05:26.550 --> 05:29.250
Więc skończyliśmy z tą funkcją push.

05:29.250 --> 05:34.620
Teraz możemy przejść do następnej funkcji, która jest prostą funkcją, która pobiera kilka

05:34.620 --> 05:40.440
losowych próbek z tej pamięci na ostatnich elementach pojemności, a zrobienie tego znacznie się poprawi.

05:40.470 --> 05:42.510
Głęboki proces czyszczenia.

05:42.510 --> 05:42.790
W porządku.

05:42.790 --> 05:44.540
Zróbmy to w następnym samouczku.

05:44.580 --> 05:46.200
I do tego czasu I.
