1
00:00:00,590 --> 00:00:02,100
私は戻ってきます。

2
00:00:02,100 --> 00:00:04,480
だから、このレッスンは完全にオプションです。

3
00:00:04,770 --> 00:00:06,660
それはちょっとしたボーナスです。

4
00:00:06,690 --> 00:00:09,810
それは本当にやや興味深いものです。

5
00:00:09,840 --> 00:00:13,080
だからこそ私はあなたにそれを見せていますが、コースには必須ではありません。

6
00:00:13,080 --> 00:00:18,360
そして、foreachがどのように動作するのかを話し、それぞれに独自のバージョンを構築しようとしています。

7
00:00:18,690 --> 00:00:23,130
だから、関数を引数として取り込んでその中でその関数を実行する関数を書く方法について話します。

8
00:00:23,250 --> 00:00:25,470
 

9
00:00:25,470 --> 00:00:27,620
もう一度完全にオプションです。

10
00:00:27,720 --> 00:00:32,880
 

11
00:00:32,940 --> 00:00:38,760
 

12
00:00:38,760 --> 00:00:41,250
それをオプションにするもう一つの理由は、それは少し進歩していると私は誰も脅かさないようにすることです私はあなたが混乱しているとそれは複数の繰り返しこれの。

13
00:00:41,490 --> 00:00:42,790
私の生徒がそれを手に入れるために。

14
00:00:42,960 --> 00:00:44,350
それは完全にオプションです。

15
00:00:44,550 --> 00:00:48,540
そしてこれは重要ですが、アプリケーションを作ることは必須ではありません。

16
00:00:48,630 --> 00:00:51,310
コースで前進することは必須ではありません。

17
00:00:51,330 --> 00:00:55,500
 

18
00:00:55,820 --> 00:01:00,280
それは何かですが、今一度それを見てみると、あなたに感謝の気持ちを与えることはできません。あなたがJavascriptでもっと経験を積むと、クラスの終わりに向かってそれを再訪することができます。

19
00:01:00,330 --> 00:01:03,490
そして、それはいつも私の生徒と一緒にやっていなければならないことです。

20
00:01:03,570 --> 00:01:06,080
私が言及したように、我々はこのトピックを再訪する。

21
00:01:06,210 --> 00:01:11,310
 

22
00:01:12,120 --> 00:01:17,160
 

23
00:01:17,160 --> 00:01:23,800
 

24
00:01:23,810 --> 00:01:27,660
それでは、それぞれを独自に構築してみましょう。最初に呼び出される関数を定義することから始めます。実際のforeachが動作する方法とは多少異なる方法で動作します。それぞれの作品について、私は配列を定義します。それをNomと呼びましょう。そこにいくつかの数字があります。

25
00:01:28,050 --> 00:01:30,390
私はノームズのそれぞれを呼びます。

26
00:01:30,480 --> 00:01:37,770
だからそれぞれのためにドットがついていますし、私はそれに関数を与えて、これを見ましたので、うまくあなたを退屈させませんが、この番号を呼び出して単純な定数ログを行います。

27
00:01:37,770 --> 00:01:44,820
 

28
00:01:45,240 --> 00:01:46,160
いいえ。

29
00:01:46,800 --> 00:01:49,030
そこに行く。

30
00:01:49,260 --> 00:01:54,580
それは関数を受け取り、配列内のすべての要素で関数を呼び出します。

31
00:01:54,740 --> 00:01:59,130
私たちがNomをそれぞれに渡す必要はなかったことに気づく。

32
00:01:59,190 --> 00:02:04,680
配列について知っていた数字について知っていたのは、それぞれにGnomeのドットを付けたからです。

33
00:02:04,680 --> 00:02:07,740
だから我々はそのように機能する関数を定義することから始めるつもりはない。

34
00:02:07,830 --> 00:02:09,810
私たちはこのように見えるものから始めます。

35
00:02:09,990 --> 00:02:16,560
まあ、それぞれのために私を呼び出すというよりはむしろ1つの引数を取るよりも2つかかります。

