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 spec η ίδια παίρνει μια ώρα για να το διαβάσετε.

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 εβδομάδα μικρότερη, και δεν έχουμε πλέον μια PSET JavaScript.

15
00:01:09,560 --> 00:01:12,310
Δεν ξέρω πως ότι επηρεάζει το αν το JavaScript πρόκειται να εμφανιστεί για τις εξετάσεις

16
00:01:12,310 --> 00:01:15,510
ή Κουίζ 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
Λοιπόν, να πω αντίο σε όλα αυτά τα char, float, int, και άλλες λέξεις-κλειδιά θα πρέπει να χρησιμοποιήσετε

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, float, 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
η οποία είναι στατικά πληκτρολογήσει, είναι ότι δυναμικά δακτυλογραφημένες, όλα έλεγχο τύπου και τα πράγματά σας

33
00:02:32,010 --> 00:02:37,350
συμβαίνει κατά το χρόνο εκτέλεσης, ενώ στατικά πληκτρολογήσει συμβαίνει κατά τη μεταγλώττιση.

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
Στο C αν προσπαθήσετε να προσθέσετε ένα string και έναν ακέραιο, όταν το υπολογίσουν,

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, float, int, και όλα αυτά τα πράγματα,

45
00:03:35,220 --> 00:03:40,940
αλλά η γλώσσα μπορεί να πει από το πλαίσιο του πράγματος τι τύπο που θα έπρεπε να είναι,

46
00:03:40,940 --> 00:03:43,980
αλλά είναι ακόμα στατικά πληκτρολογήσει.

47
00:03:43,980 --> 00:03:49,000
Έτσι, εάν παίρνετε 51, ocaml, ποτέ δεν πρέπει να χρησιμοποιήσετε κάποιο από αυτά τα είδη,

48
00:03:49,000 --> 00:03:58,700
αλλά ακόμα θα σε χρόνο μεταγλώττισης λένε δεν μπορείτε να κάνετε αυτό επειδή είστε ανάμειξη ένα int και ένα string.

49
00:03:58,700 --> 00:04:05,650
Δυναμικά πληκτρολογήσει απλά σημαίνει ότι κάποια στιγμή κατά τη διάρκεια του χρόνου τρέχει εσείς πρόκειται να πάρετε μια καταγγελία.

50
00:04:05,650 --> 00:04:13,430
Εάν έχετε χρησιμοποιήσει επίσης Java πριν, σε γενικές γραμμές, σχεδόν κάθε Ο-τύπο γλώσσας

51
00:04:13,430 --> 00:04:20,070
πρόκειται να πληκτρολογήσει στατικά, έτσι C, C + +, Java, όλα αυτά είναι γενικά στατικά πληκτρολογήσει.

52
00:04:20,070 --> 00:04:22,910
Στην Java κατά τη μεταγλώττιση κάτι και λέτε

53
00:04:22,910 --> 00:04:26,670
string s ισούται με νέα κάτι που δεν είναι string,

54
00:04:26,670 --> 00:04:28,950
που πρόκειται να διαμαρτυρηθεί επειδή αυτοί οι τύποι απλά δεν ταιριάζουν.

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
σε έναν τύπο που είναι πιο συγκεκριμένες από ό, τι τρέχοντα τύπο του,

58
00:04:40,500 --> 00:04:45,610
δεν υπάρχει τίποτα που μπορεί να κάνει κατά τη μεταγλώττιση για να ελέγξετε αν το καστ πρόκειται να πετύχει.

59
00:04:45,610 --> 00:04:51,130
Java έχει επίσης κάποια δυναμική τύπου έλεγχο ότι από τη στιγμή που παίρνει σε αυτή τη γραμμή του κώδικα

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 στην Boolean καθώς περνάμε.

73
00:05:45,920 --> 00:05:54,590
Στη C δεν υπάρχει Boolean τύπο δεδομένων, δεν υπάρχει συμβολοσειρά τύπου δεδομένων.

74
00:05:54,590 --> 00:06:00,500
Υπάρχει char * και Boolean τείνει μόνο να είναι int ή char ή κάτι τέτοιο.

75
00:06:00,500 --> 00:06:05,690
Στην PHP αυτοί οι τύποι δεν υπάρχουν, και αυτό είναι ένα από τα μεγάλα πλεονεκτήματα της PHP σε C -

76
00:06:05,690 --> 00:06:13,290
ότι οι εργασίες χορδών είναι απείρως πιο εύκολο από ό, τι σε PHP Γ. Απλώς δουλειά.

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
Στο C θα πρέπει να συγκεντρώνουν κάτι και στη συνέχεια να εκτελέσετε αυτή καταρτίζονται αρχείο.

