1
00:00:01,100 --> 00:00:06,540
そして、このビデオでは、この配列問題の解決策を最初から作成する方法を説明します。

2
00:00:07,290 --> 00:00:10,250
だから私たちが最初に持っているのは、印刷の紹介者です。

3
00:00:10,260 --> 00:00:11,100
だから始める前に。

4
00:00:11,100 --> 00:00:15,780
私のファイルが正しく設定されると、私は既に老人のファイルを持っています。

5
00:00:15,780 --> 00:00:18,020
私はその解決策をそのHMOと呼んでいます。

6
00:00:18,450 --> 00:00:27,840
J Sと同じソリューションタグのソースをインクルードしてから、そのファイルを作成する必要があります。

7
00:00:28,450 --> 00:00:30,620
では、その解決策を保存しましょう。

8
00:00:30,730 --> 00:00:31,840
はい。

9
00:00:32,940 --> 00:00:37,860
そしていつものように、私は議会で始めるが、ログはつながっている。

10
00:00:39,090 --> 00:00:39,650
行こう。

11
00:00:39,660 --> 00:00:41,490
これをブラウザで開きます。

12
00:00:42,450 --> 00:00:45,830
コンソールを開き、接続されていることがわかります。

13
00:00:46,110 --> 00:00:46,860
大丈夫。

14
00:00:46,860 --> 00:00:49,390
ですから、逆の印刷から始めましょう。

15
00:00:49,450 --> 00:00:51,180
したがって、逆の印字は機能です。

16
00:00:51,540 --> 00:00:57,640
ですから、私は関数print reverseを定義することから始めます。これは単一の引数と配列をとります。

17
00:00:57,690 --> 00:01:03,340
私はそれをr rと呼び、配列をループするだけです。

18
00:01:03,600 --> 00:01:08,430
配列の終わりから先頭にループしたい場合を除いて、varの各項目を単に呼び出すだけです。

19
00:01:08,430 --> 00:01:10,140
 

20
00:01:10,200 --> 00:01:12,510
だから、foreachは理想的ではありません。

21
00:01:12,690 --> 00:01:17,160
forループを使うつもりですが、これはリストをたどる順序で少し柔軟になります。

22
00:01:18,390 --> 00:01:24,570
だから私はゼロから始まる代わりにvar私は配列の終わりにそれを開始するつもりです。

23
00:01:24,630 --> 00:01:32,130
だからvarは配列がマイナス1を好きではないので、長さが常に最大のインデックスより1大きいので、マイナス1を加えなければなりません。

24
00:01:32,130 --> 00:01:34,550
 

25
00:01:34,740 --> 00:01:36,730
だから、少し離れている。

26
00:01:36,750 --> 00:01:38,590
次に、我々は続けるつもりです。

27
00:01:38,670 --> 00:01:42,480
私はゼロに等しい。

28
00:01:42,510 --> 00:01:47,400
そして最後に、マイナスマイナスに行くつもりです。

29
00:01:47,640 --> 00:01:49,470
だから私は始めるでしょう。

30
00:01:49,740 --> 00:02:03,050
この配列3

31
00:02:03,690 --> 00:02:13,470
6から5の印刷逆の場合、私はこのインデックスで3となるでしょう、私は5を印刷し、次にIを1から減算して印刷するならば、ログ配列を出力します。

32
00:02:13,470 --> 00:02:21,160
Iの配列は2を与え、次に6を与え、次に3を、最後の時間は0に等しい。

33
00:02:21,300 --> 00:02:23,460
だから私たちは3つを印刷し、それから終了です。

34
00:02:23,700 --> 00:02:25,120
だから見てみましょう。

35
00:02:25,170 --> 00:02:28,070
私はこのプリントをこの配列と呼んでいます。

36
00:02:28,080 --> 00:02:36,070
ブラウザで実行すると、私たちが期待していた5から6と3を得ることができます。

37
00:02:36,150 --> 00:02:38,580
5〜6および3。

