1
00:00:01,100 --> 00:00:06,540
E questo video ho intenzione di andare oltre la creazione di soluzioni a questo problema di array impostato partendo da zero.

2
00:00:07,290 --> 00:00:10,250
Quindi il primo che abbiamo sono referrer di stampa.

3
00:00:10,260 --> 00:00:11,100
Quindi, prima di iniziare.

4
00:00:11,100 --> 00:00:15,780
E quando riesco a impostare correttamente i miei file, ho già un file vecchio di lui.

5
00:00:15,780 --> 00:00:18,020
Ho appena chiamato quella soluzione che HMO.

6
00:00:18,450 --> 00:00:27,840
Includerò una fonte di tag script uguale alla soluzione di J S e quindi ho bisogno di creare quel file.

7
00:00:28,450 --> 00:00:30,620
Quindi salviamo questa soluzione.

8
00:00:30,730 --> 00:00:31,840
Sì.

9
00:00:32,940 --> 00:00:37,860
E come sempre mi piacerebbe iniziare con il mio consiglio ma registro connesso.

10
00:00:39,090 --> 00:00:39,650
Andiamo.

11
00:00:39,660 --> 00:00:41,490
Apri questo nel browser.

12
00:00:42,450 --> 00:00:45,830
Apri la console e vediamo che sono collegati.

13
00:00:46,110 --> 00:00:46,860
Tutto ok.

14
00:00:46,860 --> 00:00:49,390
Quindi iniziamo con la stampa inversa.

15
00:00:49,450 --> 00:00:51,180
Quindi il reverse di stampa è una funzione.

16
00:00:51,540 --> 00:00:57,640
Quindi inizierò definendo la funzione reverse di stampa che prende un singolo argomento e array.

17
00:00:57,690 --> 00:01:03,340
Lo chiamerò semplicemente r e tutto ciò che dobbiamo fare è fare un ciclo attraverso l'array.

18
00:01:03,600 --> 00:01:08,430
Tranne il fatto che vogliamo tornare indietro dalla fine dell'array all'inizio e quindi chiameremo il

19
00:01:08,430 --> 00:01:10,140
suo var log ogni elemento.

20
00:01:10,200 --> 00:01:12,510
Quindi un foreach non sarà ideale qui.

21
00:01:12,690 --> 00:01:17,160
Useremo un ciclo for che è un po 'più flessibile nell'ordine in cui attraversiamo la lista.

22
00:01:18,390 --> 00:01:24,570
Quindi per var I invece di partire da zero lo avvieremo alla fine dell'array.

23
00:01:24,630 --> 00:01:32,130
Quindi var equals array non mi piace meno 1 e dobbiamo aggiungere che meno 1 perché la lunghezza è

24
00:01:32,130 --> 00:01:34,550
sempre maggiore di un indice maggiore.

25
00:01:34,740 --> 00:01:36,730
Quindi è distanziato un po '.

26
00:01:36,750 --> 00:01:38,590
Avanti continueremo.

27
00:01:38,670 --> 00:01:42,480
Mentre I è maggiore di uguale a zero.

28
00:01:42,510 --> 00:01:47,400
E poi, infine, stiamo andando a meno meno.

29
00:01:47,640 --> 00:01:49,470
Quindi inizierò a

30
00:01:49,740 --> 00:02:03,050
In caso di inversione di stampa di questo array da 3 6 a 5, partirò da questo indice che sarà tre e stamperemo l'array di

31
00:02:03,690 --> 00:02:13,470
log se io stamperò 5 e poi sottrai 1 da I e stamperò una matrice di I ci

32
00:02:13,470 --> 00:02:21,160
dà 2 e poi 6 e poi 3 e l'ultima volta è uguale a zero.

33
00:02:21,300 --> 00:02:23,460
Quindi stampiamo tre e poi abbiamo finito.

34
00:02:23,700 --> 00:02:25,120
Quindi diamo un'occhiata.

35
00:02:25,170 --> 00:02:28,070
Ho intenzione di chiamare questa stampa si riferisce a questo array.

36
00:02:28,080 --> 00:02:36,070
Eseguilo nel browser e puoi vedere che otteniamo da 5 a 6 e 3 che è quello che ci aspettavamo.