83
00:06:48,200 --> 00:06:50,490
Στην PHP ποτέ δεν compile τίποτα.

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
Υπάρχει ένα κομμάτι της σύνταξης που κάνει, και αποθηκεύει τα αποτελέσματα

87
00:07:10,910 --> 00:07:15,510
οπότε αν εκτελέσετε τη δέσμη ενεργειών αργότερα μπορείτε να κάνετε μερικά,

88
00:07:15,510 --> 00:07:19,280
αλλά ουσιαστικά είναι ένα είδος γραμμή με γραμμή του πράγματος.

89
00:07:19,280 --> 00:07:25,280
Αυτό σημαίνει ότι πολλές από τις βελτιώσεις που έχουμε πάρει σε C,

90
00:07:25,280 --> 00:07:31,920
όπως η κατάρτιση, είναι ακριβώς γενικά ο compiler μπορεί να κάνει πολλά κόλπα για σας.

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
>> Back στη δυναμική δακτυλογράφηση μας: αρκετά δροσερό, ε;

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
σε PHP, NULL είναι δικό της τύπο, όπου το μόνο πράγμα που ισχύουν αυτού του τύπου είναι NULL.

111
00:08:57,560 --> 00:09:00,670
Αυτό είναι πολύ πιο χρήσιμο για τον έλεγχο σφαλμάτων.

112
00:09:00,670 --> 00:09:04,310
Στην C, όπου είχαμε το θέμα αυτό όπου κι αν επιστρέψει NULL,

113
00:09:04,310 --> 00:09:08,660
Μήπως αυτό σημαίνει ότι είστε επιστρέφοντας ένα δείκτη NULL NULL χρήση ή για να δηλώσει σφάλμα

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
Κοιτάζοντας τους τύπους που δεν περιμένουν από εμάς να γνωρίζουμε,

121
00:09:53,940 --> 00:09:59,000
τι νομίζετε ότι ο τύπος των 3,50 είναι; >> [Φοιτητής] Float.

122
00:09:59,000 --> 00:10:00,370
Ναι.

123
00:10:00,370 --> 00:10:06,290
Έτσι λοιπόν εδώ, τι νομίζετε ότι ο τύπος είναι αυτό; >> [Φοιτητής] Array.

124
00:10:06,290 --> 00:10:09,890
Ναι. Το πρώτο ήταν πλωτήρα, το δεύτερο είναι ένας πίνακας.

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
Εδώ οι δείκτες είναι a, b, και c και οι τιμές είναι 1, 2, και 3.

128
00:10:26,320 --> 00:10:33,980
Στην PHP, δεν υπάρχει διαφορά ανάμεσα σε ένα associative array και μόνο τακτική σειρά

129
00:10:33,980 --> 00:10:36,740
όσο θα πίστευε κανείς από την Γ.

130
00:10:36,740 --> 00:10:43,040
Υπάρχει μόνο αυτό, και κάτω από το καπό μια κανονική σειρά είναι απλά ένα associative array

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
Στην PHP πρόσβαση σε ένα μέλος είναι ποιος ξέρει πόσο χρόνο;

135
00:11:11,860 --> 00:11:18,970
Είναι μάλλον σταθερή, αν hashes σωστά.

136
00:11:18,970 --> 00:11:21,620
Ποιος ξέρει τι πραγματικά κάνει κάτω από την κουκούλα;

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
Η ιδέα των πόρων, σε C κατά κάποιο τρόπο πήρε ένα αρχείο * ή οτιδήποτε άλλο?

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
Ναι. Έτσι, το μόνο πράγμα που είναι NULL είναι NULL.

150
00:12:30,650 --> 00:12:33,480
NULL είναι NULL.

151
00:12:35,490 --> 00:12:41,170
>> Ένα χαρακτηριστικό του συστήματος τύπου της PHP (προς το καλύτερο ή προς το χειρότερο) είναι η ικανότητά του να ταχυδακτυλουργία τύπους.

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
Δοκιμάστε κάθε μία από τις παρακάτω γραμμές κώδικα 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
Στην Γ αυτό δεν θα λειτουργήσει.

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
Η Python είναι ένα άλλο παράδειγμα μιας γλώσσας που είναι δυναμικά πληκτρολογήσει.

165
00:13:34,050 --> 00:13:41,770
Μπορείτε να ρίξει γύρω από τους τύπους των μεταβλητών και πρόκειται να καθοριστεί κατά το χρόνο εκτέλεσης

166
00:13:41,770 --> 00:13:44,680
όλα τα σημεία ελέγχων σφάλμα.