36
00:02:16,710 --> 00:02:21,870
そして最初のものは配列であり、2番目のものは関数です。

37
00:02:21,870 --> 00:02:24,390
配列はNomesになります。

38
00:02:24,450 --> 00:02:25,880
そして、これが関数になります。

39
00:02:26,010 --> 00:02:33,270
だから、同じコードをNomで実行したければ、Nomのカンマごとにこのようになります。次に、私たちの全機能がここにあり、上のものと同じに見えます。

40
00:02:33,270 --> 00:02:39,590
 

41
00:02:39,600 --> 00:02:42,560
だから我々はこのバージョンを使い始めています。もっとシンプルだからです。

42
00:02:43,080 --> 00:02:46,310
構文はもう少しですが、書くのが簡単です。

43
00:02:46,590 --> 00:02:52,350
だから、私たちは特別なjavascriptの魔法を使ってそれをつかむのではなく、Nomを渡しています。

44
00:02:52,350 --> 00:02:57,600
私たちがここにあるような方法でメソッドを定義しているなら、それをつかむ方法がありますが、私たちはそれに着きます。

45
00:02:57,600 --> 00:02:57,950
 

46
00:02:58,110 --> 00:03:02,520
OK、関数MYFを定義しましょう。

47
00:03:02,940 --> 00:03:06,150
そして配列と関数を取ります。

48
00:03:06,150 --> 00:03:10,560
それはJavascriptの特別な単語なので、その関数を呼び出すことはできません。

49
00:03:10,560 --> 00:03:16,840
だから私たちはあなたがそれを呼びたいと思っていてもそれをphunkまたはFと呼ぶでしょう、そして私たちは私たちの機能を開きます。

50
00:03:17,520 --> 00:03:20,830
各自が実際に何をしているのか話し始めることにしましょう。

51
00:03:21,210 --> 00:03:27,460
だから、その関数が必要であり、配列内のすべての項目に対してそれを呼び出すことを忘れないでください。

52
00:03:27,480 --> 00:03:32,390
そのためには、配列内のすべての項目に対して何かを実行するためにループを使用する必要があります。

53
00:03:32,400 --> 00:03:33,730
我々はループを持たなければならない。

54
00:03:33,780 --> 00:03:40,200
だから我々はforループを使用して配列をループし、ループ内で関数を呼び出すだけで、関数を呼び出すために必要なのは最後に括弧を追加することです。

55
00:03:40,230 --> 00:03:45,570
 

56
00:03:45,810 --> 00:03:51,300
だから、これはちょっと混乱しています。これは私の生徒が常に苦労しているものです.JavaScriptを学んでいる人はここでハングアップします。

57
00:03:51,300 --> 00:03:52,800
 

58
00:03:52,950 --> 00:03:58,060
しかし、括弧のない関数の名前の区別を覚えておいてください。

59
00:03:58,740 --> 00:04:00,960
それは関数そのものを指しているだけです。

60
00:04:01,050 --> 00:04:07,740
しかし、カッコを追加するとすぐに関数を実行するのではなく、関数funcではなくコードを実行して実行します。

61
00:04:07,740 --> 00:04:08,320
 

62
00:04:08,670 --> 00:04:10,480
だから私はここに例を挙げることができます。

63
00:04:10,710 --> 00:04:11,860
私たちがやるなら。

64
00:04:12,010 --> 00:04:13,310
これをカットしてみましょう。

65
00:04:13,530 --> 00:04:17,610
アラートするだけでは、実際にはアラートが実行されません。

66
00:04:17,760 --> 00:04:20,690
しかし、それらのカッコを追加するとすぐに警告が表示されます。

67
00:04:20,820 --> 00:04:24,200
私は何も渡さなかったが、まだコードを実行している。

68
00:04:24,780 --> 00:04:31,170
ですから、私たちのコードに戻って、ちょうどphunkをこのように直ぐに呼び出すのではなく、配列をループします。