37
00:02:36,150 --> 00:02:38,580
Cinque a sei e tre.

38
00:02:38,790 --> 00:02:40,880
Passiamo al prossimo problema.

39
00:02:41,460 --> 00:02:47,160
Quindi il problema successivo è uniforme, che prende di nuovo un array come argomento e restituisce true.

40
00:02:47,190 --> 00:02:49,890
Solo se tutti gli elementi sono esattamente gli stessi.

41
00:02:50,430 --> 00:02:57,930
Quindi inizierò semplicemente scrivendo una nota che questo è dove inizia l'uniforme perché questo file sarà pieno

42
00:02:57,930 --> 00:02:59,930
alla fine di questo.

43
00:03:00,150 --> 00:03:01,700
Quindi voglio solo chiarire.

44
00:03:02,220 --> 00:03:08,940
Quindi iniziamo definendo che la nostra funzione è uniforme e richiederà un singolo array.

45
00:03:09,510 --> 00:03:15,120
Quindi, nel modo in cui ho intenzione di risolverlo, realizzerò una variabile pari al primo elemento.

46
00:03:15,660 --> 00:03:22,200
Quindi in questo caso 1 e poi ho intenzione di scorrere l'array e confrontare quel primo oggetto con

47
00:03:22,200 --> 00:03:27,840
ogni altro elemento e se in qualsiasi momento non sono uguali, restituiremo false e termineremo

48
00:03:27,840 --> 00:03:28,990
l'intera funzione .

49
00:03:29,280 --> 00:03:33,060
Ma se ce la facciamo fino alla fine significa che ogni oggetto è lo stesso.

50
00:03:33,060 --> 00:03:34,530
Quindi possiamo restituire il vero.

51
00:03:35,010 --> 00:03:41,890
Quindi inizierò a rendere la prima variabile var prima uguale al primo elemento.

52
00:03:43,080 --> 00:03:45,340
Quindi ho intenzione di scorrere l'array.

53
00:03:45,660 --> 00:03:50,100
Quindi userò un ciclo for qui e c'è una ragione per cui non sto usando un

54
00:03:50,310 --> 00:03:51,390
foreach che spiegherò dopo.

55
00:03:51,390 --> 00:04:01,260
Quindi inizierò a scorrere I in meno di Array, non mi piace il plus plus e

56
00:04:01,260 --> 00:04:07,810
vedrò solo se l'array high non è uguale al primo.

57
00:04:07,890 --> 00:04:10,410
Ciò significa che il nostro array non è uniforme.

58
00:04:10,590 --> 00:04:12,920
Quindi restituirò falso.

59
00:04:13,860 --> 00:04:19,820
E poi alla fine del mio array, se lo facciamo attraverso l'intero ciclo, posso tornare vero.

60
00:04:20,790 --> 00:04:28,140
C'è una piccola ottimizzazione qui che sto attualmente confrontando i primi array di articoli zero con il

61
00:04:28,140 --> 00:04:29,120
primo elemento.

62
00:04:29,280 --> 00:04:30,680
La primissima volta attraverso il ciclo.

63
00:04:30,690 --> 00:04:35,710
Se inizio dico 0 e il controllo cancella la riga uguale alla prima.

64
00:04:35,790 --> 00:04:36,900
Quindi non voglio farlo.

65
00:04:36,960 --> 00:04:39,090
Sto per avviarlo all'indice 1.

66
00:04:39,660 --> 00:04:41,280
Proviamoci.

67
00:04:41,280 --> 00:04:49,310
Aggiorna la nostra pagina è uniforme dell'array 1 1 1.

68
00:04:49,500 --> 00:04:50,600
È vero.

69
00:04:50,790 --> 00:04:52,360
Ma che ne dici di 1 1 2.

70
00:04:52,620 --> 00:04:55,540
Questo è falso e due sono andati.

71
00:04:55,620 --> 00:04:57,250
Anche questo è falso.

72
00:04:57,780 --> 00:04:58,290
OK.

73
00:04:58,290 --> 00:05:01,380
Quindi ho detto che non volevo usarne uno per ciascuno.

74
00:05:01,470 --> 00:05:08,780
E la ragione dietro è che se ho scritto un commento su foreach questo e