167
00:13:44,680 --> 00:13:50,740
Στην Python πρόκειται να εκτελέσει αυτό και θα δείτε ("1" + 2)?

168
00:13:50,740 --> 00:13:55,920
και αυτό θα αποτύχει, διότι λέει ότι δεν μπορείτε να προσθέσετε ένα string και έναν ακέραιο.

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-r, τότε μπορεί να ρίξει στην εντολή εδώ:

182
00:14:57,710 --> 00:15:06,610
"Print ('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
"Print (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 string ή κάτι τέτοιο

190
00:15:59,550 --> 00:16:08,080
PHP επειδή, σε αντίθεση με JavaScript και Java πάρα πολύ,

191
00:16:08,080 --> 00:16:11,670
έχει ένα ξεχωριστό φορέα για συνένωσης.

192
00:16:11,670 --> 00:16:14,930
Αλληλουχία στην PHP είναι η τελεία.

193
00:16:14,930 --> 00:16:22,950
Έτσι, εκτύπωση (1 '2 '.)? Πρόκειται να μας δώσει 12.

194
00:16:25,790 --> 00:16:32,420
Αυτό τείνει να οδηγήσει σε σύγχυση όταν οι άνθρωποι προσπαθούν να κάνουν κάτι σαν str + =

195
00:16:32,420 --> 00:16:37,840
κάποιο άλλο πράγμα που θέλετε να προσθέσετε για να το τέλος του string τους, και ότι πρόκειται να αποτύχει.

196
00:16:37,840 --> 00:16:40,770
Θα χρειαστεί να κάνετε str. =

197
00:16:42,000 --> 00:16:46,240
Γι 'αυτό μην ξεχνάτε συνένωση σε PHP είναι μια τελεία.

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
Βλέπει το string, και εγώ στοίχημα αν βάλουμε 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), αν αυτό ήταν C, τι θα ήταν αυτό επιστρέψουν;

216
00:18:23,700 --> 00:18:29,630
[Φοιτητής] 1. >> Ναι, θα είναι 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
Εδώ εκτύπωση (7.10)? Πρόκειται να ερμηνεύσει ότι στην πραγματικότητα.

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
Στο C είναι μάλλον περίεργο ότι μπορείτε να βασιστείτε ακέραιο περικοπή τακτικά,

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 μεταβλητή συμβαίνει να είναι ένα string

231
00:19:47,240 --> 00:19:51,310
και η άλλη μεταβλητή που συμβαίνει να είναι ένα 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
και όλα θα δουλέψουν, είναι δύσκολο να γνωρίζουν καν ότι αυτή η μεταβλητή πρέπει να είναι μια συμβολοσειρά τώρα,

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
Αν περνάμε στο "print (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
Στο C θα πρέπει να επαναλάβει πάνω από όλους τους χαρακτήρες

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
και αυτό είναι που επιστρέφει false.

253
00:21:56,520 --> 00:22:02,120
Έτσι, όταν εκτυπώνεται ότι, το έντυπο τίποτα, έτσι εδώ είμαι σύγκριση για να δούμε,

254
00:22:02,120 --> 00:22:05,490
δεν τυχαίνει να είναι ψευδής; Και έτσι τώρα είναι εκτύπωση 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
Ναι. Εντάξει, τώρα θα πάω να δω αν πραγματικά συγκρίνουν να είναι ίσες.

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
Αλλά αν μπορώ να αλλάξω ότι σε ένα f - το καταριέται! Κρατάω χρησιμοποιώντας διπλά εισαγωγικά.

270
00:23:33,170 --> 00:23:38,780
Ο λόγος για τα διπλά εισαγωγικά είναι φωνάζεις γιατί έχω βάλει αυτό σε διπλά εισαγωγικά.

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, αλλά είναι κοντά ότι είναι σαν -

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 '== False)? Είναι αλήθεια.

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
α μπορεί να είναι ίσο με το β και το α μπορεί να είναι ίσο με c,

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
Αυτό είναι στην πραγματικότητα μεγάλωσε στο spec PSET

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
Θα πρέπει να θέσει σε ένα μεγάλο κόκκινο κουτί, "Αυτό θα επιστρέψει false αν υπάρχει ένα σφάλμα."

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
Αλλά τι γίνεται αν έχετε περάσει το ένα μη έγκυρο αρχείο και η λειτουργία συμβαίνει να επιστρέψει false

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, ο τύπος πίνακα είναι διαφορετική από ό, τι έχετε συνηθίσει στο C.

309
00:27:01,660 --> 00:27:06,650
Πράγματι, μπορεί να έχετε παρατηρήσει ήδη αυτό το παραπάνω, όταν είδε ότι αυτό είναι του τύπου σειρά.

