1
00:00:00,000 --> 00:00:12,510

2
00:00:12,510 --> 00:00:13,870
>> ROB: Va bene.

3
00:00:13,870 --> 00:00:16,770
Benvenuti alla prima sezione.

4
00:00:16,770 --> 00:00:17,480
Sono Rob.

5
00:00:17,480 --> 00:00:18,806
>> JOSEPH: Sono Giuseppe.

6
00:00:18,806 --> 00:00:21,540
>> ROB: Così ci immergeremo a destra dentro

7
00:00:21,540 --> 00:00:23,420
La prima cosa di cui parlare
è l'apparecchio.

8
00:00:23,420 --> 00:00:27,150
Così si spera la maggior parte di voi hanno
scaricato già.

9
00:00:27,150 --> 00:00:37,180
Ma potete vedere le istruzioni
a cs50.net/appliance.

10
00:00:37,180 --> 00:00:38,430
Oh dio, ora sono consapevole.

11
00:00:38,430 --> 00:00:44,590

12
00:00:44,590 --> 00:00:45,430
Sento ancora esso.

13
00:00:45,430 --> 00:00:47,232
>> JOSEPH: Wow, suona come
è disorientato.

14
00:00:47,232 --> 00:00:52,460
>> ROB: Così alcune persone hanno avuto
problemi con esso, quindi non aspettare fino a

15
00:00:52,460 --> 00:00:54,940
l'ultimo minuto del problema impostato su
cercare di risolvere l'apparecchio e

16
00:00:54,940 --> 00:00:56,320
scoprire che non funziona.

17
00:00:56,320 --> 00:00:59,010
>> JOSEPH: E se qualcosa è che non funziona
e avete bisogno di aiuto, si può andare a

18
00:00:59,010 --> 00:01:03,390
cs50.net/discussion dove siamo
un forum in cui si

19
00:01:03,390 --> 00:01:04,110
possono inviare le vostre domande.

20
00:01:04,110 --> 00:01:06,655
E ci arriveremo a loro alla fine.

21
00:01:06,655 --> 00:01:07,490
>> ROB: Va bene.

22
00:01:07,490 --> 00:01:12,180
Quindi questo è ciò che il Appliance
assomiglia.

23
00:01:12,180 --> 00:01:15,480
Anche in questo caso, è solo una completamente separato
sistema operativo in esecuzione all'interno

24
00:01:15,480 --> 00:01:19,440
qualunque sistema operativo si
sono in esecuzione sul vostro computer portatile.

25
00:01:19,440 --> 00:01:24,450
E le cose principali che si
utilizzeranno sono gedit.

26
00:01:24,450 --> 00:01:28,050
Quindi speriamo che questo ha già
diventare un sito familiare.

27
00:01:28,050 --> 00:01:29,470
Il terminale.

28
00:01:29,470 --> 00:01:31,890
>> E si può anche eseguire Chrome
all'interno del Appliance.

29
00:01:31,890 --> 00:01:33,860
Ci sono stati un paio di persone
che hanno segnalato internet

30
00:01:33,860 --> 00:01:35,390
non lavorare in Appliance.

31
00:01:35,390 --> 00:01:38,090
E alcuni di loro hanno appena assunto
che non si suppone che sia

32
00:01:38,090 --> 00:01:39,190
internet in Appliance.

33
00:01:39,190 --> 00:01:40,750
Ma sì, ci dovrebbe
essere Internet.

34
00:01:40,750 --> 00:01:44,000

35
00:01:44,000 --> 00:01:46,410
>> Lo dirò adesso, ma non lo fa
significa veramente nulla.

36
00:01:46,410 --> 00:01:50,680
Se internet non funziona,
questo è ciò che si tende ad avere bisogno

37
00:01:50,680 --> 00:01:52,180
a correre per risolvere il problema.

38
00:01:52,180 --> 00:01:55,602
Se si hanno problemi di internet, non
ricordarlo, basta postare su

39
00:01:55,602 --> 00:01:57,560
Spiega, e diremo, eseguire tale.

40
00:01:57,560 --> 00:02:00,420
Ma internet dovrebbe funzionare.

41
00:02:00,420 --> 00:02:06,650
>> Quindi l'unica altra cosa - sì, niente
il resto è davvero rilevante.

42
00:02:06,650 --> 00:02:08,979
Ma io volevo solo far notare che -

43
00:02:08,979 --> 00:02:13,290
vedi in questo angolo in basso a destra.

44
00:02:13,290 --> 00:02:16,530
Così ciascuno dei vostri elettrodomestici dovrebbero
avere un indirizzo IP.

45
00:02:16,530 --> 00:02:22,350
E più tardi nel semestre, questo IP
Indirizzo diventerà più rilevante quando

46
00:02:22,350 --> 00:02:27,230
stai lavorando sul web p-set, perché
sarete in grado di accedere alla

47
00:02:27,230 --> 00:02:32,310
il sito si sta lavorando dal
Chrome locale utilizzando l'indirizzo IP.

48
00:02:32,310 --> 00:02:35,400
>> Ma quello che mi piace utilizzare l'indirizzo IP
- e non c'è bisogno di fare questo, io

49
00:02:35,400 --> 00:02:37,460
vogliono solo farlo notare -

50
00:02:37,460 --> 00:02:39,540
è qui.

51
00:02:39,540 --> 00:02:42,910
Quindi questa è una finestra terminale
il mio Mac, questo non è in

52
00:02:42,910 --> 00:02:44,580
Apparecchio a tutti.

53
00:02:44,580 --> 00:02:47,190
E si può cercare ciò che
questo comando fa.

54
00:02:47,190 --> 00:02:51,855
Ma ho intenzione di SSH direttamente
al mio Appliance.

55
00:02:51,855 --> 00:02:53,410
Non so quale sia la IP.

56
00:02:53,410 --> 00:02:54,300
>> JOSEPH: 168 -

57
00:02:54,300 --> 00:02:56,080
>> 168.224.1.0.

58
00:02:56,080 --> 00:02:59,950
>> ROB: Così una volta ho fatto
con questo, accedere

59
00:02:59,950 --> 00:03:05,450
Ora, fondamentalmente, questo è identico a un
finestra di terminale nel mio Appliance.

60
00:03:05,450 --> 00:03:10,280
Così ho praticamente mai effettivamente lavorato
all'interno dell'apparecchio stesso.

61
00:03:10,280 --> 00:03:12,550
Ho sempre ho in esecuzione
in background minimizzato

62
00:03:12,550 --> 00:03:15,890
e SSHed in esso.

63
00:03:15,890 --> 00:03:24,270
>> Il problema con questo è che non sta andando
essere in grado di utilizzare gedit facilmente

64
00:03:24,270 --> 00:03:25,600
direttamente da questa.

65
00:03:25,600 --> 00:03:31,500
Ma se si vuole essere un vero e proprio fresco
hacker, allora si dovrebbe abituarsi ad una

66
00:03:31,500 --> 00:03:34,220
riga di comando editor di testo in ogni caso.

67
00:03:34,220 --> 00:03:39,620
Così Vim e Emacs e Nano, tutti questi
sono diverse alternative.

68
00:03:39,620 --> 00:03:41,560
Nano tende ad essere il più facile.

69
00:03:41,560 --> 00:03:45,006
E penso che non ha
evidenziazione della sintassi.

70
00:03:45,006 --> 00:03:47,620
Oh, no, lo fa totalmente.

71
00:03:47,620 --> 00:03:49,870
Così si può utilizzare Nano, perché
che uno è abbastanza facile.

72
00:03:49,870 --> 00:03:52,000
>> Vedete tutti questi comandi
nella parte inferiore.

73
00:03:52,000 --> 00:03:54,750
Questo piccolo simbolo carota.

74
00:03:54,750 --> 00:03:57,620
Se non avete visto prima, ti
probabilmente vedrete un sacco momento.

75
00:03:57,620 --> 00:04:02,350
Significa generalmente la carota controllo,
come il fondo a sinistra della tastiera

76
00:04:02,350 --> 00:04:04,130
carattere di controllo.

77
00:04:04,130 --> 00:04:07,260
Così qui mi sta dicendo qui -

78
00:04:07,260 --> 00:04:08,710
oh, non è tagliato fuori se lo zoom dentro

79
00:04:08,710 --> 00:04:11,040
Quindi controllo, X è come
Sto per uscire.

80
00:04:11,040 --> 00:04:14,710
E si dice che posso colpire Y
Sì, per il risparmio, N per No.

81
00:04:14,710 --> 00:04:17,190
Ecco, questo è Nano.

82
00:04:17,190 --> 00:04:22,860
>> Vim e Emacs tendono ad essere leggermente più
complicato e travolgente.

83
00:04:22,860 --> 00:04:28,840
Ma si può abitua ad esso,
e allora vi piacerà.

84
00:04:28,840 --> 00:04:30,590
Ecco, questo è quello.

85
00:04:30,590 --> 00:04:31,720
>> JOSEPH: Non c'è bisogno di farlo.

86
00:04:31,720 --> 00:04:31,840
>> ROB: Già.

87
00:04:31,840 --> 00:04:37,510
Siete liberi di usare gedit per l'
resto del semestre.

88
00:04:37,510 --> 00:04:40,630
Quindi tutte le domande di elettrodomestici connessi?

89
00:04:40,630 --> 00:04:42,820
O avete qualche idea su cos'altro
deve essere parlato in merito

90
00:04:42,820 --> 00:04:43,610
l'apparecchio?

91
00:04:43,610 --> 00:04:43,996
Sì.

92
00:04:43,996 --> 00:04:47,720
>> SPEAKER 1: Quando si SSHed nella vostra
cosa, è stato il Crimson password?

93
00:04:47,720 --> 00:04:48,390
>> ROB: Già.

94
00:04:48,390 --> 00:04:50,170
La password per praticamente tutto
nel Appliance sta andando

95
00:04:50,170 --> 00:04:52,473
per essere Crimson.

96
00:04:52,473 --> 00:04:56,517
>> SPEAKER 2: Installare come un vero e proprio IDE
sull'apparecchio, funzionerà?

97
00:04:56,517 --> 00:04:59,200

98
00:04:59,200 --> 00:05:07,290
>> ROB: Io immagino Eclipse ha un
Versione di Fedora, in questo caso, sì,

99
00:05:07,290 --> 00:05:08,420
si può fare.

100
00:05:08,420 --> 00:05:10,875
Probabilmente non è davvero la pena.

101
00:05:10,875 --> 00:05:11,742
>> SPEAKER 2: OK.

102
00:05:11,742 --> 00:05:15,924
Quindi è probabilmente più facile se volevo
utilizzare Eclipse, basta usare il nativo e

103
00:05:15,924 --> 00:05:17,646
poi caricarle -

104
00:05:17,646 --> 00:05:21,090
>> ROB: Oh, che è anche probabilmente più facile.

105
00:05:21,090 --> 00:05:24,046
Ma è possibile farlo funzionare
all'interno del Appliance.

106
00:05:24,046 --> 00:05:27,740
>> JOSEPH: E per la macchina fotografica, la domanda
era, si può installare un altro

107
00:05:27,740 --> 00:05:29,490
IDE interna del dispositivo?

108
00:05:29,490 --> 00:05:31,520
>> ROB: Eclipse essere un
esempio di un IDE.

109
00:05:31,520 --> 00:05:34,800

110
00:05:34,800 --> 00:05:36,050
Tutte le altre domande Appliance?

111
00:05:36,050 --> 00:05:38,250

112
00:05:38,250 --> 00:05:38,680
Bene.

113
00:05:38,680 --> 00:05:44,920
>> Così noi ora passare alla riga di comando
cose di interfaccia-correlati, così CLI.

114
00:05:44,920 --> 00:05:47,990
E ancora, sto solo andando a lavorare in
qui, perché questa è identica a

115
00:05:47,990 --> 00:05:52,780
lavorando all'interno di una finestra di terminale
all'interno del Appliance.

116
00:05:52,780 --> 00:05:54,160
Come sta il font cercando?

117
00:05:54,160 --> 00:05:55,970
Che è abbastanza grande?

118
00:05:55,970 --> 00:05:57,000
Bene.

119
00:05:57,000 --> 00:06:02,480
>> Quindi ci sono un sacco di comandi che
si dovrebbe ottenere abbastanza utilizzato per

120
00:06:02,480 --> 00:06:04,490
tutto il semestre.

121
00:06:04,490 --> 00:06:09,480
Il grande due per la navigazione sono ls lista
i file in questa directory, e

122
00:06:09,480 --> 00:06:11,380
cd, in modo da cambiare la directory.

123
00:06:11,380 --> 00:06:18,390
Così posso cambiare per desktop e poi
un modello molto comune è cd per un

124
00:06:18,390 --> 00:06:22,550
directory e immediatamente ls
Cosa c'è nella directory.

125
00:06:22,550 --> 00:06:25,540
>> La gente a volte non si rendono conto
che il completamento Tab è una cosa.

126
00:06:25,540 --> 00:06:28,370
Cd Così come, vh, e poi mi ha colpito Tab.

127
00:06:28,370 --> 00:06:30,790
Non ho quasi mai digito su
l'intera cosa.

128
00:06:30,790 --> 00:06:32,920
E poi se continuo a prenderla Tab
ancora una volta, sarà automaticamente

129
00:06:32,920 --> 00:06:33,670
iniziare l'elenco per me.

130
00:06:33,670 --> 00:06:37,000
Così posso cd vhosts, host locale.

131
00:06:37,000 --> 00:06:39,880
E questo è solo andando -

132
00:06:39,880 --> 00:06:43,380
nel caso in cui non avete sentito il termine
prima, directory è solo un'altra parola

133
00:06:43,380 --> 00:06:45,170
per la cartella.

134
00:06:45,170 --> 00:06:49,930
Così ora se vedete -

135
00:06:49,930 --> 00:06:51,810
cerchiamo di portare quella verso l'alto.

136
00:06:51,810 --> 00:06:55,380
>> Così ora se vedete tra parentesi, è
vedere la tilde poco, barra, vhost,

137
00:06:55,380 --> 00:06:56,810
slash, host locale.

138
00:06:56,810 --> 00:07:00,040
Così la tilde, che si riferisce
alla mia home directory.

139
00:07:00,040 --> 00:07:03,090
Si tratta di una directory sei
quando si SSH dentro

140
00:07:03,090 --> 00:07:05,660
E 'la directory che sei quando
si apre un terminale.

141
00:07:05,660 --> 00:07:08,650
E 'dove si inizia.

142
00:07:08,650 --> 00:07:13,110
E quindi sono dentro la mia home directory,
e io sono all'interno del vhost

143
00:07:13,110 --> 00:07:14,475
directory all'interno della mia home directory.

144
00:07:14,475 --> 00:07:19,670
E poi sono all'interno del locale
ospiterà directory all'interno di questo.

145
00:07:19,670 --> 00:07:23,740
>> Così alcune altre cose utili con cd -

146
00:07:23,740 --> 00:07:29,220
o anche, in generale, così dot sempre
si riferisce alla directory corrente.

147
00:07:29,220 --> 00:07:31,130
Cd, dot è un comando piuttosto inutile.

148
00:07:31,130 --> 00:07:35,150
Ma questo sta cambiando la
directory corrente.

149
00:07:35,150 --> 00:07:38,230
Uno più utile in termini di
cd è dot, dot, che è

150
00:07:38,230 --> 00:07:40,220
basta andare su una directory.

151
00:07:40,220 --> 00:07:43,360
>> E notare che queste -

152
00:07:43,360 --> 00:07:48,610
Voglio dire alias, ma questi
simboli, dot, e dot, dot, quelli di lavoro

153
00:07:48,610 --> 00:07:51,740
per praticamente qualsiasi comando sei
andando a pensare di correre.

154
00:07:51,740 --> 00:07:55,370
Così come il cd è probabilmente dove sarai
utilizzando le più, ma questi non sono

155
00:07:55,370 --> 00:07:56,780
cose che proprio cd capisce.

156
00:07:56,780 --> 00:07:59,980
È praticamente qualcosa l'intero
riga di comando capisce.

157
00:07:59,980 --> 00:08:01,932
Un sacco di programmi capire
dot e dot, dot.

158
00:08:01,932 --> 00:08:04,830

159
00:08:04,830 --> 00:08:09,090
>> Così gli altri utili - cd, dash.

160
00:08:09,090 --> 00:08:13,460
Così che sta per portarmi al
ultima directory che ero dentro

161
00:08:13,460 --> 00:08:15,980
Così a volte farò qualcosa di simile,
oh, sto lavorando qui.

162
00:08:15,980 --> 00:08:21,110
E vedo qualche errore con qualcosa, e
Vado a indagare è andando a

163
00:08:21,110 --> 00:08:24,020
una directory a caso da qualche parte.

164
00:08:24,020 --> 00:08:25,260
E non so se sarà
lasciami in là.

165
00:08:25,260 --> 00:08:25,720
Sarà.

166
00:08:25,720 --> 00:08:27,615
Allora io faccio quello che voglio
in questa directory.

167
00:08:27,615 --> 00:08:28,950
Blah, blah, blah, blah, blah.

168
00:08:28,950 --> 00:08:31,770
E mi sono detto, va bene, voglio
per tornare a dove mi trovavo.

169
00:08:31,770 --> 00:08:34,490
cd, cruscotto, e mi porta a destra indietro.

170
00:08:34,490 --> 00:08:39,970
>> Quindi ho intenzione di buttare un sacco
di questi a voi oggi.

171
00:08:39,970 --> 00:08:43,730
Non mi aspetto di memorizzare
tutti loro.

172
00:08:43,730 --> 00:08:46,170
E 'una specie di sufficiente sapere
che esistono.

173
00:08:46,170 --> 00:08:48,690
E poi quando siete come,
hmm, voglio tornare al

174
00:08:48,690 --> 00:08:51,870
directory che ero solo a, oh, aspetta,
qualcosa di simile esiste.

175
00:08:51,870 --> 00:08:53,980
Non dovete digitare solo in
ancora una volta l'intera directory.

176
00:08:53,980 --> 00:08:56,090
>> JOSEPH: E alla fine vi sarà solo
usarli più e più volte, e

177
00:08:56,090 --> 00:08:57,830
essa diventerà memoria muscolare.

178
00:08:57,830 --> 00:09:00,090
>> ROB: Già.

179
00:09:00,090 --> 00:09:02,930
Quindi, come ho detto prima, che la tilde
è la vostra directory home.

180
00:09:02,930 --> 00:09:04,820
Così posso cd, tilde.

181
00:09:04,820 --> 00:09:07,280
Ma non ho nemmeno bisogno di
farlo se ho appena -

182
00:09:07,280 --> 00:09:09,760
Tornerò alla directory in modo
non è un esempio inutile.

183
00:09:09,760 --> 00:09:14,560
Ma se io faccio solo cd, che è anche l'
stessa, andare alla mia home directory.

184
00:09:14,560 --> 00:09:18,380

185
00:09:18,380 --> 00:09:19,880
Faccio Command, K.

186
00:09:19,880 --> 00:09:24,015
>> JOSEPH: È anche possibile digitare chiaro, il
parola, e dovrebbe cancellarlo.

187
00:09:24,015 --> 00:09:28,650
>> ROB: E penso anche di controllo,
L fa anche.

188
00:09:28,650 --> 00:09:29,690
Così un sacco di modi diversi.

189
00:09:29,690 --> 00:09:34,070
Penso che ci siano alcune differenze dove
chiaro e Controllo, L sarà solo

190
00:09:34,070 --> 00:09:37,280
davvero spingere verso l'alto e
Posso ancora scorrere indietro.

191
00:09:37,280 --> 00:09:40,580
Comando, K distrugge letteralmente
tutto, e si

192
00:09:40,580 --> 00:09:42,960
non può scorrere indietro.

193
00:09:42,960 --> 00:09:45,530
Per lo meno, questo è
come funziona in iTerm2.

194
00:09:45,530 --> 00:09:48,690
Io non so come le altre cose -

195
00:09:48,690 --> 00:09:49,360
oh.

196
00:09:49,360 --> 00:09:55,450
>> Con sshing, quindi se siete su Windows,
si sta andando ad avere per scaricare PuTTY

197
00:09:55,450 --> 00:10:02,360
al fine di SSH quando Windows non
avere come uno strumento integrato in SSH.

198
00:10:02,360 --> 00:10:06,150
Da Mac, si può solo SSH direttamente
da una finestra di terminale.

199
00:10:06,150 --> 00:10:08,755

200
00:10:08,755 --> 00:10:09,690
OK.

201
00:10:09,690 --> 00:10:11,840
Domande?

202
00:10:11,840 --> 00:10:19,260
>> Con ls, quindi qualcosa per abituarsi a
con la maggior parte di questi comandi è -

203
00:10:19,260 --> 00:10:20,060
bene, lo farò uno.

204
00:10:20,060 --> 00:10:21,310
Ls, dash, l.

205
00:10:21,310 --> 00:10:26,330
Così trattino, l è quello che stiamo andando
per chiamare un flag per ls.

206
00:10:26,330 --> 00:10:30,770
E molti di questi comandi hanno bandiere
che è possibile passare a loro.

207
00:10:30,770 --> 00:10:35,020
Quindi, in questo caso, dash, l è una bandiera
che dice di darmi una completa

208
00:10:35,020 --> 00:10:37,850
elenco di tutte le informazioni
di questi file.

209
00:10:37,850 --> 00:10:44,790
>> Così vediamo qui che il tavolo era
modificato il 30 luglio alle 00:54.

210
00:10:44,790 --> 00:10:47,160
Download è stato modificato al 6 settembre.

211
00:10:47,160 --> 00:10:52,350
Queste sono le dimensioni attuali e
byte di queste directory.

212
00:10:52,350 --> 00:10:54,412
Non devi capire
tutto questo.

213
00:10:54,412 --> 00:11:00,380
>> Questa roba sulla sinistra, questi drwx di,
che diventerà molto più rilevante

214
00:11:00,380 --> 00:11:02,290
più tardi, quando si ha a che fare con -

215
00:11:02,290 --> 00:11:05,900
che ha a che fare con chi ha i permessi
guardare a questi file.

216
00:11:05,900 --> 00:11:09,880
E così, se tu non fossi l'unico utente su
questo computer, si sarebbe in grado di

217
00:11:09,880 --> 00:11:13,345
per esempio, OK, dovrei essere l'unico
permesso di guardare a questo file o sono