69
00:04:31,170 --> 00:04:31,790
 

70
00:04:31,830 --> 00:04:43,490
だから私は配列を介してコメントループを追加し、配列内の各項目のループコールファンクの中に追加します。

71
00:04:43,560 --> 00:04:45,360
配列をループするためです。

72
00:04:46,080 --> 00:04:47,250
これはforループです

73
00:04:47,280 --> 00:04:50,260
whileループを使用することもできますが、forループを使用します。

74
00:04:50,280 --> 00:04:58,050
したがって、var Iの場合、引数の名前であるr rのドット長よりも小さい値になります。

75
00:04:58,140 --> 00:04:59,590
A R.

76
00:04:59,880 --> 00:05:01,170
 

77
00:05:04,640 --> 00:05:13,760
そして私はそれにちょうど同じようにプラスして、このラインを私たちのループに移します。私たちがやりたいことは、このループの中でphunkと呼ぶためです。

78
00:05:13,760 --> 00:05:20,050
 

79
00:05:20,840 --> 00:05:26,900
 

80
00:05:26,900 --> 00:05:32,060
したがって、2番目の引数として渡される関数は、配列内の各項目に対して一度呼び出されますが、配列の各項目のデータを実際に渡す重要な要素はまだありません。

81
00:05:32,060 --> 00:05:33,250
 

82
00:05:33,320 --> 00:05:35,360
しかし、このすべての項目の列。

83
00:05:35,360 --> 00:05:36,680
だからエンターを押しましょう。

84
00:05:37,420 --> 00:05:38,920
そして、これを実行しようとしましょう。

85
00:05:38,930 --> 00:05:46,780
私は色と呼ばれる配列を定義するか、少なくともお気に入りのお気に入りを選ぶつもりです。

86
00:05:46,910 --> 00:05:48,640
そして、私たちは黄色で止まります。

87
00:05:49,160 --> 00:05:58,040
だから3つのアイテムと私はちょうど私の4つを呼び出して、配列として色で渡すつもりですし、私はただ警告をします。

88
00:05:58,640 --> 00:05:59,910
 

89
00:06:00,110 --> 00:06:04,430
また、括弧はすぐに警告を発するため、覚えていません。

90
00:06:04,430 --> 00:06:05,580
それは私たちが望むものではありません。

91
00:06:06,170 --> 00:06:10,980
我々はそれぞれの機能を私が警告を実行するものにしたい。

92
00:06:11,180 --> 00:06:13,600
だから、ファンクは実際には警戒していることに注意してください

93
00:06:13,610 --> 00:06:20,900
このケースでは、それはまた、ログまたはほとんどの場合、それは無名関数となることを領事にすることができます。

94
00:06:20,900 --> 00:06:24,740
私たちはそれが内部のファンクと呼ばれることを定義します。

95
00:06:24,800 --> 00:06:29,480
それで、それを警報に戻して変更して、enterを押しましょう。

96
00:06:29,900 --> 00:06:31,340
私は1つの警告を得る。

97
00:06:31,730 --> 00:06:34,430
私はOKを押すと別の警告が出ます。

98
00:06:34,640 --> 00:06:37,320
私はOKを押すともう一度警告が出ます。

99
00:06:37,670 --> 00:06:43,640
それでは、このforループが、3つのアイテムを持つ色の配列である配列全体をループしています。

100
00:06:43,640 --> 00:06:44,900
 

101
00:06:44,900 --> 00:06:51,520
だから3回ループし、funcを呼び出すたびにファンクが警告されます。

102
00:06:51,560 --> 00:06:52,670
それがすべてです。

103
00:06:52,670 --> 00:06:57,980
それで、ファンクに何も渡していないので、空のアラートを3回警告します。

104
00:06:57,980 --> 00:07:05,000
だから、データをアラートに渡すか、関数が何をしているのかは、ここで少しデータを渡すだけです。データのほんの少しが配列の各項目になっているはずです。