310
00:27:06,650 --> 00:27:15,640
Η σύνταξη είναι νέο στήριγμα από την PHP 5.4, η οποία είναι η νεότερη έκδοση της PHP.

311
00:27:15,640 --> 00:27:36,960
Πριν από αυτό που πάντα έπρεπε να γράψω array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Αυτός ήταν ο κατασκευαστής για μια σειρά.

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
Κατά τη διάρκεια του καλοκαιριού που έτρεξε σε αυτό το θέμα, όπου PHP 5.3 ήταν ό, τι είχαμε στη συσκευή,

318
00:28:08,220 --> 00:28:14,480
αλλά ο διακομιστής που έχουμε αναπτύξει όλα βαθμού βιβλίο μας και να υποβάλουν και όλα αυτά τα πράγματα για να

319
00:28:14,480 --> 00:28:16,750
ήταν PHP 5.4.

320
00:28:16,750 --> 00:28:23,060
Μη γνωρίζοντας αυτό, έχουμε αναπτύξει σε 5,3, ώθησε σε 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
Αλλά αν ψάχνετε τα πράγματα γύρω από το Internet,

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 [«β»].

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. Γιατί αυτό θα είναι λάθος;

337
00:29:52,490 --> 00:29:59,870
Θα δημιουργήσει πιθανώς μια προειδοποίηση, αλλά εξακολουθούν να εργάζονται. PHP έχει την τάση να το κάνουμε αυτό.

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
Έτσι τώρα β μπορούσε να είναι μια συνεχής και $ array [b] θα είναι πραγματικά να κάνει 'Hello World'.

344
00:30:28,740 --> 00:30:32,380
Νομίζω ότι σε αυτό το σημείο, ή τουλάχιστον PHP ρυθμίσεις μας,

345
00:30:32,380 --> 00:30:37,870
αν προσπαθήσετε να δημιουργήσετε ευρετήριο σε μια σειρά και ότι το κλειδί δεν υπάρχει, θα αποτύχει.

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 ['β']) θα επιστρέψει αλήθεια.

351
00:31:06,830 --> 00:31:09,880
Μπορείτε να αναμίξετε αυτές τις συντάξεις.

352
00:31:15,060 --> 00:31:22,440
Είμαι αρκετά σίγουρος τι αυτός ο πίνακας θα καταλήξει να είναι είναι - Μπορούμε να το δοκιμάσετε.

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 του πίνακα, εάν υπήρχαν.

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
Ναι. Είναι 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
Ποτέ δεν πρόκειται να ορίσετε ένα δείκτη string σε 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, κλειδί d.

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 δεν είναι ακριβώς όπως το κανονικό πίνακα κατακερματισμού σας.

386
00:34:41,270 --> 00:34:45,570
Είναι απολύτως λογικό να σκεφτούμε τους ως πίνακες κατακερματισμού το 99% του χρόνου.

387
00:34:45,570 --> 00:34:53,790
Αλλά σε πίνακες κατακερματισμού σας δεν υπάρχει καμία αίσθηση του σειρά με την οποία εισήχθησαν τα πράγματα.

388
00:34:53,790 --> 00:34:56,639
Έτσι, μόλις το τοποθετήσετε σε πίνακα κατακερματισμού σας,

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 πρώτη και ξέρει όταν είναι εκτύπωση από αυτό το array ότι 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
έτσι ώστε να αντιστοιχίζει κλειδιά για τις αξίες και θυμάται τη σειρά με την οποία οι κλειδιά εισήχθησαν.

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
Απενεργοποίηση συμβαίνει να unset των δύο μεταβλητών και δεικτών πίνακα.

