1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [ნაწილში 8 - უფრო კომფორტული]

2
00:00:02,610 --> 00:00:04,910
[Rob Bowden - ჰარვარდის უნივერსიტეტი]

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

4
00:00:11,520 --> 00:00:14,160
>> ეს კვირაში მონაკვეთზე აღნიშნავს ვაპირებთ იყოს საკმაოდ მოკლე,

5
00:00:14,160 --> 00:00:19,070
ამიტომ მე უბრალოდ აპირებს შეინარჩუნოს ვსაუბრობთ, თქვენ ბიჭები ვაპირებთ შენარჩუნება სვამს კითხვებს,

6
00:00:19,070 --> 00:00:22,720
და ჩვენ შევეცდებით შეავსოთ იმდენი დრო რაც შეიძლება.

7
00:00:22,720 --> 00:00:31,950
ბევრი ფიქრობს, რომ ეს pset არ არის აუცილებლად რთული, მაგრამ ეს ძალიან ხანგრძლივი.

8
00:00:31,950 --> 00:00:37,070
Pset სპეც თავად იღებს საათობრივად წაიკითხოს.

9
00:00:40,530 --> 00:00:45,730
ჩვენ მოგცემთ ბევრი SQL თქვენ შეიძლება უნდა გამოვიყენოთ.

10
00:00:45,730 --> 00:00:50,520
ჩვენ ფეხით თქვენ მეშვეობით ბევრი, ასე რომ არ უნდა იყოს ძალიან ცუდი.

11
00:00:50,520 --> 00:00:54,560
აქვს ვინმეს დაიწყო ან დასრულდება?

12
00:00:55,380 --> 00:00:59,710
ეს ბოლო pset. ოჰ, ღმერთი ჩემი.

13
00:00:59,710 --> 00:01:05,400
ჩვეულებრივ არსებობს JavaScript ერთი ამის შემდეგ, მაგრამ კალენდარი შეცვალოს

14
00:01:05,400 --> 00:01:09,560
აკეთებს ყველაფერს 1 კვირაში მოკლეა, და ჩვენ უკვე აღარ გვაქვს JavaScript pset.

15
00:01:09,560 --> 00:01:12,310
მე არ ვიცი როგორ გავლენას ახდენს, რომ თუ არა JavaScript აპირებს გამოჩნდება გამოცდა

16
00:01:12,310 --> 00:01:15,510
ან Quiz 1.

17
00:01:15,510 --> 00:01:22,260
მე წარმოიდგინეთ ეს იქნება რაღაც თქვენ უნდა იცოდეთ მაღალი დონის რამ JavaScript,

18
00:01:22,260 --> 00:01:26,460
მაგრამ ეჭვი მაქვს, რომ ჩვენ უბრალოდ მოგცემთ სწორი JavaScript კოდი

19
00:01:26,460 --> 00:01:28,720
მას შემდეგ, რაც თქვენ არ ჰქონდათ pset მას.

20
00:01:28,720 --> 00:01:33,000
მაგრამ ეს იქნება კონკურსები და ინტელექტუალური მიმოხილვა მომავალ კვირას.

21
00:01:33,000 --> 00:01:36,320
>> სექცია კითხვებზე.

22
00:01:36,320 --> 00:01:43,870
ბევრი ამ პერსონალის გარკვეულწილად ცუდად ფორმულირებული, მაგრამ ჩვენ განვიხილავთ, თუ რატომ.

23
00:01:43,870 --> 00:01:50,220
განსხვავებით C, PHP არის "დინამიურად-აკრეფილი" ენა. რას ნიშნავს ეს, თქვენ ეკითხებით?

24
00:01:50,220 --> 00:01:53,830
ისე, Say Goodbye ყველა იმ char, ათწილადი, int და სხვა Keywords თქვენ უნდა გამოვიყენოთ

25
00:01:53,830 --> 00:01:56,190
როდესაც გამოცხადების ცვლადები და ფუნქციები C.

26
00:01:56,190 --> 00:02:00,420
PHP-ში, ცვლადი ს ტიპის განისაზღვრება ღირებულება რომ ის გაკეთებული ჩატარების.

27
00:02:00,420 --> 00:02:04,990
ასე რომ სანამ ჩვენ აკრიფოთ ეს კოდი შევიდა ფაილი სახელად dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP არის დინამიურად აკრეფილი. რაც თავისთავად ასეა.

29
00:02:12,670 --> 00:02:17,590
მე არ ეთანხმებიან იმ ფაქტს, რომ ეს ნიშნავს, რომ ჩვენ ვამბობთ, მშვიდობით რომ char, ათწილადი, int,

30
00:02:17,590 --> 00:02:20,620
და სხვა საკვანძო სიტყვები.

31
00:02:20,620 --> 00:02:25,510
ზუსტი განსხვავება დინამიურად აკრეფილი და ალტერნატიული,

32
00:02:25,510 --> 00:02:32,010
რომელიც statically აკრეფილი, არის ის, რომ დინამიურად აკრეფილი, ყველა თქვენი ტიპის შემოწმება და პერსონალი

33
00:02:32,010 --> 00:02:37,350
ხდება პერსპექტივაში დრო, ხოლო statically აკრეფილი ეს ხდება კომპილირების დროს.

34
00:02:37,350 --> 00:02:43,030
სიტყვა სტატიკური ზოგადად, როგორც ჩანს, ნიშნავს კომპილირების დროს რამ.

35
00:02:43,030 --> 00:02:48,170
ვფიქრობ არსებობს სხვა მიზნებისათვის ამისთვის, მაგრამ C, როდესაც თქვენ გამოაცხადოს სტატიკური ცვლადი,

36
00:02:48,170 --> 00:02:52,650
მისი შენახვა გამოყო, კომპილირების დროს.

37
00:02:52,650 --> 00:02:59,260
აქ, დინამიურად აკრეფილი მხოლოდ იმას ნიშნავს, რომ -

38
00:02:59,260 --> 00:03:04,350
In C, თუ თქვენ ცდილობენ დაამატოთ სიმებიანი და რიცხვი, როდესაც თქვენ კომპილირება,

39
00:03:04,350 --> 00:03:11,000
ის აპირებს უჩივიან, რადგან იგი აპირებს ამბობენ, რომ თქვენ ვერ შეძლებთ დაამატოთ int და მაჩვენებელი.

40
00:03:11,000 --> 00:03:14,710
უბრალოდ არ მოქმედებს ოპერაცია.

41
00:03:14,710 --> 00:03:21,170
რომ სხვა საქმეა, რომ ჩვენ კიდევ ამ მეორე.

42
00:03:21,170 --> 00:03:24,860
მაგრამ ეს ერთგვარი შემოწმება, ის ფაქტი, რომ უჩივის საათზე კომპილირების დროს,

43
00:03:24,860 --> 00:03:29,220
არის სტატიკური ტიპის შემოწმებას.

44
00:03:29,220 --> 00:03:35,220
არსებობს ენებზე, სადაც თქვენ არ უნდა ვთქვა, char, ათწილადი, int, და ყველა იმ რამ,

45
00:03:35,220 --> 00:03:40,940
მაგრამ ენა, შეუძლია თქვას კონტექსტში რამ რა ტიპის ის უნდა იყოს,

46
00:03:40,940 --> 00:03:43,980
მაგრამ მაინც statically აკრეფილი.

47
00:03:43,980 --> 00:03:49,000
ასე რომ, თუ თქვენ მიიღოს 51, OCaml, თქვენ არასოდეს უნდა გამოვიყენოთ ნებისმიერი ამ ტიპის,

48
00:03:49,000 --> 00:03:58,700
მაგრამ ეს ჯერ კიდევ იქნება საათზე კომპილირების დროს ამბობენ ვერ ვაკეთებთ, რადგან თქვენ შერევას int და სიმებიანი.

49
00:03:58,700 --> 00:04:05,650
დინამიურად აკრეფილი მხოლოდ იმას ნიშნავს, რომ შუალედში დროს აწარმოებს ახლა თქვენ აპირებს მიიღოს საჩივარი.

50
00:04:05,650 --> 00:04:13,430
თუ თქვენ ასევე გამოიყენება Java ადრე, ზოგადად, თითქმის ნებისმიერი C-ტიპის ენა

51
00:04:13,430 --> 00:04:20,070
იქნება statically აკრეფილი, ამიტომ C, C + +, Java, ყველა იმ ზოგადად statically აკრეფილი.

52
00:04:20,070 --> 00:04:22,910
ჯავაში, როდესაც თქვენ შედგენის რაღაც და თქვენ ამბობდა

53
00:04:22,910 --> 00:04:26,670
string s უდრის ახალი რაღაც რომ არ არის ტექსტი,

54
00:04:26,670 --> 00:04:28,950
რომ აპირებს უჩივიან, რადგან იმ ტიპის უბრალოდ არ ემთხვევა up.

55
00:04:28,950 --> 00:04:31,180
რომ აპირებს უჩივიან საათზე კომპილირების დროს.

56
00:04:31,180 --> 00:04:36,750
მაგრამ მას ასევე აქვს გარკვეული დინამიური დრო რამ, როგორიცაა, თუ თქვენ ცდილობენ მიცემული რაღაც

57
00:04:36,750 --> 00:04:40,500
to type რომ უფრო კონკრეტული, ვიდრე მის დღევანდელ ტიპის,

58
00:04:40,500 --> 00:04:45,610
არაფერი მას შეუძლია გააკეთოს საათზე კომპილირების დროს, რათა შეამოწმოს თუ არა, რომ მსახიობი აპირებს კიდეც.

59
00:04:45,610 --> 00:04:51,130
ჯავის ასევე აქვს გარკვეული დინამიური ტიპის შემოწმების, რომ როგორც კი იგი იღებს, რომ ხაზი კოდი

60
00:04:51,130 --> 00:04:54,130
როცა ეს რეალურად შესრულებაში, იგი აპირებს მსახიობი,

61
00:04:54,130 --> 00:04:56,260
შეამოწმეთ თუ ეს მსახიობი იყო მართებული პირველ რიგში,

62
00:04:56,260 --> 00:04:59,890
და თუ ეს არ იყო, მაშინ იგი აპირებს ჩივიან, რომ თქვენ გაქვთ არასწორი ტიპი.

63
00:04:59,890 --> 00:05:03,200
დინამიური ტიპის შემოწმების.

64
00:05:03,200 --> 00:05:07,010
შეიტანეთ ამ შევიდა ფაილი სახელად dynamic.php.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
მე unzip რომ გაფორმებით.

67
00:05:18,750 --> 00:05:21,880
ჩვენ გვყავს ცვლადი, ჩვენ ვაყენებთ მას მთელი რიცხვი 7,

68
00:05:21,880 --> 00:05:27,930
მაშინ ჩვენ ვაპირებთ ბეჭდვა და% s -

69
00:05:27,930 --> 00:05:32,830
ოჰ, ჩვენ დაბეჭდვის ტიპის, ასე რომ gettype დაბრუნებას აპირებს ტიპის ცვლადი.

70
00:05:32,830 --> 00:05:35,720
ჩვენ უბრალოდ ბეჭდვის ტიპი უსასრულოდ.

71
00:05:35,720 --> 00:05:39,440
ჩვენ უბრალოდ php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
ჩვენ დავინახავთ, რომ იგი იცვლება მთელი რიცხვი უნდა string to ლოგიკური როგორც ჩვენ გაიაროს.

73
00:05:45,920 --> 00:05:54,590
დო არ არსებობს ლოგიკური მონაცემები ტიპის, არ არსებობს სიმებიანი მონაცემები ტიპის.

74
00:05:54,590 --> 00:06:00,500
არსებობს char * და ლოგიკური მხოლოდ tends უნდა იყოს int ან char ან რამე.

75
00:06:00,500 --> 00:06:05,690
PHP-ში ამ ტიპის არსებობენ, და რომ ერთ ერთი დიდი უპირატესობა PHP ზე C -

76
00:06:05,690 --> 00:06:13,290
რომ სიმებიანი ოპერაციებს უსასრულოდ ადვილია PHP-ში, ვიდრე C. ისინი უბრალოდ მუშაობა.

77
00:06:13,290 --> 00:06:18,290
>> ამიტომ, ჩვენ დავბრუნდებით აქ.

78
00:06:18,290 --> 00:06:21,260
ჩვენ გაიქცა dynamic.php.

79
00:06:21,260 --> 00:06:26,710
ეს ეუბნება PHP ინტერპრეტატორი, მოუწოდა PHP, აწარმოებს PHP კოდი dynamic.php.

80
00:06:26,710 --> 00:06:30,250
თუ თქვენ გაქვთ რაიმე შეცდომები ფაილი, თარჯიმანი გეტყვით!

81
00:06:30,250 --> 00:06:39,110
თარჯიმანი, ეს არის კიდევ ერთი დიდი სხვაობა PHP და C.

82
00:06:39,110 --> 00:06:48,200
In C, თქვენ უნდა შეადგინონ რაღაც და მაშინ აწარმოებს, რომ შედგენილი ფაილი.

83
00:06:48,200 --> 00:06:50,490
PHP-ში თქვენ არასდროს კომპილაციის არაფერი.

84
00:06:50,490 --> 00:06:57,200
ასე რომ PHP ინტერპრეტატორი ძირითადად მხოლოდ კითხულობს ამ ხაზს.

85
00:06:57,200 --> 00:07:02,900
ეს ურტყამს var = 7 მაშინ ჰიტები printf მაშინ ჰიტები var მაშინ ჰიტები printf და ასე შემდეგ.

86
00:07:02,900 --> 00:07:10,910
არსებობს ცოტა შედგენის ეს ასეა, და ეს caches შედეგები

87
00:07:10,910 --> 00:07:15,510
ასე რომ, თუ თქვენ აწარმოებს სცენარის later შეგიძლიათ დაკავდით,

88
00:07:15,510 --> 00:07:19,280
მაგრამ ძირითადად ეს ხაზს სახის რამ.

89
00:07:19,280 --> 00:07:25,280
ეს იმას ნიშნავს, რომ ბევრი ოპტიმიზაციით, რომ მივიღებთ დო,

90
00:07:25,280 --> 00:07:31,920
მოსწონს შედგენა, უბრალოდ ზოგადად შემდგენელი შეუძლია გააკეთოს ბევრი ხრიკები თქვენთვის.

91
00:07:31,920 --> 00:07:36,110
მას შეუძლია აიღოს გამოუყენებელი ცვლადები, მას შეუძლია გააკეთოს ყველა ამ სახის ნივთები,

92
00:07:36,110 --> 00:07:38,660
მას შეუძლია გააკეთოს კუდი უკან.

93
00:07:38,660 --> 00:07:42,550
PHP-ში თქვენ არ აპირებს მიიღოს, რომ უპირატესობა

94
00:07:42,550 --> 00:07:45,690
რადგან ეს მხოლოდ იწყებს შესრულებაში ხაზის მიერ ხაზს,

95
00:07:45,690 --> 00:07:49,950
და ეს ნამდვილად არ აღიარებს ეს ყველაფერი ადვილად

96
00:07:49,950 --> 00:07:54,440
რადგან არ 1 დიდი კრებული უღელტეხილზე მეტი რამ და შემდეგ აღსრულება;

97
00:07:54,440 --> 00:07:56,860
უბრალოდ ხაზს.

98
00:08:00,730 --> 00:08:02,750
ასე რომ თარჯიმანი.

99
00:08:02,750 --> 00:08:06,840
>> თავში ჩვენი დინამიური აკრეფით: საკმაოდ გრილი, eh?

