1
00:00:00,000 --> 00:00:02,270
>> [レビュー：クイズ1]

2
00:00:02,270 --> 00:00:04,620
[アリナーム、Oreoluwa Barbarinsa、ルーカスフレイタス、ロブ·ボーデン] [ハーバード大学]

3
00:00:04,620 --> 00:00:07,660
[これはCS50である。] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[ルーカスフレイタス]はすべての人を歓迎します。これはクイズ1のレビューです。

5
00:00:11,610 --> 00:00:15,040
ただ免責事項として、これは - 私は意味、私たちはカバーしようとしている

6
00:00:15,040 --> 00:00:17,770
できるだけ多くの材料が、それはそれを意味するものではありません

7
00:00:17,770 --> 00:00:20,780
私たちは、クイズ1にもできることのすべてをカバーするつもりだ。

8
00:00:20,780 --> 00:00:25,270
だから、また、講義、セクション、あなたができることはすべてを見てみてください。

9
00:00:25,270 --> 00:00:28,240
クイズ1は水曜日、来週の水曜日になるだろう。

10
00:00:28,240 --> 00:00:33,800
だから、勉強​​してください。それは最初のクイズのように、かなり多くの、になるだろう

11
00:00:33,800 --> 00:00:36,390
そのフォーマットに関しては、それはおそらくはるかに困難になるだろう。

12
00:00:36,390 --> 00:00:39,600
私は50を取ったとき、少なくとも、昨年、私はそれがはるか​​に困難だと思った。

13
00:00:39,600 --> 00:00:42,410
だから、多くのことを研究しています。

14
00:00:42,410 --> 00:00:45,190
>>私は、データ構造をカバーするつもりだし、ハフマン符号化。

15
00:00:45,190 --> 00:00:47,910
これは、多くの人々が複雑だと思うものです。

16
00:00:47,910 --> 00:00:51,930
しかし、私はそれをできるだけ簡単に作ってみるつもりです。

17
00:00:51,930 --> 00:00:56,330
まず第一に、私たちはあなたたちはクイズ1のために知ってほしいことである

18
00:00:56,330 --> 00:01:00,970
私が提示するつもりのデータ構造の各々の概念的な説明を理解しています。

19
00:01:00,970 --> 00:01:03,960
それはあなたが実際にする必要がないことを意味します

20
00:01:03,960 --> 00:01:07,020
クイズ1でハッシュテーブルを実装します。

21
00:01:07,020 --> 00:01:10,250
私たちは、あなたが全体のハッシュテーブルを実装しない、多分私達は頑張ります

22
00:01:10,250 --> 00:01:13,090
あなたには、いくつかの機能を実装できるようにするには、

23
00:01:13,090 --> 00:01:16,940
最も一般的な操作が、我々はあなたがすべてのものを実装することするつもりはない。

24
00:01:16,940 --> 00:01:21,010
だから、あなたがそれぞれのデータ構造の背後にある概念を理解することが重要です

25
00:01:21,010 --> 00:01:23,510
そしてまた、あなたがC言語でコーディングすることができること、

26
00:01:23,510 --> 00:01:27,880
彼らは各々のデータ構造を持っているだけで、ほとんどの一般的な操作。

27
00:01:27,880 --> 00:01:30,090
また、ポインタや構造体を確認することができる

28
00:01:30,090 --> 00:01:33,470
それらは、これらのデータ構造内に多く現れるためである。

29
00:01:33,470 --> 00:01:37,380
>>まず、リストのリンク。リンクリストは、実際には配列に非常に類似している、

30
00:01:37,380 --> 00:01:39,930
しかし、リンクされたリストと配列の違い、

31
00:01:39,930 --> 00:01:45,160
まず、リンクリストは、非常に柔軟なサイズを有することで、

32
00:01:45,160 --> 00:01:50,060
配列には、配列のための非常に大きなサイズを選択するか持っている間、

33
00:01:50,060 --> 00:01:53,710
だから、あなたがそのアレイ内のすべてのデータを格納できるようにするつもりだことを知っている

34
00:01:53,710 --> 00:01:59,370
または、配列の柔軟な長さにmalloc関数を使用する必要があります。

35
00:01:59,370 --> 00:02:03,680
リンクされたリストでは、それだけでより多くの要素を取得するのは非常に簡単です、

36
00:02:03,680 --> 00:02:07,210
リンクされたリストに複数の要素を入れたり、要素を削除する。

37
00:02:07,210 --> 00:02:09,370
そして実際に、リンクされたリストがソートされたくない場合には、

38
00:02:09,370 --> 00:02:13,950
あなたが一定の時間内の要素を検索し、削除することができ、

39
00:02:13,950 --> 00:02:16,800
これはO（1）時間がので、それは非常に便利です。

40
00:02:16,800 --> 00:02:20,660
あなただけの、いつものmallocに覚えていて、ノードを解放するために注意する必要があります

41
00:02:20,660 --> 00:02:25,510
そうしないというだけでは、メモリリークがあるでしょう。

42
00:02:25,510 --> 00:02:31,480
だから、リンクリスト - ノードの定義は、ちょうど私達がすぐそこ持っているもののようです。

43
00:02:31,480 --> 00:02:35,110
私は、int型のnを入れていますが、あなたが望む任意のデータを格納することができます。

44
00:02:35,110 --> 00:02:37,280
あなたは文字列を格納したいのであれば、それは大丈夫です。

45
00:02:37,280 --> 00:02:41,690
あなたは、構造体を格納する場合、それはあなたが好きな、二重大丈夫です。

46
00:02:41,690 --> 00:02:44,630
私はここに例についてはint型のnを置く。

47
00:02:44,630 --> 00:02:46,800
そして、あなたは、次のノードへのポインタを持っている。

48
00:02:46,800 --> 00:02:51,940
したがって、基本的に、リンクされたリストは、いくつかのデータを有しており、それは次のノードを指す。

49
00:02:51,940 --> 00:02:56,710
それがリンクされたリストの最後の要素の場合は、NULLを指すようになるだろう。

50
00:02:56,710 --> 00:02:59,060
だから、これはリンクされたリストの一例です。

51
00:02:59,250 --> 00:03:05,960
>>わかりま​​したので、今度は私がリンクされたリスト内の要素を挿入したい場合は、我々は何をすべきかを見てみましょう。

52
00:03:05,960 --> 00:03:08,810
まず、関数insertはvoid型になります

53
00:03:08,810 --> 00:03:11,350
私は何を返すようにしたくないので。

54
00:03:11,350 --> 00:03:14,200
と私は、引数としてint型を取るつもりだ、

55
00:03:14,200 --> 00:03:17,090
私は挿入するかを知りたいので。

56
00:03:17,090 --> 00:03:21,840
だから私は、最初にすべきことは何ですか？まあ、私はnewnodeが上をmallocべき、

57
00:03:21,840 --> 00:03:24,240
だから、最初の行です。

58
00:03:24,240 --> 00:03:27,580
私はリンクされたリストに入れて新しいノードを作成しています。

59
00:03:27,580 --> 00:03:32,360
だから私は何ができますか？さて、私たちは知っているリンクリストの我々の実装で

60
00:03:32,360 --> 00:03:38,180
クラスで、私たちは常にグローバル変数として頭を置く。

61
00:03:38,180 --> 00:03:41,800
それでは、私たちにできることは頭に変更される。

62
00:03:41,800 --> 00:03:44,300
私は、この新しいノードは、新しいヘッドで作ることができ、

63
00:03:44,300 --> 00:03:46,670
そしてそれは、前の頭部を指すようになるだろう。

64
00:03:46,670 --> 00:03:50,390
我々はそれをどのように行うことができますか？私がしなければならない最初のこと

65
00:03:50,390 --> 00:03:54,770
値に新しいノードでの 'N'を変更され、

66
00:03:54,770 --> 00:03:57,530
関数に渡された。

67
00:03:57,530 --> 00:04:01,050
その後newnodeが次の頭になるだろう。

68
00:04:01,050 --> 00:04:05,800
頭がnewnodeがされようとしている。だから、非常に簡単です。

69
00:04:05,800 --> 00:04:10,090
ノードを削除するために、我々は次のようにそれを行うことができます - 

70
00:04:10,090 --> 00:04:14,790
我々はそれを行うことができ一つの方法は、言うことです、

71
00:04:14,790 --> 00:04:18,160
さて、私は削除したい場合は、例えば、3、

72
00:04:18,160 --> 00:04:24,850
私は何ができることは、直前のノードを指すようです。

73
00:04:24,850 --> 00:04:27,580
3の次のノードに。

74
00:04:27,580 --> 00:04:29,400
だから、僕はそのようなことをするだろう。

75
00:04:29,400 --> 00:04:33,400
しかし、それをやっての問題点は何ですか？

76
00:04:33,400 --> 00:04:37,400
私は、メモリリークを持っているので、私はもう数3にアクセスすることはできません。

77
00:04:37,400 --> 00:04:42,480
それに伴う問題は、私は、そのノードを解放できるようにするつもりはないんだということです。

78
00:04:42,480 --> 00:04:45,360
私はメモリリークと（理解できない）は私を憎むために起こっている持っているつもりです。

79
00:04:45,360 --> 00:04:49,370
だからではなく、それを行うので、私はおそらく一時的なポインタを持っている必要があります。

80
00:04:49,370 --> 00:04:53,210
だから私は、TEMPを置く。それは私が削除するノードを指すようになるだろう。

81
00:04:53,210 --> 00:04:58,170
そして私は、次のノードを指すように、前のノードを移動することができます

82
00:04:58,170 --> 00:05:00,390
私は削除するノードの。

83
00:05:00,390 --> 00:05:02,730
そして最後に、私はポインタを解放することができます。

84
00:05:02,730 --> 00:05:07,480
私はすぐそこに作成されたポインタを解放する必要がありますか？

85
00:05:07,480 --> 00:05:09,560
私がする、という理由だけではありません - 

86
00:05:09,560 --> 00:05:13,430
違いは、このノードはmallocを使用して作成されたことで、

87
00:05:13,430 --> 00:05:17,280
この1は単なるスタック内のNULLスイッチとして宣言されている間ので、ヒープ内にあります。

88
00:05:17,280 --> 00:05:20,000
だから私はそれを解放する必要はありません。

89
00:05:20,000 --> 00:05:22,030
>>オーケー。だから今度は、スタックについて話しましょう​​。

90
00:05:22,030 --> 00:05:24,680
スタックは非常に簡単です。

91
00:05:24,680 --> 00:05:29,540
私達はちょうど配列を使用してクラスでのスタックとキューをしました、

92
00:05:29,540 --> 00:05:32,820
しかし、あなたは理解している必要があります - ちょうどに注意してください

93
00:05:32,820 --> 00:05:40,740
また、同様にリンクされたリストを使用してキューにスタックを行うことができます。

94
00:05:40,740 --> 00:05:44,460
あなたは配列を持っているのであれば、どのようなスタックでしょうか？

95
00:05:44,460 --> 00:05:46,810
スタックは、最初に、大きさを持っている必要があります。

96
00:05:46,810 --> 00:05:49,950
あなたは、あなたが今持っているスタックのサイズが何であるかを格納することがあります。

97
00:05:49,950 --> 00:05:52,980
そしてまた、あなたは、この数値の場合、配列を持っているでしょう

98
00:05:52,980 --> 00:05:55,120
あなたが望むなら、それは配列にすることができます

99
00:05:55,120 --> 00:06:00,380
文字列の、構造体の配列を、保存したいもの。

100
00:06:00,380 --> 00:06:03,240
スタックに関する：スタックとリンクリストの違い

101
00:06:03,240 --> 00:06:08,590
スタック内だけスタックに入れ最後の要素へのアクセス権を持っているということです。

102
00:06:08,590 --> 00:06:11,770
それが最初に出て、最後に呼ばれています。

103
00:06:11,770 --> 00:06:15,090
あなたはトレーのスタックを持っているのと同じように、

104
00:06:15,090 --> 00:06:17,670
あなたはスタックの一番上のトレイを置く場合、

105
00:06:17,670 --> 00:06:22,670
あなたが他のトレイにアクセスできるように、最初にそのトレイを削除する必要があります。

106
00:06:22,670 --> 00:06:26,310
これは、スタックと同じことだ。

107
00:06:26,310 --> 00:06:31,220
私は、例えば、スタックに要素を追加したいのであれば、私は何をすべきか？

108
00:06:31,220 --> 00:06:34,070
それは、プッシュと呼ばれ、それはかなり簡単ですだ。

109
00:06:34,070 --> 00:06:37,130
あなたがしなければならない最初のことは、スタックのサイズかどうかを確認している

110
00:06:37,130 --> 00:06:40,150
以上スタックの容量に等しいではありません。

111
00:06:40,150 --> 00:06:45,810
あなたはすでにフル稼働にしている場合は、何か他のものを追加することができないため。

112
00:06:45,810 --> 00:06:51,140
されていない場合、その後、あなただけのスタックに要素を追加する必要があります。

113
00:06:51,140 --> 00:06:54,530
そして最後に、サイズを増やします。だから、非常に簡単です。

114
00:06:54,530 --> 00:06:57,140
だから、僕は数2を追加します。

115
00:06:57,140 --> 00:07:00,350
そして、私は私が削除することを意味し、ポップアップしたい場合

116
00:07:00,350 --> 00:07:03,870
追加された要素の値を返した最後の要素、

117
00:07:03,870 --> 00:07:09,180
私がチェックする必要がまず​​最初に、スタックが空ではないということです。

118
00:07:09,180 --> 00:07:11,510
それが空なら、私は何も返すことができないため。

119
00:07:11,510 --> 00:07:14,820
その場合、私は-1を返しています。

120
00:07:14,820 --> 00:07:18,960
そうでなければ、私はスペックのサイズを増減するつもりだ、

121
00:07:18,960 --> 00:07:22,510
と数字（s.size）を返します。

122
00:07:22,510 --> 00:07:27,230
なぜ私はサイズをデクリメントしてからs.sizeを返したのですか？

123
00:07:27,230 --> 00:07:30,930
この場合、specはサイズ4を有するので、だ

124
00:07:30,930 --> 00:07:33,810
と私は第四の要素を返すようにしたいですよね？

125
00:07:33,810 --> 00:07:36,030
しかし、第四の要素のインデックスとは何でしょうか？三。

126
00:07:36,030 --> 00:07:44,510
私はサイズがないので -  3であることを行っている、私はちょうど（s.size）s.numbersを返すことができます

127
00:07:44,510 --> 00:07:48,410
それは3だから。だから、ただのインデックスです。

128
00:07:48,410 --> 00:07:50,380
>>今キューに入れます。キューは、ほとんど同じことである。

129
00:07:50,380 --> 00:07:54,950
唯一の違いは、その代わりに第5、の最後有するものである

130
00:07:54,950 --> 00:07:57,480
あなたが最初に出て、最初の持っている。

131
00:07:57,480 --> 00:07:59,460
おそらく、あなたがコンサートに行くのを待っているのなら、

132
00:07:59,460 --> 00:08:04,260
あなたが代わりにキューのスタックを持っていた場合、あなたは幸せではないでしょう。

133
00:08:04,260 --> 00:08:07,730
来て最後の人であることは、コンサートを入力する最初の人になる。

134
00:08:07,730 --> 00:08:09,760
あなたは、おそらく幸せではないでしょう。

135
00:08:09,760 --> 00:08:15,020
キューに、で取得する最初の人にも外に出た最初​​の人物である。

136
00:08:15,020 --> 00:08:18,720
そのようにキューの定義で、アレイ内のサイズを有する他に、

137
00:08:18,720 --> 00:08:23,360
また、スタックの先頭にインデックスされたヘッドを持っている必要があります。

138
00:08:23,360 --> 00:08:29,000
今最初の要素はそう。

139
00:08:29,000 --> 00:08:32,710
エンキューは、スタックのプッシュと同じものです。

140
00:08:32,710 --> 00:08:34,980
あなたは非常にナイーブだったら、あなただけだと思います、

141
00:08:34,980 --> 00:08:39,289
私がプッシュするために行ったようによく、私はちょうど全く同じことを行うことができます。

142
00:08:39,289 --> 00:08:44,030
それが容量を超えない場合、私はちょうどチェックすることができます。

143
00:08:44,030 --> 00:08:48,760
もしそうであれば、私はそうでなければ私はちょうど新しい値をエクスポートすることができ、falseを返す

144
00:08:48,760 --> 00:08:50,630
して、サイ​​ズを増やします。

145
00:08:50,630 --> 00:08:52,750
しかし、なぜこれが問題なのでしょうか？

146
00:08:52,750 --> 00:08:55,010
のは、この例を見てみましょう。

147
00:08:55,010 --> 00:08:57,020
私は原料の束をエンキューしようとしている、

148
00:08:57,020 --> 00:08:58,390
そして私は、デキューおよびエンキューするつもりです。

149
00:08:58,390 --> 00:09:00,550
そこのコマンドの多くはだが、それは非常に簡単です。

150
00:09:00,550 --> 00:09:04,790
私は、5をキューので、5を追加しようとしています7

151
00:09:04,790 --> 00:09:09,310
1、4、6、その後、私は何かをデキューしたい、

152
00:09:09,310 --> 00:09:12,000
これは私が最初の要素を削除するつもりだということです。

153
00:09:12,000 --> 00:09:14,640
だから私は右、番号3を削除するつもりだ？

154
00:09:14,640 --> 00:09:17,320
最初の要素。大丈夫。

155
00:09:17,320 --> 00:09:21,450
私は何か他のものをエンキューしようとすると、今、何が起こるだろう？

156
00:09:21,450 --> 00:09:24,290
私の実装によれば、

157
00:09:24,290 --> 00:09:31,040
私は、インデックスq.sizeの次の番号を入れるつもりだった。

158
00:09:31,040 --> 00:09:35,140
この場合、サイズは8であり、

159
00:09:35,140 --> 00:09:38,640
そのインデックス8は最後の位置に右ここになります。

160
00:09:38,640 --> 00:09:43,900
私はここに1をキューしようとすると、私は最後の位置を上書きすることになる

161
00:09:43,900 --> 00:09:45,870
完全に間違っている番号1に。

162
00:09:45,870 --> 00:09:49,870
私は何をしたいのは、ラップアラウンドし、最初の位置に移動しますです。