401
00:35:54,880 --> 00:35:58,630
Έτσι unset ($ 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
και μπορώ να επαναλάβει πάνω ως τέτοια.

408
00:36:30,810 --> 00:36:38,520
Αλλά μόλις έχω unset το δεύτερο δείκτη, τι ήταν στο δείκτη 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
Είναι απλά ενοχλητικό και πρέπει να κάνουμε τα πράγματα όπως συνδέσεων πίνακα. Ναι.

412
00:36:53,950 --> 00:36:57,200
>> [Φοιτητής] Τι θα συμβεί αν είχατε ένα για βρόχο

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
Επανάληψη σε μια σειρά. Υπάρχουν 2 τρόποι που μπορείτε να το κάνετε.

416
00:37:10,150 --> 00:37:12,770
Μπορείτε να χρησιμοποιήσετε μια τακτική για βρόχο.

417
00:37:12,770 --> 00:37:22,000
Αυτό είναι μια άλλη πολυπλοκότητα της 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
Αυτός είναι ο λόγος που, ως επί το πλείστον, δεν θα πρέπει να επαναλάβει πάνω από μια σειρά σαν αυτή.

426
00:38:03,020 --> 00:38:07,110
Θα μπορούσε να είναι μια υπερβολή, αλλά ποτέ δεν πρέπει να επαναλάβει σε μια σειρά, όπως αυτό

427
00:38:07,110 --> 00:38:19,410
επειδή η PHP παρέχει σύνταξη της foreach όπου foreach ($ array $ ως στοιχείο).

428
00:38:19,410 --> 00:38:31,830
Τώρα, αν θα εκτυπώσετε ($ στοιχείο)? - We'll το συζητήσουμε σε ένα δεύτερο - που λειτουργεί τέλεια πρόστιμο.

429
00:38:31,830 --> 00:38:38,960
Ο τρόπος που λειτουργεί foreach είναι το πρώτο επιχείρημα είναι ότι η σειρά είστε πάνω από την επανάληψη.

430
00:38:38,960 --> 00:38:44,060
Και το δεύτερο επιχείρημα, στοιχείο, με κάθε πέρασμα του βρόχου for

431
00:38:44,060 --> 00:38:52,690
πρόκειται να αναλάβει το επόμενο πράγμα στο πίνακα. Έτσι θυμηθείτε η σειρά έχει μια παραγγελία.

432
00:38:52,690 --> 00:38:55,690
Η πρώτη φορά μέσω του για βρόχο, το στοιχείο θα είναι 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
Τι θα συμβεί αν εμείς unset ($ array [1])?

437
00:39:20,410 --> 00:39:26,030
Αυτό ήταν μάλλον αναμενόμενο.

438
00:39:26,030 --> 00:39:30,950
Είσαι πάνω από την επανάληψη αυτού του πίνακα, και κάθε φορά που είστε απενεργοποίηση του πρώτου δείκτη.

439
00:39:30,950 --> 00:39:39,720
Έτσι, για το δείκτη 0, το πρώτο πράγμα, στοιχείο παίρνει την τιμή 0, γι 'αυτό πρόκειται να είναι 123.

440
00:39:39,720 --> 00:39:44,630
Αλλά μέσα από το βρόχο για να unset δείκτης 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
από νέες γραμμές σε Windows είναι διαφορετικός από νέες γραμμές για Mac και UNIX.

444
00:40:08,890 --> 00:40:18,040
Στα Windows νέας γραμμής είναι \ r \ n, ενώ παντού αλλού τείνει μόνο να είναι \ 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 ακόμα κι αν unset 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
δεν θα νοιάζονται. Το στοιχείο θα αναλάβει τις αρχικές τιμές.

453
00:41:17,240 --> 00:41:19,240
Ας προσπαθήσουμε απενεργοποίηση αυτό.

454
00:41:19,240 --> 00:41:24,460
Κι αν αυτό είναι $ array [1] = "γεια"?

455
00:41:24,460 --> 00:41:31,770
Ακόμα κι αν βάλουμε "γεια" στη σειρά, ποτέ δεν παίρνει θέση σε αυτή την τιμή.

456
00:41:31,770 --> 00:41:37,430
Υπάρχει μια άλλη σύνταξη για foreach βρόχους

457
00:41:37,430 --> 00:41:45,900
όπου βάζετε 2 μεταβλητές που χωρίζονται από ένα βέλος.

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
Αυτό έχει ενδιαφέρον εδώ, αλλά αν πάμε πίσω στην αρχική μας υπόθεση του «ενός» -> 1,

461
00:42:01,610 --> 00:42:06,090
«Β» -> 1,

462
00:42:06,090 --> 00:42:14,470
εδώ αν εμείς απλά επαναλάβει για κάθε πίνακα ως στοιχείο, το στοιχείο θα είναι 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
Τώρα είναι πάνω από την επανάληψη και την εκτύπωση κάθε πλήκτρο και συνδέονται αξία του.

467
00:42:39,380 --> 00:42:47,030
>> Ένα επιπλέον πράγμα που μπορούμε να κάνουμε είναι foreach βρόχους μπορείτε να δείτε αυτή τη σύνταξη.

468
00:42:47,030 --> 00:42:54,770
Συμπλεκτικά σύμβολα πριν από τα ονόματα των μεταβλητών τείνουν να είναι πώς 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 ($ array ως στοιχείο $), τότε το στοιχείο θα είναι η τιμή 1

477
00:43:49,560 --> 00:43:54,190
η πρώτη φορά μέσω του βρόχου. Θα αυξήσετε 1 με 2 και στη συνέχεια, τελειώσαμε.

478
00:43:54,190 --> 00:43:57,260
Έτσι, στη συνέχεια θα περάσει από το δεύτερο πέρασμα του βρόχου και αυτό το στοιχείο είναι 10.

479
00:43:57,260 --> 00:44:01,570
Το στοιχείο αυξήσεις έως 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 ($ array ως στοιχείο & $)

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
Η πιο άμεση μετατροπή της αρχικής σειρά μας.

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, $ bar) και στη συνέχεια να ορίσετε να είναι οτιδήποτε.

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 ($ στοιχείο)?

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
έτσι πράγματι αυξάνεται.