105
00:07:05,000 --> 00:07:10,240
 

106
00:07:10,250 --> 00:07:13,190
それで、私たちが各項目にアクセスする方法は、Iを使用することです。

107
00:07:13,370 --> 00:07:19,810
だから、ここでコードを思い出すと、配列の括弧を追加するだけです。

108
00:07:20,860 --> 00:07:25,100
ループをはじめて見るとfuncが呼び出されます。これは警告です。

109
00:07:25,100 --> 00:07:32,230
この場合、読み込まれた配列内の最初の項目が読み込まれ、その後、私は1になります。

110
00:07:32,240 --> 00:07:33,240
 

111
00:07:33,320 --> 00:07:38,510
だからオレンジ色の配列でまだ気づいているファンクを思い出してください。

112
00:07:38,510 --> 00:07:46,340
だから私たちは警報を発するオレンジ色になり、もう一度警報が黄色く聞こえる。

113
00:07:46,700 --> 00:07:49,840
 

114
00:07:50,420 --> 00:07:58,500
今、それは私に赤いオレンジと黄色を与え、それは実際にはそれぞれのために定義することです。

115
00:07:58,580 --> 00:08:04,190
しかし、ほとんどの場合、私たちが名前付き関数を渡すところでは、このように見えませんが、通常は無名関数があります。

116
00:08:04,190 --> 00:08:06,270
 

117
00:08:06,320 --> 00:08:07,620
ですから、それを打ち明けましょう。

118
00:08:07,730 --> 00:08:09,920
しかし、無名関数を使う。

119
00:08:09,920 --> 00:08:17,390
だから私はそれぞれのために、私たちは再び通過し、再び色付けし、そして無名の機能を果たします。

120
00:08:17,390 --> 00:08:22,670
ここで括弧があるにもかかわらず、これらは関数を呼び出すものとはまったく異なる括弧であることを覚えておいてください。

121
00:08:22,670 --> 00:08:25,270
 

122
00:08:25,280 --> 00:08:27,050
だから私が実際にあなたが何を意味するかを見せてあげましょう。

123
00:08:27,470 --> 00:08:33,050
私はこの最初の部分を削除し、私はちょうどここに無名関数があります。

124
00:08:33,410 --> 00:08:35,610
そして、私たちが内部でやっているのは相談のダイアログです。

125
00:08:35,790 --> 00:08:43,130
私は機能であり、今すぐEnterキーを押すと、あなたのために少しばかり外に出ることができるので、何が起こっているのかが少し分かりやすくなります。

126
00:08:43,130 --> 00:08:45,730
 

127
00:08:45,770 --> 00:08:47,930
あなたは何が起こると思いますか？

128
00:08:49,130 --> 00:08:50,750
もちろん、それは起こった。

129
00:08:50,960 --> 00:08:54,540
私は戻って、私の弁護士ドットログのための閉じ括弧を追加してみましょう。

130
00:08:54,740 --> 00:08:56,360
今あなたは何が起こると思いますか？

131
00:08:56,360 --> 00:08:58,910
私はここで一種の廃墟と思う。

132
00:08:59,150 --> 00:09:03,100
しかし、私がEnterを押すと、本当に何も起こらないことがわかります。

133
00:09:03,110 --> 00:09:06,200
私は戻ってきた価値を私に返してくれました。

134
00:09:06,200 --> 00:09:12,380
しかし、コードが実行されていない私は一定の見通しが表示されない、そして、これは決してこの無名関数が呼び出されなかったためです。

135
00:09:12,380 --> 00:09:13,620
 

136
00:09:13,670 --> 00:09:16,040
基本的にそれはしばらく存在していましたが、今は消えてしまっています。

137
00:09:16,040 --> 00:09:16,960
私はそれに名前をつけなかった。

138
00:09:16,970 --> 00:09:18,450
私はそれを変数に保存しませんでした。

139
00:09:18,500 --> 00:09:21,530
私はそれを書き直さない限り、決してそれをもう一度呼び出すことはできません。