100
00:08:06,840 --> 00:08:08,640
თქვენ აუცილებლად ვერ რომ C!

101
00:08:08,640 --> 00:08:11,860
ახლა ვნახოთ, თუ შეგიძლიათ გაერკვნენ ტიპის თითოეულ შემდეგ ფასეულობებს.

102
00:08:11,860 --> 00:08:14,760
იხილეთ ამ ცნობისთვის.

103
00:08:14,760 --> 00:08:19,420
ასე რომ 3.50. რა ტიპისა ფიქრობთ, რომ იქნება?

104
00:08:24,480 --> 00:08:26,370
აქ არის სახის გვაქვს.

105
00:08:26,370 --> 00:08:30,430
ჩვენ გვყავს bools, რიცხვებით, მცურავი ქულა, სიმები, მასივები, ობიექტების,

106
00:08:30,430 --> 00:08:38,370
და მაშინ რესურსების, რომელიც სახის ბუნდოვანია.

107
00:08:38,370 --> 00:08:41,010
ვფიქრობ, სინამდვილეში მაგალითად აქ.

108
00:08:41,010 --> 00:08:43,740
მაშინ არსებობს null. NULL არის სპეციალური ტიპის.

109
00:08:43,740 --> 00:08:47,140
განსხვავებით C აქ NULL მხოლოდ კურსორი ერთად მისამართზე 0,

110
00:08:47,140 --> 00:08:54,930
in PHP, NULL არის საკუთარი ტიპის სადაც ძალაშია მხოლოდ ისაა, რომ ტიპის null.

111
00:08:57,560 --> 00:09:00,670
ეს არის ბევრად უფრო სასარგებლოა შეცდომა შემოწმებისას.

112
00:09:00,670 --> 00:09:04,310
In C, სადაც ჩვენ გვქონდა ამ საკითხთან დაკავშირებით, სადაც თუ დაბრუნების NULL,

113
00:09:04,310 --> 00:09:08,660
ნიშნავს ეს თქვენ დაბრუნების NULL კურსორი ან NULL to ნიშნავდეს შეცდომა

114
00:09:08,660 --> 00:09:12,380
ან ყველა, რომ დაბნეულობა გვქონდა ერთ მომენტში.

115
00:09:12,380 --> 00:09:18,440
აქ დაბრუნების NULL ზოგადად ნიშნავს შეცდომა.

116
00:09:20,860 --> 00:09:27,300
ბევრი რამ ასევე დაბრუნების ცრუ ამისთვის შეცდომა.

117
00:09:27,300 --> 00:09:33,140
მაგრამ საქმე იმაშია არის NULL ტიპი, ერთადერთი იმ NULL ტიპი არის NULL.

118
00:09:33,140 --> 00:09:40,090
მაშინ გადმორეკე ჰგავს შეგიძლიათ განსაზღვროს გარკვეული ანონიმური ფუნქციები.

119
00:09:40,090 --> 00:09:46,420
თქვენ არ მისცეს ფუნქციის სახელი, მაგრამ თქვენ არ უნდა გაუმკლავდეთ, რომ აქ.

120
00:09:46,420 --> 00:09:53,940
შევხედავთ იმ ტიპის რომ მათ ველოდებით us იცოდეს,

121
00:09:53,940 --> 00:09:59,000
როგორ ფიქრობთ რა ტიპის 3.50 არის? >> [სტუდენტი] Float.

122
00:09:59,000 --> 00:10:00,370
Yeah.

123
00:10:00,370 --> 00:10:06,290
ასე შემდეგ აქ, როგორ ფიქრობთ რა ტიპის ეს? >> [სტუდენტი] მასივი.

124
00:10:06,290 --> 00:10:09,890
Yeah. პირველი იყო float, ხოლო მეორე არის მასივი.

125
00:10:09,890 --> 00:10:14,500
გაითვალისწინეთ, რომ ეს წყობა არ მოსწონს C მასივი

126
00:10:14,500 --> 00:10:19,610
სადაც თქვენ ინდექსი 0 აქვს გარკვეული მნიშვნელობა, ინდექსი 1 აქვს გარკვეული მნიშვნელობა.

127
00:10:19,610 --> 00:10:26,320
აქ ინდექსების არიან, B, და C და ღირებულებები 1, 2, და 3.

128
00:10:26,320 --> 00:10:33,980
PHP-ში არ არსებობს განსხვავება შორის ასოციაციურ მასივში და მხოლოდ რეგულარული მასივი

129
00:10:33,980 --> 00:10:36,740
როგორც თქვენ ამას ვფიქრობ მას C.

130
00:10:36,740 --> 00:10:43,040
არსებობს მხოლოდ ამ, და ქვეშ the hood რეგულარული მასივი მხოლოდ ასოციაციურ მასივში

131
00:10:43,040 --> 00:10:50,000
სადაც 0 რუკების გარკვეული მნიშვნელობა ისევე რუკების გარკვეული მნიშვნელობა.

132
00:10:50,000 --> 00:11:00,410
ამ მიზეზით, PHP შეიძლება საკმაოდ ცუდი ნამდვილად სწრაფად კოდი / ბენჩმარკინგი რამ

133
00:11:00,410 --> 00:11:07,930
რადგან C, როდესაც თქვენ იყენებთ მასივი თქვენ იცით, რომ წვდომის წევრი არის მუდმივი დრო.

134
00:11:07,930 --> 00:11:11,860
In PHP წვდომის წევრი არის ვინ იცის რამდენ ხანს?

135
00:11:11,860 --> 00:11:18,970
ალბათ მუდმივი თუ ის ჰეშები სწორად.

136
00:11:18,970 --> 00:11:21,620
ვინ იცის, რა ეს ნამდვილად აკეთებს ქვეშ hood?

137
00:11:21,620 --> 00:11:25,600
თქვენ ნამდვილად გესაჭიროებათ შევხედოთ განხორციელების ვნახავთ, როგორ აპირებს გაუმკლავდეთ რომ.

138
00:11:25,600 --> 00:11:28,550
ასე რომ მაშინ fopen.

139
00:11:28,550 --> 00:11:36,420
ვფიქრობ აქ მოდით უბრალოდ PHP სახელმძღვანელო fopen შევხედოთ დაბრუნების ტიპის.

140
00:11:36,420 --> 00:11:41,260
ჩვენ ვხედავთ, აქ თქვენ შეგიძლიათ ეძებოთ საკმაოდ ბევრი ნებისმიერი ფუნქცია PHP სახელმძღვანელო

141
00:11:41,260 --> 00:11:47,540
და ეს არის ერთგვარი კაცს გვერდზე PHP.

142
00:11:47,540 --> 00:11:51,060
დაბრუნება ტიპის იქნება რესურსი.

143
00:11:51,060 --> 00:11:56,050
ამიტომ ჩანდა ეს, რადგან ჩვენ არ ნამდვილად განსაზღვრავს რესურსი.

144
00:11:56,050 --> 00:12:04,110
იდეა რესურსი, დო თქვენ სახის მივიღე ი * ან რასაც;

145
00:12:04,110 --> 00:12:07,200
PHP-ში რესურსი არის თქვენი ფაილი *.

146
00:12:07,200 --> 00:12:10,360
ეს არის ის, რაც თქვენ უნდა კითხულობს საწყისი, ეს არის ის, რაც თქვენ უნდა წერილობით.

147
00:12:10,360 --> 00:12:20,710
ეს, როგორც წესი, გარე, ამიტომ რესურსი შეგიძლიათ დახევის ნივთები და გადაყარეთ რამ.

148
00:12:20,710 --> 00:12:26,520
და ბოლოს, რა არის გაცნობის NULL? >> [სტუდენტი] null.

149
00:12:26,520 --> 00:12:30,650
Yeah. ასე, რომ ერთადერთი, რაც არის NULL არის NULL.

150
00:12:30,650 --> 00:12:33,480
NULL არის NULL.

151
00:12:35,490 --> 00:12:41,170
>> ერთი თვისება PHP-ის ტიპის სისტემით (უკეთესი ან უარესი) არის მისი უნარი juggle ტიპები.

152
00:12:41,170 --> 00:12:44,390
როდესაც ვწერთ ხაზი PHP კოდი, რომელიც აერთიანებს ფასეულობებს სხვადასხვა ტიპის,

153
00:12:44,390 --> 00:12:46,670
PHP შეეცდება გააკეთოს გონივრული რამ.

154
00:12:46,670 --> 00:12:48,920
სცადეთ out ყოველი შემდეგი ხაზი PHP კოდი. რა ამობეჭდილი?

155
00:12:48,920 --> 00:12:51,000
არის თუ არა, რაც თქვენ მოსალოდნელია? რატომ ან რატომ არა?

156
00:12:51,000 --> 00:12:58,600
ეს ფაქტი იმის შესახებ, PHP არის რა ხდის, რაც ჩვენ მოვუწოდებთ სუსტად აკრეფილი.

157
00:12:58,600 --> 00:13:04,610
სუსტად აკრეფილი და კატეგორიულად აკრეფილი,

158
00:13:04,610 --> 00:13:06,840
არსებობს სხვადასხვა მიზნებისათვის შეეხება იმ თვალსაზრისით,

159
00:13:06,840 --> 00:13:12,020
მაგრამ ყველაზე ადამიანი სარგებლობს სუსტად აკრეფილი და კატეგორიულად აკრეფილი ნიშნავს ასეთი რამ

160
00:13:12,020 --> 00:13:15,920
სადაც ("1" + 2); რომ მუშაობს.

161
00:13:15,920 --> 00:13:18,290
In C, რომელიც არ მუშაობს.

162
00:13:18,290 --> 00:13:22,490
თქვენ წარმოიდგინეთ ეს არ მუშაობს.

163
00:13:22,490 --> 00:13:29,200
ბევრი ადამიანი აღრევას დინამიური აკრეფით და სუსტი აკრეფით და სტატიკური აკრეფით და ძლიერი აკრეფით.

164
00:13:29,200 --> 00:13:34,050
პითონი არის კიდევ ერთი მაგალითი იმისა, ენა რომ დინამიურად აკრეფილი.

165
00:13:34,050 --> 00:13:41,770
შეგიძლიათ გადააგდოთ გარშემო ტიპების ცვლადები და ის აპირებს განსაზღვრავს პერსპექტივაში დრო

166
00:13:41,770 --> 00:13:44,680
ნებისმიერი შეცდომა checkings.

167
00:13:44,680 --> 00:13:50,740
In Python ის აპირებს შეასრულოს ეს და ის დაინახავს ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
და ეს ვერ რადგან ის ამბობს თქვენ ვერ შეძლებთ დაამატოთ სიმებიანი და რიცხვი.

169
00:13:55,920 --> 00:14:00,860
PHP-ში, რომელიც, ისევე როგორც დინამიურად აკრეფილი, ეს არ ჩავარდება.

170
00:14:00,860 --> 00:14:04,220
სუსტი აკრეფით უნდა ვუყოთ იმ ფაქტს, რომ ეს ასეა რამ ერთად ტიპის

171
00:14:04,220 --> 00:14:07,800
რომ ნამდვილად არ აქვს აზრი აუცილებლად.

172
00:14:07,800 --> 00:14:17,420
ასე რომ ("1" + 2); მე წარმომიდგენია, რომ სიმებიანი 12, მე წარმომიდგენია იგი სიმებიანი 3,

173
00:14:17,420 --> 00:14:20,710
მე წარმომიდგენია იგი იყო მთელი რიცხვი 3.

174
00:14:20,710 --> 00:14:24,530
ეს აუცილებლად არ ჩამოყალიბებული და ჩვენ ალბათ აპირებს აქ

175
00:14:24,530 --> 00:14:29,140
რომ როდესაც ჩვენ ბეჭდვა ("1" + 2); ალბათ აპირებს დასრულდება მდე მიმდინარეობს სხვადასხვა

176
00:14:29,140 --> 00:14:32,320
ვიდრე ბეჭდვის (1 + "2").

177
00:14:32,320 --> 00:14:39,700
და ეს ტენდენცია რომ იყოს, ჩემი აზრით, ამისთვის უარესი.

178
00:14:39,700 --> 00:14:44,240
აქ ჩვენ შეგვიძლია ვცდილობთ ამ.

179
00:14:44,240 --> 00:14:48,740
კიდევ ერთი პატარა ხრიკი შესახებ PHP არის არ გჭირდებათ რეალურად ჩაწეროს ფაილი.

180
00:14:48,740 --> 00:14:52,790
ეს იმას არ აწარმოებს ამ ბრძანების რეჟიმი.

181
00:14:52,790 --> 00:14:57,710
ასე PHP-ს, მაშინ ჩვენ შეგვიძლია ჩააგდოს ბრძანების აქ:

182
00:14:57,710 --> 00:15:06,610
"ბეჭდვის ('1 '+ 2);" და მე ჩააგდოს ახალი ხაზი.

183
00:15:19,550 --> 00:15:23,970
ეს ნაბეჭდი 3.

184
00:15:31,100 --> 00:15:35,330
როგორც ჩანს ეს ბეჭდავს 3 და ეს რიცხვი 3.

185
00:15:35,330 --> 00:15:38,420
ახლა მოდით შევეცადოთ პირიქით:

186
00:15:38,420 --> 00:15:42,970
"ბეჭდვის (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
ჩვენ კიდევ 3 და იგი ასევე იქნება მთელი რიცხვი 3? მე ნამდვილად არ ვიცი.

188
00:15:50,490 --> 00:15:54,030
როგორც ჩანს, რომ არის თანმიმდევრული.

189
00:15:54,030 --> 00:15:59,550
არსებობს არასდროს ნებისმიერი მოსალოდნელი იგი იყო სიმებიანი 12 ან არაფერი რომ

190
00:15:59,550 --> 00:16:08,080
რადგან PHP, განსხვავებით JavaScript და ჯავის ძალიან,

191
00:16:08,080 --> 00:16:11,670
აქვს ცალკე ოპერატორი გაერთიანების.

192
00:16:11,670 --> 00:16:14,930
გაერთიანების PHP-ში არის dot.

193
00:16:14,930 --> 00:16:22,950
ამიტომ ბეჭდვის (1. '2 '); აპირებს მოგვცეს 12.

194
00:16:25,790 --> 00:16:32,420
ეს tends უნდა გამოიწვიოს დაბნეულობა სადაც ადამიანები ცდილობენ რაღაც მოსწონს ქ + =

195
00:16:32,420 --> 00:16:37,840
ზოგიერთი სხვა რამ, რომ მათ სურთ დაამატოთ on ბოლომდე მათი სიმებიანი და ეს აპირებს ჩავარდება.

196
00:16:37,840 --> 00:16:40,770
თქვენ გევალებათ ქ. =

197
00:16:42,000 --> 00:16:46,240
ამიტომ, ნუ დაგავიწყდებათ გაერთიანების PHP-ში არის dot.

198
00:16:46,240 --> 00:16:52,100
სხვა რამ ცდილობენ: ბეჭდვა ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
მე გითხარით, რომ არ არსებობს იმედი ამ შედეგადაც CS50

200
00:17:03,610 --> 00:17:06,119
წლიდან გაერთიანების არ არის +.

201
00:17:06,119 --> 00:17:08,440
რას ფიქრობთ ამ აპირებს დასრულდება მდე მიმდინარეობს?

202
00:17:10,359 --> 00:17:13,460
მე ნამდვილად აქვს აბსოლუტურად წარმოდგენა არ.

203
00:17:14,250 --> 00:17:16,460
როგორც ჩანს ეს მხოლოდ 50.

