1
00:00:00,000 --> 00:00:02,270
>> [მიმოხილვა: Quiz 1]

2
00:00:02,270 --> 00:00:04,620
[Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, რობ Bowden] [ჰარვარდის უნივერსიტეტის]

3
00:00:04,620 --> 00:00:07,660
[ეს არის CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] მოგესალმებით ყველას. ეს არის რეცენზია ვიქტორინა 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
Quiz 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
>> მე ვაპირებ დაფარავს მონაცემები სტრუქტურებისა და Huffman კოდირების.

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
განხორციელების hash table თქვენს ვიქტორინა 1.

21
00:01:07,020 --> 00:01:10,250
ჩვენ არ გვინდა თქვენ განახორციელოს მთელი hash table, ალბათ, ჩვენ შევეცდებით

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
და ასევე შეძლებთ განიხილავს მაჩვენებლებისა და structs,

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
In უკავშირდება სიები ძალიან ადვილია უბრალოდ უფრო ელემენტები,

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
თუ გსურთ შესანახად struct, ეს ჯარიმა, ორმაგი, რაც გაგიხარდებათ.

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
>> Okay, ასე რომ, ახლა ვნახოთ, რა უნდა გააკეთოს, თუ მინდა ჩადეთ ელემენტს უკავშირდება სიაში.

52
00:03:05,960 --> 00:03:08,810
პირველი, ფუნქციის ჩანართით იქნება ტიპის ბათილად

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
რა არის პირველი რაც უნდა გავაკეთოთ? ისე, მე უნდა malloc on newnode,

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
okay, თუ მინდოდა წაშლა, მაგალითად, 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
ამიტომ დააყენა დროებითი. ის აპირებს აღვნიშნო, რომ კვანძის რომ მინდა წაშლა.

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
ასე რომ, ეს არის ბევრი, ხოლო ეს ერთი იყო მხოლოდ გამოცხადდა NULL შეცვლა Stack.

88
00:05:17,280 --> 00:05:20,000
ასე რომ, მე არ მაქვს გასათავისუფლებლად იგი.

89
00:05:20,000 --> 00:05:22,030
>> Okay. ახლა მოდით ვისაუბროთ stacks.

90
00:05:22,030 --> 00:05:24,680
Stacks საკმაოდ მარტივია.

91
00:05:24,680 --> 00:05:29,540
ჩვენ გავაკეთეთ stacks და რიგები კლასში მხოლოდ გამოყენებით მასივები,

92
00:05:29,540 --> 00:05:32,820
მაგრამ თქვენ უნდა იყოს ნაცნობი - უბრალოდ უნდა იცოდეს,

93
00:05:32,820 --> 00:05:40,740
რომ თქვენ ასევე შეგიძლიათ გააკეთოთ stacks რიგები გამოყენებით დაკავშირებული სიები ასევე.

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
სიმები, მასივი struct, არაფერი რომ გსურთ შეინახოთ.

100
00:06:00,380 --> 00:06:03,240
მომხმარებლის დასტის: განსხვავება დასტის და უკავშირდება სიაში

101
00:06:03,240 --> 00:06:08,590
ის არის, რომ დასტის თქვენ მხოლოდ ხელი მიუწვდება ბოლო ელემენტს, რომელიც დასვა Stack.

102
00:06:08,590 --> 00:06:11,770
ეს მოუწოდა ბოლო წელს, პირველი გარეთ.

103
00:06:11,770 --> 00:06:15,090
ისევე, როგორც თქვენ გაქვთ Stack of ქაღალდის,

104
00:06:15,090 --> 00:06:17,670
თუ თქვენ დააყენა tray ზედა დასტის,

105
00:06:17,670 --> 00:06:22,670
თქვენ უნდა ამოიღონ, რომ უჯრა პირველი ჰქონდეს სხვა უჯრები.

106
00:06:22,670 --> 00:06:26,310
ეს იგივე stacks.

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
არ არის დიდი ან ტოლია რანგში Stack.

111
00:06:40,150 --> 00:06:45,810
იმის გამო, რომ, თუ თქვენ უკვე ხართ სრული დატვირთვით, თქვენ ვერ შეძლებთ დაამატოთ არაფერი.

112
00:06:45,810 --> 00:06:51,140
და თუ არა, თქვენ უბრალოდ უნდა დაამატოთ ელემენტი Stack.

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
წინააღმდეგ შემთხვევაში, მე ვაპირებ decrement ზომა Spec,

121
00:07:18,960 --> 00:07:22,510
და დაბრუნების ნომრები (s.size).

122
00:07:22,510 --> 00:07:27,230
რატომ decrement ზომა და შემდეგ დაბრუნდნენ s.size?

123
00:07:27,230 --> 00:07:30,930
ეს იმიტომ, რომ, ამ შემთხვევაში, სპეც ზომის 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.numbers (s.size)

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
ერთადერთი განსხვავება ის არის, რომ ნაცვლად, რომელმაც ბოლო წელს, პირველი out,

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
Being ბოლო პირი მოსვლა იქნება პირველი პირი შესვლის კონცერტი.

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
თქვენ ასევე უნდა ჰქონდეს ხელმძღვანელი, რომელიც ინდექსი ხელმძღვანელს Stack.

138
00:08:23,360 --> 00:08:29,000
ამიტომ პირველ ელემენტს ახლა.

139
00:08:29,000 --> 00:08:32,710
Enqueue არის იგივე როგორც დააყენებს, stacks.

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
თუ ეს არის, მე დაბრუნების ცრუ, წინააღმდეგ შემთხვევაში, მე შემიძლია მხოლოდ საექსპორტო ახალი ღირებულება

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
ვცდილობ enqueue bunch პერსონალის,

148
00:08:57,020 --> 00:08:58,390
და შემდეგ მე ვაპირებ dequeue და enqueue.

149
00:08:58,390 --> 00:09:00,550
არსებობს ბევრი ბრძანებები, მაგრამ ეს ძალიან მარტივია.

150
00:09:00,550 --> 00:09:04,790
მე ვაპირებ enqueue 5, ისე დაამატოთ 5, შემდეგ კი 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, და მერე მინდა dequeue რაღაც,

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
პირველი ელემენტს. Okay.

155
00:09:17,320 --> 00:09:21,450
ახლა, თუ ვცდილობ enqueue რაღაც, რა მოხდება?

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
თუ ვცდილობ enqueue 1 სწორედ აქ, მე overwriting ბოლო თანამდებობა

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
თუ არა, მე უბრალოდ, ვამბობთ, oh, ახალი სრული დატვირთვით

166
00:09:58,560 --> 00:10:02,010
რეალურად სიმძლავრე - 1, და ვერ დააყენა ელემენტს არსებობს.

167
00:10:02,010 --> 00:10:06,150
მაგრამ რა არის პრობლემა? პრობლემა ისაა, რომ თუ უბრალოდ dequeue ყველაფერი აქ

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
რომ თქვენ ბიჭები შეიტყო ქმედითი და სხვა psets იყენებდა 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
სახლში, ცდილობენ ძალიან იცნობს განხორციელების enqueue, dequeue, ბიძგი და საესტრადო.

183
00:11:11,620 --> 00:11:16,560
და ასევე კარგად გვესმის, როდესაც თქვენ გამოიყენოთ თითოეული მათგანი.

184
00:11:16,560 --> 00:11:22,830
>> მოდით მოდუნების 10 წამში ერთად bunch of Pokemons.

185
00:11:22,830 --> 00:11:26,080
და ახლა მოდით დავუბრუნდეთ მონაცემები სტრუქტურებში.

186
00:11:26,080 --> 00:11:29,770
Hash მაგიდები. ბევრი ადამიანი იყვნენ ეშინია hash მაგიდები.

187
00:11:29,770 --> 00:11:33,650
in პრობლემა კომპლექტი 6, Spell Checker.

188
00:11:33,650 --> 00:11:35,980
Hash მაგიდები და ცდილობს, ბევრი ხალხი შეშინებულია მათგანი.

189
00:11:35,980 --> 00:11:38,540
მათ მიაჩნიათ, რომ ისინი იმდენად რთული გასაგებია. ჰო?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] პრობლემა კომპლექტი 5. >> პრობლემა მითითებული 5, yeah. Thanks Rob.

191
00:11:41,490 --> 00:11:43,370
ჰო. ექვსი იყო Huff n 'Puff, yeah.

192
00:11:43,370 --> 00:11:49,340
პრობლემა მითითებული 5 იყო მართლწერის შემოწმება, და თქვენ უნდა გამოიყენოთ hash მაგიდასთან ან ცდილობენ.