140
00:09:21,530 --> 00:09:26,240
この関数を実行するには、後でそれらの括弧が必要です。

141
00:09:26,240 --> 00:09:29,700
だから、これは多くの構文ですが、私の意見では一見醜いものです。

142
00:09:29,810 --> 00:09:33,490
しかし、今私はそれらのかっこを持っている場合、私は関数を取得します。

143
00:09:33,830 --> 00:09:43,970
だから、色を変えて同じことをして、無名関数を渡します。

144
00:09:45,520 --> 00:09:53,720
この関数が何もしないと言うと、この関数がここで呼び出されていないという警告を出しているだけです。

145
00:09:53,720 --> 00:09:55,020
 

146
00:09:55,310 --> 00:09:56,860
これはここの関数です。

147
00:09:56,870 --> 00:10:00,120
私たちはここのように後でそれらのカッコが必要です。

148
00:10:00,520 --> 00:10:07,250
そして、それは私のforeachの中から来ていて、ここでそれらのカッコをファンクとファンクに追加しています。

149
00:10:07,310 --> 00:10:10,540
ここのケースでは、それは第2引数全体です。

150
00:10:10,610 --> 00:10:15,670
あなたが少しでもこのことで迷っていれば、もう一度心配しないでコースの残りの部分に不可欠ではありません。

151
00:10:15,950 --> 00:10:22,300
しかし、これを最後にもう一度やり直してみてください。このようなことを私がただ気づいたところでやったり、赤いオレンジや黄色のようなデータを実際に使っているわけではありません。

152
00:10:22,310 --> 00:10:25,670
 

153
00:10:25,750 --> 00:10:29,010
私がenterを押した場合、それをしたいのはそれほど一般的ではありません。

154
00:10:29,570 --> 00:10:33,530
あなたは私が1つ高い2つと3つの高を得るのを見るでしょう。

155
00:10:33,560 --> 00:10:37,370
その色の配列の各アイテムには3つのアイテムがあります。

156
00:10:37,370 --> 00:10:43,490
それはこの関数全体を呼び出すが、私たちがやりたかったことよりも、実際にここでやっているように、実際にその色を利用することが多い。

157
00:10:43,490 --> 00:10:44,940
 

158
00:10:45,130 --> 00:10:47,160
あるいは、各色のように始めることができます。

159
00:10:47,620 --> 00:10:50,920
だから私たちがしなければならないことは、私たちの機能の議論を受け入れることだけです。

160
00:10:51,010 --> 00:10:55,570
だから、私のforeachとそれはこれを少し外しています。

161
00:10:55,580 --> 00:11:02,480
したがって、関数とこれは色と呼ばれますが、もちろん、他の関数と同様に定義することができます。

162
00:11:02,480 --> 00:11:03,450
 

163
00:11:03,620 --> 00:11:08,810
これは、有効なjavascript名でなければならないものであればほとんど何でもかまいません。関数やvarのようなものはキーワードとして予約されていますが、それ以外のものは動作しません。

164
00:11:08,890 --> 00:11:13,800
 

165
00:11:13,820 --> 00:11:15,110
それがここにあります。

166
00:11:15,230 --> 00:11:20,820
引数を期待している匿名関数。次にここでそれを使うことができます。

167
00:11:20,840 --> 00:11:24,920
そのため、コンソールのドットログの色を開始します。

168
00:11:26,260 --> 00:11:30,640
だからもう一度この時間を歩くために、色を繰り返します。

169
00:11:30,640 --> 00:11:37,280
この場合、それは私たちの配列が何であるかであり、毎回それをループしています。ここでこの全体のものであるphunkを呼び出しています。

170
00:11:37,280 --> 00:11:40,600
 

171
00:11:40,940 --> 00:11:45,770
私はその配列の現在の項目を渡す際にそれを思い出しています。

172
00:11:45,880 --> 00:11:48,280
そこで、このコードをここで呼んでいます。