163
00:09:49,870 --> 00:09:52,870
多分あなただけでなく、私は確認しなければならない、と言うでしょう

164
00:09:52,870 --> 00:09:55,600
私は実際にそこに何かを置くことができます。

165
00:09:55,600 --> 00:09:58,560
そうでなければ、私は言って、ああ、新しいフル稼働

166
00:09:58,560 --> 00:10:02,010
実際の容量は -  1、あなたはそこに要素を配置することはできません。

167
00:10:02,010 --> 00:10:06,150
しかし、問題は何ですか？問題は、私はちょうどここですべてをデキューした場合

168
00:10:06,150 --> 00:10:08,240
そして、私は何か他のものを追加しようと、それだけだと思います、

169
00:10:08,240 --> 00:10:11,210
さて、あなたは0でフル稼働、にあった。

170
00:10:11,210 --> 00:10:13,620
だからあなたのキューがなくなっています。

171
00:10:13,620 --> 00:10:16,990
あなたの周りにラップする必要があり、ラップアラウンドのやり方

172
00:10:16,990 --> 00:10:22,040
先見の明や他のpsetで学んだ皆さんはMOD使用していた。

173
00:10:22,040 --> 00:10:29,090
あなたはq.size + q.headをするだろう理由を理解するために自宅でそれを試すことができます

174
00:10:29,090 --> 00:10:31,080
MODの容量が、あなたはここをチェックした場合、

175
00:10:31,080 --> 00:10:34,760
我々はそれが機能することを確認することができます。

176
00:10:34,760 --> 00:10:37,760
だから、最後の例では、q.sizeは8であった

177
00:10:37,760 --> 00:10:47,590
それはここに、配列のこの位置だったので、頭が1であった。

178
00:10:47,590 --> 00:10:51,970
だから、8 + 1、9になります。 MOD容量9は0になります。

179
00:10:51,970 --> 00:10:56,640
これは、インデックス0に行くだろう。私たちは、正しい位置になるでしょう。

180
00:10:56,640 --> 00:10:59,750
して、自宅でキューをしてみてください。

181
00:10:59,750 --> 00:11:04,950
いくつかの重要な事柄：スタックとキューの違いを理解してみてください。

182
00:11:04,950 --> 00:11:11,620
自宅で、エンキュー、デキュー、pushとpopの実装に精通して取得しようとする。

183
00:11:11,620 --> 00:11:16,560
あなたがそれらのそれぞれを使用する際にも理解しています。

184
00:11:16,560 --> 00:11:22,830
>>それでは、ポケモンの束と10秒間リラックスしましょう​​。

185
00:11:22,830 --> 00:11:26,080
そして今度は、バックデータ構造に行きましょう。

186
00:11:26,080 --> 00:11:29,770
ハッシュテーブル。多くの人々は、ハッシュテーブルを怖がっていた。

187
00:11:29,770 --> 00:11:33,650
問題6セットに、スペルチェッカー。

188
00:11:33,650 --> 00:11:35,980
ハッシュテーブルと試みは、多くの人々は彼らの不安になる。

189
00:11:35,980 --> 00:11:38,540
彼らは、彼らが理解することがとても難しいだと思う。うん？

190
00:11:38,540 --> 00:11:41,490
[ロブ·ボーデン]問題は5に設定してください。 >>問題うん、5を設定してください。おかげでロブ。

191
00:11:41,490 --> 00:11:43,370
うん。シックスハフN 'パフ、そうだった。

192
00:11:43,370 --> 00:11:49,340
問題は、スペルチェッカーで、あなたがハッシュテーブルやTRYのいずれかを使用していた5に設定します。

193
00:11:49,340 --> 00:11:55,360
多くの人々は、彼らが理解し超硬と思っていたが、実際には非常に単純だ。

194
00:11:55,360 --> 00:12:01,290
基本的には、ハッシュテーブルとは？ハッシュテーブルは、リンクされたリストの配列である。

195
00:12:01,290 --> 00:12:06,730
アレイ、ハッシュテーブルとの間の唯一の違い

196
00:12:06,730 --> 00:12:09,730
ハッシュテーブルにして、ハッシュ関数と呼ばれるものを持っているということです。

197
00:12:09,730 --> 00:12:12,080
ハッシュ関数とは何ですか？

198
00:12:12,080 --> 00:12:13,970
あなたたちはここで読むことができるかどうかは知りません。

199
00:12:13,970 --> 00:12:16,090
これは、ハッシュテーブルの一例である。

200
00:12:16,090 --> 00:12:19,220
だから、あなたが31の要素を持つ配列を持っていることがわかります。

201
00:12:19,220 --> 00:12:22,440
そして私たちはハッシュテーブルにやっていることは、ハッシュ関数を持っている

202
00:12:22,440 --> 00:12:26,660
それは、インデックスのキーは、それぞれのint型に変換しようとしている。

203
00:12:26,660 --> 00:12:31,740
もし、例えば、私はBのハリソンのために選択する場合は、

204
00:12:31,740 --> 00:12:34,190
私はハッシュ関数でBにハリソンを置く、

205
00:12:34,190 --> 00:12:36,960
ハッシュ関数は、24を返します。

206
00:12:36,960 --> 00:12:40,930
だから私は、私が24でBにハリソンを格納したいことを知っている。

207
00:12:40,930 --> 00:12:46,580
だから、それはちょうど配列を有し、ハッシュテーブルを持つとの違いです。

208
00:12:46,580 --> 00:12:48,740
ハッシュテーブルでは、あなたを教えしようとしている機能があるでしょう

209
00:12:48,740 --> 00:12:54,740
保存したいデータを格納する場所。

210
00:12:54,740 --> 00:12:57,040
ハッシュ関数については、ハッシュ関数を探したい

211
00:12:57,040 --> 00:13:00,600
つまり、決定論的、よく分布している。

212
00:13:00,600 --> 00:13:07,810
あなたがここに見ることができるように、私は店に思ったデータの多くは、実際に19であったことを参照してください。

213
00:13:07,810 --> 00:13:12,470
代わりに、すべての自由だった31と30と29を使用する。

214
00:13:12,470 --> 00:13:16,920
だから、私が使用したハッシュ関数は非常によく配布されませんでした。

215
00:13:16,920 --> 00:13:20,710
我々は、よく分散型と言うとき、それは我々がしたいことを意味し、

216
00:13:20,710 --> 00:13:26,520
およそ、の各々について、少なくとも1又は2  - 

217
00:13:26,520 --> 00:13:32,190
アレイ内のインデックスの各々について1又は2の差、などが挙げられる。

218
00:13:32,190 --> 00:13:43,950
あなたは、およそ、配列内の各リンクリスト内の要素数が同じであるしたいと思います。

219
00:13:43,950 --> 00:13:48,600
そしてそれは、ハッシュテーブル内の有効なのかどうかを確認するのは簡単です、ハッシュテーブルとして表示します。

220
00:13:48,600 --> 00:13:51,770
>>すると木。これは木です。

221
00:13:51,770 --> 00:13:56,400
コンピュータサイエンスの木は何らかの理由で逆さまである。

222
00:13:56,400 --> 00:14:00,150
だから、ここであなたは、ツリーのルート、次に葉を持っています。

223
00:14:00,150 --> 00:14:05,630
あなただけの両親と子供のための命名法を知っている必要があります。

224
00:14:05,630 --> 00:14:12,880
各ノードには、親の下にあるノードでその子を持っています。

225
00:14:12,880 --> 00:14:19,660
したがって、たとえば、図2に示すように、右が3のためにと他の子の親であることを行っている

226
00:14:19,660 --> 00:14:25,290
3は、1の親とがある他の子供であることを行っている間。

227
00:14:25,290 --> 00:14:29,990
そして1は、というように3の子になるだろう、とされている。

228
00:14:29,990 --> 00:14:34,610
我々は、はるかに興味深いもの、二分探索木と呼ばれるがあります

229
00:14:34,610 --> 00:14:39,040
その内のノードの右側にあるすべての値

230
00:14:39,040 --> 00:14:41,660
右ここでは、右側にあることを行っている - の右側に、

231
00:14:41,660 --> 00:14:46,780
ルートの要素よりも大きくなるだろうしている。

232
00:14:46,780 --> 00:14:49,780
右のだから私はここ数5を持っている場合、すべての要素

233
00:14:49,780 --> 00:14:51,940
5以上になるだろう、とされている左側の

234
00:14:51,940 --> 00:14:56,770
すべての要素が5未満であることを行っている。

235
00:14:56,770 --> 00:14:58,780
なぜこれが役立ちましたか？

236
00:14:58,780 --> 00:15:01,660
まあ、私は数7はここにあるかどうかを確認したい場合は、例えば、

237
00:15:01,660 --> 00:15:05,960
私は最初の5に行くと私は見に行くよ、5より7大きいか小さい？

238
00:15:05,960 --> 00:15:09,540
それは大きなだので、私はそれがツリーの右側になるように持っているつもりだ知っている。

239
00:15:09,540 --> 00:15:13,980
だから私は見てはるかに少ないものを持っている。

240
00:15:13,980 --> 00:15:19,520
二分探索木の実装では、ノードが、私はデータを持っているつもりだけど、

241
00:15:19,520 --> 00:15:21,750
そうINT nが、あなたはまた、文字列を持つことができ

242
00:15:21,750 --> 00:15:23,630
またはあなたが望む何でも。

243
00:15:23,630 --> 00:15:28,100
あなただけの小さいものを、大きいものを定義する上で注意する必要があります。

244
00:15:28,100 --> 00:15:30,390
ですから、文字列があった場合、たとえば、あなたが定義することができます

245
00:15:30,390 --> 00:15:34,690
右のすべてのものは、より大きな長さを持っているとしていることを、

246
00:15:34,690 --> 00:15:40,940
左が下の長さを持っているとしているので、それはあなた次第です、本当に。

247
00:15:40,940 --> 00:15:44,930
>>どのようにすれば、BSTを見つけるに実装することができますか？

248
00:15:44,930 --> 00:15:47,840
ルートがNULLの場合、我々がしなければならないだろう最初のことはチェックです。

249
00:15:47,840 --> 00:15:50,920
それがNULLなら、それは物がないことを意味します

250
00:15:50,920 --> 00:15:53,330
あなたも木を持っていないので、右か？

251
00:15:53,330 --> 00:15:55,790
だから私はfalseを返します。

252
00:15:55,790 --> 00:15:58,740
そうでなければ、私は番号が大きいかどうかを確認するつもりだ

253
00:15:58,740 --> 00:16:01,720
ルートの値より。

254
00:16:01,720 --> 00:16:04,250
私は右側の要素を見つけようとするつもりだ

255
00:16:04,250 --> 00:16:08,590
木の。

256
00:16:08,590 --> 00:16:11,310
あなたは、私がここに再帰を使用していることがわかります。

257
00:16:11,310 --> 00:16:14,150
それはあまりだ場合には、その後、私は左を見て行きます。

258
00:16:14,150 --> 00:16:18,330
そして最後に、そうでなければ、それは大きな少ないかではない場合、

259
00:16:18,330 --> 00:16:20,660
それは値自体だということです。

260
00:16:20,660 --> 00:16:23,010
だから、僕はtrueを返します。

261
00:16:23,010 --> 00:16:26,360
あなたがもし、もし、あれば私が使用していることをここに見ることができます。

262
00:16:26,360 --> 00:16:30,820
と覚えて、クイズ0で、我々はもし、あれば、あれば持っていた問題を抱えていた、

263
00:16:30,820 --> 00:16:32,780
あなたは、非効率性を見つけることになっていた、

264
00:16:32,780 --> 00:16:35,180
と非効率は、次の場合に使用したということでした。

265
00:16:35,180 --> 00:16:39,060
もしそうでなければ、もし、それ以外他に、場合は、使用している必要があります。

266
00:16:39,060 --> 00:16:44,240
ifとelse ifとelseここだから、私は他に使うべきでしょうか？

267
00:16:44,240 --> 00:16:46,200
ない人 - うん？

268
00:16:46,200 --> 00:16:51,140
[学生に言えば、聞こえない]

269
00:16:51,140 --> 00:16:53,480
それは最高だ。そこで彼女は、それは問題ではないことを言っている

270
00:16:53,480 --> 00:16:55,930
我々の前に持っていたという理由だけで非効率

271
00:16:55,930 --> 00:16:59,550
いくつかの条件が満たされたかもしれない場合には、そのためだった、

272
00:16:59,550 --> 00:17:03,570
だから、アクションを実行しましたが、その後、他のすべての条件を確認するつもりだった。

273
00:17:03,570 --> 00:17:06,319
しかし、この場合には、すぐに返されたので、それは問題ではありません。

274
00:17:06,319 --> 00:17:09,220
だからかどう他に使用する必要はありません。

275
00:17:09,220 --> 00:17:11,740
>>そして最後に、の試みについて話しましょう​​、

276
00:17:11,740 --> 00:17:13,800
そのみんなのお気に入りです。

277
00:17:13,800 --> 00:17:15,980
TRYは、配列のツリーです。

278
00:17:15,980 --> 00:17:20,369
これは、値を参照するために非常に高速だが、それは大量のメモリを使用しています。

279
00:17:20,369 --> 00:17:22,530
そして、それは言葉をフィルタリングするために、通常なので、ときに

280
00:17:22,530 --> 00:17:27,920
お使いの携帯電話内の電話帳のように、例えば、私は知りませんが、実装したい

281
00:17:27,920 --> 00:17:30,440
あなたは、Bを入力できるようにしたい

282
00:17:30,440 --> 00:17:32,510
ちょうどBを持っている人の名前を持っている

283
00:17:32,510 --> 00:17:37,960
それは、例えば、トライを使用していることを実現するのは非常に簡単です。

284
00:17:37,960 --> 00:17:39,820
どのようにしてみるのノードを定義するのですか？

285
00:17:39,820 --> 00:17:43,910
あなただけのis_wordされようとしているBOOLを持っている必要があります。

286
00:17:43,910 --> 00:17:48,660
つまり、そのノードの前にすべての文字を使用していることを表し、

287
00:17:48,660 --> 00:17:51,920
あなたは単語を形成することができました、

288
00:17:51,920 --> 00:17:57,230
そしてその後は、ノードへのポインタの配列があるでしょう。

289
00:17:57,230 --> 00:18:03,120
あなたは私たちが親ノードの配列なので、ノード*配列を持っていることを見ることができますか？うん？

290
00:18:03,120 --> 00:18:06,050
それでは、それが動作する方法を見てみましょう。スペルチェックのために、

291
00:18:06,050 --> 00:18:08,230
我々は、27素子のアレイを有し、

292
00:18:08,230 --> 00:18:12,150
我々はすべての文字に加えてアポストロフィを持っているので。

293
00:18:12,150 --> 00:18:17,800
ここで前に私はちょうど私がボードに書き込むことができるようにしたいので、2を使用するつもりです。

294
00:18:17,800 --> 00:18:20,230
大丈夫。だから、これは試してみるの例です。

295
00:18:20,230 --> 00:18:25,600
私は最初のノードを定義した場合、私は2要素の配列があるでしょう

296
00:18:25,600 --> 00:18:29,290
つまり、NULLに2のポインタであるので、私はちょうど 'と' b 'を追加。

297
00:18:29,290 --> 00:18:32,430
そして、私はis_word言うBOOLを持っているつもりです。

298
00:18:32,430 --> 00:18:34,420
これは、最初の1のために偽になるだろう、

299
00:18:34,420 --> 00:18:37,370
ただ、そのため前に任意の文字を持っていない。

300
00:18:37,370 --> 00:18:40,900
だから、空の言葉は言葉ではない。だから、偽です。

301
00:18:40,900 --> 00:18:46,320
私はこの辞書に「A」を追加したい場合、私は何をしなければならないでしょう？

302
00:18:46,320 --> 00:18:49,760
私は 'A'のための新しいノードををmallocしなければならない、

303
00:18:49,760 --> 00:18:54,630
した後、trueに単語を追加する。

304
00:18:54,630 --> 00:19:00,180
だから、それだけで持つこと」「本当であることを行っていることを表している。理にかなって？

305
00:19:00,180 --> 00:19:04,120
私は「BA」を追加したい場合は、その後、私は 'B'のためのmalloc 1する必要があります、

306
00:19:04,120 --> 00:19:07,550
そして私は、falseにブールを設定するつもりだ

307
00:19:07,550 --> 00:19:10,160
単独では「B」は言葉ではないので。

308
00:19:10,160 --> 00:19:13,010
それから私は別の 'A'の1ので、「BA」ををmallocするつもりだ、

309
00:19:13,010 --> 00:19:16,290
そして、私はそれが本当のWordのセットアップするつもりです。

310
00:19:16,290 --> 00:19:18,950
「BA」は言葉であるため。

311
00:19:18,950 --> 00:19:21,910
私が見たい場合は、次に「B」は、この辞書にある場合

312
00:19:21,910 --> 00:19:26,730
私は最初に1、 'B'に行くことができます。私がダウンして、私は見て言葉であり、それは誤ったと言います。

313
00:19:26,730 --> 00:19:30,110
だから、言葉ではありません。私は、「BA」をチェックしたい場合は、

314
00:19:30,110 --> 00:19:38,010
私は最初の1、「B」に移動し、「A」に行き、私は真の参照なので、言葉である。理にかなって？

315
00:19:38,010 --> 00:19:41,950
多くの人々が試みることで混乱する。なし？

316
00:19:41,950 --> 00:19:44,740
>>最後に、ハフマン符号化。ハフマン符号化は、非常に便利です

317
00:19:44,740 --> 00:19:47,550
メモリを保存し、テキストフ​​ァイルを圧縮するには、

318
00:19:47,550 --> 00:19:52,270
という理由だけであなたは、たとえば、 'a'と 'E'を使用し多くの時間、

319
00:19:52,270 --> 00:19:57,710
あなたたちは同じくらい 'Q'または 'Z'を使用している場合、あなたの文書に、私は知らない。

320
00:19:57,710 --> 00:20:02,040
一つ一つの文字に対してだけで1バイトを持つことは、

321
00:20:02,040 --> 00:20:08,520
ひとつひとつの - 私たちはASCIIテーブルを持っている256の文字は非常に最適ではない、