218
00:11:13,345 --> 00:11:14,870
andando per permettere a tutti
di guardare a questo file.

219
00:11:14,870 --> 00:11:17,710
Così qualcuno sul mio computer
può guardare a questo file.

220
00:11:17,710 --> 00:11:22,190

221
00:11:22,190 --> 00:11:25,600
Io non so nemmeno cosa questa -
che cosa fa questo?

222
00:11:25,600 --> 00:11:26,840
>> JOSEPH: Io non sono molto sicuro, in realtà.

223
00:11:26,840 --> 00:11:27,705
>> ROB: Non ne ho idea.

224
00:11:27,705 --> 00:11:30,530
>> JOSEPH: Ma se non si sa, c'è
un comando utile che è possibile utilizzare

225
00:11:30,530 --> 00:11:31,680
per dirti cosa significa l'uscita.

226
00:11:31,680 --> 00:11:33,780
E se si digita l'uomo
prima del comando -

227
00:11:33,780 --> 00:11:35,000
così M-A-N. ROB: Uomo.

228
00:11:35,000 --> 00:11:37,690
Così l'uomo è un altro
che è molto utile.

229
00:11:37,690 --> 00:11:39,540
E l'uomo, ls.

230
00:11:39,540 --> 00:11:47,320
Così le pagine man, hanno entrambi
comandi che si sta andando ad essere con

231
00:11:47,320 --> 00:11:50,330
nella riga di comando, e hanno anche
funzioni che saranno rilevanti

232
00:11:50,330 --> 00:11:52,530
con C. Così si può l'uomo -

233
00:11:52,530 --> 00:11:53,720
e ho ignorato 3.

234
00:11:53,720 --> 00:11:57,410
Ma man 3 printf sta per portare
la versione C della printf.

235
00:11:57,410 --> 00:12:01,030
Ma se io faccio solo uomo printf, questo è
andando a portare il comando printf

236
00:12:01,030 --> 00:12:03,540
che accade nella riga di comando.

237
00:12:03,540 --> 00:12:05,730
>> Così l'uomo, ls.

238
00:12:05,730 --> 00:12:09,030
Le pagine man possono essere abbastanza
travolgente.

239
00:12:09,030 --> 00:12:12,770
Qui, però, vedrete questo annuncio
di tutti questi flag che ls

240
00:12:12,770 --> 00:12:14,300
capisce.

241
00:12:14,300 --> 00:12:17,876
Quindi, se andiamo a precipitare, l, e -

242
00:12:17,876 --> 00:12:19,300
Sto solo andando a buttare questo a voi.

243
00:12:19,300 --> 00:12:23,050
Ma per la ricerca, si vuole
alla prima colpire la questione

244
00:12:23,050 --> 00:12:24,780
marchio o il pulsante di barra.

245
00:12:24,780 --> 00:12:26,040
Quindi tagliare.

246
00:12:26,040 --> 00:12:29,000
>> E poi posso cercare
per quello che voglio.

247
00:12:29,000 --> 00:12:33,780
Quindi ho intenzione di tagliare per il cruscotto, l.

248
00:12:33,780 --> 00:12:35,110
Ed eccolo lì.

249
00:12:35,110 --> 00:12:37,450
Quindi, utilizzare un formato di elenco lungo.

250
00:12:37,450 --> 00:12:40,060
Questo non mi aiuta a capire che cosa
quella colonna particolare significato, ma io

251
00:12:40,060 --> 00:12:44,480
assumere da qualche parte qui
si spiegherebbe così.

252
00:12:44,480 --> 00:12:48,740
Quindi, utilizzare le pagine man di un comando
che non si capisce immediatamente.

253
00:12:48,740 --> 00:12:51,080
>> Sono abbastanza sicuro che si può anche l'uomo, l'uomo.

254
00:12:51,080 --> 00:12:53,070
Un'interfaccia alla linea
manuali di riferimento.

255
00:12:53,070 --> 00:12:57,700

256
00:12:57,700 --> 00:13:03,570
Ah, un'ultima uno che è forse un po '
rilevanti è LS, cruscotto, a.

257
00:13:03,570 --> 00:13:08,490
Quindi notare se io faccio solo ls,
Ottengo questi cinque file.

258
00:13:08,490 --> 00:13:11,480
Se faccio ls Dash, una, io
ottenere molto di più file.

259
00:13:11,480 --> 00:13:15,350
Quindi la cosa in comune tra tutti questi
nuovi file è il punto in anticipo.

260
00:13:15,350 --> 00:13:21,220
>> Così la convenzione è che un file che
inizia con un punto è nascosto.

261
00:13:21,220 --> 00:13:25,300
Quindi non si vuole vedere che file,
Non vuole avere pasticciare con

262
00:13:25,300 --> 00:13:26,750
profilo directory.

263
00:13:26,750 --> 00:13:30,020
E 'solo quando si chiede esplicitamente,
tutto bene, LS, dash, una, mi mostra.

264
00:13:30,020 --> 00:13:32,830
La A sta per tutti i file,
compresi quelli nascosti.

265
00:13:32,830 --> 00:13:37,260

266
00:13:37,260 --> 00:13:39,270
Così alcuni altri comandi.

267
00:13:39,270 --> 00:13:41,323
Oh, domande a quel punto?

268
00:13:41,323 --> 00:13:41,746
Sì.

269
00:13:41,746 --> 00:13:45,914
>> SPEAKER 3: Quando si esegue ls,
una, qual è il punto, dot?

270
00:13:45,914 --> 00:13:46,870
>> ROB: Oh.

271
00:13:46,870 --> 00:13:48,780
Quindi questo è quello che stavo parlando.

272
00:13:48,780 --> 00:13:50,890
E 'la stessa cosa, dove
Posso scrivere un cd, dot, dot.

273
00:13:50,890 --> 00:13:56,790
Tecnicamente, quindi, punto e dot, dot sono
file che esistono in ogni singola

274
00:13:56,790 --> 00:14:03,620
directory dove il file dot riferisce
alla directory corrente.

275
00:14:03,620 --> 00:14:06,930
Quindi, se ho cd, puntino, sto solo andando
rimanere nella directory.

276
00:14:06,930 --> 00:14:10,870
E dot, dot fa sempre riferimento al
precedente directory di livello superiore.

277
00:14:10,870 --> 00:14:18,200
Quindi se vado in ceppi e LS, cruscotto, al,
Vedrò dot, dot. cd per dot, dot

278
00:14:18,200 --> 00:14:20,390
mi porta alla directory precedente.

279
00:14:20,390 --> 00:14:24,530

280
00:14:24,530 --> 00:14:25,780
Già.

281
00:14:25,780 --> 00:14:27,160

282
00:14:27,160 --> 00:14:28,110
OK.

283
00:14:28,110 --> 00:14:33,070
>> Così un altro abbastanza importante
comando rm.

284
00:14:33,070 --> 00:14:35,650
Ecco, questo è quello che stiamo andando
da utilizzare per rimuovere.

285
00:14:35,650 --> 00:14:38,100
E lasciatemi fatto fare un altro
primo comando.

286
00:14:38,100 --> 00:14:39,610
Così mkdir.

287
00:14:39,610 --> 00:14:42,770
Mkdir è come si può
creare directory.

288
00:14:42,770 --> 00:14:47,530
E creerò una directory temporanea
e vai in quella directory temporanea.

289
00:14:47,530 --> 00:14:49,590
E come previsto, è vuota.

290
00:14:49,590 --> 00:14:53,680
Ma se io ls, Dash, una, ho ancora dot
e dot, dot, dot perché si riferisce a

291
00:14:53,680 --> 00:14:54,480
la directory corrente.

292
00:14:54,480 --> 00:14:56,170
E dot, dot si riferisce al
directory precedente.

293
00:14:56,170 --> 00:14:58,700
E quelli saranno sempre esisterà, non importa
la directory in cui ti trovi

294
00:14:58,700 --> 00:15:01,910

295
00:15:01,910 --> 00:15:09,010
>> E questo è un completamente inutile
comando, ma tocco.

296
00:15:09,010 --> 00:15:11,880
Sto solo usando, perché è
un modo semplice per creare file.

297
00:15:11,880 --> 00:15:16,180
Quindi toccare una Toccare b, toccare c è solo
andando a creare tre file chiamati a,

298
00:15:16,180 --> 00:15:17,845
B e C che sono completamente vuoti.

299
00:15:17,845 --> 00:15:20,450

300
00:15:20,450 --> 00:15:24,980
Quindi il punto di me creando quelli nella
primo posto è solo così che rm è

301
00:15:24,980 --> 00:15:26,250
come possiamo rimuoverlo.

302
00:15:26,250 --> 00:15:27,850
Quindi rm, a.

303
00:15:27,850 --> 00:15:30,960
Sta andando a chiedere a me, rimuovere
regolare un file vuoto?

304
00:15:30,960 --> 00:15:33,170
E allora io dico sì.

305
00:15:33,170 --> 00:15:39,090
>> Quindi, se io so per certo che voglio
cancellare quel file senza dover essere

306
00:15:39,090 --> 00:15:44,500
richiesto, rimuovere regolarmente file vuoto?,
allora rm, cruscotto, f sta per essere il

307
00:15:44,500 --> 00:15:48,230
bandiera che dice, forzare il rimuovere senza
anche a me spingendo, oh, sei

308
00:15:48,230 --> 00:15:49,710
sicuri di voler cancellare il file?

309
00:15:49,710 --> 00:15:50,810
Sì, ne sono sicuro.

310
00:15:50,810 --> 00:15:56,050
Così rm, dash, fb sarà solo
farlo senza chiedere.

311
00:15:56,050 --> 00:15:57,950
>> Quindi cerchiamo di fare qualche altra directory.

312
00:15:57,950 --> 00:16:03,670
mkdir, tmp2, cd, tmp2,
toccare un tocco b.

313
00:16:03,670 --> 00:16:04,300
OK.

314
00:16:04,300 --> 00:16:08,180
Così ora voglio rimuovere
tmp2 come una directory.

315
00:16:08,180 --> 00:16:10,316
Tmp2 così rm.

316
00:16:10,316 --> 00:16:12,920
Non è possibile rimuovere tmp2,
questa è una directory.

317
00:16:12,920 --> 00:16:21,370
Quindi il problema qui è che rm non
lavorare immediatamente su directory.

318
00:16:21,370 --> 00:16:26,530
E 'pensato solo per i file come
file non-directory.

319
00:16:26,530 --> 00:16:30,800
>> E allora cosa possiamo fare
ecco rm, cruscotto, r.

320
00:16:30,800 --> 00:16:35,160
Che sta per ricorsivo, che potrebbe
non significa nulla per voi ancora.

321
00:16:35,160 --> 00:16:38,280
Ma quando si arriva a ricorsione,
vorrà dire di più.

322
00:16:38,280 --> 00:16:43,540
Così rm, dash, r, tmp2 sta per
ricorsivamente andare in quella directory.

323
00:16:43,540 --> 00:16:45,540
Quindi si scende nella directory tmp2?

324
00:16:45,540 --> 00:16:47,330
Sì, andiamo in quella.

325
00:16:47,330 --> 00:16:49,360
Vogliamo rimuovere tmp2 / a?

326
00:16:49,360 --> 00:16:49,745
Sì.

327
00:16:49,745 --> 00:16:51,830
Vogliamo rimuovere tmp2 / b?

328
00:16:51,830 --> 00:16:52,840
Sì.

329
00:16:52,840 --> 00:16:55,170
Ora vogliamo eliminare
il tmp2 directory?

330
00:16:55,170 --> 00:16:56,040
Sì.

331
00:16:56,040 --> 00:16:58,410
E così ora la directory
e tutto dentro

332
00:16:58,410 --> 00:16:59,660
di esso è stato rimosso.

333
00:16:59,660 --> 00:17:02,850

334
00:17:02,850 --> 00:17:07,250
>> Vi è tecnicamente un rmdir comando
che è possibile utilizzare per rimuovere

335
00:17:07,250 --> 00:17:11,670
directory, ma esso funziona solo
sulla directory vuote comunque.

336
00:17:11,670 --> 00:17:14,109
E vedere che, diciamo solo
fare di nuovo mkdir, tmp2.

337
00:17:14,109 --> 00:17:15,940
Tmp2, toccare una.

338
00:17:15,940 --> 00:17:16,800
OK.

339
00:17:16,800 --> 00:17:22,770
Quindi, se provo a rimuoverlo dirtmp2, sarà
dire, directory non vuota.

340
00:17:22,770 --> 00:17:29,540
Così ho praticamente mai usato la rimozione
comando dir in ogni caso, perché rm, dash,

341
00:17:29,540 --> 00:17:35,140
r lavorerà su directory vuote
e le directory non vuote.

342
00:17:35,140 --> 00:17:37,760
>> E anche se io non voglio avere a
passare attraverso questo intero processo di

343
00:17:37,760 --> 00:17:40,720
scendendo nella directory e
rimozione di ogni singolo file, rm,

344
00:17:40,720 --> 00:17:44,190
dash, rf, tmp2.

345
00:17:44,190 --> 00:17:45,670
E ora non c'è più.

346
00:17:45,670 --> 00:17:51,220
>> Qualcosa da stare attenti
in merito è rm, cruscotto, rf.

347
00:17:51,220 --> 00:17:53,660
E mi spaventa anche di tipo IT,
perché se mi sbaglio

348
00:17:53,660 --> 00:17:55,090
premere Invio o qualcosa del genere.

349
00:17:55,090 --> 00:18:02,735
Così rm, dash, rf, tilde sarebbe, senza
me spingendo, la f non chiede

350
00:18:02,735 --> 00:18:05,670
me, rimuoverà automaticamente
tutta la mia home directory e

351
00:18:05,670 --> 00:18:06,780
tutto in esso.

352
00:18:06,780 --> 00:18:11,460
Quindi si potrebbe pensare che sia
una cosa stupida da fare.

353
00:18:11,460 --> 00:18:12,830
E bene, è.

354
00:18:12,830 --> 00:18:18,600
>> Ma può accadere molto facilmente
incidente se, per esempio, ho voluto rimuovere

355
00:18:18,600 --> 00:18:21,640
la mia barra, directory vhost.

356
00:18:21,640 --> 00:18:26,610
E proprio nella digitazione veloce,
Ho accidentalmente faccio.

357
00:18:26,610 --> 00:18:31,880
Che rimuovere ricorsivamente sia la mia
home directory e la directory vhost

358
00:18:31,880 --> 00:18:35,450
in questa directory particolare, che solo
succede a non esistere in questo momento.

359
00:18:35,450 --> 00:18:39,520
Ma questo sarebbe ancora rimuovere
tutta la mia home directory.

360
00:18:39,520 --> 00:18:43,090
Almeno non avendo un f,
mi avrebbe chiesto prima.

361
00:18:43,090 --> 00:18:45,670
E sarei come, oh, no,
non vogliono farlo.

362
00:18:45,670 --> 00:18:50,570
Ma la gente, Slash, tra cui
io tendo ad entrare nel

363
00:18:50,570 --> 00:18:53,090
abitudine di sempre rf-ing.

364
00:18:53,090 --> 00:18:58,713
Anche i file regolari che posso solo rm,
c, tendo a solo rm, dash, rf, c.

365
00:18:58,713 --> 00:19:01,330
Basta essere attenti quando sei rf-ing.

366
00:19:01,330 --> 00:19:03,160
>> SPEAKER 4: Cosa C fare?

367
00:19:03,160 --> 00:19:11,570
>> ROB: C è sto parlando di quel file C
in questa directory, che rm, c.

368
00:19:11,570 --> 00:19:15,730
>> JOSEPH: E più pericolosamente, se si utilizza
una stella, si riferisce a tutto a

369
00:19:15,730 --> 00:19:16,450
la directory.

370
00:19:16,450 --> 00:19:20,040
Quindi quello che normalmente tendo a fare è io
Vado in una directory e voglio

371
00:19:20,040 --> 00:19:21,510
rimuovere tutti i file in là.

372
00:19:21,510 --> 00:19:23,640
Così rm, dash, rf, stella.

373
00:19:23,640 --> 00:19:25,700
>> ROB: Già.

374
00:19:25,700 --> 00:19:26,780
Rm, dash, rf, stella.

375
00:19:26,780 --> 00:19:29,530
>> JOSEPH: E se non stai attento
quale directory siete in -

376
00:19:29,530 --> 00:19:33,340
Non ero in temperatura, ma ero accidentalmente
nella mia home directory,

377
00:19:33,340 --> 00:19:35,450
poi mi tolgo tutto
nella mia home directory.

378
00:19:35,450 --> 00:19:39,095
E in realtà ho fatto prima, e
Credo che tu abbia fatto questo prima o

379
00:19:39,095 --> 00:19:40,640
Jay ha fatto prima.

380
00:19:40,640 --> 00:19:42,480
>> ROB: Ho rimosso accidentalmente -

381
00:19:42,480 --> 00:19:44,480
in modo da ignorare che il comando per un po '.

382
00:19:44,480 --> 00:19:45,800
>> JOSEPH: Non divertente.

383
00:19:45,800 --> 00:19:52,650
>> ROB: Quindi nella directory bin barra è un
gruppo di file binari, dove ci sarà

384
00:19:52,650 --> 00:19:54,840
essere quelli familiari come clang.

385
00:19:54,840 --> 00:20:00,740
Beh, clang e praticamente tutti questi
cose che sto correndo al comando

386
00:20:00,740 --> 00:20:02,060
linea sono in questa directory bin barra.

387
00:20:02,060 --> 00:20:03,090
>> JOSEPH: come ls è qui.

388
00:20:03,090 --> 00:20:06,285
>> ROB: Così puntino, tagliare, LS sarebbero
elencare questa directory.

389
00:20:06,285 --> 00:20:08,120
>> JOSEPH: Rm è anche in questa directory.

390
00:20:08,120 --> 00:20:12,770
>> ROB: Ho accidentalmente RM, rf-ed bin,
che rimosso qualsiasi comando che potevo

391
00:20:12,770 --> 00:20:14,380
forse mai desiderare.

392
00:20:14,380 --> 00:20:18,085
Che poi ho appena reinstallare un
nuova Appliance in quel punto.

393
00:20:18,085 --> 00:20:20,170
>> JOSEPH: Quindi, essere molto attenti quando
si utilizza questo comando.

394
00:20:20,170 --> 00:20:21,120
>> AUDIENCE: [incomprensibile]?

395
00:20:21,120 --> 00:20:22,640
>> ROB: sì.

396
00:20:22,640 --> 00:20:24,135
Questa è anche una cattiva abitudine per entrare.

397
00:20:24,135 --> 00:20:27,920

398
00:20:27,920 --> 00:20:30,170
Se notate, ora sono -

399
00:20:30,170 --> 00:20:33,580
bene, non si nota, ma
il mio zoom-in può forse.

400
00:20:33,580 --> 00:20:35,360
Quindi sono ora root @ apparecchio.

401
00:20:35,360 --> 00:20:39,790
Così jharvard è l'utente che vogliamo
di essere sempre in uso.

402
00:20:39,790 --> 00:20:43,820
Root è l'utente che disponga dell'autorizzazione
di fare assolutamente nulla.

403
00:20:43,820 --> 00:20:50,260
>> Così notato quando sono jharvard,
se cerco di cd -

404
00:20:50,260 --> 00:20:52,461
cos'è una directory?

405
00:20:52,461 --> 00:20:53,980
Oh, la radice è un buon esempio.

406
00:20:53,980 --> 00:20:54,950
Così cd, radice.

407
00:20:54,950 --> 00:20:56,030
Permesso negato.

408
00:20:56,030 --> 00:21:00,060
Perché se guardiamo a questo annuncio -

409
00:21:00,060 --> 00:21:02,410
e ancora, non c'è bisogno di
tutto capire questo.

410
00:21:02,410 --> 00:21:09,210
Ma questi tre trattini stanno dicendo
che non lasciare nessun altro

411
00:21:09,210 --> 00:21:11,120
utente in questa directory.

412
00:21:11,120 --> 00:21:14,540
E la directory succede a
essere di proprietà di root.

413
00:21:14,540 --> 00:21:20,310
>> Quindi il fatto che io sono jharvard e non
uno che non è root è consentito in

414
00:21:20,310 --> 00:21:23,490
questa directory, il che significa che sono
sta per ottenere il permesso negato quando ho

415
00:21:23,490 --> 00:21:25,160
cercare di cd in esso.

416
00:21:25,160 --> 00:21:31,370
Così, quando sono root, ho il permesso di
fare assolutamente nulla, compreso

417
00:21:31,370 --> 00:21:34,660
eliminare i file essenziali
per l'apparecchio e

418
00:21:34,660 --> 00:21:36,640
distruggere l'intera cosa.

419
00:21:36,640 --> 00:21:41,240
>> Quindi è una cattiva abitudine per entrare
semplicemente passeggiare intorno alla vostra

420
00:21:41,240 --> 00:21:43,650
sistema operativo come root.

421
00:21:43,650 --> 00:21:46,520
Io faccio comunque.

422
00:21:46,520 --> 00:21:48,710
Domande?

423
00:21:48,710 --> 00:21:52,230
E io esco radice, rimango come jharvard.

424
00:21:52,230 --> 00:21:54,510
OK.

425
00:21:54,510 --> 00:21:55,820
>> I comandi più rilevanti.

426
00:21:55,820 --> 00:22:03,975
Quindi, tornando nel nostro temp, l'
comando mv sta per muoversi.

427
00:22:03,975 --> 00:22:05,450
È possibile spostare un file.

428
00:22:05,450 --> 00:22:07,610
Ora vogliamo chiamarlo b,
così ora si chiama b.

429
00:22:07,610 --> 00:22:10,650
O forse vogliamo spostare
b su una directory.

430
00:22:10,650 --> 00:22:12,730
Così ora vuoto di questa directory.

431
00:22:12,730 --> 00:22:15,410
Tornerò alla mia home directory, e
vediamo che b è qui, perché l'

432
00:22:15,410 --> 00:22:19,230
home directory è una directory dal
la directory che b era stato dentro

433
00:22:19,230 --> 00:22:24,710

434
00:22:24,710 --> 00:22:26,580
>> C'è anche cp.

435
00:22:26,580 --> 00:22:33,210
Così cp è copiare la sezione super,
dot, il testo.

436
00:22:33,210 --> 00:22:35,750
Posso chiamarla s, punto, il testo.