193
00:11:49,340 --> 00:11:55,360
ბევრი ადამიანი ფიქრობდა, რომ ისინი super ძნელი გასაგებია, მაგრამ ისინი რეალურად საკმაოდ მარტივია.

194
00:11:55,360 --> 00:12:01,290
რა არის hash table, ძირითადად? Hash table არის მასივი უკავშირდება სიები.

195
00:12:01,290 --> 00:12:06,730
ერთადერთი განსხვავება array და hash მაგიდა

196
00:12:06,730 --> 00:12:09,730
ის არის, რომ hash table თქვენ გაქვთ რაიმე მოუწოდა ქეშირების ფუნქცია.

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
ეს არის მაგალითი იმისა, hash მაგიდასთან.

200
00:12:16,090 --> 00:12:19,220
ასე რომ, თქვენ ხედავთ, რომ თქვენ გაქვთ მასივი 31 ელემენტები.

201
00:12:19,220 --> 00:12:22,440
და რას ვაკეთებთ hash მაგიდა აქვს ქეშირების ფუნქცია

202
00:12:22,440 --> 00:12:26,660
რომ აპირებს თარგმნოს გასაღები, თითოეული int to ინდექსი.

203
00:12:26,660 --> 00:12:31,740
იმ შემთხვევაში, თუ, მაგალითად, თუ მინდა აირჩიოს B. ჰარისონი,

204
00:12:31,740 --> 00:12:34,190
მინდა დააყენა B. Harrison ჩემი hash ფუნქციები,

205
00:12:34,190 --> 00:12:36,960
და hash ფუნქცია დაბრუნდნენ 24.

206
00:12:36,960 --> 00:12:40,930
ასე რომ, მე ვიცი, რომ მინდა შესანახად B. Harrison 24.

207
00:12:40,930 --> 00:12:46,580
ასე რომ სხვაობაა მხოლოდ მქონე მასივი და მქონე hash მაგიდასთან.

208
00:12:46,580 --> 00:12:48,740
In hash მაგიდასთან თქვენ ფუნქცია რომ აპირებს გითხრათ,

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
რომ არის deterministic და კარგად ნაწილდება.

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
და ადვილი, რათა შეამოწმოთ, თუ ის მართებული hash table, ნახოთ როგორც hash მაგიდები.

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
ვაპირებთ, რომ იყოს მეტი ელემენტია root.

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 პირველი და მე ვაპირებ, რომ ნახოთ, 7 მეტი ან ნაკლები 5?

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; თქვენ შეიძლება ასევე აქვს string

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
მარცხენა ვაპირებთ აქვს ქვედა lengths, ამიტომ ნამდვილად თქვენზეა.

247
00:15:40,940 --> 00:15:44,930
>> როგორ შემიძლია განახორციელოს მოვძებნოთ BST?

248
00:15:44,930 --> 00:15:47,840
პირველი, რაც ჩვენ უნდა გავაკეთოთ არის შეამოწმოს თუ root არის 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
ასე რომ, მე დაბრუნების ცრუ.

252
00:15:55,790 --> 00:15:58,740
წინააღმდეგ შემთხვევაში, მე ვაპირებ შეამოწმოს თუ ნომერი მეტი

253
00:15:58,740 --> 00:16:01,720
მეტი ღირებულების root.

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
ასე რომ, მე უბრალოდ დააბრუნოს ჭეშმარიტი.

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
ასე რომ, უნდა გამოვიყენო სხვაგან, თუ სხვაგან, თუ სხვაგან აქ?

267
00:16:44,240 --> 00:16:46,200
ვინმეს - Yeah?

268
00:16:46,200 --> 00:16:51,140
[სტუდენტური მოლაპარაკე, inaudible]

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
ლელო არის ხე მასივები.

278
00:17:15,980 --> 00:17:20,369
ეს ძალიან სწრაფად გამოიყურებოდეს up ღირებულებები, მაგრამ იგი იყენებს მეხსიერების დიდ ნაწილს.

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
როგორ განვსაზღვროთ node in ლელო?

285
00:17:39,820 --> 00:17:43,910
თქვენ უბრალოდ უნდა ჰქონდეს bool, რომ აპირებს is_word.

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
რადგან ჩვენ გვაქვს ყველა წერილი plus აპოსტროფი.

293
00:18:12,150 --> 00:18:17,800
ადრე აქ მე უბრალოდ აპირებს გამოიყენოს 2 რადგან მინდა შეძლონ წერა ფორუმში.

294
00:18:17,800 --> 00:18:20,230
Okay. ასე რომ, ეს არის მაგალითი იმისა, ცდილობენ.

295
00:18:20,230 --> 00:18:25,600
თუ უბრალოდ განსაზღვროს პირველი კვანძი, მე გვექნება მასივი 2 ელემენტები

296
00:18:25,600 --> 00:18:29,290
რომლებიც 2 მითითებას NULL, ამიტომ მე უბრალოდ დააყენა "ა" და "ბ".

297
00:18:29,290 --> 00:18:32,430
და მე ვაპირებ აქვს bool რომ ამბობს is_word.

298
00:18:32,430 --> 00:18:34,420
ეს იქნება ყალბი პირველი,

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
მე უბრალოდ უნდა malloc ახალი კვანძის for "ა",

303
00:18:49,760 --> 00:18:54,630
და შემდეგ დაამატოთ თავისი სიტყვა ჭეშმარიტი.

304
00:18:54,630 --> 00:19:00,180
ასე რომ, ეს უბრალოდ წარმოადგენს, რომ მას "ა" იქნება ჭეშმარიტი. აზრი?

305
00:19:00,180 --> 00:19:04,120
თუ მინდა დაამატოთ 'ba', მე უნდა malloc 1 "ბ",

306
00:19:04,120 --> 00:19:07,550
და შემდეგ მე ვაპირებ შეიქმნა ლოგიკური ცრუ,

307
00:19:07,550 --> 00:19:10,160
იმის გამო, რომ "ბ" თავისთავად არ არის სიტყვა.

308
00:19:10,160 --> 00:19:13,010
მაშინ მე ვაპირებ malloc კიდევ ერთი "ა", ისე "ba ',

309
00:19:13,010 --> 00:19:16,290
და შემდეგ მე ვაპირებ შეიქმნა ეს სიტყვა ჭეშმარიტი.

310
00:19:16,290 --> 00:19:18,950
რადგან "ა" არის სიტყვა.

311
00:19:18,950 --> 00:19:21,910
და მაშინ თუ მინდა, რომ თუ "ბ" არის ამ ლექსიკონი,

312
00:19:21,910 --> 00:19:26,730
შემიძლია უბრალოდ წასვლა პირველი, "ბ". მე ქვევით, და მე შევხედოთ არის სიტყვა, და ეს ამბობს, სიცრუეა.

313
00:19:26,730 --> 00:19:30,110
ასე რომ, ეს არ არის სიტყვა. იმ შემთხვევაში, თუ მინდა შევამოწმო 'ba',

314
00:19:30,110 --> 00:19:38,010
მე წასვლა პირველი, "ბ", შემდეგ კი "ა", და მე ვხედავ ასეა, ასე, რომ ეს არის სიტყვა. აზრი?

315
00:19:38,010 --> 00:19:41,950
ბევრი ადამიანი დაბნეული ლელო. არა?

316
00:19:41,950 --> 00:19:44,740
>> საბოლოოდ, Huffman კოდირების. Huffman კოდირების არის ძალიან სასარგებლო,

317
00:19:44,740 --> 00:19:47,550
გადარჩენა მეხსიერება და შეკუმშოს ტექსტური ფაილი,

318
00:19:47,550 --> 00:19:52,270
მხოლოდ იმიტომ, რომ ბევრი ჯერ თქვენ გამოიყენოს "ა" და "ე", მაგალითად,

319
00:19:52,270 --> 00:19:57,710
თქვენი დოკუმენტები, მაგრამ არ ვიცი თუ ბიჭები გამოიყენოთ 'Q' ან 'z' იმდენი.

320
00:19:57,710 --> 00:20:02,040
რომელსაც მხოლოდ 1 byte თითოეული ხასიათი,

321
00:20:02,040 --> 00:20:08,520
თითოეული - 256 სიმბოლო, რომ გვაქვს ASCII მაგიდასთან არ არის ძალიან ოპტიმალური,

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
როგორ უნდა გამოვიყენო Huffman კოდირების?

325
00:20:17,560 --> 00:20:20,010
ჩვენ უნდა გავაკეთოთ Huffman ხე.