322
00:20:08,520 --> 00:20:11,410
あなたがはるかに使用するいくつかの文字があるという理由だけで、

323
00:20:11,410 --> 00:20:15,180
だから、おそらくそれらのために、より少ないメモリを使用する必要があります。

324
00:20:15,180 --> 00:20:17,560
私は、ハフマン符号化をどのように使うのですか？

325
00:20:17,560 --> 00:20:20,010
私たちは、ハフマン木をしなければならない。

326
00:20:20,010 --> 00:20:23,370
 ハフマンツリーはノードを持つ

327
00:20:23,370 --> 00:20:27,760
手紙、 'C'、 'B'、 'A'、のようなことを行っているシンボルを持っている、

328
00:20:27,760 --> 00:20:32,990
あなたが持っているどのような文字、単語がテキストで表示された周波数であり、周波数、

329
00:20:32,990 --> 00:20:36,280
あなたがハフマンツリーを作成していたこと、

330
00:20:36,280 --> 00:20:41,800
した後、ハ​​フマン木の左を指すように起こっているノード

331
00:20:41,800 --> 00:20:47,210
と右を指すように起こっている別のノード。だから木が好きです。

332
00:20:47,210 --> 00:20:49,440
どのようにしてハフマンツリーを構築しますか？

333
00:20:49,440 --> 00:20:54,020
あなたが最も低い周波数を持つ2つのノードを選択するつもりだ。

334
00:20:54,020 --> 00:20:56,490
あなたはネクタイを持っている場合は、2つのノードを選択するつもりだ

335
00:20:56,490 --> 00:20:59,870
同様に、最も低いASCII値を持っている。

336
00:20:59,870 --> 00:21:02,420
次に、これらの2つのノードから新しいツリーを作成しましょう

337
00:21:02,420 --> 00:21:08,030
それは、親ノードに組み合わさ周波数を持っているとしている。

338
00:21:08,030 --> 00:21:13,240
そして、あなたは森から2子を削除しようとしている

339
00:21:13,240 --> 00:21:15,570
親に置き換えます。

340
00:21:15,570 --> 00:21:18,930
そして、あなたはあなただけの森の中で1木になるまでそれを繰り返すつもりだ。

341
00:21:18,930 --> 00:21:23,840
それでは、あなたがZAMYLA用ハフマン木をするだろう方法を見てみましょう。

342
00:21:23,840 --> 00:21:29,220
あなたはすべての文字が「A」を除いて、周波数1を持っていることをここに見ることができます。周波数2を有している。

343
00:21:29,220 --> 00:21:34,090
だから私は、私はASCII値と周波数の順に入れてすべての文字のためのノードを作成しました。

344
00:21:34,090 --> 00:21:40,090
私が最初にツリーを作成したいのであれば、それは「L」と「M」とされます。

345
00:21:40,090 --> 00:21:43,100
だから、ここにある。ペアの頻度は2になります

346
00:21:43,100 --> 00:21:49,470
それは+1 1だから、それから、最も低い周波数を持つ次の2は「Y」と「Z」である。

347
00:21:49,470 --> 00:21:53,180
2の周波数を持っている - そして私はそれらのすべてがされています。

348
00:21:53,180 --> 00:22:00,470
ので、次の1のための最低のASCII値を持つものは、どれですか？

349
00:22:00,470 --> 00:22:04,830
'A'と 'L'。だから私は、新しいノードを作成し、

350
00:22:04,830 --> 00:22:09,930
そして最後に、4と2なので、2は左側にあることを行っている。

351
00:22:09,930 --> 00:22:12,430
そして、これはハフマン木である。

352
00:22:12,430 --> 00:22:16,060
それから私はいくつかのテキストを書きたい場合には、

353
00:22:16,060 --> 00:22:24,440
のようなハフマン木を使用して、テキストに変換するためのバイナリには非常に簡単です。

354
00:22:24,440 --> 00:22:30,220
私は左に移動すると、0と右に移動していることを言う場合は、1である

355
00:22:30,220 --> 00:22:32,410
行くが表現することは何ですか？

356
00:22:32,410 --> 00:22:35,530
だから、右なので右、1、1のような

357
00:22:35,530 --> 00:22:40,370
次いでそのように左0は、Lになり、次いで1,0,0。

358
00:22:40,370 --> 00:22:43,950
だから1、0、これだけ1、0、 'A'。

359
00:22:43,950 --> 00:22:47,540
して、0、1、その「Z」。

360
00:22:47,540 --> 00:22:52,170
して、1、0、0  - いいえ。

361
00:22:52,170 --> 00:22:56,780
0、0、怠け者「Y」になります。

362
00:22:56,780 --> 00:23:06,060
だから、私にとってすべてです、ロブのは引き継ぐつもり。

363
00:23:06,060 --> 00:23:08,400
>> [ロブ·ボーデン]だから、週7のもの。

364
00:23:08,400 --> 00:23:11,390
我々は本当に速いの上に行くためにたくさん持っている。

365
00:23:11,390 --> 00:23:13,430
ビット演算子、バッファオーバーフロー、

366
00:23:13,430 --> 00:23:16,760
CS50ライブラリ、そしてHTML、HTTP、CSS。

367
00:23:16,760 --> 00:23:20,990
全部で15〜20分のような。

368
00:23:20,990 --> 00:23:24,330
ビット演算子。あなたが知る必要があると彼らの6があります。

369
00:23:24,330 --> 00:23:31,200
ビット単位AND、ビット単位のOR、XOR、左シフト、右シフトではなく、。

370
00:23:31,200 --> 00:23:35,420
右シフトしていないあなたがほとんどすべてでの講演で見た。

371
00:23:35,420 --> 00:23:40,480
我々はすぐにここで上に行くだろうが、それはこれらが存在する6であることを知って良いことだ。

372
00:23:40,480 --> 00:23:45,070
ビット演算子を使用すると、+ 4 3を行うときのようなものであることを忘れないでください。

373
00:23:45,070 --> 00:23:49,420
あなたは3および4のバイナリを扱っていません。

374
00:23:49,420 --> 00:23:56,550
ビット演算子を使用すると、実際に数字3と4の個々のビットを扱っている。

375
00:23:56,550 --> 00:23:59,120
>>だから我々は言うでしょう最初の1は、ビット単位ではない、

376
00:23:59,120 --> 00:24:02,340
そしてそれがない、すべてはすべてのビットを反転です。

377
00:24:02,340 --> 00:24:05,500
あなたがC言語でこれを書いているのであれば、ここで、あなたはそれを書かないだろう

378
00:24:05,500 --> 00:24:09,380
〜11011または任意として、あなたは、〜4のように記述します

379
00:24:09,380 --> 00:24:12,970
そして、それは4のバイナリ表現を反転あろう。

380
00:24:12,970 --> 00:24:24,800
だからここに、いくつかの〜進数1101101のは、正確に1の0のへのすべての1とすべて0を反転しようとしている。

381
00:24:24,800 --> 00:24:27,600
私はそこに言ったように、これを頻繁に使用、

382
00:24:27,600 --> 00:24:30,830
そして我々は我々はいくつかの数を思い付くしたいようなもので、少しでそれを見ることができます

383
00:24:30,830 --> 00:24:35,460
ビットのすべては、それらの一つを除いて、1どこ。

384
00:24:35,460 --> 00:24:38,560
だから、数を表現するために、通常は簡単です

385
00:24:38,560 --> 00:24:40,630
ちょうどその単一のビットがセットされる場合には、

386
00:24:40,630 --> 00:24:44,650
して、そのように他のすべてのビットはその1を除いて設定されていることの〜を取る。

387
00:24:44,650 --> 00:24:50,300
だから、我々は少しで多くを使用するつもりだものだ。

388
00:24:50,300 --> 00:24:58,220
>>ビットごとのOR。ここでは2進数、およびこれらの2つの数値がある

389
00:24:58,220 --> 00:25:00,780
彼らはすべての可能を表すことから、かなり代表的なものである

390
00:25:00,780 --> 00:25:07,290
ビットの組み合わせは、あなたが上で動作する必要がある可能性があります。

391
00:25:07,290 --> 00:25:13,540
私は各ビットを論理和するときここで、我々だけでまっすぐに比較しようとしている。

392
00:25:13,540 --> 00:25:15,410
だから、左側に私たちは、1と1を持っている。

393
00:25:15,410 --> 00:25:20,510
私はビット単位のときは|ものを、私は何を取得するつもりですか？一つ。

394
00:25:20,510 --> 00:25:25,320
その後、ビット単位| 0と1は私を与えるために起こっている？一つ。

395
00:25:25,320 --> 00:25:27,840
ビット単位の1と0は同じもの、1になるだろう。

396
00:25:27,840 --> 00:25:31,880
ビット単位0 | 0は私0を与えるために起こっている。

397
00:25:31,880 --> 00:25:37,300
0ケース|だから私は0を得る唯一のケースは0である。

398
00:25:37,300 --> 00:25:40,020
そしてあなたは自分の論理和をとり、そのようなものと考えることができます。

399
00:25:40,020 --> 00:25:44,830
あなたは、真1、偽0と考えるのであれば、同じことがここでも適用される。

400
00:25:44,830 --> 00:25:50,040
だから、真または真真であり、trueまたはfalseはtrueです。

401
00:25:50,040 --> 00:25:57,150
falseまたはtrueはtrueです。虚偽または虚偽のは、実際に偽の唯一のものです。

402
00:25:57,150 --> 00:26:00,100
ここであなたが知っておくべき例です

403
00:26:00,100 --> 00:26:05,160
ビット演算子を使用した場合のかなり良い例として。

404
00:26:05,160 --> 00:26:08,660
ここまたはOX20との資本 'A'の場合、

405
00:26:08,660 --> 00:26:11,830
そして我々は我々が何かを得る、第二に、これらを見てみましょう。

406
00:26:11,830 --> 00:26:16,020
我々または小文字の 'OX20であれば、我々は何かを得る。

407
00:26:16,020 --> 00:26:26,750
それでは、ASCIIテーブルを引き上げてみましょう。

408
00:26:26,750 --> 00:26:34,000
大丈夫。ここでは「A」であることがわかります - 

409
00:26:34,000 --> 00:26:36,920
ここでは、「A 'は65進数である必要があります。

410
00:26:36,920 --> 00:26:45,120
しかし、私はOx41で16進数、一緒に行くよ。

411
00:26:45,120 --> 00:26:48,280
かなり確信して、私たちは、クラスでそれを見た。私たちはクラスでそれを見たと思う

412
00:26:48,280 --> 00:26:52,730
それは、16進数のバイナリに変換するために非常に簡単だということ。

413
00:26:52,730 --> 00:26:55,280
だからここに、私はバイナリに4を入れたい場合には、

414
00:26:55,280 --> 00:26:59,550
それはちょうど0100になるだろう。

415
00:26:59,550 --> 00:27:03,620
これは1の位、2の位、4の場所であるので、これは4である。

416
00:27:03,620 --> 00:27:08,550
それから私は0001であることを行っているバイナリの中に1を分割することができます。

417
00:27:08,550 --> 00:27:14,280
そしてこれは、バイナリ内の「A」の表現になるだろう。

418
00:27:14,280 --> 00:27:22,720
小文字の ''、それが今Ox61になるだろうと考えると、

419
00:27:22,720 --> 00:27:27,050
そのバイナリに、これらを分割する場合、、その6  - 

420
00:27:27,050 --> 00:27:37,830
それでは、実際にそれをやってみましょう - ん、消しゴムがないのはなぜですか。消しゴム。

421
00:27:37,830 --> 00:27:48,220
Ox61。だから、バイナリに6を分割する+ 4 + 2 + 0 0になるだろう。

422
00:27:48,220 --> 00:27:54,610
そして分割1は0001になるだろう。

423
00:27:54,610 --> 00:27:56,520
これら2との違いを見てみると、

424
00:27:56,520 --> 00:28:04,250
私たちは、小文字と大文字の 'A'の間の唯一の違いは、この単一のビットであることがわかります。

425
00:28:04,250 --> 00:28:11,810
だから、ここに戻ってくるまで - 大丈夫。

426
00:28:11,810 --> 00:28:15,920
我々は少しOX20が何であるかを見れば、ここに戻ってくると、

427
00:28:15,920 --> 00:28:22,210
そう、そのバイナリにOX20を分割、

428
00:28:22,210 --> 00:28:27,310
0010、0000である。

429
00:28:27,310 --> 00:28:33,470
OX20、設定されている唯一のビットは、我々はと懸念している、このビットである

430
00:28:33,470 --> 00:28:38,210
資本と小文字の間で ''を切り替えると。

431
00:28:38,210 --> 00:28:47,610
私か、この1である「A」、「A」であれば、

432
00:28:47,610 --> 00:28:50,580
もしIまたはOX20と「A」、

433
00:28:50,580 --> 00:28:53,490
私は何を取得するつもりですか？

434
00:28:53,490 --> 00:28:58,960
[学生、聞こえない] >>小文字の「A」、それは、このビットを1に反転するために起こっているからです。

435
00:28:58,960 --> 00:29:04,170
そしてもし私か '' OX20で、私は何を取得するつもりですか？

436
00:29:04,170 --> 00:29:08,780
単に '' OX20と論理和をとるため、小文字

437
00:29:08,780 --> 00:29:14,580
私はちょうど1に、この単一のビット論理和をとることするつもりだ、それは問題ではありませんので、それは、すでに1です。

438
00:29:14,580 --> 00:29:17,960
だから我々は、 'a'と 'A'を得る。

439
00:29:17,960 --> 00:29:24,820
>>ビット単位のAND。再び、我々は我々の論理と相手と考えることができます。

440
00:29:24,820 --> 00:29:28,180
左側には、我々は真＆真持っています。

441
00:29:28,180 --> 00:29:31,160
それが本当であることを行って、例のすべてについてですが、

442
00:29:31,160 --> 00:29:36,270
偽＆trueまたは真·偽、またはfalse＆偽

443
00:29:36,270 --> 00:29:38,550
それらのものがいずれも該当しない。

444
00:29:38,550 --> 00:29:44,170
それでは、私たちが得てしまうことは1000年である。

445
00:29:44,170 --> 00:29:48,830
だから今、ここで、ここで私は信頼できる、ビット単位のいない使用しましたところですが、

446
00:29:48,830 --> 00:29:52,230
私たちは、OX20を持っていたところ。

447
00:29:52,230 --> 00:29:54,350
だから、これはOX20です。

448
00:29:54,350 --> 00:29:59,570
今、私が何をしたいのか、ビット単位のOX20の〜。

449
00:29:59,570 --> 00:30:03,600
それはすべてのビットを反転しようとしている。

450
00:30:03,600 --> 00:30:09,330
だから私は、1101年、1111年を持っている。

451
00:30:09,330 --> 00:30:18,940
だから〜OX20とAND 'A'は私に何を与えるために起こっている？

452
00:30:18,940 --> 00:30:22,430
私たちは本当に考える必要がある唯一のビットは、この1である、

453
00:30:22,430 --> 00:30:26,020
以来、これらのビットのすべてが1に設定されている場合、

454
00:30:26,020 --> 00:30:29,000
その後、我々は、 'A'があった正確に何を取得するつもりだ

455
00:30:29,000 --> 00:30:31,260
を除いて、おそらく、このビットはどのようである。

456
00:30:31,260 --> 00:30:34,460
それが1だった場合は、ここでは0に設定される予定なので、

457
00:30:34,460 --> 00:30:39,810
これが何であれ、これが0になるだろうとANDので。

458
00:30:39,810 --> 00:30:43,280
だから、「A」は〜OX20は私を与えるつもり＆何ですか？

459
00:30:43,280 --> 00:30:48,200
[学生が答える、聞こえない] >>そして、「A」とはどのようなものである - それは「A」です。

460
00:30:48,200 --> 00:30:52,170
と ''＆〜OX20は私を与えるつもりは何ですか？

461
00:30:52,170 --> 00:30:56,720
'A.'これは、現在1であるため。

462
00:30:56,720 --> 00:30:59,570
この0との論理積は、それを0にするとしている

463
00:30:59,570 --> 00:31:02,530
そして今、我々は「A」を取得するつもりだ。

464
00:31:02,530 --> 00:31:06,600
>>どちらも '、A'であり、この種の最後になりましたが、

465
00:31:06,600 --> 00:31:10,830
我々は、排他的論理和を持っている。それは非常に多くのようなものだか、

466
00:31:10,830 --> 00:31:14,400
それは排他的手段または除いて。

467
00:31:14,400 --> 00:31:18,420
これは、通常、または現実世界で考えるもののようです。

468
00:31:18,420 --> 00:31:23,190
だから、どちらか 'X'または 'Y'ではなく、両方を行う。

469
00:31:23,190 --> 00:31:28,700
ここで1 ^ 1は0になるだろう。

470
00:31:28,700 --> 00:31:33,650
真のためである - それは論理的真と偽と同様に動作しません

471
00:31:33,650 --> 00:31:37,150
、ビット単位＆およびまたはそうであるように

472
00:31:37,150 --> 00:31:40,100
しかし、本当の^真はfalseです。

473
00:31:40,100 --> 00:31:44,810
我々は唯一のいずれか一方のみが真の場合にtrueを返すようにしたいので。

474
00:31:44,810 --> 00:31:50,950
だから、1 ^ 1は0である。何^ 1 0はどうでしょうか？

475
00:31:50,950 --> 00:31:56,010
1です。 1 ^ 0 ^ 0 0は0、1である。

476
00:31:56,010 --> 00:32:03,890
だから、すべての状況下で、0ビット単位のもの0は0になるだろう。

477
00:32:03,890 --> 00:32:10,270
1ビットごとに何か0または0ビット単位の1、

478
00:32:10,270 --> 00:32:14,660
それはだた場合|または^、それは1になるでしょうし、それは＆だ場合、それは0になるでしょう。

479
00:32:14,660 --> 00:32:20,850
そして1ビット単位の1が1でない場合だけは、排他的論理和である。

480
00:32:20,850 --> 00:32:24,580
それは0110です。

481
00:32:24,580 --> 00:32:36,520
だからここに今、排他的論理和を使用して - 私たちは戻って20にいる。

482
00:32:36,520 --> 00:32:43,480
'' ^ OX20は、我々が比較しているこれらの2ビットである。