437
00:22:35,750 --> 00:22:39,780
Ora abbiamo sia la sezione super,
dot, il testo, e s, punto, il testo.

438
00:22:39,780 --> 00:22:41,340
Questo funziona anche su directory.

439
00:22:41,340 --> 00:22:44,040

440
00:22:44,040 --> 00:22:46,560
I rf-ed un singolo file.

441
00:22:46,560 --> 00:22:48,200
Così cp -

442
00:22:48,200 --> 00:22:51,710
bene, prima proviamo cp, tmp, tmp2.

443
00:22:51,710 --> 00:22:53,220
Quindi, omettendo directory tmp.

444
00:22:53,220 --> 00:22:57,440
Così simile a RM, il comportamento predefinito
è quello di non lavorare sulle directory.

445
00:22:57,440 --> 00:23:01,570
>> E ancora, simile a RM, il default
comportamento - bene, a farla funzionare

446
00:23:01,570 --> 00:23:04,230
con le directory è un trattino-r di distanza.

447
00:23:04,230 --> 00:23:09,240
Quindi copiare ricorsivamente la temperatura
directory in tmp2.

448
00:23:09,240 --> 00:23:13,700
E così ora abbiamo sia tmp e tmp2,
e che non è che utile in quanto tmp

449
00:23:13,700 --> 00:23:16,814
era vuoto, in primo luogo.

450
00:23:16,814 --> 00:23:18,660
Tmp2.

451
00:23:18,660 --> 00:23:22,680
>> Ora cerchiamo di copiare tmp in tmp2.

452
00:23:22,680 --> 00:23:27,900
E vediamo che tmp2 ha anche il file
una, perché la directory e

453
00:23:27,900 --> 00:23:32,220
tutto all'interno di tale
directory è stato copiato.

454
00:23:32,220 --> 00:23:36,000
E che può essere in qualche modo utile
Se, per esempio si sta lavorando

455
00:23:36,000 --> 00:23:38,860
il problema di impostare uno -

456
00:23:38,860 --> 00:23:41,320
o addirittura, insiemi di problemi successivi sono
ancora più importante, perché ci

457
00:23:41,320 --> 00:23:43,660
sarà un intero gruppo
di file e cose.

458
00:23:43,660 --> 00:23:47,010
>> Ma vuoi solo, per una frazione di
secondo, sei come, va bene, io sono

459
00:23:47,010 --> 00:23:50,210
andando a provare qualcosa di diverso.

460
00:23:50,210 --> 00:23:57,860
Vorrei solo copiare tutta la mia pset1
Elenco di backup in modo che se pset1

461
00:23:57,860 --> 00:24:01,490
Mi finire avvitamento cose, posso
tornare nella mia directory di backup.

462
00:24:01,490 --> 00:24:07,340
Ci sono modi più appropriati di
versioning backup del codice, ma

463
00:24:07,340 --> 00:24:10,610
questo è sempre un modo rapido per fare solo
Assicurarsi di avere una copia di qualcosa

464
00:24:10,610 --> 00:24:11,860
che si sta per modificare.

465
00:24:11,860 --> 00:24:16,974

466
00:24:16,974 --> 00:24:27,090
>> Così eco è anche un comando one-off che
tipo di sillily sarà solo stampare

467
00:24:27,090 --> 00:24:31,540
riga di comando esattamente ciò che
si voleva fare eco.

468
00:24:31,540 --> 00:24:32,680
Quindi echo hi.

469
00:24:32,680 --> 00:24:35,420
Dobbiamo solo stampiamo hi.

470
00:24:35,420 --> 00:24:38,030
Echo ciao mondo.

471
00:24:38,030 --> 00:24:39,800
Ti Stampiamo ciao mondo.

472
00:24:39,800 --> 00:24:44,350
Che entra in uso quando si
iniziare combinando i comandi.

473
00:24:44,350 --> 00:24:48,300
>> E ancora, non aspettatevi di tutto
comprendere questo ancora, ma è

474
00:24:48,300 --> 00:24:49,910
qualcosa da vedere.

475
00:24:49,910 --> 00:24:52,470
E poi se siete usare Google per gli esempi
o ti rendi conto che vuoi fare

476
00:24:52,470 --> 00:24:55,030
qualcosa, può essere utile.

477
00:24:55,030 --> 00:24:59,020
Quindi cerchiamo di, ad esempio,
così LS, cruscotto, l.

478
00:24:59,020 --> 00:25:01,160
Così qui vedo l'uscita
di LS, cruscotto, l.

479
00:25:01,160 --> 00:25:06,560
E io dico, OK, voglio
memorizzare che in un file.

480
00:25:06,560 --> 00:25:11,620
Tutto di questa uscita qui, voglio
mettere in un file separato.

481
00:25:11,620 --> 00:25:16,080
>> Così questo piccolo simbolo di maggiore
è quello che stiamo andando a chiamare.

482
00:25:16,080 --> 00:25:18,570
Noi stiamo reindirizzando l'
output in un file.

483
00:25:18,570 --> 00:25:21,680
Chiamiamo il file bla, perché è
quello che io tendo a chiamare sempre.

484
00:25:21,680 --> 00:25:26,430
Così ora vediamo che abbiamo un
presentare blah proprio qui.

485
00:25:26,430 --> 00:25:30,270
E se lo apro, mi vedrò che è
esattamente l'output del comando

486
00:25:30,270 --> 00:25:31,990
che ho appena eseguito.

487
00:25:31,990 --> 00:25:36,020
E allo stesso modo, è possibile -

488
00:25:36,020 --> 00:25:41,260
se questo era output in un file, questo
è ottenere input da un file.

489
00:25:41,260 --> 00:25:45,790

490
00:25:45,790 --> 00:25:47,050
Che cosa è un comando che ho -

491
00:25:47,050 --> 00:25:49,620
>> JOSEPH: Penso che si possa utilizzare
meno o più, probabilmente.

492
00:25:49,620 --> 00:25:53,031
>> ROB: Ma come circa poco meno blah?

493
00:25:53,031 --> 00:25:53,930
Non lo so.

494
00:25:53,930 --> 00:25:57,870
Se si entra in questo scenario, come
c'è pset che è utile per.

495
00:25:57,870 --> 00:25:59,950
>> JOSEPH: È possibile reindirizzare in eco.

496
00:25:59,950 --> 00:26:02,920
Tubo il file in eco per vederlo.

497
00:26:02,920 --> 00:26:04,060
>> ROB: E 'pipe.

498
00:26:04,060 --> 00:26:04,860
>> JOSEPH: Mi dispiace.

499
00:26:04,860 --> 00:26:06,190
>> ROB: Va bene.

500
00:26:06,190 --> 00:26:12,720
Quindi questo è output in un file.

501
00:26:12,720 --> 00:26:18,700
Questa è ottenere il testo dal file
e consegnarla al programma.

502
00:26:18,700 --> 00:26:20,560
E vedrete anche questo ragazzo.

503
00:26:20,560 --> 00:26:24,410
Quindi questo è una specie di fare entrambe le cose contemporaneamente.

504
00:26:24,410 --> 00:26:28,310
E in realtà, io presento due nuovi
comandi solo per fare uso di esso.

505
00:26:28,310 --> 00:26:33,060
>> La storia è un comando a portata di mano che è solo
andando a stampare un elenco di

506
00:26:33,060 --> 00:26:34,940
qualsiasi cosa io abbia mai eseguito una riga di comando.

507
00:26:34,940 --> 00:26:38,290
Così vediamo qui tutto quello che ho
stato in esecuzione tutto questo tempo.

508
00:26:38,290 --> 00:26:39,540
Un sacco di LS di.

509
00:26:39,540 --> 00:26:41,570

510
00:26:41,570 --> 00:26:48,470
>> E un altro comando utile è grep che
il suo scopo è quello di verificare oltre

511
00:26:48,470 --> 00:26:52,060
testo alla ricerca di modelli, bene,
alla ricerca di quello che

512
00:26:52,060 --> 00:26:53,310
vogliono cercare.

513
00:26:53,310 --> 00:26:59,770
E così un utilizzo pratico: ecco, diciamo
vogliamo afferrare la storia.

514
00:26:59,770 --> 00:27:03,860
E voglio cercare i comandi
dove io - che cosa è un

515
00:27:03,860 --> 00:27:05,000
un utile cercare?

516
00:27:05,000 --> 00:27:06,898
>> JOSEPH: [incomprensibile]?

517
00:27:06,898 --> 00:27:09,710
>> ROB: O Diamo un'occhiata a tutti
tocca, per qualsiasi motivo.

518
00:27:09,710 --> 00:27:13,850
Quindi questo è quello che sarà simile.

519
00:27:13,850 --> 00:27:15,560
E non c'è bisogno di tutto
capire che.

520
00:27:15,560 --> 00:27:20,570
Ma l'idea è qui, la storia sta dando
la stessa uscita che ha fatto qui

521
00:27:20,570 --> 00:27:25,030
dove è stampare l'intera
storia di tutto ciò che ho mai eseguito.

522
00:27:25,030 --> 00:27:27,030
Stiamo passando poi che -

523
00:27:27,030 --> 00:27:30,230
così invece di stamparlo allo schermo,
vogliamo passare che al

524
00:27:30,230 --> 00:27:34,640
comando grep, che è alla ricerca di
tutte le istanze della parola tatto.

525
00:27:34,640 --> 00:27:40,280
>> E così utilizzando questa combinazione di
storia strumenti e grep, posso vedere, OK,

526
00:27:40,280 --> 00:27:44,820
ecco tutti i comandi che io abbia mai
correre, ed ecco uno piuttosto comune.

527
00:27:44,820 --> 00:27:45,510
Siamo in fondo.

528
00:27:45,510 --> 00:27:47,930
Ed è anche darmi il comando
Ho appena corse che ha avuto il

529
00:27:47,930 --> 00:27:51,240
Parola tocco in esso.

530
00:27:51,240 --> 00:27:58,500
Ma il tubo è una cosa molto utile
per combinare più programmi.

531
00:27:58,500 --> 00:28:04,670
E in realtà, è una scorciatoia per let
me la storia di output su file bla, e

532
00:28:04,670 --> 00:28:10,190
mi permetta di Grep utilizzando il file blah
come quello che voglio guardare oltre.

533
00:28:10,190 --> 00:28:13,460
Così il tubo è solo una scorciatoia
per questi due comandi.

534
00:28:13,460 --> 00:28:13,950
Sì.

535
00:28:13,950 --> 00:28:15,306
>> SPEAKER 4: [incomprensibile]?

536
00:28:15,306 --> 00:28:16,556
>> ROB: sì.

537
00:28:16,556 --> 00:28:20,142

538
00:28:20,142 --> 00:28:21,110
Che cosa è -

539
00:28:21,110 --> 00:28:21,858
Oh.

540
00:28:21,858 --> 00:28:24,820
Testiamo.

541
00:28:24,820 --> 00:28:29,170
Così gatto, cane, pesce.

542
00:28:29,170 --> 00:28:33,770
Quindi voglio grep.

543
00:28:33,770 --> 00:28:37,680
Dash, r, ancora una volta, sta per essere
ricorsivamente, quindi voglio scendere giù

544
00:28:37,680 --> 00:28:38,870
tutte le directory.

545
00:28:38,870 --> 00:28:43,210
Voglio grep ricorsivamente per tutti -
e fatemi temporaneamente ottenere

546
00:28:43,210 --> 00:28:44,460
questo fuori strada.

547
00:28:44,460 --> 00:28:48,650

548
00:28:48,650 --> 00:28:50,740
Mi Ignora.

549
00:28:50,740 --> 00:28:51,360
OK.

550
00:28:51,360 --> 00:28:56,740
>> Quindi voglio grep temporaneamente
tutte le istanze della parola pesce.

551
00:28:56,740 --> 00:29:00,510
Ed ecco quello che sto facendo è grep
ricorsivo per la parola pesce.

552
00:29:00,510 --> 00:29:05,410
E stella significa più di tutti questi
file in questa directory.

553
00:29:05,410 --> 00:29:08,930
E così mi ha dato una Autorizzazione negata,
perché non è consentito leggere che

554
00:29:08,930 --> 00:29:10,060
particolare file.

555
00:29:10,060 --> 00:29:14,040
Ma ha trovato il pesce nel file, test.

556
00:29:14,040 --> 00:29:18,450
>> Potrei anche dire, in particolare, ho solo
vuole guardare nel file blah, in

557
00:29:18,450 --> 00:29:19,580
qual caso non troverà nulla.

558
00:29:19,580 --> 00:29:20,990
Voglio solo guardare nel file, test.

559
00:29:20,990 --> 00:29:22,240
Si troverà di pesce.

560
00:29:22,240 --> 00:29:25,980

561
00:29:25,980 --> 00:29:29,260
Questo è un comando molto utile
sapere in generale.

562
00:29:29,260 --> 00:29:31,640
Ci sono alcune alternative a grep
che si suppone essere più

563
00:29:31,640 --> 00:29:36,780
PROGRAMMATORE cordiale, ma io tendo
a cadere ancora indietro grep.

564
00:29:36,780 --> 00:29:38,030
Domande?

565
00:29:38,030 --> 00:29:39,965

566
00:29:39,965 --> 00:29:40,919
OK.

567
00:29:40,919 --> 00:29:42,520
>> Ci sono altri comandi?

568
00:29:42,520 --> 00:29:45,270
Oh.

569
00:29:45,270 --> 00:29:48,370
Solo un one-off quello che ho sempre
trovare ad essere divertente è cal.

570
00:29:48,370 --> 00:29:55,610
Così notare quando mi trovo in questa bella
modalità a schermo intero, non ho cima come

571
00:29:55,610 --> 00:29:56,720
barra degli strumenti o nulla.

572
00:29:56,720 --> 00:29:59,530
So Cal mi dà solo un bel po '
calendario che è giusto

573
00:29:59,530 --> 00:30:02,380
ormai tagliato fuori, suppongo.

574
00:30:02,380 --> 00:30:04,770
Ma bel po 'di comando.

575
00:30:04,770 --> 00:30:06,540
>> JOSEPH: E '[incomprensibile].

576
00:30:06,540 --> 00:30:09,170
Altri comandi che si potrebbero avere
visto comprendono clang e fare.

577
00:30:09,170 --> 00:30:11,180
Andremo su di loro in
dettaglio più avanti.

578
00:30:11,180 --> 00:30:13,400
Ma se hai lavorato su
il PSET, si dovrebbe essere

579
00:30:13,400 --> 00:30:15,160
familiarità con quelli.

580
00:30:15,160 --> 00:30:16,640
>> ROB: Va bene.

581
00:30:16,640 --> 00:30:18,520
Domande on line cose di comando?

582
00:30:18,520 --> 00:30:22,450

583
00:30:22,450 --> 00:30:23,260
Bene.

584
00:30:23,260 --> 00:30:27,416
Quindi passiamo a qualche
Stuff C-correlati.

585
00:30:27,416 --> 00:30:28,666
Variabili matematica.

586
00:30:28,666 --> 00:30:39,078

587
00:30:39,078 --> 00:30:40,060
OK.

588
00:30:40,060 --> 00:30:45,230
Quindi, proprio come avevamo matematica in Scratch,
è anche possibile utilizzare la matematica in C.

589
00:30:45,230 --> 00:30:49,270
>> Prima di arrivare a questo tutto,
così variabili.

590
00:30:49,270 --> 00:30:53,920
Ricordate che ogni volta che si dichiara una
variabile come int x o float y, si

591
00:30:53,920 --> 00:30:56,710
devono dare digitare prima
il nome della variabile.

592
00:30:56,710 --> 00:31:03,020
Così tipi che abbiamo visto finora sono int,
float, double, lunga lunga, che mi

593
00:31:03,020 --> 00:31:06,150
non realtà non sappiamo se abbiamo
visto che finora.

594
00:31:06,150 --> 00:31:07,700
>> Ci sono alcune altre.

595
00:31:07,700 --> 00:31:09,990
Abbiamo vediamo char.

596
00:31:09,990 --> 00:31:13,920
C'è insomma, che è come se fosse il
opposto del lungo tempo in cui è

597
00:31:13,920 --> 00:31:16,650
più piccolo di un numero intero.

598
00:31:16,650 --> 00:31:18,580
Abbiamo anche visto stringa.

599
00:31:18,580 --> 00:31:23,070
Così che cosa c'è di speciale stringa?

600
00:31:23,070 --> 00:31:25,350
Perché dovrei dire che è
non proprio come int?

601
00:31:25,350 --> 00:31:27,030
>> SPEAKER 4: non esiste realmente.

602
00:31:27,030 --> 00:31:27,990
>> ROB: Già.

603
00:31:27,990 --> 00:31:31,820
Quindi l'unico motivo per cui abbiamo stringa
è perché quando si fa

604
00:31:31,820 --> 00:31:33,215
hash, includere cs50.h.

605
00:31:33,215 --> 00:31:36,530

606
00:31:36,530 --> 00:31:42,670
E vedremo esempi di questo più tardi -
oh, che non gestisce molto bene -

607
00:31:42,670 --> 00:31:46,160
dove cs50.h sta facendo qualcosa
lungo le linee di tipo

608
00:31:46,160 --> 00:31:49,230
def, char stella, stringa.

609
00:31:49,230 --> 00:31:53,280
>> E così che sta dicendo che noi non sappiamo nemmeno
sa che cosa una stella char è ancora.

610
00:31:53,280 --> 00:31:56,770
Ma questo sta dicendo che vogliamo stringa.

611
00:31:56,770 --> 00:32:00,250
Qualsiasi luogo che hai utilizzato stringa,
avrebbe potuto usare char stelle,

612
00:32:00,250 --> 00:32:04,670
che in realtà è un tipo che
esiste nel linguaggio C.

613
00:32:04,670 --> 00:32:06,680
Ma ci arriveremo.

614
00:32:06,680 --> 00:32:07,860
Oh, e va a destra indietro.

615
00:32:07,860 --> 00:32:10,170
Neat.

616
00:32:10,170 --> 00:32:15,370
>> Quindi, stessa cosa con bool
dove vero e falso.

617
00:32:15,370 --> 00:32:22,510
Questo non è davvero un tipo built-in in C.
Invece, è solo, questo ha

618
00:32:22,510 --> 00:32:23,740
il valore zero?

619
00:32:23,740 --> 00:32:26,200
Poi ci limiteremo a considerare
che sia falso.

620
00:32:26,200 --> 00:32:27,350
Questo ha il valore -

621
00:32:27,350 --> 00:32:30,530
bene, questo ha alcuna
valore che non è zero?

622
00:32:30,530 --> 00:32:32,200
Poi ci consideriamo vero.

623
00:32:32,200 --> 00:32:35,940
Così uno è vero, due è vero,
qualcosa di diverso da zero è vero.

624
00:32:35,940 --> 00:32:38,710

625
00:32:38,710 --> 00:32:42,790
Così quelli sono quelli.

626
00:32:42,790 --> 00:32:47,624
Domande sulle variabili che dichiarano e
tipi di variabili e tutto quello che?

627
00:32:47,624 --> 00:32:48,100
Già.

628
00:32:48,100 --> 00:32:52,384
>> SPEAKER 4: Per lungo tempo, nel libro,
si diceva che doveva essere long long int.

629
00:32:52,384 --> 00:32:54,288
Ma sarà solo lungo lungo lavoro?

630
00:32:54,288 --> 00:32:58,210

631
00:32:58,210 --> 00:33:01,470
>> ROB: Quindi questi modificatori di tipo.

632
00:33:01,470 --> 00:33:04,170
Così int x.

633
00:33:04,170 --> 00:33:07,710
Quindi possiamo anche dire unsigned int x.

634
00:33:07,710 --> 00:33:09,640
Possiamo dire short int x.

635
00:33:09,640 --> 00:33:12,570
Possiamo dire long long int x.

636
00:33:12,570 --> 00:33:17,250
Ma praticamente qualsiasi di quelle cose che
appena detto, unsigned int, short int,

637
00:33:17,250 --> 00:33:21,480
long long int, è possibile sbarazzarsi di
int e sarà solo supporre

638
00:33:21,480 --> 00:33:22,510
che volevi dire int.

639
00:33:22,510 --> 00:33:26,045
Quindi senza segno x, il che significa semplicemente -

640
00:33:26,045 --> 00:33:29,400
si sa come di solito con un int,
si può dire che x è uguale negativa 3?

641
00:33:29,400 --> 00:33:31,636
Con un unsigned int, non si può.

642
00:33:31,636 --> 00:33:34,480
>> JOSEPH: E ancora, per la fotocamera, l'
domanda era: qual è la differenza

643
00:33:34,480 --> 00:33:37,796
tra long long int
e proprio lungo tempo?

644
00:33:37,796 --> 00:33:38,410
>> ROB: Già.

645
00:33:38,410 --> 00:33:42,850
Quindi io quasi mai
scrivere long long int.

646
00:33:42,850 --> 00:33:44,100
Vorrei scrivere molto lungo.

647
00:33:44,100 --> 00:33:47,770

648
00:33:47,770 --> 00:33:50,636
>> JOSEPH: Tutte le domande?

649
00:33:50,636 --> 00:33:51,886
>> ROB: OK.

650
00:33:51,886 --> 00:33:56,180

651
00:33:56,180 --> 00:34:02,390
Così stupido piccolo promemoria di quello Funziona
dichiariamo una variabile e inizializzare

652
00:34:02,390 --> 00:34:04,450
la variabile e dichiarare un altro
variabile e inizializzare

653
00:34:04,450 --> 00:34:05,870
il tutto in un solo passo.

654
00:34:05,870 --> 00:34:09,370
Così la dichiarazione della variabile e
la variabile di inizializzazione non hanno

655
00:34:09,370 --> 00:34:11,120
a ma può essere sulla stessa linea.

656
00:34:11,120 --> 00:34:15,409

657
00:34:15,409 --> 00:34:20,060
>> Così abbiamo gli operatori matematiche standard
che siete abituati a -

658
00:34:20,060 --> 00:34:22,199
più, meno, dividere, orari.

659
00:34:22,199 --> 00:34:24,389
C'è anche modulo, che vedremo.

660
00:34:24,389 --> 00:34:29,060
Non vi è, almeno in
C, una potenza integrato

661
00:34:29,060 --> 00:34:31,765
elevamento a potenza operatore caret.

662
00:34:31,765 --> 00:34:33,770
Beh, c'è un operatore di accento circonflesso,
ma non è potere.