38
00:02:38,790 --> 00:02:40,880
次の問題に移りましょう。

39
00:02:41,460 --> 00:02:47,160
したがって、次の問題は、配列を引数として再度取ってtrueを返すuniformです。

40
00:02:47,190 --> 00:02:49,890
すべての要素がまったく同じ場合に限ります。

41
00:02:50,430 --> 00:02:57,930
ですから、私はこのファイルがこれで終わりまでに完全なものになるので、これがユニフォームの始まりであるというメモを書き始めることから始めます。

42
00:02:57,930 --> 00:02:59,930
 

43
00:03:00,150 --> 00:03:01,700
だから私はそれを明確にしたい。

44
00:03:02,220 --> 00:03:08,940
まず、関数が統一されていることを定義することから始めましょう。そして、それは単一の配列をとることになります。

45
00:03:09,510 --> 00:03:15,120
だから私はこれを解決するつもりです、私は非常に最初の項目と等しい変数を作るつもりです。

46
00:03:15,660 --> 00:03:22,200
 

47
00:03:22,200 --> 00:03:27,840
 

48
00:03:27,840 --> 00:03:28,990
ですから、この場合1で配列をループし、その最初のアイテムを他のすべてのアイテムと比較し、いずれのポイントでも同じでない場合は、falseを返して関数全体を終了します。

49
00:03:29,280 --> 00:03:33,060
しかし、もしそれが終わったら、それはすべての商品が同じであることを意味します。

50
00:03:33,060 --> 00:03:34,530
だから我々は真実を返すことができます。

51
00:03:35,010 --> 00:03:41,890
最初の変数varを最初のアイテムと同じにすることから始めます。

52
00:03:43,080 --> 00:03:45,340
それから私は配列をループするつもりです。

53
00:03:45,660 --> 00:03:50,100
だから私はここでforループを使うつもりだし、私はこの後に説明するforeachを使っていない理由がある。

54
00:03:50,310 --> 00:03:51,390
 

55
00:03:51,390 --> 00:04:01,260
だから私はループを開始するつもりはない配列は私がプラス好きではないと私はちょうど配列の高さが最初に等しくないかどうかをチェックするつもりです。

56
00:04:01,260 --> 00:04:07,810
 

57
00:04:07,890 --> 00:04:10,410
つまり、配列が一様ではないということです。

58
00:04:10,590 --> 00:04:12,920
だから私は偽に戻るでしょう。

59
00:04:13,860 --> 00:04:19,820
そして、私の配列の最後で、私たちがループ全体を通してそれを作るなら、私は真実を返すことができます。

60
00:04:20,790 --> 00:04:28,140
私は現在、最初のアイテム配列0を最初のアイテムと比較しています。

61
00:04:28,140 --> 00:04:29,120
 

62
00:04:29,280 --> 00:04:30,680
ループをはじめて。

63
00:04:30,690 --> 00:04:35,710
私が0と言うことを始めると、行が最初に等しい行が消去されます。

64
00:04:35,790 --> 00:04:36,900
だから私はそれをしたくない。

65
00:04:36,960 --> 00:04:39,090
私はインデックス1で始めるつもりです。

66
00:04:39,660 --> 00:04:41,280
それを試してみましょう。

67
00:04:41,280 --> 00:04:49,310
私たちのページをリフレッシュすると、アレイの1 1 1の均一です。

68
00:04:49,500 --> 00:04:50,600
それは本当だ。

69
00:04:50,790 --> 00:04:52,360
しかし、どのように約1 2。

70
00:04:52,620 --> 00:04:55,540
それは間違っており、2人が行きました。

71
00:04:55,620 --> 00:04:57,250
それはまた間違っている。

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

73
00:04:58,290 --> 00:05:01,380
だから私はそれぞれのためにaを使いたくないと言った。

74
00:05:01,470 --> 00:05:08,780
 

75
00:05:10,110 --> 00:05:21,690
 