204
00:17:16,460 --> 00:17:21,490
იგი ხედავს სიმებიანი და მე დადებს თუ ჩვენ დააყენა 123CS -

205
00:17:21,490 --> 00:17:29,640
იგი ხედავს პირველი ტექსტი, იგი ცდილობს წაიკითხა მთელი მისგან ან ნომრის იგი.

206
00:17:29,640 --> 00:17:31,710
ამ შემთხვევაში იგი ხედავს 123CS.

207
00:17:31,710 --> 00:17:35,190
"ეს არ აქვს აზრი, როგორც მთელი რიცხვი, ასე რომ მე უბრალოდ აპირებს ვფიქრობ 123."

208
00:17:35,190 --> 00:17:38,580
ასე რომ 123 + 50 იქნება 173.

209
00:17:38,580 --> 00:17:40,740
და აქ იწყება შორის როგორც მთელი რიცხვი.

210
00:17:40,740 --> 00:17:45,690
იგი ვერაფერს ხედავს, ასე რომ მხოლოდ ეპყრობა, როგორც 0. ასე 0 + 50 იქნება 50.

211
00:17:45,690 --> 00:17:51,600
ეს მე თუ ვთქვათ აპირებს რაიმე მსგავსი.

212
00:17:51,600 --> 00:17:54,310
მე ვფიქრობ 99.

213
00:17:54,310 --> 00:17:57,580
ჰო, რადგან ის აპირებს პირველი -

214
00:18:12,880 --> 00:18:15,730
ასე 99.

215
00:18:15,730 --> 00:18:21,970
აქ (10/7), თუ ამ were C, რა, რომ დაბრუნდეს?

216
00:18:23,700 --> 00:18:29,630
[სტუდენტი] 1. >> Yeah, ეს იქნება 1, რადგან 10/7 არის გამყოფი 2 რიცხვებით.

217
00:18:29,630 --> 00:18:32,910
მთელი რიცხვი იყოფა მთელი რიცხვი დაბრუნებას აპირებს მთელი რიცხვი.

218
00:18:32,910 --> 00:18:37,750
იგი ვერ ბრუნდება 1 ქულა რასაც არ იქნება, ამიტომ უბრალოდ აპირებს დაბრუნებას 1.

219
00:18:37,750 --> 00:18:46,120
აქ ბეჭდვა (10/7); ის აპირებს რეალურად ინტერპრეტაცია რომ.

220
00:18:46,120 --> 00:18:53,760
ეს კი იმას ნიშნავს, რომ თუ თქვენ ნამდვილად გსურთ მთელი დამრგვალება და პერსონალის მოსწონს რომ,

221
00:18:53,760 --> 00:18:59,950
თქვენ გევალებათ ბეჭდვითი (სართული (10/7));

222
00:18:59,950 --> 00:19:08,460
In C ალბათ უცნაური, რომ შეგიძლიათ დაეყრდნოთ რიცხვი truncation რეგულარულად,

223
00:19:08,460 --> 00:19:12,260
მაგრამ PHP ვერ რადგან ეს ავტომატურად ჩართოთ იგი მიმოქცევაში.

224
00:19:13,430 --> 00:19:17,610
და მაშინ (7 + ნამდვილი); როგორ ფიქრობთ რომ აპირებს იყოს?

225
00:19:18,550 --> 00:19:23,640
მე გამოცნობა 8 თუ იგი ხდება ინტერპრეტაცია ჭეშმარიტი როგორც 1.

226
00:19:23,640 --> 00:19:25,740
როგორც ჩანს ეს 8.

227
00:19:25,740 --> 00:19:31,710
>> ასე რომ არაფერი ჩვენ გავაკეთეთ წარსულში 10 წუთში თქვენ უნდა აბსოლუტურად არ ვაკეთებთ.

228
00:19:31,710 --> 00:19:39,870
დაინახავთ კოდი, რომელიც აკეთებს ამას.

229
00:19:39,870 --> 00:19:42,700
იგი არ უნდა იყოს, როგორც პირდაპირი, როგორც ეს.

230
00:19:42,700 --> 00:19:47,240
თქვენ შეიძლება 2 ცვლადები და 1 variable ხდება იყოს სიმებიანი

231
00:19:47,240 --> 00:19:51,310
და სხვა variable ხდება იყოს int, და შემდეგ თქვენ დაამატოთ ეს ცვლადები ერთად.

232
00:19:51,310 --> 00:20:00,120
მას შემდეგ, PHP არის დინამიურად აკრეფილი და იგი ამას არ გააკეთებს ნებისმიერი ტიპის მოსინჯვის თქვენ

233
00:20:00,120 --> 00:20:03,640
და რადგან სუსტად აკრეფილი და რადგან ის მხოლოდ ავტომატურად გადაყარეთ ეს ყველაფერი ერთად

234
00:20:03,640 --> 00:20:11,490
და ყველაფერი მხოლოდ მუშაობს, ძნელია კი იცის, რომ ეს variable უნდა იყოს სიმებიანი ახლა,

235
00:20:11,490 --> 00:20:14,930
ასე რომ მე არ უნდა დაამატოთ ეს ამ ცვლადი, რომელიც არის მთელი რიცხვი.

236
00:20:18,780 --> 00:20:24,560
საუკეთესო პრაქტიკა თუ ცვლადი ტექსტი, შეინახოს იგი როგორც სიმებიანი სამუდამოდ.

237
00:20:24,560 --> 00:20:26,980
თუ ცვლადი int, შეინახოს იგი როგორც int სამუდამოდ.

238
00:20:26,980 --> 00:20:30,770
თუ გსურთ გაუმკლავდეთ რიცხვებით და სიმები,

239
00:20:30,770 --> 00:20:36,970
თქვენ შეგიძლიათ გამოიყენოთ varsint - რომ JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. მე ამის გაკეთება ყველა დროის. PHP და JavaScript მე აღრევას ყველაფერი.

241
00:20:42,520 --> 00:20:47,600
ამიტომ intval დაბრუნებას აპირებს რაც მთელი რიცხვი მიაღწევს ღირებულება ცვლადში.

242
00:20:47,600 --> 00:20:56,550
თუ ჩვენ კორიდორი "ბეჭდვის (intval ('123 ')); თქვენ 123.

243
00:21:06,820 --> 00:21:15,850
Intval თავად არ აპირებს გამშვები ჩვენთვის, რომ მხოლოდ მთელი რიცხვი.

244
00:21:15,850 --> 00:21:20,460
, PHP მექანიკური, არსებობს მხოლოდ ამდენი ფუნქციები ხელმისაწვდომია,

245
00:21:20,460 --> 00:21:26,560
ამიტომ აქ მე ვფიქრობ რა მინდა გამოყენება is_numeric პირველი.

246
00:21:26,560 --> 00:21:32,590
მე გამოცნობა რომ დაბრუნდა ყალბი.

247
00:21:32,590 --> 00:21:35,780
სწორედ სხვა რამ გვაქვს გასავლელი მეტი არის ===.

248
00:21:37,850 --> 00:21:44,020
ამიტომ is_numeric ('123df '), თქვენ არ ვფიქრობ, რომ როგორც is_numeric.

249
00:21:44,020 --> 00:21:46,720
In C თქვენ უნდა iterate ყველა გმირები

250
00:21:46,720 --> 00:21:50,410
და შეამოწმეთ, რომ თითოეული ხასიათი არის ციფრი ან რასაც.

251
00:21:50,410 --> 00:21:53,850
აქ is_numeric გაკეთებას აპირებს, რომ ჩვენთვის,

252
00:21:53,850 --> 00:21:56,520
და ეს დაბრუნების ცრუ.

253
00:21:56,520 --> 00:22:02,120
ასე რომ, როდესაც მე დაბეჭდილი, რომ იგი ნაბეჭდი არაფერი, ასე რომ აქ ვარ შედარებით მას ვხედავთ,

254
00:22:02,120 --> 00:22:05,490
did თქვენ მოხდეს იქნება ყალბი? და ა.შ. ახლა კი ბეჭდვა 1.

255
00:22:05,490 --> 00:22:10,060
როგორც ირკვევა ბეჭდავს 1 როგორც ჭეშმარიტი ნაცვლად ბეჭდვა ჭეშმარიტი როგორც ჭეშმარიტი.

256
00:22:10,060 --> 00:22:15,790
მაინტერესებს, თუ print_r. არა, ეს ჯერ კიდევ 1.

257
00:22:15,790 --> 00:22:26,760
>> ბრუნდება ===, == ისევ არსებობს,

258
00:22:26,760 --> 00:22:32,260
და თუ გაიგო Tommy მაშინ ამბობენ == სრულიად ჯარიმა.

259
00:22:32,260 --> 00:22:37,700
მე ვაპირებ ვთქვა, რომ == არის საშინელი და თქვენ არასდროს არ უნდა გამოიყენოს ==.

260
00:22:37,700 --> 00:22:44,870
განსხვავება ისაა, რომ == ადარებს რამ

261
00:22:44,870 --> 00:22:48,450
სადაც მას შეუძლია იყოს ჭეშმარიტი მაშინაც კი, თუ ისინი არ არის იგივე ტიპის,

262
00:22:48,450 --> 00:22:53,810
ხოლო === ადარებს რამ და პირველი ის ამოწმებს არიან ისინი იმავე ტიპის?

263
00:22:53,810 --> 00:22:58,010
დიახ. Okay, ახლა მე ვაპირებ თუ ისინი რეალურად შედარებით იყოს თანაბარი.

264
00:22:58,010 --> 00:23:08,890
თქვენ მიიღებთ უცნაური რამ, როგორიცაა 10 შეადგენს - ვნახოთ რა, რომ ამბობს.

265
00:23:08,890 --> 00:23:15,570
ასე რომ ('10 '== '1 E1');

266
00:23:15,570 --> 00:23:17,980
ეს დააბრუნებს true.

267
00:23:17,980 --> 00:23:21,420
ვინმეს აქვს რაიმე მიხვდება რატომ ბრუნდება მართალია?

268
00:23:25,180 --> 00:23:27,120
ეს არ არის მხოლოდ შესახებ, რომ. იქნებ ეს არის მინიშნება.

269
00:23:27,120 --> 00:23:33,170
მაგრამ თუ შევცვალო რომ ვ - darn ეს! მე შენარჩუნება გამოყენებით ორმაგი შეთავაზებები.

270
00:23:33,170 --> 00:23:38,780
ამის მიზეზი ორმაგი ფასები yelling at me არის, რადგან მე დააყენა ამ ორმაგ ბრჭყალებში.

271
00:23:38,780 --> 00:23:43,850
ასე რომ, მე კი გაქცევა მოახერხეს ორმაგი შეთავაზებები აქ, მაგრამ მარტოხელა შეთავაზებები გაუადვილოს.

272
00:23:43,850 --> 00:23:49,120
ასე რომ ('10 '== '1 F1'); არ ბეჭდვა ჭეშმარიტი. ('10 '== '1 E1'); ბეჭდავს ჭეშმარიტი.

273
00:23:49,120 --> 00:23:56,330
[სტუდენტი] ეს hex? >> ეს არ hex, მაგრამ ახლოს რომ მოსწონს -

274
00:23:56,330 --> 00:24:01,060
1e1, სამეცნიერო ნოტაცია.

275
00:24:01,060 --> 00:24:07,950
იგი აღიარებს 1e1 როგორც 1 * 10 ^ 1 ან რასაც.

276
00:24:07,950 --> 00:24:11,510
იმ თანაბარი რიცხვებით.

277
00:24:11,510 --> 00:24:15,930
თუ ასე === მაშინ იქნება ყალბი.

278
00:24:15,930 --> 00:24:28,490
მე რეალურად არ ვიცი, თუ რა == შესახებ (10 და '10abc '); ყველა უფლება. ასე რომ მართალია.

279
00:24:28,490 --> 00:24:35,940
ასე რომ ისევე როგორც მაშინ, როდესაც თქვენ გააკეთეთ (10 + '10abc '); და იქნებოდა 20,

280
00:24:35,940 --> 00:24:38,800
აქ (10 == '10abc '); მართალია.

281
00:24:38,800 --> 00:24:45,350
კიდევ უფრო უარესი არიან რამ, როგორიცაა (ყალბი == NULL); მართალია

282
00:24:45,350 --> 00:24:52,210
ან (ყალბი == 0); მართალია, (ყალბი == []);

283
00:24:52,210 --> 00:25:00,970
არსებობს უცნაური შემთხვევები - ეს ერთი იმ უცნაური შემთხვევები.

284
00:25:00,970 --> 00:25:08,110
გაითვალისწინეთ, რომ (ყალბი == []); მართალია.

285
00:25:08,110 --> 00:25:11,950
('0 '== ყალბი); მართალია.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); სიცრუეა.

287
00:25:16,090 --> 00:25:19,090
ასე == არ არის გარდამავალი.

288
00:25:19,090 --> 00:25:26,830
შეიძლება იყოს ტოლი ბ და შეიძლება იყოს ტოლი გ,

289
00:25:26,830 --> 00:25:29,340
მაგრამ ბ შეიძლება არ იყოს ტოლი გ.

290
00:25:29,340 --> 00:25:35,580
სწორედ უმსგავსოება ჩემთვის, და თქვენ ყოველთვის უნდა გამოიყენოს ===.

291
00:25:35,580 --> 00:25:38,590
[სტუდენტი] გავაკეთოთ? == ისევე? >> [Bowden] დიახ.

292
00:25:38,590 --> 00:25:44,600
ეკვივალენტი იქნება! = და, ==.

293
00:25:44,600 --> 00:25:48,230
ეს ფაქტობრივად აღიზარდოს ამ pset Spec

294
00:25:48,230 --> 00:25:52,000
აქ ბევრი ფუნქციები დაბრუნების -

295
00:25:52,000 --> 00:25:53,890
, PHP სახელმძღვანელო არის კარგი ამის შესახებ.

296
00:25:53,890 --> 00:25:59,140
იგი აყენებს დიდ წითელ ყუთში, "ეს დაბრუნდება ცრუ თუ არა რაიმე შეცდომა."

297
00:25:59,140 --> 00:26:03,940
მაგრამ დაბრუნების 0 არის შესანიშნავად გონივრული რამ დაბრუნებას.

298
00:26:03,940 --> 00:26:08,250
იფიქრეთ რაიმე ფუნქცია, რომელიც მოსალოდნელია დაბრუნების რიცხვი.

299
00:26:11,250 --> 00:26:17,880
ვთქვათ ეს ფუნქცია უნდა ქონოდა რაოდენობის ხაზები ფაილი ან რამე.

300
00:26:17,880 --> 00:26:23,490
ნორმალურ პირობებში, თქვენ გაივლით ამ ფუნქციის ფაილი

301
00:26:23,490 --> 00:26:27,120
და ის აპირებს დაბრუნებას მთელი რიცხვი რომელიც წარმოადგენს რიცხვი ხაზები.

302
00:26:27,120 --> 00:26:30,820
ასე რომ 0 არის შესანიშნავად გონივრული რაოდენობის თუ ფაილი არის მხოლოდ ცარიელი.

303
00:26:30,820 --> 00:26:36,810
მაგრამ რა, თუ თქვენ მსგავ ფაილის მცდარი და ფუნქცია ხდება დაბრუნების ცრუ

304
00:26:36,810 --> 00:26:38,860
თუ გაიაროს ეს არასწორი ფაილი?

305
00:26:38,860 --> 00:26:46,500
თუ თქვენ უბრალოდ == თქვენ არ გამიჯვნის შემთხვევაში შორის ფაილის მცდარი და ცარიელი ფაილი.