663
00:34:33,770 --> 00:34:34,239
>> JOSEPH: Ma non è l'elevamento a potenza,
Sì.

664
00:34:34,239 --> 00:34:36,210
>> ROB: Non utilizzare l'accento circonflesso
supporre che significa

665
00:34:36,210 --> 00:34:39,980
come il quadrato o qualsiasi altra cosa.

666
00:34:39,980 --> 00:34:42,289
Quindi alcune cose da tenere a
mente sulla divisione.

667
00:34:42,289 --> 00:34:46,282

668
00:34:46,282 --> 00:34:48,880
Starò.

669
00:34:48,880 --> 00:34:51,315
Così ha dichiarato la risposta di inizializzazione.

670
00:34:51,315 --> 00:34:54,670
Quindi stiamo dicendo risposta galleggiante
uguale a 1 diviso 10.

671
00:34:54,670 --> 00:34:57,500
Stampa risposta a due cifre decimali.

672
00:34:57,500 --> 00:35:02,180
>> E questo è il genere di cosa che mi
sarebbe l'uomo printf per capire che

673
00:35:02,180 --> 00:35:05,110
che diamine vuol%, puntino, 2f dire?

674
00:35:05,110 --> 00:35:07,930
E questo significa solo, bene,
ignorando la 0.2.

675
00:35:07,930 --> 00:35:10,420
E%, f è quello che usiamo
per la stampa a galleggiare.

676
00:35:10,420 --> 00:35:15,370
Il 0.2 sta dicendo, stampa
float con due decimali.

677
00:35:15,370 --> 00:35:19,600
Quindi questo programma ha un bug, e si potrebbe
hanno visto questo prima in qualche

678
00:35:19,600 --> 00:35:20,870
previo corso di CS.

679
00:35:20,870 --> 00:35:22,170
Ma che cosa è che bug?

680
00:35:22,170 --> 00:35:23,050
>> SPEAKER 5: Zero.

681
00:35:23,050 --> 00:35:24,130
>> ROB: Già.

682
00:35:24,130 --> 00:35:29,630
Così, quando diciamo, la risposta è uguale
1 diviso 10, vogliamo l'

683
00:35:29,630 --> 00:35:31,610
rispondere 0.1.

684
00:35:31,610 --> 00:35:37,450
Ma 1 diviso 10, 1 è un
intero, 10 è un numero intero.

685
00:35:37,450 --> 00:35:41,060
E così quando facciamo un intero diviso per
un numero intero, stiamo per tornare

686
00:35:41,060 --> 00:35:42,190
un numero intero.

687
00:35:42,190 --> 00:35:43,660
Così 1 diviso 10 è 0,1.

688
00:35:43,660 --> 00:35:46,760
>> Dal momento che deve darci un numero intero,
è solo andando a buttare via che

689
00:35:46,760 --> 00:35:49,410
decimale e dire che
la risposta è 0.

690
00:35:49,410 --> 00:35:55,314
E così quando stampiamo rispondere qui,
sta andando a stampare 0.00.

691
00:35:55,314 --> 00:35:58,430
>> JOSEPH: E proprio come una nota, in realtà
getta via ciò che è dopo l'

692
00:35:58,430 --> 00:35:59,390
punto decimale.

693
00:35:59,390 --> 00:36:03,180
Quindi, se invece avessi 6 diviso per 10,
si potrebbe pensare che darebbe

694
00:36:03,180 --> 00:36:05,200
0.6 e poi si sarebbe arrotondare a 1.

695
00:36:05,200 --> 00:36:10,520
Ma in realtà, cosa succede quando si digita
attività è che scende ciò che è

696
00:36:10,520 --> 00:36:11,470
dopo il punto decimale.

697
00:36:11,470 --> 00:36:13,020
Così 0.6 non diventa 0.

698
00:36:13,020 --> 00:36:13,370
>> ROB: Già.

699
00:36:13,370 --> 00:36:15,160
E diremo troncato per questo.

700
00:36:15,160 --> 00:36:21,760
Così ogni volta che lanci ad un int,
decimale viene troncato.

701
00:36:21,760 --> 00:36:23,980
Così la correzione per questo - non c'è
in realtà due.

702
00:36:23,980 --> 00:36:27,890
E ho intenzione di farlo secondo, perché
questa è una soluzione molto più semplice.

703
00:36:27,890 --> 00:36:32,670
>> Quindi una soluzione è usare carri allegorici
nella divisione.

704
00:36:32,670 --> 00:36:34,720
E davvero, devi solo
fare uno di loro un galleggiante.

705
00:36:34,720 --> 00:36:37,400
Ma è un po 'più chiaro solo
fare entrambi galleggianti.

706
00:36:37,400 --> 00:36:41,170
Così 1.0 diviso per 10,0 è
che divide due galleggianti.

707
00:36:41,170 --> 00:36:43,970
Quindi la risposta finirà per essere
un galleggiante, e così si farà

708
00:36:43,970 --> 00:36:48,050
stampare correttamente 0.10 qui.

709
00:36:48,050 --> 00:36:52,220
>> Qualcosa che non funziona così bene
a tale proposito è, beh, certo, è stato facile

710
00:36:52,220 --> 00:36:56,240
abbastanza per convertire 1 ad un
galleggiare rendendo 1.0.

711
00:36:56,240 --> 00:37:02,180
Ma cosa succede se invece abbiamo avuto due numeri interi
come int x è uguale a 1 e int y

712
00:37:02,180 --> 00:37:05,660
è uguale a 10, e poi volevamo
Per fare x diviso y?

713
00:37:05,660 --> 00:37:10,420
Quindi non è facile da solo
fare X.0 o qualcosa del genere.

714
00:37:10,420 --> 00:37:12,790
>> Così la correzione di tale sta lanciando.

715
00:37:12,790 --> 00:37:19,780
Così colata è un modo in C per convertire
da un tipo variabile a un'altra.

716
00:37:19,780 --> 00:37:22,320
Così qui, uno è un numero intero.

717
00:37:22,320 --> 00:37:27,050
E mettendo questo galleggiante davanti
si, stiamo gettando uno ad un galleggiante.

718
00:37:27,050 --> 00:37:30,350
E così questo convertirà
la 1 a 1,0.

719
00:37:30,350 --> 00:37:33,380
E questo verrà convertito
il 10 a 10.0.

720
00:37:33,380 --> 00:37:36,790
>> E poi le cose si comportano in modo simile al
versione precedente abbiamo appena mostrato

721
00:37:36,790 --> 00:37:42,190
dove, come previsto, otteniamo 0,10
e si metterà a stampare quello.

722
00:37:42,190 --> 00:37:44,120
E possiamo farlo con
variabili, troppo.

723
00:37:44,120 --> 00:37:47,376
Quindi possiamo dire, float x
diviso per float y.

724
00:37:47,376 --> 00:37:48,626
>> JOSEPH: Tutte le domande?

725
00:37:48,626 --> 00:37:54,182

726
00:37:54,182 --> 00:38:00,090
>> ROB: Così, proprio come in matematica normale,
abbiamo precedenza degli operatori.

727
00:38:00,090 --> 00:38:06,960
Quindi, in classe di matematica, è molto più probabile
chiamarlo ordine delle operazioni.

728
00:38:06,960 --> 00:38:09,890
Qui, il termine ufficiale è
precedenza degli operatori.

729
00:38:09,890 --> 00:38:15,230
Ma la precedenza degli operatori, o la maggior parte
operatori, è come ci si aspetterebbe.

730
00:38:15,230 --> 00:38:22,660
>> Quindi, proprio come in matematica, 2 volte 10 è
andando ad essere raggruppati più strettamente di

731
00:38:22,660 --> 00:38:25,410
questo 10 diviso 2 e poi 2.

732
00:38:25,410 --> 00:38:29,745
L'ordine delle operazioni, lo farà 2
tempi 10, 10 diviso 2, e poi

733
00:38:29,745 --> 00:38:32,720
lo farà 20 più 5 più 2.

734
00:38:32,720 --> 00:38:37,020
Quindi è come previsto, ed è possibile utilizzare
parentesi per raggruppare espressioni.

735
00:38:37,020 --> 00:38:41,063
Non è possibile utilizzare le parentesi quadre
alle espressioni di gruppo.

736
00:38:41,063 --> 00:38:41,544
Sì?

737
00:38:41,544 --> 00:38:43,468
>> SPEAKER 5: Potrebbe effettivamente
basta andare indietro di un secondo?

738
00:38:43,468 --> 00:38:47,316
Si può lanciare un int in una stringa?

739
00:38:47,316 --> 00:38:53,330
>> ROB: Quindi, in C, si può lanciare qualsiasi cosa
si vuole tutto quello che vuoi.

740
00:38:53,330 --> 00:38:55,600
Questo non significa che sia
una buona cosa da fare.

741
00:38:55,600 --> 00:38:59,760
Così, quando lanci un int a
una stringa, che significa -

742
00:38:59,760 --> 00:39:03,240
e ci arriveremo in questo
molto più a fondo -

743
00:39:03,240 --> 00:39:03,720
>> JOSEPH: Molto più tardi.

744
00:39:03,720 --> 00:39:06,840
>> ROB: io non voglio dire molto più tardi,
così ho provato a cambiare la mia frase.

745
00:39:06,840 --> 00:39:13,370
Arriveremo in molto più a fondo
più tardi dove davvero quando si ha un

746
00:39:13,370 --> 00:39:14,810
variabile stringa -

747
00:39:14,810 --> 00:39:17,160
quindi una stringa può essere arbitrariamente
lungo, giusto?

748
00:39:17,160 --> 00:39:21,850
E stiamo dicendo che un int è
quattro byte e lungo tempo di otto

749
00:39:21,850 --> 00:39:23,620
byte e un galleggiante è di quattro byte.

750
00:39:23,620 --> 00:39:29,520
Quindi una stringa, proprio come un int, ha solo
un certo numero di byte da esso.

751
00:39:29,520 --> 00:39:31,800
E che sarà di quattro byte.

752
00:39:31,800 --> 00:39:34,750
>> Ma una stringa può essere abbastanza
arbitrariamente lungo, giusto?

753
00:39:34,750 --> 00:39:40,190
Ciao Quindi mondo già, se è 10
personaggi o qualsiasi altra cosa, che è già

754
00:39:40,190 --> 00:39:42,670
andando ad essere sopra i 4 byte
Posso inserire in una stringa.

755
00:39:42,670 --> 00:39:51,140
E così come le stringhe funzionano veramente è che
essi sono dove in memoria che stringa

756
00:39:51,140 --> 00:39:52,380
viene mantenuta.

757
00:39:52,380 --> 00:39:57,290
>> E così qui, quando dico stringa x
uguale ciao mondo, all'interno di x è

758
00:39:57,290 --> 00:40:01,840
solo dicendo, oh, ciao mondo viene memorizzato
in questo luogo particolare in memoria.

759
00:40:01,840 --> 00:40:07,060
Quindi, se proviamo a lanciare un numero intero a un
stringa, quindi stiamo cercando di interpretare

760
00:40:07,060 --> 00:40:10,500
una parte casuale di memoria
come una stringa.

761
00:40:10,500 --> 00:40:14,465
E che rompe quasi sempre le cose.

762
00:40:14,465 --> 00:40:17,040
>> JOSEPH: Ma se questo confonde
tu, noi tratteremo esso

763
00:40:17,040 --> 00:40:17,550
più in profondità in seguito.

764
00:40:17,550 --> 00:40:17,850
>> ROB: Già.

765
00:40:17,850 --> 00:40:20,540
Questo è dove stai andando
per entrare in puntatori.

766
00:40:20,540 --> 00:40:25,485
E questo è un pezzo significativo
di due settimane di questo corso.

767
00:40:25,485 --> 00:40:28,275
>> SPEAKER 6: Funziona come gli oggetti
in altre lingue o non proprio?

768
00:40:28,275 --> 00:40:34,050
>> ROB: Quindi, in altre lingue, oggetti
sarebbe rappresentato mediante puntatori.

769
00:40:34,050 --> 00:40:37,070

770
00:40:37,070 --> 00:40:38,793
Non è la stessa cosa, però.

771
00:40:38,793 --> 00:40:42,110

772
00:40:42,110 --> 00:40:42,910
Qualche idea?

773
00:40:42,910 --> 00:40:43,760
>> JOSEPH: No.

774
00:40:43,760 --> 00:40:44,185
Senza pensieri.

775
00:40:44,185 --> 00:40:44,980
>> ROB: OK.

776
00:40:44,980 --> 00:40:46,994
>> JOSEPH: Avanti.

777
00:40:46,994 --> 00:40:48,255
>> ROB: Basta andare con quello.

778
00:40:48,255 --> 00:40:48,670
Bene.

779
00:40:48,670 --> 00:40:51,120
Così modulo.

780
00:40:51,120 --> 00:40:53,900
Proprio come abbiamo più, meno,
dividersi e moltiplicarsi.

781
00:40:53,900 --> 00:40:56,720
Così modulo è quello che si può
non hanno mai visto prima.

782
00:40:56,720 --> 00:40:59,540
E dice semplicemente, dare
me il resto.

783
00:40:59,540 --> 00:41:02,850
Quindi il 55% 10.

784
00:41:02,850 --> 00:41:06,840
Il resto di fare 55 diviso
da 10 sarebbe 5.

785
00:41:06,840 --> 00:41:09,630
Quindi 55% 10 è 5.

786
00:41:09,630 --> 00:41:12,260
E il 3% 5 sarebbe 3.

787
00:41:12,260 --> 00:41:14,180
8% 8 sarà 0.

788
00:41:14,180 --> 00:41:15,903
16% 15 sarà 1.

789
00:41:15,903 --> 00:41:20,670
>> JOSEPH: Una cosa da notare con questo,
troppo, è che potrebbe non funzionare come previsto

790
00:41:20,670 --> 00:41:22,700
se si utilizza un numero negativo.

791
00:41:22,700 --> 00:41:26,215
Così negativo 5% 4, alcune persone
potrebbe pensare che è -

792
00:41:26,215 --> 00:41:28,890

793
00:41:28,890 --> 00:41:33,808
cosa pensereste negativo
5% 4 sarebbe?

794
00:41:33,808 --> 00:41:34,792
>> SPEAKER 5: One.

795
00:41:34,792 --> 00:41:37,920
>> JOSEPH: Così alcune persone dicono una,
alcune persone dicono uno negativo.

796
00:41:37,920 --> 00:41:38,450
Ma ciò -

797
00:41:38,450 --> 00:41:40,820
>> ROB: Io non avrei nemmeno
disse uno di quelli.

798
00:41:40,820 --> 00:41:42,370
>> JOSEPH: Due, mi dispiace.

799
00:41:42,370 --> 00:41:43,240
Alcune persone dicono -

800
00:41:43,240 --> 00:41:43,450
>> ROB: Three.

801
00:41:43,450 --> 00:41:43,800
>> JOSEPH: Three?

802
00:41:43,800 --> 00:41:44,890
>> ROB: Negativo -

803
00:41:44,890 --> 00:41:45,950
quello che era il - negativo cinque -

804
00:41:45,950 --> 00:41:47,100
>> JOSEPH: Tre, tre, tre.

805
00:41:47,100 --> 00:41:48,450
Scusi.

806
00:41:48,450 --> 00:41:51,910
Perché con modulo, in genere, quando hai
visto altrove, di solito significa

807
00:41:51,910 --> 00:41:54,000
restituire un numero positivo, giusto?

808
00:41:54,000 --> 00:42:01,160
>> ROB: Così, quando diciamo in matematica, 10% di,
essi tendono a voler dare -

809
00:42:01,160 --> 00:42:05,980
se noi mod da 10, allora ci aspettiamo di
ottenere un numero compreso tra 0 e 9.

810
00:42:05,980 --> 00:42:09,860
In qui, che non è il caso che si
otterrà i numeri negativi restituiti.

811
00:42:09,860 --> 00:42:15,898
>> JOSEPH: così negativo 5%
4 sarebbe negativa 1.

812
00:42:15,898 --> 00:42:19,325
>> ROB: Ma è raro che sei mod-ing
numeri negativi per cominciare.

813
00:42:19,325 --> 00:42:25,490

814
00:42:25,490 --> 00:42:25,970
Saltare questo.

815
00:42:25,970 --> 00:42:27,314
>> JOSEPH: Già.

816
00:42:27,314 --> 00:42:29,420
>> ROB: Meh.

817
00:42:29,420 --> 00:42:29,990
OK.

818
00:42:29,990 --> 00:42:36,400
Quindi un'ultima cosa da sottolineare in merito
galleggianti è che è un comportamento pericoloso,

819
00:42:36,400 --> 00:42:39,850
ma galleggianti non sono un esatto
di rappresentanza.

820
00:42:39,850 --> 00:42:46,190
Quindi, tornando al byte di nuovo, ricordare
che un int è sempre quattro byte e un

821
00:42:46,190 --> 00:42:47,830
galleggiante è sempre quattro byte.

822
00:42:47,830 --> 00:42:51,340
Quindi l'esempio di Lucas è abbastanza buono.

823
00:42:51,340 --> 00:42:55,730
>> Quindi, pensare di 1 diviso per 3.

824
00:42:55,730 --> 00:42:57,800
Così 0,3333333.

825
00:42:57,800 --> 00:43:03,540
Se ho solo 32 bit, come si può
Immagazzino 0.33333 esattamente?

826
00:43:03,540 --> 00:43:07,250
E forse, per qualsiasi ragione, si dice,
tutto bene, beh, diciamo solo che

827
00:43:07,250 --> 00:43:13,210
che questo particolare 1011001, LET'S
solo dire che dovrebbe essere 0,333333.

828
00:43:13,210 --> 00:43:16,960
Beh, hai solo un numero finito di
i bit, quindi è impossibile

829
00:43:16,960 --> 00:43:22,550
rappresentare ogni singola virgola mobile
valore dato solo 32 bit.

830
00:43:22,550 --> 00:43:25,580
>> Beh, è ​​impossibile rappresentare qualsiasi
valore in virgola mobile dato infinito -

831
00:43:25,580 --> 00:43:28,480
bene, dato un qualsiasi numero finito di bit.

832
00:43:28,480 --> 00:43:38,265
Quindi il problema qui è, bene, quando abbiamo usato
per la stampa a due cifre decimali,

833
00:43:38,265 --> 00:43:42,000
abbiamo avuto modo corretto ottiene la risposta 0.10.

834
00:43:42,000 --> 00:43:47,510
Ma sotto il cofano, è davvero
essere immagazzinato il più vicino possibile

835
00:43:47,510 --> 00:43:51,790
0.10 come quei bit può rappresentare.

836
00:43:51,790 --> 00:43:53,200
È questa la diapositiva successiva?

837
00:43:53,200 --> 00:43:53,830
O non è vero?

838
00:43:53,830 --> 00:43:54,660
>> JOSEPH: Sì, è così.

839
00:43:54,660 --> 00:43:55,750
>> ROB: Blegh, blegh.

840
00:43:55,750 --> 00:43:57,760
>> JOSEPH: Sì, si può solo
tirare le note un po '.

841
00:43:57,760 --> 00:43:59,700
>> ROB: Sto solo andando per ingrandire
in sull'ultimo su questo.

842
00:43:59,700 --> 00:44:00,950
Oh mio Dio, questo è [incomprensibile].

843
00:44:00,950 --> 00:44:06,089

844
00:44:06,089 --> 00:44:08,300
Così quel numero.

845
00:44:08,300 --> 00:44:12,300
Questo è ciò che verrà stampata
se corriamo quel programma.

846
00:44:12,300 --> 00:44:20,340
E notate che non è proprio un grande affare
se stiamo preoccuparsi solo come

847
00:44:20,340 --> 00:44:21,920
2-3 decimali.

848
00:44:21,920 --> 00:44:26,700
Come abbiamo solo inizialmente stampato 0,10,
ed è per questo che abbiamo visto nulla di male.

849
00:44:26,700 --> 00:44:31,380
Ma una volta che cominciamo entrare nel
esatto, il numero esatto che è

850
00:44:31,380 --> 00:44:35,660
rappresentare, vediamo che non può
esattamente rappresentare 0.1.

851
00:44:35,660 --> 00:44:40,900
>> E parte del problema qui è come,
tutto bene, va bene, ma, beh,

852
00:44:40,900 --> 00:44:46,120
in primo luogo, che cosa se abbiamo cercato di fare,
la risposta è uguale uguale a 0,1?

853
00:44:46,120 --> 00:44:49,200
È che andando a restituire true o false?

854
00:44:49,200 --> 00:44:51,850
E quindi è difficile da dire.

855
00:44:51,850 --> 00:44:53,330
Penso che in realtà potrebbe restituire true.

856
00:44:53,330 --> 00:44:55,265
Sarà in primo luogo -

857
00:44:55,265 --> 00:44:56,180
Non lo so.

858
00:44:56,180 --> 00:45:00,090
La risposta è ancora una volta si inizia a trattare
con valori a virgola mobile, è abbastanza

859
00:45:00,090 --> 00:45:05,150
tanto che non dovrebbe usare l'uguaglianza
A causa di questa imprecisione.

860
00:45:05,150 --> 00:45:09,470
>> E per tutto quello che sai, è la centesima
decimale che l'

861
00:45:09,470 --> 00:45:13,670
virgola mobile non ha potuto
per gestire correttamente.

862
00:45:13,670 --> 00:45:18,180
E così la parità sarà solo riuscire anche
se il numero - se tu fossi stato

863
00:45:18,180 --> 00:45:24,450
utilizzando i numeri esatti, i numeri dovrebbero
stato esattamente lo stesso.

864
00:45:24,450 --> 00:45:27,790
È nel corso di 50 come
calcoli utilizzando questi galleggiante

865
00:45:27,790 --> 00:45:30,270
valori del punto, l'errore può costruire
su e su e su, e

866
00:45:30,270 --> 00:45:31,125
le cose solo ottenere sbagliato.

867
00:45:31,125 --> 00:45:33,870
>> JOSEPH: E ci sono stati davvero
esempi famosi di questo avvenimento.

868
00:45:33,870 --> 00:45:37,190
Come ingegneri della NASA hanno ottenuto questo
sbagliate, causando razzi per esplodere in

869
00:45:37,190 --> 00:45:38,665
l'aria dopo che sono stati lanciati.

870
00:45:38,665 --> 00:45:41,490
E un sacco di problemi come questo.

871
00:45:41,490 --> 00:45:41,956
Quindi, sì.