326
00:20:20,010 --> 00:20:23,370
 Huffman ხე აქვს კვანძების

327
00:20:23,370 --> 00:20:27,760
რომ აქვს სიმბოლო, რომ აპირებს იყოს, "ა", "ბ", "გ", წერილი,

328
00:20:27,760 --> 00:20:32,990
რასაც წერილი გაქვთ, სიხშირე, რომ არის სიხშირე, რომ სიტყვა ჩნდება ტექსტი

329
00:20:32,990 --> 00:20:36,280
რომ თქვენ შექმნაში Huffman ხე,

330
00:20:36,280 --> 00:20:41,800
და შემდეგ კვანძის რომ აპირებს აღვნიშნო, რომ მარცხნივ Huffman ხე

331
00:20:41,800 --> 00:20:47,210
და კიდევ ერთი კვანძის რომ აპირებს აღვნიშნო უფლება. ასე რომ, ისევე, როგორც ხე.

332
00:20:47,210 --> 00:20:49,440
როგორ უნდა ავაშენოთ Huffman ხე?

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
მოდით ვნახოთ, თუ როგორ გავაკეთოთ Huffman ხე Zamyla.

342
00:21:23,840 --> 00:21:29,220
თქვენ ხედავთ, რომ ყველა წერილი აქვს სიხშირე 1 გარდა 'A', რომელსაც აქვს სიხშირე 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
ასე რომ რაც პირობა არის პირობა, რომ აქვს ყველაზე დაბალი 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
და ეს არის Huffman ხე.

352
00:22:12,430 --> 00:22:16,060
თუ მინდა დაწერა რაიმე ტექსტი,

353
00:22:16,060 --> 00:22:24,440
როგორც ორობითი კონვერრტაციისთვის ტექსტი გამოყენებით Huffman ხე ძალიან მარტივია.

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", ასე Lazy.

362
00:22:56,780 --> 00:23:06,060
ასე რომ ყველა ჩემთვის, რობ აპირებს მეტი.

363
00:23:06,060 --> 00:23:08,400
>> [Rob Bowden] ასე რომ, week 7 პერსონალი.

364
00:23:08,400 --> 00:23:11,390
ჩვენ მივიღეთ ბევრი წასვლა მართლაც სწრაფი.

365
00:23:11,390 --> 00:23:13,430
Bitwise ოპერატორები, ბუფერული overflow,

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
Bitwise ოპერატორები. არსებობს 6 მათგანი, რომ თქვენ უნდა იცოდეთ.

369
00:23:24,330 --> 00:23:31,200
Bitwise და bitwise ან, XOR, მარცხენა ცვლა, მარჯვენა ცვლა, და არა.

370
00:23:31,200 --> 00:23:35,420
მარჯვენა Shift და არა თქვენ ძლივს ვნახე ლექცია ყველა.

371
00:23:35,420 --> 00:23:40,480
ჩვენ წავიდეთ მეტი იგი სწრაფად, მაგრამ კარგია, რომ ვიცით, რომ ეს არის 6 რომ არსებობს.

372
00:23:40,480 --> 00:23:45,070
გახსოვდეთ, რომ bitwise ოპერატორები არიან როგორც, როდესაც თქვენ 3 + 4.

373
00:23:45,070 --> 00:23:49,420
თქვენ არ საქმე ორობითი 3 და 4.

374
00:23:49,420 --> 00:23:56,550
With bitwise ოპერატორების თქვენ რეალურად საქმე ინდივიდუალურ ბიტი ნომრები 3 და 4.

375
00:23:56,550 --> 00:23:59,120
>> ასე რომ, პირველი, რომ ჩვენ ვთქვათ, არის bitwise არ,

376
00:23:59,120 --> 00:24:02,340
და ყველა ის არ არის Flip ყველა ბიტი.

377
00:24:02,340 --> 00:24:05,500
ასე რომ აქ, თუ თქვენ წერა ამ დო, თქვენ არ დაწერა

378
00:24:05,500 --> 00:24:09,380
როგორც ~ 11011 ან რასაც, თქვენ ამას წერენ მას მოსწონს ~ 4,

379
00:24:09,380 --> 00:24:12,970
და მაშინ flip ორობითი წარმომადგენლობა 4.

380
00:24:12,970 --> 00:24:24,800
ასე რომ აქ, ~ ზოგიერთი ბინარული ნომერი 1101101 აპირებს ზუსტად Flip ყველა 1 ს 0 და ყველა 0 ს 1 ს.

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
სადაც მხოლოდ, რომ ერთი bit არის მითითებული,

386
00:24:40,630 --> 00:24:44,650
და შემდეგ მიიღოს ~, ასე რომ ყველა სხვა bit არის მითითებული გარდა, რომ ერთი.

387
00:24:44,650 --> 00:24:50,300
ასე რომ, ის, რასაც ჩვენ ვაპირებთ გამოვიყენოთ უფრო ცოტა.

388
00:24:50,300 --> 00:24:58,220
>> Bitwise ან. აქ არის 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
აქ, როცა მე or'd თითოეული bit, ჩვენ უბრალოდ აპირებს შედარების სწორი ქვემოთ.

392
00:25:13,540 --> 00:25:15,410
ასე რომ მარცხენა მხარეს გვაქვს 1 და 1.

393
00:25:15,410 --> 00:25:20,510
როდესაც მე bitwise | მათ, რა ვარ მე აპირებს მიიღოს? ერთი.

394
00:25:20,510 --> 00:25:25,320
მაშინ bitwise | 0 და 1 აპირებს მომეცი? ერთი.

395
00:25:25,320 --> 00:25:27,840
Bitwise 1 და 0 იქნება იგივე, ერთი.

396
00:25:27,840 --> 00:25:31,880
Bitwise 0 | 0 აპირებს მომეცი 0.

397
00:25:31,880 --> 00:25:37,300
ასე რომ ერთადერთი შემთხვევა, როდესაც მივიღებ 0 არის 0 | 0 შემთხვევაში.

398
00:25:37,300 --> 00:25:40,020
და შეგიძლიათ წარმოიდგინოთ, რომ, ისევე, როგორც თქვენი ლოგიკური ORS.

399
00:25:40,020 --> 00:25:44,830
ასე რომ, თუ ფიქრობთ 1 როგორც ჭეშმარიტი და 0 როგორც ყალბი, იგივე ეხება აქ.

400
00:25:44,830 --> 00:25:50,040
ამიტომ ჭეშმარიტი ან ნამდვილი მართალია, ჭეშმარიტი ან მცდარი მართალია.

401
00:25:50,040 --> 00:25:57,150
ყალბი ან ნამდვილი მართალია, ყალბი ან მცდარი არის ერთადერთი, რაც რეალურად ყალბი.

402
00:25:57,150 --> 00:26:00,100
აი, მაგალითად, რომ თქვენ უნდა იცოდეს,

403
00:26:00,100 --> 00:26:05,160
როგორც საკმაოდ კარგი მაგალითია, როდესაც bitwise ოპერატორები გამოიყენება.

404
00:26:05,160 --> 00:26:08,660
აქ თუ ჩვენ ან კაპიტალის "ერთად Ox20,

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
მოდით დახევის up ASCII მაგიდასთან.

408
00:26:26,750 --> 00:26:34,000
Okay. აქ ჩვენ ვხედავთ, რომ 'A' არის -

409
00:26:34,000 --> 00:26:36,920
აქ ჩვენ გვაქვს 'A' არის ათობითი 65.

410
00:26:36,920 --> 00:26:45,120
მაგრამ მე წასვლა თექვსმეტობითი, რომელიც Ox41.

411
00:26:45,120 --> 00:26:48,280
დარწმუნებული ვარ, ჩვენ ვნახეთ, რომ კლასი. ვფიქრობ, ჩვენ ვნახეთ, რომ კლასი

412
00:26:48,280 --> 00:26:52,730
რომ ეს საკმაოდ ადვილი დააკონვერტიროთ საწყისი თექვსმეტობითი ორობითი.

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
მერე შეგიძლიათ გაყოფილი 1 შევიდა ორობითი, რომელიც იქნება 0001.

417
00:27:08,550 --> 00:27:14,280
და ეს იქნება წარმომადგენლობა 'A' ორობითი.

418
00:27:14,280 --> 00:27:22,720
Taking ამას "ა", ის ახლა იქნება Ox61,

419
00:27:22,720 --> 00:27:27,050
სადაც, გაყოფა ამ up შევიდა მისი ორობითი, ასე რომ 6 -