483
00:32:43,480 --> 00:32:50,020
だから、1 ^ 0は私に何を与えるために起こっている？ 1。

484
00:32:50,020 --> 00:32:58,430
'' ^ OX20は私を与えるために起こっている？小文字。

485
00:32:58,430 --> 00:33:04,010
'' ^ OX20は私を与えるために起こっている？資本A.

486
00:33:04,010 --> 00:33:09,310
これはやっているものは何でも、OX20、このXOR演算

487
00:33:09,310 --> 00:33:15,380
効果的にこのビットが何であれフリッピングされる。

488
00:33:15,380 --> 00:33:21,240
これが0であれば、それは今1になるために起こっている。

489
00:33:21,240 --> 00:33:26,160
これが1であるため、^ 1は0である。

490
00:33:26,160 --> 00:33:33,280
だから私たちの ''は 'A'となっている、と私たちの 'A'は ''となっています。

491
00:33:33,280 --> 00:33:36,910
だから、XORは念をひっくり返すのは本当に便利です。

492
00:33:36,910 --> 00:33:39,960
あなただけの文字列を反復処理したい

493
00:33:39,960 --> 00:33:44,330
そして一つ一つの文字の大文字と小文字を交互に、

494
00:33:44,330 --> 00:33:50,680
OX20とあなただけのXORすべて。

495
00:33:50,680 --> 00:33:55,220
>>今、私たちはシフトを残している。左シフトはただ、基本的には、しようとしている

496
00:33:55,220 --> 00:34:01,250
へ、あるいは左に数字のすべてをプッシュすると、その背後に0を挿入します。

497
00:34:01,250 --> 00:34:05,550
そこでここでは、00001101を持っています。

498
00:34:05,550 --> 00:34:08,560
我々は、右から3 0年代をプッシュするつもりだ

499
00:34:08,560 --> 00:34:13,580
そして我々は01101000を得る。

500
00:34:13,580 --> 00:34:16,380
バイナリ以外の面では、

501
00:34:16,380 --> 00:34:24,699
我々は、本当に13左シフト3で、私たちに104を与え扱うだことがわかります。

502
00:34:24,699 --> 00:34:32,530
だから、左シフトは、我々はここを参照してください、X << yは基本的には、X * 2 ^ yです。

503
00:34:32,530 --> 00:34:40,139
* 2 13 ^ 3 ^ 3 2が13 * 8が104で、8です。

504
00:34:40,139 --> 00:34:45,679
あなただけの一般的な、どのように各桁内のバイナリを考えた場合、

505
00:34:45,679 --> 00:34:49,530
我々は右から起動する場合は、1の位は、2のところ、それから4の場所です。

506
00:34:49,530 --> 00:34:51,330
だから、右から0年代に押すことにより、

507
00:34:51,330 --> 00:34:55,080
私達はちょうど、8の場所に4の観戦したものをプッシュしている

508
00:34:55,080 --> 00:34:57,920
そして16の場所に8の観戦したもの。

509
00:34:57,920 --> 00:35:01,280
各シフトはわずか2で乗算します。うん？

510
00:35:01,280 --> 00:35:05,210
あなたは5分シフトした場合、[学生]はどうなりますか？

511
00:35:05,210 --> 00:35:10,790
[ボーデン]あなたは5だけシフトした場合、あなただけの数字を失うことになる。

512
00:35:10,790 --> 00:35:15,410
必然的に、それは同じことだ。同様に、整数は32ビットであり、

513
00:35:15,410 --> 00:35:20,750
あなたは2本当に大きな整数を追加した場合ので、それだけで、整数に収まらない。

514
00:35:20,750 --> 00:35:23,660
だから、ここでは同じことだ。あなたは5分シフトした場合、

515
00:35:23,660 --> 00:35:25,650
我々はちょうどその1を失うことになる。

516
00:35:25,650 --> 00:35:28,820
そして、それは "ほぼ"私は何を意味のようなものだ

517
00:35:28,820 --> 00:35:37,470
あなたはあまりにも遠くにシフトした場合には、ビットを失うところ。

518
00:35:37,470 --> 00:35:39,830
>>右シフトは逆になるだろう、

519
00:35:39,830 --> 00:35:43,090
我々は、末尾から0を突き出すつもりだどこ

520
00:35:43,090 --> 00:35:48,400
そして我々の目的のために、左から0年代に記入してください。

521
00:35:48,400 --> 00:35:52,910
だから、これをやって、我々は基本的に我々はすでに行っていたものを反転している。

522
00:35:52,910 --> 00:35:57,780
そして、我々は、右の3 0ちょうど落ちていることがわかります

523
00:35:57,780 --> 00:36:02,020
私たちは右に1101のすべての方法をプッシュしている。

524
00:36:02,020 --> 00:36:08,380
これは、事実上、X / 2 ^ yは104 >> 3をやっている。

525
00:36:08,380 --> 00:36:11,200
だから今、ここでは、同じような考えです。

526
00:36:11,200 --> 00:36:18,720
なぜそれだけでおおよそのx / 2 ^ Yではなく、実際にはX / 2 ^ Y？

527
00:36:18,720 --> 00:36:22,240
私は4だけずれていた場合、私は1を失っているからである。

528
00:36:22,240 --> 00:36:25,950
基本的に、どのようなあなたが考えるには、単に一般的に整数の除算を考える。

529
00:36:25,950 --> 00:36:31,070
だから、5月2日のような2です。それは2.5ではありません。

530
00:36:31,070 --> 00:36:35,000
ここは同じ考えです。私たちは、2で割る場合には、

531
00:36:35,000 --> 00:36:39,910
私たちは道に沿って奇数ビットを失う可能性があります。

532
00:36:39,910 --> 00:36:43,870
だから今 - それは、ビット単位のためにそれだ。それはあなたが知る必要があるすべてです。

533
00:36:43,870 --> 00:36:46,340
我々は、クラスで見たユースケースを覚えて、

534
00:36:46,340 --> 00:36:49,340
ビットマスクのようなビット演算子のために有用であり、

535
00:36:49,340 --> 00:36:53,220
または、ビットマスクのためにそれらを使用しています。

536
00:36:53,220 --> 00:36:58,620
大文字と小文字、変換はかなり典型的な例である。

537
00:36:58,620 --> 00:37:01,640
>>わかりま​​したので、バッファオーバーフロー攻撃。

538
00:37:01,640 --> 00:37:05,110
誰もがこの機能に間違っていたものを覚えていますか？

539
00:37:05,110 --> 00:37:10,140
、我々は12バイトで、12文字の配列を宣言し注目してください

540
00:37:10,140 --> 00:37:18,510
そして、我々は12文字列全体バーの我々のバッファにコピーします。

541
00:37:18,510 --> 00:37:25,080
だから、ここでの問題は何ですか？

542
00:37:25,080 --> 00:37:32,270
なぜ12  - マジックナンバー12はかなりすぐにように飛び出す必要がありますか？

543
00:37:32,270 --> 00:37:35,050
バーは12文字以上であることを起こるとしたらどう？

544
00:37:35,050 --> 00:37:41,200
何バーは、文字の何百万人であるかの？

545
00:37:41,200 --> 00:37:46,010
ここでの問題は、memcpyをです。バーが十分に長い場合、

546
00:37:46,010 --> 00:37:50,330
それだけで完全になります -  'C'、 'c'は、それが唯一の12文字だったことを気にしない。

547
00:37:50,330 --> 00:37:53,280
'c'は、それが多くのバイトを収めることができないことを気にしません。

548
00:37:53,280 --> 00:37:58,250
それだけで完全に文字が上書きされ、我々はそれのために割り当てられてきた12バイト、

549
00:37:58,250 --> 00:38:01,830
そして、実際にそのバッファに属していないメモリに過去のすべてのもの

550
00:38:01,830 --> 00:38:06,520
どのような文字列バーがあると。

551
00:38:06,520 --> 00:38:09,780
だから、これは私たちが授業で見た絵だった

552
00:38:09,780 --> 00:38:12,220
我々は我々のスタックを育った場所。

553
00:38:12,220 --> 00:38:16,040
あなたはこれらの写真を使用したり、再び慣れる必要があります。

554
00:38:16,040 --> 00:38:21,260
我々は、スタックが育っている、メモリアドレスは、上部に0から始まります

555
00:38:21,260 --> 00:38:26,270
と下部に40億を好きにダウンして成長する。

556
00:38:26,270 --> 00:38:28,820
私たちは、どこかにメモリ内の私達の配列 'c'を持っている

557
00:38:28,820 --> 00:38:32,260
その後、我々は右のそれの下に棒に私たちのポインタを持っている、

558
00:38:32,260 --> 00:38:38,720
そして、我々は、この私たちのリターンアドレスと私たちの親ルーチンのスタック内のフレームポインタを保存している。

559
00:38:38,720 --> 00:38:40,800
リターンアドレスが何であるかを覚えていますか？

560
00:38:40,800 --> 00:38:45,360
主な機能バーを呼び出し、関数fooを呼び出したときに、それは、だ

561
00:38:45,360 --> 00:38:48,100
必然的に、返品バー。

562
00:38:48,100 --> 00:38:52,610
そうするときバーが戻ると、彼らはそれが戻ってそれを呼ばfooのために起こっていることを知っておく必要があります。

563
00:38:52,610 --> 00:39:01,360
だから、リターンアドレスは、関数が戻るときに返さなければならない関数のアドレスです。

564
00:39:01,360 --> 00:39:05,830
バッファオーバーフロー攻撃のために重要なの理由は、都合からである、

565
00:39:05,830 --> 00:39:09,580
ハッカーはそのリターンアドレスを変更したい。

566
00:39:09,580 --> 00:39:14,950
代わりに戻っfooへ行くの、私は戻って、ハッカーが私に戻って行きたいところへ行くつもりです。

567
00:39:14,950 --> 00:39:17,760
そして、便利なことに、ハッカーは頻繁に戻って行きたいところ

568
00:39:17,760 --> 00:39:22,400
我々は元々持っていたバッファの先頭です。

569
00:39:22,400 --> 00:39:26,170
だから、もう一度、リトルインドに注目してください。

570
00:39:26,170 --> 00:39:28,490
アプライアンスは、リトルインディアンシステムの一例である、

571
00:39:28,490 --> 00:39:34,140
その整数またはポインタが逆にバイトで保存されます。

572
00:39:34,140 --> 00:39:38,980
だからここに私達が見る - これは何ですか？うん。

573
00:39:38,980 --> 00:39:45,660
私たちは、Ox80、OxC0、OX35、OxO8を参照してください。

574
00:39:45,660 --> 00:39:48,250
桁の16進数を覚えていますか？

575
00:39:48,250 --> 00:39:50,640
我々は、リトルインドにおける桁の16進数を逆にしないでください

576
00:39:50,640 --> 00:39:56,110
2進数の桁が1バイトを構成している、と私たちはバイトを逆からです。

577
00:39:56,110 --> 00:40:00,300
我々は80530CO8、同じように、保管しない理由です。

578
00:40:00,300 --> 00:40:07,520
我々は右から、その代わりに、2桁の各ペアを格納します。

579
00:40:07,520 --> 00:40:10,880
そのアドレスは、先頭のアドレスを参照

580
00:40:10,880 --> 00:40:15,190
我々は、実際に最初の場所でにコピーしたかった私たちのバッファの。

581
00:40:15,190 --> 00:40:19,230
便利だ理由は、どのような場合、攻撃される

582
00:40:19,230 --> 00:40:24,100
だけではなくだった文字列を持つのに起こった

583
00:40:24,100 --> 00:40:27,060
等を無害な文字列、自分の名前か何か、

584
00:40:27,060 --> 00:40:33,900
どのような場合は、代わりに、その文字列はいくつかの任意のコードだった

585
00:40:33,900 --> 00:40:38,610
それは彼らがそれをやってみたかった何でしたか？

586
00:40:38,610 --> 00:40:45,630
そこで、彼らは可能性が - 私はすべてのクールなコードを考えることはできません。

587
00:40:45,630 --> 00:40:47,780
これは、しかし、何でもかまいません。どんな悲惨なコード。

588
00:40:47,780 --> 00:40:51,440
彼らが望んした場合、彼らはSEG故障で何かを行うことができますが、それは無意味になります。

589
00:40:51,440 --> 00:40:54,950
彼らは通常、あなたのシステムをハックするためにそれをやる。

590
00:40:54,950 --> 00:40:59,930
>>オーケー。 CS50ライブラリ。

591
00:40:59,930 --> 00:41:04,800
これは、基本的には、のgetInt、getStringを、私たちはあなたのため提供されるすべてのこれらの関数である。

592
00:41:04,800 --> 00:41:10,630
だから我々は、char *文字列があり、それは我々が吹き飛ばした抽象化だ

593
00:41:10,630 --> 00:41:12,450
学期中のある時点で。

594
00:41:12,450 --> 00:41:18,220
文字列は文字の配列だけであることに注意してください。

595
00:41:18,220 --> 00:41:23,240
そこでここでは、getStringをの簡略版を参照してください。

596
00:41:23,240 --> 00:41:25,920
あなたはそれを実際に実装している方法を覚えておくことを振り返る必要があります。

597
00:41:25,920 --> 00:41:30,950
キーの詳細は、我々は、一度に単一の文字を取っ気づく

598
00:41:30,950 --> 00:41:34,570
ちょうど私達がキーボードでタイプするようなもので、これで標準から。

599
00:41:34,570 --> 00:41:37,890
だから、一度に単一の文字、そして我々はあまりにも多くの文字を取得する場合、

600
00:41:37,890 --> 00:41:40,580
そう+ nは1容量よりも大きい場合には、

601
00:41:40,580 --> 00:41:44,140
その後、我々は我々のバッファの容量を増やす必要があります。

602
00:41:44,140 --> 00:41:47,780
そこでここでは、我々のバッファのサイズを倍にしている。

603
00:41:47,780 --> 00:41:51,840
そして、それはいっている、我々は我々のバッファに文字を挿入

604
00:41:51,840 --> 00:41:56,220
私たちは、新しい行またはファイルまたは何の終わりを受信するまで、

605
00:41:56,220 --> 00:41:59,380
その場合には、我々は、文字列、次に実際のgetStringをして終了です

606
00:41:59,380 --> 00:42:05,120
我々はあまりにも多くのメモリを割り当てた場合、それは戻って少し縮みますように、メモリを縮小します。

607
00:42:05,120 --> 00:42:08,830
だから我々はそれを示していないが、主なアイデアはある

608
00:42:08,830 --> 00:42:11,960
一度に単一の文字を読み込むことがあります。

609
00:42:11,960 --> 00:42:17,140
それだけで一度に全部で読むことができない、

610
00:42:17,140 --> 00:42:19,550
そのバッファは、特定のサイズであるためです。

611
00:42:19,550 --> 00:42:26,590
それがバッファに挿入しようとした文字列が大きすぎるのであれば、それはオーバーフローする。

612
00:42:26,590 --> 00:42:28,940
そこでここでは、単一の文字を読み込んでいることを防ぐ

613
00:42:28,940 --> 00:42:33,750
当時、我々がする必要があるときはいつでも成長しています。

614
00:42:33,750 --> 00:42:40,270
そうのgetIntや他CS50ライブラリ関数は、getStringをを使用する傾向がある

615
00:42:40,270 --> 00:42:42,310
その実装では。

616
00:42:42,310 --> 00:42:45,370
だから私はここで重要なことを強調した。

617
00:42:45,370 --> 00:42:49,460
これは、文字列を取得するためには、getStringを呼び出します。

618
00:42:49,460 --> 00:42:51,710
のgetStringは、メモリを返すことができなかった場合は、

619
00:42:51,710 --> 00:42:54,270
のgetStringのmalloc何かで登録して、呼び出されるたびにgetStringことを覚えておいてください

620
00:42:54,270 --> 00:42:57,820
あなたは（理解できない）あなたが得たその文字列を解放しないでください。

621
00:42:57,820 --> 00:43:02,870
それが何かをのmallocに失敗したのであれば、ここで、我々は、単にフラグとしてINT_MAXを返す

622
00:43:02,870 --> 00:43:05,650
ねえ、私たちは実際には整数を取得することができませんでした。

623
00:43:05,650 --> 00:43:10,830
あなたは私があなたに戻って何でも無視すべきである、または

624
00:43:10,830 --> 00:43:15,540
あなたは有効な入力として扱うべきではありません。

625
00:43:15,540 --> 00:43:21,360
最終的に、それが成功しなかったと仮定すると、我々は、特別なフラグを指定してsscanf関数を使う

626
00:43:21,360 --> 00:43:23,820
つまり、最初の整数と一致し、

627
00:43:23,820 --> 00:43:26,770
その整数の後に任意の文字に一致する。

628
00:43:26,770 --> 00:43:29,070
だから我々はそれが1と等しくなるようにしたい気づく。

629
00:43:29,070 --> 00:43:32,940
だから、sscanfは戻りは正常にどのように多くの試合をした場合はどうなりますか？

630
00:43:32,940 --> 00:43:37,010
それが成功して整数にマッチした場合は1が返され、

631
00:43:37,010 --> 00:43:40,890
それは、整数と一致しなかった場合は0を返し、それは2を返します

632
00:43:40,890 --> 00:43:45,920
それが一致した場合には、整数は、いくつかの文字が続く。

633
00:43:45,920 --> 00:43:49,780
だから我々は1以外のものと一致した場合、我々は再試行気づく。

634
00:43:49,780 --> 00:43:55,230
私たちが入力した場合は1、2、3、C、または1、2、3、X、

635
00:43:55,230 --> 00:43:57,400
それから1、2、3の整数に格納さになるだろう、

636
00:43:57,400 --> 00:43:59,620
Xは、文字で保存になるだろう

637
00:43:59,620 --> 00:44:06,410
我々は唯一の整数をしたいので、sscanf関数は2を返します、そして我々は再試行になります。

638
00:44:06,410 --> 00:44:09,810
>>すばやく、HTML、HTTP、CSSを吹く。

639
00:44:09,810 --> 00:44:15,340
ハイパーテキストマークアップ言語は、ウェブの構造と意味です。

640
00:44:15,340 --> 00:44:19,960
ここでは、HTMLタグを持って講義からの例です。