510
00:47:06,300 --> 00:47:08,790
Ανακοίνωση χρειαζόμαστε αναφορές σε 2 μέρη.

511
00:47:08,790 --> 00:47:13,050
Τι και αν το έκανα αυτό; Τι σημαίνει αυτό;

512
00:47:13,050 --> 00:47:15,810
[Φοιτητής] Αυτό θα αλλάξει. Ναι >>.

513
00:47:15,810 --> 00:47:18,290
Θέση είναι μόνο ένα αντίγραφο της τιμής στη συστοιχία.

514
00:47:18,290 --> 00:47:26,670
Έτσι, το στοιχείο θα αλλάξει σε 2, αλλά ο πίνακας ['a'] θα εξακολουθεί να είναι 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
Έτσι, το αντίγραφο του επιχειρήματος θα αυξάνεται σε 2,

518
00:47:46,330 --> 00:47:49,240
αλλά το ίδιο το στοιχείο δεν ήταν ποτέ αυξάνεται σε 2.

519
00:47:49,240 --> 00:47:52,880
Και το στοιχείο είναι το ίδιο πράγμα με οποιαδήποτε σειρά βραχίονα,

520
00:47:52,880 --> 00:47:55,380
έτσι ώστε η σειρά ποτέ δεν αυξάνεται.

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
[Φοιτητής] Έτσι, δεν έχετε να αντιγράψετε κάτι μεγάλο. Ναι >>.

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
Αν μέσα από αυτή τη λειτουργία, δεν τροποποιεί πραγματικά foo,

538
00:49:15,940 --> 00:49:22,660
οπότε αν ($ foo === «γεια») επιστρέφουν αλήθεια.?

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
ενώ αν βάλουμε απλά αυτό το εμπορικό και το οποίο σημαίνει ότι δεν αντιγράφει ακόμη

549
00:50:06,640 --> 00:50:08,640
ακόμα κι αν δεν το τροποποιήσετε.

550
00:50:08,640 --> 00:50:10,680
Αυτή η συμπεριφορά ονομάζεται copy-on-write.

551
00:50:10,680 --> 00:50:17,380
Θα το δείτε και σε άλλα μέρη, ειδικά αν λάβει μια σειρά μαθημάτων του λειτουργικού συστήματος.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write είναι ένα αρκετά συνηθισμένο μοτίβο, όπου δεν χρειάζεται να δημιουργήσετε ένα αντίγραφο του κάτι

553
00:50:23,880 --> 00:50:26,650
εκτός και αν αυτό είναι στην πραγματικότητα αλλάζει. Ναι.

554
00:50:26,650 --> 00:50:29,520
[Φοιτητής] Τι θα συμβεί αν είχατε την αύξηση στο εσωτερικό της δοκιμής,

555
00:50:29,520 --> 00:50:33,700
οπότε μόνο 1 από το στοιχείο 1000 θα πρέπει να αλλάξει;

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
Στη συνέχεια, «a» δείκτης είναι μια σειρά από [1 2 3 4], και ο δείκτης «β», είναι μια σειρά από οτιδήποτε άλλο.

560
00:51:11,000 --> 00:51:15,380
Χρειάζομαι κόμματα μεταξύ όλων αυτών. Φανταστείτε ότι υπάρχουν κόμματα.

561
00:51:15,380 --> 00:51:21,210
Στη συνέχεια, «γ», είναι το 3 αξία.

562
00:51:24,210 --> 00:51:26,290
Εντάξει.

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 ['c'] + +?

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
επειδή δεν έχω ιδέα κάτω από το καπό όταν αυτό είναι κάνοντας αυτά τα αντίγραφα των πραγμάτων,

585
00:53:52,530 --> 00:53:55,170
Ω, είναι ότι πρόκειται να είναι μια σταθερή αντίγραφο του χρόνου,