420
00:27:27,050 --> 00:27:37,830
მოდით რეალურად გაკეთება - იქ არ საშლელი? Eraser.

421
00:27:37,830 --> 00:27:48,220
Ox61. ასე გაყოფა 6 შევიდა ორობითი იქნება 0 + 4 + 2 + 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' ეს ერთჯერადი bit.

425
00:28:04,250 --> 00:28:11,810
ასე ბრუნდება აქ - okay.

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, მხოლოდ ცოტა რომ არის ეს bit, რომ ჩვენ დაინტერესებული,

430
00:28:33,470 --> 00:28:38,210
გადართვის შორის კაპიტალი და ამას 'a'.

431
00:28:38,210 --> 00:28:47,610
თუ მე ან 'A', რომელიც ამ ერთი, 'A',

432
00:28:47,610 --> 00:28:50,580
თუ მე ან "ერთად Ox20,

433
00:28:50,580 --> 00:28:53,490
რა ვარ მე აპირებს მიიღოს?

434
00:28:53,490 --> 00:28:58,960
[სტუდენტი inaudible] >> მხედრულ "ა", იმიტომ, რომ ის აპირებს Flip ამ მწირი 1.

435
00:28:58,960 --> 00:29:04,170
და თუ მე ან "ერთად Ox20, რა ვარ მე აპირებს მიიღოს?

436
00:29:04,170 --> 00:29:08,780
ამას, იმიტომ, რომ მხოლოდ Oring "ა" ერთად Ox20,

437
00:29:08,780 --> 00:29:14,580
მე უბრალოდ უნდა Oring ამ ერთი მწირი 1, ეს უკვე 1, ასე რომ მნიშვნელობა არ აქვს.

438
00:29:14,580 --> 00:29:17,960
ამიტომ ჩვენ კიდევ "ა" და "ა".

439
00:29:17,960 --> 00:29:24,820
>> Bitwise და. ისევ და ისევ, ჩვენ შეგვიძლია ვიფიქროთ, რომ ეს ჩვენი ლოგიკური და კოლეგას.

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
ცრუ და ჭეშმარიტი ან ნამდვილი და ყალბი, ან ცრუ და ყალბი,

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
ახლა, აქ, აქ, სადაც მე გამოიყენება სანდო bitwise არ,

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
ახლა რა მინდა, bitwise ~ საქართველოს Ox20.

449
00:29:59,570 --> 00:30:03,600
რომ აპირებს Flip ყველა ბიტი.

450
00:30:03,600 --> 00:30:09,330
ასე რომ, მე მაქვს 1101, 1111.

451
00:30:09,330 --> 00:30:18,940
და ასე 'A' anded დავუკავშირდეთ ~ Ox20 აპირებს მომეცი რა?

452
00:30:18,940 --> 00:30:22,430
მხოლოდ ცოტა ჩვენ ნამდვილად უნდა ვიფიქროთ, ეს ერთი,

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
რადგან ყველაფერი ეს არის, anded ამ იქნება 0.

458
00:30:39,810 --> 00:30:43,280
რა არის 'A' და ~ Ox20 აპირებს მომეცი?

459
00:30:43,280 --> 00:30:48,200
[სტუდენტები პასუხი, inaudible] >> რა არის "ა" და - ის 'A'.

460
00:30:48,200 --> 00:30:52,170
და რა არის "ა" და ~ Ox20 აპირებს მომეცი?

461
00:30:52,170 --> 00:30:56,720
'ა' იმიტომ, რომ ეს არის გაკეთებული 1.

462
00:30:56,720 --> 00:30:59,570
Anding ამ 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
ჩვენ XOR. ეს ძალიან ჰგავს, ან,

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
როგორც bitwise & და ან არ,

472
00:31:37,150 --> 00:31:40,100
მაგრამ ჭეშმარიტი ^ ჭეშმარიტი არის ყალბი.

473
00:31:40,100 --> 00:31:44,810
იმის გამო, რომ ჩვენ მხოლოდ გვინდა TRUE თუ მხოლოდ ერთი მათგანი არის ჭეშმარიტი.

474
00:31:44,810 --> 00:31:50,950
ამგვარად 1 ^ 1 არის 0. რაც შეეხება 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
არის 1. 1 ^ 0 არის 1, 0 ^ 0 არის 0.

476
00:31:56,010 --> 00:32:03,890
ასე ქვეშ ყველა გარემოება, 0 bitwise რაღაც 0 იქნება 0.

477
00:32:03,890 --> 00:32:10,270
1 bitwise რაღაც 0 ან 0 bitwise 1,

478
00:32:10,270 --> 00:32:14,660
თუ ის | ან ^, ეს იქნება 1, და თუ ის და ეს იქნება 0.

479
00:32:14,660 --> 00:32:20,850
და ერთადერთი შემთხვევა სადაც 1 bitwise 1 არ არის 1 არის ექსკლუზიური ან.

480
00:32:20,850 --> 00:32:24,580
ეს არის ის, 0110.

481
00:32:24,580 --> 00:32:36,520
ასე რომ, აქ არის, გამოყენებით XOR - ასე ჩვენ უკან 20.

482
00:32:36,520 --> 00:32:43,480
'A' ^ Ox20 არის ამ 2 ბიტი ჩვენ შედარებით.

483
00:32:43,480 --> 00:32:50,020
ასე რომ 1 ^ 0 აპირებს მომეცი რა? ერთი.

484
00:32:50,020 --> 00:32:58,430
'A' ^ Ox20 აპირებს მომეცი? მხედრულ.

485
00:32:58,430 --> 00:33:04,010
'A' ^ Ox20 აპირებს მომეცი? კაპიტალური ა

486
00:33:04,010 --> 00:33:09,310
იმის გამო, რასაც ეს აკეთებს, ამ XORing ერთად Ox20

487
00:33:09,310 --> 00:33:15,380
ეფექტურად flipping რასაც ამ ცოტა არის.

488
00:33:15,380 --> 00:33:21,240
იმ შემთხვევაში, თუ ეს არის 0, ის ახლა აპირებს გახდეს 1.

489
00:33:21,240 --> 00:33:26,160
რადგან ეს არის 1, 1 ^ 1 არის 0.

490
00:33:26,160 --> 00:33:33,280
ასე რომ, ჩვენი 'a' გახდა 'A', და ჩვენი 'A' გახდა 'a'.

491
00:33:33,280 --> 00:33:36,910
ასე XOR არის მართლაც მოსახერხებელი გზა უბრალოდ flipping შემთხვევაში.

492
00:33:36,910 --> 00:33:39,960
გსურთ iterate მეტი სიმებიანი წერილები

493
00:33:39,960 --> 00:33:44,330
და ალტერნატიული შემთხვევაში თითოეული ხასიათი,

494
00:33:44,330 --> 00:33:50,680
უბრალოდ XOR ყველაფერი Ox20.

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
In nonbinary თვალსაზრისით,

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
13 * 2 ^ 3, 2 ^ 3 არის 8, ასე 13 * 8 104.

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
ასე ავლით in 0 ს, მარჯვენა ფლანგიდან

507
00:34:51,330 --> 00:34:55,080
ჩვენ უბრალოდ უბიძგებს რამ, რომ იყო 4 ის ადგილი, რათა 8 ის ადგილი,

508
00:34:55,080 --> 00:34:57,920
და რაც იყო 8 ის ადგილი 16 ადგილი.

509
00:34:57,920 --> 00:35:01,280
თითოეული ცვლა მხოლოდ multiplies მიერ 2. ჰო?

510
00:35:01,280 --> 00:35:05,210
[სტუდენტი] რა მოხდება თუ გადავიდა მიერ 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] თუ გადავიდა მიერ 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
ჩვენ უბრალოდ დაკარგავს, რომ ერთი.

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
>> მარჯვენა Shift იქნება, პირიქით,

519
00:35:39,830 --> 00:35:43,090
სადაც ჩვენ ვაპირებთ shove 0 ს off ბოლოს,

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
და ჩვენ ვხედავთ, რომ სამი 0 ს მარჯვენა ახლახანს დაეცა off,

523
00:35:57,780 --> 00:36:02,020
და ჩვენ მივიღებთ 1101 ყველა გზა უფლება.

524
00:36:02,020 --> 00:36:08,380
ამ აკეთებს 104 >> 3, რომელიც, პრაქტიკულად, x / 2 ^ y.

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
ასე რომ, ახლა - ეს ის bitwise. ეს ყველაფერი თქვენ უნდა იცოდეთ.