173
00:11:48,530 --> 00:11:51,760
それから、赤とオレンジ、次に黄色で渡します。

174
00:11:51,880 --> 00:11:54,950
だから色は赤、オレンジ、黄色に等しい。

175
00:11:54,950 --> 00:12:00,000
あなたが見ることができるように、毎回このリストを通って、赤とオレンジを得る。

176
00:12:00,160 --> 00:12:02,530
それはそれぞれのための基本的な書き方です。

177
00:12:02,870 --> 00:12:08,180
しかし、約束どおりに配列に追加する方法を示すこともできますので、それぞれの色のドットのように書くか、それぞれのために私のドットをつけることができます。

178
00:12:08,430 --> 00:12:13,530
 

179
00:12:13,660 --> 00:12:14,570
私たちはそれを残しておきます。

180
00:12:14,650 --> 00:12:16,140
しかし、それぞれのために私の色をアップ。

181
00:12:16,120 --> 00:12:20,590
そして、それを行うための関数をここに渡すことができます。

182
00:12:20,960 --> 00:12:25,580
 

183
00:12:25,790 --> 00:12:30,140
 

184
00:12:30,130 --> 00:12:30,970
そして少し前に飛び降りると、私たちは物体についてはまだ話していませんが、プロトタイプについては言及していませんが、私はここであなたにそれを示すつもりです。そしてコースが進むにつれてそれについてもっと学びますに。

185
00:12:30,980 --> 00:12:33,800
実際、次のユニットはすべてオブジェクトに関するものです。

186
00:12:33,860 --> 00:12:40,750
だから私たちは実際にはそれを綴ることのないreドットプロトタイプの型にメソッドを追加しています。

187
00:12:43,370 --> 00:12:48,550
 

188
00:12:48,560 --> 00:12:51,860
そして私がそれをする前に、オートコンプリートに気づく。

189
00:12:52,310 --> 00:12:55,640
これらは配列プロトタイプに存在するすべてのメソッドです。

190
00:12:55,630 --> 00:13:00,770
 

191
00:13:00,800 --> 00:13:07,580
 

192
00:13:07,580 --> 00:13:11,750
そこでpush、pop、shift、unshippedのようなメソッドをすべて取得し、配列のプロトタイプと定義されているすべての配列に存在するそれぞれに対して、そのプロトタイプで定義されたものはすべて利用可能です。

193
00:13:12,380 --> 00:13:18,830
それでは、これを試してみましょう。それぞれの関数が関数であり、関数は1つの引数しか取りません。

194
00:13:21,630 --> 00:13:23,770
 

195
00:13:23,770 --> 00:13:32,870
ここではfuncを取った後、内部で同じロジックを実行し、配列内の各項目に対して関数を呼び出す必要があります。

196
00:13:32,870 --> 00:13:36,660
 

197
00:13:36,680 --> 00:13:40,930
変化する唯一のことは、我々が議論を受け入れていないことです。

198
00:13:40,970 --> 00:13:45,410
Rは配列がもうありませんが、ここにはあります。

199
00:13:45,620 --> 00:13:47,030
それは少し違う。

200
00:13:47,090 --> 00:13:49,880
これをキーワードにしなければなりません。

201
00:13:50,030 --> 00:13:56,050
つまり、キーワードは、Assanと呼ぶ特定の配列を指します。

202
00:13:56,090 --> 00:14:03,590
だから、それぞれの定義のためにキーワードを書いていれば、それぞれの色の点で色がついています。

203
00:14:03,590 --> 00:14:04,950
 

204
00:14:05,140 --> 00:14:08,350
しかし、もし私たちがそれぞれのために数字をつけたり、犬のために数字をつけたりすれば

205
00:14:08,570 --> 00:14:12,530
これは、呼び出す特定の配列を指します。

206
00:14:13,220 --> 00:14:19,980
だから私たちは4つのVAR Iを行うつもりです0はゼロです。

207
00:14:20,210 --> 00:14:28,490
私はこのドットよりも小さいが、プラスプラスのようなものだ。