872
00:45:41,956 --> 00:45:45,218
>> SPEAKER 6: Quando dici 0.3 f,
Non mi tronca il resto?

873
00:45:45,218 --> 00:45:46,468
Oppure è arrotondare alto o in basso?

874
00:45:46,468 --> 00:45:48,800

875
00:45:48,800 --> 00:45:50,200
>> ROB: Sarà printf intorno ad esso?

876
00:45:50,200 --> 00:45:52,180
>> JOSEPH: Credo che tronca printf.

877
00:45:52,180 --> 00:45:52,640
>> ROB: OK.

878
00:45:52,640 --> 00:45:59,890
Quindi possiamo analogicamente andare in senso opposto
direzione di questo, dove, in questo caso,

879
00:45:59,890 --> 00:46:03,320
più vicino potrebbe rappresentare
0.1 è stato con questo numero.

880
00:46:03,320 --> 00:46:06,820
Il più vicino potrebbe essere in grado di
rappresentare 0.2 è in senso opposto

881
00:46:06,820 --> 00:46:11,420
direzione, 0,199999996356
o qualcosa del genere.

882
00:46:11,420 --> 00:46:17,480
Quindi, se siamo andati in quella direzione
cose, poi printf 0.3 f sarebbero tornati

883
00:46:17,480 --> 00:46:20,866
1.99 invece di 2.00.

884
00:46:20,866 --> 00:46:22,960
>> JOSEPH: E io non sono del tutto
sicuro su questo.

885
00:46:22,960 --> 00:46:25,430
Si potrebbe desiderare di scrivere un piccolo, piccolo
programma per verificare proprio questo.

886
00:46:25,430 --> 00:46:29,370
>> ROB: Però, quello che siamo certi è che
se si è tentato di lanciare quella di un

887
00:46:29,370 --> 00:46:33,660
int, e colata di un int sta per
indurlo a troncare il decimale, se

888
00:46:33,660 --> 00:46:38,140
si tenta di lanciare 1.9999999
ad un int, otterrete 1.

889
00:46:38,140 --> 00:46:41,440
E così si dovrebbe in genere utilizzare il
Funzione rotonda nella libreria matematica.

890
00:46:41,440 --> 00:46:44,190

891
00:46:44,190 --> 00:46:45,440
Domande?

892
00:46:45,440 --> 00:46:47,660

893
00:46:47,660 --> 00:46:48,982
OK.

894
00:46:48,982 --> 00:46:54,000
>> JOSEPH: Quindi passare alle condizioni
ed espressioni booleane.

895
00:46:54,000 --> 00:46:58,120
Quindi avete visto questi prima.

896
00:46:58,120 --> 00:47:07,420
E in realtà, mi permetta di assicurarsi il mio
computer nel formato proprio qui.

897
00:47:07,420 --> 00:47:08,670
Spazio.

898
00:47:08,670 --> 00:47:10,630

899
00:47:10,630 --> 00:47:13,870
Siamo spiacenti, stiamo andando ad avere a che fare un
po 'con cutoff ai bordi.

900
00:47:13,870 --> 00:47:15,830
>> Ma sì, voi ragazzi avete visto
prima in Scratch.

901
00:47:15,830 --> 00:47:19,930
Quindi questo qui è espressione
che è utilizzato in

902
00:47:19,930 --> 00:47:21,250
un'istruzione condizionale.

903
00:47:21,250 --> 00:47:23,930
Così rispondere maggiore di zero volontà
dirvi vero o falso.

904
00:47:23,930 --> 00:47:26,530
E questi sono davvero importanti, perché
ci permettono di introdurre

905
00:47:26,530 --> 00:47:28,670
logica nel nostro codice.

906
00:47:28,670 --> 00:47:32,820
>> Così, per esempio, questo è un programma
scritto in Scratch che chiede all'utente

907
00:47:32,820 --> 00:47:36,980
per un numero intero e dice loro se
il numero intero che ti hanno dato è stata una

908
00:47:36,980 --> 00:47:38,690
numero positivo o negativo.

909
00:47:38,690 --> 00:47:42,980
E la conversione qui per vedere è
prima di stampare la dichiarazione,

910
00:47:42,980 --> 00:47:43,870
dammi un numero intero.

911
00:47:43,870 --> 00:47:45,980
E poi si chiede loro per un numero intero.

912
00:47:45,980 --> 00:47:49,870
>> E quindi si utilizza la logica condizionale su
qui per verificare se quel numero

913
00:47:49,870 --> 00:47:52,030
era in realtà maggiore di zero oppure no.

914
00:47:52,030 --> 00:47:58,960
Quindi qui abbiamo una espressione booleana
interno di un condizionale If.

915
00:47:58,960 --> 00:48:00,660
C'è qualche domanda?

916
00:48:00,660 --> 00:48:03,030
Ci sono domande a riguardo?

917
00:48:03,030 --> 00:48:03,950
OK.

918
00:48:03,950 --> 00:48:06,140
>> Quindi c'è più di una semplice
superiore, naturalmente.

919
00:48:06,140 --> 00:48:10,385
È possibile costruire espressioni booleane
utilizzando la maggior parte dei tipi di cose che si

920
00:48:10,385 --> 00:48:11,150
potrebbe pensare in matematica.

921
00:48:11,150 --> 00:48:12,370
Quindi superiore.

922
00:48:12,370 --> 00:48:13,740
Questo dovrebbe essere un meno.

923
00:48:13,740 --> 00:48:14,990
Scusi.

924
00:48:14,990 --> 00:48:18,520

925
00:48:18,520 --> 00:48:19,760
E la spaziatura.

926
00:48:19,760 --> 00:48:22,971
>> ROB: Dio non voglia si lascia.

927
00:48:22,971 --> 00:48:23,620
>> JOSEPH: Va bene.

928
00:48:23,620 --> 00:48:25,950
Quindi maggiore di, minore di, maggiore
di, o uguale a, minore

929
00:48:25,950 --> 00:48:27,070
o uguale a.

930
00:48:27,070 --> 00:48:31,980
Usiamo doppio uguale per verificare
uguaglianza, perché unico è uguale mezzi

931
00:48:31,980 --> 00:48:32,810
assegnazione, giusto?

932
00:48:32,810 --> 00:48:33,140
Sì.

933
00:48:33,140 --> 00:48:37,130
E poi possiamo anche non uguale per
con punto esclamativo, è uguale.

934
00:48:37,130 --> 00:48:41,530
>> E questo simbolo punto esclamativo può
anche essere esteso in modo che se si vuole

935
00:48:41,530 --> 00:48:44,050
invertire qualsiasi tipo di booleana
espressione, si può fare.

936
00:48:44,050 --> 00:48:48,530
Quindi questo valuterà true
solo se la risposta è meno

937
00:48:48,530 --> 00:48:51,240
o uguale a zero.

938
00:48:51,240 --> 00:48:53,950
Hai domande su questo?

939
00:48:53,950 --> 00:48:55,180
OK.

940
00:48:55,180 --> 00:48:58,840
>> Così si può anche combinare queste
espressioni utilizzando logiche And e

941
00:48:58,840 --> 00:48:59,790
logico Or.

942
00:48:59,790 --> 00:49:03,530
Quindi questo è solo il simbolo E,
che dovrebbe essere Shift, 7.

943
00:49:03,530 --> 00:49:07,720
E questo è il simbolo pipe, che è
non una minuscola L. E 'quello

944
00:49:07,720 --> 00:49:09,440
che è di destra sopra il vostro tasto Invio.

945
00:49:09,440 --> 00:49:12,870
Quindi si utilizzano due di questi a simboleggiare
logico E la logica Or.

946
00:49:12,870 --> 00:49:18,180
>> Quindi questo sarà solo restituisce true se la risposta
è uno, due, tre, o quattro.

947
00:49:18,180 --> 00:49:23,030
E questo sarà solo restituisce true se la risposta
è oltre che su entrambi i lati.

948
00:49:23,030 --> 00:49:26,190
Quindi non è uno, due, tre, o quattro.

949
00:49:26,190 --> 00:49:28,385
E il modo in cui si usa
che in un'espressione -

950
00:49:28,385 --> 00:49:29,990
>> ROB: o zero o un cinque.

951
00:49:29,990 --> 00:49:32,200
>> JOSEPH: Zero o un cinque.

952
00:49:32,200 --> 00:49:32,380
Scusi.

953
00:49:32,380 --> 00:49:33,320
Sì, sì, sì.

954
00:49:33,320 --> 00:49:34,180
OK.

955
00:49:34,180 --> 00:49:38,980
E qui ora, allo stesso modo si
avrebbe usato questa espressione, una più piccola

956
00:49:38,980 --> 00:49:42,000
lato espressione di un caso condizionale
dichiarazione, si potrebbe anche utilizzare il

957
00:49:42,000 --> 00:49:47,800
Allo stesso modo, semplicemente inserendolo all'interno di
le parentesi dell'istruzione If.

958
00:49:47,800 --> 00:49:54,020
Quindi questo printf solo fuoco se la risposta
è uno, due, tre, o quattro.

959
00:49:54,020 --> 00:49:56,002
Tutte le domande di combinare
espressioni?

960
00:49:56,002 --> 00:50:00,450

961
00:50:00,450 --> 00:50:04,240
>> Quindi c'è un altro condizionale
costrutto che chiamiamo un If / Else.

962
00:50:04,240 --> 00:50:08,120
Quindi, fondamentalmente, ciò significa che ora, OK, se
qualcosa che volevo controllare non era

963
00:50:08,120 --> 00:50:11,600
vero, poi andare al Else e
eseguire l'altra azione.

964
00:50:11,600 --> 00:50:15,570
Quindi, in questo caso particolare, ho chiesto
l'utente per un numero intero.

965
00:50:15,570 --> 00:50:17,790
È il numero intero maggiore di zero?

966
00:50:17,790 --> 00:50:18,310
Sì?

967
00:50:18,310 --> 00:50:20,100
Bene, allora hanno scelto
un numero positivo.

968
00:50:20,100 --> 00:50:22,320
Se no, allora deve avere
stato negativo o uno zero.

969
00:50:22,320 --> 00:50:27,530
Quindi hai scelto un numero negativo
o uno zero in questo caso.

970
00:50:27,530 --> 00:50:29,235
Sì.

971
00:50:29,235 --> 00:50:30,485
O uno zero.

972
00:50:30,485 --> 00:50:36,320

973
00:50:36,320 --> 00:50:39,300
>> E poi abbiamo anche If / Else,
Se e Else.

974
00:50:39,300 --> 00:50:45,640
Quindi questo ci permette di eseguire una sequenza di
cose solo se i primi sicuro.

975
00:50:45,640 --> 00:50:49,540
Quindi, in questo caso, ora stiamo facendo
l'ultimo si sceglie zero.

976
00:50:49,540 --> 00:50:53,080
Quindi, se non scelto un positivo, né
un numero negativo, allora essi devono

977
00:50:53,080 --> 00:50:53,640
aver raccolto zero.

978
00:50:53,640 --> 00:50:56,720
Così va proprio in fondo alla
catena come questo.

979
00:50:56,720 --> 00:50:59,960
>> Così un esempio di come un
Se è diverso da -

980
00:50:59,960 --> 00:51:02,590
Se un / Else è diverso da
solo una sequenza di Ifs.

981
00:51:02,590 --> 00:51:07,680
E questa è una domanda comune che
la gente chiede è, bene, se ottenete come un

982
00:51:07,680 --> 00:51:11,265
95 in CS50, che cosa sarà questo
programma che si dice?

983
00:51:11,265 --> 00:51:12,600
>> SPEAKER 5: Hai un A.

984
00:51:12,600 --> 00:51:13,490
>> JOSEPH: sì.

985
00:51:13,490 --> 00:51:14,960
Hai ogni singolo
uno di quelli di destra.

986
00:51:14,960 --> 00:51:17,130
Hai una A, hai una B, è
ottenuto un C e D, giusto?

987
00:51:17,130 --> 00:51:19,770
Quindi, tutti questi ottenere valutato
in ordine.

988
00:51:19,770 --> 00:51:23,570
Così, mentre un 95 è maggiore di 90, è
anche maggiore di 80, è anche

989
00:51:23,570 --> 00:51:25,790
superiore a 70, ed è
anche maggiore di 60.

990
00:51:25,790 --> 00:51:27,620
Quindi hai tutti questi gradi.

991
00:51:27,620 --> 00:51:31,630
E presumo si farebbe
vogliono solo la A.

992
00:51:31,630 --> 00:51:34,060
>> Il modo per rimediare è quello di sostituire
quelli con Else / Se s '.

993
00:51:34,060 --> 00:51:37,540
Quindi, in questo scenario, si vede che 95 è
superiore a 90, e poi lo fa

994
00:51:37,540 --> 00:51:38,885
Non valutare il resto
delle dichiarazioni.

995
00:51:38,885 --> 00:51:41,900

996
00:51:41,900 --> 00:51:43,150
Hai domande su questo?

997
00:51:43,150 --> 00:51:48,580

998
00:51:48,580 --> 00:51:52,470
>> Quindi c'è un altro tipo condizionale
struttura che abbiamo qui che noi

999
00:51:52,470 --> 00:51:53,390
chiamare un'istruzione switch.

1000
00:51:53,390 --> 00:51:57,390
Quindi questo consente di controllare praticamente
quale sia il valore di un numero mettete

1001
00:51:57,390 --> 00:51:59,000
nella istruzione switch è.

1002
00:51:59,000 --> 00:52:03,200
Quindi, in questo scenario, stiamo passando
su n, e noi stiamo dicendo, oh, se n è

1003
00:52:03,200 --> 00:52:04,710
uno, quindi stampare questa affermazione.

1004
00:52:04,710 --> 00:52:07,910
E poi pausa, il che significa che l'uscita
fuori l'istruzione switch.

1005
00:52:07,910 --> 00:52:12,670
>> Se non fosse stato uno, allora, bene, basta
infine controllare tutti quei casi.

1006
00:52:12,670 --> 00:52:16,280
E così controlla se è uno o due o
tre, e la stampa di conseguenza.

1007
00:52:16,280 --> 00:52:19,780
E che cosa questa parola chiave predefinita qui
mezzi è se non entrano alcuna

1008
00:52:19,780 --> 00:52:21,690
di quelli, poi dire non valido.

1009
00:52:21,690 --> 00:52:25,910
Quindi diciamo che chiedo n e
l'utente mi dà quattro.

1010
00:52:25,910 --> 00:52:29,470
Beh, corrisponde a nessuno di questi casi,
per far stampare ciò che c'è nella

1011
00:52:29,470 --> 00:52:30,540
sezione di default.

1012
00:52:30,540 --> 00:52:31,180
Sì, in discussione?

1013
00:52:31,180 --> 00:52:32,614
>> SPEAKER 5: Si può utilizzare booleano
espressioni anziché

1014
00:52:32,614 --> 00:52:33,570
uno, due, o tre?

1015
00:52:33,570 --> 00:52:36,940
>> JOSEPH: Quindi la domanda è: si può usare
Espressioni booleane invece di uno,

1016
00:52:36,940 --> 00:52:37,940
due e tre?

1017
00:52:37,940 --> 00:52:40,520
E in C, ti credo
non può farlo.

1018
00:52:40,520 --> 00:52:44,320
Ma in altre lingue, che si potrebbe
incontrare al fine

1019
00:52:44,320 --> 00:52:46,460
semestre come JavaScript, è possibile.

1020
00:52:46,460 --> 00:52:50,050
Beh, si dovrebbe calcolare primo
tale valore e quindi utilizzare nel

1021
00:52:50,050 --> 00:52:50,650
passare dichiarazione.

1022
00:52:50,650 --> 00:52:50,930
Sì?

1023
00:52:50,930 --> 00:52:54,760
>> ROB: Quindi una parte del beneficio dello switch
dichiarazioni si pensa di se avete fatto questo

1024
00:52:54,760 --> 00:52:58,680
come If / Else, così come se n è uguale
equivale a uno o qualsiasi altra cosa.

1025
00:52:58,680 --> 00:53:00,300
Else / Se n è uguale uguale a due, a prescindere.

1026
00:53:00,300 --> 00:53:01,960
Else / Se n è uguale uguale a tre.

1027
00:53:01,960 --> 00:53:05,930
Così il modo in cui il programma si porrebbe è altrove
sarebbe sequenza andare giù quella lista

1028
00:53:05,930 --> 00:53:07,500
e controllare, è n uno?

1029
00:53:07,500 --> 00:53:08,040
Nope.

1030
00:53:08,040 --> 00:53:09,070
E 'n due?

1031
00:53:09,070 --> 00:53:09,490
Nope.

1032
00:53:09,490 --> 00:53:10,940
È n tre?

1033
00:53:10,940 --> 00:53:11,710
Già.

1034
00:53:11,710 --> 00:53:12,610
Fate questo.

1035
00:53:12,610 --> 00:53:15,270
>> Mentre con istruzioni switch, è
effettivamente in grado di compilarlo per essere

1036
00:53:15,270 --> 00:53:16,360
veramente veloce.

1037
00:53:16,360 --> 00:53:19,550
E non appena si dice interruttore,
dice, va bene, n è due, io sono

1038
00:53:19,550 --> 00:53:23,060
immediatamente intenzione di saltare a dove
Dovrei avviare l'esecuzione.

1039
00:53:23,060 --> 00:53:26,080
Io non vado a controllare in primo luogo,
n è uno, è n due?

1040
00:53:26,080 --> 00:53:28,860
Si può subito iniziare a fare
che cosa dovrebbe fare.

1041
00:53:28,860 --> 00:53:33,830
>> E a causa di ciò, non può
prendere condizioni booleane.

1042
00:53:33,830 --> 00:53:36,480
Altrimenti avrebbe dovuto fare l'
sequenziale, come, va bene, è n

1043
00:53:36,480 --> 00:53:37,820
maggiore di zero?

1044
00:53:37,820 --> 00:53:41,140
Else è n maggiore di 10 o qualsiasi altra cosa.

1045
00:53:41,140 --> 00:53:44,780
>> JOSEPH: In questo caso, se si è utilizzato
If / Else, se del, quindi l'interruttore sarebbe

1046
00:53:44,780 --> 00:53:47,792
eseguire circa tre volte
più veloce rispetto al caso / altro, se.

1047
00:53:47,792 --> 00:53:53,060

1048
00:53:53,060 --> 00:53:56,040
Possiamo organizzare l'interruttore in tale
un modo che non ci spezziamo

1049
00:53:56,040 --> 00:53:57,520
dopo ciascuno dei casi.

1050
00:53:57,520 --> 00:54:00,960
Quindi, in questo caso, sto partizionamento del
numeri che abbiamo scelto in uno e

1051
00:54:00,960 --> 00:54:04,250
due non essendo un numero elevato e
tre è un numero alto.

1052
00:54:04,250 --> 00:54:08,290
>> Quindi, in questo caso, se n è uno o due,
colpirà il caso e allora sarà

1053
00:54:08,290 --> 00:54:10,640
cadere attraverso, perché
non c'è nessuna rottura.

1054
00:54:10,640 --> 00:54:11,610
E finirà qui.

1055
00:54:11,610 --> 00:54:15,360
Quindi, se prendiamo uno, farà il printf
e poi rompere in modo che nessuno dei

1056
00:54:15,360 --> 00:54:17,610
questa viene eseguita.

1057
00:54:17,610 --> 00:54:21,870
E naturalmente, se entrano in tre
o qualcosa d'altro, allora salterà

1058
00:54:21,870 --> 00:54:25,320
quelli che non ci vanno, e
eseguirà invece l'

1059
00:54:25,320 --> 00:54:27,490
corrispondente linea.

1060
00:54:27,490 --> 00:54:29,390
Ci sono domande a riguardo?

1061
00:54:29,390 --> 00:54:29,780
Sì?

1062
00:54:29,780 --> 00:54:32,642
>> SPEAKER 4: Desideri ottenere un errore se si
ha avuto una pausa dopo caso uno ma

1063
00:54:32,642 --> 00:54:34,550
non ha avuto qualcosa che lo facesse?

1064
00:54:34,550 --> 00:54:37,820
>> JOSEPH: Quindi la domanda è: sarebbe si ottiene
un errore se si dispone di una pausa dopo

1065
00:54:37,820 --> 00:54:39,730
maiuscole uno, ma non c'è niente da fare?

1066
00:54:39,730 --> 00:54:41,520
E la risposta è no.

1067
00:54:41,520 --> 00:54:43,172
Non sarà effettivamente un errore.

1068
00:54:43,172 --> 00:54:44,590
Sì, mm hmm.

1069
00:54:44,590 --> 00:54:54,540
>> Così come una sorta di piccolo cambiamento qui,
Ho intenzione di mettere un printf qui.

1070
00:54:54,540 --> 00:54:55,790
Whoops.

1071
00:54:55,790 --> 00:55:00,994

1072
00:55:00,994 --> 00:55:04,880
Quindi, che cosa sarebbe questa la stampa se
Ho messo uno come input?

1073
00:55:04,880 --> 00:55:07,530

1074
00:55:07,530 --> 00:55:07,770
Già.

1075
00:55:07,770 --> 00:55:10,360
Si direbbe che non ci voleva
un numero alto due volte, giusto?

1076
00:55:10,360 --> 00:55:13,500
Perché avrebbe colpito quel primo caso,
non sarebbe rompere, e sarebbe caduta

1077
00:55:13,500 --> 00:55:15,730
attraverso al secondo caso.

1078
00:55:15,730 --> 00:55:16,950
Hai domande su questo?

1079
00:55:16,950 --> 00:55:18,280
>> ROB: Hai avuto un'altra domanda?

1080
00:55:18,280 --> 00:55:20,840
>> JOSEPH: OK, raffreddare.

1081
00:55:20,840 --> 00:55:22,400
Bene.

1082
00:55:22,400 --> 00:55:25,780
Quindi c'è qualcosa che chiamiamo
operatore ternario che è fondamentalmente un

1083
00:55:25,780 --> 00:55:29,010
sintassi alternativa a fare
Se poi Else.

1084
00:55:29,010 --> 00:55:30,470
E ti permette di fare tutto in una sola riga.

1085
00:55:30,470 --> 00:55:34,110
Quindi, in questo particolare programma,
Sto chiedendo all'utente di n.

1086
00:55:34,110 --> 00:55:37,190
E se n è maggiore di 100, dico
loro hanno scelto un numero alto.