533
00:36:43,870 --> 00:36:46,340
დამახსოვრება გამოყენების შემთხვევაში ჩვენ ვნახეთ კლასში,

534
00:36:46,340 --> 00:36:49,340
მოსწონს bit ნიღაბი არის სასარგებლო bitwise ოპერატორები,

535
00:36:49,340 --> 00:36:53,220
ან თქვენ მათი გამოყენება bit ნიღბები.

536
00:36:53,220 --> 00:36:58,620
ასოებით და ამას წერილები, კონვერტაციის არის საკმაოდ prototypical მაგალითი.

537
00:36:58,620 --> 00:37:01,640
>> Okay, ასე რომ ბუფერული overflow თავდასხმები.

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
და მაშინ ჩვენ კოპირება ჩვენს ბუფერული of 12 chars მთელი სიმებიანი ბარი.

541
00:37:18,510 --> 00:37:25,080
რა პრობლემა აქ?

542
00:37:25,080 --> 00:37:32,270
ჯადოსნური ნომერი 12 უნდა საკმაოდ ბევრი დაუყოვნებლივ პოპ out როგორც - რატომ 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
ეს იქნება მხოლოდ მთლიანად - "გ", "დ" არ აღელვებს, რომ ეს იყო მხოლოდ 12 სიმბოლო;

547
00:37:50,330 --> 00:37:53,280
'C' არ აღელვებს, რომ მას არ შეუძლია მოერგოს რომ ბევრი bytes.

548
00:37:53,280 --> 00:37:58,250
ის უბრალოდ სრულიად გადავაწერო char, 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
და იზრდება ქვემოთ მინდა 4 მილიარდი ბოლოში.

556
00:38:26,270 --> 00:38:28,820
ჩვენ გვაქვს ჩვენი array 'c' სადღაც მეხსიერებაში,

557
00:38:28,820 --> 00:38:32,260
მაშინ ჩვენ გვაქვს ჩვენი მომცეთ ბარიერი უფლება ქვევმოთ იგი,

558
00:38:32,260 --> 00:38:38,720
და მაშინ ჩვენ ამ შენახული კარკასი მაჩვენებელი ჩვენი დაბრუნების მისამართი და ჩვენი მშობელი რუტინული მიერ Stack.

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
იმ მიზეზით, რომ მნიშვნელოვანია ბუფერული overflow თავდასხმები იმიტომ, მოხერხებულად,

565
00:39:05,830 --> 00:39:09,580
ჰაკერები მინდა რომ შეიცვალოს, რომ დაბრუნების მისამართზე.

566
00:39:09,580 --> 00:39:14,950
იმის ნაცვლად, რომ ბრუნდება foo, მე ვაპირებ დაბრუნდეს იქ, სადაც hacker სურს ჩემგან დაბრუნდეს.

567
00:39:14,950 --> 00:39:17,760
და მოხერხებულად, სადაც hacker ხშირად უნდა დაბრუნდეს

568
00:39:17,760 --> 00:39:22,400
არის დაწყების ბუფერული რომ ჩვენ თავდაპირველად ჰქონდა.

569
00:39:22,400 --> 00:39:26,170
ასე რომ შეამჩნია, კიდევ ერთხელ, პატარა Indian.

570
00:39:26,170 --> 00:39:28,490
ელექტრო არის მაგალითი პატარა ინდური სისტემით,

571
00:39:28,490 --> 00:39:34,140
ასე მთელი რიცხვი ან კურსორი ინახება ერთად bytes საპირისპიროა.

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
დამახსოვრება თექვსმეტობითი ციფრები?

575
00:39:48,250 --> 00:39:50,640
ჩვენ არ შეცვალოს თექვსმეტობითი ციფრები პატარა ინდური,

576
00:39:50,640 --> 00:39:56,110
რადგან 2 თექვსმეტობითი ციფრები შეადგინოს ერთი ბაიტი, და ჩვენ დავამარცხებთ bytes.

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
ასე რომ მათ შეეძლოთ - ვერ ვფიქრობ ნებისმიერი cool კოდი.

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
ისინი როგორც წესი, მას hack თქვენს სისტემაში.

590
00:40:54,950 --> 00:40:59,930
>> Okay. 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
აარიდოს მეხსიერება, მოსწონს თუ ჩვენ გამოყოფილი ძალიან ბევრი მეხსიერების ის დავბრუნდებით და shrink bit.

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
ასე რომ, თუ სიმებიანი, რომ ცდილობს ჩადეთ ბუფერული არის ძალიან დიდი, მაშინ overflow.

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 mallocs რაღაც, ასე რომ როცა მოვუწოდებთ 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
hey, ჩვენ არ ვიყავით რეალურად შეუძლია მიიღოს რიცხვი.

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
HyperText Markup Language სტრუქტურა და სემანტიკა ვებგვერდი.

640
00:44:15,340 --> 00:44:19,960
აქ არის მაგალითი ლექცია სადაც ჩვენ HTML tags.

641
00:44:19,960 --> 00:44:22,110
ჩვენ გვყავს ხელმძღვანელი tags, სხეულის tags,

642
00:44:22,110 --> 00:44:27,770
ჩვენ მაგალითები ცარიელი tags სადაც ჩვენ რეალურად არ გვაქვს დაწყება და ახლო tag,

643
00:44:27,770 --> 00:44:30,820
ჩვენ უბრალოდ ლინკი და იმიჯი.

644
00:44:30,820 --> 00:44:38,480
არ არსებობს დახურვის იმიჯი tag, იქ მხოლოდ ერთი tag რომ ახორციელებს ყველაფერს tag უნდა გააკეთოს.

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
POST არის, სადაც ეს არ არის დასვა URL.

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 / search.

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
HyperText Markup Language, და ეს ასეა.

663
00:45:57,710 --> 00:46:00,170
მაგრამ ეს ასევე გადადის ნებისმიერი images თქვენთვის ინტერნეტში,

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, ალტერნატიული, რომ ჩანაწერი, რომ თქვენ შეიძლება ნახოთ.

671
00:46:30,110 --> 00:46:40,790
და URL, რომ მე ვცდილობდი ვიზიტი www.google.com/search?q = blah, blah, blah.

672
00:46:40,790 --> 00:46:44,240
ასე მახსოვს, რომ ამ, კითხვის ნიშნის q = blah blah blah,

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 Internal Server Error

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 შინაგან Server შეცდომები.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP არის 1 ფენის ქვეშ HTTP.

688
00:47:43,050 --> 00:47:47,550
გვახსოვდეს, რომ არსებობს ინტერნეტ გარეთ მსოფლიო აბლაბუდა.

689
00:47:47,550 --> 00:47:52,270
Like თუ თქვენ თამაშობთ ონლაინ თამაში, რომელიც არ გადის 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, ან რასაც, რომ tends იყოს ადგილობრივი ერთი.

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
ის, რაც ითარგმნება რამ, როგორიცაა google.com ფაქტობრივი IP მისამართი.

699
00:48:33,410 --> 00:48:37,700
ასე რომ, თუ თქვენ ჩაწერეთ რომ IP მისამართი შევიდა URL,

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
ბოლო რაც ჩვენ გვაქვს არის პორტები, სადაც ეს არის TCP ნაწილი IP.

703
00:48:51,560 --> 00:48:54,880
TCP აკეთებს სხვა. ვფიქრობ, ისევე, როგორც, თქვენ ბრაუზერში გაშვებული.

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
ასე რომ, პორტები, ისე, რომ ჩვენ შეუძლია გაყოფილი up

709
00:49:10,780 --> 00:49:13,550
როგორ შეიძლება ამ განაცხადების შეგიძლიათ გამოიყენოთ ინტერნეტში.

710
00:49:13,550 --> 00:49:17,230
თითოეული პროგრამა იღებს 1 კონკრეტული პორტი, რომ მას შეუძლია მოუსმინოს on,

711
00:49:17,230 --> 00:49:19,670
და იყოს, HTTP იყენებს port 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
არსებობს 3 ადგილებში თქვენ შეგიძლიათ განათავსოთ თქვენი CSS.

718
00:49:38,440 --> 00:49:46,300
ეს შეიძლება იყოს inline, შორის სტილის tags, ან მთლიანად ცალკე ფაილი და შემდეგ უკავშირდება შემოსული

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
სადაც პირველი მაგალითია ჩვენ შესატყვისი სხეულის tag,

722
00:49:54,310 --> 00:49:56,680
და აქ ჩვენ centering ორგანოს აქვს.

723
00:49:56,680 --> 00:50:00,420
მეორე მაგალითი, ჩვენ შესატყვისი რამ