208
00:14:28,850 --> 00:14:30,490
それが最初の変更です。

209
00:14:30,500 --> 00:14:34,420
特定の配列を参照しているこのリンクを使用しました。

210
00:14:34,610 --> 00:14:36,440
だから私たちはもはやそれを渡していません。

211
00:14:36,740 --> 00:14:44,240
次のことは、配列ブラケットの代わりに私がこのブラケットを行う以外、元のバージョンと同じようにphunkと呼ぶことです。

212
00:14:44,300 --> 00:14:48,160
 

213
00:14:48,160 --> 00:14:51,480
私はちょうどそれが好きです。

214
00:14:51,770 --> 00:14:53,140
それは実際にそこにあるすべてです。

215
00:14:53,140 --> 00:14:58,560
だから私たちはちょうど私たちの議論の名前を持つr rを置き換えることによってそれを少し修正しました。

216
00:14:58,580 --> 00:15:04,040
もちろん、これをキーワードに置き換えることで、何もできなかったでしょう。

217
00:15:04,120 --> 00:15:07,100
だからそれを試してみましょう。

218
00:15:07,100 --> 00:15:08,520
私たちは新しい配列を作る必要があります。

219
00:15:08,650 --> 00:15:14,540
だから、私は友人と呼ばれるものを作って、それに友人がいくつかあります。

220
00:15:14,650 --> 00:15:16,790
チャーリー。

221
00:15:18,020 --> 00:15:26,340
Dave MatieとCaitlinはちょうどそのような打撃を入力します。

222
00:15:26,450 --> 00:15:33,290
今私たちはそれぞれのために私の友人ドットをすることができ、それは引数として単一の機能を取ります。

223
00:15:33,400 --> 00:15:36,140
だから私たちが欲しいのであれば、それを警告することができます。

224
00:15:36,950 --> 00:15:38,090
そして私たちはチャーリーを手に入れます。

225
00:15:38,210 --> 00:15:46,800
Dave

226
00:15:46,970 --> 00:15:54,090
MadieとCaitlinですが、典​​型的には、私のような無名関数を使ってそれを見てみましょう。ここに関数を入れ、それぞれが名前であるとしましょう。

227
00:15:54,110 --> 00:16:06,020
そして、私たちがすることは私たちに任されますが、私が好きなログに名前を加えて名前を付けるようなカウンセリングをしましょう。

228
00:16:07,310 --> 00:16:09,560
そこに行き、私達は得る。

229
00:16:09,560 --> 00:16:10,900
私はチャーリーが大好きです。

230
00:16:10,940 --> 00:16:12,780
私はマディーが好きです、私はケイトリンが大好きです。

231
00:16:13,250 --> 00:16:15,030
それですべてOKです。

232
00:16:15,320 --> 00:16:20,840
そして、私はそれがたくさんあることを意味しているわけではありませんが、実際にはかなり短いコードです。

233
00:16:20,840 --> 00:16:24,010
 

234
00:16:24,130 --> 00:16:28,290
私が実際にやったことのないプロトタイプのものは、目的に応じて作ったものです。

235
00:16:28,660 --> 00:16:34,090
 

236
00:16:34,100 --> 00:16:40,570
 

237
00:16:40,580 --> 00:16:47,060
それに焦点を当てることはそれほど重要ではありませんが、私が注目したいのは、関数を引数に渡すことができるように関数を渡すという考えです。実際にコードを参照し、その括弧を最後に追加します。

238
00:16:47,060 --> 00:16:50,230
これらのかっこがなければ、関数は何もしません。

239
00:16:50,240 --> 00:16:50,810
それが存在します。

240
00:16:50,820 --> 00:16:56,560
それは参照できる値ですが、カッコを追加すると実際に実行されます。

241
00:16:56,620 --> 00:16:57,650
大丈夫です。

242
00:16:57,630 --> 00:16:59,890
次のユニットで、オブジェクトについて話を始めるところを見ていきます