641
00:44:19,960 --> 00:44:22,110
我々は、ヘッドタグ、bodyタグを有する

642
00:44:22,110 --> 00:44:27,770
我々は、我々が実際に開始と終了タグを持たない空のタグの例を持っている

643
00:44:27,770 --> 00:44:30,820
我々だけで、リンクや画像を持っている。

644
00:44:30,820 --> 00:44:38,480
全く閉じイメージタグはありません。タグが行う必要があるすべてのものを達成するだけで、単一のタグがあります。

645
00:44:38,480 --> 00:44:41,950
リンクは例であり、我々はあなたがCSSにリンクする方法を見ていき、

646
00:44:41,950 --> 00:44:45,910
スクリプトは、外部のJavaScriptにリンクする方法の例です。

647
00:44:45,910 --> 00:44:53,100
それは非常に簡単だし、HTMLはプログラミング言語ではありませんが、覚えています。

648
00:44:53,100 --> 00:44:58,250
ここでは、これがどうなるのか、フォームを定義するか、少なくともだろうか覚えている？

649
00:44:58,250 --> 00:45:01,740
このような形態は、アクションとメソッドがあります。

650
00:45:01,740 --> 00:45:06,210
あなただけの今まで表示されます方法は、GETとPOSTです。

651
00:45:06,210 --> 00:45:09,040
そうなものをURLに入れれますバージョンです取得します。

652
00:45:09,040 --> 00:45:11,680
それは、URLに置かれていない場合、POSTはある。

653
00:45:11,680 --> 00:45:18,520
代わりに、フォームからのデータは、HTTP要求に、より隠された挿入されている。

654
00:45:18,520 --> 00:45:22,390
HTTPリクエストがどこに行くので、ここで、アクションが定義されています。

655
00:45:22,390 --> 00:45:27,490
それが起こっている場所は、google.com /検索です。

656
00:45:27,490 --> 00:45:32,890
方法。 GETとPOSTの違いを覚えて、

657
00:45:32,890 --> 00:45:37,200
ブックマークの何かにしたい場合や、単に、例として言う。

658
00:45:37,200 --> 00:45:40,660
あなたは、POSTのURLをブックマークすることができなくなります

659
00:45:40,660 --> 00:45:44,970
データはURLに含まれていないため。

660
00:45:44,970 --> 00:45:49,790
>> HTTPは、今、ハイパーテキスト転送プロトコルである。

661
00:45:49,790 --> 00:45:54,080
あなたはそれが転送するのに期待するハイパーテキスト転送プロトコル、

662
00:45:54,080 --> 00:45:57,710
ハイパーテキストマークアップ言語、それはない。

663
00:45:57,710 --> 00:46:00,170
それはまた、あなたがWeb上で見つけた画像を転送し、

664
00:46:00,170 --> 00:46:05,400
あなたが作る任意のダウンロードは、HTTPリクエストとして開始します。

665
00:46:05,400 --> 00:46:10,350
だから、HTTPはWorld Wide Webの言語だけです。

666
00:46:10,350 --> 00:46:15,610
そしてここでは、HTTPリクエストのこの種を認識する必要があります。

667
00:46:15,610 --> 00:46:19,300
ここ側のHTTP/1.1はちょうどそのバージョンだと言う

668
00:46:19,300 --> 00:46:21,570
私が使用しているプロトコルの。

669
00:46:21,570 --> 00:46:25,770
これはかなり、常にあなたがそれを見ることができますように、HTTP/1.1になるだろう。

670
00:46:25,770 --> 00:46:30,110
その後、我々は、これはあなたが見るかもしれないと、GET、POSTされて代替したことがわかります。

671
00:46:30,110 --> 00:46:40,790
そして、私が訪問しようとしていたURLがwww.google.com/search?q =何とか、何とか、何とかだった。

672
00:46:40,790 --> 00:46:44,240
だから覚えて、この、疑問符Q =何とか何とか何とか、

673
00:46:44,240 --> 00:46:49,040
フォームから送信されるものの一種である。

674
00:46:49,040 --> 00:46:51,830
それは私に返される可能性があります応答は次のようになり。

675
00:46:51,830 --> 00:46:54,050
ここでも、そのことを行っているプロトコルで始まる

676
00:46:54,050 --> 00:46:59,190
ステータスコードが続く。ここでは、200 OKです。

677
00:46:59,190 --> 00:47:05,060
そして最後に、私が実際に求めたウェブページが続きます。

678
00:47:05,060 --> 00:47:08,210
可能なステータスコードは次のように表示されます、あなたはそれらのいくつかを知っている必要があります。

679
00:47:08,210 --> 00:47:12,770
200 OKあなたはおそらく前に見てきました。

680
00:47:12,770 --> 00:47:17,830
403禁止、404見つかりません、500内部サーバーエラー

681
00:47:17,830 --> 00:47:22,140
あなたがウェブサイトにアクセスして、何かが壊れているか、彼らのPHPコードがクラッシュした場合、通常、

682
00:47:22,140 --> 00:47:24,930
アプライアンスで、我々はその大きなオレンジ色のボックスを持っているのに対し、

683
00:47:24,930 --> 00:47:27,830
それがアップするなどで、何かが間違っている、と言い、このコードは動作しません

684
00:47:27,830 --> 00:47:30,380
またはこの関数の悪い。

685
00:47:30,380 --> 00:47:33,230
通常のウェブサイトでは、あなたは関数が実際に悪いかを知る必要はありません

686
00:47:33,230 --> 00:47:37,880
だからではなく、彼らはあなたに500内部サーバーエラーを与えるでしょう。

687
00:47:37,880 --> 00:47:43,050
>> TCP / IPは、HTTP下で1層である。

688
00:47:43,050 --> 00:47:47,550
インターネットはワールド·ワイド·ウェブの外に存在することを忘れないでください。

689
00:47:47,550 --> 00:47:52,270
好きな人は、HTTPを経由しないオンラインゲームをプレイする場合には、

690
00:47:52,270 --> 00:47:55,740
それは違うを通じて起こっている - それはまだ、インターネットを使っている、

691
00:47:55,740 --> 00:47:58,900
それは、HTTPを使用しません。

692
00:47:58,900 --> 00:48:02,470
HTTPはTCP / IPプロトコル上に構築されたのほんの一例である。

693
00:48:02,470 --> 00:48:07,820
IPは、文字通り、インターネットプロトコルを意味します。

694
00:48:07,820 --> 00:48:11,500
すべてのコンピュータはIPアドレスを持って、彼らはそれらの4桁のものです

695
00:48:11,500 --> 00:48:16,510
192.168.2.1のような、または何でも、それは地元の1になる傾向がある。

696
00:48:16,510 --> 00:48:23,390
しかし、それは、IPアドレスのパターンです。

697
00:48:23,390 --> 00:48:29,060
そう、DNS、ドメインネームサービス、

698
00:48:29,060 --> 00:48:33,410
つまり、実際のIPアドレスにgoogle.comのようなものを翻訳ものだ。

699
00:48:33,410 --> 00:48:37,700
ですから、URLにそのIPアドレスを入力すると、

700
00:48:37,700 --> 00:48:40,850
それは、Googleにあなたをもたらすだろうが、あなたはそれらの事を覚えていない傾向がある。

701
00:48:40,850 --> 00:48:45,470
代わりに、google.comを覚えがちである。

702
00:48:45,470 --> 00:48:51,560
我々が持っている最後のことは、これはIPアドレスのTCPの一部であるポートです。

703
00:48:51,560 --> 00:48:54,880
TCPは、より多くを行います。あなたのWeb​​ブラウザを実行している、のように、考えてみてください。

704
00:48:54,880 --> 00:48:58,670
たぶん、あなたは、いくつかの電子メールアプリケーションを実行している。

705
00:48:58,670 --> 00:49:02,150
多分あなたは、インターネットの実行を使用して他のプログラムを持っている。

706
00:49:02,150 --> 00:49:05,090
彼らはすべてのインターネットにアクセスする必要があり、

707
00:49:05,090 --> 00:49:08,100
しかし、あなたのコンピュータは1 WiFiカードまたは何を持っています。

708
00:49:08,100 --> 00:49:10,780
だからポートは、我々は分割することができるしている方法です

709
00:49:10,780 --> 00:49:13,550
どのようにこれらのアプリケーションは、インターネットを使用することができます。

710
00:49:13,550 --> 00:49:17,230
各アプリケーションは、それが聴くことができます1特定のポートを取得します

711
00:49:17,230 --> 00:49:19,670
と、デフォルトでは、HTTPはポート80を使用しています。

712
00:49:19,670 --> 00:49:22,410
一部の電子メールサービスでは、25を使用しています。

713
00:49:22,410 --> 00:49:24,490
小さい番号のものは予約される傾向にある。

714
00:49:24,490 --> 00:49:29,270
通常は、自分のために高い番号のものを得ることができます。

715
00:49:29,270 --> 00:49:32,010
>> CSS、カスケーディングスタイルシート。

716
00:49:32,010 --> 00:49:36,030
我々のCSSとHTML形式ではなく、との様式のウェブページ。

717
00:49:36,030 --> 00:49:38,440
あなたのCSSを置くことができる3の場所があります。

718
00:49:38,440 --> 00:49:46,300
それはスタイルのタグの間、または完全に別のファイルにしてからインチリンク、インラインすることができます

719
00:49:46,300 --> 00:49:48,470
そして、ここで、CSSのほんの一例です。

720
00:49:48,470 --> 00:49:50,450
あなたはこのパターンを認識する必要があり、

721
00:49:50,450 --> 00:49:54,310
ここで最初の例は、私たちは、bodyタグに一致しているが、

722
00:49:54,310 --> 00:49:56,680
そしてここでは、bodyタグを中心としている。

723
00:49:56,680 --> 00:50:00,420
第二の例は、事を一致している

724
00:50:00,420 --> 00:50:04,740
IDのフッターに、我々はそれにいくつかのスタイルを適用しています。

725
00:50:04,740 --> 00:50:07,310
左にそのIDのフッターテキスト整列に注意してください

726
00:50:07,310 --> 00:50:09,840
本文テキスト、整列センターのに対し。

727
00:50:09,840 --> 00:50:13,180
フッターは体内にある。

728
00:50:13,180 --> 00:50:16,470
それは、体がテキスト整列センターを言っていても、左ではなく、テキストを整列します。

729
00:50:16,470 --> 00:50:18,880
これは、全体のカスケーディング部分です。

730
00:50:18,880 --> 00:50:22,110
あなたが持つことができます - あなたは身体のスタイルを指定することができ、

731
00:50:22,110 --> 00:50:25,320
した後、体内にあるものは、あなたがより多くの特定のスタイルを指定することができ、

732
00:50:25,320 --> 00:50:28,160
物事が期待どおりに動作します。

733
00:50:28,160 --> 00:50:34,420
より具体的なCSSの指定子が優先されます。

734
00:50:34,420 --> 00:50:46,140
私は、それはそれだと思う。

735
00:50:46,140 --> 00:50:49,260
>> [アリナーム]皆さん、こんにちは。私はあなたの注意を得ることができれば。

736
00:50:49,260 --> 00:50:53,990
私はアリだと私は本当に速いPHPとSQLを介して行くつもりです。

737
00:50:53,990 --> 00:51:00,310
だから我々は開始することができます。 PHPは、PHPの略です：Hypertext Preprocessorの。

738
00:51:00,310 --> 00:51:03,730
あなたはすべて知っている必要がありますようにと、それはサーバー側のスクリプト言語ですが、

739
00:51:03,730 --> 00:51:06,800
私たちはウェブサイトのバックエンドのためにそれを使用する、

740
00:51:06,800 --> 00:51:12,540
そしてそれはどのように計算、舞台裏シーン部分の多くを行います。

741
00:51:12,540 --> 00:51:17,510
構文。これは、C、驚き、驚きのようではありません。

742
00:51:17,510 --> 00:51:22,060
私は先に移動することはできません - それは常にあなたが見ることができれば、、で始まる必要があります。

743
00:51:22,060 --> 00:51:31,340
あなたは、ブレースの新しい種類が必要に見ることができますし、その後も？PHPを必要としています。

744
00:51:31,340 --> 00:51:35,780
それは、あなたのPHPのテキスト、PHPコードをフレームに持っているか、常にです。

745
00:51:35,780 --> 00:51:39,180
だから、ちょうどあなたが初めての試みの上に置く、Cのようにすることはできません。

746
00:51:39,180 --> 00:51:42,290
あなたはいつもそれを囲む必要があります。

747
00:51:42,290 --> 00:51:47,610
そして今、主要な構文は、すべての変数は$文字で開始する必要があるということです。

748
00:51:47,610 --> 00:51:49,490
あなたは、あなたがそれらを定義しているときにそれを行う必要がある、あなたはそれを行う必要があります

749
00:51:49,490 --> 00:51:51,860
後で、彼らにに言及しているとき。

750
00:51:51,860 --> 00:51:56,510
あなたは、常にその$を必要としています。これはかなり、あなたの新しい親友だ。

751
00:51:56,510 --> 00:52:01,690
あなたはしない -  Cとは異なり、それは変数の型の種類を置く必要はありません。

752
00:52:01,690 --> 00:52:04,940
あなたは$を必要ですがだから、あなたは、のように、配置する必要はありません

753
00:52:04,940 --> 00:52:09,470
int型のxまたは文字列Y、エトセトラ、エトセトラ。

754
00:52:09,470 --> 00:52:11,490
そうわずかな違い。

755
00:52:11,490 --> 00:52:15,590
この結果、PHPが弱く型であることを意味する。

756
00:52:15,590 --> 00:52:19,310
PHPは弱く型言語であり、それが弱いの変数を入力した。

757
00:52:19,310 --> 00:52:24,020
言い換えれば、それはあなたが、変数の型の異なる種類を切り替えることができますことを意味します。

758
00:52:24,020 --> 00:52:27,230
あなたはintとしてあなたの番号1を格納することができ、

759
00:52:27,230 --> 00:52:29,650
あなたはそれを文字列として格納することができます、そしてあなたは、floatとしてそれを保存することができ、

760
00:52:29,650 --> 00:52:33,550
そしてそれはすべてその数1になります。

761
00:52:33,550 --> 00:52:36,080
あなたは様々な形態でそれを保存しているにもかかわらず、

762
00:52:36,080 --> 00:52:39,120
それはまだです - 変数の型は、まだ最終的に保持している。

763
00:52:39,120 --> 00:52:41,540
ですから、ここで見れば、あなたはPSET 7から覚えていれば、

764
00:52:41,540 --> 00:52:43,500
皆さんの多くは、おそらくこれで問題があった。

765
00:52:43,500 --> 00:52:47,280
等号2つ、3等号、4等号。

766
00:52:47,280 --> 00:52:49,990
さて、何4等号はありませんが、2と3があります。

767
00:52:49,990 --> 00:52:53,320
あなたが値をチェックするために2等号を使用しています。

768
00:52:53,320 --> 00:52:55,830
これは、タイプにわたってチェックすることができます。

769
00:52:55,830 --> 00:52:58,770
だから、最初の例で見ることができれば、

770
00:52:58,770 --> 00:53:02,210
私はnum_int == num_stringを持っている。

771
00:53:02,210 --> 00:53:06,710
だからあなたのint型や、文字列の両方があり、技術的には、1、

772
00:53:06,710 --> 00:53:10,790
しかし、彼らはさまざまなタイプだ。しかし、二重等号のために、それはまだ渡します。

773
00:53:10,790 --> 00:53:15,510
しかし、トリプルイコールのために、それは価値だけでなく、様々なタイプをチェックします。

774
00:53:15,510 --> 00:53:18,760
つまり、ここでは、第2の場合に渡すつもりはないことを意味し、

775
00:53:18,760 --> 00:53:22,350
あなたが代わりに3等号を使用しているところ。

776
00:53:22,350 --> 00:53:26,590
だから、あなたがすべての今示されているはずの大きな違いです。

777
00:53:26,590 --> 00:53:31,570
>>文字列の連結を使用すると、PHPで使用できるもう1つの強力なものです。

778
00:53:31,570 --> 00:53:34,080
それは、基本的にはこの便利なドット表記です

779
00:53:34,080 --> 00:53:36,230
それはあなたが一緒に文字列を結合することができる方法です。

780
00:53:36,230 --> 00:53:40,800
だから、猫を持っていて、犬を飼っている、とあなたが一緒に2文字列を入れたい場合には、

781
00:53:40,800 --> 00:53:44,080
あなたはピリオドを使用することができ、それは、それがどのように動作するかのようなものだ。

782
00:53:44,080 --> 00:53:46,660
また、単に隣同士にそれらを配置することができ、

783
00:53:46,660 --> 00:53:49,030
あなたは下の例では、ここで見ることができるように、

784
00:53:49,030 --> 00:53:51,610
私は、文字列1、スペース文字列2をエコーし​​ているところ。

785
00:53:51,610 --> 00:53:56,930
PHPはそのように置き換えることがわかります。

786
00:53:56,930 --> 00:53:59,780
配列。今、PHPで、配列の2種類があります。

787
00:53:59,780 --> 00:54:03,180
あなたは、通常の配列を持つことができます。また、連想配列を持つことができ、

788
00:54:03,180 --> 00:54:06,040
そして我々は今、それらを介して行くつもりです。

789
00:54:06,040 --> 00:54:08,280
通常の配列はC言語でこれだけある、

790
00:54:08,280 --> 00:54:11,240
ので、あなたは、番号が付けられているインデックスを持っている。

791
00:54:11,240 --> 00:54:13,160
今私達はちょうど1を作成するために行くと置いています - 

792
00:54:13,160 --> 00:54:15,500
これは、我々は空の配列を作成する方法ですし、我々はするつもりだ

793
00:54:15,500 --> 00:54:17,310
インデックス番号0に入れた。

794
00:54:17,310 --> 00:54:19,200
私たちは、数6、値6を置くつもりです。

795
00:54:19,200 --> 00:54:21,500
ここ一番下にそれを見ることができます。

796
00:54:21,500 --> 00:54:24,240
Where's  - インデックス番号1で我々は、値番号4を置くつもりだ

797
00:54:24,240 --> 00:54:26,720
あなたは6があると見ることができるので、図4に示すように、あります