306
00:26:48,870 --> 00:26:51,350
ყოველთვის გამოიყენეთ ===.

307
00:26:55,690 --> 00:26:58,000
ეს იყო იმ.

308
00:26:58,000 --> 00:27:01,660
>> PHP-ში, მასივის ტიპის განსხვავდება თუ რას გამოიყენება in C.

309
00:27:01,660 --> 00:27:06,650
მართლაც, თქვენ შეიძლება უკვე შენიშნა ეს ზემოთ, როდესაც თქვენ ხედავთ, რომ ეს არის ტიპის მასივი.

310
00:27:06,650 --> 00:27:15,640
The bracket სინტაქსი არის ახალი როგორც PHP 5.4, რომელიც არის უახლესი ვერსია PHP.

311
00:27:15,640 --> 00:27:36,960
მანამდე კი თქვენ ყოველთვის ჰქონდა დაწერა array ('' -> 1, "ბ" -> 2.

312
00:27:36,960 --> 00:27:41,160
ეს იყო მშენებელი for მასივი.

313
00:27:41,160 --> 00:27:45,950
არის PHP საბოლოოდ მოდის გარშემო ლამაზი სინტაქსის მხოლოდ კვადრატულ ფრჩხილებში,

314
00:27:45,950 --> 00:27:50,900
რაც არის ბევრად უკეთესი, ვიდრე მასივი.

315
00:27:50,900 --> 00:27:54,480
მაგრამ იმის გათვალისწინებით, PHP 5.4 არის უახლესი ვერსია,

316
00:27:54,480 --> 00:27:59,090
თქვენ შეიძლება ექმნებათ ადგილებში, სადაც კი არ PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Over ზაფხულში ჩვენ შეუვარდნენ ამ საკითხზე, სადაც PHP 5.3 იყო ის, რაც ჩვენ გვქონდა on ელექტრო მოწყობილობების,

318
00:28:08,220 --> 00:28:14,480
მაგრამ სერვერზე რომ ჩვენ განლაგებული ყველა ჩვენი კლასის წიგნი და წარმოადგინოს და ყველა რომ პერსონალის to

319
00:28:14,480 --> 00:28:16,750
იყო PHP 5.4.

320
00:28:16,750 --> 00:28:23,060
არ იცოდა, ჩვენ განვითარებული 5.3, აიძულა to 5.4,

321
00:28:23,060 --> 00:28:25,660
და ახლა უეცრად არა ჩვენი კოდი მუშაობს

322
00:28:25,660 --> 00:28:28,680
რადგან იქ მოხდა უკვე ცვლილებების შორის 5.3 და 5.4

323
00:28:28,680 --> 00:28:31,030
რომლებიც არ არიან უკან თავსებადი,

324
00:28:31,030 --> 00:28:35,770
და ჩვენ უნდა წავიდეთ და დაფიქსირება ყველა ჩვენი რამ, რომ არ მუშაობენ PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
ამისთვის ამ კლასში, რადგან ელექტრო აქვს PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
ეს შესანიშნავად ჯარიმა გამოიყენოს კვადრატულ ფრჩხილებში.

327
00:28:47,240 --> 00:28:50,440
მაგრამ თუ თქვენ ეძებთ up რამ გარშემო ინტერნეტი,

328
00:28:50,440 --> 00:28:54,880
თუ თქვენ ეძებთ გარკვეული სახის მასივი პერსონალის, როგორც ჩანს, ვაპირებთ ვხედავ

329
00:28:54,880 --> 00:29:02,020
სიტყვიერად მასივი მშენებელი სინტაქსის მას შემდეგ უკვე გარშემო წლიდან PHP დაიბადა

330
00:29:02,020 --> 00:29:07,340
და კვადრატული ფრჩხილი სინტაქსის უკვე გარშემო, უკანასკნელი რამდენიმე თვის განმავლობაში

331
00:29:07,340 --> 00:29:10,020
ან როცა 5.4 მოვიდა გარშემო.

332
00:29:10,020 --> 00:29:12,710
ეს არის, თუ როგორ ინდექსი.

333
00:29:12,710 --> 00:29:30,610
ისევე, C, როგორ ინდექსი მიერ კვადრატულ ფრჩხილებში მსგავსად $ array [0] $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
თქვენ ინდექსი ანალოგიურად, თუ მოხდება თქვენი მაჩვენებლების მყოფი სტრიქონები.

335
00:29:36,320 --> 00:29:40,440
ასე რომ $ array [''] და $ array ['B'].

336
00:29:40,440 --> 00:29:47,410
$ Array [B]. რატომ უნდა იყოს ეს მიზეზი?

337
00:29:52,490 --> 00:29:59,870
ეს ალბათ გენერირება გაფრთხილება, მაგრამ მაინც გვემსახურება. PHP tends გაგვაჩნია.

338
00:29:59,870 --> 00:30:04,890
იგი აპირებს უბრალოდ, "მე ვაპირებ გაფრთხილებთ ამაში, მაგრამ მე უბრალოდ აპირებს შეინარჩუნოს აპირებს

339
00:30:04,890 --> 00:30:07,550
"და ნუ რასაც შემიძლია."

340
00:30:07,550 --> 00:30:11,500
ეს ალბათ თარგმნოს ეს ტექსტი,

341
00:30:11,500 --> 00:30:15,000
მაგრამ შესაძლებელია, რომ რაღაც მომენტში წარსულში ვინმე ამბობს

342
00:30:15,000 --> 00:30:20,180
განისაზღვროს B იქნება "Hello World".

343
00:30:20,180 --> 00:30:28,740
ახლა B შეიძლება იყოს მუდმივი და $ array [b] რეალურად უნდა აკეთებს "Hello World".

344
00:30:28,740 --> 00:30:32,380
ვფიქრობ, ამ ეტაპზე, ან თუნდაც ჩვენი PHP პარამეტრების,

345
00:30:32,380 --> 00:30:37,870
თუ თქვენ ცდილობენ ინდექსი შევიდა array და რომ გასაღები არ არსებობს, ამას ვერ.

346
00:30:37,870 --> 00:30:40,150
მე არ ვფიქრობ, ეს იქნება მხოლოდ გაფრთხილებთ.

347
00:30:40,150 --> 00:30:44,560
ან მინიმუმ შეგიძლიათ დააყენეთ ისე, რომ ეს სულაც არ არის მხოლოდ გაფრთხილებთ, ეს მხოლოდ სწორი მდე ვერ.

348
00:30:44,560 --> 00:30:49,290
>> გზა თქვენ შეამოწმეთ თუ რეალურად არის ასეთი ინდექსი არის isset.

349
00:30:49,290 --> 00:30:54,690
ამიტომ isset ($ array ['Hello World']) დაბრუნდება ცრუ.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['B']) დაბრუნდება ნამდვილი.

351
00:31:06,830 --> 00:31:09,880
თქვენ შეგიძლიათ ავურიოთ ამ syntaxes.

352
00:31:15,060 --> 00:31:22,440
მე საკმაოდ დარწმუნებული რა ამ მასივი რომ დასრულდება მდე მიმდინარეობს არის - ჩვენ შეგვიძლია შევამოწმოთ იგი out.

353
00:31:43,290 --> 00:31:45,700
ოჰ, მე უნდა PHPWord.

354
00:31:53,960 --> 00:32:00,260
ეს არის შერევას სინტაქსის სადაც თქვენ დააკონკრეტა, თუ რა არის გასაღები

355
00:32:00,260 --> 00:32:03,330
და თქვენ არ დააკონკრეტა, თუ რა არის გასაღები.

356
00:32:03,330 --> 00:32:05,520
ასე 3 უფლება აქ არის ღირებულება.

357
00:32:05,520 --> 00:32:08,080
თქვენ არ არის მკაფიოდ განაცხადა რა თავისი გასაღები იქნება.

358
00:32:08,080 --> 00:32:11,670
როგორ ფიქრობთ მის გასაღები აპირებს იყოს?

359
00:32:11,670 --> 00:32:21,410
[სტუდენტი] 0. >> მე გამოცნობა 0 მხოლოდ იმიტომ რომ პირველი ჩვენ არ არის მითითებული.

360
00:32:21,410 --> 00:32:23,500
ჩვენ შეგვიძლია მართლაც რამდენიმე ასეთ შემთხვევებში.

361
00:32:23,500 --> 00:32:28,030
ამიტომ print_r არის ბეჭდვის რეკურსიული. ეს იქნება ბეჭდვა მთელი მასივი.

362
00:32:28,030 --> 00:32:32,700
ეს იქნებოდა ბეჭდვა subarrays of array თუ იყო რაიმე.

363
00:32:32,700 --> 00:32:36,630
ამიტომ print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
ეს იმას ჰგავს ეს მისცა 0.

365
00:32:38,810 --> 00:32:43,530
არსებობს რეალურად რაღაც გვახსოვდეს, მაგრამ ჩვენ დავუბრუნდეთ მას მეორე.

366
00:32:43,530 --> 00:32:45,850
მაგრამ რა მოხდება თუ მე მოხდეს, რათა ეს მაჩვენებელი 1?

367
00:32:45,850 --> 00:32:51,170
PHP არ განსხვავდება ერთმანეთისგან სიმებიანი მაჩვენებლების და მთელი ინდექსები,

368
00:32:51,170 --> 00:33:00,280
ამრიგად, ამ ეტაპზე მე მხოლოდ განსაზღვრული ინდექსი 1 და შემიძლია ორივე $ array [1] და $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
და ეს იქნება ანალოგიური მაჩვენებელი და იგივე გასაღები.

370
00:33:06,250 --> 00:33:13,000
ახლა როგორ ფიქრობთ 3 აპირებს იყოს? >> [სტუდენტი] 2. >> [Bowden] მე გამოცნობა 2.

371
00:33:16,000 --> 00:33:18,690
Yeah. ეს 2.

372
00:33:18,690 --> 00:33:24,790
რა მოხდება, თუ ეს გავაკეთეთ არის 10, ეს არის 4? როგორ ფიქრობთ მაჩვენებელი 3 აპირებს იყოს?

373
00:33:27,360 --> 00:33:29,110
მე ვფიქრობ 11.

374
00:33:29,110 --> 00:33:33,060
ჩემი ამოიცნობთ, როგორი PHP აკეთებს - და ვფიქრობ მე ვნახე ამ ადრე -

375
00:33:33,060 --> 00:33:39,760
იგი მხოლოდ ინახება რა უმაღლესი რიცხვითი ინდექსის ის გამოიყენება იმდენად, რამდენადაც არის.

376
00:33:39,760 --> 00:33:44,230
არასდროს აპირებს დაავალოს სიმებიანი ინდექსი დან 3. ეს ყოველთვის იქნება რიცხვითი ინდექსი.

377
00:33:44,230 --> 00:33:47,690
ასე რომ ინახება უმაღლესი ერთი ის ენიჭება ჯერჯერობით, რომელიც ხდება უნდა იყოს 10,

378
00:33:47,690 --> 00:33:52,540
და ის აპირებს 11 დან 3.

379
00:33:52,540 --> 00:34:02,110
რა ვთქვი, შეამჩნია გზა იგი ბეჭდვა ამ მასივი.

380
00:34:02,110 --> 00:34:06,850
იგი ბეჭდავს გასაღები 10, გასაღები 4, გასაღები 11, გასაღები დ.

381
00:34:06,850 --> 00:34:09,790
ან თუნდაც მოდით -

382
00:34:15,760 --> 00:34:22,489
ვფიქრობ მე არ დააყენოს 0, მაგრამ ბეჭდვა 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
რა მოხდება თუ მე გადართოთ აქ? ან მოდით რეალურად გადართოთ ეს 2.

384
00:34:29,330 --> 00:34:31,940
ახლა კი ბეჭდავს 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
PHP-ს კოლექტორები არ არიან, ისევე, როგორც თქვენი რეგულარული hash მაგიდასთან.

386
00:34:41,270 --> 00:34:45,570
ეს შესანიშნავად გონივრული ვიფიქროთ, მათ hash მაგიდები 99% დაფიქსირდა.

387
00:34:45,570 --> 00:34:53,790
მაგრამ თქვენს hash მაგიდები არ გრძნობა წესრიგზე, რომლის ნივთები ჩასმული.

388
00:34:53,790 --> 00:34:56,639
ამიტომ, როგორც კი თქვენ ჩადეთ იგი თქვენი hash მაგიდა,

389
00:34:56,639 --> 00:35:00,590
ვივარაუდოთ, არ უკავშირდება სიაში და შეგიძლიათ იმსჯელოთ ფარგლებში უკავშირდება სია

390
00:35:00,590 --> 00:35:03,980
რომელიც ჩასმული პირველი.

391
00:35:03,980 --> 00:35:10,060
მაგრამ აქ ჩვენ ჩასმული 2 პირველი და იგი დარწმუნებულია, როცა ეს დაბეჭდვისას მასივისათვის რომ 2 მოდის პირველი.

392
00:35:10,060 --> 00:35:13,090
იგი არ ამობეჭდოთ მხოლოდ გარეშე.

393
00:35:13,090 --> 00:35:17,550
ტექნიკური მონაცემები სტრუქტურის, რომ ის გამოყენებით არის უბრძანა რუკა,

394
00:35:17,550 --> 00:35:24,690
ასე რომ რუკები გასაღებები ღირებულებებს და მას ახსოვს წესრიგზე, რომლის იმ გასაღებები were ჩასმული.

395
00:35:24,690 --> 00:35:31,600
ძირითადად ეს ზოგიერთ გართულებები, სადაც ეს შემაშფოთებელი რეალურად -

396
00:35:31,600 --> 00:35:34,510
ვთქვათ თქვენ გაქვთ მასივი 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
და გსურთ აიღოს ინდექსი 2.

398
00:35:37,700 --> 00:35:47,750
ერთი გზა ამის გაკეთება, ვნახოთ რა, რომ ჰგავს.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
ამორთვისთვის ხდება ამორთვისთვის ორივე ცვლადები და array ინდექსების.

401
00:35:54,880 --> 00:35:58,630
ამიტომ ამორთვისთვის ($ array [2]);

402
00:35:58,630 --> 00:36:03,430
ახლა რა არის ეს აპირებს გამოიყურებოდეს მოგწონთ? 2 მხოლოდ წასული, ასე რომ შესანიშნავად ჯარიმა.

403
00:36:03,430 --> 00:36:11,670
სხვა შემაშფოთებელი არის თუ გინდათ რამ რეალურად იყოს მასივი.

404
00:36:11,670 --> 00:36:14,910
მე დააყენა შემთხვევითი რიცხვების.

405
00:36:14,910 --> 00:36:20,400
ახლა შეამჩნია ჩემი მაჩვენებლების.

406
00:36:20,400 --> 00:36:26,860
მინდა მას უბრალოდ იყოს C მასივი, სადაც იგი მიემართება 0 სიგრძე - 1

407
00:36:26,860 --> 00:36:30,810
და შემიძლია iterate მას, როგორც ასეთი.

408
00:36:30,810 --> 00:36:38,520
მაგრამ როგორც კი ამორთვისთვის მეორე ინდექსი, რა იყო ინდექსი 3 არ არის გახდეს ინდექსი 2.

409
00:36:38,520 --> 00:36:44,790
ამის ნაცვლად უბრალოდ შლის, რომ ინდექსი და ახლა მიდიხარ 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
ეს არის იდეალურად გონივრული.

411
00:36:48,740 --> 00:36:53,950
უბრალოდ შემაშფოთებელი და თქვენ უნდა გააკეთოთ რამ, როგორიცაა მასივი splice. Yeah.