586
00:53:55,170 --> 00:54:01,140
είναι ακριβώς πρόκειται να αλλάξει δείκτη 1, είναι αυτό πρόκειται να είναι μια γελοία δύσκολη γραμμική αντίγραφο;

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
Στην 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
Δεδομένου ότι η εργασία με πίνακες κατακερματισμού είναι τόσο εύκολο τώρα, εδώ είναι ένα διασκεδαστικό παζλ για να εργαστούν.

596
00:54:41,980 --> 00:54:45,920
Ανοίξτε ένα αρχείο που ονομάζεται unique.php και να το γράψετε ένα πρόγραμμα PHP

597
00:54:45,920 --> 00:54:48,330
(Επίσης γνωστό ως "σενάριο").

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
στη γραμμή εντολών, μπορείτε να καλέσετε αυτό το σενάριο εκτελέσιμο.

601
00:55:05,920 --> 00:55:08,510
Θα μπορούσα κάλλιστα γράψετε ένα πρόγραμμα C που το κάνει αυτό,

602
00:55:08,510 --> 00:55:12,300
αλλά εγώ δεν το ονομάσουμε ένα σενάριο από τότε που συγκεντρώνουν για πρώτη φορά και στη συνέχεια να εκτελέσετε το δυαδικό.

603
00:55:12,300 --> 00:55:15,480
Αλλά αυτό το πρόγραμμα PHP θα πάμε να καλέσετε ένα σενάριο.

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 σε C, εξακολουθούμε να έχουμε αυτά στην 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 είστε σε αυτή την κατάσταση που είμαστε στο -

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
έτσι ώστε να μην χρειάζεται να επιστρέψει το 1 πράγμα που τότε συνειδητοποιεί ότι υπάρχει ένα σφάλμα

628
00:57:29,650 --> 00:57:32,270
έτσι ώστε να επιστρέφει μέχρι και αν αναγνωρίζει ότι υπήρξε σφάλμα.

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
Αντί να λέμε μόνο $ f. Εντάξει.

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
[Φοιτητής] Δεν θα περάσουμε ακόμα και γραμμές με αναφορά σε κάτι τέτοια;

647
00:59:10,960 --> 00:59:28,850
Αυτό είναι το είδος που θα μπορούσε να οριστεί ως είδος λειτουργία (& $ array).

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. Θα μπορούσα να έχω κάτι μπέρδεμα πάνω.

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
Εντάξει, php.unique.php. Δεν είχα περάσει το επιχείρημα γιατί δεν έχω ένα αρχείο.

667
01:01:09,210 --> 01:01:13,560
Είναι php.unique.php για 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 εγκοπές επίπεδο μας

672
01:01:30,190 --> 01:01:33,360
τότε ελάτε όλοι μας δεν εσοχές.

673
01:01:33,360 --> 01:01:38,620
Ναι. >> [Φοιτητής] Έτσι, για τον πηγαίο κώδικα δεν ψηφίστηκε από αναφορά;

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
Επίσης, τροποποιεί τον πίνακα στη θέση του.

681
01:02:10,200 --> 01:02:17,400
Αυτό είναι απλά δεν επιτρέπεται. Δεν σας επιτρέπεται να το κάνετε αυτό. >> [Φοιτητής] Ω, εντάξει.

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
όπου, επειδή είναι copy-on-write, τώρα ένα αντίγραφο του αντιγράφου πρόκειται να γίνει.

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
Μπορείτε να χρησιμοποιήσετε και να αντιγράψετε γραμμές εναλλάξ.

694
01:03:19,940 --> 01:03:25,430
Μπορείτε να κάνετε unset ($ αντίγραφο)? Και ότι δεν unset γραμμές,

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
Ναι.

699
01:03:42,460 --> 01:03:45,880
[Φοιτητής] Εντελώς εκτός θέματος, αλλά δεν έχετε να κλείσει με την PHP - >> Δεν κάνουμε.

700
01:03:45,880 --> 01:03:47,730
Εντάξει.

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
Αυτό δεν έκανε τίποτα. Τι θα συμβεί αν ήθελα - [αναστενάζει]

705
01:04:13,870 --> 01:04:16,960
Πρέπει να περάσει ένα επιχείρημα.

706
01:04:19,000 --> 01:04:22,050
Shoot. Κάλεσα λάθος.

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 μπλα, μπλα, μπλα τάξη ή οτιδήποτε άλλο,

716
01:05:18,050 --> 01:05:25,140
μπλα, μπλα, μπλα και στη συνέχεια να κάνουμε κάποιες 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
απλά μια αδέσποτη newline στο κάτω μέρος του αρχείου.

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
>> Πώς ανακατευθύνει την εργασία ή οποιαδήποτε εργασία βασικά κεφαλίδες,

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 των δεδομένων που αποστέλλονται.