1087
00:55:37,190 --> 00:55:39,560
Altrimenti dico loro che
scelto un numero basso.

1088
00:55:39,560 --> 00:55:43,030
>> Così possiamo usare questa sintassi molto lungo,
stringa, S, e quindi verificare se n è

1089
00:55:43,030 --> 00:55:45,260
maggiore di 100 e assegnare
di conseguenza.

1090
00:55:45,260 --> 00:55:49,450
Ma possiamo rendere questo molto più conciso
utilizzando questa sintassi operatore ternario

1091
00:55:49,450 --> 00:55:52,090
che coinvolge una domanda
segno e due punti.

1092
00:55:52,090 --> 00:55:55,070
Quindi, il punto interrogativo è essenzialmente
fare una domanda, giusto?

1093
00:55:55,070 --> 00:55:56,625
>> ROB: Forse zoom su quella.

1094
00:55:56,625 --> 00:55:57,372
>> JOSEPH: sì.

1095
00:55:57,372 --> 00:56:00,210
Buon punto.

1096
00:56:00,210 --> 00:56:02,550
Quindi questo è l'operatore ternario.

1097
00:56:02,550 --> 00:56:06,100
Mi chiedo prima la domanda,
n è maggiore di 100?

1098
00:56:06,100 --> 00:56:09,770
Se lo è, allora eseguo la prima
parte prima dei due punti.

1099
00:56:09,770 --> 00:56:13,360
Se non lo è, allora eseguo l'
seconda parte dopo i due punti.

1100
00:56:13,360 --> 00:56:16,640
Quindi, se n è maggiore di 100,
poi raccoglie e mette alto

1101
00:56:16,640 --> 00:56:18,360
che nella stringa s.

1102
00:56:18,360 --> 00:56:22,170
Se n è inferiore a 100, raccoglie basso
e poi la mette nella stringa s.

1103
00:56:22,170 --> 00:56:30,186
In modo che si condensare questo grande pezzo
giù in solo che una sola riga.

1104
00:56:30,186 --> 00:56:32,010
>> SPEAKER 5: Che è popolare?

1105
00:56:32,010 --> 00:56:36,070
>> JOSEPH: Sì, è abbastanza popolare per
cose dove in sostanza si desidera

1106
00:56:36,070 --> 00:56:38,700
do un incarico basa su
una sorta di condizione.

1107
00:56:38,700 --> 00:56:43,110
E in questo caso, abbiamo cercato
ad assegnare un valore alla stringa s.

1108
00:56:43,110 --> 00:56:44,840
Non è così -

1109
00:56:44,840 --> 00:56:47,670
Credo che non mi preferisco
negli altri casi.

1110
00:56:47,670 --> 00:56:49,390
Ma è particolarmente utile
per questo incarico.

1111
00:56:49,390 --> 00:56:54,490
>> ROB: Questo è un modello abbastanza comune
dove avete qualche variabile

1112
00:56:54,490 --> 00:56:58,200
stai per dire, se qualcosa, impostare
questa variabile per un valore, altrimenti, impostare

1113
00:56:58,200 --> 00:56:59,810
questa variabile per un altro valore.

1114
00:56:59,810 --> 00:57:03,360
E questo è lo scenario
dove utilizzare un ternario.

1115
00:57:03,360 --> 00:57:05,220
>> JOSEPH: E stai risparmiando
un sacco di linee, giusto?

1116
00:57:05,220 --> 00:57:08,090
E rende solo il codice discutibilmente
un po 'più leggibile.

1117
00:57:08,090 --> 00:57:08,635
Sì, in discussione?

1118
00:57:08,635 --> 00:57:12,384
>> SPEAKER 6: Per un ternario, potresti andare,
stringa s eguali s, punto interrogativo?

1119
00:57:12,384 --> 00:57:15,280
E allora si potrebbe avere, ad esempio,
cinque diverse opzioni.

1120
00:57:15,280 --> 00:57:18,310
E a seconda di ciò che il numero di n
è stato, vuoi scegliere uno di quelli?

1121
00:57:18,310 --> 00:57:22,210
>> JOSEPH: Quindi la domanda è: esiste un
sorta di sintassi dove si può fare stringa

1122
00:57:22,210 --> 00:57:25,910
s è uguale a n, e quindi avere più di due
opzioni dopo che il punto interrogativo?

1123
00:57:25,910 --> 00:57:29,740
E una risposta semplice è no, non c'è
davvero un buon modo per farlo se non

1124
00:57:29,740 --> 00:57:33,850
Vuoi nido ternario multipla
operatori all'interno di ogni altro.

1125
00:57:33,850 --> 00:57:38,050
>> Si potrebbe fare come n maggiore di 100,
punto interrogativo, e poi un altro

1126
00:57:38,050 --> 00:57:41,850
operatore ternario, n maggiore di 50,
punto interrogativo, e nidificano in questo modo.

1127
00:57:41,850 --> 00:57:45,240
Ma in questo scenario, il codice è
ottenendo genere di illeggibile e disordinato,

1128
00:57:45,240 --> 00:57:47,920
e potrebbe essere meglio andare solo per
un'istruzione If / Else a quel punto.

1129
00:57:47,920 --> 00:57:54,530
>> ROB: E anche, come nota a margine, PHP
implementa in modo errato il ternario

1130
00:57:54,530 --> 00:57:58,053
operatore tale che ternari nidificati
non anche lavorare come dovrebbero.

1131
00:57:58,053 --> 00:57:58,840
>> JOSEPH: Già.

1132
00:57:58,840 --> 00:58:01,170
Così diventa un po 'di confusione,
soprattutto quando si va

1133
00:58:01,170 --> 00:58:02,145
a lingue diverse.

1134
00:58:02,145 --> 00:58:04,810
>> ROB: E 'abbastanza confuso che
le lingue sono sbagliato su di esso.

1135
00:58:04,810 --> 00:58:08,030

1136
00:58:08,030 --> 00:58:11,510
>> JOSEPH: Quindi, in realtà, giusto per chiarire,
sa a tutti ciò che

1137
00:58:11,510 --> 00:58:13,900
% S fa qui?

1138
00:58:13,900 --> 00:58:15,650
Hai domande su questo?

1139
00:58:15,650 --> 00:58:19,760
Credo che solo per la fotocamera, l'% s
fondamentalmente ci permette di mettere un segnaposto

1140
00:58:19,760 --> 00:58:20,790
per una stringa.

1141
00:58:20,790 --> 00:58:23,920
E poi, alla fine, si precisa che la
variabile vogliamo mettere in questo

1142
00:58:23,920 --> 00:58:25,500
supporto posto è s.

1143
00:58:25,500 --> 00:58:27,730
Quindi, che prende fondamentalmente s
e mette in qui.

1144
00:58:27,730 --> 00:58:32,130
E poi stamperà, hai scelto
un alto o scelto un numero basso.

1145
00:58:32,130 --> 00:58:33,770
OK.

1146
00:58:33,770 --> 00:58:36,970
>> Quindi loop consentono di eseguire le cose
con movimenti circolari, giusto?

1147
00:58:36,970 --> 00:58:40,300
Si potrebbe avere incontrato questo
Scratch in forma di loop per sempre

1148
00:58:40,300 --> 00:58:45,650
o Ripeti Fino a quando o Ripeti una particolare
numero di volte.

1149
00:58:45,650 --> 00:58:47,540
Allora, perché questo è un bene per noi?

1150
00:58:47,540 --> 00:58:51,500
Beh, in C, diciamo che abbiamo questa
canzone implementato in Scratch che

1151
00:58:51,500 --> 00:58:53,450
canta, questa è la canzone
che non finisce mai.

1152
00:58:53,450 --> 00:58:55,710
Si va solo avanti e avanti e
per sempre e per sempre.

1153
00:58:55,710 --> 00:58:59,395
Beh, non si può davvero fare un programma
che ha un numero infinito di printf

1154
00:58:59,395 --> 00:59:00,850
dichiarazioni in esso, giusto?

1155
00:59:00,850 --> 00:59:04,900
>> Quindi, in questo particolare scenario, in un modo
che si potrebbe fare questo lavoro e

1156
00:59:04,900 --> 00:59:09,330
per farlo stampare sempre è
invece utilizzare un ciclo While.

1157
00:59:09,330 --> 00:59:13,640
Quindi un ciclo While esegue ciò che è
nel corpo delle due bretelle che

1158
00:59:13,640 --> 00:59:17,250
appartiene ad esso sulla base di ciò
la condizione è.

1159
00:59:17,250 --> 00:59:21,170
Quindi in questo esempio particolare prima, se
vogliamo stampare questa per sempre, ciò che

1160
00:59:21,170 --> 00:59:23,590
potremmo fare?

1161
00:59:23,590 --> 00:59:25,190
Beh, certo, giusto?

1162
00:59:25,190 --> 00:59:32,290
>> Quindi questo tipo di combina l'idea
di qualche espressione booleana

1163
00:59:32,290 --> 00:59:33,610
con un ciclo.

1164
00:59:33,610 --> 00:59:35,780
E abbiamo imparato a conoscere booleano
espressioni precedenti.

1165
00:59:35,780 --> 00:59:39,650
Così ogni volta che la condizione all'interno di
Mentre che rimane vero, questo ciclo

1166
00:59:39,650 --> 00:59:41,480
verrà eseguito su e su e su.

1167
00:59:41,480 --> 00:59:44,640
E in questo caso, se abbiamo appena forniamo essa
con il vero, questo provoca un infinito

1168
00:59:44,640 --> 00:59:49,310
ciclo che stampa la canzone su e su
e come noi desideravamo prima, senza

1169
00:59:49,310 --> 00:59:52,410
avere un programma che ha un infinito
numero di istruzioni printf, che è

1170
00:59:52,410 --> 00:59:55,220
non possibile.

1171
00:59:55,220 --> 00:59:57,810
>> Quindi più convincente, però,
è possibile utilizzare questo con un

1172
00:59:57,810 --> 00:59:59,710
variabile ed una condizione.

1173
00:59:59,710 --> 01:00:04,420
Quindi diciamo che vogliamo ripetere l'
frase, totalmente Loopy, 10 volte.

1174
01:00:04,420 --> 01:00:08,380
Che cosa si può fare con un ciclo While è
è possibile innanzitutto inizializzare un contatore

1175
01:00:08,380 --> 01:00:10,860
variabile all'esterno del
Mentre ciclo a 10.

1176
01:00:10,860 --> 01:00:14,360
E poi in fondo, ogni volta che si va
attraverso il ciclo While, si stampa

1177
01:00:14,360 --> 01:00:19,090
l'istruzione e quindi si riduce il
variabile contatore fino alla fine,

1178
01:00:19,090 --> 01:00:23,020
a un certo punto, una volta che sottraiamo ho abbastanza
volte, 1 da I abbastanza volte -

1179
01:00:23,020 --> 01:00:27,290
e giusto per chiarire, io meno meno
significa che è uguale a I meno 1.

1180
01:00:27,290 --> 01:00:31,280
>> Che fondamentalmente mi porterà verso il
punto dove una volta mi ha colpito zero, questo

1181
01:00:31,280 --> 01:00:35,260
condizione non è più vera e
quindi esce dal ciclo.

1182
01:00:35,260 --> 01:00:37,045
Così totalmente Loopy stampa solo 10 volte.

1183
01:00:37,045 --> 01:00:39,550

1184
01:00:39,550 --> 01:00:41,080
Hai domande su un ciclo While?

1185
01:00:41,080 --> 01:00:44,580

1186
01:00:44,580 --> 01:00:46,790
OK.

1187
01:00:46,790 --> 01:00:50,550
>> Quindi c'è un modo in cui possiamo fare quello che abbiamo appena
ha fatto in modo più conciso

1188
01:00:50,550 --> 01:00:51,715
ciò che noi chiamiamo un ciclo For.

1189
01:00:51,715 --> 01:00:55,750
Quindi un ciclo For costituito da un
inizializzazione, condizione, e un

1190
01:00:55,750 --> 01:00:58,950
aggiornamento, proprio come avevamo prima
in questo ciclo While.

1191
01:00:58,950 --> 01:00:59,890
Quindi diamo un'occhiata.

1192
01:00:59,890 --> 01:01:02,900
In questo ciclo While, abbiamo avuto un
inizializzazione, poi abbiamo avuto una

1193
01:01:02,900 --> 01:01:04,260
condizione che abbiamo controllato.

1194
01:01:04,260 --> 01:01:06,450
E poi abbiamo avuto un aggiornamento
un passo in alto.

1195
01:01:06,450 --> 01:01:10,060
>> Con un ciclo For, questo richiede fondamentalmente
queste tre cose e lo condensa

1196
01:01:10,060 --> 01:01:11,370
giù in una riga.

1197
01:01:11,370 --> 01:01:15,130
Quindi la prima cosa che si fa nel
Per loop è l'inizializzazione.

1198
01:01:15,130 --> 01:01:19,090
E poi si fa un punto e virgola, e poi
fate la condizione, che è io

1199
01:01:19,090 --> 01:01:22,200
maggiore di zero va là,
e poi la fase di aggiornamento.

1200
01:01:22,200 --> 01:01:26,470
Così questa viene effettuata a
fine del corpo del ciclo.

1201
01:01:26,470 --> 01:01:28,790
Quindi, questi due programmi sono
sostanzialmente equivalente.

1202
01:01:28,790 --> 01:01:31,960

1203
01:01:31,960 --> 01:01:33,870
>> Tutte le domande?

1204
01:01:33,870 --> 01:01:37,000
Così che cosa è una differenza
tra questi due?

1205
01:01:37,000 --> 01:01:38,000
Chiunque può farlo notare?

1206
01:01:38,000 --> 01:01:40,480
Potrebbe essere un po 'sottile.

1207
01:01:40,480 --> 01:01:41,930
E 'solo una differenza molto piccola.

1208
01:01:41,930 --> 01:01:42,330
Sì?

1209
01:01:42,330 --> 01:01:49,008
>> SPEAKER 5: non sarebbe in grado di utilizzare
la variabile I all'esterno del ciclo For

1210
01:01:49,008 --> 01:01:49,962
[Incomprensibile]?

1211
01:01:49,962 --> 01:01:50,900
>> JOSEPH: Esattamente.

1212
01:01:50,900 --> 01:01:53,550
Quindi questo è qualcosa che arriveremo a
più tardi chiamato portata variabile.

1213
01:01:53,550 --> 01:01:56,610
Ma in sostanza, questo int vite I
al di fuori di questo ciclo While.

1214
01:01:56,610 --> 01:01:59,800
Quindi, una volta che questo ciclo While è fatto
esecuzione, sarò in grado di utilizzare successivamente ho

1215
01:01:59,800 --> 01:02:00,880
sul nel programma.

1216
01:02:00,880 --> 01:02:05,430
>> Considerando che con questo ciclo for, questo int I
è ambito interno di questo ciclo For.

1217
01:02:05,430 --> 01:02:10,240
E poiché è all'interno di questa porzione
del ciclo For, che inizia

1218
01:02:10,240 --> 01:02:13,200
le parentesi e finisce con
la parentesi graffa laggiù.

1219
01:02:13,200 --> 01:02:16,120
Tutto ciò che è dichiarata all'interno di
qui non può essere utilizzato al di fuori.

1220
01:02:16,120 --> 01:02:20,420
Quindi, se io cerco di usare io fuori, sarà
dimmi, simbolo sommerso.

1221
01:02:20,420 --> 01:02:22,420
E in sostanza, non vorrei
essere in grado di usarlo.

1222
01:02:22,420 --> 01:02:28,460
>> ROB: E così, 10 anni fa, in
letteralmente tutti i casi, le parentesi graffe sono

1223
01:02:28,460 --> 01:02:31,140
quello che hai usato per determinare
l'ambito di una variabile.

1224
01:02:31,140 --> 01:02:37,240
Così in là, INT uguale a 10
è dichiarata all'interno di questa

1225
01:02:37,240 --> 01:02:38,520
set di parentesi graffe.

1226
01:02:38,520 --> 01:02:42,530
E così poi fino a quando si tenta di utilizzare I
prima di questa parentesi graffa, va bene.

1227
01:02:42,530 --> 01:02:47,090

1228
01:02:47,090 --> 01:02:51,460
Si potrebbe vedere quando si digita fare, si
vedi cruscotto, plancia, std, pari, C99.

1229
01:02:51,460 --> 01:02:57,100
>> Così che è una versione successiva di C che
GCC ha implementato che dà anche

1230
01:02:57,100 --> 01:02:58,740
questa scorciatoia.

1231
01:02:58,740 --> 01:03:03,505
Quindi questo consente di non essere consentito in C. E
si può capire perché, perché questa int

1232
01:03:03,505 --> 01:03:07,600
Mi è al di fuori di questa parentesi graffa ma
è ancora considerato nella

1233
01:03:07,600 --> 01:03:09,750
portata di queste parentesi graffe.

1234
01:03:09,750 --> 01:03:14,120
Ma questa è una cosa molto comoda,
e quindi è una buona estensione.

1235
01:03:14,120 --> 01:03:15,370
>> JOSEPH: Tutte le domande?

1236
01:03:15,370 --> 01:03:17,550

1237
01:03:17,550 --> 01:03:19,260
OK.

1238
01:03:19,260 --> 01:03:22,820
Allora, cosa c'è di più utile è che a volte
si vuole una sorta di dinamismo

1239
01:03:22,820 --> 01:03:23,410
il ciclo, giusto?

1240
01:03:23,410 --> 01:03:26,350
Tu non vuoi solo necessariamente stampare
totalmente Loopy tutto il tempo,

1241
01:03:26,350 --> 01:03:28,650
voglia di contare da
10 o qualcosa del genere.

1242
01:03:28,650 --> 01:03:32,010
E così è possibile utilizzare la variabile contatore
all'interno di tale ciclo pure.

1243
01:03:32,010 --> 01:03:35,530
E in questo caso, questo programma solo
conta alla rovescia da 10 fino in fondo.

1244
01:03:35,530 --> 01:03:39,260
E che cosa non stampa?

1245
01:03:39,260 --> 01:03:42,790
Essa non stampa nulla,
destra, perché quando -

1246
01:03:42,790 --> 01:03:45,460
Sì, anche non stampa 11.

1247
01:03:45,460 --> 01:03:49,200
>> Quindi non stampa nulla, perché quando
Mi è zero, ricordo, valuta

1248
01:03:49,200 --> 01:03:52,170
la condizione prima di metterlo in
per eseguire il corpo del ciclo.

1249
01:03:52,170 --> 01:03:56,820
E quando mi è zero, questo è falso, così
non stampare il conto alla rovescia

1250
01:03:56,820 --> 01:04:00,200
zero, esso stampa appena fuori conteggio
giù 10 tutta la strada fino a 1.

1251
01:04:00,200 --> 01:04:03,420
Se abbiamo effettivamente volevamo stampare zero,
allora avremmo messo un segno di uguale

1252
01:04:03,420 --> 01:04:04,750
dopo questo segno di maggiore.

1253
01:04:04,750 --> 01:04:09,400

1254
01:04:09,400 --> 01:04:10,130
OK.

1255
01:04:10,130 --> 01:04:16,410
>> Quindi un modo per farlo convalida dell'input, che
è quando si chiede all'utente di fare

1256
01:04:16,410 --> 01:04:18,620
qualcosa, si vuole fare in modo che
seguire le vostre istruzioni, è quello di utilizzare

1257
01:04:18,620 --> 01:04:19,400
il ciclo While, giusto?

1258
01:04:19,400 --> 01:04:22,990
Quindi, in questo caso particolare, sto chiedendo
per un numero positivo e quindi sono

1259
01:04:22,990 --> 01:04:23,810
in attesa di input.

1260
01:04:23,810 --> 01:04:28,210
>> E poi ho controllato Mentre l'ingresso è
minore di zero, tenerli a chiedere.

1261
01:04:28,210 --> 01:04:32,100
Quindi, fintanto che mi danno un numero
che non è positivo, continuare a chiedere,

1262
01:04:32,100 --> 01:04:33,600
continuare a chiedere, continuare a chiedere.

1263
01:04:33,600 --> 01:04:35,860
Ma che è una sorta di strano su questo?

1264
01:04:35,860 --> 01:04:38,570
O che cosa non sembra ottimale su
questa struttura proprio qui?

1265
01:04:38,570 --> 01:04:44,282

1266
01:04:44,282 --> 01:04:44,758
Chiunque?

1267
01:04:44,758 --> 01:04:45,234
Sì?

1268
01:04:45,234 --> 01:04:47,614
>> SPEAKER 6: Si sta ripetendo
l'istruzione due volte.

1269
01:04:47,614 --> 01:04:48,100
>> JOSEPH: Giusto.

1270
01:04:48,100 --> 01:04:50,090
Quindi abbiamo due istruzioni printf
qui, giusto?

1271
01:04:50,090 --> 01:04:53,440
Quindi c'è un modo abbiamo potuto ottenere questo basta
fino a uno che avrebbe fatto la nostra

1272
01:04:53,440 --> 01:04:57,170
codice più facile da leggere e un
po 'più pulito.

1273
01:04:57,170 --> 01:05:00,180
E allora non avremmo dovuto
hanno Ottieni due volte pure.

1274
01:05:00,180 --> 01:05:03,740
E un modo è possibile fare questo è
utilizzando un ciclo Do-While.

1275
01:05:03,740 --> 01:05:07,670
>> E un ciclo Do-While è fondamentalmente un
differente forma di un ciclo While dove

1276
01:05:07,670 --> 01:05:11,460
tutto ciò che è all'interno delle parentesi graffe
viene eseguito almeno una volta.

1277
01:05:11,460 --> 01:05:14,840
Quindi qui, dichiaro, int
ingresso, esterno prima.

1278
01:05:14,840 --> 01:05:18,100
E poi ho appena detto, fare questo
istruzione mentre l'ingresso

1279
01:05:18,100 --> 01:05:19,140
è minore di zero.

1280
01:05:19,140 --> 01:05:20,530
Così colpisce il Do primo.

1281
01:05:20,530 --> 01:05:24,190
Sarà sempre eseguire questo almeno
una volta, in modo che sempre chiedere all'utente

1282
01:05:24,190 --> 01:05:25,960
per ingresso almeno una volta.

1283
01:05:25,960 --> 01:05:29,390
E poi si valuta che l'ingresso,
e si va avanti in un cerchio.