412
00:36:53,950 --> 00:36:57,200
>> [სტუდენტი] რა მოხდება, თითქოს ამისთვის loop

413
00:36:57,200 --> 00:36:59,630
და თქვენ უნდოდა ყველა ელემენტები?

414
00:36:59,630 --> 00:37:02,290
როდესაც იგი მოხვდა 2, რომ ეს გამოიღო ოდესმე?

415
00:37:02,290 --> 00:37:10,150
Iterating მეტი მასივი. 2 გზა არსებოსბს თქვენ შეგიძლიათ ეს გააკეთოთ.

416
00:37:10,150 --> 00:37:12,770
თქვენ შეგიძლიათ გამოიყენოთ რეგულარული ამისთვის loop.

417
00:37:12,770 --> 00:37:22,000
ეს არის კიდევ ერთი intricacy of PHP.

418
00:37:22,000 --> 00:37:27,420
ყველაზე ენებზე, მე ვიტყოდი, აქვს გარკვეული სიგრძის ან len ან რამე

419
00:37:27,420 --> 00:37:30,470
მითითებით სიგრძეზე მასივი.

420
00:37:30,470 --> 00:37:32,820
PHP-ში ეს რაოდენობა.

421
00:37:32,820 --> 00:37:36,160
ასე რომ ჯამში ($ array); $ i + +)

422
00:37:36,160 --> 00:37:42,950
მოდით უბრალოდ ბეჭდვის ($ array [$ i]);

423
00:37:45,920 --> 00:37:48,820
Notice: Undefined offset: 2.

424
00:37:48,820 --> 00:37:51,610
უბრალოდ აპირებს ჩავარდება.

425
00:37:51,610 --> 00:38:03,020
ეს არის მიზეზი, რომ დიდი ნაწილი, თქვენ არასოდეს უნდა iterate მეტი მასივი მოსწონს ეს.

426
00:38:03,020 --> 00:38:07,110
ეს შეიძლება იყოს გადაჭარბებული, მაგრამ თქვენ არასოდეს უნდა iterate მეტი მასივი მოსწონს

427
00:38:07,110 --> 00:38:19,410
რადგან PHP უზრუნველყოფს მის foreach სინტაქსი აქ foreach ($ წყობის $ პუნქტში).

428
00:38:19,410 --> 00:38:31,830
ახლა თუ ჩვენ ბეჭდვა ($ item); - we'll განიხილოს იგი მეორე - რომ მუშაობს შესანიშნავად ჯარიმა.

429
00:38:31,830 --> 00:38:38,960
ისე, რომ foreach მუშაობს არის პირველი არგუმენტი არის array, რომ თქვენ iterating დასრულდა.

430
00:38:38,960 --> 00:38:44,060
და მეორე არგუმენტი, ნივთი, მეშვეობით თითოეულ უღელტეხილზე ამისთვის loop

431
00:38:44,060 --> 00:38:52,690
ის აპირებს მომდევნო რამ მასივი. ასე გვახსოვს მასივი აქვს წესრიგს.

432
00:38:52,690 --> 00:38:55,690
პირველად მეშვეობით ამისთვის მარყუჟის, item იქნება 123

433
00:38:55,690 --> 00:38:59,540
მაშინ ეს იქნება 12 მაშინ ეს იქნება 13 მაშინ ეს იქნება 23 მაშინ ეს იქნება 213.

434
00:38:59,540 --> 00:39:04,670
რამ მისაღებად ნამდვილად უცნაური როცა რაღაც foreach.

435
00:39:04,670 --> 00:39:07,480
ვნახოთ რა ხდება იმიტომ, რომ თქვენ არასოდეს არ უნდა ამის გაკეთება.

436
00:39:07,480 --> 00:39:13,320
რა მოხდება, თუ ჩვენ ამორთვისთვის ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
ამის ალბათ მოსალოდნელია.

438
00:39:26,030 --> 00:39:30,950
თქვენ iterating ამ მასივი, და ყოველ ჯერზე თქვენ unsetting პირველი ინდექსი.

439
00:39:30,950 --> 00:39:39,720
ასე რომ ინდექსი 0, პირველი, რაც, item იღებს ღირებულების 0, ამიტომ იქნება 123.

440
00:39:39,720 --> 00:39:44,630
მაგრამ შიგნით ამისთვის loop ჩვენ ამორთვისთვის ინდექსი 1, ასე რომ იმას ნიშნავს, 12 გაქრა.

441
00:39:44,630 --> 00:39:57,480
ამიტომ ბეჭდვა. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL მხოლოდ სტრიქონების გადატანით, მაგრამ ეს ტექნიკურად უფრო პორტატული

443
00:40:03,580 --> 00:40:08,890
რადგან newlines in Windows განსხვავდება newlines on Mac და UNIX.

444
00:40:08,890 --> 00:40:18,040
On Windows სტრიქონების გადატანით არის \ r \ n, ხოლო ყველგან მას tends უბრალოდ უნდა იყოს \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL არის კონფიგურირებული ისე, რომ იგი იყენებს რასაც სტრიქონების გადატანით თქვენი სისტემა.

446
00:40:25,150 --> 00:40:29,310
ასე რომ ბეჭდვა. ნუ print_r ($ array) დასასრულისათვის.

447
00:40:32,830 --> 00:40:37,390
არ მქონდა იდეა, რომ ეს იქნება ქცევა.

448
00:40:41,740 --> 00:40:48,960
საქონელი კვლავ იღებს ღირებულება 12 მიუხედავად იმისა, რომ ჩვენ ამორთვისთვის 12 სანამ ჩვენ ოდესმე მიიღო, რათა მას მასივი.

449
00:40:52,770 --> 00:40:58,840
არ მიიღოს სიტყვას ამ, მაგრამ ეს ჰგავს foreach ქმნის ასლი მასივი

450
00:40:58,840 --> 00:41:02,160
და შემდეგ პუნქტში იღებს ყველა ღირებულებებს რომ ასლი.

451
00:41:02,160 --> 00:41:07,760
ასე რომ, თუნდაც ცვლილებები მასივი შიგნით ამისთვის მარყუჟის,

452
00:41:07,760 --> 00:41:17,240
ეს არ აღელვებს. საქონელი მიიღებს on ორიგინალური ღირებულებებს.

453
00:41:17,240 --> 00:41:19,240
მოდით ვეცადოთ unsetting იგი.

454
00:41:19,240 --> 00:41:24,460
რა მოხდება, თუ ეს $ array [1] = "Hello";

455
00:41:24,460 --> 00:41:31,770
მიუხედავად იმისა, რომ ჩვენ "Hello" შევიდა მასივი, item არასოდეს იღებს, რომ ღირებულება.

456
00:41:31,770 --> 00:41:37,430
არსებობს კიდევ ერთი სინტაქსი უნდა foreach მარყუჟების

457
00:41:37,430 --> 00:41:45,900
სადაც თქვენ დააყენა 2 ცვლადები გამოყოფილი arrow.

458
00:41:45,900 --> 00:41:49,680
ეს პირველი ცვლადი იქნება გასაღები, რომ ღირებულება,

459
00:41:49,680 --> 00:41:53,050
და ეს მეორე ცვლადი იქნება იგივე ზუსტი ნივთი.

460
00:41:53,050 --> 00:42:01,610
ეს არის uninteresting აქ, მაგრამ თუ ჩვენ დავუბრუნდებით ჩვენი ორიგინალური შემთხვევაში '' -> 1,

461
00:42:01,610 --> 00:42:06,090
"ბ" -> 1,

462
00:42:06,090 --> 00:42:14,470
აქ თუ ჩვენ მხოლოდ iterate თითოეული წყობის პუნქტის, ნივთი იქნება 1 ყველა დროის.

463
00:42:14,470 --> 00:42:18,170
მაგრამ თუ ჩვენ ასევე გვინდა ვიცოდეთ გასაღები ასოცირდება, რომ ნივთი

464
00:42:18,170 --> 00:42:25,230
შემდეგ ვაკეთებთ, როგორც $ გასაღები -> $ ნივთი.