75
00:05:10,110 --> 00:05:21,690
invece di un ciclo for qui se ho fatto un punto rosso per ogni funzione e lo chiamo elemento e vado a controllare

76
00:05:21,750 --> 00:05:23,700
se l'elemento non è

77
00:05:26,890 --> 00:05:29,350
uguale a First Ritornerò falso.

78
00:05:29,380 --> 00:05:34,840
Questa è esattamente la stessa logica tranne che in un foreach invece di un ciclo for.

79
00:05:35,120 --> 00:05:41,140
Abbiamo un problema e il problema è che quando restituisco false qui questo ritorna solo

80
00:05:41,140 --> 00:05:43,860
dalla prima funzione che è proprio qui.

81
00:05:44,080 --> 00:05:50,540
Quindi non esce dall'uniforme per uscire dalla prima funzione che poi ci porta a questo livello

82
00:05:50,540 --> 00:05:55,040
e quindi esegue semplicemente la riga successiva che viene restituita vera.

83
00:05:55,900 --> 00:06:00,500
Quindi, piuttosto che dover gestire il lavoro da queste parti, userò un ciclo for perché è molto

84
00:06:00,500 --> 00:06:03,400
più semplice, ma voglio che tu capisca qual è il problema.

85
00:06:03,440 --> 00:06:06,910
Quindi per riassumere che ritorna invece di una funzione.

86
00:06:06,940 --> 00:06:12,940
Rimuove solo un livello in modo che restituisca solo quell'esatta funzione e quindi la funzione

87
00:06:12,940 --> 00:06:16,760
successiva al suo interno termina ancora la sua esecuzione.

88
00:06:16,750 --> 00:06:22,460
Quindi verrò con questo fuori e lasciamo solo questo come nostra vera soluzione.

89
00:06:23,950 --> 00:06:26,220
Prossimo abbiamo un array.

90
00:06:26,620 --> 00:06:31,420
Quindi alcuni array prendono un singolo array e riassume ogni elemento all'interno di esso.

91
00:06:31,430 --> 00:06:41,660
Quindi inizieremo con il mio commento alcuni array e dichiarerò la funzione che alcuni array richiedono un

92
00:06:42,800 --> 00:06:44,280
singolo array.

93
00:06:44,890 --> 00:06:48,710
E in questo caso abbiamo bisogno di creare una variabile per contenere il totale.

94
00:06:48,800 --> 00:06:52,920
E poi abbiamo bisogno di scorrere l'intero array e aggiungere a quel totale.

95
00:06:52,940 --> 00:06:57,170
Quindi inizierò con il mio totale variabile pari a zero.

96
00:06:57,880 --> 00:06:59,850
E poi lo farò per ciascuno.

97
00:07:00,310 --> 00:07:02,480
Quindi array per ciascuno.

98
00:07:02,500 --> 00:07:11,090
E potrei semplicemente fare un ciclo regolare e io chiamerò questo elemento

99
00:07:11,090 --> 00:07:15,010
e aggiungerò il totale ogni volta.

100
00:07:15,010 --> 00:07:18,300
Quindi più totale equivale a elementi.

101
00:07:19,340 --> 00:07:23,340
E poi la fine restituisce il totale e questo è tutto ciò che devo fare.

102
00:07:23,380 --> 00:07:30,050
Quindi avviare il ciclo di zero totale attraverso l'array, prendere ogni elemento e aggiunto in totale e quindi restituire il

103
00:07:30,050 --> 00:07:30,960
totale alla fine.

104
00:07:31,390 --> 00:07:33,750
Proviamoci.

105
00:07:34,060 --> 00:07:37,640
Proviamo a fare qualche array sull'array.

106
00:07:37,630 --> 00:07:41,500
Uno due tre e ne ho sei.

107
00:07:41,530 --> 00:07:45,300
E che ne dici di 10 10 10 e ne ottieni 30.

108
00:07:45,680 --> 00:07:47,710
OK, questo è un array.

109
00:07:48,250 --> 00:07:53,220
L'ultimo qui sta determinando l'elemento massimo in una matrice di numeri.

110
00:07:53,530 --> 00:07:57,430
Quindi aggiungo i miei commenti in primo luogo.