724
00:50:00,420 --> 00:50:04,740
პირადობის ძირი, და ჩვენ გამოყენებით გარკვეული სტილის რომ.

725
00:50:04,740 --> 00:50:07,310
გაითვალისწინეთ, რომ ID ძირი ტექსტის aligns მარცხნივ,

726
00:50:07,310 --> 00:50:09,840
ხოლო სხეულის ტექსტის aligns ცენტრი.

727
00:50:09,840 --> 00:50:13,180
Footer არის შიგნით ორგანო.

728
00:50:13,180 --> 00:50:16,470
ეს იქნება, ნაცვლად, text-align მარცხენა, მიუხედავად იმისა, რომ სხეულის ამბობს ტექსტის გასწორება ცენტრი.

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 specifiers უპირატესი.

734
00:50:34,420 --> 00:50:46,140
მე ვფიქრობ, რომ ეს არის ის.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Hi ყველას. თუ შეიძლება უბრალოდ თქვენი ყურადღება.

736
00:50:49,260 --> 00:50:53,990
მე ალი და მე ვაპირებ გავლა PHP და SQL მართლაც სწრაფი.

737
00:50:53,990 --> 00:51:00,310
ასე რომ, ჩვენ შეიძლება დაიწყოს. PHP არის მოკლე PHP: ჰიპერტექსტის 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
და როგორ აკეთებს ბევრი computations, უკან სცენები ნაწილი.

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
თქვენ ხედავთ, თქვენ გჭირდებათ ახალი სახის braces და მაშინ ასევე უნდა? 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, თქვენ არ უნდა დააყენოს რა სახის ცვლადი type ეს არის.

752
00:52:01,690 --> 00:52:04,940
ასე რომ, ხოლო თქვენ გჭირდებათ $, თქვენ არ უნდა დააყენოს, ისევე,

753
00:52:04,940 --> 00:52:09,470
int x ან string Y, etcetera, etcetera.

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
თქვენ შეგიძლიათ შეინახოთ თქვენი ნომერი 1, int,

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
ორი თანაბარი ნიშნები, 3 თანაბარი ნიშნები, 4 თანაბარ ნიშნები.

766
00:52:47,280 --> 00:52:49,990
Okay, არ არსებობს 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
ეს იმას ნიშნავს, რომ ის არ აპირებს გაიაროს ამ მეორე შემთხვევაში აქ,

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.

778
00:53:31,570 --> 00:53:34,080
ეს, ძირითადად, მხოლოდ ამ მოსახერხებელი dot ნოტაცია,

779
00:53:34,080 --> 00:53:36,230
და რომ ის, თუ როგორ შეიძლება სავალდებულოა strings ერთად.

780
00:53:36,230 --> 00:53:40,800
ასე რომ, თუ თქვენ გაქვთ კატა და თქვენ უნდა ძაღლი, და გსურთ დააყენა 2 strings ერთად,

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
სადაც მე არ echo string 1, სივრცე string 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
რეგულარული კოლექტორები მხოლოდ ამ დო,

790
00:54:08,280 --> 00:54:11,240
და ა.შ. თქვენ გაქვთ ინდექსების რომ დათვლილია.

791
00:54:11,240 --> 00:54:13,160
ახლა ჩვენ უბრალოდ აპირებს, რომ შევქმნათ ერთი და დასვა -

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 იბეჭდება out. Cool?

801
00:54:36,900 --> 00:54:40,160
ასე რომ, რეგულარულ კოლექტორები თქვენთვის.

802
00:54:40,160 --> 00:54:42,750
კიდევ ერთი გზა, ასევე შეგიძლიათ დაამატოთ რამ რეგულარული კოლექტორები now

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
ასე რომ, თქვენ ხედავთ, 1 უფლება არსებობს იმ 0 ლაქა,

808
00:54:59,190 --> 00:55:02,690
2 წავიდა იქ პირველ ადგილზე.

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
და მაშინ, როდესაც ჩვენ echoing ინდექსი ნომერი 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, და ისინი ორმაგ ბრჭყალებში ნიშნავდეს, რომ ისინი ყველა strings.

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
თქვენ შეგიძლიათ ეს გააკეთოთ ყველა ერთ ბლოკი. ასე რომ, თქვენ ხედავთ, რომ tf რომ მასივი,

828
00:56:09,400 --> 00:56:13,350
და მაშინ ჩვენ მათი ყველა ერთ გიგანტური კვადრატული ფრჩხილი კომპლექტი.

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
In C გვაქვს მარყუჟების, რომ მუშაობა მოსწონს ეს.

833
00:56:26,020 --> 00:56:29,690
ჩვენ გვქონდა ჩვენი array და წავედით ეხლა ინდექსი 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
რადგან ახლა ჩვენ გვაქვს string მაჩვენებლები.

838
00:56:39,610 --> 00:56:44,800
ახლა ჩვენ ვიყენებთ foreach მარყუჟების, რომელიც, კიდევ ერთხელ, თქვენ იმედია გამოყენებული pset 7.

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
ერთ შემთხვევაში ან ერთი განყოფილების მასივი.

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
ასე ვთქვათ ჩვენ ვიწყებთ იმ arrow რომ ჩვენ იქ.

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
ჩვენ ვაპირებთ დავიწყოთ î0 და შემდეგ ჩვენ ვაპირებთ echo იგი.

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
ერთი არის არანაკლებ 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, ასე რომ თქვენ გაივლის for loop, და ეს კიდე ბეჭდვა 2.

868
00:58:29,860 --> 00:58:35,100
მაშინ თქვენ აღვნიშნო, რომ 3 არანაკლებ 3, ასე რომ ჩვენ შესვენება გარეთ ამისთვის loop.

869
00:58:35,100 --> 00:58:40,050
ახლა ჩვენ დასრულების, და შემდეგ ჩვენ ვაპირებთ წასვლას aFunction.

870
00:58:40,050 --> 00:58:45,010
Okay. ასე რომ თქვენ უნდა გაითვალისწინოთ, რომ ეს ცვლადი, რომელიც ჩვენ შევქმენით,

871
00:58:45,010 --> 00:58:48,270
'i' ცვლადი, არ ადგილობრივად scoped.

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
თქვენ ფიქრობთ, პირველ რიგში, ეფუძნება C, რომ ეს არის ის ასლი 'i' ცვლადი.

877
00:59:09,410 --> 00:59:12,830
ეს სრულიად განსხვავებული რამ, რაც არის სწორი.

878
00:59:12,830 --> 00:59:16,560
ასე რომ, როდესაც ჩვენ ბეჭდვა, ჩვენ ვაპირებთ ბეჭდვა 'i' + +, რომელიც აპირებს ამობეჭდოთ, რომ 4,

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
და ჩვენ ვაპირებთ, რომ იყოს, სადაც, რომ arrow არის ახლა.

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
ეს იმას ნიშნავს, რომ როდესაც ჩვენ echo 'i', იგი არ შეცვლილა ფარგლებში ფუნქცია,

886
00:59:38,960 --> 00:59:43,660
და ასე შემდეგ, ჩვენ ვაპირებთ ბეჭდვა 3 ერთხელ.

887
00:59:43,660 --> 00:59:47,520
სხვა რამ ფარგლებს PHP, ვიდრე C.

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-თან ერთად, ჩვენ ყოველთვის მხოლოდ იგივე სტატიკური რამ, როგორიცაა, თუ როგორ Rob აჩვენა,

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
მიუხედავად იმისა, რომ ტექნიკურად მაინც წვდომის იმავე ვებ გვერდზე ზედაპირზე.

903
01:00:38,870 --> 01:00:43,450
გამოიმუშავებს HTML. არსებობს 2 სხვადასხვა გზები, რომ თქვენ შეგიძლიათ ამის გაკეთება.

904
01:00:43,450 --> 01:00:48,980
ამიტომ ჩვენ გაიაროს, რომ ახლა. პირველი გზა არის, თქვენ - yeah, უკაცრავად.

905
01:00:48,980 --> 01:00:51,150
ასე, რომ თქვენ უბრალოდ უნდა თქვენი რეგულარული for loop in PHP,

906
01:00:51,150 --> 01:00:56,270
და მაშინ echo PHP და თქვენ echo გარეთ HTML.

907
01:00:56,270 --> 01:00:58,720
გამოყენება რა რობ აჩვენა თქვენ HTML script

908
01:00:58,720 --> 01:01:04,030
და შემდეგ გამოყენებით PHP ბეჭდვითი უბრალოდ ამობეჭდოთ ვებ გვერდზე.