1284
01:05:29,390 --> 01:05:30,135
Sì, in discussione?

1285
01:05:30,135 --> 01:05:32,602
>> SPEAKER 6: C'è un modo per farlo
[Incomprensibile] tipi, come se dici,

1286
01:05:32,602 --> 01:05:34,268
GetString, e qualcuno [incomprensibile]

1287
01:05:34,268 --> 01:05:35,220
c'è un modo per [incomprensibile]

1288
01:05:35,220 --> 01:05:40,060
>> JOSEPH: Quindi la domanda è: esiste un
modo per farlo convalida dell'input se l'utente

1289
01:05:40,060 --> 01:05:41,850
non mette nella giusta
tipo di variabile?

1290
01:05:41,850 --> 01:05:44,460
Quindi, se chiediamo un int e
ci danno invece una stringa.

1291
01:05:44,460 --> 01:05:49,110
E nelle funzioni che implementiamo
per voi, GetInt, GetString in tutti

1292
01:05:49,110 --> 01:05:52,680
quelle funzioni, che in realtà già
fare questo tipo di input tipo di base

1293
01:05:52,680 --> 01:05:54,120
validazione sotto il cofano.

1294
01:05:54,120 --> 01:05:57,390
Quindi, se si sta utilizzando le funzioni che abbiamo
ti ha dato, in realtà non è necessario.

1295
01:05:57,390 --> 01:06:01,380
>> Ma se si vuole guardare più in che modo
si può effettivamente fare questo, si può guardare

1296
01:06:01,380 --> 01:06:03,360
sotto il cofano il file I/O--

1297
01:06:03,360 --> 01:06:07,990
non depositare, le funzioni di I / O standard
come una lettura da standard input e

1298
01:06:07,990 --> 01:06:08,580
standard output.

1299
01:06:08,580 --> 01:06:10,630
E si può ottenere un senso migliore
di come si potrebbe fare.

1300
01:06:10,630 --> 01:06:13,670
>> ROB: Un problema, però, è specificamente
con l'esempio che

1301
01:06:13,670 --> 01:06:17,070
Detto questo, ci si aspetta una stringa
ed entro un int.

1302
01:06:17,070 --> 01:06:20,110
Come vorresti dire la differenza
tra intenzionalmente vogliono il

1303
01:06:20,110 --> 01:06:23,130
stringa 123 contro voler int 123?

1304
01:06:23,130 --> 01:06:29,230
Così stringa, è praticamente non c'è
convalida, è solo quello che

1305
01:06:29,230 --> 01:06:31,600
immesso si interpreta
come una stringa.

1306
01:06:31,600 --> 01:06:35,790
>> Int è più facile, perché non importa l'
ingresso si prende da parte dell'utente, si sono

1307
01:06:35,790 --> 01:06:37,470
tenendo sempre una stringa.

1308
01:06:37,470 --> 01:06:40,650
E così quella corda si può quindi
controllare, sono tutti questi

1309
01:06:40,650 --> 01:06:44,218
le cifre in realtà numeriche?

1310
01:06:44,218 --> 01:06:45,170
>> JOSEPH: OK.

1311
01:06:45,170 --> 01:06:46,420
Hai domande su un ciclo Do-While?

1312
01:06:46,420 --> 01:06:49,170
>> ROB: Oh, e questo è anche -

1313
01:06:49,170 --> 01:06:55,130
tornare a portata, un po 'comune
errore sta cercando di utilizzare alcuni locali

1314
01:06:55,130 --> 01:06:59,540
variabile da questa Do-While
ciclo all'interno di questa condizione.

1315
01:06:59,540 --> 01:07:02,850
E in realtà, se solo siamo sbarazzati di
questo e disse, int ingresso è uguale

1316
01:07:02,850 --> 01:07:06,990
GetInt, poi il compilatore urlare a
noi, perché ingresso non esiste

1317
01:07:06,990 --> 01:07:08,900
al di fuori del campo di applicazione
queste parentesi graffe.

1318
01:07:08,900 --> 01:07:10,792
>> JOSEPH: Ed è per questo che
bisogno di questa formazione qui.

1319
01:07:10,792 --> 01:07:13,620

1320
01:07:13,620 --> 01:07:14,630
OK.

1321
01:07:14,630 --> 01:07:17,530
Così si può anche uscire da un
ciclo presto se si vuole.

1322
01:07:17,530 --> 01:07:21,240
Quindi questo è un modo diverso di
attuazione di quello che abbiamo appena implementato.

1323
01:07:21,240 --> 01:07:24,340
E invece di utilizzare la condizione
all'interno delle parentesi, stiamo usando un

1324
01:07:24,340 --> 01:07:26,920
Se dichiarazione all'interno del corpo
del ciclo Do-While.

1325
01:07:26,920 --> 01:07:30,000
>> E in fondo, quando l'ingresso è finalmente
maggiore di zero, ci sarà

1326
01:07:30,000 --> 01:07:31,000
uscire dal loop.

1327
01:07:31,000 --> 01:07:33,420
E così andremo tutti
fino a qui.

1328
01:07:33,420 --> 01:07:37,920
E si può vedere che questo sarebbe
probabilmente preferibile in questo

1329
01:07:37,920 --> 01:07:39,870
scenario, perché è un po '
po 'più pulito e un po'

1330
01:07:39,870 --> 01:07:41,380
po 'più facile da leggere.

1331
01:07:41,380 --> 01:07:45,210
Considerando che questo è una sorta di
disporre di linee aggiuntive in esso.

1332
01:07:45,210 --> 01:07:47,890
E 'solo un po' più brutta,
Credo che, in un certo senso.

1333
01:07:47,890 --> 01:07:48,530
Sì, in discussione?

1334
01:07:48,530 --> 01:07:52,178
>> SPEAKER 4: si romperà ottenere solo
fuori di una serie di parentesi graffe?

1335
01:07:52,178 --> 01:07:53,080
>> JOSEPH: Giusto.

1336
01:07:53,080 --> 01:07:58,100
Quindi la domanda è si romperà solo
si ottiene da un loop?

1337
01:07:58,100 --> 01:07:59,280
E la risposta è sì.

1338
01:07:59,280 --> 01:08:04,290
Quindi, se avete cicli for nidificati, per
esempio, se ho Per int io uguale a 0

1339
01:08:04,290 --> 01:08:09,040
fino alle 10 e poi per int J è uguale a 0
fino alle 10, se rompo fuori interiore

1340
01:08:09,040 --> 01:08:12,310
loop, io ancora andare
all'anello esterno.

1341
01:08:12,310 --> 01:08:15,760
Così terrò eseguire l'
operazioni all'esterno.

1342
01:08:15,760 --> 01:08:17,640
Hai domande su questo?

1343
01:08:17,640 --> 01:08:18,000
Sì?

1344
01:08:18,000 --> 01:08:21,760
>> SPEAKER 5: Ma rompere solo le funzioni
di parentesi graffe, non per altro

1345
01:08:21,760 --> 01:08:22,230
dichiarazioni?

1346
01:08:22,230 --> 01:08:22,700
[Incomprensibile]

1347
01:08:22,700 --> 01:08:27,620
>> JOSEPH: Quindi la domanda è si romperà
funzione solo per i cicli in contrapposizione a

1348
01:08:27,620 --> 01:08:29,014
altre dichiarazioni come se?

1349
01:08:29,014 --> 01:08:32,950
E sì, questo è il caso, perché
si sta rottura di un ciclo, a destra,

1350
01:08:32,950 --> 01:08:33,630
in un senso.

1351
01:08:33,630 --> 01:08:37,215
>> ROB: Nella stragrande maggioranza dei casi, è
questo è il tipo di Se qualcosa,

1352
01:08:37,215 --> 01:08:37,660
poi pausa.

1353
01:08:37,660 --> 01:08:41,580
Quindi non c'è bisogno di rompere applicare a
il caso che sta avvolgendo intorno ad esso.

1354
01:08:41,580 --> 01:08:45,250
E inoltre, questo non è molto di un ciclo,
ma ricordate che gli interruttori sono anche

1355
01:08:45,250 --> 01:08:46,340
scoppiata di da interruzioni.

1356
01:08:46,340 --> 01:08:48,390
Abbiamo visto pause utilizzati
con interruttori prima.

1357
01:08:48,390 --> 01:08:52,189
>> JOSEPH: E potete anche usarli
nei cicli while e for loop.

1358
01:08:52,189 --> 01:08:54,560
Tutte le domande?

1359
01:08:54,560 --> 01:08:55,830
OK.

1360
01:08:55,830 --> 01:08:57,779
Così la prossima up è funzioni.

1361
01:08:57,779 --> 01:09:01,500
Così si potrebbe aver usato uno di questi BYOB
blocchi nel progetto Scratch.

1362
01:09:01,500 --> 01:09:04,569
E questo permette fondamentalmente
di definire un set di

1363
01:09:04,569 --> 01:09:05,680
le istruzioni da seguire.

1364
01:09:05,680 --> 01:09:09,569
>> E quello che voglio dire con questo è pensiamoci
torna alla matematica, diritto, algebra.

1365
01:09:09,569 --> 01:09:13,370
Hai ciò che noi chiamiamo una funzione di x,
qualche variabile, e diciamo che questo

1366
01:09:13,370 --> 01:09:16,080
funzione f di x è uguale x più 5.

1367
01:09:16,080 --> 01:09:20,410
Così si può pensare di f di x come questo nero
casella che prende 15 in poi

1368
01:09:20,410 --> 01:09:22,590
produce 20.

1369
01:09:22,590 --> 01:09:26,630
>> Quindi, più in generale, una funzione è
qualcosa che prende alcuni ingressi e

1370
01:09:26,630 --> 01:09:27,880
poi produce alcune uscite.

1371
01:09:27,880 --> 01:09:31,920

1372
01:09:31,920 --> 01:09:32,960
E perché sono funzioni bene?

1373
01:09:32,960 --> 01:09:35,189
Sono buoni per una serie di motivi.

1374
01:09:35,189 --> 01:09:40,470
Così fa qualcuno vuole prendere una pugnalata
a quale organizzazione significa?

1375
01:09:40,470 --> 01:09:42,630
In termini di Perché funzioni sono utili?

1376
01:09:42,630 --> 01:09:43,090
Sì?

1377
01:09:43,090 --> 01:09:44,735
>> SPEAKER 4: Rende il vostro
codice più leggibile.

1378
01:09:44,735 --> 01:09:45,399
>> JOSEPH: Giusto.

1379
01:09:45,399 --> 01:09:47,670
Così una delle cose è fa
il codice più leggibile, giusto?

1380
01:09:47,670 --> 01:09:53,710
Invece di avere come int x è uguale x
volte x volte x, posso avere cubo di x,

1381
01:09:53,710 --> 01:09:57,190
che è più leggibile e più
comprensibile ad un lettore.

1382
01:09:57,190 --> 01:10:01,150
>> L'organizzazione è anche in termini di
suddividendo il codice in gestibile

1383
01:10:01,150 --> 01:10:05,610
porzioni, in modo che invece di cercare di
implementare tutto questo in una sezione lungo

1384
01:10:05,610 --> 01:10:09,070
in principale, è possibile una sorta di dividerlo
in come, OK, scriviamo una funzione

1385
01:10:09,070 --> 01:10:11,910
al cubo qualcosa, scriviamo un
funzione di piazza qualcosa.

1386
01:10:11,910 --> 01:10:15,950
In questo modo è possibile dividerlo in minuscolo,
piccole parti che si possono affrontare

1387
01:10:15,950 --> 01:10:18,944
invece di cercare di affrontare
un grosso problema tutto in una volta.

1388
01:10:18,944 --> 01:10:21,806
>> ROB: O anche piccole, piccole parti che
voi e il partner può affrontare.

1389
01:10:21,806 --> 01:10:22,283
>> JOSEPH: Già.

1390
01:10:22,283 --> 01:10:23,855
>> ROB: Così, invece di due
stai cercando di impiantare una

1391
01:10:23,855 --> 01:10:27,170
funzionare allo stesso tempo.

1392
01:10:27,170 --> 01:10:28,800
>> JOSEPH: Semplificazione.

1393
01:10:28,800 --> 01:10:30,050
Chiunque vuole prendere una congettura?

1394
01:10:30,050 --> 01:10:33,080

1395
01:10:33,080 --> 01:10:33,410
Sì?

1396
01:10:33,410 --> 01:10:34,675
>> SPEAKER 5: Più ripetizione.

1397
01:10:34,675 --> 01:10:35,260
>> JOSEPH: Giusto.

1398
01:10:35,260 --> 01:10:39,210
Quindi, una cosa che si può fare con
semplificazione è che è una sorta di on

1399
01:10:39,210 --> 01:10:42,520
le stesse linee riutilizzabilità è che
Una volta ho scritto una funzione cubo, posso

1400
01:10:42,520 --> 01:10:45,410
basta usare che più e più e più volte
di nuovo nel mio programma invece di digitare

1401
01:10:45,410 --> 01:10:49,610
x volte x volte x sopra e
più e più volte.

1402
01:10:49,610 --> 01:10:52,980
E semplificazione anche qui solo
significa che rende il codice sorta di

1403
01:10:52,980 --> 01:10:55,900
facile eseguire il debug di una volta si divide
questo in su in funzioni.

1404
01:10:55,900 --> 01:10:58,250
Perché allora si può localizzare dove
i vostri problemi di sorta sono.

1405
01:10:58,250 --> 01:11:00,910

1406
01:11:00,910 --> 01:11:02,160
Tutte le domande?

1407
01:11:02,160 --> 01:11:04,200

1408
01:11:04,200 --> 01:11:06,540
>> Quindi, un'altra idea è l'astrazione, giusto?

1409
01:11:06,540 --> 01:11:07,390
Questa scatola nera.

1410
01:11:07,390 --> 01:11:11,360
Come si fa a sapere cosa fa GetInt
per ricevere input da parte dell'utente?

1411
01:11:11,360 --> 01:11:12,510
Non abbiamo davvero detto che, giusto?

1412
01:11:12,510 --> 01:11:15,670
Tutto quello che vi abbiamo detto è GetInt fa
esattamente quello che dice lo fa.

1413
01:11:15,670 --> 01:11:18,440
Quindi, anche se noi non diciamo come
funziona, si sa ancora.

1414
01:11:18,440 --> 01:11:21,670
>> Quindi, in questo caso particolare, è
una funzione quadrupla che fa

1415
01:11:21,670 --> 01:11:24,520
cose diverse per un ingresso
per produrre un output.

1416
01:11:24,520 --> 01:11:28,050
E si può quadruplicare il numero
moltiplicandolo per quattro.

1417
01:11:28,050 --> 01:11:30,790
Oppure si può ciò che noi chiamiamo
bit spostarlo per due.

1418
01:11:30,790 --> 01:11:32,960
E vedremo questa
un po 'più tardi.

1419
01:11:32,960 --> 01:11:36,570
E non c'è bisogno di sapere come questo
funzione effettivamente funziona fintanto che

1420
01:11:36,570 --> 01:11:37,640
funziona come indicato.

1421
01:11:37,640 --> 01:11:40,740
>> Così, sotto il cofano, potrei essere
come, ritorno orari di ingresso

1422
01:11:40,740 --> 01:11:41,690
otto diviso per due.

1423
01:11:41,690 --> 01:11:42,510
E non si sa, giusto?

1424
01:11:42,510 --> 01:11:44,970
Tutto quello che devi sapere è
si fa quello che dice.

1425
01:11:44,970 --> 01:11:48,070
Ecco, questo è la cosa più utile
su astrazione.

1426
01:11:48,070 --> 01:11:52,910
>> E un'altra cosa è una sorta di questa idea
di localizzare il codice per un

1427
01:11:52,910 --> 01:11:54,280
particolare sezione.

1428
01:11:54,280 --> 01:11:57,450
Quindi, se avete un problema, non è necessario
deve andare tutto il codice cercando

1429
01:11:57,450 --> 01:11:58,730
per risolvere dove fosse il problema.

1430
01:11:58,730 --> 01:12:00,990
Quindi, in questo caso, ho implementato
cubo sbagliato.

1431
01:12:00,990 --> 01:12:02,820
Ho pensato cubo è stato moltiplicando
per tre.

1432
01:12:02,820 --> 01:12:05,760
>> Quindi, in questo caso, si tratta di un programma
che appena ha moltiplicando per tre

1433
01:12:05,760 --> 01:12:06,750
ovunque.

1434
01:12:06,750 --> 01:12:10,910
E c'è un altro programma che ha
cubo di factoring fuori in una funzione.

1435
01:12:10,910 --> 01:12:14,040
E così ora se voglio risolvere il mio errore
qui, devo sistemare ogni singola riga

1436
01:12:14,040 --> 01:12:15,620
di codice in questo programma.

1437
01:12:15,620 --> 01:12:19,190
Considerando che, d'altra parte, se uso l'
funzione, ho solo bisogno di cambiare

1438
01:12:19,190 --> 01:12:20,650
cosa c'era di sbagliato in un unico luogo.

1439
01:12:20,650 --> 01:12:25,330

1440
01:12:25,330 --> 01:12:28,730
>> Quindi, in informatica, si
chiamare ingressi e uscite.

1441
01:12:28,730 --> 01:12:31,640
Gli ingressi sono denominati parametri o
argomenti, e le uscite sono chiamati

1442
01:12:31,640 --> 01:12:32,950
restituire valori.

1443
01:12:32,950 --> 01:12:39,000
E vedremo come questo ci aiuta a risolvere
di definire una funzione in un secondo.

1444
01:12:39,000 --> 01:12:41,430
Quindi questa è una definizione di funzione
per la cubatura.

1445
01:12:41,430 --> 01:12:45,110
Così richiede un input, e poi
restituisce che numero di volte

1446
01:12:45,110 --> 01:12:47,020
si tre volte.

1447
01:12:47,020 --> 01:12:48,020
Quindi cerchiamo di scomposizione.

1448
01:12:48,020 --> 01:12:53,090
>> Quindi abbiamo una intestazione di funzione, che
consiste essenzialmente di tre cose.

1449
01:12:53,090 --> 01:12:56,050
Così abbiamo i parametri, che
sono, come ho detto prima, l'

1450
01:12:56,050 --> 01:12:57,680
Ingressi in questa funzione.

1451
01:12:57,680 --> 01:12:59,300
E poi diamo la funzione di un nome.

1452
01:12:59,300 --> 01:13:00,740
In questo caso, si chiama cubo.

1453
01:13:00,740 --> 01:13:03,860
E poi specifichiamo che tipo
del valore di ritorno è.

1454
01:13:03,860 --> 01:13:06,760
>> Quindi, in questo caso, la mia funzione cubo
prende in un numero intero ed è anche

1455
01:13:06,760 --> 01:13:07,890
restituisce un numero intero.

1456
01:13:07,890 --> 01:13:11,510
Quindi, se mi passate in due, due è un numero intero,
ritorna otto a me, che

1457
01:13:11,510 --> 01:13:13,250
è un numero intero.

1458
01:13:13,250 --> 01:13:15,420
Quindi tornare parametri nome del tipo.

1459
01:13:15,420 --> 01:13:16,670
Domande su questo?

1460
01:13:16,670 --> 01:13:19,440

1461
01:13:19,440 --> 01:13:24,230
>> E poi il valore di ritorno è in realtà
specificato alla fine dicendo ritorno

1462
01:13:24,230 --> 01:13:27,540
e poi tornare a prescindere
contiene il valore di ritorno.

1463
01:13:27,540 --> 01:13:30,940
Quindi, in questo caso, se mettiamo tutto
insieme, una funzione prende in

1464
01:13:30,940 --> 01:13:35,100
parametri, si chiama qualcosa, e
restituisce qualcosa che è del tipo

1465
01:13:35,100 --> 01:13:36,350
che noi diciamo che sarebbe stato.

1466
01:13:36,350 --> 01:13:39,830

1467
01:13:39,830 --> 01:13:41,080
Tutte le domande?

1468
01:13:41,080 --> 01:13:43,710

1469
01:13:43,710 --> 01:13:45,080
>> Così come usiamo una funzione?

1470
01:13:45,080 --> 01:13:49,230
Ebbene, scriviamo una funzione e poi
usiamo nel nostro programma, giusto?

1471
01:13:49,230 --> 01:13:51,565
Così ho chiamato cubo, e
allora posso usare cubo.

1472
01:13:51,565 --> 01:13:54,200
>> Ma ciò che è importante notare
è che le questioni di ordine.

1473
01:13:54,200 --> 01:13:58,100
Se ho cubo di seguito principale, è
andando a correre in cubo.

1474
01:13:58,100 --> 01:14:00,360
E a questo punto, non c'è niente
chiamato cubo nel programma, ed è

1475
01:14:00,360 --> 01:14:02,550
solo andando a essere come, ho
idea di cosa cubo è.

1476
01:14:02,550 --> 01:14:05,060
>> Così vi dirà, implicita
dichiarazione di funzione.

1477
01:14:05,060 --> 01:14:06,690
Questo è l'errore che si presenta.

1478
01:14:06,690 --> 01:14:10,230
E così in questo caso, cubo è inferiore
principale, quindi non sta andando

1479
01:14:10,230 --> 01:14:12,006
a sapere.

1480
01:14:12,006 --> 01:14:14,724
>> SPEAKER 5: Così principale è di solito
l'ultima funzione definita?

1481
01:14:14,724 --> 01:14:17,290
>> JOSEPH: Quindi la domanda è,
è il principale solito l'ultima

1482
01:14:17,290 --> 01:14:18,170
cosa che avresti definito?

1483
01:14:18,170 --> 01:14:19,730
E nessuno.

1484
01:14:19,730 --> 01:14:22,280
È perché noi di solito piace principale
per essere al top, giusto?

1485
01:14:22,280 --> 01:14:24,640
Perché questa è la prima cosa che
vuole aprire il programmatore del

1486
01:14:24,640 --> 01:14:25,640
programma per vedere.

1487
01:14:25,640 --> 01:14:29,950
E così come possiamo risolvere questo problema di noi
voler principale di essere in alto, ma l'

1488
01:14:29,950 --> 01:14:33,750
funzioni che vogliamo, noi li vogliono
al di sotto principale ancora in grado di utilizzare

1489
01:14:33,750 --> 01:14:34,930
loro all'interno della principale?

1490
01:14:34,930 --> 01:14:36,870
>> Beh, usiamo quello che noi chiamiamo
un prototipo di funzione.