726
01:06:18,230 --> 01:06:23,140
Μπορείτε να ανακατευθύνετε χιλιάδες φορές, αλλά μόλις το πρώτο byte των δεδομένων που αποστέλλονται

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
Απλά δεν χρειάζεται αυτές τις ετικέτες κλεισίματος.

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 script είναι σπάνιο να το κλείσετε.

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
Με μονά εισαγωγικά δεν μπορείτε να χρησιμοποιήσετε "απόδραση" ακολουθίες.

748
01:08:12,820 --> 01:08:17,640
Συνεχώς ξεφύγει, μπλα, μπλα, μπλα.

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
Και το ωραίο πράγμα για το ενιαίο χορδές απόσπασμα είναι θα μπορούσα να πω "Γειά σου Κόσμε!" μπλα, μπλα, μπλα,

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, η οποία θα έλεγε κανείς ότι θα είναι νέες γραμμές -

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 = "Rob"?

774
01:10:52,730 --> 01:10:58,020
Έτσι echo "Γεια, το όνομά μου είναι $ όνομα!"?

775
01:10:58,020 --> 01:11:09,260
Αυτό το αναγνωρίζει αυτό ως μια μεταβλητή.

776
01:11:09,260 --> 01:11:21,210
Όταν τρέχω ότι - και εγώ θα εισάγει μια νέα γραμμή - Γεια σου, το όνομά μου είναι Rob! γειά σου και τον κόσμο!

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
Γεια, το όνομά μου είναι 1! το οποίο δεν είναι αυτό που ήθελα.

785
01:11:59,860 --> 01:12:05,050
Σύνταξη επισήμανση ψέματα για μένα.

786
01:12:05,050 --> 01:12:13,020
Ας προσπαθήσουμε "ένα" -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
Αυτό είναι το πώς θα πρέπει να το γράψω.

788
01:12:26,350 --> 01:12:32,160
Απροσδόκητη απλό εισαγωγικό (T_ENCAPSED μπλα, μπλα, μπλα, μπλα, μπλα).

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
Θέλετε να το κάνουμε αυτό μέσα σε άγκιστρα,

792
01:12:49,870 --> 01:12:54,730
και τώρα ό, τι είναι σε αυτό το στήριγμα σγουρά θα παρεμβληθούν,

793
01:12:54,730 --> 01:13:00,340
η οποία είναι η λέξη που χρησιμοποιούμε για μαγικά εισαγωγή αυτών των μεταβλητών στις σωστές θέσεις.

794
01:13:00,340 --> 01:13:04,280
Τώρα το κάνετε αυτό, php.unique, και Γεια σου, το όνομά μου είναι 1! όπως αναμένεται

795
01:13:04,280 --> 01:13:07,720
ή Γεια σου, το όνομά μου είναι Rob!

796
01:13:14,110 --> 01:13:23,130
Ένα πράγμα που είναι είδος της Νίκαιας για μονά εισαγωγικά είναι ότι -

797
01:13:23,130 --> 01:13:28,480
Υπάρχει κάποιο κόστος για την παρεμβολή.

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
τίποτα μέσα από αυτά τα διπλά εισαγωγικά θα πρέπει να παρεμβληθούν,

802
01:13:52,220 --> 01:13:56,800
αλλά θα εξακολουθεί να είναι αργή, διότι πρέπει να πάει πέρα ​​από τα διπλά εισαγωγικά

803
01:13:56,800 --> 01:14:00,130
ψάχνουν για πράγματα που πρέπει να παρεμβληθούν.

804
01:14:00,130 --> 01:14:05,360
Έτσι μονά εισαγωγικά μπορεί να είναι λίγο πιο γρήγορα, αν δεν χρειάζεται να παρεμβληθούν,

805
01:14:05,360 --> 01:14:15,650
και έχω την τάση να χρησιμοποιούν ακόμη και μονά εισαγωγικά για «Γεια σου, το όνομά μου είναι». $ Array ['a'] ούτως ή άλλως.

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 εδώ, αυτό ονομάζεται short 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
Αυτό εξακολουθεί να υποστηρίζεται, τόσο σύντομη ετικέτες με το <? = Εξακολουθούν να είναι απολύτως εντάξει.

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
>> Μείνετε αριστοκρατικό, Σαν Ντιέγκο.

822
01:16:13,800 --> 01:16:16,070
[Συγκρατημένα γέλια]

823
01:16:18,620 --> 01:16:22,660
Αντίο. [Γέλια]

824
01:16:24,350 --> 01:16:28,470
[Χειροκροτήματα] [γέλια]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]