909
01:01:04,030 --> 01:01:09,520
ალტერნატიული გზა არის ამას თუ გამოყოფთ out PHP და HTML.

910
01:01:09,520 --> 01:01:11,940
ასე რომ თქვენ შეგიძლიათ აქვს ხაზი 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
ასე რომ, ეს სახის ჰყოფს იგი out.

914
01:01:21,800 --> 01:01:24,020
მარცხენა მხარეს, შეგიძლიათ, რომ თქვენ გაქვთ ყველა -

915
01:01:24,020 --> 01:01:26,360
უბრალოდ 1 ბლოკი PHP.

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
ასე ჰყოფს იგი out შევიდა რა ისინი აკეთებენ.

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 images გამოჩნდება თქვენი ნახვა.

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
მაგრამ თქვენ მაინც ნახოთ იგი თქვენს cookies ინფორმაციას, რომ თქვენ გაგზავნის.

937
01:02:34,420 --> 01:02:38,260
ასე რომ, არა მგონია, რომ ერთი ან მეორე.

938
01:02:38,260 --> 01:02:42,160
კიდევ ერთი რამ უნდა აღვნიშნო, რომ თქვენ ასევე უნდა მონაკვეთზე ცვლადები.

939
01:02:42,160 --> 01:02:45,850
თქვენ ბიჭები გამოიყენება ეს pset 7 მიიღოთ თქვენი მომხმარებლის ID ინფორმაციას.

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
ხოლო თუ თქვენ უბრალოდ შეინახოს იგი, რომ ერთ უშუალო მომენტი

952
01:03:29,930 --> 01:03:33,720
და შემდეგ გამოიყენოთ იგი მოგვიანებით, თქვენ ვერ შეძლონ არაფერი რომ თქვენ გადაარჩინა.

953
01:03:33,720 --> 01:03:37,660
ჩვენ გვყავს 4 ძირითადი რამ, რომ ჩვენ ვიყენებთ SQL ბრძანებები.

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, და ჩვენ გვაქვს კლასის პირადობის მოწმობა და სლოგანი.

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, კლასის სახელი და სლოგანი, რომ მას შეუძლია აირჩიოთ out.

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
ჩვენ ყოველთვის უნდა შეამოწმოთ, თუ row ს სამმაგი თანაბარი თუ ცრუ.

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
წინააღმდეგ შემთხვევაში, თქვენ გსურთ loop მეშვეობით ყველაფერს იმ მოსახერხებელი

975
01:04:55,870 --> 01:04:59,410
foreach მარყუჟების, რომ ჩვენ უბრალოდ წავიდა.

976
01:04:59,410 --> 01:05:01,280
არის, რომ ჩვენ looping მეშვეობით და ჩვენ გახადა წარსულში,

977
01:05:01,280 --> 01:05:05,080
მოდით ვივარაუდოთ, რომ ჩვენი ხერხისთვის გავიდა, ახლა ჩვენ გვაქვს ჩვენი foreach loop.

978
01:05:05,080 --> 01:05:11,050
და პირველ რიგში მას აქვს, ამიტომ აქ ზედიზედ, სწორედ აქ, ის boxed.

979
01:05:11,050 --> 01:05:14,010
ის აპირებს ამობეჭდოთ ყველა ინფორმაციას, რომ ის მიღებული.

980
01:05:14,010 --> 01:05:18,070
ასე რომ, ის აპირებს ამობეჭდოთ ბოლოში "Wanna Learn HTML?"

981
01:05:18,070 --> 01:05:23,370
შემდეგ ის აპირებს წასვლა მომდევნო ზედიზედ, იმიტომ, რომ ის დასრულდა პირველი მარყუჟის,

982
01:05:23,370 --> 01:05:26,510
და ასე შემდეგ ის აპირებს ამობეჭდოთ მეორე ხაზი, რომ,

983
01:05:26,510 --> 01:05:32,120
რომელიც იქნება STAT110, მოძებნა ყველა Moments.

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 Injection არის ერთგვარი სახიფათო რამ.

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 შეკითხვაზე, და გსურთ დაძრულიყო ეს off და მიიღეთ რაც თქვენს მონაცემები მაგიდასთან.

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 query ახლა,

999
01:06:25,070 --> 01:06:29,090
იგი აფასებს ყოველთვის ასეა, რადგან თქვენ აღვნიშნო, რომ

1000
01:06:29,090 --> 01:06:32,240
თქვენ შეგიძლიათ SQL query შეარჩიოთ ყველა ამ ინფორმაციას

1001
01:06:32,240 --> 01:06:35,420
ან შეგიძლიათ მხოლოდ 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
ასე რომ ყოველთვის აპირებს შეაფასოს ჭეშმარიტი.

1003
01:06:41,030 --> 01:06:46,610
რომ არ აპირებს, რომ ნამდვილად მუშაობს, რადგან ეს ნიშნავს, რომ ჰაკერი შეიძლება დაარღვიოს თქვენი სისტემა.

1004
01:06:46,610 --> 01:06:49,300
გამოსავალი არის ის, რომ თქვენ უნდა გამოიყენოთ სახალხო დამცველის სისტემა,

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
მერე დააყენა ცვლადების შემდეგ ჩემი strings ასე ვიცი შეცვლის მათ ამ მიზნით შემდეგ.

1012
01:07:15,420 --> 01:07:18,470
რომ დარწმუნდნენ, რომ, თუ ვინმე აკეთებს ასე,

1013
01:07:18,470 --> 01:07:24,050
და მათ აქვთ or 1 = 1 სიტუაციას, რომელიც დარწმუნდით,

1014
01:07:24,050 --> 01:07:30,490
უკან ბოლოს, დარწმუნდით, რომ ის რეალურად არ დაარღვიოს SQL შეკითხვაზე.

1015
01:07:30,490 --> 01:07:33,660
Okay, ასე რომ საკმაოდ ბევრი ის, whirlwind PHP და SQL.

1016
01:07:33,660 --> 01:07:41,520
საუკეთესო luck ყველას, და ახლა Ore.

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Okay ყველას. ახლა წავიდეთ მეტი რამდენიმე JavaScript

1018
01:07:44,270 --> 01:07:48,840
და ზოგიერთი სხვა რამ ძალიან სწრაფად ამიტომ ჩვენ არ გამართავს თქვენ up tonight.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. დიახ. JavaScript არის სახის cool რამ, სავარაუდოდ.

1020
01:07:56,930 --> 01:07:59,090
რამ ნამდვილად უნდა იცოდეთ შესახებ JavaScript, ეს ერთგვარი მოსწონს

1021
01:07:59,090 --> 01:08:03,810
კლიენტის მხარის ბოლოს რა თქვენი web app იქნება აკეთებს.

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
Cool რამ 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
სხვა რამ არის cool შესახებ: ეს Curly გაუწიოს ენაზე

1032
01:08:37,520 --> 01:08:41,359
რაც იმას ნიშნავს, სინტაქსის მსგავსია C და PHP.

1033
01:08:41,359 --> 01:08:47,050
თქვენ არ გაქვთ ბევრი რამ rework როცა თქვენ სწავლის 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
ჩვენ ცოტა 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
შემდეგ მეორე ცოტა რეალურად რამდენიმე inline JavaScript,

1040
01:09:06,910 --> 01:09:10,790
ძალიან ჰგავს inline სტილის 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
oh, მე უნდა გამოყოს რამ, ან რამე მსგავსი.

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
გზა თქვენ ჯგუფი მონაცემები ერთად, გარკვეულწილად მსგავსი struct,

1056
01:10:10,100 --> 01:10:17,280
მაგრამ თქვენ შეგიძლიათ თქვათ ეს მოსწონს struct ან ასოციაციურ მასივში სინტაქსი.

1057
01:10:17,280 --> 01:10:22,520
ეს არის საკმაოდ მარტივი და რა შეგიძლიათ გააკეთოთ, რომელზეც ეს არის ჯგუფი მონაცემები ერთად

1058
01:10:22,520 --> 01:10:24,810
თუ თქვენ გაქვთ bunch of მონაცემები რომ დაკავშირებული.

1059
01:10:24,810 --> 01:10:26,850
იმიტომ, რომ ეს ყველაფერი, თქვენ უნდა აღწერს მანქანა,

1060
01:10:26,850 --> 01:10:29,050
თქვენ არ უნდა მას bunch სხვადასხვა ადგილებში.

1061
01:10:29,050 --> 01:10:35,300
თქვენ შეგიძლიათ მხოლოდ გამყარებაში მას 1 ობიექტი JavaScript.