1491
01:14:36,870 --> 01:14:40,830
Così che cosa un prototipo di funzione essenzialmente
si è in primo luogo prende ciò che

1492
01:14:40,830 --> 01:14:45,060
la firma o l'intestazione funzione
di ciò che vogliamo implementare giù

1493
01:14:45,060 --> 01:14:47,420
qui, e abbiamo messo a
all'inizio di un programma.

1494
01:14:47,420 --> 01:14:51,400
>> Quindi, in questo caso, diciamo che, beh,
più avanti nel nostro programma, stiamo andando

1495
01:14:51,400 --> 01:14:55,010
per fare una promessa per implementare questo
funzione chiamata int cubo, che prende

1496
01:14:55,010 --> 01:14:56,260
un valore intero.

1497
01:14:56,260 --> 01:15:00,870
Così ora, perché è al di sopra principale,
principale, sta andando a dire, oh, bene,

1498
01:15:00,870 --> 01:15:03,910
più avanti nel programma, che sta per essere
c'è modo che io possa fare riferimento ad esso, quindi mi

1499
01:15:03,910 --> 01:15:05,230
basta lasciare che si completi per ora.

1500
01:15:05,230 --> 01:15:07,660
>> E quindi nella parte inferiore,
implementiamo cubo.

1501
01:15:07,660 --> 01:15:11,180
E poi principale sarà solo dire,
bene, ordinerà di collegamento

1502
01:15:11,180 --> 01:15:12,250
questi due simboli insieme.

1503
01:15:12,250 --> 01:15:14,320
E vedremo che cosa
significa seguito.

1504
01:15:14,320 --> 01:15:17,090
E così saprà che questo è il
funzione di cubo che dovrebbe utilizzare.

1505
01:15:17,090 --> 01:15:19,630

1506
01:15:19,630 --> 01:15:23,383
>> ROB: Il [incomprensibile] di voler
principale in basso o

1507
01:15:23,383 --> 01:15:24,880
top, ho visto entrambi.

1508
01:15:24,880 --> 01:15:28,630
Ci sono cose che proprio come
mettere principale in basso.

1509
01:15:28,630 --> 01:15:32,520
Ma una volta che un progetto diventa particolarmente
grande, di solito principale è in una

1510
01:15:32,520 --> 01:15:34,290
archiviare tutto suo.

1511
01:15:34,290 --> 01:15:38,170
E a quel punto, come il
int linea cube sarebbe -

1512
01:15:38,170 --> 01:15:42,460
all'interno di stdio.h sono un mucchio
di linee proprio come quella int

1513
01:15:42,460 --> 01:15:44,010
linea di ingresso cubo int.

1514
01:15:44,010 --> 01:15:50,170
>> E così quei prototipi sono cose che
tendono a mettere in file di intestazione, a

1515
01:15:50,170 --> 01:15:52,140
che punto, non importa.

1516
01:15:52,140 --> 01:15:54,700
Beh, non importa.

1517
01:15:54,700 --> 01:15:56,070
Quelli vanno sempre al top.

1518
01:15:56,070 --> 01:15:59,490
E se principale non è un file tutto suo,
non dovete preoccuparvi di mettere

1519
01:15:59,490 --> 01:16:02,360
singoli prototipi di funzione
nel file.

1520
01:16:02,360 --> 01:16:05,370
>> JOSEPH: E ci arriveremo un po '
po 'più tardi, quando Rob comincia a parlare

1521
01:16:05,370 --> 01:16:06,380
sulla compilazione.

1522
01:16:06,380 --> 01:16:09,480
E così c'è anche una differenza
tra il parametro e l'argomento.

1523
01:16:09,480 --> 01:16:12,500
E il parametro è proprio quello
chiamiamo questi ingressi quando

1524
01:16:12,500 --> 01:16:13,820
definiamo la funzione.

1525
01:16:13,820 --> 01:16:16,950
E noi lo chiamiamo un argomento quando abbiamo
effettivamente passare alla funzione.

1526
01:16:16,950 --> 01:16:19,600
>> Quindi, in questo caso, si tratta di un parametro,
come abbiamo detto prima.

1527
01:16:19,600 --> 01:16:24,130
E quando abbiamo effettivamente usiamo laggiù,
cubo di x, allora X è di per sé

1528
01:16:24,130 --> 01:16:25,910
ciò che noi chiamiamo un argomento
alla funzione cubo.

1529
01:16:25,910 --> 01:16:28,150
>> ROB: Quindi gli argomenti del parametro sono -

1530
01:16:28,150 --> 01:16:33,270
c'è questa distinzione, molto
confusa intercambiabile.

1531
01:16:33,270 --> 01:16:37,090
A questo punto, per me, è come uno di
quelle parole che quando la vedo in

1532
01:16:37,090 --> 01:16:41,190
selvaggio, non posso fare a meno subito
questione se lo si utilizza in

1533
01:16:41,190 --> 01:16:44,120
contesto corretto, perché il
la differenza è abbastanza sottile che basta

1534
01:16:44,120 --> 01:16:45,500
ognuno tende -

1535
01:16:45,500 --> 01:16:48,530
Ho quasi sempre dico argomento
indipendentemente da quello che voglio dire.

1536
01:16:48,530 --> 01:16:51,230

1537
01:16:51,230 --> 01:16:54,630
>> Giuseppe e funzioni sono anche utili
per quello che noi chiamiamo effetti collaterali.

1538
01:16:54,630 --> 01:16:59,230
Quindi, una funzione può prendere nessun ingresso, e
può anche produrre nessuna uscita.

1539
01:16:59,230 --> 01:17:03,280
Quindi, in questo caso particolare, io sono
definire una subroutine che non ha

1540
01:17:03,280 --> 01:17:03,970
valore di ritorno.

1541
01:17:03,970 --> 01:17:07,730
E al fine di specificare che, usiamo
ciò che noi chiamiamo un vuoto qui.

1542
01:17:07,730 --> 01:17:10,890
E così l'effetto collaterale di questa funzione
è che la stampa solo roba

1543
01:17:10,890 --> 01:17:11,920
out alla pagina.

1544
01:17:11,920 --> 01:17:13,840
In realtà non si assume alcuna
ingressi, e non è così

1545
01:17:13,840 --> 01:17:15,360
effettivamente produrre qualsiasi uscita.

1546
01:17:15,360 --> 01:17:18,230
>> Ma questo potrebbe essere utile nel senso
se si vuole, ad esempio, eseguire il debug

1547
01:17:18,230 --> 01:17:21,530
qualcosa nel programma, se volete
per scrivere un po subroutine che

1548
01:17:21,530 --> 01:17:25,160
stampa fuori, diciamo, il contenuto
di memoria o qualcosa del genere.

1549
01:17:25,160 --> 01:17:29,800
E così questi effetti collaterali sono a volte
utile di fuori del contesto

1550
01:17:29,800 --> 01:17:33,010
di proprio come ingressi e uscite.

1551
01:17:33,010 --> 01:17:34,260
Tutte le domande?

1552
01:17:34,260 --> 01:17:37,270

1553
01:17:37,270 --> 01:17:44,240
>> E per finire questo particolare segmento,
cosa fa questo programma?

1554
01:17:44,240 --> 01:17:47,420
Ti darò ragazzi un paio di
secondi per leggere attraverso di essa.

1555
01:17:47,420 --> 01:17:52,720

1556
01:17:52,720 --> 01:17:56,880
A un livello molto elementare, quello che vogliamo
dire è che scambia x e y, giusto?

1557
01:17:56,880 --> 01:18:00,090
>> Così come molti di voi effettivamente pensare
questa cambierà xey?

1558
01:18:00,090 --> 01:18:02,160
Alzi la mano.

1559
01:18:02,160 --> 01:18:02,760
Nessuno.

1560
01:18:02,760 --> 01:18:03,070
OK.

1561
01:18:03,070 --> 01:18:06,720
Chi pensa che lo farà
Non scambiare x e y?

1562
01:18:06,720 --> 01:18:09,120
E la somma di che era
non l'intera stanza.

1563
01:18:09,120 --> 01:18:10,440
Così alcune persone non sono sicuro.

1564
01:18:10,440 --> 01:18:10,920
OK.

1565
01:18:10,920 --> 01:18:11,630
Questo è ragionevole.

1566
01:18:11,630 --> 01:18:16,450
>> Quindi cerchiamo di passare attraverso ciò che accade quando
si chiama in realtà in primo luogo funzioni

1567
01:18:16,450 --> 01:18:18,320
Per rispondere a questa domanda.

1568
01:18:18,320 --> 01:18:21,430
Quindi questo è ciò che la memoria
sorta di simile.

1569
01:18:21,430 --> 01:18:23,860
Questo è un po 'come un modello semplificato
di ciò che la memoria sembra quando

1570
01:18:23,860 --> 01:18:24,800
si esegue un programma.

1571
01:18:24,800 --> 01:18:27,270
Quindi c'è qualcosa che si chiama
lo stack qui e

1572
01:18:27,270 --> 01:18:28,330
qualcosa chiamato heap.

1573
01:18:28,330 --> 01:18:30,950
E questi crescono verso
mezzo di memoria.

1574
01:18:30,950 --> 01:18:33,860
>> Quindi, in questo caso particolare, quando
si chiama una funzione,

1575
01:18:33,860 --> 01:18:35,680
viene messo in pila.

1576
01:18:35,680 --> 01:18:38,900
E quindi ciò che è contenuto in tale
funzione rimane in ciò che noi chiamiamo

1577
01:18:38,900 --> 01:18:40,550
stack frame della funzione.

1578
01:18:40,550 --> 01:18:44,500
E così, per ottenere una bella visualizzazione di
questo, let's - per esempio, abbiamo avuto la

1579
01:18:44,500 --> 01:18:45,960
programma principale precedenza.

1580
01:18:45,960 --> 01:18:47,820
E dentro di principale, abbiamo chiamato cubo.

1581
01:18:47,820 --> 01:18:50,650
Quindi principale sarebbe prima andare in pila
cornice, perché è la prima funzione

1582
01:18:50,650 --> 01:18:51,640
che si chiama.

1583
01:18:51,640 --> 01:18:55,740
>> E poi, quando cubo viene chiamato all'interno di
principale, viene messo in cima principale

1584
01:18:55,740 --> 01:18:57,790
all'interno della memoria.

1585
01:18:57,790 --> 01:19:02,090
Quindi, ciò che noterete è che cubo
ha i suoi parametri e la sua

1586
01:19:02,090 --> 01:19:02,950
propri locali.

1587
01:19:02,950 --> 01:19:06,720
Così, quando si passa effettivamente qualcosa da
una funzione, i parametri che

1588
01:19:06,720 --> 01:19:09,910
ottiene sono copie di quello che era
passato dalla principale.

1589
01:19:09,910 --> 01:19:14,140
>> E per una sorta di spiegare questo, cerchiamo di
a piedi attraverso un programma.

1590
01:19:14,140 --> 01:19:16,960
Così abbiamo la pila, questo è
solo la porzione stack.

1591
01:19:16,960 --> 01:19:21,240
E quello che facciamo è per prima cosa inizializziamo
x ed y di uno e due.

1592
01:19:21,240 --> 01:19:22,400
Così abbiamo queste piccole scatole.

1593
01:19:22,400 --> 01:19:25,310
Sono seduto in stack principale
inquadrare sullo stack.

1594
01:19:25,310 --> 01:19:26,580
Essi contengono uno e due.

1595
01:19:26,580 --> 01:19:28,820
>> Ora chiamiamo swap.

1596
01:19:28,820 --> 01:19:33,940
Quello che succede è passiamo x e y in
swap e di swap crea le proprie copie

1597
01:19:33,940 --> 01:19:36,520
di tali variabili da utilizzare all'interno
del suo stack frame.

1598
01:19:36,520 --> 01:19:39,920
Così ora là, abbiamo una, che
contiene il valore che aveva x e b,

1599
01:19:39,920 --> 01:19:41,620
che contiene il valore che y avevano.

1600
01:19:41,620 --> 01:19:42,670
Quindi uno, due.

1601
01:19:42,670 --> 01:19:47,130
>> E si noterà che questa è separata
da xey all'interno del principale.

1602
01:19:47,130 --> 01:19:51,390
Così ora creiamo un temporaneo
variabile per contenere un.

1603
01:19:51,390 --> 01:19:56,100
Abbiamo impostato una uguale a b, quindi
modifiche da uno a due.

1604
01:19:56,100 --> 01:19:59,340
E poi abbiamo fissato b uguale
di temperatura, che è uno.

1605
01:19:59,340 --> 01:20:01,640
>> E poi adesso usciamo fuori
di questa funzione.

1606
01:20:01,640 --> 01:20:04,310

1607
01:20:04,310 --> 01:20:07,410
Quando si esce dalla funzione, l'
stack frame viene estratto dallo stack.

1608
01:20:07,410 --> 01:20:08,270
Noi lo chiamiamo spingere.

1609
01:20:08,270 --> 01:20:12,750
Si preme uno stack frame nello stack
e se si pop dallo stack.

1610
01:20:12,750 --> 01:20:16,080
E così quello che succede è tutto ciò che
sia in quello stack frame sorta di appena

1611
01:20:16,080 --> 01:20:17,280
va in fiamme.

1612
01:20:17,280 --> 01:20:19,180
E in modo tale che non esiste più.

1613
01:20:19,180 --> 01:20:20,470
>> Ma cosa notiamo?

1614
01:20:20,470 --> 01:20:23,690
Non abbiamo mai realmente cambiato il
valori di x ed y, giusto?

1615
01:20:23,690 --> 01:20:26,530
Così quelli soggiornato locale principale.

1616
01:20:26,530 --> 01:20:29,900
E passando le cose in swap, ci
in realtà mai cambiato quei valori.

1617
01:20:29,900 --> 01:20:31,260
E che cosa chiamiamo questo?

1618
01:20:31,260 --> 01:20:33,040
Noi chiamiamo questo passaggio per valore.

1619
01:20:33,040 --> 01:20:36,860
>> Quindi, in C, quando si passa le cose in
funzioni, li passa dal valore e

1620
01:20:36,860 --> 01:20:40,160
fa una copia di loro per
la funzione da utilizzare.

1621
01:20:40,160 --> 01:20:43,980
E impareremo qualcosa chiamato
passando per riferimento futuro, ma che è

1622
01:20:43,980 --> 01:20:45,390
un modo per risolvere questo problema.

1623
01:20:45,390 --> 01:20:47,080
Ma noi non preoccuparsi
che fino a tardi.

1624
01:20:47,080 --> 01:20:52,200
>> ROB: E in realtà, quel termine, passando
per riferimento, quindi C non ha nemmeno

1625
01:20:52,200 --> 01:20:54,270
passando per riferimento.

1626
01:20:54,270 --> 01:20:56,760
C è esclusivamente di passaggio per valore.

1627
01:20:56,760 --> 01:20:59,630
Non importa quello che fai, sei sempre
passando una copia di qualcosa.

1628
01:20:59,630 --> 01:21:03,395
E 'solo che, come ho accennato una sorta di
che prima con puntatori

1629
01:21:03,395 --> 01:21:07,690
e che una stringa è in realtà solo quattro
byte che punta a un posto nella memoria.

1630
01:21:07,690 --> 01:21:11,890
>> Beh, se ho questa stringa ed è
mi dice che è dove la stringa -

1631
01:21:11,890 --> 01:21:15,470
bene, se ho questo puntatore a questo
collocare nella memoria, allora posso passare un

1632
01:21:15,470 --> 01:21:19,160
copia di tale puntatore a una funzione, e
che la funzione sa ancora dove

1633
01:21:19,160 --> 01:21:19,780
memoria è.

1634
01:21:19,780 --> 01:21:22,950
Quindi entrambi questi indicatori siano rivolte
nello stesso posto in memoria, e

1635
01:21:22,950 --> 01:21:26,460
è così che stiamo andando potere
modificare cose oltre l'

1636
01:21:26,460 --> 01:21:29,852
stack frame corrente.

1637
01:21:29,852 --> 01:21:31,040
>> JOSEPH: Vuoi fare la compilazione?

1638
01:21:31,040 --> 01:21:31,820
>> ROB: No, è 05:30.

1639
01:21:31,820 --> 01:21:32,910
>> JOSEPH: OK.

1640
01:21:32,910 --> 01:21:35,040
E '5:30.

1641
01:21:35,040 --> 01:21:35,360
OK.

1642
01:21:35,360 --> 01:21:39,280
Quindi ci occuperemo di compilazione Credo che in
la sezione successiva, o la vostra sezione

1643
01:21:39,280 --> 01:21:42,795
Leader in quel punto.

1644
01:21:42,795 --> 01:21:43,272
E -

1645
01:21:43,272 --> 01:21:44,630
>> ROB: Tutte le domande?

1646
01:21:44,630 --> 01:21:46,760
>> JOSEPH: Tutte le domande?

1647
01:21:46,760 --> 01:21:47,150
Sì?

1648
01:21:47,150 --> 01:21:52,469
>> SPEAKER 5: Utilizzo di stringhe da CS50, qualsiasi
funzioni che vogliamo utilizzare per

1649
01:21:52,469 --> 01:21:53,880
quelli, che sarà come funzioni C.

1650
01:21:53,880 --> 01:21:59,050
CS50 non è andato in e
fatto alcun ulteriore.

1651
01:21:59,050 --> 01:22:01,850
>> ROB: Corretto.

1652
01:22:01,850 --> 01:22:08,155
Qualsiasi della C come [incomprensibile], è
avrebbe usato quelle sulle nostre corde.

1653
01:22:08,155 --> 01:22:12,400
>> JOSEPH: E un'ultima cosa che voglio
menzione è che abbiamo una guida di stile

1654
01:22:12,400 --> 01:22:13,130
per questa classe.

1655
01:22:13,130 --> 01:22:13,360
>> ROB: Oh, sì.

1656
01:22:13,360 --> 01:22:15,270
>> JOSEPH: Quindi, se siete arrivati ​​da un
sfondo di programmazione prima,

1657
01:22:15,270 --> 01:22:17,750
potrebbero avere alcune convenzioni quando
si sta scrivendo il codice come mettere

1658
01:22:17,750 --> 01:22:20,950
parentesi sulla stessa linea o particolari
modi di rientro

1659
01:22:20,950 --> 01:22:22,240
o nominare le variabili.

1660
01:22:22,240 --> 01:22:26,870
In questa classe, vogliamo seguire un
Guida stile specifico solo perché,

1661
01:22:26,870 --> 01:22:31,100
bene, se si va fuori e lavorare in
industria, si sta andando ad essere previsto

1662
01:22:31,100 --> 01:22:34,780
seguire la guida di stile del
società in cui si va a.

1663
01:22:34,780 --> 01:22:38,040
>> Come per esempio, Facebook penso
ha una particolare specie di denominazione

1664
01:22:38,040 --> 01:22:38,760
convenzione.

1665
01:22:38,760 --> 01:22:42,570
E ci sono differenze tra cammello
variabili involucro e come

1666
01:22:42,570 --> 01:22:44,610
separandoli con sottolineatura.

1667
01:22:44,610 --> 01:22:52,170
E anche, credo, soprattutto, come
per esempio, il rientro, giusto?

1668
01:22:52,170 --> 01:22:56,440
>> Noi parentesi graffe cominciamo dove
la condizione è, e

1669
01:22:56,440 --> 01:22:57,730
sono sulla riga successiva.

1670
01:22:57,730 --> 01:23:01,230
E abbiamo anche messo tra parentesi graffe in
anche se è solo una linea.

1671
01:23:01,230 --> 01:23:06,100
E un sacco di volte, ci sono modi per farlo
dove è possibile lasciare questi tutori

1672
01:23:06,100 --> 01:23:08,380
fuori se si tratta di una sola riga
sotto l'istruzione If.

1673
01:23:08,380 --> 01:23:12,070
Ma in questa classe, vogliamo seguire un
Guida stile specifico solo così si ottiene

1674
01:23:12,070 --> 01:23:13,550
utilizzato per questo genere di cose.

1675
01:23:13,550 --> 01:23:16,410
>> ROB: Sì, e Style 50 sta per
far rispettare questa guida di stile, e siamo

1676
01:23:16,410 --> 01:23:18,080
intenzione di utilizzare Style 50
al grado codice.

1677
01:23:18,080 --> 01:23:25,150
Quindi rende le cose più facili per noi e
speriamo non dovrebbe fare cose che

1678
01:23:25,150 --> 01:23:30,120
molto peggio per voi dato l'
stile standardizzato non dovrebbe essere così

1679
01:23:30,120 --> 01:23:31,460
irrealistico.

1680
01:23:31,460 --> 01:23:36,000
>> JOSEPH: E infine, per trovare lo stile
guida, passare a manual.cs50.net/style.

1681
01:23:36,000 --> 01:23:37,725
E sì.

1682
01:23:37,725 --> 01:23:40,575
>> SPEAKER 4: Avete intenzione di far rispettare
eventuali caratteri per riga?

1683
01:23:40,575 --> 01:23:42,480
>> ROB: sì.

1684
01:23:42,480 --> 01:23:45,405
>> JOSEPH: Mi dispiace, ragazzi.

1685
01:23:45,405 --> 01:23:47,680
>> ROB: E 'come uno di unici.

1686
01:23:47,680 --> 01:23:50,420
A questo punto, io sono OK con 120.

1687
01:23:50,420 --> 01:23:52,460
Sto bene con dire 120
caratteri per riga.

1688
01:23:52,460 --> 01:23:53,830
Capisco che ci sia un limite.

1689
01:23:53,830 --> 01:23:57,130
Penso che 80 è così piccolo, ma
stiamo farla rispettare.

1690
01:23:57,130 --> 01:24:00,260
>> JOSEPH: Personalmente, penso che con
C, 80 caratteri è più OK.

1691
01:24:00,260 --> 01:24:04,160
Una volta che si avvia sempre di altri
linguaggi come JavaScript e PHP, non

1692
01:24:04,160 --> 01:24:08,860
così ragionevole limitare solo
a 80 caratteri.

1693
01:24:08,860 --> 01:24:09,260
OK.

1694
01:24:09,260 --> 01:24:12,780
Beh, quella era la sezione eccellente.

1695
01:24:12,780 --> 01:24:14,750
Qualcuno vuole caramelle?

1696
01:24:14,750 --> 01:24:16,000
>> SPEAKER 4: Sì.

1697
01:24:16,000 --> 01:24:18,667