465
00:42:25,230 --> 00:42:31,980
ახლა ჩვენ შეგვიძლია გავაკეთოთ ბეჭდვითი ($ გასაღები. ':'.

466
00:42:31,980 --> 00:42:39,380
ახლა კი iterating მეტი და დაბეჭდვის თითოეული გასაღები და მისი ასოცირდება ღირებულება.

467
00:42:39,380 --> 00:42:47,030
>> დამატებითი რამ შეგვიძლია გავაკეთოთ foreach მარყუჟების არის თქვენ შეიძლება ნახოთ ამ სინტაქსს.

468
00:42:47,030 --> 00:42:54,770
Ampersands ადრე ცვლადი სახელები ტენდენცია იყოს როგორ PHP ს ცნობას.

469
00:42:54,770 --> 00:43:00,460
სად ცნობას ძალიან ჰგავს პოინტერები,

470
00:43:00,460 --> 00:43:04,820
თქვენ არ გჭირდებათ, ასე რომ თქვენ არასოდეს გაუმკლავდეთ მეხსიერების პირდაპირ.

471
00:43:04,820 --> 00:43:12,620
მაგრამ თუ თქვენ ჩვენგან აქვს რეკომენდაციები ვისგანაც 1 ცვლადი ეხება იგივე მორიგ ცვლადი.

472
00:43:12,620 --> 00:43:21,450
შიგნით აქ მოდით $ ნივთი. მოდით დავუბრუნდეთ 1, 10.

473
00:43:21,450 --> 00:43:28,800
მოდით $ ნივთი + +, რომ ჯერ კიდევ არსებობს PHP. შეგიძლიათ ისევ გავაკეთებთ + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. მე უნდა დაბეჭდეთ. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
ჩვენ ბეჭდვა 2, 11.

476
00:43:42,730 --> 00:43:49,560
თუ ვიყავი გაკეთდეს foreach ($ წყობის $ ნივთი), მაშინ ნივთი იქნება ღირებულება 1

477
00:43:49,560 --> 00:43:54,190
პირველად მეშვეობით loop. ეს იქნება ნამატი 1 დან 2 და შემდეგ ჩვენ გავაკეთეთ.

478
00:43:54,190 --> 00:43:57,260
ასე რომ მაშინ გაივლის მეორე უღელტეხილზე მარყუჟის და რომ საქონელი 10.

479
00:43:57,260 --> 00:44:01,570
ეს increments ელემენტის 11, და შემდეგ ეს მხოლოდ დააგდეს დაშორებით.

480
00:44:01,570 --> 00:44:06,670
მაშინ ჩვენ print_r ($ array); და ვნახოთ, რომ ეს არის მხოლოდ 1, 10.

481
00:44:06,670 --> 00:44:09,070
ამიტომ ნამატი გავაკეთეთ დაიკარგა.

482
00:44:09,070 --> 00:44:13,410
მაგრამ foreach ($ წყობის & $ item)

483
00:44:13,410 --> 00:44:21,910
ახლა ეს საქონელი იმავე საგანს როგორც ამ უფლების აქ. ეს იგივე.

484
00:44:21,910 --> 00:44:26,820
ასე რომ $ ნივთი + + არის შეცვლის მასივი 0.

485
00:44:29,330 --> 00:44:41,850
ძირითადად, ასევე, შეგიძლიათ ამის გაკეთება $ K -> $ ნივთი და შეგიძლიათ გააკეთოთ $ array [$ K] + +;

486
00:44:41,850 --> 00:44:48,650
>> ასე რომ სხვა გზა კეთების რომ, ჩვენ თავისუფლად ცვლილებები პუნქტის,

487
00:44:48,650 --> 00:44:54,070
მაგრამ, რომ არ ცვლილებები ჩვენი ორიგინალური მასივი.

488
00:44:54,070 --> 00:44:59,720
მაგრამ თუ ჩვენ ვიყენებთ K, რომელიც ჩვენი გასაღები, მაშინ ჩვენ შეგვიძლია მხოლოდ ინდექსი ჩვენს მასივი გამოყენებით რომ გასაღები

489
00:44:59,720 --> 00:45:01,530
და წუთობრივი რომ.

490
00:45:01,530 --> 00:45:05,410
ეს უფრო პირდაპირ modifies ჩვენი ორიგინალური მასივი.

491
00:45:05,410 --> 00:45:10,690
თქვენ კი ასე თუ რაიმე მიზეზით თქვენ სურდა უნარი ცვლილებები -

492
00:45:10,690 --> 00:45:13,510
სინამდვილეში, ეს სრულიად სამართლიანია.

493
00:45:13,510 --> 00:45:16,020
თქვენ არ სურს უნდა დაწეროს $ array [$ K] + +,

494
00:45:16,020 --> 00:45:27,890
უბრალოდ სურდა დაეწერა $ ნივთი + +, მაგრამ თქვენ ისევ უნდოდა იმის თქმა, თუ ($ K === '')

495
00:45:27,890 --> 00:45:30,620
მაშინ ნამატი ნივთი და შემდეგ ბეჭდვა ჩვენი მასივი.

496
00:45:30,620 --> 00:45:36,290
ახლა რას ველოდოთ print_r ვაკეთოთ? რა ღირებულებებს უნდა იყოს დაბეჭდილი?

497
00:45:36,290 --> 00:45:43,770
[სტუდენტი] 2 და 10. >> [Bowden] თუ გასაღები იყო '' ჩვენ რეალურად ბეჭდვა რომ.

498
00:45:51,940 --> 00:45:55,670
>> ალბათ ძალიან იშვიათად, თუ ოდესმე, უნდა განისაზღვროს ფუნქციების PHP,

499
00:45:55,670 --> 00:46:03,370
მაგრამ თქვენ ალბათ შეამჩნევთ რაიმე მსგავსი, სადაც თქვენ განსაზღვროს ფუნქცია მოსწონს ფუნქცია რასაც.

500
00:46:03,370 --> 00:46:09,900
ჩვეულებრივ თქვენ ვიტყოდი ($ foo, $ ბარი) და შემდეგ განსაზღვრავს, რომ იყოს რასაც.

501
00:46:09,900 --> 00:46:17,580
მაგრამ, თუ ეს, მაშინ ეს ნიშნავს, რომ რაც არ უნდა უწოდებს რასაც,

502
00:46:17,580 --> 00:46:25,110
რასაც მოუწოდებს baz, ამიტომ პირველი არგუმენტი გადასცა baz შეიძლება შეიცვალოს.

503
00:46:25,110 --> 00:46:38,100
მოდით $ foo + +;

504
00:46:38,100 --> 00:46:48,020
და შიგნით აქ მოდით baz ($ item);

505
00:46:48,020 --> 00:46:52,250
ახლა ჩვენ მოუწოდებენ ფუნქცია.

506
00:46:52,250 --> 00:46:56,780
არგუმენტი იღებს მინიშნება, რაც იმას ნიშნავს, რომ თუ ჩვენ ცვლილებები მას

507
00:46:56,780 --> 00:47:00,390
ჩვენ შეცვლის, რაც მიღებულ იქნა შემოსული

508
00:47:00,390 --> 00:47:04,420
და ბეჭდვა ამ ველოდოთ - სანამ არ არევა სინტაქსი - მივიღეთ 2, 11,

509
00:47:04,420 --> 00:47:06,300
ასე რომ რეალურად incremented.

510
00:47:06,300 --> 00:47:08,790
Notice გვჭირდება წყარო 2 ადგილებში.

511
00:47:08,790 --> 00:47:13,050
რა მე რომ ამ საკითხთან დაკავშირებით? რას ნიშნავს ეს?

512
00:47:13,050 --> 00:47:15,810
[სტუდენტი] ეს შეიცვლება. >> Yeah.

513
00:47:15,810 --> 00:47:18,290
საქონელი არის მხოლოდ ასლი ღირებულების მასივი.

514
00:47:18,290 --> 00:47:26,670
ასე რომ ნივთი შეიცვლება 2, მაგრამ array [''] მაინც 1.

515
00:47:26,670 --> 00:47:32,560
ან რა რომ ამის გაკეთება?

516
00:47:32,560 --> 00:47:39,260
არის ნივთი იგზავნება როგორც ასლი baz.

517
00:47:39,260 --> 00:47:46,330
ამიტომ ასლი არგუმენტი იქნება incremented 2,

518
00:47:46,330 --> 00:47:49,240
მაგრამ ნივთი თავისთავად არასოდეს incremented დან 2.

519
00:47:49,240 --> 00:47:52,880
და საქონელი იგივე როგორც მასივი bracket რასაც,

520
00:47:52,880 --> 00:47:55,380
ასე რომ მასივი არასოდეს incremented.

521
00:47:55,380 --> 00:47:57,960
ასე რომ ორივე იმ ადგილებში სჭირდება.

522
00:47:57,960 --> 00:48:03,830
>> PHP ჩვეულებრივ საკმაოდ ჭკვიანი ამის შესახებ.

523
00:48:03,830 --> 00:48:06,570
თქვენ ალბათ ფიქრობთ, მინდა გაივლის მიერ მინიშნება -

524
00:48:06,570 --> 00:48:09,560
ეს იყო რეალურად საკითხი ერთ psets.

525
00:48:09,560 --> 00:48:14,480
ეს იყო questions.txt რამ, სადაც იგი ამბობს,

526
00:48:14,480 --> 00:48:19,280
რატომ შეიძლება გსურთ გაივლის ამ struct მიერ მინიშნება?

527
00:48:19,280 --> 00:48:21,250
რა იყო პასუხი ამაზე?

528
00:48:21,250 --> 00:48:25,100
[სტუდენტი] ასე რომ თქვენ არ უნდა კოპირება რაღაც დიდი. >> Yeah.

529
00:48:25,100 --> 00:48:32,920
Struct შეიძლება თვითნებურად დიდი, და როდესაც თქვენ გაივლით struct როგორც არგუმენტი

530
00:48:32,920 --> 00:48:36,800
მას სჭირდება კოპირება რომ მთელი struct გავლა მას ფუნქცია,

531
00:48:36,800 --> 00:48:40,410
ხოლო თუ თქვენ უბრალოდ გაივლის struct მიერ მინიშნება

532
00:48:40,410 --> 00:48:46,530
მაშინ უბრალოდ სჭირდება კოპირება 4-byte მისამართი როგორც არგუმენტი ფუნქცია.

533
00:48:48,520 --> 00:48:52,320
PHP არის ცოტა სასურველი სტუმარი გახდებით ვიდრე ამას.

534
00:48:52,320 --> 00:49:00,650
თუ მაქვს ზოგიერთი ფუნქცია და მე გაივლის მას მასივი 1,000 ნივთები,

535
00:49:00,650 --> 00:49:03,990
ნიშნავს ეს ის აპირებს კოპირება ყველა 1,000 იმ რამ

536
00:49:03,990 --> 00:49:10,450
უნდა გაიაროს ეს შევიდა ფუნქცია? ეს არ უნდა გავაკეთოთ, რომ დაუყოვნებლივ.

537
00:49:10,450 --> 00:49:15,940
თუ შიგნით ამ ფუნქციის მას არასოდეს რეალურად modifies foo,

538
00:49:15,940 --> 00:49:22,660
ასე რომ, თუ ($ foo === 'მიესალმები') იქნება TRUE.;

539
00:49:22,660 --> 00:49:26,460
გაითვალისწინეთ ჩვენ არასოდეს რეალურად შეცვლილია არგუმენტი შიგნით ამ ფუნქციას,

540
00:49:26,460 --> 00:49:30,010
რაც იმას ნიშნავს, რომ რაც მიღებულ იქნა საქართველოს, როგორც არასდროს foo საჭიროებს გადაწერილი

541
00:49:30,010 --> 00:49:32,100
რადგან ეს არ შეცვლის მას.

542
00:49:32,100 --> 00:49:39,240
ასე რომ გზა PHP სამუშაოების არგუმენტები ყოველთვის გაიარა მინიშნება

543
00:49:39,240 --> 00:49:42,170
სანამ თქვენ ნამდვილად ცდილობენ ცვლილებები მას.

544
00:49:42,170 --> 00:49:51,160
ახლა თუ ვიტყვი $ foo + +, ეს ახლა მიიღოს ასლი ორიგინალური foo და ცვლილებები ასლი.

545
00:49:51,160 --> 00:49:53,090
ეს ზოგავს გარკვეული დრო.

546
00:49:53,090 --> 00:49:58,210
თუ თქვენ არასდროს არ ეხება ამ მასიური მასივი, არასოდეს რეალურად ცვლილებები ის,

547
00:49:58,210 --> 00:50:02,360
მას არ დასჭირდება, რათა ასლი,

548
00:50:02,360 --> 00:50:06,640
ხოლო თუ ჩვენ უბრალოდ დააყენა ამ ampersand რაც იმას ნიშნავს, რომ ეს კი არ კოპირება

549
00:50:06,640 --> 00:50:08,640
მაშინაც კი, თუ თქვენ ჩვენგან ცვლილებები მას.

550
00:50:08,640 --> 00:50:10,680
ეს ქცევა ეწოდება ასლი-on-ჩაწერის.

551
00:50:10,680 --> 00:50:17,380
თქვენ ნახავთ მას სხვა ადგილებში, მით უფრო ოპერაციული სისტემის რა თქმა უნდა.

552
00:50:17,380 --> 00:50:23,880
Copy-on-ჩაწერის არის საკმაოდ ჩვეულებრივი ნიმუში სადაც თქვენ არ უნდა მიიღოს ასლი რაღაც

553
00:50:23,880 --> 00:50:26,650
თუ ეს სინამდვილეში იცვლება. Yeah.

554
00:50:26,650 --> 00:50:29,520
[სტუდენტი] რა თუ ჰქონდა ნამატი შიგნით ტესტი,

555
00:50:29,520 --> 00:50:33,700
ასე მხოლოდ 1 ელემენტს გარეთ 1,000 იქნებოდა საჭიროებს შეიცვალა?

556
00:50:33,700 --> 00:50:38,770
მე არ ვარ დარწმუნებული.

557
00:50:38,770 --> 00:50:51,250
მე ვფიქრობ, რომ კოპირება მთელი რამ, მაგრამ ეს შესაძლებელია ეს ჭკვიანი საკმარისი, რომ -

558
00:50:51,250 --> 00:51:00,020
სინამდვილეში, რა მე ვფიქრობ არის წარმოიდგინეთ გვქონდა მასივი, რომ ასე გამოიყურება: $ array2 = [

559
00:51:00,020 --> 00:51:11,000
მაშინ ინდექსი '' არის მასივი [1 2 3 4], და ინდექსი "ბ" არის მასივი რასაც.

560
00:51:11,000 --> 00:51:15,380
მჭირდება მძიმეები შორის ყველა იმ. წარმოიდგინეთ არსებობს მძიმეები.

561
00:51:15,380 --> 00:51:21,210
მაშინ 'c' არის ღირებულება 3.

562
00:51:24,210 --> 00:51:26,290
Okay.

563
00:51:26,290 --> 00:51:33,440
ახლა ვთქვათ ვაკეთებთ $ baz ($ array2);

564
00:51:33,440 --> 00:51:36,540
აქ baz არ იღებს ამ მიერ მითითება.

565
00:51:43,510 --> 00:51:47,370
ასე რომ $ foo ['გ'] + +;

566
00:51:47,370 --> 00:51:52,340
ეს არის ასეთი მაგალითი, სადაც ჩვენ გადიან array2 როგორც არგუმენტი

567
00:51:52,340 --> 00:51:57,010
და მაშინ შეცვლის კონკრეტული მაჩვენებელი მასივი მიერ დამატება იგი.

568
00:51:57,010 --> 00:52:01,090
მე ნამდვილად არ ვიცი რა PHP გაკეთებას აპირებს.

569
00:52:01,090 --> 00:52:07,200
ეს შეიძლება ადვილად ასლი მთელი რამ, მაგრამ თუ ეს ჭკვიანი,

570
00:52:07,200 --> 00:52:15,030
ის გააკეთებს ასლი ამ გასაღებები, სადაც ეს ექნება თავისი განსხვავებული ღირებულება

571
00:52:15,030 --> 00:52:20,620
მაგრამ ეს ჯერ კიდევ აღვნიშნო, რომ იგივე მასივი 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
და ეს შეიძლება კვლავ აღვნიშნავთ, რომ იგივე მასივი.

573
00:52:22,320 --> 00:52:24,170
მე iPad იგი.

574
00:52:28,900 --> 00:52:45,950
ჩვენ გაივლის ამ მასივი, სადაც ეს ბიჭი ქულა 3, ამ ბიჭს მიუთითებს [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
ამ ბიჭს მიუთითებს [34, ...]

576
00:52:51,350 --> 00:52:58,590
არის, რომ ჩვენ ავლით მას უნდა baz, ჩვენ შეცვლის ამ.

577
00:52:58,590 --> 00:53:03,550
თუ PHP არის ჭკვიანი, მას შეუძლია უბრალოდ -

578
00:53:11,850 --> 00:53:18,230
ჩვენ ჯერ კიდევ კოპირება გარკვეული მეხსიერება, მაგრამ თუ იყო ამ დიდი წყობილი subarrays

579
00:53:18,230 --> 00:53:21,560
ჩვენ არ გვჭირდება კოპირება იმ.

580
00:53:21,560 --> 00:53:27,530
მე არ ვიცი, თუ არის ის, რაც ეს ასეა, მაგრამ მე წარმომიდგენია ეს აკეთებს, რომ.

581
00:53:29,050 --> 00:53:36,690
ეს არის ასევე საკმაოდ დიდი უპირატესობა C ზე PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP ხდის ცხოვრება იმდენად ადვილი ბევრი რამ,

583
00:53:40,320 --> 00:53:45,060
მაგრამ თქვენ სახის აბსოლუტურად წარმოდგენა არ რამდენად კარგად ეს შეასრულებს

584
00:53:45,060 --> 00:53:52,530
რადგან არ ვიცი ქვეშ Hood როცა ეს მიღების ეს ასლები რამ,

585
00:53:52,530 --> 00:53:55,170
OH, რომ იქნება მუდმივი დრო ასლი,

586
00:53:55,170 --> 00:54:01,140
არის უბრალოდ შეიცვლება 1 კურსორი, იგი იქნება ridiculously რთული ხაზოვანი ასლი?

587
00:54:01,140 --> 00:54:03,000
მერე რა, რომ ვერ პოულობენ მოცულობა?

588
00:54:03,000 --> 00:54:06,760
ამჯამად მაშინ უნდა აწარმოებს ნაგვის შეგროვების მივიღოთ მეტი სივრცე?

589
00:54:06,760 --> 00:54:11,210
და ნაგვის შეგროვების შეუძლია თვითნებურად ხანგრძლივი.

590
00:54:11,210 --> 00:54:13,600
In C თქვენ არ ფიქრი ეს ყველაფერი.

591
00:54:13,600 --> 00:54:19,780
თითოეული ხაზი წერთ თქვენ შეგიძლიათ საკმაოდ ბევრი მიზეზი, თუ როგორ ის აპირებს შეასრულოს.

592
00:54:26,800 --> 00:54:29,150
>> მოდით ვიხსენებთ ამ.

593
00:54:35,400 --> 00:54:37,520
როგორ ლამაზი არის ის, რომ თქვენ არ უნდა გაუმკლავდეთ hash ფუნქციები,

594
00:54:37,520 --> 00:54:39,010
უკავშირდება სიები, ან არაფერი ასე?

595
00:54:39,010 --> 00:54:41,980
წლიდან მუშაობს hash მაგიდები არის ადვილი არის, აქ არის სახალისო თავსატეხი მუშაობა.

596
00:54:41,980 --> 00:54:45,920
გახსენით ფაილი სახელად unique.php და მასში წერენ PHP პროგრამა

597
00:54:45,920 --> 00:54:48,330
(ასევე ცნობილი როგორც "Script").

598
00:54:48,330 --> 00:54:55,700
ჩვენ გვსურს წავახალისოთ მოვუწოდებთ მათ სკრიპტები თუ ისინი მოკლე რამ, რომ თქვენ აწარმოებს ბრძანებათა ზოლს.

599
00:54:55,700 --> 00:55:02,950
ძირითადად, ნებისმიერ ენაზე, რომ თქვენ არ კომპილირდება მაგრამ თქვენ აპირებთ აწარმოებს შესრულებადი

600
00:55:02,950 --> 00:55:05,920
ბრძანებათა ზოლს, შეგიძლიათ დარეკოთ, რომ შესრულებადი Script.

601
00:55:05,920 --> 00:55:08,510
შემეძლო მხოლოდ ასევე წერენ C პროგრამა, რომელიც აკეთებს ამას,

602
00:55:08,510 --> 00:55:12,300
მაგრამ მე არ ეძახით Script რადგან მე პირველი კომპილირება და შემდეგ აწარმოებს ორობითი.

603
00:55:12,300 --> 00:55:15,480
მაგრამ ეს პროგრამა PHP ჩვენ ვაპირებთ მოვუწოდებთ Script.

604
00:55:15,480 --> 00:55:23,830
ან თუ ჩვენ წერდა იგი Python ან Perl ან Node.js ან იმ რამ,

605
00:55:23,830 --> 00:55:26,500
ჩვენ გვინდა მოვუწოდებთ მათ ყველა სკრიპტები იმიტომ, რომ თქვენ აწარმოებს მათ ბრძანებათა ზოლს

606
00:55:26,500 --> 00:55:30,040
მაგრამ ჩვენ არ კომპილირდება მათ.

607
00:55:30,860 --> 00:55:33,400
ჩვენ შეგვეძლო ამის გაკეთება საკმაოდ სწრაფად.

608
00:55:36,960 --> 00:55:41,480
ჩვენ არ ვაპირებთ, გამოვიყენოთ argv. მოდით უბრალოდ აფეთქება მეშვეობით.

609
00:55:41,480 --> 00:55:45,730
ზარის ეს უნიკალური, დაწერეთ პროგრამა.

610
00:55:45,730 --> 00:55:49,400
თქვენ შეიძლება ვივარაუდოთ, რომ შეყვანის შეიცავს ერთი სიტყვით თითო ხაზზე.

611
00:55:49,400 --> 00:55:52,020
სინამდვილეში, argv იქნება საკმაოდ ტრივიალური გამოიყენოს.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
პირველი, რაც პირველ რიგში, ჩვენ გვინდა, რომ შეამოწმოთ, თუ ჩვენ უკვე გავიდა 1 ბრძანების ხაზი არგუმენტი.

614
00:56:13,750 --> 00:56:20,900
ზუსტად ისე, როგორც თქვენ მოელოდა argc და argv დო, ჩვენ დღემდე იმ PHP.

615
00:56:20,900 --> 00:56:33,900
ასე რომ, თუ ($ argc! == 2) მაშინ მე არ გაუმკლავდეთ დაბეჭდვის გაგზავნა ან არაფერი.

616
00:56:33,900 --> 00:56:37,340
მე უბრალოდ გასასვლელი, შეცდომა კოდი 1.

617
00:56:37,340 --> 00:56:41,340
მე შეიძლება დაბრუნდეს 1.

618
00:56:41,340 --> 00:56:53,180
იშვიათად PHP ხართ ამ სახელმწიფო სადაც ჩვენ at -

619
00:56:53,180 --> 00:56:57,820
ჩვეულებრივ თქვენ ფუნქცია რომელსაც ფუნქცია რომელსაც ფუნქცია რომელსაც ფუნქცია.

620
00:56:57,820 --> 00:57:02,070
და თუ რამე მიდის არასწორი და თქვენ უბრალოდ გასასვლელად ყველაფერი მთლიანად,

621
00:57:02,070 --> 00:57:05,680
გასასვლელში უბრალოდ დამთავრდა პროგრამა.

622
00:57:05,680 --> 00:57:08,160
ეს ასევე არსებობს C.

623
00:57:08,160 --> 00:57:10,700
თუ თქვენ ფუნქცია ფუნქცია ფუნქცია ფუნქცია

624
00:57:10,700 --> 00:57:17,540
და გსურთ მხოლოდ მოკვლა პროგრამა, შეგიძლიათ დარეკოთ გასასვლელში და იგი მხოლოდ გაითიშება.

625
00:57:17,540 --> 00:57:23,120
მაგრამ PHP ეს კიდევ უფრო იშვიათი, რომ ჩვენ ვართ ამ უმაღლესი დონის.

626
00:57:23,120 --> 00:57:26,090
ჩვეულებრივ ჩვენ შიგნით გარკვეული ფუნქცია, ამიტომ ჩვენ მოვუწოდებთ გასასვლელში

627
00:57:26,090 --> 00:57:29,650
ასე რომ ჩვენ არ გვაქვს დასაბრუნებელი up 1 რამ რაც მაშინ ხვდება, იქ შეცდომა

628
00:57:29,650 --> 00:57:32,270
ასე რომ ბრუნდება up თუ რომელიც აღიარებს იყო შეცდომა.

629
00:57:32,270 --> 00:57:35,270
ჩვენ არ გვინდა, რომ გაუმკლავდეთ, რომ, ასე გასვლა (1);

630
00:57:35,270 --> 00:57:38,240
დაბრუნების (1); ამ შემთხვევაში იქნებოდა ექვივალენტს.

631
00:57:38,240 --> 00:57:44,000
>> აბა რა გვინდა გახსნა გვინდა fopen.

632
00:57:44,000 --> 00:57:46,760
არგუმენტები ვაპირებთ შევხედოთ საკმაოდ მსგავსი.

633
00:57:46,760 --> 00:57:51,600
ჩვენ გვინდა fopen ($ argv [1], და გვინდა, რომ იგი უნდა გახსნას წასაკითხად.

634
00:57:51,600 --> 00:57:55,720
რომ ბრუნდება რესურსი, რომელიც ჩვენ ვაპირებთ მოვუწოდებთ ვ.

635
00:57:55,720 --> 00:58:02,180
ეს გამოიყურება საკმაოდ მსგავსია როგორ C ს გარდა არ გვაქვს იმის თქმა ფაილ *.

636
00:58:02,180 --> 00:58:06,170
ამის ნაცვლად ჩვენ უბრალოდ, ვამბობთ $ ვ. Okay.

637
00:58:06,170 --> 00:58:17,190
სინამდვილეში, ვფიქრობ, ეს კი გვაძლევს მინიშნება როგორც PHP ფუნქცია მოუწოდა ფაილი. PHP ფაილი.

638
00:58:17,190 --> 00:58:23,990
რა ამ გაკეთებას აპირებს წაკითხვის მთელი ფაილის შევიდა მასივი.

639
00:58:23,990 --> 00:58:29,770
თქვენ კი არ უნდა fopen იგი. ის აპირებს, რომ თქვენ.

640
00:58:37,450 --> 00:58:43,700
ასე რომ $ ხაზები = ფაილი ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
ახლა ყველა ხაზების ფაილებს, რომლებიც არიან ხაზები. ახლა ჩვენ გვინდა დასალაგებლად ხაზები.

642
00:58:49,680 --> 00:58:52,180
როგორ შეგვიძლია დასალაგებლად ხაზები?

643
00:58:52,180 --> 00:58:54,920
ჩვენ დასალაგებლად ხაზები.

644
00:58:54,920 --> 00:58:58,080
და ახლა ჩვენ შეგვიძლია ბეჭდვა მათ ან რასაც.

645
00:58:58,080 --> 00:59:05,580
ალბათ იოლი გზა არის foreach ($ ხაზები როგორც $ ხაზი) ​​echo $ ხაზი;

646
00:59:05,580 --> 00:59:10,960
[სტუდენტი] არ ჩვენ კი გადაკვეთს ხაზების მიერ referencing რაღაც შევიდა დალაგება?

647
00:59:10,960 --> 00:59:28,850
ეს არის სადაც სახის იქნება განსაზღვრული როგორც ფუნქცია sort (& $ მასივი).

648
00:59:28,850 --> 00:59:32,650
როცა რეკავთ ფუნქცია თქვენ არ უნდა გაიაროს ეს მიერ მითითება.

649
00:59:32,650 --> 00:59:36,900
ეს ფუნქცია, რომელიც განსაზღვრავს, როგორც აღების, როგორც მითითება.

650
00:59:36,900 --> 00:59:40,900
ეს არის რეალურად სწორედ ის, რაც მოხდა ისე

651
00:59:40,900 --> 00:59:46,220
როდესაც ჩვენ ყველაფერი ჩვენი სერვერები როდესაც წავედით საწყისი 5.3 დან 5.4.

652
00:59:46,220 --> 00:59:53,800
დღემდე 5.4, ეს იყო შესანიშნავად გონივრული.

653
00:59:53,800 --> 00:59:58,740
ფუნქცია არ ელის მიიღოს ეს როგორც მინიშნება, მაგრამ თქვენ ვერ გაივლის მას, როგორც მინიშნება

654
00:59:58,740 --> 01:00:02,860
ასე რომ, თუ ფუნქცია არ მოხდეს ცვლილებები, ეს დღემდე შეცვლილია.

655
01:00:02,860 --> 01:00:05,850
როგორც 5.4, თქვენ არ უნდა გავაკეთოთ ეს.

656
01:00:05,850 --> 01:00:11,740
ახლა ერთადერთი გზა თქვენ გაივლით მიერ მინიშნება არის თუ ფუნქციის მკაფიოდ აკეთებს.

657
01:00:11,740 --> 01:00:19,840
თუ თქვენ არ გსურთ მას ცვლილებები, მაშინ თქვენ გჭირდებათ რომ გააკეთოთ $ ასლი = $ ხაზები და უღელტეხილზე ასლი.

658
01:00:19,840 --> 01:00:24,820
ახლა ხაზები შენარჩუნებული იქნება და ასლი შეიცვლება.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. მე შეიძლება რაღაც messed up.

660
01:00:31,460 --> 01:00:33,190
მოულოდნელი 'დალაგების ".

661
01:00:38,320 --> 01:00:43,850
აქ იქნება ის, რაც ჯერ ეს ჩვენთვის.

662
01:00:43,850 --> 01:00:45,820
ეს კი არ არსებობს.

663
01:00:45,820 --> 01:00:52,140
გაითვალისწინეთ, როდესაც წაიკითხავთ სახელმძღვანელო რომ პირველი არგუმენტი იქნება მასივი

664
01:00:52,140 --> 01:00:56,490
და ის მიერ გადაღებული მითითება.

665
01:00:58,160 --> 01:01:03,540
რატომ არის ეს უკმაყოფილო მე? რადგან ამ ფუნქციას დალაგების კვლავ აქ რომ არ მინდა.

666
01:01:03,540 --> 01:01:09,210
Okay, php.unique.php. მე არ უნდა გაიაროს ეს არგუმენტი, რადგან მე არ მაქვს ფაილი.

667
01:01:09,210 --> 01:01:13,560
ეს php.unique.php on test.php.

668
01:01:13,560 --> 01:01:19,080
აქ არის test.php ყველა ნაბეჭდი გარეთ ლამაზი დახარისხებული მიზნით.

669
01:01:19,080 --> 01:01:24,600
გაითვალისწინეთ, რომ დალაგებულია ბრძანება სახის უცნაური ამისთვის კოდი ფაილი

670
01:01:24,600 --> 01:01:27,460
რადგან ყველა ჩვენი ცარიელი ხაზები ვაპირებთ მოდის პირველი

671
01:01:27,460 --> 01:01:30,190
მაშინ ვაპირებთ მოვიდეს ყველა ჩვენი 1 დონის indentations

672
01:01:30,190 --> 01:01:33,360
შემდეგ მოდის ყველა ჩვენი არ indentations.

673
01:01:33,360 --> 01:01:38,620
Yeah. >> [სტუდენტი] ასე რომ კოდის არ იყო გაიარა მინიშნება?

674
01:01:38,620 --> 01:01:42,240
ის არის, რომ ზოგადად მიერ მიღებულ მნიშვნელობა?

675
01:01:42,240 --> 01:01:50,240
[Bowden] როცა რეკავთ ფუნქცია, მას არასოდეს განსაზღვრავს თუ არა მიღებულ იქნა საქართველოს მიერ მითითება.

676
01:01:50,240 --> 01:01:53,960
ეს ფუნქცია განმარტება, რომელიც განსაზღვრავს თუ არა მიღებულ იქნა საქართველოს მიერ მითითება.

677
01:01:53,960 --> 01:01:59,450
და ეძებს ფუნქციის განსაზღვრება დალაგება ან უბრალოდ ეძებს ამ,

678
01:01:59,450 --> 01:02:02,820
სჭირდება არგუმენტი მითითება.

679
01:02:02,820 --> 01:02:07,160
ასე რომ მიუხედავად იმისა გსურთ მიიღოს ეს მიერ მინიშნება, ის არ მიიღოს იგი მითითება.

680
01:02:07,160 --> 01:02:10,200
ეს modifies მასივი ადგილზე.

681
01:02:10,200 --> 01:02:17,400
ეს მხოლოდ ნებადართული არ არის. თქვენ არ გაქვთ უფლება ამის გაკეთება. >> [სტუდენტი] Oh, okay.

682
01:02:17,400 --> 01:02:22,410
[Bowden] ეს, დალაგება აპირებს მიიღოს ხაზების მიერ მინიშნება და ცვლილებები მას.

683
01:02:22,410 --> 01:02:26,850
ისევ და ისევ, თუ არ გსურთ მას ამის გაკეთება, თქვენ შეიძლება მიიღოს ასლი ჯიშია.

684
01:02:26,850 --> 01:02:35,850
მაშინაც კი, ამ შემთხვევაში, ასლი არ არის რეალურად ასლი ხაზები.

685
01:02:35,850 --> 01:02:40,620
ეს უბრალოდ მიუთითებს იგივე სანამ პირველი იღებს შეცვლილია,

686
01:02:40,620 --> 01:02:44,430
სადაც ეს პირველი აპირებს მისაღებად შეიცვალოს დალაგების ფუნქცია,

687
01:02:44,430 --> 01:02:50,940
სადაც, რადგან ეს ის ასლი-on-წერენ, ახლა ასლი ასლი აპირებს გაკეთდება.

688
01:02:57,500 --> 01:03:04,250
თქვენ ასევე შეგიძლიათ ამის გაკეთება. სწორედ სხვა ადგილს ხედავთ ampersand.

689
01:03:04,250 --> 01:03:07,190
ხედავთ ის foreach მარყუჟების, ხედავთ ის ფუნქცია დეკლარაციების,

690
01:03:07,190 --> 01:03:10,040
და ხედავთ, როცა მხოლოდ მინიჭების ცვლადები.

691
01:03:10,040 --> 01:03:12,350
ახლა ჩვენ დავასრულეთ არაფერი ამით

692
01:03:12,350 --> 01:03:15,600
რადგან ასლი და ხაზები სიტყვასიტყვით იგივე.

693
01:03:15,600 --> 01:03:19,940
თქვენ შეგიძლიათ გამოიყენოთ ხაზები და კოპირება interchangeably.

694
01:03:19,940 --> 01:03:25,430
ამის გაკეთება შეგიძლიათ ამორთვისთვის ($ ასლი); და რომ არ ამორთვისთვის ხაზები,

695
01:03:25,430 --> 01:03:29,120
უბრალოდ დაკარგოთ მინიშნება იგივე.

696
01:03:29,120 --> 01:03:33,440
ასე რომ, როგორც ამ ეტაპზე, არის ხაზები არის ერთადერთი გზა შეგიძლიათ ხაზები.

697
01:03:36,450 --> 01:03:38,770
>> კითხვები?

698
01:03:41,000 --> 01:03:42,460
Yeah.

699
01:03:42,460 --> 01:03:45,880
[სტუდენტი] სრულიად თავისუფალი თემა, მაგრამ თქვენ არ დახუროს PHP ერთად - >> თქვენ არ.

700
01:03:45,880 --> 01:03:47,730
Okay.

701
01:03:47,730 --> 01:03:53,790
[Bowden] მინდა წასვლა რამდენადაც ვთქვა ეს ცუდი პრაქტიკა დახუროს მათ.

702
01:03:53,790 --> 01:03:57,580
სწორედ ალბათ გაზვიადება, განსაკუთრებით სკრიპტი,

703
01:03:57,580 --> 01:04:03,740
მაგრამ ვნახოთ, რა მოხდება, თუ ამ.

704
01:04:03,740 --> 01:04:08,890
რომ არაფერი. რა მოხდება, თუ მინდოდა - [sighs]

705
01:04:13,870 --> 01:04:16,960
მე უნდა გაიაროს არგუმენტი.

706
01:04:19,000 --> 01:04:22,050
ესროლეთ. მე მას არასწორი.

707
01:04:24,340 --> 01:04:28,310
ამიტომ php.unique.php ერთად არგუმენტი.

708
01:04:28,310 --> 01:04:30,980
ახლა ისიც კი არ გვჭირდება.

709
01:04:34,520 --> 01:04:37,740
მე მსგავ სწორი არგუმენტი.

710
01:04:37,740 --> 01:04:42,050
ეს დაბეჭდილი რასაც ეს ბეჭდვა.

711
01:04:45,260 --> 01:04:50,080
მე დაბეჭდვის ასლი და ასლი არ არსებობს. ასე რომ ხაზები.

712
01:04:53,650 --> 01:04:58,270
ეს ყველაფერი დაბეჭდილი და შემდეგ შეამჩნევთ ყველა ამ უსარგებლო ქვემოთ აქ,

713
01:04:58,270 --> 01:05:06,690
რადგან PHP რამე რომ არის გარეთ PHP tags

714
01:05:06,690 --> 01:05:09,520
უბრალოდ აპირებს დაიბეჭდება სიტყვასიტყვით.

715
01:05:09,520 --> 01:05:18,050
ამიტომ HTML, ასე ლამაზი, რომ შემიძლია div blah, blah, blah კლასის ან რასაც,

716
01:05:18,050 --> 01:05:25,140
blah, blah, blah და შემდეგ დაკავდით PHP კოდი და მერე ბოლომდე DIV.

717
01:05:25,140 --> 01:05:36,460
და ახლა ბეჭდვა ამ მივიღო ჩემი ლამაზი div დასაწყისშივე, ყველაფერი, რაც PHP ბეჭდური, div ქვედა.

718
01:05:36,460 --> 01:05:43,510
დამღუპველი, როდესაც მსგავსი რამ ხდება, რაც საკმაოდ გავრცელებული,

719
01:05:43,510 --> 01:05:47,930
უბრალოდ მაწანწალა სტრიქონების გადატანით ბოლოში ფაილი.

720
01:05:47,930 --> 01:05:50,940
თქვენ არ ვფიქრობ, რომ იქნებოდა, რომ დიდი გარიგება

721
01:05:50,940 --> 01:05:58,660
სანამ თქვენ ამ ფაქტს, რომ ბრაუზერები -

722
01:05:58,660 --> 01:06:03,880
>> როგორ გადამისამართებების ნაწარმოების ან ძირითადად ნებისმიერი headers მუშაობა,

723
01:06:03,880 --> 01:06:07,980
როდესაც თქვენ გააკეთეთ თქვენი კავშირი ნახვა და ის აგზავნის უკან ყველა ეს ზედა და რამ

724
01:06:07,980 --> 01:06:12,020
მოსწონს საპასუხოდ 200 ან საპასუხოდ გადამისამართება ან რასაც,

725
01:06:12,020 --> 01:06:18,230
სათაურებში მხოლოდ ძალაშია პირველი byte of მონაცემები გაიგზავნება.

726
01:06:18,230 --> 01:06:23,140
შეგიძლიათ გადამისამართება ათასობით ჯერ, მაგრამ როგორც კი პირველი ბაიტი მონაცემთა იგზავნება

727
01:06:23,140 --> 01:06:26,120
თქვენ არ უნდა გადამისამართება ერთხელ.

728
01:06:26,120 --> 01:06:31,860
>> თუ თქვენ გაქვთ მაწანწალა სტრიქონების გადატანით ბოლოში ფაილი

729
01:06:31,860 --> 01:06:37,260
და ვთქვათ, რომ თქვენ გამოიყენოთ ეს ფუნქცია და შემდეგ გსურთ -

730
01:06:41,580 --> 01:06:52,870
ვთქვათ ეს არის კიდევ ერთი ფაილი, რომელიც არის index.php და თქვენ require_once რაღაც -

731
01:06:52,870 --> 01:06:56,920
მე ვერ ვფიქრობ კარგი მაგალითია.

732
01:06:56,920 --> 01:07:04,740
საკითხი ხდება, როდესაც ამ ხაზის ბოლოში იღებს გაიმეორა.

733
01:07:04,740 --> 01:07:08,660
თქვენ არ მინდა არაფერი არ გაიმეორა ამჟამად.

734
01:07:10,820 --> 01:07:15,700
მიუხედავად იმისა, რომ თქვენ არ აპირებდა შესახებ არაფერი მიღების გაიმეორა, რაღაც საერთოდ მისაღებად გაიმეორა

735
01:07:15,700 --> 01:07:17,990
და ა.შ. ახლა თქვენ არ უნდა გააგზავნოთ აღარ სათაურებში

736
01:07:17,990 --> 01:07:20,030
და თქვენ აპირებს მიიღოს საჩივრები.

737
01:07:22,170 --> 01:07:24,420
თქვენ უბრალოდ არ გვჭირდება იმ დახურვის tags.

738
01:07:24,420 --> 01:07:27,420
თუ თქვენ აპირებთ თავისსავე HTML-თან ერთად -

739
01:07:27,420 --> 01:07:30,490
და ეს შესანიშნავად გონივრული გავაკეთოთ ქვემოთ აქ div რასაც

740
01:07:30,490 --> 01:07:39,450
და მაშინ ამ ეტაპზე შეგიძლიათ ან ვერ შედის მათთან.

741
01:07:39,450 --> 01:07:41,590
ეს ნამდვილად არ აქვს.

742
01:07:41,590 --> 01:07:45,450
მაგრამ PHP სკრიპტების ის იშვიათი დახუროს იგი.

743
01:07:45,450 --> 01:07:50,400
როდესაც ყველაფერი PHP, აბსოლუტურად ყველაფერი,

744
01:07:50,400 --> 01:07:55,460
თქვენ ნამდვილად არ უნდა დახუროთ ეს / თქვენ არ უნდა დახუროს იგი.

745
01:08:02,030 --> 01:08:05,720
>> საქმე სიმები ბევრად გავალამაზოთ, ვიდრე C.

746
01:08:05,720 --> 01:08:09,470
PHP-ში შეგიძლიათ მიუთითოთ სიმებიანი ერთი ან ორმაგი შეთავაზებები.

747
01:08:09,470 --> 01:08:12,820
ერთი შეთავაზებები თქვენ არ შეგიძლიათ გამოიყენოთ "გაქცევის" sequences.

748
01:08:12,820 --> 01:08:17,640
მუდმივად გაქცევა, blah, blah, blah.

749
01:08:19,920 --> 01:08:24,010
ამიტომ printf ძალიან იშვიათია PHP.

750
01:08:24,010 --> 01:08:32,290
ვფიქრობ მინდა გამოიყენოთ printf თუ მინდოდა გავაკეთოთ ერთგვარი რამ - ში pset 5 გამოყენებულია sprintf ან რასაც.

751
01:08:32,290 --> 01:08:36,060
მაგრამ გსურთ 001.jpg 002.jpg და.

752
01:08:36,060 --> 01:08:40,300
ასე რომ სახის რამ, სადაც მე ნამდვილად გინდათ ფორმატის ტექსტი მინდა გამოიყენოთ printf.

753
01:08:40,300 --> 01:08:44,689
მაგრამ სხვა მინდა უბრალოდ გამოიყენოთ სიმებიანი გაერთიანების.

754
01:08:44,689 --> 01:08:47,000
მე არასოდეს ნამდვილად გამოიყენოს printf.

755
01:08:49,229 --> 01:09:00,170
ჩვენ უბრალოდ გამიჯვნის დეტალები შორის ერთჯერადი შეთავაზებები და ორმაგი შეთავაზებები.

756
01:09:00,170 --> 01:09:07,490
ყველაზე დიდი განსხვავება ისაა, რომ ერთჯერადი შეთავაზებები, ის დაიბეჭდება სიტყვასიტყვით.

757
01:09:07,490 --> 01:09:15,390
არ არსებობს მონაცემები char ტიპის PHP, განსხვავებით C, ამიტომ ეს არის ეკვივალენტი ამ.

758
01:09:15,390 --> 01:09:17,970
ისინი ორივე სტრიქონები.

759
01:09:17,970 --> 01:09:29,180
და ლამაზი რამ შესახებ მარტოხელა ციტირებით სიმები არის მე შეიძლება ითქვას, 'Hello world!' blah, blah, blah,

760
01:09:29,180 --> 01:09:33,340
$ $ Wooo.

761
01:09:33,340 --> 01:09:38,260
რა ხდება, როდესაც მე ბეჭდვა ეს იქნება ბეჭდვა ეს სიტყვასიტყვით.

762
01:09:38,260 --> 01:09:40,680
მოდით დავაღწიოთ ყველა ჩვენი პერსონალი.

763
01:09:40,680 --> 01:09:44,700
ამიტომ echo $ str1;

764
01:09:48,569 --> 01:09:56,570
ეს სიტყვასიტყვით დაბეჭდილი ყველა იმ რამ: დოლარის ნიშნები,

765
01:09:56,570 --> 01:09:58,770
backslash N, რომელიც თქვენ იფიქრებენ იქნებოდა newlines -

766
01:09:58,770 --> 01:10:01,500
ყველა იმ რამ იგი ბეჭდავს სიტყვასიტყვით.

767
01:10:01,500 --> 01:10:05,650
ერთადერთი, რაც გჭირდებათ გაქცევა არის ერთჯერადი შეთავაზებები

768
01:10:05,650 --> 01:10:09,470
რადგან სხვაგვარად იქნებოდა ვფიქრობ დახურვის ერთჯერადი შეთავაზებები.

769
01:10:09,470 --> 01:10:15,050
ორმაგი შეთავაზებები, სრულიად განსხვავებული.

770
01:10:20,300 --> 01:10:25,870
ჩვენ უკვე ვხედავთ სინტაქსის შეფერადება cluing ჩვენთან თუ რა დაახლოებით წასვლა საშინლად არასწორი.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo რადგან ეს გაგებული, როგორც ცვლადში wooo.

772
01:10:36,190 --> 01:10:42,400
ორმაგი შეთავაზებები მოგცემთ ჩაწეროთ ცვლადები შევიდა -

773
01:10:42,400 --> 01:10:52,730
ვთქვათ $ name = "რობ";

774
01:10:52,730 --> 01:10:58,020
ამიტომ echo "Hi, ჩემი სახელი არის $ სახელი!";

775
01:10:58,020 --> 01:11:09,260
იგი აღიარებს, როგორც ცვლადი.

776
01:11:09,260 --> 01:11:21,210
როდესაც მე აწარმოებს, რომ - და მე ჩადეთ სტრიქონების გადატანით - Hi, ჩემი სახელი არის რობ! და Hello world!

777
01:11:21,210 --> 01:11:24,910
ეს იმიტომ რომ მე არასდროს მოიხსნება ბეჭდვა wooo ზემოთ.

778
01:11:24,910 --> 01:11:30,020
არსებობს 1 შემდგომი ნაბიჯი თქვენ შეუძლია გააკეთოს.

779
01:11:30,020 --> 01:11:39,250
$ Array = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
რა მოხდება, თუ მინდა ბეჭდვა პირველი მაჩვენებელი მასივი?

781
01:11:43,270 --> 01:11:45,150
თქვენ ჩვენგან $ array [0].

782
01:11:45,150 --> 01:11:49,280
სინტაქსის შეფერადება არის ნახავ. რა არის ეს აპირებს გავაკეთო?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
Hi, ჩემი სახელი არის 1! რომელიც არ არის ის რაც მინდოდა.

785
01:11:59,860 --> 01:12:05,050
სინტაქსის შეფერადება lied to me.

786
01:12:05,050 --> 01:12:13,020
მოდით ვეცადოთ "'-> 1," ბ "-> 2.

787
01:12:18,450 --> 01:12:21,440
ასე მე დაწერა.

788
01:12:26,350 --> 01:12:32,160
მოულოდნელი ერთჯერადი ციტატა (T_ENCAPSED blah, blah, blah, blah, blah).

789
01:12:32,160 --> 01:12:41,780
იდეა ისაა, რომ ეს არ აღიარების ამ ნაწილს მასივი.

790
01:12:41,780 --> 01:12:46,620
ეს არ აღიარებენ ამას, როგორც მასივი ინდექსირებული წერილით.

791
01:12:46,620 --> 01:12:49,870
გსურთ, რომ გარშემორტყმული Curly braces,

792
01:12:49,870 --> 01:12:54,730
და ახლა რაც ამ Curly გაუწიოს იქნება interpolated,

793
01:12:54,730 --> 01:13:00,340
რომელიც სიტყვას ჩვენ ვიყენებთ magically ჩასმა ამ ცვლადების სწორი ადგილებში.

794
01:13:00,340 --> 01:13:04,280
ახლა აკეთებს ეს php.unique და Hi, ჩემი სახელი არის 1! როგორც მოსალოდნელია

795
01:13:04,280 --> 01:13:07,720
ან Hi, ჩემი სახელი არის რობ!

796
01:13:14,110 --> 01:13:23,130
ერთი რამ, რომ სახის ლამაზი შესახებ ერთჯერადი შეთავაზებები არის, რომ -

797
01:13:23,130 --> 01:13:28,480
არსებობს გარკვეული ღირებულება interpolating.

798
01:13:30,520 --> 01:13:35,100
თუ იყენებთ ორმაგი შეთავაზებები, თარჯიმანი უნდა წავიდეს ამ სტრიქონს,

799
01:13:35,100 --> 01:13:41,500
მიღების დარწმუნებული ვარ, რომ, "ო, აქ ცვლადი. ახლა უნდა წავიდეთ მისაღებად რომ ცვლადი და ჩადეთ აქ."

800
01:13:41,500 --> 01:13:48,930
მაშინაც კი, თუ თქვენ არ გამოიყენოთ ნებისმიერი ცვლადები,

801
01:13:48,930 --> 01:13:52,220
არაფერი შიგნით ამ ორმაგი შეთავაზებები საჭიროებს interpolated,

802
01:13:52,220 --> 01:13:56,800
მაგრამ ის მაინც იყოს ნელა იმიტომ, რომ ეს სჭირდება წასვლა მეტი ორმაგი შეთავაზებები

803
01:13:56,800 --> 01:14:00,130
ეძებს რამ, რომლებიც უნდა interpolated.

804
01:14:00,130 --> 01:14:05,360
ამიტომ ერთჯერადი შეთავაზებები შეიძლება იყოს ცოტა უფრო სწრაფად თუ არაფერი საჭიროებს interpolated,

805
01:14:05,360 --> 01:14:15,650
და მე როგორც წესი, თუნდაც გამოიყენოთ ერთჯერადი კვოტების, 'Hi, ჩემი სახელი არის ". $ Array [''] მაინც.

806
01:14:15,650 --> 01:14:20,430
რომ იქნება ექვივალენტური რა გვქონდა ადრე.

807
01:14:24,840 --> 01:14:28,440
მაგრამ ეს საკითხი უპირატესობა.

808
01:14:28,440 --> 01:14:34,750
თუ თქვენ იყენებთ PHP, თქვენ ალბათ არ აინტერესებს სიჩქარე სხვაობა.

809
01:14:34,750 --> 01:14:39,480
არ არის საკმარისი, რომ მიზეზი მათ უნდა დაიწყოს.

810
01:14:39,480 --> 01:14:43,030
>> ნებისმიერი საბოლოო კითხვები?

811
01:14:47,430 --> 01:14:51,710
>> ჩვენ რეალურად კი არ მიიღოთ მეშვეობით ყველა, მაგრამ ამ პერსონალის იყო მოსაწყენი.

812
01:14:51,710 --> 01:14:59,080
ბოლო რამ, რომ სახის ლამაზი PHP-ში არის, როდესაც თქვენ საქმე HTML,

813
01:14:59,080 --> 01:15:06,450
თქვენ გამოიყენოს იგი ცოტა, ასე ლამაზი კომბინაცია სინტაქსი ბეჭდვა ცვლადი.

814
01:15:32,400 --> 01:15:36,730
არ აყენებდა PHP აქ, ამ ეწოდება მოკლე tags.

815
01:15:36,730 --> 01:15:44,330
ოფიციალურად როგორც PHP 5.4, ეს უარყოფილია.

816
01:15:44,330 --> 01:15:48,640
თქვენ რეკომენდირებული დააყენოს php.

817
01:15:48,640 --> 01:15:55,770
ეს ჯერ კიდევ დაუჭირა მხარი, ასე მოკლე tags ერთად <? = დღესაც შესანიშნავად ჯარიმა.

818
01:15:55,770 --> 01:16:02,480
ეს თავისთავად ცხადია მხარდაჭერა, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს როგორც თქვენ გსურთ, და ისინი საკმაოდ მოსახერხებელია.

819
01:16:02,480 --> 01:16:05,700
>> ნებისმიერი კითხვები?

820
01:16:07,780 --> 01:16:09,270
ყველა უფლება.

821
01:16:10,840 --> 01:16:13,800
>> იყავი classy, ​​სან დიეგო.

822
01:16:13,800 --> 01:16:16,070
[Chuckles]

823
01:16:18,620 --> 01:16:22,660
Bye. [იცინის]

824
01:16:24,350 --> 01:16:28,470
[ტაში] [იცინის]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]