1062
01:10:35,300 --> 01:10:39,090
როგორც თქვენ ალბათ იცით, iterating არის ერთი იმ tedious ამოცანა.

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
ამ შემთხვევაში, ის ამ loop.

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
რომ თქვენ დავუბრუნდეთ ყველა გასაღებები, ძალიან მსგავსი გზა hash მაგიდასთან.

1076
01:11:27,180 --> 01:11:30,880
თუ გახსოვთ, რომ, როდესაც თქვენ დასვა string თქვენ ვერ რაიმე

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
მე დასვა მანქანა, და მე მას Ferrari.

1080
01:11:42,120 --> 01:11:45,290
ასე, რომ თქვენ შეგიძლიათ განათავსოთ სიმებიანი Ferrari მოგვიანებით, და შეგიძლიათ მიიღოთ, რომ.

1081
01:11:45,290 --> 01:11:50,000
და შეგიძლიათ გააკეთოთ, რომ მარყუჟი, ერთად ამ loop.

1082
01:11:50,000 --> 01:11:53,320
ასე რომ მხოლოდ უფრო მეტი ობიექტების. მთავარია, ამ, თქვენ უნდა გვახსოვდეს

1083
01:11:53,320 --> 01:12:00,340
არის, რომ თქვენ შეგიძლიათ გამოიყენოთ ობიექტზე struct მოსწონს სინტაქსის მაშინ, როცა გნებავთ ამ,

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
რომ უბრალოდ არ აქვს აზრი syntactically.

1088
01:12:15,320 --> 01:12:22,730
ასე რომ თქვენ მხოლოდ შეგვიძლია გავაკეთოთ, რომ ამ სახის bracket სინტაქსი.

1089
01:12:22,730 --> 01:12:26,520
>> ასევე, JavaScript ძალიან ფარგლებს ბრძენი to 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
თქვენ ხედავთ, რომ ყველგან. მაშინაც კი, თუ თქვენ უნდა დააყენოს ამ თუ განაცხადი,

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
მე არ მაქვს მაგალითად, მაგრამ, yeah. ეს არის ერთ ერთი იმ რამ, სადაც

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
სადაც თუ რამე გამოცხადებული ამისთვის მარყუჟის, ის აპირებს დარჩენას, რომ მარყუჟი.

1103
01:13:15,820 --> 01:13:18,790
რაც ჩვენ რეალურად აინტერესებს გამოყენებით JavaScript ამისთვის არის მანიპულირების ვებ გვერდები, არა?

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
და მოდელები იგი out შევიდა bunch ობიექტების, რომლებიც წყობილი ფარგლებში ერთმანეთს.

1109
01:13:34,110 --> 01:13:37,080
თქვენ იწყებთ ერთად რაღაც მსგავსი.

1110
01:13:37,080 --> 01:13:44,770
გაქვთ, მარჯვენა ჩემთვის, bunch of კოდი იქ რომ სახის -

1111
01:13:44,770 --> 01:13:46,640
თქვენ ფიქრობთ, რომ მინდა იყოს ძალიან რთული მანიპულირება,

1112
01:13:46,640 --> 01:13:48,700
იმიტომ, რომ თქვენ მინდა იყოს parsing მეშვეობით bunch of ტექსტი

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
ისევე როგორც ერთი ჩემი მარცხენა, სადაც თქვენ უბრალოდ აქვს დოკუმენტი,

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
და შიგნით რომ head თქვენ გაქვთ სათაური, და ა.შ. და ა.შ. და ა.შ..

1120
01:14:08,420 --> 01:14:11,810
ეს ამარტივებს მანიპულირების ვებ გვერდზე ისე, რომ ეს უბრალოდ,

1121
01:14:11,810 --> 01:14:14,190
oh, მე უბრალოდ მინდა გაიგო, რომ ეს ობიექტი.

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
და როგორც თქვენ ალბათ გითხრათ, ამ იღებს ძალიან unwieldy შემდეგ, ხოლო.

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
და მერე ამბობენ, hey. როდესაც ამ დატვირთვების ან ვინმე დააჭერს ეს,

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
რა they're - უბრალოდ ლამაზი გზა ამბობდა,

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
ეს არის, თუ როგორ ქმნის out ღონისძიება დამმუშავებლის.

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
თქვენ გაქვთ ღილაკს tag, და click თქვენ გაქვთ სიმებიანი, რომელიც ამბობს,

1148
01:15:46,430 --> 01:15:50,460
oh, სხვათა შორის, მე ამ აფეთქებენ ჩემთვის.

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
მიერ grabbing DOM ელემენტს, მაგრამ ჩვენ გადარჩენა, რომ მას შემდეგ, რაც ჩვენ ვსაუბრობთ jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: ეს არის ბიბლიოთეკა, რომელიც არის cross-ბრაუზერი.

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 app თქვენ შეიძლება გსურთ.

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
თქვენ ასევე selectors, რომელიც გაძლევთ მიიღოს ყველა იმ ელემენტების

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 "Rock".

1164
01:16:49,800 --> 01:16:56,450
ასევე, jQuery, უბრალოდ $ და შემდეგ სიმებიანი რომ აქვს ფუნტი, და შემდეგ "Rock".

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 არის ერთ - ერთი მაგარი მახასიათებლები არის შეგიძლიათ სახის შეკუმშოს

1168
01:17:08,140 --> 01:17:14,350
ქვემოთ თქვენი queries თქვენს DOM ძალიან, ძალიან სწრაფად.

1169
01:17:14,350 --> 01:17:18,980
ახლა ჩვენ უკან ღონისძიების გატარება, და ეს არის, თუ როგორ გაუმკლავდეს ერთი მოვლენა jQuery.

1170
01:17:18,980 --> 01:17:23,090
ასე რომ, რასაც ჩვენ ვაპირებთ აქ არის ჩვენ ვამბობთ, ყველა უფლება. მაქვს სცენარი აქვს, არა?

1171
01:17:23,090 --> 01:17:25,400
ასე რომ, მე ამ inline 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
ის ძირითადად ამბობდა, ყველა უფლება, get me ელემენტს ერთად ID "myid".

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
თქვენ არ მინდა ფიქრი, okay, მე უნდა დავრწმუნდეთ ამ რამ მოლაპარაკებები ამ რამ,

1184
01:18:10,520 --> 01:18:14,660
ეს საგანი blah blah blah, რადგან გსურს გაიგო, რაც თვალსაზრისით მოვლენები.

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
თითოეული დრო იღებს სახის tedious და რატომ მჭირდება

1195
01:18:44,390 --> 01:18:47,430
გაიყვანოს ქვემოთ header ერთხელ, და ძირი ისევ,

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
რა შეგვიძლია გავაკეთოთ აქ აიაქსი არის, ჩვენ შეგვიძლია ვთქვათ, ყველა უფლება,

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
თქვენს სერვერზე ვერ უბრალოდ magically მოსმენა არსად.

1205
01:19:18,650 --> 01:19:21,960
თქვენ უნდა კონკრეტული ადგილი თქვენ გაგზავნის ამ მონაცემებს.

1206
01:19:21,960 --> 01:19:26,240
და თქვენ ასევე უნდა ზოგიერთი მონაცემების გაგზავნას, ან იქნებ ის dataless შეკითხვაზე.

1207
01:19:26,240 --> 01:19:31,380
გსურთ PING თავში სერვერზე და აცხადებენ, hey, მე ვარ ცოცხალი, ან რამე მაგდაგვარს.

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
თქვენ შექმნით on click ფუნქცია ამ ღილაკს მოუწოდა greeter.

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
და თქვენ ამბობთ, hey, ჩემთვის რაღაც თქვენი გვერდი.

1218
01:20:07,290 --> 01:20:09,890
ჩვენ ნამდვილად არ უნდა აღწერდეს, მაგრამ greetings.php,

1219
01:20:09,890 --> 01:20:12,480
მოდით უბრალოდ, ვამბობთ, აძლევს უკან "Hello World".

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
და ეს არის ძალიან მარტივი გზა შექმნის აიაქსი შეკითხვა.

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, ყველაფერი წავიდა okay.

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
თქვენ უბრალოდ არ გინდათ app და მოდით უბრალოდ იზრდება

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
რათა ის effortless. ყველა ამ თქმით, ძირითადად,

1242
01:21:29,000 --> 01:21:34,950
გაადვილება მომხმარებელს გამოიყენოს იგი, არ იყოს იგი გიგანტური blob ტექსტის მოსწონს ეს slide არის, ფაქტობრივად.

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]