798
00:54:26,720 --> 00:54:29,160
そして、我々は物事をプリントするように、

799
00:54:29,160 --> 00:54:33,550
我々は試してみて、インデックス番号0に格納された値を出力するとき、

800
00:54:33,550 --> 00:54:36,900
その後、我々は6が印刷されている値が表示されます。クール？

801
00:54:36,900 --> 00:54:40,160
だから、あなたのための通常の配列です。

802
00:54:40,160 --> 00:54:42,750
あなたも今通常の配列に物事を追加することができます別の方法

803
00:54:42,750 --> 00:54:44,780
あなただけの末尾に追加することができますです。

804
00:54:44,780 --> 00:54:47,240
つまり、特定のインデックスを指定する必要はありませんことを意味します。

805
00:54:47,240 --> 00:54:51,000
あなたが数を確認することができますし、角括弧内に指定されたインデックスがありません。

806
00:54:51,000 --> 00:54:56,270
そして、それは知っているだろう -  PHPはちょうどリストの最後に、次のフリースポットに追加し知っている。

807
00:54:56,270 --> 00:54:59,190
だから、その0スポットで右が1を見ることができます

808
00:54:59,190 --> 00:55:02,690
図2は、第1スポットで右そこに行った。

809
00:55:02,690 --> 00:55:04,690
3は行く - そこにも追加されます。

810
00:55:04,690 --> 00:55:06,720
だから、その種類の意味があります。あなただけの、常にそれを追加して、

811
00:55:06,720 --> 00:55:09,360
そして、我々は、数1のインデックスをエコーし​​ているとき

812
00:55:09,360 --> 00:55:13,080
それは値2を出力します。

813
00:55:13,080 --> 00:55:16,800
>>その後、我々は連想配列である配列を持っています。

814
00:55:16,800 --> 00:55:19,370
代わりに、数値的指標を持っていることの連想配列、

815
00:55:19,370 --> 00:55:23,630
彼らは何をやっていることは、彼らが文字列であるインデックスを持っている、である。

816
00:55:23,630 --> 00:55:25,670
あなたの代わりに、見ることができます - 私は、これらすべての数値指標を処分した、

817
00:55:25,670 --> 00:55:32,140
今ではKEY1、KEY2、KEY3だし、彼らはすべての文字列したことを示すために、二重引用符にしている。

818
00:55:32,140 --> 00:55:34,470
だから我々は、この一例を持つことができます。

819
00:55:34,470 --> 00:55:38,790
この一例は、我々はtfは有することがあり、それはインデックス名だ。

820
00:55:38,790 --> 00:55:42,030
私たちは、カロリーを食べ、インデックスで、名前として「アリ」を置くつもりだ

821
00:55:42,030 --> 00:55:47,640
私たちは、文字列の代わりにint型にこの時間を置くことができ、

822
00:55:47,640 --> 00:55:52,240
そして、インデックスが好きで、我々はその中に配列全体を置くことができます。

823
00:55:52,240 --> 00:55:55,490
だから、これは種類のものである - それは我々が持っていた方法と似た概念だ

824
00:55:55,490 --> 00:55:58,930
番号のインデックスが、今、私たちの周りのインデックスを変更することができます

825
00:55:58,930 --> 00:56:03,890
代わりに、文字列としてそれらを持っている。

826
00:56:03,890 --> 00:56:06,070
また、単に個々にそれをやって以外に、これを行うことができ、

827
00:56:06,070 --> 00:56:09,400
あなたは1チャンクにそれをすべて行うことができます。だから、その配列のTFを見ることができます

828
00:56:09,400 --> 00:56:13,350
そして、我々は1巨大な角括弧セットにそれらをすべて設定してください。

829
00:56:13,350 --> 00:56:15,220
だから物事をスピードアップすることができます。

830
00:56:15,220 --> 00:56:19,730
それがないよりは文体の選択の詳細です。

831
00:56:19,730 --> 00:56:21,550
また、ループを持っている。

832
00:56:21,550 --> 00:56:26,020
C言語では、このような働きをするループを持っている。

833
00:56:26,020 --> 00:56:29,690
我々は我々の配列を持っていたし、我々はリストの最後にインデックス0から行きました、

834
00:56:29,690 --> 00:56:31,740
そして我々は正しい、それをすべて印刷する？

835
00:56:31,740 --> 00:56:33,880
問題を除き、連想配列のために、である、

836
00:56:33,880 --> 00:56:36,610
我々は、必ずしもこれらの数値指標を知らない

837
00:56:36,610 --> 00:56:39,610
今、私たちは、文字列のインデックスを持っているので。

838
00:56:39,610 --> 00:56:44,800
今、我々は再び、あなたがうまくいけばPSET 7で使用し、foreachのループを使用しています。

839
00:56:44,800 --> 00:56:48,930
のforeachループは単にリストの一つ一つの部分を知っている。

840
00:56:48,930 --> 00:56:52,450
そして、それはあなたが持っている正確に数値インデックスを知っている必要はありません。

841
00:56:52,450 --> 00:56:56,490
だから、foreachの構文を持っているので、それがforeachのです、あなたは配列を置く。

842
00:56:56,490 --> 00:57:00,430
だから私の配列はPSETと呼ばれ、その後、などのワードとして、

843
00:57:00,430 --> 00:57:04,530
そして、あなたが使用しようとしているこのローカルの一時的な変数を入れて

844
00:57:04,530 --> 00:57:10,690
ただ特定を保持するために起こっている具体的なもののために - 

845
00:57:10,690 --> 00:57:14,770
1インスタンスまたは配列の1セクション。

846
00:57:14,770 --> 00:57:18,350
、PSETのnumは1を保持し、その後、多分それは数6を開催します

847
00:57:18,350 --> 00:57:20,410
そしてそれは数2を開催します。

848
00:57:20,410 --> 00:57:26,630
しかし、それは、アレイ内のすべての単一の値を通過することが保証されている。

849
00:57:26,630 --> 00:57:30,530
あなたは、PHPで知っておくべき便利な機能が必要とされ、

850
00:57:30,530 --> 00:57:35,880
終了、空、エコーだから、あなたが特定のファイルをインクルードしていることを確認します。

851
00:57:35,880 --> 00:57:40,490
私は非常にPSET 7を見て、それらの機能を見てお勧めします。

852
00:57:40,490 --> 00:57:42,810
あなたがそれらを知っているかもしれない、

853
00:57:42,810 --> 00:57:47,060
私は間違いなく正確に、それらはすべて何をしているか、知っているだろう。

854
00:57:47,060 --> 00:57:50,080
>>そして今、我々は本当にすぐにスコープを通過しようとしている。

855
00:57:50,080 --> 00:57:53,490
スコープでは、PHPは、C言語とは異なり、ファンキーなものの一種である

856
00:57:53,490 --> 00:57:56,170
ので、我々だけですぐにそれを通過しようとしている。

857
00:57:56,170 --> 00:57:58,930
それでは、私たちはそこに持っている矢印で開始しましょう​​。

858
00:57:58,930 --> 00:58:02,900
そして、我々は$ Iで開始するつもりだ。 'i'は0であることを行っているので、変数、

859
00:58:02,900 --> 00:58:06,730
そして私達はちょうどあそこの大きな白い箱に印刷維持するつもりだ。

860
00:58:06,730 --> 00:58:09,220
私たちは、I0で開始するつもりだし、私たちはそれをエコーするつもりだ。

861
00:58:09,220 --> 00:58:12,670
だから、0があります。

862
00:58:12,670 --> 00:58:15,210
そして、我々は、ループによってそれをインクリメントするつもりだ

863
00:58:15,210 --> 00:58:17,810
そして、それは1の値になるだろう。

864
00:58:17,810 --> 00:58:20,070
それはforループ、その通過に起こっているので、1つは、3以下である、

865
00:58:20,070 --> 00:58:23,230
そして、我々はそれが再び印刷された参照してくださいとしている。

866
00:58:23,230 --> 00:58:25,520
我々は、2のためにもう一度インクリメントするつもりだ

867
00:58:25,520 --> 00:58:29,860
および2は、3未満であるので、ループで通るだろうし、それが2を印刷します。

868
00:58:29,860 --> 00:58:35,100
その後、3が3以上であることに注意しますので、forループから抜け出すだろう。

869
00:58:35,100 --> 00:58:40,050
だから今我々は終了しましたし、私たちはaFunctionに入るつもりだ。

870
00:58:40,050 --> 00:58:45,010
大丈夫。だから、この変数私達が作成したのであることに注意する必要があります

871
00:58:45,010 --> 00:58:48,270
'I'変数は、ローカルにスコープされていません。

872
00:58:48,270 --> 00:58:50,280
つまり、ループにローカルではないことを意味し、

873
00:58:50,280 --> 00:58:58,060
その変数は、我々はまだアクセスし、その後変更し、それはまだ有効となることができます。

874
00:58:58,060 --> 00:59:02,160
あなたは今、関数に入るのであれば、あなたは、我々はまた、 'I'変数を使用していることがわかります

875
00:59:02,160 --> 00:59:05,320
私たちは 'I' + +インクリメントするつもりだ。

876
00:59:05,320 --> 00:59:09,410
あなたはそれが 'I'変数のコピーだと、C言語に基づいて、最初は、と思うだろう。

877
00:59:09,410 --> 00:59:12,830
それが正しいのか、全く別のことだ。

878
00:59:12,830 --> 00:59:16,560
我々はそれを印刷するときので、私たちは、その4をプリントアウトしようとしている、 'I' +印刷しようとしている

879
00:59:16,560 --> 00:59:19,640
申し訳ありません - そして、我々はするつもりだ。

880
00:59:19,640 --> 00:59:22,030
その後、我々は、その関数の外に終了するつもりだ、

881
00:59:22,030 --> 00:59:24,820
そして我々は、その矢印が今ここになるだろう。

882
00:59:24,820 --> 00:59:29,190
それはその後、ただし、関数は「I」の値を変更していてもことを意味し、

883
00:59:29,190 --> 00:59:32,620
それは、関数の外で変化しなかった、

884
00:59:32,620 --> 00:59:35,060
機能は別々のスコープを持っているので。

885
00:59:35,060 --> 00:59:38,960
すなわち、我々は「私」をエコーするとき、それは関数の範囲に変化していないことを意味

886
00:59:38,960 --> 00:59:43,660
ので、我々は再び3を印刷しようとしている。

887
00:59:43,660 --> 00:59:47,520
C.よりもPHPのスコープについてのさまざまなこと

888
00:59:47,520 --> 00:59:51,130
>>今PHPとHTMLで。

889
00:59:51,130 --> 00:59:53,510
PHPは、ウェブページを動的にするために使用される。

890
00:59:53,510 --> 00:59:58,660
それはちょっと物事が違う。

891
00:59:58,660 --> 01:00:02,090
我々は、HTMLからのそれは別の持っている。

892
01:00:02,090 --> 01:00:05,230
HTMLで、我々は常にただ、ロブがあったかのように、同じ静的なものを持っている

893
01:00:05,230 --> 01:00:09,370
PHPのに対して、ユーザーが誰であるかに基づいて物事を変更することができます。

894
01:00:09,370 --> 01:00:11,830
私はこれを持っているなら、私は、「あなたがとしてログインしている -  "を持っているし、名前、

895
01:00:11,830 --> 01:00:14,420
と私は名前を変更することができます。だから、今の名前は、ジョセフです

896
01:00:14,420 --> 01:00:18,880
そしてそれは、「私のことを "持っていますが、私もトミーを持つように名前を変更することができます。

897
01:00:18,880 --> 01:00:21,700
そして、それは異なるものになるだろう。

898
01:00:21,700 --> 01:00:23,840
それでは我々はまた、彼についてさまざまなことを変更することができ、

899
01:00:23,840 --> 01:00:27,070
それは名前に基づいて異なるコンテンツを表示します。

900
01:00:27,070 --> 01:00:31,430
だから、PHPは一種のあなたのウェブサイトに何が起こっているか変更することができます。

901
01:00:31,430 --> 01:00:33,540
ここに同じです。それでも、それらは異なるコンテンツを有していることに注意して、

902
01:00:33,540 --> 01:00:38,870
あなたが技術的にはまだ表面に、同じWebページにアクセスしているにもかかわらず。

903
01:00:38,870 --> 01:00:43,450
HTMLを生成する。あなたがこれを行うことができます2つの方法があります。

904
01:00:43,450 --> 01:00:48,980
だから我々は今その権利を通過します。最初の方法は、あなたが持っている、である - ええ、申し訳ありません。

905
01:00:48,980 --> 01:00:51,150
だから、あなただけの、PHPでループの通常のを持っている

906
01:00:51,150 --> 01:00:56,270
そして、あなたは、PHPでのエコーとは、HTMLをエコーし​​ます。

907
01:00:56,270 --> 01:00:58,720
ロブは、HTMLスクリプトをユーザーに示したものを使用して

908
01:00:58,720 --> 01:01:04,030
そして、ちょうどWebページにそれをプリントアウトするためにPHPのプリントを使用した。

909
01:01:04,030 --> 01:01:09,520
別の方法は、PHPとHTMLを分離するかのようにそれを行うことです。

910
01:01:09,520 --> 01:01:11,940
だから、forループを開始し、PHPの行を持つことができます

911
01:01:11,940 --> 01:01:16,020
その後は別々のもので、HTMLの行を持つことができ、

912
01:01:16,020 --> 01:01:19,700
そして、あなたは、PHPで、もう一度、ループを終了します。

913
01:01:19,700 --> 01:01:21,800
だから、それを分離するようなものだ。

914
01:01:21,800 --> 01:01:24,020
左側には、あなたがすべて持っていることができます - 

915
01:01:24,020 --> 01:01:26,360
これは、PHPのちょうど1塊だ。

916
01:01:26,360 --> 01:01:28,510
右側には、あなたは、PHPのラインを持っていることがわかります

917
01:01:28,510 --> 01:01:32,540
あなたは、HTMLの行があり、再度、PHPのラインを持っている。

918
01:01:32,540 --> 01:01:36,870
そこで、彼らがやっていることにそれを分離する。

919
01:01:36,870 --> 01:01:39,330
そして、あなたはそれらのいずれかについて、そのいずれかの方法に注意してくださいよ、

920
01:01:39,330 --> 01:01:41,980
彼らは、静止画、画像、画像をプリントアウトし、

921
01:01:41,980 --> 01:01:44,540
その結果、HTMLはまだ同じように印刷されます。

922
01:01:44,540 --> 01:01:49,870
それから、あなたはまだ3画像をあなたのウェブサイト上に表示表示されます。

923
01:01:49,870 --> 01:01:52,820
だから、同じことを行うための2種類の方法です。

924
01:01:52,820 --> 01:01:55,060
>>今、私たちは、フォームや要求を持っている。ロブはあなたを示したように、

925
01:01:55,060 --> 01:01:59,400
そこにHTMLの形式があり、我々はちょうどこのを通してそよ風ます。

926
01:01:59,400 --> 01:02:02,040
あなたがアクションを持っていて、メソッドを持って、そしてあなたの行動

927
01:02:02,040 --> 01:02:04,350
種類のあなたがそれを送信しようとしているあなたが表示され、方法があるかどうか

928
01:02:04,350 --> 01:02:06,960
それはGETまたはPOSTになるだろう。

929
01:02:06,960 --> 01:02:11,220
とGETリクエストは、ロブが言ったように、フォームに入れてするつもりだことを意味します

930
01:02:11,220 --> 01:02:15,760
そしてあなたがURLに表示されませんPOSTリクエストに対し、URLとしてそれを見ることができます。

931
01:02:15,760 --> 01:02:17,840
そうわずかな違い。

932
01:02:17,840 --> 01:02:19,950
しかし、同じようなことだと一つのこと

933
01:02:19,950 --> 01:02:22,560
POSTおよびGETは平等に安全であるということです。

934
01:02:22,560 --> 01:02:26,430
だから、という理由だけでは、URLに表示されませんと思うかもしれ

935
01:02:26,430 --> 01:02:28,790
それは、POSTがより安全であることを意味し、

936
01:02:28,790 --> 01:02:34,420
しかし、あなたはまだあなたが送信している情報であなたのクッキーでそれを見ることができます。

937
01:02:34,420 --> 01:02:38,260
だから、約1または他のことを考えていない。

938
01:02:38,260 --> 01:02:42,160
注意すべきもう一つは、あなたがまた、セクションの変数を持っているということです。

939
01:02:42,160 --> 01:02:45,850
君たちは自分のユーザーID情報を取得するにはPSET 7でこれを使用していました。

940
01:02:45,850 --> 01:02:48,550
何が起きたかというと、この連想配列を使用することができますということでした、

941
01:02:48,550 --> 01:02:53,310
$ _SESSION、その後、別のものにアクセスすることができるしている

942
01:02:53,310 --> 01:02:57,720
とページ間で異なるものを格納します。

943
01:02:57,720 --> 01:03:00,750
>>最後の事は、我々は、SQL、構造化照会言語を持っているということです

944
01:03:00,750 --> 01:03:04,360
これは、データベースを管理するためのプログラミング言語です。

945
01:03:04,360 --> 01:03:08,220
正確には、データベースは何ですか？彼らは、テーブルの集合だ、

946
01:03:08,220 --> 01:03:10,630
各テーブルは、オブジェクトの同じような種類を持つことができます。

947
01:03:10,630 --> 01:03:14,990
だから我々はあなたの金融PSET内のユーザのテーブルを持っていた。

948
01:03:14,990 --> 01:03:20,610
そして、なぜ彼らは便利ですか？それが恒久的に情報を格納する方法だからです。

949
01:03:20,610 --> 01:03:22,840
それは、物事を追跡し、物事を管理する方法です

950
01:03:22,840 --> 01:03:25,890
そして実際には別のページと保持トラックにそれを見て。

951
01:03:25,890 --> 01:03:29,930
一方、あなたはちょうどその1即時瞬間に、それを格納する場合

952
01:03:29,930 --> 01:03:33,720
後でそれを使用してから、あなたが保存されてきたものにアクセスできなくなります。

953
01:03:33,720 --> 01:03:37,660
私たちは、SQLコマンドで使用する4つの主要なものを持っている。

954
01:03:37,660 --> 01:03:40,190
私たちは、選択、挿入、削除、更新しました。