76
00:05:21,750 --> 00:05:23,700
 

77
00:05:26,890 --> 00:05:29,350
その背後にある理由は、もし私がforeachコメントを書きましたが、forループの代わりにここではそれぞれの関数に赤い点をつけて、それを要素と呼びます。要素がFirstと等しくないかどうかをチェックします私は偽に戻るでしょう。

78
00:05:29,380 --> 00:05:34,840
forループの代わりにforeachで追加した以外は全く同じロジックです。

79
00:05:35,120 --> 00:05:41,140
私たちには問題があります。問題は、私がここでfalseを返すとき、これはここの最初の関数からのみ返ることです。

80
00:05:41,140 --> 00:05:43,860
 

81
00:05:44,080 --> 00:05:50,540
だから、それは私たちはこのレベルに私たちをもたらす最初の関数を終了し、それだけでtrueを返す次の行を実行する制服のすべてを終了しません。

82
00:05:50,540 --> 00:05:55,040
 

83
00:05:55,900 --> 00:06:00,500
だから、ここで取り組むべきことではなく、私はforループを使うつもりです。これははるかに単純ですが、問題の内容を理解してほしいからです。

84
00:06:00,500 --> 00:06:03,400
 

85
00:06:03,440 --> 00:06:06,910
だから、もう一度それを合計すると、私は1つの関数の代わりに戻ります。

86
00:06:06,940 --> 00:06:12,940
それは1つのレイヤーだけを剥がすので、その正確な関数だけを返し、その内部の次の関数はまだ実行を終了します。

87
00:06:12,940 --> 00:06:16,760
 

88
00:06:16,750 --> 00:06:22,460
だから私はこの1つと一緒に来て、これを私たちの真の解決策として残しましょう。

89
00:06:23,950 --> 00:06:26,220
次に、いくつかの配列があります。

90
00:06:26,620 --> 00:06:31,420
だから、いくつかの配列は単一の配列をとり、その内部のすべての項目を合計します。

91
00:06:31,430 --> 00:06:41,660
だから私はいくつかの配列から私のコメントを開始するつもりです、私はいくつかの配列を単一の配列を取る関数を宣言するつもりです。

92
00:06:42,800 --> 00:06:44,280
 

93
00:06:44,890 --> 00:06:48,710
この場合、合計を保持する変数を作成する必要があります。

94
00:06:48,800 --> 00:06:52,920
そして、配列全体をループしてその合計に追加する必要があります。

95
00:06:52,940 --> 00:06:57,170
だから、私は変数totalが0になることから始めます。

96
00:06:57,880 --> 00:06:59,850
それから私はそれぞれのためにそれをやるつもりです。

97
00:07:00,310 --> 00:07:02,480
したがって、それぞれの配列。

98
00:07:02,500 --> 00:07:11,090
そして私はちょうど定期的なforループを行うことができ、私はこの要素を呼び出すつもりです、そして、私は毎回合計するために追加するつもりです。

99
00:07:11,090 --> 00:07:15,010
 

100
00:07:15,010 --> 00:07:18,300
したがって、合計は要素と等しくなります。

101
00:07:19,340 --> 00:07:23,340
そして、最終的なリターンの合計とそれは私がしなければならないすべてです。

102
00:07:23,380 --> 00:07:30,050
したがって、配列全体のゼロ・ループを開始し、すべての要素を取り出し、合計に追加して、最後に合計を返します。

103
00:07:30,050 --> 00:07:30,960
 

104
00:07:31,390 --> 00:07:33,750
それを試してみましょう。

105
00:07:34,060 --> 00:07:37,640
配列上で何らかの配列を試してみましょう。

106
00:07:37,630 --> 00:07:41,500
1 2 3と私は6を得る。

107
00:07:41,530 --> 00:07:45,300
10 10と10の差は30です。

108
00:07:45,680 --> 00:07:47,710
OKなので配列です。

109
00:07:48,250 --> 00:07:53,220
最後の1つは、数値の配列でmax要素を決定することです。

