1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Section 8 - Plus confortable]

2
00:00:02,610 --> 00:00:04,910
[Rob Bowden - Université de Harvard]

3
00:00:04,910 --> 00:00:07,070
[C'est CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> Ces notes de sections semaines vont être assez court,

5
00:00:14,160 --> 00:00:19,070
donc je vais juste continuer à parler, vous les gars vont continuer à poser des questions,

6
00:00:19,070 --> 00:00:22,720
et nous allons essayer de remplir autant de temps que possible.

7
00:00:22,720 --> 00:00:31,950
Beaucoup de gens pensent que ce pset n'est pas forcément difficile, mais c'est très long.

8
00:00:31,950 --> 00:00:37,070
La spécification pset lui-même prend une heure à lire.

9
00:00:40,530 --> 00:00:45,730
Nous vous donnons une bonne partie du SQL, vous pourriez avoir besoin d'utiliser.

10
00:00:45,730 --> 00:00:50,520
Nous vous guidera à travers beaucoup de lui, il ne devrait pas être trop mauvais.

11
00:00:50,520 --> 00:00:54,560
Quelqu'un at-il commencé ou fini?

12
00:00:55,380 --> 00:00:59,710
C'est le pset dernier. Oh, mon Dieu.

13
00:00:59,710 --> 00:01:05,400
Habituellement, il s'agit d'un JavaScript uns après cela, mais les choses changent calendrier

14
00:01:05,400 --> 00:01:09,560
rend tout 1 semaine plus courte, et nous n'avons plus de pset JavaScript.

15
00:01:09,560 --> 00:01:12,310
Je ne sais pas comment cela affecte si JavaScript est va apparaître sur l'examen

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

17
00:01:15,510 --> 00:01:22,260
J'imagine que ce sera quelque chose que vous avez besoin de savoir des choses de haut niveau sur JavaScript,

18
00:01:22,260 --> 00:01:26,460
mais je doute que nous venions de vous donner directement le code JavaScript

19
00:01:26,460 --> 00:01:28,720
puisque vous n'avez pas eu un pset en elle.

20
00:01:28,720 --> 00:01:33,000
Mais ce sera chose pour examen questionnaire semaine prochaine.

21
00:01:33,000 --> 00:01:36,320
>> Section des questions.

22
00:01:36,320 --> 00:01:43,870
Un grand nombre de ce genre de choses est un peu mal formulée, mais nous allons expliquer pourquoi.

23
00:01:43,870 --> 00:01:50,220
Contrairement au C, PHP est un "typé dynamiquement" la langue. Qu'est-ce que cela veut dire, demandez-vous?

24
00:01:50,220 --> 00:01:53,830
Eh bien, disons au revoir à tous ceux char, float, int, et d'autres mots clés dont vous avez besoin pour utiliser

25
00:01:53,830 --> 00:01:56,190
lors de la déclaration des variables et des fonctions en C.

26
00:01:56,190 --> 00:02:00,420
En PHP, le type d'une variable est déterminée par la valeur qu'il est actuellement retenue.

27
00:02:00,420 --> 00:02:04,990
Donc, avant de taper ce code dans un fichier nommé dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP est typé dynamiquement. C'est vrai.

29
00:02:12,670 --> 00:02:17,590
Je suis en désaccord avec le fait que cela signifie que nous disons au revoir à char, float, int,

30
00:02:17,590 --> 00:02:20,620
et d'autres mots clés.

31
00:02:20,620 --> 00:02:25,510
La différence exacte entre typé dynamiquement et l'alternative,

32
00:02:25,510 --> 00:02:32,010
qui est typé statiquement, c'est que typage dynamique, l'ensemble de votre vérification de type et d'autres choses

33
00:02:32,010 --> 00:02:37,350
qui se passe au moment de l'exécution, alors que statiquement typé, il arrive au moment de la compilation.

34
00:02:37,350 --> 00:02:43,030
Le mot statique en général semble signifier des choses de compilation.

35
00:02:43,030 --> 00:02:48,170
Je pense qu'il ya d'autres utilisations pour elle, mais en C lorsque vous déclarez une variable statique,

36
00:02:48,170 --> 00:02:52,650
sa mémoire est allouée au moment de la compilation.

37
00:02:52,650 --> 00:02:59,260
Ici, à typage dynamique signifie simplement que -

38
00:02:59,260 --> 00:03:04,350
En C, si vous essayez d'ajouter une chaîne et un entier, lorsque vous compilez-le,

39
00:03:04,350 --> 00:03:11,000
il va se plaindre parce qu'il va dire que vous ne pouvez pas ajouter un int et un pointeur.

40
00:03:11,000 --> 00:03:14,710
Il n'est tout simplement pas une opération valide.

41
00:03:14,710 --> 00:03:21,170
C'est une autre chose que nous aurons dans un instant.

42
00:03:21,170 --> 00:03:24,860
Mais ce genre de vérification, le fait qu'elle se plaint au moment de la compilation,

43
00:03:24,860 --> 00:03:29,220
est la vérification de type statique.

44
00:03:29,220 --> 00:03:35,220
Il ya des langues où vous n'avez pas besoin de dire char, float, int, et toutes ces choses,

45
00:03:35,220 --> 00:03:40,940
mais la langue peut dire à partir du contexte de la chose quel type il est censé être,

46
00:03:40,940 --> 00:03:43,980
mais il est toujours typé statiquement.

47
00:03:43,980 --> 00:03:49,000
Donc, si vous prenez 51, OCaml, vous n'avez jamais besoin d'utiliser un de ces types,

48
00:03:49,000 --> 00:03:58,700
mais elle ne sera au moment de la compilation que vous ne pouvez pas faire cela parce que vous mélangez un entier et une chaîne.

49
00:03:58,700 --> 00:04:05,650
Typage dynamique signifie simplement que parfois au cours de l'exécution que vous allez recevoir une plainte.

50
00:04:05,650 --> 00:04:13,430
Si vous avez également utilisé Java avant, en général, presque toutes les langues de type C

51
00:04:13,430 --> 00:04:20,070
va être statiquement typé, donc C, C + +, Java, tous ceux qui sont généralement typé statiquement.

52
00:04:20,070 --> 00:04:22,910
En Java, lorsque vous compilez quelque chose et que vous dites

53
00:04:22,910 --> 00:04:26,670
chaîne s est égal à quelque chose de nouveau qui n'est pas une chaîne,

54
00:04:26,670 --> 00:04:28,950
qui va se plaindre parce que ces types n'ont tout simplement pas à la hauteur.

55
00:04:28,950 --> 00:04:31,180
Cela va se plaindre au moment de la compilation.

56
00:04:31,180 --> 00:04:36,750
Mais elle a aussi un peu de temps dynamique des choses comme si vous essayer de lancer quelque chose

57
00:04:36,750 --> 00:04:40,500
à un type qui est plus spécifique que le type actuel,

58
00:04:40,500 --> 00:04:45,610
il n'y a rien qu'il puisse faire au moment de la compilation pour vérifier si cette fonte va réussir.

59
00:04:45,610 --> 00:04:51,130
Java possède également un certain type dynamique vérifiant que dès qu'il arrive à cette ligne de code

60
00:04:51,130 --> 00:04:54,130
quand il est réellement l'exécuter, il va faire le casting,

61
00:04:54,130 --> 00:04:56,260
vérifier si cette fonte était valide en premier lieu,

62
00:04:56,260 --> 00:04:59,890
et si ce n'était pas le cas, alors il va se plaindre que vous avez un type non valide.

63
00:04:59,890 --> 00:05:03,200
Type dynamique vérification.

64
00:05:03,200 --> 00:05:07,010
Tapez ceci dans un fichier appelé dynamic.php.

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

66
00:05:14,580 --> 00:05:17,190
Je vais décompresser ce formatage.

67
00:05:18,750 --> 00:05:21,880
Nous disposons d'une variable, nous l'avons mis à l'entier 7,

68
00:05:21,880 --> 00:05:27,930
alors nous allons l'imprimer et% s -

69
00:05:27,930 --> 00:05:32,830
Oh, nous imprimons le type de celui-ci, de sorte gettype va retourner le type de la variable.

70
00:05:32,830 --> 00:05:35,720
Nous sommes en train d'imprimer le type maintes et maintes fois.

71
00:05:35,720 --> 00:05:39,440
Nous venons de php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Nous allons voir qu'elle varie d'un entier en chaîne en valeur booléenne que nous traversons.

73
00:05:45,920 --> 00:05:54,590
En C il n'existe pas de type de données Boolean, il n'existe pas de type de données chaîne.

74
00:05:54,590 --> 00:06:00,500
Il ya char * et booléenne tend simplement à être int ou char ou quelque chose.

75
00:06:00,500 --> 00:06:05,690
En PHP ces types existent, et c'est un des grands avantages de PHP sur C -

76
00:06:05,690 --> 00:06:13,290
que les opérations de chaîne sont infiniment plus facile en PHP que C. Ils ont juste travailler.

77
00:06:13,290 --> 00:06:18,290
>> Donc, nous reviendrons ici.

78
00:06:18,290 --> 00:06:21,260
Nous avons couru dynamic.php.

79
00:06:21,260 --> 00:06:26,710
Cela indique à l'interpréteur PHP, php appelé, pour exécuter le code PHP dans dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Si vous avez des erreurs dans le fichier, l'interprète vous le diront!

81
00:06:30,250 --> 00:06:39,110
L'interprète, c'est une autre grande différence entre PHP et C.

82
00:06:39,110 --> 00:06:48,200
En C, vous devez compiler quelque chose et puis vous exécutez ce fichier compilé.

83
00:06:48,200 --> 00:06:50,490
En PHP, vous ne jamais compiler quoi que ce soit.

84
00:06:50,490 --> 00:06:57,200
Ainsi, l'interpréteur PHP est fondamentalement juste la lecture ligne par ligne.

85
00:06:57,200 --> 00:07:02,900
Il frappe var = 7, puis il frappe printf puis il frappe var puis il frappe printf et ainsi de suite.

86
00:07:02,900 --> 00:07:10,910
Il ya un peu de la compilation, il le fait, et il met en cache les résultats

87
00:07:10,910 --> 00:07:15,510
donc si vous exécutez le script plus tard, vous pouvez le faire certains,

88
00:07:15,510 --> 00:07:19,280
mais au fond, c'est une ligne trier par ligne de chose.

89
00:07:19,280 --> 00:07:25,280
Cela signifie que beaucoup des optimisations que nous obtenons en C,

90
00:07:25,280 --> 00:07:31,920
comme la compilation, c'est juste généralement le compilateur peut faire beaucoup de trucs pour vous.

91
00:07:31,920 --> 00:07:36,110
Il peut prendre les variables inutilisées, il peut faire toutes ces sortes de choses,

92
00:07:36,110 --> 00:07:38,660
il peut faire la récursivité terminale.

93
00:07:38,660 --> 00:07:42,550
En PHP, vous n'allez pas obtenir cet avantage

94
00:07:42,550 --> 00:07:45,690
car il va juste commencer à exécuter ligne par ligne par ligne,

95
00:07:45,690 --> 00:07:49,950
et il ne reconnaît pas vraiment ces choses aussi facilement

96
00:07:49,950 --> 00:07:54,440
car ce n'est pas 1 pass compilation big sur la chose, puis l'exécution;

97
00:07:54,440 --> 00:07:56,860
c'est juste ligne par ligne.

98
00:08:00,730 --> 00:08:02,750
Donc, c'est l'interprète.

99
00:08:02,750 --> 00:08:06,840
>> Retour à notre typage dynamique: assez cool, hein?

100
00:08:06,840 --> 00:08:08,640
Vous avez certainement ne pouvait pas le faire en C!

101
00:08:08,640 --> 00:08:11,860
Maintenant, voyez si vous pouvez déterminer le type de chacune des valeurs suivantes.

102
00:08:11,860 --> 00:08:14,760
Voir ce pour référence.

103
00:08:14,760 --> 00:08:19,420
Donc, 3,50. Quel type pensez-vous que ça va être?

104
00:08:24,480 --> 00:08:26,370
Voici les types que nous avons.

105
00:08:26,370 --> 00:08:30,430
Nous avons bools, entiers, flottants, chaînes, tableaux, objets,

106
00:08:30,430 --> 00:08:38,370
puis les ressources, ce qui est assez vague.

107
00:08:38,370 --> 00:08:41,010
Je pense qu'il ya effectivement un exemple ici.

108
00:08:41,010 --> 00:08:43,740
Ensuite, il ya la valeur NULL. NULL est un type spécial.

109
00:08:43,740 --> 00:08:47,140
Contrairement au C où NULL est juste un pointeur avec l'adresse 0,

110
00:08:47,140 --> 00:08:54,930
en PHP, NULL est son propre type où la seule chose valable de ce type est NULL.

111
00:08:57,560 --> 00:09:00,670
Cela est beaucoup plus utile pour la vérification d'erreur.

112
00:09:00,670 --> 00:09:04,310
En C, où nous avons eu ce problème où si vous retournera NULL,

113
00:09:04,310 --> 00:09:08,660
ça veut dire que vous êtes de retour un pointeur NULL NULL ou utiliser pour signifier erreur

114
00:09:08,660 --> 00:09:12,380
tout ou partie de cette confusion que nous avions à un moment donné.

115
00:09:12,380 --> 00:09:18,440
Ici, renvoyer NULL signifie généralement une erreur.

116
00:09:20,860 --> 00:09:27,300
Beaucoup de choses retournent également false à l'erreur.

117
00:09:27,300 --> 00:09:33,140
Mais le point est le type NULL, la seule chose que du type NULL est NULL.

118
00:09:33,140 --> 00:09:40,090
Puis rappel est comme vous pouvez définir des fonctions anonymes.

119
00:09:40,090 --> 00:09:46,420
Vous n'avez pas à donner à la fonction d'un nom, mais vous n'aurez pas à faire face à cela ici.

120
00:09:46,420 --> 00:09:53,940
En regardant les types qu'ils ne s'attendent que nous sachions,

121
00:09:53,940 --> 00:09:59,000
que pensez-vous du type de 3.50 est? >> [L'élève] Float.

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

123
00:10:00,370 --> 00:10:06,290
Alors ici, que pensez-vous du type de ce que c'est? >> [L'élève] Array.

124
00:10:06,290 --> 00:10:09,890
Ouais. La première est une float, le second est un tableau.

125
00:10:09,890 --> 00:10:14,500
Notez que ce tableau n'est pas comme un tableau C

126
00:10:14,500 --> 00:10:19,610
où vous avez l'index 0 a une certaine valeur, l'indice 1 a une certaine valeur.

127
00:10:19,610 --> 00:10:26,320
Ici les indices sont a, b et c et les valeurs sont 1, 2, et 3.

128
00:10:26,320 --> 00:10:33,980
En PHP il n'ya pas de différence entre un tableau associatif et tout un réseau régulier

129
00:10:33,980 --> 00:10:36,740
comme on aurait pu penser qu'il en C.

130
00:10:36,740 --> 00:10:43,040
Il ya juste cela, et sous le capot un réseau régulier est juste un tableau associatif

131
00:10:43,040 --> 00:10:50,000
où 0 correspond à une certaine valeur de la même façon une carte à une certaine valeur.

132
00:10:50,000 --> 00:11:00,410
Pour cette raison, PHP peut être assez mauvais pour vraiment rapides de code / benchmarking des choses

133
00:11:00,410 --> 00:11:07,930
puisque dans C lorsque vous utilisez un tableau, vous savez que l'accès à un membre est la constante de temps.

134
00:11:07,930 --> 00:11:11,860
En PHP d'accéder à un membre est qui sait combien de temps?

135
00:11:11,860 --> 00:11:18,970
C'est probablement constante si elle hachages correctement.

136
00:11:18,970 --> 00:11:21,620
Qui sait ce qu'il fait réellement sous le capot?

137
00:11:21,620 --> 00:11:25,600
Vous avez vraiment besoin de regarder la mise en œuvre de voir comment il va s'en occuper.

138
00:11:25,600 --> 00:11:28,550
Alors fopen.

139
00:11:28,550 --> 00:11:36,420
Je pense ici nous allons simplement PHP fopen manuel de regarder le type de retour.

140
00:11:36,420 --> 00:11:41,260
Nous voyons ici que vous pouvez regarder à peu près n'importe quelle fonction dans le manuel PHP

141
00:11:41,260 --> 00:11:47,540
et c'est en quelque sorte la page de manuel de PHP.

142
00:11:47,540 --> 00:11:51,060
Le type de retour va être des ressources.

143
00:11:51,060 --> 00:11:56,050
C'est pourquoi je l'ai cherché, parce que nous n'avons pas vraiment définir des ressources.

144
00:11:56,050 --> 00:12:04,110
L'idée de la ressource, en C, vous sorte de se FILE * ou que ce soit;

145
00:12:04,110 --> 00:12:07,200
PHP, la ressource est votre FILE *.

146
00:12:07,200 --> 00:12:10,360
C'est ce que vous allez lire à partir, c'est ce que vous allez écrire à.

147
00:12:10,360 --> 00:12:20,710
Il est généralement externe, donc c'est une ressource que vous pouvez tirer les choses et jeter des choses à.

148
00:12:20,710 --> 00:12:26,520
Et enfin, quel est le type de la valeur NULL? >> [L'élève] NULL.

149
00:12:26,520 --> 00:12:30,650
Ouais. Donc, la seule chose qui vaut NULL est NULL.

150
00:12:30,650 --> 00:12:33,480
NULL est NULL.

151
00:12:35,490 --> 00:12:41,170
>> Une des caractéristiques de système de type PHP (pour le meilleur ou pour le pire) est sa capacité à jongler avec les types.

152
00:12:41,170 --> 00:12:44,390
Lorsque vous écrivez une ligne de code PHP qui combine les valeurs des différents types,

153
00:12:44,390 --> 00:12:46,670
PHP va essayer de faire la chose sensée.

154
00:12:46,670 --> 00:12:48,920
Essayez chacune des lignes suivantes de code PHP. Qu'est-ce une impression?

155
00:12:48,920 --> 00:12:51,000
Est-ce que vous attendiez? Pourquoi ou pourquoi pas?

156
00:12:51,000 --> 00:12:58,600
Ce fait à propos de PHP est ce qu'il fait ce que nous appelons faiblement typé.

157
00:12:58,600 --> 00:13:04,610
Faiblement typé et fortement typé,

158
00:13:04,610 --> 00:13:06,840
il ya différentes utilisations de ces termes,

159
00:13:06,840 --> 00:13:12,020
mais la plupart des gens utilisent faiblement typé et fortement typé à dire ce genre de chose

160
00:13:12,020 --> 00:13:15,920
où ("1" + 2); qui fonctionne.

161
00:13:15,920 --> 00:13:18,290
En C qui ne fonctionnerait pas.

162
00:13:18,290 --> 00:13:22,490
Vous pouvez imaginer ce ne fonctionne pas.

163
00:13:22,490 --> 00:13:29,200
Beaucoup de gens mélangent le typage dynamique et typage faible et typage statique et le typage fort.

164
00:13:29,200 --> 00:13:34,050
Python est un autre exemple d'une langue qui est typé dynamiquement.

165
00:13:34,050 --> 00:13:41,770
Vous pouvez jeter autour des différents types de variables et il va déterminer lors de l'exécution

166
00:13:41,770 --> 00:13:44,680
des vérifications d'erreur.

167
00:13:44,680 --> 00:13:50,740
En Python il va exécuter cela et il verra ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
et cela va échouer, car il dit que vous ne pouvez pas ajouter une chaîne et un entier.

169
00:13:55,920 --> 00:14:00,860
En PHP, ce qui est tout aussi typé dynamiquement, ce qui ne manquera pas.

170
00:14:00,860 --> 00:14:04,220
Typage faible a à voir avec le fait qu'il fait des choses avec des types

171
00:14:04,220 --> 00:14:07,800
qui n'ont pas vraiment de sens nécessairement.

172
00:14:07,800 --> 00:14:17,420
Donc ("1" + 2), je ne peux imaginer que d'être la chaîne de 12, je ne peux imaginer qu'il soit la chaîne 3,

173
00:14:17,420 --> 00:14:20,710
Je ne peux imaginer qu'il soit l'entier 3.

174
00:14:20,710 --> 00:14:24,530
Ce n'est pas forcément bien défini, et nous allons probablement voir ici

175
00:14:24,530 --> 00:14:29,140
que lorsque nous imprimons ("1" + 2), il va probablement finir par être différent

176
00:14:29,140 --> 00:14:32,320
que l'impression (1 + "2").

177
00:14:32,320 --> 00:14:39,700
Et cela tend à être, à mon avis, pour le pire.

178
00:14:39,700 --> 00:14:44,240
Ici, nous pouvons essayer de celles-ci.

179
00:14:44,240 --> 00:14:48,740
Un autre petit truc à propos de PHP est que vous n'avez pas besoin d'écrire le fichier.

180
00:14:48,740 --> 00:14:52,790
Il ne dirigent cette mode commande.

181
00:14:52,790 --> 00:14:57,710
Donc php-r, alors on peut jeter dans la commande ici:

182
00:14:57,710 --> 00:15:06,610
"Print ('1 '+ 2);» et je vais jeter une nouvelle ligne.

183
00:15:19,550 --> 00:15:23,970
Cet imprimé 3.

184
00:15:31,100 --> 00:15:35,330
On dirait qu'il imprime 3 et c'est l'entier 3.

185
00:15:35,330 --> 00:15:38,420
Alors maintenant, nous allons essayer dans l'autre sens:

186
00:15:38,420 --> 00:15:42,970
"Impression (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
On obtient 3, et est-elle aussi va être entier 3? Honnêtement, je n'en ai aucune idée.

188
00:15:50,490 --> 00:15:54,030
On dirait que c'est cohérent.

189
00:15:54,030 --> 00:15:59,550
Il n'y a jamais aucune chance que ce soit le 12 cordes ou quelque chose comme ça

190
00:15:59,550 --> 00:16:08,080
parce que PHP, contrairement à JavaScript et Java aussi,

191
00:16:08,080 --> 00:16:11,670
dispose d'un exploitant distinct pour la concaténation.

192
00:16:11,670 --> 00:16:14,930
Concaténation en PHP est dot.

193
00:16:14,930 --> 00:16:22,950
Donc impression (1 '2 '.); Va nous donner 12.

194
00:16:25,790 --> 00:16:32,420
Cela tend à créer une confusion, où les gens essaient de faire quelque chose comme str + =

195
00:16:32,420 --> 00:16:37,840
une autre chose qu'ils veulent ajouter à la fin de leur chaîne, et cela va à l'échec.

196
00:16:37,840 --> 00:16:40,770
Vous devez faire str. =

197
00:16:42,000 --> 00:16:46,240
Alors n'oubliez pas de concaténation en PHP est un point.

198
00:16:46,240 --> 00:16:52,100
D'autres choses à essayer: print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Je vous ai dit qu'il n'y a aucun espoir de ce résultat CS50

200
00:17:03,610 --> 00:17:06,119
depuis concaténation n'est pas +.

201
00:17:06,119 --> 00:17:08,440
Que pensez-vous que cela va finir par être?

202
00:17:10,359 --> 00:17:13,460
Honnêtement, je n'ai absolument aucune idée.

203
00:17:14,250 --> 00:17:16,460
On dirait que c'est juste 50.

204
00:17:16,460 --> 00:17:21,490
Il voit la corde, et je parie que si nous mettons 123CS -

205
00:17:21,490 --> 00:17:29,640
Il voit la première chaîne, il essaie de lire un entier de lui ou d'elle un certain nombre.

206
00:17:29,640 --> 00:17:31,710
Dans ce cas, il voit 123CS.

207
00:17:31,710 --> 00:17:35,190
"Cela n'a pas de sens comme un entier, donc je vais juste penser à 123."

208
00:17:35,190 --> 00:17:38,580
Donc 123 + 50 va être 173.

209
00:17:38,580 --> 00:17:40,740
Et là, il commence à lire cela comme un nombre entier.

210
00:17:40,740 --> 00:17:45,690
Il ne voit rien, il traite simplement comme 0. Donc, 0 + 50 va être 50.

211
00:17:45,690 --> 00:17:51,600
Ce que je suis en supposant que va faire quelque chose de similaire.

212
00:17:51,600 --> 00:17:54,310
Je pense 99.

213
00:17:54,310 --> 00:17:57,580
Oui, parce que ça va prendre la première -

214
00:18:12,880 --> 00:18:15,730
Ainsi, 99.

215
00:18:15,730 --> 00:18:21,970
Ici (7.10), si ce n'était C, qu'est-ce que revenir?

216
00:18:23,700 --> 00:18:29,630
[L'élève] 1. Oui >>, il serait 1 car 10/7 divise 2 entiers.

217
00:18:29,630 --> 00:18:32,910
Un entier divisé par un entier va retourner un entier.

218
00:18:32,910 --> 00:18:37,750
Il ne peut pas retourner 1 quelque point que ce serait, donc il va juste revenir 1.

219
00:18:37,750 --> 00:18:46,120
Ici, l'impression (10/7), il va interpréter ce fait.

220
00:18:46,120 --> 00:18:53,760
Et cela signifie que si vous voulez vraiment faire l'arrondi entier et des trucs comme ça,

221
00:18:53,760 --> 00:18:59,950
vous devez faire impression (plancher (10/7));

222
00:18:59,950 --> 00:19:08,460
En C, c'est probablement bizarre que vous pouvez compter sur troncature entier régulièrement,

223
00:19:08,460 --> 00:19:12,260
mais en PHP, vous ne pouvez pas car il sera automatiquement transformer en un flotteur.

224
00:19:13,430 --> 00:19:17,610
Et puis (7 + true); que pensez-vous que ça va être?

225
00:19:18,550 --> 00:19:23,640
Je devine que 8 si elle va interpréter vrai que 1.

226
00:19:23,640 --> 00:19:25,740
Il semble que c'est 8.

227
00:19:25,740 --> 00:19:31,710
>> Donc tout ce que nous avons fait dans les 10 dernières minutes, vous devez absolument jamais faire.

228
00:19:31,710 --> 00:19:39,870
Vous verrez du code qui fait cela.

229
00:19:39,870 --> 00:19:42,700
Il n'a pas besoin d'être aussi simple que cela.

230
00:19:42,700 --> 00:19:47,240
Vous pourriez avoir 2 variables, et 1 variable se trouve être une chaîne

231
00:19:47,240 --> 00:19:51,310
et l'autre variable se trouve être un int, et puis vous ajoutez ces variables entre elles.

232
00:19:51,310 --> 00:20:00,120
Depuis PHP est typé dynamiquement et il ne fera pas de vérification de type pour vous

233
00:20:00,120 --> 00:20:03,640
et depuis il est faiblement typé et depuis il va juste jeter automatiquement ces choses ensemble

234
00:20:03,640 --> 00:20:11,490
et tout marchera bien, il est difficile même de savoir que cette variable doit être une chaîne de maintenant,

235
00:20:11,490 --> 00:20:14,930
si je ne devrais pas ajouter à cette variable, qui est un entier.

236
00:20:18,780 --> 00:20:24,560
La meilleure pratique est de savoir si une variable est une chaîne, gardez-le comme une chaîne pour toujours.

237
00:20:24,560 --> 00:20:26,980
Si une variable est de type int, le garder comme un int pour toujours.

238
00:20:26,980 --> 00:20:30,770
Si vous voulez traiter avec des entiers et des chaînes,

239
00:20:30,770 --> 00:20:36,970
vous pouvez utiliser varsint - c'est JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Je le fais tout le temps. PHP et JavaScript je mélange tout.

241
00:20:42,520 --> 00:20:47,600
Donc intval va retourner la valeur entière d'une variable.

242
00:20:47,600 --> 00:20:56,550
Si nous passons "d'impression (intval ('123 ')); vous obtenez 123.

243
00:21:06,820 --> 00:21:15,850
Intval lui-même ne va pas faire la vérification pour nous que c'est exclusivement un entier.

244
00:21:15,850 --> 00:21:20,460
Le manuel PHP, il existe des fonctions tellement nombreux disponibles,

245
00:21:20,460 --> 00:21:26,560
alors voici ce que je pense que j'utiliserais est is_numeric premier.

246
00:21:26,560 --> 00:21:32,590
Je devine que retourné false.

247
00:21:32,590 --> 00:21:35,780
C'est une autre chose que nous devons aller plus est. ===

248
00:21:37,850 --> 00:21:44,020
Donc is_numeric ('123df »), vous ne penseriez pas que is_numeric.

249
00:21:44,020 --> 00:21:46,720
En C il vous faudra parcourir tous les caractères

250
00:21:46,720 --> 00:21:50,410
et vérifier si chaque caractère est un chiffre ou que ce soit.

251
00:21:50,410 --> 00:21:53,850
Voici is_numeric va le faire pour nous,

252
00:21:53,850 --> 00:21:56,520
et il retourne false.

253
00:21:56,520 --> 00:22:02,120
Alors, quand j'ai imprimé qui, a imprimé rien, donc ici je compare cela à voir,

254
00:22:02,120 --> 00:22:05,490
ne vous arrive d'être faux? Et maintenant c'est l'impression 1.

255
00:22:05,490 --> 00:22:10,060
Apparemment, il affiche 1 comme véritable lieu d'imprimer vrai que vrai.

256
00:22:10,060 --> 00:22:15,790
Je me demande si je fais print_r. Non, cela ne fonctionne toujours 1.

257
00:22:15,790 --> 00:22:26,760
>> Pour en revenir à ===, == existe toujours,

258
00:22:26,760 --> 00:22:32,260
et si vous parlez à Tommy, il dira == est parfaitement bien.

259
00:22:32,260 --> 00:22:37,700
Je vais dire que == est terrible et il ne faut jamais utiliser ==.

260
00:22:37,700 --> 00:22:44,870
La différence est que == compare des choses

261
00:22:44,870 --> 00:22:48,450
où il peut être vrai même si elles ne sont pas du même type,

262
00:22:48,450 --> 00:22:53,810
tandis === compare des choses et d'abord il vérifie qu'ils sont du même type?

263
00:22:53,810 --> 00:22:58,010
Oui. Bon, maintenant je vais voir si elles réellement comparer à être égaux.

264
00:22:58,010 --> 00:23:08,890
Vous obtenez des choses bizarres comme 10 égale - Voyons voir ce que cela dit.

265
00:23:08,890 --> 00:23:15,570
Donc ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
Cela renvoie vrai.

267
00:23:17,980 --> 00:23:21,420
Quelqu'un at-il devine pourquoi cette retourne vrai?

268
00:23:25,180 --> 00:23:27,120
Il ne s'agit pas seulement de cela. C'est peut-être un indice.

269
00:23:27,120 --> 00:23:33,170
Mais si je change que pour un f - bon sang! Je continuer à utiliser des guillemets doubles.

270
00:23:33,170 --> 00:23:38,780
La raison pour laquelle les guillemets sont de me crier dessus parce que je l'ai mis entre guillemets.

271
00:23:38,780 --> 00:23:43,850
Ainsi, j'ai pu échapper les guillemets ici, mais apostrophes rendre plus facile.

272
00:23:43,850 --> 00:23:49,120
Donc ('10 '== '1 f1'); n'imprime pas vrai. ('10 '== '1 E1'); imprime vrai.

273
00:23:49,120 --> 00:23:56,330
[L'élève] Est-ce hex? >> Ce n'est pas hexagonale, mais il est proche que c'est comme -

274
00:23:56,330 --> 00:24:01,060
1e1, la notation scientifique.

275
00:24:01,060 --> 00:24:07,950
Il reconnaît que 1e1 1 * 10 ^ 1 ou peu importe.

276
00:24:07,950 --> 00:24:11,510
Ce sont des nombres entiers égaux.

277
00:24:11,510 --> 00:24:15,930
Si nous ne faisons === alors ça va être faux.

278
00:24:15,930 --> 00:24:28,490
En fait, je n'ai aucune idée si nous ne faisons que dire == (10 et '10abc ');? Très bien. Donc, c'est vrai.

279
00:24:28,490 --> 00:24:35,940
Donc, tout comme lorsque vous l'avez fait (10 + '10abc '), et il serait de 20,

280
00:24:35,940 --> 00:24:38,800
ici (10 '10abc == '); est vrai.

281
00:24:38,800 --> 00:24:45,350
Pire encore sont des choses comme (faux == NULL); est vrai

282
00:24:45,350 --> 00:24:52,210
ou (false == 0); est vrai, (false == []);

283
00:24:52,210 --> 00:25:00,970
Il ya des cas étranges de - C'est un de ces cas étranges.

284
00:25:00,970 --> 00:25:08,110
Notez que (false == []); est vrai.

285
00:25:08,110 --> 00:25:11,950
('0 '== False); est vrai.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); Est fausse.

287
00:25:16,090 --> 00:25:19,090
Donc == n'est en aucune façon transitive.

288
00:25:19,090 --> 00:25:26,830
a peut être égal à b et a peut être égal à c,

289
00:25:26,830 --> 00:25:29,340
mais b peut ne pas être égale à c.

290
00:25:29,340 --> 00:25:35,580
C'est une abomination à moi, et vous devriez toujours utiliser. ===

291
00:25:35,580 --> 00:25:38,590
[L'élève] Pouvons-nous faire! == Ainsi? >> [Bowden] Oui.

292
00:25:38,590 --> 00:25:44,600
L'équivalent serait! = Et! ==.

293
00:25:44,600 --> 00:25:48,230
Il s'agit en fait élevé dans la spécification pset

294
00:25:48,230 --> 00:25:52,000
où un grand nombre de fonctions renvoient -

295
00:25:52,000 --> 00:25:53,890
Le manuel PHP est bon à ce sujet.

296
00:25:53,890 --> 00:25:59,140
Il met dans une grande boîte rouge, "Ceci renvoie false si il ya une erreur."

297
00:25:59,140 --> 00:26:03,940
Mais 0 scrutin est une chose tout à fait raisonnable d'y retourner.

298
00:26:03,940 --> 00:26:08,250
Pensez à n'importe quelle fonction qui devrait retourner un entier.

299
00:26:11,250 --> 00:26:17,880
Disons que cette fonction est supposée compter le nombre de lignes dans un fichier ou quelque chose.

300
00:26:17,880 --> 00:26:23,490
Dans des circonstances normales, vous passez cette fonction dans un fichier

301
00:26:23,490 --> 00:26:27,120
et il va retourner un entier qui représente le nombre de lignes.

302
00:26:27,120 --> 00:26:30,820
Donc 0 est un nombre tout à fait raisonnable si le fichier est tout simplement vide.

303
00:26:30,820 --> 00:26:36,810
Mais que faire si vous lui transmettez un fichier non valide et la fonction qui arrive à retourner faux

304
00:26:36,810 --> 00:26:38,860
si vous lui passez un fichier non valide?

305
00:26:38,860 --> 00:26:46,500
Si vous venez de faire == vous n'êtes pas différencier le cas entre fichier non valide et le fichier vide.

306
00:26:48,870 --> 00:26:51,350
Toujours utiliser ===.

307
00:26:55,690 --> 00:26:58,000
C'est tout cela.

308
00:26:58,000 --> 00:27:01,660
>> En PHP, le type de tableau est différent de ce que vous êtes habitué à en C.

309
00:27:01,660 --> 00:27:06,650
En effet, vous avez déjà noté ce ci-dessus quand vous avez vu que c'est de type tableau.

310
00:27:06,650 --> 00:27:15,640
La syntaxe est nouveau support de PHP 5.4, qui est la dernière version de PHP.

311
00:27:15,640 --> 00:27:36,960
Avant ce que vous avez toujours eu à écrire array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
C'était le constructeur pour un tableau.

313
00:27:41,160 --> 00:27:45,950
Maintenant, PHP est enfin venu autour de la syntaxe agréable de seulement crochets,

314
00:27:45,950 --> 00:27:50,900
qui est juste tellement mieux que tableau.

315
00:27:50,900 --> 00:27:54,480
Mais compte tenu de PHP 5.4 est la version la plus récente,

316
00:27:54,480 --> 00:27:59,090
vous pouvez rencontrer des endroits qui n'ont même pas de PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Durant l'été, nous sommes tombés sur cette question où PHP 5.3 était ce que nous avions sur l'appareil,

318
00:28:08,220 --> 00:28:14,480
mais le serveur que nous avons déployé toute notre carnet de notes et de soumettre, et tout ça à

319
00:28:14,480 --> 00:28:16,750
PHP est 5,4.

320
00:28:16,750 --> 00:28:23,060
Ne sachant pas cela, nous avons développé en 5.3, poussé à 5,4,

321
00:28:23,060 --> 00:28:25,660
et maintenant, tout d'un coup, rien de notre code fonctionne

322
00:28:25,660 --> 00:28:28,680
car il est arrivé à modifications ont été apportées entre 5,3 et 5,4

323
00:28:28,680 --> 00:28:31,030
qui ne sont pas rétro-compatible,

324
00:28:31,030 --> 00:28:35,770
et nous devons aller et fixer l'ensemble de nos choses qui ne fonctionnent pas pour PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
Pour cette classe, puisque l'appareil ne doivent PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
il est tout à fait possible d'utiliser des crochets.

327
00:28:47,240 --> 00:28:50,440
Mais si vous cherchez des choses autour de l'Internet,

328
00:28:50,440 --> 00:28:54,880
si vous cherchez un peu de genre de trucs ensemble, très probablement vous allez voir

329
00:28:54,880 --> 00:29:02,020
le sort sur la syntaxe constructeur de tableau depuis qui a été autour depuis PHP est né

330
00:29:02,020 --> 00:29:07,340
et la syntaxe crochet a été autour depuis les deux derniers mois

331
00:29:07,340 --> 00:29:10,020
ou chaque fois 5,4 est venu autour.

332
00:29:10,020 --> 00:29:12,710
C'est ainsi que vous l'index.

333
00:29:12,710 --> 00:29:30,610
Tout comme dans la façon dont vous le feriez C indice entre crochets comme $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
vous indexez la même façon si vous arrive d'avoir vos indices étant chaînes.

335
00:29:36,320 --> 00:29:40,440
Tableau afin $ array ['a'] et $ ['b'].

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. Pourquoi serait-ce mal?

337
00:29:52,490 --> 00:29:59,870
Il va probablement générer un avertissement, mais encore du travail. PHP a tendance à le faire.

338
00:29:59,870 --> 00:30:04,890
Il a tendance à tout simplement: «Je vais vous mettre en garde à ce sujet, mais je vais juste continuer

339
00:30:04,890 --> 00:30:07,550
»Et faire tout ce que je peux."

340
00:30:07,550 --> 00:30:11,500
Il se traduiront probablement ce à une chaîne,

341
00:30:11,500 --> 00:30:15,000
mais il est possible qu'à un moment donné dans le passé, quelqu'un a dit

342
00:30:15,000 --> 00:30:20,180
b définissent comme «BONJOUR TOUT LE MONDE".

343
00:30:20,180 --> 00:30:28,740
Alors maintenant, b pourrait être une constante de type tableau et $ [b] sera effectivement faire "BONJOUR TOUT LE MONDE".

344
00:30:28,740 --> 00:30:32,380
Je pense qu'à ce moment-là, ou du moins nos paramètres de PHP,

345
00:30:32,380 --> 00:30:37,870
si vous essayez d'index dans un tableau et que la clé n'existe pas, ce sera un échec.

346
00:30:37,870 --> 00:30:40,150
Je ne pense pas que cela va simplement vous mettre en garde.

347
00:30:40,150 --> 00:30:44,560
Ou au moins vous pouvez le configurer de sorte qu'il n'est pas juste vous mettre en garde, il ne parvient pas tout droit vers le haut.

348
00:30:44,560 --> 00:30:49,290
>> La façon dont vous vérifier pour voir si il ya effectivement un tel indice est isset.

349
00:30:49,290 --> 00:30:54,690
Donc isset ($ array ['BONJOUR TOUT LE MONDE']) renvoie false.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['b']) renverra vrai.

351
00:31:06,830 --> 00:31:09,880
Vous pouvez mélanger ces syntaxes.

352
00:31:15,060 --> 00:31:22,440
Je suis assez sûr de ce que ce tableau finirait par être est - Nous pouvons le tester.

353
00:31:43,290 --> 00:31:45,700
Oh, j'ai besoin PHPWord.

354
00:31:53,960 --> 00:32:00,260
Ce mélange est la syntaxe vous permet de spécifier ce que la clé est

355
00:32:00,260 --> 00:32:03,330
et vous ne spécifiez pas ce que la clé est.

356
00:32:03,330 --> 00:32:05,520
Ainsi, 3 à droite ici est une valeur.

357
00:32:05,520 --> 00:32:08,080
Vous n'avez pas dit explicitement ce que sa clé va être.

358
00:32:08,080 --> 00:32:11,670
Que pensez-vous de sa clé va être?

359
00:32:11,670 --> 00:32:21,410
[L'élève] 0. >> Je devine 0 uniquement parce que c'est la première que nous n'avons pas spécifié.

360
00:32:21,410 --> 00:32:23,500
Nous pouvons en fait faire une ou deux de ces cas.

361
00:32:23,500 --> 00:32:28,030
Donc print_r est d'imprimer récursive. Il permet d'imprimer le tableau entier.

362
00:32:28,030 --> 00:32:32,700
Il imprimer sous-réseaux du réseau s'il y en avait.

363
00:32:32,700 --> 00:32:36,630
Donc print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
Il ne ressemble elle lui a donné 0.

365
00:32:38,810 --> 00:32:43,530
Il ya vraiment quelque chose à garder à l'esprit ici, mais nous allons y revenir dans un instant.

366
00:32:43,530 --> 00:32:45,850
Mais que faire si il m'arrive de faire cet indice 1?

367
00:32:45,850 --> 00:32:51,170
PHP ne fait pas de distinction entre les indices des chaînes et des indices entiers,

368
00:32:51,170 --> 00:33:00,280
sorte à ce point que je viens de définir un index 1 et je peux faire les deux $ array [1] et $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
et ce sera le même indice et la même clé.

370
00:33:06,250 --> 00:33:13,000
Alors maintenant, que pensez-vous 3 va être? >> [L'élève] 2. >> [Bowden] Je devine 2.

371
00:33:16,000 --> 00:33:18,690
Ouais. Il est 2.

372
00:33:18,690 --> 00:33:24,790
Et si nous faisions cela est 10, c'est 4? Que pensez-vous de l'indice de 3 va être?

373
00:33:27,360 --> 00:33:29,110
Je pense 11.

374
00:33:29,110 --> 00:33:33,060
Ma conjecture quant à ce que PHP ne - et je crois que j'ai vu cela auparavant -

375
00:33:33,060 --> 00:33:39,760
est il ne cesse de trace de ce que le plus grand index numérique il est utilisé jusqu'à présent est.

376
00:33:39,760 --> 00:33:44,230
Il ne va jamais d'attribuer un indice chaîne à 3. Ce sera toujours un index numérique.

377
00:33:44,230 --> 00:33:47,690
Ainsi, il conserve la trace de la plus haute il est assigné à ce jour, qui se trouve être 10,

378
00:33:47,690 --> 00:33:52,540
et il va donner 11 à 3.

379
00:33:52,540 --> 00:34:02,110
Ce que j'ai dit avant, remarquez la façon dont elle est l'impression de ce tableau.

380
00:34:02,110 --> 00:34:06,850
Elle imprime 10 Touche, touche 4, clé de 11, clé d.

381
00:34:06,850 --> 00:34:09,790
Ou encore, faisons -

382
00:34:15,760 --> 00:34:22,489
Je suppose que je n'ai pas mis un 0, mais c'est l'impression 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Que faire si je passe ici? Ou encore, fait passer ces 2.

384
00:34:29,330 --> 00:34:31,940
Maintenant, il imprime 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
Tableaux PHP ne sont pas exactement comme votre table de hachage régulière.

386
00:34:41,270 --> 00:34:45,570
Il est parfaitement raisonnable de les considérer comme des tables de hachage 99% du temps.

387
00:34:45,570 --> 00:34:53,790
Mais dans vos tables de hachage ça n'a aucun sens de l'ordre dans lequel les choses ont été insérés.

388
00:34:53,790 --> 00:34:56,639
Donc dès que vous l'insérez dans votre table de hachage,

389
00:34:56,639 --> 00:35:00,590
supposons qu'il n'ya pas de liste, et vous pourriez juger dans une liste chaînée

390
00:35:00,590 --> 00:35:03,980
qui a été insérée en premier.

391
00:35:03,980 --> 00:35:10,060
Mais ici, nous avons inséré première 2 et il sait quand il a l'impression de ce tableau que 2 vient en premier.

392
00:35:10,060 --> 00:35:13,090
Il n'a pas l'imprimer dans n'importe quel ordre.

393
00:35:13,090 --> 00:35:17,550
La structure des données techniques que c'est en utilisant une carte ordonné,

394
00:35:17,550 --> 00:35:24,690
il mappe les touches aux valeurs et il se souvient de l'ordre dans lequel ces clés ont été insérés.

395
00:35:24,690 --> 00:35:31,600
Fondamentalement, c'est à des complications où il est ennuyeux de fait -

396
00:35:31,600 --> 00:35:34,510
Disons que vous avez un tableau 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
et vous voulez sortir indice 2.

398
00:35:37,700 --> 00:35:47,750
Une façon de le faire, nous allons voir à quoi ça ressemble.

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

400
00:35:50,410 --> 00:35:54,880
Unset arrive à désarmer les deux variables et les indices de tableau.

401
00:35:54,880 --> 00:35:58,630
Donc unset ($ array [2]);

402
00:35:58,630 --> 00:36:03,430
Maintenant, ce qui est ce que ça va ressembler? 2 est tout simplement disparu, de sorte que c'est tout à fait correct.

403
00:36:03,430 --> 00:36:11,670
Plus gênant, si vous voulez que les choses vraiment être comme un tableau.

404
00:36:11,670 --> 00:36:14,910
Je vais mettre des nombres aléatoires.

405
00:36:14,910 --> 00:36:20,400
Maintenant, remarquez mes indices.

406
00:36:20,400 --> 00:36:26,860
Je veux juste être comme un tableau C où elle passe de 0 à length - 1

407
00:36:26,860 --> 00:36:30,810
et je peux parcourir en tant que telle.

408
00:36:30,810 --> 00:36:38,520
Mais dès que je désarmer le deuxième indice, ce qui était dans l'indice 3 ne pas devenir l'index 2.

409
00:36:38,520 --> 00:36:44,790
Au contraire, il supprime simplement que l'indice et maintenant vous allez 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Ceci est tout à fait raisonnable.

411
00:36:48,740 --> 00:36:53,950
C'est juste ennuyeux et vous avez à faire des choses comme épissure tableau. Ouais.

412
00:36:53,950 --> 00:36:57,200
>> [L'élève] Que se passerait-il si vous aviez une boucle for

413
00:36:57,200 --> 00:36:59,630
et que vous voulez passer en revue tous les éléments?

414
00:36:59,630 --> 00:37:02,290
Quand il a frappé 2, ne serait-il céder jamais?

415
00:37:02,290 --> 00:37:10,150
Itération sur un tableau. Il ya 2 façons de le faire.

416
00:37:10,150 --> 00:37:12,770
Vous pouvez utiliser une boucle for régulière.

417
00:37:12,770 --> 00:37:22,000
Il s'agit d'une autre complexité de PHP.

418
00:37:22,000 --> 00:37:27,420
La plupart des langues, je dirais, avoir une sorte de longueur ou len ou quelque chose

419
00:37:27,420 --> 00:37:30,470
indiquant la longueur d'un tableau.

420
00:37:30,470 --> 00:37:32,820
En PHP, il est chef d'accusation.

421
00:37:32,820 --> 00:37:36,160
Donc count ($ array); $ i + +)

422
00:37:36,160 --> 00:37:42,950
Disons simplement print ($ array [$ i]);

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

424
00:37:48,820 --> 00:37:51,610
Il va tout simplement à l'échec.

425
00:37:51,610 --> 00:38:03,020
C'est la raison pour laquelle, la plupart du temps, vous n'aurez jamais besoin d'itérer sur un tableau comme celui-ci.

426
00:38:03,020 --> 00:38:07,110
Il serait peut-être exagéré, mais vous n'avez jamais besoin d'itérer sur un tableau comme celui-ci

427
00:38:07,110 --> 00:38:19,410
parce que PHP fournit la syntaxe foreach où foreach ($ array que $ item).

428
00:38:19,410 --> 00:38:31,830
Maintenant, si nous imprimons ($ item); - nous allons en discuter dans un instant - qui fonctionne parfaitement bien.

429
00:38:31,830 --> 00:38:38,960
La façon dont foreach travaille est le premier argument est le tableau que vous itération sur.

430
00:38:38,960 --> 00:38:44,060
Et le deuxième argument, le point, à travers chaque passage de la boucle for

431
00:38:44,060 --> 00:38:52,690
il va prendre la chose suivante dans le tableau. Alors rappelez-vous le tableau a une commande.

432
00:38:52,690 --> 00:38:55,690
La première fois par la boucle for, point va de 123

433
00:38:55,690 --> 00:38:59,540
alors ce sera 12 puis ce sera 13 puis ce sera 23 puis ce sera 213.

434
00:38:59,540 --> 00:39:04,670
Les choses deviennent vraiment bizarre quand tu fais quelque chose comme foreach.

435
00:39:04,670 --> 00:39:07,480
Voyons voir ce qui se passe parce que vous ne devriez jamais faire cela.

436
00:39:07,480 --> 00:39:13,320
Et si nous unset ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
Cela a probablement été prévu.

438
00:39:26,030 --> 00:39:30,950
Vous n'êtes itération sur ce tableau, et chaque fois que vous désarmer le premier indice.

439
00:39:30,950 --> 00:39:39,720
Donc, pour l'indice 0, la première chose, élément prend la valeur 0, donc ça va être 123.

440
00:39:39,720 --> 00:39:44,630
Mais à l'intérieur de la boucle for nous unset index 1, ce qui signifie que 12 est disparu.

441
00:39:44,630 --> 00:39:57,480
Donc imprimer. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL retour à la ligne est juste, mais il est techniquement plus portable

443
00:40:03,580 --> 00:40:08,890
depuis sauts de ligne dans Windows est différente de retours à la ligne sur Mac et UNIX.

444
00:40:08,890 --> 00:40:18,040
Sous Windows saut de ligne est \ r \ n, alors que partout ailleurs elle tend simplement à être \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL est configuré de telle sorte qu'il utilise quelle que soit la nouvelle ligne de votre système est.

446
00:40:25,150 --> 00:40:29,310
Alors que d'imprimer. Il ne faut pas print_r ($ array) à la fin.

447
00:40:32,830 --> 00:40:37,390
Je n'avais aucune idée que ce serait le comportement.

448
00:40:41,740 --> 00:40:48,960
Point prend toujours la valeur 12, même si nous désarmer 12 avant que nous ayons jamais eu à le à partir du tableau.

449
00:40:52,770 --> 00:40:58,840
Ne prenez pas mon mot à ce sujet, mais il semble que foreach crée une copie du tableau

450
00:40:58,840 --> 00:41:02,160
puis ouvrage prend toutes les valeurs de cette copie.

451
00:41:02,160 --> 00:41:07,760
Donc, même si vous modifiez le tableau à l'intérieur de la boucle for,

452
00:41:07,760 --> 00:41:17,240
il ne s'en soucient pas. Article prendra les valeurs d'origine.

453
00:41:17,240 --> 00:41:19,240
Essayons désactivation.

454
00:41:19,240 --> 00:41:24,460
Que faire si ce n'est $ array [1] = "bonjour";

455
00:41:24,460 --> 00:41:31,770
Même si nous mettons «bonjour» dans le tableau, le point ne prend jamais sur cette valeur.

456
00:41:31,770 --> 00:41:37,430
Il ya une autre syntaxe pour les boucles foreach

457
00:41:37,430 --> 00:41:45,900
où vous mettez 2 variables séparées par une flèche.

458
00:41:45,900 --> 00:41:49,680
Cette première variable va être la clé de cette valeur,

459
00:41:49,680 --> 00:41:53,050
et cette deuxième variable va être le même article précise.

460
00:41:53,050 --> 00:42:01,610
Ceci est sans intérêt ici, mais si nous revenons à notre cas original de 'a' -> 1,

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

462
00:42:06,090 --> 00:42:14,470
ici nous venons de parcourir, pour chaque tableau comme élément, élément qui va de 1 à chaque fois.

463
00:42:14,470 --> 00:42:18,170
Mais si nous voulons aussi connaître la clé associée à cet élément

464
00:42:18,170 --> 00:42:25,230
puis nous as $ key -> $ item.

465
00:42:25,230 --> 00:42:31,980
Alors maintenant, nous pouvons faire imprimer ($ key. ':'.

466
00:42:31,980 --> 00:42:39,380
Maintenant, c'est une itération sur chaque touche et de l'impression et sa valeur associée.

467
00:42:39,380 --> 00:42:47,030
>> Une chose supplémentaire que nous pouvons faire dans le foreach boucles est que vous pourriez voir cette syntaxe.

468
00:42:47,030 --> 00:42:54,770
Esperluettes avant les noms de variables ont tendance à être la façon dont PHP fait référence.

469
00:42:54,770 --> 00:43:00,460
Lorsque des références sont très semblables aux pointeurs,

470
00:43:00,460 --> 00:43:04,820
vous n'avez pas de pointeurs, de sorte que vous n'avez jamais traiter directement la mémoire.

471
00:43:04,820 --> 00:43:12,620
Mais vous avez des références où la variable 1 se réfère à la même chose que d'une autre variable.

472
00:43:12,620 --> 00:43:21,450
A l'intérieur d'ici faisons $ item. Revenons à 1, 10.

473
00:43:21,450 --> 00:43:28,800
Faisons $ item + +; Cela existe encore en PHP. Vous pouvez toujours faire + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Je dois l'imprimer. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
Nous imprimons 2, 11.

476
00:43:42,730 --> 00:43:49,560
Si je venais de faire foreach ($ array que $ item) puis article sera la valeur 1

477
00:43:49,560 --> 00:43:54,190
la première fois à travers la boucle. Il sera incrémenté de 1 à 2, puis nous avons terminé.

478
00:43:54,190 --> 00:43:57,260
Alors il faudra passer par le deuxième passage de la boucle et que le point est de 10.

479
00:43:57,260 --> 00:44:01,570
Il produit des incréments de 11, puis c'est juste jeté.

480
00:44:01,570 --> 00:44:06,670
Ensuite, nous print_r ($ array), et nous allons voir que ce n'est que de 1, 10.

481
00:44:06,670 --> 00:44:09,070
Ainsi, l'augmentation que nous avons fait a été perdu.

482
00:44:09,070 --> 00:44:13,410
Mais foreach ($ array as & $ item)

483
00:44:13,410 --> 00:44:21,910
maintenant cet article est la même rubrique que ce droit ici. C'est la même chose.

484
00:44:21,910 --> 00:44:26,820
Donc, $ item + + modifie gamme 0.

485
00:44:29,330 --> 00:44:41,850
Fondamentalement, vous pouvez également faire: $ k -> array $ item et vous pouvez faire [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Donc, une autre façon de le faire, nous sommes libres de modifier l'article,

487
00:44:48,650 --> 00:44:54,070
mais cela ne modifie pas notre tableau original.

488
00:44:54,070 --> 00:44:59,720
Mais si nous utilisons k, qui est notre clé, alors nous pouvons simplement index dans notre tableau en utilisant cette clé

489
00:44:59,720 --> 00:45:01,530
et incrémenter que.

490
00:45:01,530 --> 00:45:05,410
Cette plus directement modifie notre tableau original.

491
00:45:05,410 --> 00:45:10,690
Vous pouvez le faire même si pour une raison quelconque vous voulez la possibilité de modifier -

492
00:45:10,690 --> 00:45:13,510
En fait, c'est tout à fait raisonnable.

493
00:45:13,510 --> 00:45:16,020
Vous ne voulez pas avoir à écrire $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
vous avez juste envie d'écrire $ item + + mais vous avez toujours voulu dire if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
puis incrémenter élément, puis imprimez notre tableau.

496
00:45:30,620 --> 00:45:36,290
Alors maintenant, qu'est-ce que nous nous attendons à print_r faire? Quelles sont les valeurs doivent être imprimés?

497
00:45:36,290 --> 00:45:43,770
[Élève] 2 et 10. >> [Bowden] Ce n'est que si la clé était «a» peut-on réellement imprimer cela.

498
00:45:51,940 --> 00:45:55,670
>> Vous avez sans doute très rarement, voire jamais, auront besoin de définir des fonctions en PHP,

499
00:45:55,670 --> 00:46:03,370
mais vous pourriez voir quelque chose de similaire dans laquelle vous définissez une fonction comme quelque fonction.

500
00:46:03,370 --> 00:46:09,900
Habituellement, vous dirais ($ foo, $ bar), puis le définir comme autre chose.

501
00:46:09,900 --> 00:46:17,580
Mais si je fais ça, ça veut dire que tout ce qui appelle que ce soit,

502
00:46:17,580 --> 00:46:25,110
quel que soit appelle baz, de sorte que le premier argument passé à baz peut être modifié.

503
00:46:25,110 --> 00:46:38,100
Faisons $ foo + +;

504
00:46:38,100 --> 00:46:48,020
et à l'intérieur d'ici faisons baz ($ item);

505
00:46:48,020 --> 00:46:52,250
Maintenant que nous appelons une fonction.

506
00:46:52,250 --> 00:46:56,780
L'argument est pris en référence, ce qui signifie que si nous le modifier

507
00:46:56,780 --> 00:47:00,390
nous sommes modifiant la chose qui a été adoptée po

508
00:47:00,390 --> 00:47:04,420
Et l'impression de ce que nous attendons - à moins que j'ai foiré la syntaxe - nous avons obtenu 2, 11,

509
00:47:04,420 --> 00:47:06,300
si elle a été effectivement incrémenté.

510
00:47:06,300 --> 00:47:08,790
Notez que nous besoin de références dans 2 endroits.

511
00:47:08,790 --> 00:47:13,050
Que faire si j'ai fait cela? Qu'est-ce que cela signifie?

512
00:47:13,050 --> 00:47:15,810
[L'élève] Il va changer. Ouais >>.

513
00:47:15,810 --> 00:47:18,290
L'article est juste une copie de la valeur dans le tableau.

514
00:47:18,290 --> 00:47:26,670
Alors élément va changer à 2, mais le tableau ['a'] sera toujours 1.

515
00:47:26,670 --> 00:47:32,560
Ou si je fais cela?

516
00:47:32,560 --> 00:47:39,260
Maintenant élément est envoyé en copie à baz.

517
00:47:39,260 --> 00:47:46,330
Ainsi, la copie de l'argument sera incrémenté à 2,

518
00:47:46,330 --> 00:47:49,240
mais l'article lui-même n'a jamais été incrémenté à 2.

519
00:47:49,240 --> 00:47:52,880
Et le point est la même chose que support de réseau que ce soit,

520
00:47:52,880 --> 00:47:55,380
si ce tableau n'a jamais été incrémenté.

521
00:47:55,380 --> 00:47:57,960
Donc, ces deux endroits ont besoin.

522
00:47:57,960 --> 00:48:03,830
>> PHP est généralement assez intelligente à ce sujet.

523
00:48:03,830 --> 00:48:06,570
Vous pourriez penser que je veux passer par référence -

524
00:48:06,570 --> 00:48:09,560
Ce fut d'ailleurs une question sur l'un des psets.

525
00:48:09,560 --> 00:48:14,480
C'était une chose Questions.txt où il est dit,

526
00:48:14,480 --> 00:48:19,280
Pourquoi pourriez-vous vouloir transmettre cette structure par référence?

527
00:48:19,280 --> 00:48:21,250
Quelle a été la réponse à cette question?

528
00:48:21,250 --> 00:48:25,100
[L'élève] Donc, vous n'avez pas à copier quelque chose de grand. Ouais >>.

529
00:48:25,100 --> 00:48:32,920
Une structure ne peut être arbitrairement grand, et quand vous passez la structure en tant qu'argument

530
00:48:32,920 --> 00:48:36,800
il a besoin de copier cette struct entier à passer à la fonction,

531
00:48:36,800 --> 00:48:40,410
tandis que si vous venez de passer la structure par référence

532
00:48:40,410 --> 00:48:46,530
alors il a juste besoin de copier une adresse de 4 octets comme argument à la fonction.

533
00:48:48,520 --> 00:48:52,320
PHP est un peu plus intelligent que ça.

534
00:48:52,320 --> 00:49:00,650
Si j'ai une fonction et je lui passer un tableau de 1.000 choses,

535
00:49:00,650 --> 00:49:03,990
ça veut dire que ça va avoir à copier tous les 1.000 de ces choses

536
00:49:03,990 --> 00:49:10,450
pour passer dans la fonction? Il n'a pas à le faire immédiatement.

537
00:49:10,450 --> 00:49:15,940
Si l'intérieur de cette fonction, il ne modifie en fait foo,

538
00:49:15,940 --> 00:49:22,660
si ($ foo === 'bonjour') return true.;

539
00:49:22,660 --> 00:49:26,460
Notez que nous n'avons jamais été réellement modifié l'intérieur argument de cette fonction,

540
00:49:26,460 --> 00:49:30,010
ce qui signifie que tout ce qui a été adoptée en tant que foo n'a jamais besoin d'être copiés

541
00:49:30,010 --> 00:49:32,100
car ce n'est pas le modifier.

542
00:49:32,100 --> 00:49:39,240
Ainsi, la manière de PHP sont les arguments sont toujours passés par référence

543
00:49:39,240 --> 00:49:42,170
jusqu'à ce que vous essayez de la modifier.

544
00:49:42,170 --> 00:49:51,160
Maintenant, si je dis $ foo + +, il va maintenant faire une copie de l'original foo et modifier la copie.

545
00:49:51,160 --> 00:49:53,090
Cela permet d'économiser un peu de temps.

546
00:49:53,090 --> 00:49:58,210
Si vous n'avez jamais toucher cette vaste massif, vous n'avez jamais le modifier,

547
00:49:58,210 --> 00:50:02,360
il n'a pas besoin de faire la copie,

548
00:50:02,360 --> 00:50:06,640
tandis que si nous venons de mettre cette esperluette ce qui signifie qu'il n'a même pas le copier

549
00:50:06,640 --> 00:50:08,640
même si vous ne les modifiez.

550
00:50:08,640 --> 00:50:10,680
Ce comportement est appelé copie-sur-écriture.

551
00:50:10,680 --> 00:50:17,380
Vous le verrez dans d'autres endroits, surtout si vous prenez un cours de système d'exploitation.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write est un modèle assez habituel où vous n'avez pas besoin de faire une copie de quelque chose

553
00:50:23,880 --> 00:50:26,650
à moins qu'elle soit réellement changer. Ouais.

554
00:50:26,650 --> 00:50:29,520
[L'élève] Et si vous aviez l'augmentation à l'intérieur de l'épreuve,

555
00:50:29,520 --> 00:50:33,700
si seulement 1 élément sur 1000 devrait être changé?

556
00:50:33,700 --> 00:50:38,770
Je ne suis pas sûr.

557
00:50:38,770 --> 00:50:51,250
Je pense qu'il serait copier l'ensemble de chose, mais il est possible qu'il est assez intelligent pour cela -

558
00:50:51,250 --> 00:51:00,020
En fait, ce que je pense, c'est imaginer que nous avions un tableau qui ressemble à ceci: $ tableau2 = [

559
00:51:00,020 --> 00:51:11,000
Ensuite, l'indice «a» est un tableau de [1 2 3 4], et l'indice «b» est un tableau de ce que.

560
00:51:11,000 --> 00:51:15,380
J'ai besoin de virgules entre tous ces éléments. Imaginez, il ya des virgules.

561
00:51:15,380 --> 00:51:21,210
Ensuite, 'c' est la valeur 3.

562
00:51:24,210 --> 00:51:26,290
D'accord.

563
00:51:26,290 --> 00:51:33,440
Maintenant, disons que nous faisons baz $ (tableau2 $);

564
00:51:33,440 --> 00:51:36,540
où baz ne prend pas cela en référence.

565
00:51:43,510 --> 00:51:47,370
Donc, $ foo ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
Il s'agit d'un exemple où nous passons comme argument tableau2

567
00:51:52,340 --> 00:51:57,010
puis on la modification d'un indice spécifique de la matrice en l'incrémentant.

568
00:51:57,010 --> 00:52:01,090
Honnêtement, je n'ai aucune idée de ce que PHP va faire.

569
00:52:01,090 --> 00:52:07,200
Il peut facilement faire une copie de l'ensemble de chose, mais si elle est intelligente,

570
00:52:07,200 --> 00:52:15,030
il fera une copie de ces touches lorsque cela aura sa valeur distincte

571
00:52:15,030 --> 00:52:20,620
mais cela peut toujours pointer vers le même tableau 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
et cela peut toujours pointer vers le même tableau.

573
00:52:22,320 --> 00:52:24,170
Je vais l'iPad.

574
00:52:28,900 --> 00:52:45,950
Nous passons dans ce tableau où ce gars points à 3, cela indique gars à [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
ce mec points à [34, ...]

576
00:52:51,350 --> 00:52:58,590
Maintenant que nous la transmettre pour baz, nous modifions la présente.

577
00:52:58,590 --> 00:53:03,550
Si PHP est intelligent, il peut tout faire -

578
00:53:11,850 --> 00:53:18,230
Nous avions encore à copier de la mémoire, mais si il y avait ces sous-réseaux imbriqués énormes

579
00:53:18,230 --> 00:53:21,560
nous n'avons pas besoin de copier ceux-ci.

580
00:53:21,560 --> 00:53:27,530
Je ne sais pas si c'est ce qu'il fait, mais je ne peux l'imaginer faire cela.

581
00:53:29,050 --> 00:53:36,690
C'est aussi un avantage assez grand de C sur PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP rend la vie tellement plus facile pour beaucoup de choses,

583
00:53:40,320 --> 00:53:45,060
mais vous sorte de n'ai absolument aucune idée de la façon dont il exécute

584
00:53:45,060 --> 00:53:52,530
parce que je n'ai aucune idée de sous le capot quand il fait ces copies de choses,

585
00:53:52,530 --> 00:53:55,170
Oh, est ce que cela va être une copie constante de temps,

586
00:53:55,170 --> 00:54:01,140
est-ce juste va changer 1 aiguille, est ce que ça va être une copie ridiculement difficile linéaire?

587
00:54:01,140 --> 00:54:03,000
Que faire si on ne peut pas trouver de l'espace?

588
00:54:03,000 --> 00:54:06,760
Est-il alors nécessaire d'exécuter la collecte des déchets pour obtenir un peu plus d'espace?

589
00:54:06,760 --> 00:54:11,210
Et la collecte des ordures peut prendre arbitrairement longue.

590
00:54:11,210 --> 00:54:13,600
En C, vous n'avez pas à vous soucier de ces choses.

591
00:54:13,600 --> 00:54:19,780
Chaque ligne que vous pouvez vous écrivez raison à peu près de la façon dont il va procéder.

592
00:54:26,800 --> 00:54:29,150
>> Revenons à celles-ci.

593
00:54:35,400 --> 00:54:37,520
Comment est-ce bien ce que vous n'avez pas à traiter avec les fonctions de hachage,

594
00:54:37,520 --> 00:54:39,010
listes chaînées, ou quelque chose comme ça?

595
00:54:39,010 --> 00:54:41,980
Depuis que je travaille avec des tables de hachage est si facile maintenant, voici un casse-tête amusant de travailler.

596
00:54:41,980 --> 00:54:45,920
Ouvrez un fichier appelé unique.php et écrire un programme PHP

597
00:54:45,920 --> 00:54:48,330
(Aussi connu comme un "script").

598
00:54:48,330 --> 00:54:55,700
Nous avons tendance à appeler les scripts si ce sont des choses courtes que vous exécutez la ligne de commande.

599
00:54:55,700 --> 00:55:02,950
Fondamentalement, n'importe quelle langue que vous ne compile pas, mais vous allez lancer l'exécutable

600
00:55:02,950 --> 00:55:05,920
à la ligne de commande, vous pouvez appeler ce script exécutable.

601
00:55:05,920 --> 00:55:08,510
Je pourrais tout aussi bien écrire un programme en C qui fait cela,

602
00:55:08,510 --> 00:55:12,300
mais je n'appelle pas cela un script depuis que je le compiler puis exécuter le fichier binaire.

603
00:55:12,300 --> 00:55:15,480
Mais ce programme PHP, nous allons appeler un script.

604
00:55:15,480 --> 00:55:23,830
Ou si nous l'avons écrit en Python ou en Perl ou Node.js ou l'une de ces choses,

605
00:55:23,830 --> 00:55:26,500
nous aimerions appeler tous les scripts, car vous les exécutez la ligne de commande

606
00:55:26,500 --> 00:55:30,040
mais nous ne les compiler.

607
00:55:30,860 --> 00:55:33,400
Nous pourrions le faire assez rapidement.

608
00:55:36,960 --> 00:55:41,480
Nous n'allons pas utiliser argv. Disons simplement souffler à travers cela.

609
00:55:41,480 --> 00:55:45,730
Appelez-il unique, écrire un programme.

610
00:55:45,730 --> 00:55:49,400
Vous pouvez supposer que l'entrée contient un mot par ligne.

611
00:55:49,400 --> 00:55:52,020
En fait, argv sera assez simples à utiliser.

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

613
00:56:08,550 --> 00:56:13,750
La première chose d'abord, nous voulons vérifier si nous avons été passé 1 ligne de commande argument.

614
00:56:13,750 --> 00:56:20,900
Tout comme on peut s'y attendre argc et argv en C, nous avons encore ceux qui en PHP.

615
00:56:20,900 --> 00:56:33,900
Donc, si ($ argc! == 2) alors je ne traiterai pas l'impression d'un message ou quoi que ce soit.

616
00:56:33,900 --> 00:56:37,340
Je vais quitter, code d'erreur 1.

617
00:56:37,340 --> 00:56:41,340
Je pourrais aussi revenir 1.

618
00:56:41,340 --> 00:56:53,180
Rarement en PHP en êtes-vous de cet état où nous en sommes -

619
00:56:53,180 --> 00:56:57,820
Habituellement, vous êtes dans une fonction appelée par une fonction appelée par une fonction appelée par une fonction.

620
00:56:57,820 --> 00:57:02,070
Et si quelque chose va mal et vous voulez juste pour sortir tout entier,

621
00:57:02,070 --> 00:57:05,680
la sortie se termine juste le programme.

622
00:57:05,680 --> 00:57:08,160
Cela existe aussi en C.

623
00:57:08,160 --> 00:57:10,700
Si vous êtes dans une fonction dans une fonction dans une fonction dans une fonction

624
00:57:10,700 --> 00:57:17,540
et que vous voulez juste tuer le programme, vous pouvez appeler sortie et il va juste sortir.

625
00:57:17,540 --> 00:57:23,120
Mais en PHP, il est encore plus rare que nous sommes à ce niveau supérieur.

626
00:57:23,120 --> 00:57:26,090
Habituellement, nous sommes à l'intérieur une sorte de fonction, de sorte que nous appelons sortie

627
00:57:26,090 --> 00:57:29,650
de sorte que nous n'avons pas à revenir jusqu'à 1 chose qui se rend compte alors qu'il ya une erreur

628
00:57:29,650 --> 00:57:32,270
de sorte que si retourne jusqu'à ce que reconnaît qu'il ya eu une erreur.

629
00:57:32,270 --> 00:57:35,270
Nous ne voulons pas faire face à ça, donc exit (1);

630
00:57:35,270 --> 00:57:38,240
return (1); dans ce cas, serait équivalent.

631
00:57:38,240 --> 00:57:44,000
>> Alors ce que nous voulons, nous voulons ouvrir à fopen.

632
00:57:44,000 --> 00:57:46,760
Les arguments vont chercher assez similaire.

633
00:57:46,760 --> 00:57:51,600
Nous voulons fopen ($ argv [1], et nous voulons l'ouvrir en lecture.

634
00:57:51,600 --> 00:57:55,720
Qui retourne une ressource que nous allons appeler f.

635
00:57:55,720 --> 00:58:02,180
Cela semble assez similaire à la façon dont il le fait, sauf C nous n'avons pas à dire FILE *.

636
00:58:02,180 --> 00:58:06,170
Au lieu de cela nous disons simplement f $. D'accord.

637
00:58:06,170 --> 00:58:17,190
En fait, je pense que cela nous donne même une indication quant à la fonction PHP appelé fichier. Fichier PHP.

638
00:58:17,190 --> 00:58:23,990
Qu'est-ce que cela va faire est de lire un fichier entier dans un tableau.

639
00:58:23,990 --> 00:58:29,770
Vous n'avez même pas besoin de la fonction fopen. Ça va le faire pour vous.

640
00:58:37,450 --> 00:58:43,700
Donc, $ lignes = file ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Maintenant, toutes les lignes du fichier sont en lignes. Maintenant, nous voulons trier les lignes.

642
00:58:49,680 --> 00:58:52,180
Comment peut-on trier les lignes?

643
00:58:52,180 --> 00:58:54,920
Nous trions les lignes.

644
00:58:54,920 --> 00:58:58,080
Et maintenant nous pouvons les imprimer ou que ce soit.

645
00:58:58,080 --> 00:59:05,580
Probablement le plus simple est foreach ($ lignes as $ ligne) echo $ ligne;

646
00:59:05,580 --> 00:59:10,960
[L'élève] Ne serions-nous encore franchir les lignes faisant référence à quelque chose en sorte?

647
00:59:10,960 --> 00:59:28,850
C'est là que sorte serait défini comme une sorte de fonction (& $ array).

648
00:59:28,850 --> 00:59:32,650
Lorsque vous appelez la fonction que vous n'avez pas le passer par référence.

649
00:59:32,650 --> 00:59:36,900
C'est la fonction qui le définit comme le prenant comme référence.

650
00:59:36,900 --> 00:59:40,900
C'est en fait exactement ce qui s'est passé

651
00:59:40,900 --> 00:59:46,220
lorsque nous mettons tout à nos serveurs quand nous sommes allés de 5,3 à 5,4.

652
00:59:46,220 --> 00:59:53,800
Jusqu'à 5.4, cela était parfaitement raisonnable.

653
00:59:53,800 --> 00:59:58,740
Une fonction ne vous attendez pas à le prendre comme référence, mais vous pouvez la passer comme référence

654
00:59:58,740 --> 01:00:02,860
donc si la fonction ne se produise pour le modifier, il est toujours modifié.

655
01:00:02,860 --> 01:00:05,850
Comme de 5,4, vous n'êtes pas censé le faire.

656
01:00:05,850 --> 01:00:11,740
Alors maintenant, la seule façon vous passez par référence est de savoir si la fonction ne fait explicitement.

657
01:00:11,740 --> 01:00:19,840
Si vous ne voulez pas le modifier, alors vous devez faire une copie $ = $ lignes et copie passe.

658
01:00:19,840 --> 01:00:24,820
Alors maintenant, les lignes seront préservés et copie en sera changé.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. J'ai peut-être raté quelque chose.

660
01:00:31,460 --> 01:00:33,190
Unexpected 'sort'.

661
01:00:38,320 --> 01:00:43,850
Il va y avoir quelque chose qui fait ça pour nous.

662
01:00:43,850 --> 01:00:45,820
Ce n'est même pas là.

663
01:00:45,820 --> 01:00:52,140
Remarquez quand vous lisez le manuel que le premier argument devrait être un réseau

664
01:00:52,140 --> 01:00:56,490
et il a fallu par référence.

665
01:00:58,160 --> 01:01:03,540
Pourquoi est-ce plaindre à moi? Parce que j'ai ce genre de fonction encore ici que je ne veux pas.

666
01:01:03,540 --> 01:01:09,210
Bon, php.unique.php. Je n'ai pas réussi un argument parce que je n'ai pas un fichier.

667
01:01:09,210 --> 01:01:13,560
C'est php.unique.php sur test.php.

668
01:01:13,560 --> 01:01:19,080
Voici test.php tous imprimés dans un ordre bien triés.

669
01:01:19,080 --> 01:01:24,600
Notez que l'ordre de tri est un peu bizarre pour un fichier de code

670
01:01:24,600 --> 01:01:27,460
parce que toutes nos lignes vides vont venir en premier

671
01:01:27,460 --> 01:01:30,190
puis vont venir tout de nos 1 indentations au niveau

672
01:01:30,190 --> 01:01:33,360
puis viennent tous nos empreintes aucun.

673
01:01:33,360 --> 01:01:38,620
Ouais. >> [L'élève] Donc, pour le code source, il n'a pas été adopté par renvoi?

674
01:01:38,620 --> 01:01:42,240
Est-ce que généralement passés par valeur?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Lorsque vous appelez une fonction, elle ne détermine s'il a été transmis par référence.

676
01:01:50,240 --> 01:01:53,960
C'est la définition de la fonction qui détermine si elle a été passée par référence.

677
01:01:53,960 --> 01:01:59,450
Et en regardant la définition de la fonction de tri ou simplement en regardant ce,

678
01:01:59,450 --> 01:02:02,820
il faut des arguments par référence.

679
01:02:02,820 --> 01:02:07,160
Donc, peu importe si vous voulez le prendre en référence, il le fait de prendre pour référence.

680
01:02:07,160 --> 01:02:10,200
Il modifie le tableau en place.

681
01:02:10,200 --> 01:02:17,400
Ce n'est tout simplement pas permis. Vous n'êtes pas autorisé à le faire. >> [L'élève] Oh, d'accord.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Ce, en quelque sorte va prendre les lignes de référence et le modifier.

683
01:02:22,410 --> 01:02:26,850
Et encore, si vous ne voulez pas qu'il fasse cela, vous pouvez faire une copie de tri.

684
01:02:26,850 --> 01:02:35,850
Même dans ce cas, la copie n'est pas en fait une copie de lignes.

685
01:02:35,850 --> 01:02:40,620
Il souligne simplement la même chose jusqu'à ce qu'il soit modifié une première fois,

686
01:02:40,620 --> 01:02:44,430
où c'est premier va se modifier dans la fonction de tri,

687
01:02:44,430 --> 01:02:50,940
où, parce que c'est un copie-sur-écriture, maintenant une copie de copie va être faite.

688
01:02:57,500 --> 01:03:04,250
Vous pouvez aussi le faire. C'est l'endroit que vous pouvez voir et commercial.

689
01:03:04,250 --> 01:03:07,190
On le voit dans la boucle foreach, vous le voyez dans les déclarations de fonctions,

690
01:03:07,190 --> 01:03:10,040
et on le voit quand vient affecter les variables.

691
01:03:10,040 --> 01:03:12,350
Maintenant que nous avons accompli rien en faisant cela,

692
01:03:12,350 --> 01:03:15,600
parce copie et les lignes sont littéralement la même chose.

693
01:03:15,600 --> 01:03:19,940
Vous pouvez utiliser des lignes et de copier de façon interchangeable.

694
01:03:19,940 --> 01:03:25,430
Vous pouvez le faire unset ($ copie), et qui n'a pas les lignes non définies,

695
01:03:25,430 --> 01:03:29,120
vous venez de perdre votre référence à la même chose.

696
01:03:29,120 --> 01:03:33,440
Alors que sur ce point, maintenant des lignes est la seule façon vous pouvez accéder aux lignes.

697
01:03:36,450 --> 01:03:38,770
>> Des questions?

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

699
01:03:42,460 --> 01:03:45,880
[Étudiant] Complètement hors sujet, mais vous n'avez pas à fermer PHP avec - >> Vous n'en ont pas.

700
01:03:45,880 --> 01:03:47,730
D'accord.

701
01:03:47,730 --> 01:03:53,790
[Bowden] J'irais même jusqu'à dire que c'est une mauvaise pratique pour les fermer.

702
01:03:53,790 --> 01:03:57,580
C'est probablement une exagération, surtout dans un script,

703
01:03:57,580 --> 01:04:03,740
mais nous allons voir ce qui se passe si je fais ça.

704
01:04:03,740 --> 01:04:08,890
Qui n'a rien fait. Que faire si je voulais - [soupir]

705
01:04:13,870 --> 01:04:16,960
J'ai besoin de passer un argument.

706
01:04:19,000 --> 01:04:22,050
Shoot. Je l'ai appelé tort.

707
01:04:24,340 --> 01:04:28,310
Donc php.unique.php avec un argument.

708
01:04:28,310 --> 01:04:30,980
Maintenant, je n'ai même pas besoin de cela.

709
01:04:34,520 --> 01:04:37,740
Je vais lui passer un argument valable.

710
01:04:37,740 --> 01:04:42,050
Cet imprimé ce que ça l'impression.

711
01:04:45,260 --> 01:04:50,080
Je suis d'impression et de copie copie n'existe pas. Donc lignes.

712
01:04:53,650 --> 01:04:58,270
Il imprimés tout, et puis notez tout ce ordure ici-bas,

713
01:04:58,270 --> 01:05:06,690
parce que dans tout ce que PHP est en dehors de balises PHP

714
01:05:06,690 --> 01:05:09,520
va juste être imprimé littéralement.

715
01:05:09,520 --> 01:05:18,050
C'est pourquoi le HTML, il est si gentil que je peux faire div blah, blah, blah classe ou que ce soit,

716
01:05:18,050 --> 01:05:25,140
blah, blah, blah, puis faire un peu de code PHP puis effectuez div fin.

717
01:05:25,140 --> 01:05:36,460
Et maintenant l'impression de ce que je obtenir mon div belle là-haut, tout ce que PHP imprimé, div en bas.

718
01:05:36,460 --> 01:05:43,510
Désastreuse quand quelque chose comme cela se produit, ce qui est assez commun,

719
01:05:43,510 --> 01:05:47,930
seulement un retour à la ligne parasite au niveau du fond du dossier.

720
01:05:47,930 --> 01:05:50,940
Vous ne penseriez pas que ce serait un gros problème

721
01:05:50,940 --> 01:05:58,660
jusqu'à ce que vous considérez le fait que les navigateurs -

722
01:05:58,660 --> 01:06:03,880
>> Comment redirige travail ou en fait tout le travail en-têtes,

723
01:06:03,880 --> 01:06:07,980
lorsque vous effectuez votre connexion à un site Web et le renvoie tous ces en-têtes et les choses

724
01:06:07,980 --> 01:06:12,020
comme réponse 200 ou réponse de redirection ou autre,

725
01:06:12,020 --> 01:06:18,230
têtes ne sont valables jusqu'à ce que le premier octet de données est envoyé.

726
01:06:18,230 --> 01:06:23,140
Vous pouvez rediriger des milliers de fois, mais dès que le premier octet de données est envoyé

727
01:06:23,140 --> 01:06:26,120
vous n'êtes pas censé rediriger à nouveau.

728
01:06:26,120 --> 01:06:31,860
>> Si vous avez un retour à la ligne perdue au fond d'un fichier

729
01:06:31,860 --> 01:06:37,260
et disons que vous utilisez cette fonction et que vous voulez -

730
01:06:41,580 --> 01:06:52,870
Disons que c'est un autre fichier qui est index.php et vous require_once quelque chose -

731
01:06:52,870 --> 01:06:56,920
Je ne peux pas penser à un bon exemple de cela.

732
01:06:56,920 --> 01:07:04,740
Le problème se produit lorsque cette ligne en bas se fait l'écho.

733
01:07:04,740 --> 01:07:08,660
Vous ne voulez rien avoir trouvé un écho encore.

734
01:07:10,820 --> 01:07:15,700
Même si vous n'avez pas l'intention de se faire quoi que ce soit fait l'écho, quelque chose ne se fait l'écho

735
01:07:15,700 --> 01:07:17,990
et maintenant que vous n'êtes pas censé envoyer têtes, pas plus

736
01:07:17,990 --> 01:07:20,030
et vous allez recevoir des plaintes.

737
01:07:22,170 --> 01:07:24,420
Vous n'avez tout simplement pas besoin de ces balises de fermeture.

738
01:07:24,420 --> 01:07:27,420
Si vous projetez de faire quelque chose avec HTML -

739
01:07:27,420 --> 01:07:30,490
et il est parfaitement raisonnable de le faire ici div quel que soit

740
01:07:30,490 --> 01:07:39,450
et puis, à ce stade, vous pouvez ou vous ne pouvez pas les inclure.

741
01:07:39,450 --> 01:07:41,590
Il n'a pas vraiment d'importance.

742
01:07:41,590 --> 01:07:45,450
Mais dans des scripts PHP, il est rare pour la refermer.

743
01:07:45,450 --> 01:07:50,400
Quand tout est en PHP, absolument tout,

744
01:07:50,400 --> 01:07:55,460
vous n'avez pas vraiment besoin de le fermer / vous ne devriez pas le fermer.

745
01:08:02,030 --> 01:08:05,720
>> Traiter avec des cordes est beaucoup plus agréable que chez C.

746
01:08:05,720 --> 01:08:09,470
En PHP, vous pouvez spécifier une chaîne avec des guillemets simples ou doubles.

747
01:08:09,470 --> 01:08:12,820
Avec des guillemets simples, vous ne pouvez pas utiliser "d'échappement" séquences.

748
01:08:12,820 --> 01:08:17,640
Constamment s'échapper, blah, blah, blah.

749
01:08:19,920 --> 01:08:24,010
Donc printf est très rare en PHP.

750
01:08:24,010 --> 01:08:32,290
Je suppose que je devrais utiliser printf si je voulais faire une sorte de chose - en pset 5 vous utilisé sprintf ou autre.

751
01:08:32,290 --> 01:08:36,060
Mais vous voulez faire 001.jpg 002.jpg et.

752
01:08:36,060 --> 01:08:40,300
Donc, pour ce genre de chose où je veux vraiment formater le texte je voudrais utiliser printf.

753
01:08:40,300 --> 01:08:44,689
Mais sinon, je voudrais simplement utiliser la concaténation de chaînes.

754
01:08:44,689 --> 01:08:47,000
Je n'ai jamais vraiment utiliser printf.

755
01:08:49,229 --> 01:09:00,170
Nous sommes en train de différencier les détails entre apostrophes et guillemets.

756
01:09:00,170 --> 01:09:07,490
La plus grande différence est que les guillemets simples, il sera imprimé littéralement.

757
01:09:07,490 --> 01:09:15,390
Il n'existe pas de type de données char en PHP, contrairement au C, alors cela équivaut à ce sujet.

758
01:09:15,390 --> 01:09:17,970
Ils sont tous les deux chaînes.

759
01:09:17,970 --> 01:09:29,180
Et la bonne chose à propos des chaînes de guillemets simples est que je pourrais dire 'Bonjour le monde!' blah, blah, blah,

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

761
01:09:33,340 --> 01:09:38,260
Qu'est-ce qui se passe lorsque j'imprime c'est elle l'imprimer littéralement.

762
01:09:38,260 --> 01:09:40,680
Débarrassons-nous de toutes nos affaires.

763
01:09:40,680 --> 01:09:44,700
Alors echo $ str1;

764
01:09:48,569 --> 01:09:56,570
Elle a littéralement imprimé toutes ces choses: les signes de dollar,

765
01:09:56,570 --> 01:09:58,770
antislash n, on pourrait penser serait retours à la ligne -

766
01:09:58,770 --> 01:10:01,500
toutes ces choses, il imprime la lettre.

767
01:10:01,500 --> 01:10:05,650
La seule chose dont vous avez besoin pour échapper sont des apostrophes

768
01:10:05,650 --> 01:10:09,470
parce que sinon il pourrait penser qu'il a la fermeture des guillemets simples.

769
01:10:09,470 --> 01:10:15,050
Les guillemets doubles, complètement différents.

770
01:10:20,300 --> 01:10:25,870
Nous voyons déjà la coloration syntaxique est cluing nous sur ce qui va se passer très mal.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo, car cela est interprété comme une variable appelée wooo.

772
01:10:36,190 --> 01:10:42,400
Guillemets vous permettent d'insérer des variables dans -

773
01:10:42,400 --> 01:10:52,730
Disons $ nom = "Rob";

774
01:10:52,730 --> 01:10:58,020
Alors echo "Salut, mon nom est $ nom!";

775
01:10:58,020 --> 01:11:09,260
Il reconnaît cela comme une variable.

776
01:11:09,260 --> 01:11:21,210
Quand je lance ça - et je vais insérer un saut de ligne - Salut, mon nom est Rob! et bonjour tout le monde!

777
01:11:21,210 --> 01:11:24,910
C'est parce que je n'ai jamais retiré l'impression de wooo ci-dessus.

778
01:11:24,910 --> 01:11:30,020
Il ya 1 peu plus loin que vous pouvez faire.

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

780
01:11:39,250 --> 01:11:43,270
Que faire si je veux imprimer le premier indice du tableau?

781
01:11:43,270 --> 01:11:45,150
Vous faites $ array [0].

782
01:11:45,150 --> 01:11:49,280
La coloration syntaxique est un indice. Quel est ce faire?

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

784
01:11:54,510 --> 01:11:59,860
Salut, mon nom est 1! ce qui n'est pas ce que je voulais.

785
01:11:59,860 --> 01:12:05,050
La coloration syntaxique m'avez menti.

786
01:12:05,050 --> 01:12:13,020
Essayons 'a' -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
C'est comme ça que je devrais écrire.

788
01:12:26,350 --> 01:12:32,160
Unexpected apostrophe (T_ENCAPSED blah, blah, blah, blah, blah).

789
01:12:32,160 --> 01:12:41,780
L'idée est que ce n'est pas reconnaître que cela fait partie du tableau.

790
01:12:41,780 --> 01:12:46,620
Ce n'est pas la reconnaissance de ce que tableau indexé par une lettre.

791
01:12:46,620 --> 01:12:49,870
Vous voulez faire cela entouré par des accolades,

792
01:12:49,870 --> 01:12:54,730
et maintenant tout ce qui est dans cette accolade sera interpolée,

793
01:12:54,730 --> 01:13:00,340
qui est le terme que nous utilisons pour l'insertion par magie ces variables dans les bons endroits.

794
01:13:00,340 --> 01:13:04,280
Maintenant, ce faisant, php.unique et Salut, mon nom est 1! comme prévu

795
01:13:04,280 --> 01:13:07,720
ou Salut, mon nom est Rob!

796
01:13:14,110 --> 01:13:23,130
Une chose qui est assez sympa à propos de guillemets simples, c'est que -

797
01:13:23,130 --> 01:13:28,480
Il ya un certain coût pour l'interpolation.

798
01:13:30,520 --> 01:13:35,100
Si vous utilisez des guillemets doubles, l'interprète doit aller sur cette chaîne,

799
01:13:35,100 --> 01:13:41,500
faire en sorte que, «Oh, voici une variable. Maintenant, j'ai besoin d'aller chercher cette variable et l'insérer ici."

800
01:13:41,500 --> 01:13:48,930
Même si vous n'utilisez pas toutes les variables,

801
01:13:48,930 --> 01:13:52,220
rien à l'intérieur de ces guillemets doit être interpolé,

802
01:13:52,220 --> 01:13:56,800
mais il sera toujours plus lent car il doit passer en revue les guillemets

803
01:13:56,800 --> 01:14:00,130
à la recherche de choses qui doivent être interpolées.

804
01:14:00,130 --> 01:14:05,360
Donc citations simples peuvent être un peu plus rapide si rien ne doit être interpolé,

805
01:14:05,360 --> 01:14:15,650
et j'ai tendance à utiliser des guillemets simples, même pour les «Salut, mon nom est '. $ Array ['a'] de toute façon.

806
01:14:15,650 --> 01:14:20,430
Cela va être équivalent à ce que nous avions auparavant.

807
01:14:24,840 --> 01:14:28,440
Mais c'est une question de préférence.

808
01:14:28,440 --> 01:14:34,750
Si vous utilisez PHP, vous avez probablement ne se soucient pas de la différence de vitesse.

809
01:14:34,750 --> 01:14:39,480
Il ne suffit pas de les raisonner pour commencer.

810
01:14:39,480 --> 01:14:43,030
>> Toutes les dernières questions?

811
01:14:47,430 --> 01:14:51,710
>> En fait, nous n'avons même pas passer à travers tout cela, mais ce genre de choses était ennuyeux.

812
01:14:51,710 --> 01:14:59,080
La dernière chose qui est plutôt agréable en PHP, c'est quand vous avez affaire avec le langage HTML,

813
01:14:59,080 --> 01:15:06,450
vous utiliserez un peu, de sorte que la syntaxe beau raccourci pour imprimer une variable.

814
01:15:32,400 --> 01:15:36,730
Sans mettre en PHP ici, c'est ce qu'on appelle les balises courtes.

815
01:15:36,730 --> 01:15:44,330
Officiellement à partir de PHP 5.4, cela est déconseillé.

816
01:15:44,330 --> 01:15:48,640
Il est recommandé de mettre php.

817
01:15:48,640 --> 01:15:55,770
Ceci est encore supporté, de tags courts avec le <? = Sont toujours parfaitement bien.

818
01:15:55,770 --> 01:16:02,480
Il est pris en charge par défaut, de sorte que vous pouvez les utiliser comme vous le souhaitez, et ils sont assez commode.

819
01:16:02,480 --> 01:16:05,700
>> Des questions?

820
01:16:07,780 --> 01:16:09,270
Très bien.

821
01:16:10,840 --> 01:16:13,800
>> Restez chics, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Rires]

823
01:16:18,620 --> 01:16:22,660
Bye. [Rires]

824
01:16:24,350 --> 01:16:28,470
[Applaudissements] [rires]

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