955
01:03:40,190 --> 01:03:42,880
それらはあなたたちがあなたのクイズのために知っておく本当に重要です。

956
01:03:42,880 --> 01:03:45,990
>>我々はすぐに今の選択の上に行くよ。

957
01:03:45,990 --> 01:03:48,540
基本的には、データベースから行を選択している。

958
01:03:48,540 --> 01:03:52,400
あなたはここ、あるのであれば - 

959
01:03:52,400 --> 01:03:56,740
我々はこれら2つの異なるものを持って、私たちは、クラス表から選択します

960
01:03:56,740 --> 01:04:01,480
ここで素晴らしい - 素晴らしい列の値が1である。

961
01:04:01,480 --> 01:04:04,460
ここで見ることができるように、我々は、クラス名のこれらの2ものを持って

962
01:04:04,460 --> 01:04:08,490
CS50とStat110、私たちは、クラスIDとスローガンを持っています。

963
01:04:08,490 --> 01:04:13,150
だから我々はその情報をすべて選択します。

964
01:04:13,150 --> 01:04:17,480
その後は、それは一種の素晴らしいコラムの拾い出しだと右ここで見ることができます

965
01:04:17,480 --> 01:04:25,170
すべてのものは1であり、それは、クラスID、クラス名で、それを選ぶことができるというスローガンを有する。

966
01:04:25,170 --> 01:04:28,100
あなたは、コードでこれを正確にどのように行うのですか？あなたは、PHPを使用する必要があります。

967
01:04:28,100 --> 01:04:33,830
だから、この種のPHPとSQLが相互に関連している方法です。

968
01:04:33,830 --> 01:04:38,130
今、私たちは私たちのコードを持っており、我々は我々のクエリー機能を使用するつもりだ

969
01:04:38,130 --> 01:04:41,370
我々はPSET 7で行った、と我々は、SQLクエリを実行するつもりのよう。

970
01:04:41,370 --> 01:04:43,870
その後、我々は持っているつもりです - 

971
01:04:43,870 --> 01:04:46,280
我々は常に、falseの場合、行のトリプル等しいかどうかを確認する必要があります。

972
01:04:46,280 --> 01:04:49,010
だからもう一度、あなたは型と値を確認したい、

973
01:04:49,010 --> 01:04:53,880
それが動作しない場合、その後、あなたは私たちがPSET 7で行ったように、いつものように、謝罪したい。

974
01:04:53,880 --> 01:04:55,870
そうしないと、便利なものですべてをループしたい

975
01:04:55,870 --> 01:04:59,410
foreachのは我々だけで渡ったことをループします。

976
01:04:59,410 --> 01:05:01,280
今、私たちは、をループしていると我々は、過去のそれを作ったこと

977
01:05:01,280 --> 01:05:05,080
今、私たちは私たちのforeachループを持って、私たちのクエリが渡されたとする。

978
01:05:05,080 --> 01:05:11,050
そして、最初の行は、それが持っているので、ここでは行はここ、だ、それは箱入りだ。

979
01:05:11,050 --> 01:05:14,010
それが得だと、すべての情報を出力するようになるだろう。

980
01:05:14,010 --> 01:05:18,070
だから、一番下にプリントアウトするために起こっている "ワナHTMLをか？"

981
01:05:18,070 --> 01:05:23,370
それはループの最初に完成だから、それは、次の行に移動するために起こっている

982
01:05:23,370 --> 01:05:26,510
ので、それはそれの2行目を印刷するだろう、

983
01:05:26,510 --> 01:05:32,120
STAT110になるだろうされている、すべての瞬間を検索します。

984
01:05:32,120 --> 01:05:34,290
>>最後に一つには、SQLの脆弱性である。

985
01:05:34,290 --> 01:05:37,300
私はダビデはこの上で、講義中に少し触れて知っている。

986
01:05:37,300 --> 01:05:40,730
後でこれを読むことができます。それは本当に面白いです。

987
01:05:40,730 --> 01:05:45,320
SQLインジェクションは、トリッキーなものの一種である。

988
01:05:45,320 --> 01:05:49,890
例えば、あなたがちょうどあなたのクエリにこれらの変数を貼ることを言わせて、

989
01:05:49,890 --> 01:05:52,290
あなたはその最初の行で見ることができるように。

990
01:05:52,290 --> 01:05:54,520
だから、右、罰金だ？あなただけのユーザー名に入れている

991
01:05:54,520 --> 01:05:58,820
と、SQLクエリにパスワード、そしてあなたがそれを出荷し、データテーブルには何でも手に入れたい。

992
01:05:58,820 --> 01:06:01,450
これはかなり簡単なようです。だから、誰かが中に入れますと言うことができます

993
01:06:01,450 --> 01:06:04,910
パスワードには、右ここでこのまたはテ​​キスト - 

994
01:06:04,910 --> 01:06:06,780
実際に赤いボックスにする必要があります。

995
01:06:06,780 --> 01:06:11,920
それでは、彼らがにそのパスワードを入れるとしましょう​​ - それは彼らが入力した内容だ。

996
01:06:11,920 --> 01:06:16,520
そこで、彼らは= 1 "1"を入れたりしています。

997
01:06:16,520 --> 01:06:20,880
持っている愚かなパスワードのようなもの。

998
01:06:20,880 --> 01:06:25,070
、今度はそれを中に置き換えてみましょう、あなたは今ではSQLクエリであることに注意します

999
01:06:25,070 --> 01:06:29,090
あなたは注意しますので、それは、常にtrueと評価され、その

1000
01:06:29,090 --> 01:06:32,240
あなたはSQLクエリは、この情報のすべてを選択することができます

1001
01:06:32,240 --> 01:06:35,420
それとも、ただ1 = 1を持つことができます。

1002
01:06:35,420 --> 01:06:41,030
だから、常にtrueと評価するだろう。

1003
01:06:41,030 --> 01:06:46,610
それはハッカーがシステムに侵入できることを意味しますので、それは、本当に仕事に行くのではない。

1004
01:06:46,610 --> 01:06:49,300
これを解決するには、PDOシステムを使用しなければならないことです、

1005
01:06:49,300 --> 01:06:51,360
これは、疑問符を使用する必要があることを意味します

1006
01:06:51,360 --> 01:06:53,350
その君たちがPSET 7で使用したものであり、

1007
01:06:53,350 --> 01:06:57,620
あなたが何かを配置する場所の代わりに疑問符を使用するつもりだところ、

1008
01:06:57,620 --> 01:07:01,430
そして、あなたはカンマを持っているつもりだし、あなたが後で必要があります

1009
01:07:01,430 --> 01:07:07,610
あなたの文字列の後に、あなたの疑問符に置き換えたいの異なる変数。

1010
01:07:07,610 --> 01:07:10,330
だから、今私は、これらの赤い疑問符を持っていることをここで注意します。

1011
01:07:10,330 --> 01:07:15,420
私はその後、この順序でそれらを置き換えるために知っているので、私は私の文字列の後に変数を置く。

1012
01:07:15,420 --> 01:07:18,470
つまり、もし誰かがこのようにそれを行うことが確認されます、

1013
01:07:18,470 --> 01:07:24,050
彼らは確認しますか1 = 1の状況を、持っている、

1014
01:07:24,050 --> 01:07:30,490
バックエンドで、それが実際にSQLクエリを壊さないように注意してください。

1015
01:07:30,490 --> 01:07:33,660
さて、それは、PHPとSQLの旋風かなりそれだそう。

1016
01:07:33,660 --> 01:07:41,520
あなたのすべてに最高の幸運、そして今オレゴンへ

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa]オーケーみんな。いくつかのJavaScriptをかけて行く時間

1018
01:07:44,270 --> 01:07:48,840
といくつかの他のものは非常に迅速に私たちは今夜あなたを保持しない。

1019
01:07:48,840 --> 01:07:56,930
JavaScriptを。はい。 JavaScriptはうわさによれば、クールなものの一種である。

1020
01:07:56,930 --> 01:07:59,090
あなたが本当にJavaScriptをについて知っておくべきことは、それは一種のようなものだ

1021
01:07:59,090 --> 01:08:03,810
あなたのWeb​​アプリがやっているように何が起こっているかのクライアント側のエンド。

1022
01:08:03,810 --> 01:08:08,280
あなただけの、サーバー側ですべての時間の世話をしたくないいくつかのものがあります。

1023
01:08:08,280 --> 01:08:12,880
一つのことを強調し、すべてのほとんどの相互作用は、何かが消えて作る。

1024
01:08:12,880 --> 01:08:15,340
あなたは本当にあなたのサーバーにそのためのすべての時間を話してしたく​​ない。

1025
01:08:15,340 --> 01:08:18,069
そして、それのいくつかはサーバ側で行うことも可能ではありません。

1026
01:08:18,069 --> 01:08:21,899
我々はJavaScriptのようなものが必要があるのはこのためです。

1027
01:08:21,899 --> 01:08:24,359
JavaScriptの約クールなものは：これは、動的に型付けされている。

1028
01:08:24,359 --> 01:08:27,149
これが意味することは、プログラムが知る必要はないということです

1029
01:08:27,149 --> 01:08:30,970
あなたはそれを書くときに何を、正確に、変数である。

1030
01:08:30,970 --> 01:08:34,510
それは実行しているように、それだけで一種のそれを把握します。

1031
01:08:34,510 --> 01:08:37,520
それについてクールだ他のこと：それは中括弧言語ですが、

1032
01:08:37,520 --> 01:08:41,359
その構文はC言語とPHPと同様であることを意味します。

1033
01:08:41,359 --> 01:08:47,050
あなたは、JavaScriptを学んでいる時に多くのリワークを行う必要はありません。

1034
01:08:47,050 --> 01:08:49,180
ここでは、JavaScriptを少し持っている。

1035
01:08:49,180 --> 01:08:52,560
右ここ興味深いのは、あなたがそれを見れば、ということで、

1036
01:08:52,560 --> 01:08:56,330
私たちは、headタグにすぐそこのJavaScriptのビットがあります。

1037
01:08:56,330 --> 01:08:59,479
どのようなことは基本的にJavaScriptファイルが含まれていない。

1038
01:08:59,479 --> 01:09:02,260
これは、あなたのプログラムにJavaScriptを含めることができる一つの方法です。

1039
01:09:02,260 --> 01:09:06,910
次に、第2少しは、実際にいくつかのインラインJavaScriptのです

1040
01:09:06,910 --> 01:09:10,790
CSSを使用したインラインスタイルに非常によく似て、

1041
01:09:10,790 --> 01:09:16,180
とするだけで、非常に迅速にそこにいくつかのコードを書いている。

1042
01:09:16,180 --> 01:09:18,120
JavaScriptは配列を持っています。

1043
01:09:18,120 --> 01:09:20,850
非常に便利な、周りのデータを保持するだけで、別の方法です。

1044
01:09:20,850 --> 01:09:25,180
非常に素晴らしく、簡単な構文。

1045
01:09:25,180 --> 01:09:29,870
あなたはすべてにアクセスして、一緒にすべてを保つために、角括弧を使用しています。

1046
01:09:29,870 --> 01:09:35,020
複雑すぎて何もない。

1047
01:09:35,020 --> 01:09:38,630
一般的にJavaScriptとスクリプト言語についてのクールなもの

1048
01:09:38,630 --> 01:09:40,920
あなたは配列サイズを心配する必要はないということです。

1049
01:09:40,920 --> 01:09:43,880
ちょうどArray.lengthとを使用し、それを追跡することができ、

1050
01:09:43,880 --> 01:09:46,960
あなたはそれがする必要があるとしても、配列は、拡大または縮小することができます。

1051
01:09:46,960 --> 01:09:49,279
だから、あなたも、あらゆる種類のを心配する必要はありません

1052
01:09:49,279 --> 01:09:57,050
ああ、いや、私はより多くのもの、またはそのようなものを割り当てる必要があります。

1053
01:09:57,050 --> 01:10:00,090
こちら>>クールなことは、JavaScriptのオブジェクトと呼ばれるものを持っているということです。

1054
01:10:00,090 --> 01:10:04,800
それはオブジェクト指向言語なので、それはしているものを、本質的に、

1055
01:10:04,800 --> 01:10:10,100
構造体に多少似てグループ化データへのあなたのための方法、

1056
01:10:10,100 --> 01:10:17,280
しかし、あなたは、構造体のような、または連想配列構文でアクセスすることができます。

1057
01:10:17,280 --> 01:10:22,520
それは非常に簡単ですし、あなたがこれを行うことができることをグループのデータであり、

1058
01:10:22,520 --> 01:10:24,810
あなたが関連のデータの束を持っている場合。

1059
01:10:24,810 --> 01:10:26,850
それはあなたが車を記述するために必要なすべてのものなので、

1060
01:10:26,850 --> 01:10:29,050
あなたはさまざまな場所の束でそれを持っている必要はありません。

1061
01:10:29,050 --> 01:10:35,300
あなただけのJavaScriptで1オブジェクトにくっつけることができます。

1062
01:10:35,300 --> 01:10:39,090
あなたはおそらく知っているように、反復処理は、これらの面倒な作業の一つです。

1063
01:10:39,090 --> 01:10:43,810
あなただけ何度も何度もかけてそれを行う。あなたが車の中ですべてのオブジェクトに話をする必要がある、

1064
01:10:43,810 --> 01:10:47,340
または、リストまたはそのようなことにすべての項目を通過する必要があります。

1065
01:10:47,340 --> 01:10:51,770
そうJavaScriptは、PHP、foreachの構文に似ています。

1066
01:10:51,770 --> 01:10:54,590
この場合には、ループ内でのためだ。

1067
01:10:54,590 --> 01:10:57,300
あなたはオブジェクトのみでこれを使用したい。

1068
01:10:57,300 --> 01:11:01,030
あなたは、配列でこれを使用する場合に発生するいくつかの問題があります。

1069
01:11:01,030 --> 01:11:03,750
それは一般的に、しかし、それは非常に便利ですが、それらのものの一つです

1070
01:11:03,750 --> 01:11:06,590
あなたは多くのオーバーヘッドをなくすため、

1071
01:11:06,590 --> 01:11:10,270
あなたが自分でオブジェクト内のすべてのものをプルアップする必要がないため。

1072
01:11:10,270 --> 01:11:12,300
あなたはすべてのキー名を覚えておく必要はありません。

1073
01:11:12,300 --> 01:11:18,270
あなただけの並べ替えのこの構文でそれらを取り戻す。

1074
01:11:18,270 --> 01:11:21,500
この中、探して、あなただけ覚えておきたい

1075
01:11:21,500 --> 01:11:27,180
あなたは、テーブルのハッシュに非常に似た方法で、すべてのキーをバック得ていること。

1076
01:11:27,180 --> 01:11:30,880
あなたはそれとは覚えている場合は、文字列に置くとするときには、何かを得ることができる

1077
01:11:30,880 --> 01:11:33,840
それはそれに関連付けられた値を有するであろう。

1078
01:11:33,840 --> 01:11:36,360
あなたはこれを行うことができますことは、あなたは、すべての権利を言うことができている

1079
01:11:36,360 --> 01:11:42,120
私は車に入れ、私はフェラーリと呼ばれる。

1080
01:11:42,120 --> 01:11:45,290
だから、後でもう一度文字列にフェラーリに置くことができ、あなたはそれを出すことができます。

1081
01:11:45,290 --> 01:11:50,000
そして、あなたは、ループ内のために、ループ内でそれを行うことができます。

1082
01:11:50,000 --> 01:11:53,320
だからオブジェクトの詳細。あなたは覚えておく必要がこれから重要なの

1083
01:11:53,320 --> 01:12:00,340
、これらをいつでもあなたは構文のようなオブジェクト構造体を使用することができるということです

1084
01:12:00,340 --> 01:12:04,590
どのようなあなたが文字列として使用するつもりは有効な変数名でない場合を除いて。

1085
01:12:04,590 --> 01:12:07,650
あなたがそのそこを見ればそう、我々は、スペースでキーを持っています。

1086
01:12:07,650 --> 01:12:12,500
さて、あなたはobject.key置くとしたら、スペース、と、スペース、スペース、

1087
01:12:12,500 --> 01:12:15,320
それはちょうど、構文的に意味がありません。

1088
01:12:15,320 --> 01:12:22,730
だから、唯一のブラケット構文のこの種でそれを行うことができます。

1089
01:12:22,730 --> 01:12:26,520
>>また、JavaScriptは非常に適用範囲ごとのPHPにある。

1090
01:12:26,520 --> 01:12:29,050
あなたは、スコープに対処する2つの方法があります。

1091
01:12:29,050 --> 01:12:31,960
あなたは、変数の前にVARを持つことはできません、

1092
01:12:31,960 --> 01:12:34,060
それはまさに、これがグローバルであることを意味します。

1093
01:12:34,060 --> 01:12:37,050
あなたはどこからでも見ることができます。あなたはif文でこれを入れていたとしても、

1094
01:12:37,050 --> 01:12:42,430
どこか他のコード内のそのポイントの後には、その変数を見ることができました。

1095
01:12:42,430 --> 01:12:46,730
もう一つは、しかし、VARであり、それはあなたがインチなら何でもする機能に限定されます

1096
01:12:46,730 --> 01:12:48,870
あなたは関数でない場合は、まあ、それは世界的だ。

1097
01:12:48,870 --> 01:12:53,900
あなたは、関数内にある場合、それは、その関数内でのみ表示されます。

1098
01:12:53,900 --> 01:12:56,420
私はええ、例を持っていますが、ありません。それはどこにそれらのものの一つだ

1099
01:12:56,420 --> 01:12:59,900
あなたがグローバルになりたいものを変数で管理することができ、

1100
01:12:59,900 --> 01:13:03,810
どのような変数をローカルにしたいが、あなたはこのことについて注意する必要があります、

1101
01:13:03,810 --> 01:13:06,890
あなたがC言語で行い微粒子制御のタイプを持っていないため、

1102
01:13:06,890 --> 01:13:15,820
何かが、forループ内で宣言されている場合は、forループという点で滞在する予定のWHERE。

1103
01:13:15,820 --> 01:13:18,790
我々は実際にJavaScriptを使用して気に事は右、Webページを操作している？