110
00:07:53,530 --> 00:07:57,430
だから私は最初に私のコメントを追加するつもりです。

111
00:07:58,180 --> 00:08:03,130
私たちはここでMaxに取り掛かり、その関数を最初に定義します。

112
00:08:03,160 --> 00:08:09,550
したがって、関数Maxは単一の配列を取ります。ここでのロジックは、最大値を追跡するための変数を持つことになります。そして、デフォルトで最初の要素として開始し、次にすべてをループします現在の最大値と比較します。

113
00:08:09,620 --> 00:08:15,800
 

114
00:08:15,800 --> 00:08:20,270
 

115
00:08:20,840 --> 00:08:25,390
それが現在の最大値より大きければ、その要素は新しい最大値です。

116
00:08:25,550 --> 00:08:27,670
そして最後にそれを返します。

117
00:08:27,880 --> 00:08:38,800
だから、私はvar Maxを配列0にしてから、配列をループするつもりです。多分、私はforループを使うつもりです。

118
00:08:38,810 --> 00:08:41,220
 

119
00:08:41,270 --> 00:08:43,950
だからvar Iはゼロに等しい。

120
00:08:44,140 --> 00:08:46,060
実際には1で始めることができます。

121
00:08:46,610 --> 00:08:51,660
同じ理由ですでに比率を使用しているので、1でこの比率を開始することができます。

122
00:08:52,310 --> 00:08:54,940
だから、私は1 4がゼロになったから始まりました。

123
00:08:55,060 --> 00:08:59,080
私はレーダーリンクプラスプラスを持っています。

124
00:08:59,330 --> 00:09:03,260
そして、私がしたいのは、Iの配列があるかどうかを調べることです。

125
00:09:03,250 --> 00:09:12,450
したがって、個々の要素が最大値より大きい場合、MaxはArrayと等しくなります。

126
00:09:13,510 --> 00:09:19,210
したがって、新しい値に達すると、常に値が変更されたり、値が変更される可能性があります。

127
00:09:20,060 --> 00:09:25,110
だから、ここでこのエクササイズでは、最初の2つは3つです。

128
00:09:25,220 --> 00:09:26,990
1つは最大です。

129
00:09:26,990 --> 00:09:29,610
そしてループをたどって2つに比較します。

130
00:09:29,920 --> 00:09:31,120
2つは1より大きい。

131
00:09:31,220 --> 00:09:32,760
したがって、2つが新しい最大値です。

132
00:09:33,010 --> 00:09:35,830
そしてそれは3を繰り返すことは2より大きい。

133
00:09:35,840 --> 00:09:41,600
だから3つは新しい最大値であり、私たちが見逃している最後の行は、ループが終了した後でMaxを返すだけです。

134
00:09:41,920 --> 00:09:43,440
 

135
00:09:43,750 --> 00:09:45,040
そして、何が良いことでなければならない。

136
00:09:45,430 --> 00:09:54,550
ですから、これをリフレッシュしてみましょう。1 2 3を最大にしてみましょう。

137
00:09:54,620 --> 00:09:59,840
今度は中央に20を追加して20を取得してみましょう。

138
00:10:00,290 --> 00:10:03,790
最後に、負の数で試してみましょう。

139
00:10:03,800 --> 00:10:05,160
私たちはまだ20を得る。

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

141
00:10:06,110 --> 00:10:08,290
ここでは4つの解決策があります。

142
00:10:08,380 --> 00:10:11,890
それらのすべては、それぞれのために使用したループとその一部を使用する必要がありました。

143
00:10:11,890 --> 00:10:14,550
私たちはforループとその一部とそのすべてを使用しました。

144
00:10:14,570 --> 00:10:16,410
我々はレースを行う。

145
00:10:16,550 --> 00:10:17,050
驚くばかり。

146
00:10:17,090 --> 00:10:21,430
次に、私たちは次のデータ構造と、オブジェクトであるjavascriptについて学びます