111
00:07:58,180 --> 00:08:03,130
Lavoreremo su Max qui e definirò prima quella funzione.

112
00:08:03,160 --> 00:08:09,550
elemento per impostazione predefinita e quindi passeremo in rassegna ogni altro elemento e confrontarlo con il massimo corrente.

113
00:08:09,620 --> 00:08:15,800
Quindi la funzione Max prende di nuovo un singolo array e la logica è che avremo una

114
00:08:15,800 --> 00:08:20,270
variabile per tenere traccia del massimo e che avremo appena iniziato come primo

115
00:08:20,840 --> 00:08:25,390
E se mai è maggiore del massimo attuale, allora quell'elemento è il nostro nuovo massimo.

116
00:08:25,550 --> 00:08:27,670
E poi lo restituiamo alla fine.

117
00:08:27,880 --> 00:08:38,800
Quindi ho intenzione di avviare var Max uguale all'array 0 e quindi ho intenzione di scorrere l'array e solo per motivi di

118
00:08:38,810 --> 00:08:41,220
varietà userò un ciclo for.

119
00:08:41,270 --> 00:08:43,950
Quindi per var I uguale a zero.

120
00:08:44,140 --> 00:08:46,060
E in realtà puoi avviarlo a 1.

121
00:08:46,610 --> 00:08:51,660
Perché stiamo già utilizzando un rapporto per lo stesso motivo per cui possono avviarlo a 1.

122
00:08:52,310 --> 00:08:54,940
Quindi ho iniziato a 1 4 uguale a zero.

123
00:08:55,060 --> 00:08:59,080
Ho meno di un collegamento radar più plus.

124
00:08:59,330 --> 00:09:03,260
E tutto quello che voglio fare è controllare se la matrice di I.

125
00:09:03,250 --> 00:09:12,450
Quindi se il singolo elemento è maggiore del massimo, Max ora è uguale a Array.

126
00:09:13,510 --> 00:09:19,210
Quindi questo cambierà costantemente il suo valore o potenzialmente cambierà il suo valore se incontra un nuovo massimo.

127
00:09:20,060 --> 00:09:25,110
Quindi in questo esercizio qui uno due tre all'inizio.

128
00:09:25,220 --> 00:09:26,990
Uno è il massimo.

129
00:09:26,990 --> 00:09:29,610
E poi passiamo attraverso il ciclo e lo confrontiamo con due.

130
00:09:29,920 --> 00:09:31,120
Due è maggiore di uno.

131
00:09:31,220 --> 00:09:32,760
Quindi due è il nuovo massimo.

132
00:09:33,010 --> 00:09:35,830
E poi quello che ripete tre è maggiore di due.

133
00:09:35,840 --> 00:09:41,600
Quindi tre è un nuovo massimo e l'ultima linea che ci manca è che, una volta terminato

134
00:09:41,920 --> 00:09:43,440
il ciclo, restituiamo solo Max.

135
00:09:43,750 --> 00:09:45,040
E cosa dovrebbe andare bene.

136
00:09:45,430 --> 00:09:54,550
Quindi proviamo questo aggiornamento e proviamo a eseguire max su 1 2 3 e ne otteniamo tre.

137
00:09:54,620 --> 00:09:59,840
Ora proviamo ad aggiungere 20 nel mezzo e otteniamo 20.

138
00:10:00,290 --> 00:10:03,790
E infine giochiamo con un numero negativo e assicuriamoci che funzioni.

139
00:10:03,800 --> 00:10:05,160
E abbiamo ancora 20.

140
00:10:05,480 --> 00:10:06,010
OK.

141
00:10:06,110 --> 00:10:08,290
Quindi abbiamo quattro soluzioni qui.

142
00:10:08,380 --> 00:10:11,890
Tutti loro avevano bisogno di usare un ciclo che usavamo per ciascuno e alcuni di essi.

143
00:10:11,890 --> 00:10:14,550
Abbiamo usato un ciclo for, alcuni di loro e tutti loro.

144
00:10:14,570 --> 00:10:16,410
Pratichiamo una gara.

145
00:10:16,550 --> 00:10:17,050
Eccezionale.

146
00:10:17,090 --> 00:10:21,430
Quindi continueremo a conoscere la nostra prossima struttura dati e javascript, che è l'oggetto