1104
01:13:18,790 --> 01:13:21,800
私が意味することは、なぜ我々はこれをやっているのです。

1105
01:13:21,800 --> 01:13:23,840
>>そのためには、我々は、DOMと呼ばれるものを使用しています。

1106
01:13:23,840 --> 01:13:25,850
ドキュメントオブジェクトモデル。

1107
01:13:25,850 --> 01:13:29,430
基本的に、どのようなそれがないと、それは、すべてのHTMLを取ります

1108
01:13:29,430 --> 01:13:34,110
お互いの中にネストされているオブジェクトの束へのモデル、それを。

1109
01:13:34,110 --> 01:13:37,080
あなたはこのようなものから始める。

1110
01:13:37,080 --> 01:13:44,770
あなたは、それは一種のだそこに、私のために右に、コードの束を持っている - 

1111
01:13:44,770 --> 01:13:46,640
あなたはそれを操作するのは非常に難しいですね、と思うだろう、

1112
01:13:46,640 --> 01:13:48,700
テキストの束によって解析することと思いますので、

1113
01:13:48,700 --> 01:13:52,080
物事を離れてつなぎすること。そして、それが正しく何がフォーマットされていない場合はどうなりますか？

1114
01:13:52,080 --> 01:13:54,880
悪いことが起こるでしょう。

1115
01:13:54,880 --> 01:13:58,140
だから、JavaScriptはあなたのためにこれの世話をする、あなたは素敵なデータ構造を取得する

1116
01:13:58,140 --> 01:14:01,390
あなただけの文書を持って私の左の上の1、のような

1117
01:14:01,390 --> 01:14:03,530
その内には、HTMLと呼ばれるものを持っている

1118
01:14:03,530 --> 01:14:05,600
その内には、頭と体を持っている

1119
01:14:05,600 --> 01:14:08,420
その頭の中には、エトセトラ、エトセトラエトセトラをし、タイトルを持っている。

1120
01:14:08,420 --> 01:14:11,810
これは、それだけのように、Webページを操作する簡素化

1121
01:14:11,810 --> 01:14:14,190
ああ、私はちょうどこのオブジェクトに話をしたい。

1122
01:14:14,190 --> 01:14:21,340
あなたはあなた自身を作った別のオブジェクトに話すだろう、非常に同じように並べ替え。

1123
01:14:21,340 --> 01:14:25,980
私が言ったように、すべてのDOMドキュメントオブジェクトである。

1124
01:14:25,980 --> 01:14:29,290
どちらか、それだけで一つの場所だと、あなたは、物事を見つけるために、その中に行くことができます

1125
01:14:29,290 --> 01:14:33,880
あなたはそれを行うことができます - これはそこまで、それを行うための古いスタイルである、

1126
01:14:33,880 --> 01:14:38,130
あなたがのdocument.getElementByIdを行い、どこで、名前、

1127
01:14:38,130 --> 01:14:42,420
そしてあなたはおそらく言うことができるように、これはしばらくすると、非常に扱いにくく取得します。

1128
01:14:42,420 --> 01:14:44,480
だから、おそらくこれを行うにはしたくない。我々が持っている理由です

1129
01:14:44,480 --> 01:14:48,760
我々はこの後、約お話するつもり次の事。

1130
01:14:48,760 --> 01:14:52,510
ここで重要なことは、そのすべての権利、あなたは正しい、これらすべての要素を持っている？

1131
01:14:52,510 --> 01:14:56,400
そのため、おそらく私は、ページのロード時に何かの色を変更することができます。

1132
01:14:56,400 --> 01:14:58,380
だから何？何私のユーザーが何かをクリックした場合？

1133
01:14:58,380 --> 01:15:00,540
私は、彼らが何かをクリックしたときに、それが面白いことをやってみたい。

1134
01:15:00,540 --> 01:15:02,600
我々は、イベントを持っている理由です。

1135
01:15:02,600 --> 01:15:05,330
あなたは、基本的には、あなたのDOM内の任意の要素を見つけることができ、

1136
01:15:05,330 --> 01:15:08,560
して、ちょっと、と言う。これは、ロードしたり、誰かがそれをクリックすると

1137
01:15:08,560 --> 01:15:11,410
または、彼らはマウスその上、それを使って何かをするとき。

1138
01:15:11,410 --> 01:15:15,330
そして何を持っていることはあなたがあなたのためにこれを処理する機能を持っている、である。

1139
01:15:15,330 --> 01:15:17,980
これらの関数は、イベントハンドラである。

1140
01:15:17,980 --> 01:15:20,440
何すばらしいスタイル - それは言うだけの空想の方法です、

1141
01:15:20,440 --> 01:15:23,500
このイベントが発生したときに、この関数は、実行されます。

1142
01:15:23,500 --> 01:15:28,070
だから、発生するイベントを処理します。

1143
01:15:28,070 --> 01:15:30,810
これにより、イベントハンドラを配置する方法です。

1144
01:15:30,810 --> 01:15:34,750
私はいくつかのボタンがあり、あなたがそれをクリックすると、それが爆発する。

1145
01:15:34,750 --> 01:15:40,560
だから、ボタンをクリックしないでください。

1146
01:15:40,560 --> 01:15:42,910
これは右、それに接近する一つの方法です？

1147
01:15:42,910 --> 01:15:46,430
、ボタンタグがあり、クリックであなたが言う文字列が

1148
01:15:46,430 --> 01:15:50,460
ああ、ところで、私は私のために、この爆発のことを行う。

1149
01:15:50,460 --> 01:15:53,990
そうでなければ、それだけで作成したばかりの、通常のボタンのようなものだ。

1150
01:15:53,990 --> 01:15:56,550
また、この別の方法を行うことができますが、

1151
01:15:56,550 --> 01:16:02,770
DOM要素をつかんによってではなく、我々はjQueryの話をした後にあることを節約できます。

1152
01:16:02,770 --> 01:16:07,580
>> jQueryの：それは、クロスブラウザでライブラリです。

1153
01:16:07,580 --> 01:16:09,580
あなたはほとんど何でそれを使用することができます。

1154
01:16:09,580 --> 01:16:12,090
それだけであなたにで動作するようにツールの多くを提供します。

1155
01:16:12,090 --> 01:16:15,850
JavaScriptは、パワフルながら、あなたは必要なすべてのツールを持っていないため、

1156
01:16:15,850 --> 01:16:20,550
本当にあなたがやりたいことがあるWebアプリケーションを取り組むために箱から出し。

1157
01:16:20,550 --> 01:16:24,650
だから、多くのものを簡素化あなたに多くの機能を提供します

1158
01:16:24,650 --> 01:16:28,760
普段何度も何度も、自分で作成しなければならない箱から出して。

1159
01:16:28,760 --> 01:16:31,600
そして、ちょうど物事は非常に簡単になります。

1160
01:16:31,600 --> 01:16:35,780
また、あなたはこれらすべての要素を取り出してみましょうセレクタを持っている

1161
01:16:35,780 --> 01:16:42,800
あなたのDOMからはるかに簡単に、代わりにこれらの非常に長い関数呼び出しを使用する必要がある。

1162
01:16:42,800 --> 01:16:46,630
これらのセレクタの詳細。あなたが持っているそこまで、持っている、のは言わせて

1163
01:16:46,630 --> 01:16:49,800
私は、IDを持つ要素を取得したい "岩"

1164
01:16:49,800 --> 01:16:56,450
さて、jQueryのでは、それだけで$してから、ポンドを持っている文字列をしてからだ」と岩。 "

1165
01:16:56,450 --> 01:17:01,960
それは非常にシンプルで、この問題に取り組むの伝統的なJavaScriptの方法よりもはるかに高速です。

1166
01:17:01,960 --> 01:17:06,120
そして、あなたはクラスや要素タイプのため、同様のものを持っている。

1167
01:17:06,120 --> 01:17:08,140
jQueryのは - クールな機能の1つは、一種の圧縮することができますです

1168
01:17:08,140 --> 01:17:14,350
あなたのDOMにクエリダウン非常に、非常に高速。

1169
01:17:14,350 --> 01:17:18,980
今、私たちは戻ってイベント処理をしているが、これはあなたがjQueryの内の1つのイベントを処理する方法である。

1170
01:17:18,980 --> 01:17:23,090
それでは、私たちがここで起こっているのは、我々はすべての権利、と言っているである。私は、スクリプトタグを持っているよね？

1171
01:17:23,090 --> 01:17:25,400
だから私はこのインラインJavaScriptを持つ。

1172
01:17:25,400 --> 01:17:27,750
私たちがやろうとしていると、我々はすべての権利、と言うつもりです。

1173
01:17:27,750 --> 01:17:30,860
文書には、文書がロードされているのを意味し、準備ができたとき

1174
01:17:30,860 --> 01:17:34,660
、我々はその関数に入るとしている、と我々は、すべての権利を言おうとしている

1175
01:17:34,660 --> 01:17:37,060
この関数は、実際に何かをやっている。

1176
01:17:37,060 --> 01:17:42,320
それは基本的にすべての権利、私にIDを持つ要素を取得、言っている「MYI​​Dを。 "

1177
01:17:42,320 --> 01:17:47,960
そして、このあなたがそれをクリックしたときに実行される関数ハンドラを与える。

1178
01:17:47,960 --> 01:17:49,820
基本的にこれは何をするか、それはすべてが正しい、と言います。

1179
01:17:49,820 --> 01:17:52,630
、ページがロードされているので、私は、この要素を見つけるつもりだ

1180
01:17:52,630 --> 01:17:56,420
それをこのイベントハンドラを与え、それは基本的にあなたのためのページを設定します。

1181
01:17:56,420 --> 01:18:00,520
そして、これはあなたがイベント処理を考えるする方法である。

1182
01:18:00,520 --> 01:18:06,310
あなただけの、考えるようにすべての権利、何かが発生したときに、私が起こることを何をしたいのか？

1183
01:18:06,310 --> 01:18:10,520
あなたは、大丈夫、私はこの事にしてください、この事の話をする必要があり、考えたくはありません

1184
01:18:10,520 --> 01:18:14,660
この事何とか何とか何とか、あなただけのイベントの面でのことをお話したいと思いますので。

1185
01:18:14,660 --> 01:18:17,650
これが発生すると、これが起こります。これが起こるとき、それは起こります。

1186
01:18:17,650 --> 01:18:20,240
物事が他のことをトリガーした場合と、それは素晴らしいことです。

1187
01:18:20,240 --> 01:18:22,150
しかし、あなたは、複雑なコードを試してみて、行うにはしたくない

1188
01:18:22,150 --> 01:18:24,130
あなたは、同時に複数の物事をトリガしている場合には、

1189
01:18:24,130 --> 01:18:28,860
あなただけの自分自身に頭痛を与えるつもりだから。

1190
01:18:28,860 --> 01:18:32,340
>>すべての権利。今、我々は我々のページがイベントを処理するために取得することができ、

1191
01:18:32,340 --> 01:18:35,640
しかし、ここでは私のユーザーがボタンをクリックしましょう​​。

1192
01:18:35,640 --> 01:18:38,040
私は、サーバーにその要求を送信する場合は、

1193
01:18:38,040 --> 01:18:41,100
新しいページをリロードする必要があるため、私は、ページをリロードする必要はありません

1194
01:18:41,100 --> 01:18:44,390
ひとつひとつの時間がちょっと退屈取得し、私は​​なぜ必要なのですか

1195
01:18:44,390 --> 01:18:47,430
もう一度もう一度ヘッダーをプルダウンして、フッターに、

1196
01:18:47,430 --> 01:18:49,670
再度ページのすべての要素

1197
01:18:49,670 --> 01:18:53,180
ただ挨拶や時間を更新する？

1198
01:18:53,180 --> 01:18:55,290
我々はAjaxのようなものを持っている理由ので、それはです。

1199
01:18:55,290 --> 01:18:59,150
私たちはAjaxをここで行うことができることは、我々は、すべての権利を言うことができている

1200
01:18:59,150 --> 01:19:01,290
私は、サーバーにデータを送信したい、

1201
01:19:01,290 --> 01:19:04,010
と私は私のページを更新できるように戻って応答を取得したい、

1202
01:19:04,010 --> 01:19:12,120
または多分ちょうど必ずしもユーザには何も表示されませんいくつかのアルゴリズムの計算を行います。

1203
01:19:12,120 --> 01:19:15,500
あなたがこれを行うには何が必要ですか？さて、あなたはあなたが話をする必要があるURLが必要です。

1204
01:19:15,500 --> 01:19:18,650
このサーバーは、単に魔法のどこから聞くことができない。

1205
01:19:18,650 --> 01:19:21,960
あなたはこのデータを送信している特定の場所を持っている必要があります。

1206
01:19:21,960 --> 01:19:26,240
そして、あなたはまた送信するためにいくつかのデータが必要な場合、または多分それはデータレス·クエリの。

1207
01:19:26,240 --> 01:19:31,380
あなただけのサーバーへのpingを実行したいと言って、ちょっと、私は生きている、またはそのような何か。

1208
01:19:31,380 --> 01:19:35,150
そして、あなたは基本的には成功して処理する関数を求めています。

1209
01:19:35,150 --> 01:19:38,250
例えば、あなたがあなたのサーバーからいくつかの情報を取り戻すとしましょう​​、

1210
01:19:38,250 --> 01:19:42,960
あなたは自分のページ上でのユーザーのタイトルを変更したい。

1211
01:19:42,960 --> 01:19:44,930
だから、戻って情報を得るだろう、

1212
01:19:44,930 --> 01:19:48,860
あなたが画面にそれをプッシュするだろう。

1213
01:19:48,860 --> 01:19:51,170
何が起こるのページは準備ができているとき、ある、

1214
01:19:51,170 --> 01:19:56,500
あなたはグリータと呼ばれるこのボタンのクリック機能に作成します。

1215
01:19:56,500 --> 01:19:58,810
これは次に行うことは、そのボタンが押されたとき、であり、

1216
01:19:58,810 --> 01:20:03,700
あなたはgreetings.phpする話を、あなたは、POSTリクエストをする

1217
01:20:03,700 --> 01:20:07,290
あなたはちょっと、私にあなたのページから何かを得る、と言う。

1218
01:20:07,290 --> 01:20:09,890
私たちは本当に、それを記述する必要がありますが、greetings.phpはありません

1219
01:20:09,890 --> 01:20:12,480
ちょうど、戻って与えましょう」の世界こんにちは。 "

1220
01:20:12,480 --> 01:20:15,650
だから我々は、「Hello World」の、これを取り戻すとこれの成功時

1221
01:20:15,650 --> 01:20:20,730
何がうまくいかないと仮定すると、我々だけで、この目的の場所に行く

1222
01:20:20,730 --> 01:20:25,720
我々は指定された、我々はそこで応答を固執すること。

1223
01:20:25,720 --> 01:20:31,560
そして、これはAjaxのクエリを設定するための非常に簡単な方法である。

1224
01:20:31,560 --> 01:20:34,340
>>非常に迅速に、ロブは一種の、すでにこれを述べた

1225
01:20:34,340 --> 01:20:37,170
物事がうまくいかないことができ、悪いことが起こることができ、

1226
01:20:37,170 --> 01:20:42,660
ですから、これらのHTTP応答コードをお読みください。

1227
01:20:42,660 --> 01:20:46,030
何これらはは単なる、200のように、すべてが大丈夫行っている。

1228
01:20:46,030 --> 01:20:48,670
何か他のもの、悪い事が起こった。

1229
01:20:48,670 --> 01:20:50,790
これは、一般的にあなたが覚えておきたいことだ。

1230
01:20:50,790 --> 01:20:53,440
しかし、それはこれらのすべてを知ってうれしいです。

1231
01:20:53,440 --> 01:20:55,970
そして最後に、かつて我々はすべてのことを経験しましたが、

1232
01:20:55,970 --> 01:20:58,680
我々は、デザインについて非常に迅速に話をする必要があります

1233
01:20:58,680 --> 01:21:00,620
し、私たちはあなたのすべてが去るせることができます。

1234
01:21:00,620 --> 01:21:03,410
デザイン。あなたは覚えておきたいもの。

1235
01:21:03,410 --> 01:21:06,950
これらの質問を自問：誰がこれを使うことになるでしょう？

1236
01:21:06,950 --> 01:21:09,580
彼らは何のためにそれを使用しているのだろうか？私のユーザーは何を気にしますか？

1237
01:21:09,580 --> 01:21:11,750
彼らは何を気にしない？

1238
01:21:11,750 --> 01:21:14,500
あなただけのアプリを作って、それだけで成長させたくない

1239
01:21:14,500 --> 01:21:18,270
そしてこの巨大な、あなたも完了しないことができるすべてのかかるものとなって。

1240
01:21:18,270 --> 01:21:23,900
あなたが対処したい個別の目標と計画し、物事を持っていると思います。

1241
01:21:23,900 --> 01:21:29,000
それは楽にする。このすべてが、基本的に言う

1242
01:21:29,000 --> 01:21:34,950
それは簡単なユーザーがそれを使用できるようにするため、実際には、それはスライドのようなテキストの巨大なBLOBであることを確認していません。

1243
01:21:34,950 --> 01:21:38,020
あなただけに行くために誰かのためにそれは非常に簡単です、何かになりたい

1244
01:21:38,020 --> 01:21:40,800
そして、彼らがやりたいこと。

1245
01:21:40,800 --> 01:21:42,920
あなたは彼らが5ページを移動する必要がありますする必要はありません

1246
01:21:42,920 --> 01:21:45,460
サイトのごプライム機能を取得する。

1247
01:21:45,460 --> 01:21:49,290
あなたも何かを検索することができる前にGoogleは5ページを持っていた場合、

1248
01:21:49,290 --> 01:21:53,080
誰もそれを使用しないであろう。

1249
01:21:53,080 --> 01:21:55,890
そして最後に、紙のプロトタイプ、フォーカスグループ。

1250
01:21:55,890 --> 01:21:59,220
グッドデザインとテスト運用を行っている。

1251
01:21:59,220 --> 01:22:00,730
あなたはそれがあなたのために働くと思うからといって、

1252
01:22:00,730 --> 01:22:04,860
他の誰それが動作すると考えているわけではありません。

1253
01:22:04,860 --> 01:22:14,490
しかし、ええ、それはそれだ。

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]