1
00:00:00,000 --> 00:00:05,410

2
00:00:05,410 --> 00:00:07,640
>> DOUG LLOYD: Muy bien, así
vamos a hablar de bucles.

3
00:00:07,640 --> 00:00:10,015
Así bucles son una especie de fresco
porque permiten a su programa

4
00:00:10,015 --> 00:00:12,050
para ejecutar líneas de código
Una y otra vez.

5
00:00:12,050 --> 00:00:15,600
En repetidas ocasiones, sin tener que copiar
y pegar o de otra manera repetirlos.

6
00:00:15,600 --> 00:00:17,630
Hay tres principales
tipos de bucles ya lo verás.

7
00:00:17,630 --> 00:00:21,010
Usted probablemente tendrá ocasión de utilizar
cada uno de ellos a medida que avanza a través CS50.

8
00:00:21,010 --> 00:00:22,940
Algunos de estos bucles son bastante
familiar para usted a partir de cero,

9
00:00:22,940 --> 00:00:25,814
así que de nuevo, como lo hicimos con los condicionales,
pondremos al lado del otro

10
00:00:25,814 --> 00:00:28,930
si hay una analogía podemos sacar.

11
00:00:28,930 --> 00:00:33,600
>> En primer lugar es para siempre desde cero,
que se compara con while (true).

12
00:00:33,600 --> 00:00:35,390
Esto es lo que llamamos un bucle infinito.

13
00:00:35,390 --> 00:00:38,560
Las líneas de código entre el rizado
llaves, al igual que las piezas del rompecabezas

14
00:00:38,560 --> 00:00:41,190
que encajan dentro de la C
del bloque de siempre,

15
00:00:41,190 --> 00:00:45,290
ejecutará varias veces de arriba
a abajo, una y otra y otra vez,

16
00:00:45,290 --> 00:00:46,085
para siempre.

17
00:00:46,085 --> 00:00:48,710
Después de todo, si usted recuerda nuestra
discusión de expresiones booleanas,

18
00:00:48,710 --> 00:00:51,060
verdadero es siempre cierto.

19
00:00:51,060 --> 00:00:53,250
Así que si lo que estamos haciendo
algo tan largo como verdadero

20
00:00:53,250 --> 00:00:58,227
se cierto-- parece un poco Silly-- verdad
siempre es cierto, por lo que siempre va a correr.

21
00:00:58,227 --> 00:01:00,060
Va a correr por siempre y
siglos de los siglos hasta que

22
00:01:00,060 --> 00:01:02,900
encontrar una manera de salir de ella con
una sentencia break, que a su vez,

23
00:01:02,900 --> 00:01:06,350
vimos hace un momento nos
estaban hablando de interruptor.

24
00:01:06,350 --> 00:01:08,725
>> O de lo contrario sólo matar a nuestro
programa, que dicho sea de paso,

25
00:01:08,725 --> 00:01:11,110
si alguna vez te encuentras en un
situación con un bucle infinito

26
00:01:11,110 --> 00:01:13,484
y usted no sabe cómo detener
su programa se ejecute.

27
00:01:13,484 --> 00:01:16,527
Sólo tiene que darle el control y C y
que va a matar a su programa para usted.

28
00:01:16,527 --> 00:01:18,360
Pero esto, de nuevo, es
llamado un bucle infinito.

29
00:01:18,360 --> 00:01:19,818
Es un bucle que se ejecutará siempre.

30
00:01:19,818 --> 00:01:22,570

31
00:01:22,570 --> 00:01:25,610
Ahora, mientras bucles no son
siempre infinito, porque también

32
00:01:25,610 --> 00:01:27,880
podemos sustituir el booleana
expresión con algo

33
00:01:27,880 --> 00:01:29,867
un poco más útil que simplemente verdad.

34
00:01:29,867 --> 00:01:30,950
Así que aquí está otro ejemplo.

35
00:01:30,950 --> 00:01:34,600
Mientras que algunos Boolean y
expresión y apoyos a continuación rizado.

36
00:01:34,600 --> 00:01:38,310
Eso es más o menos análoga
repetir hasta que, a partir de cero.

37
00:01:38,310 --> 00:01:40,700
Aunque en un segundo, voy a
explicar la diferencia.

38
00:01:40,700 --> 00:01:44,310
>> Así que en C, si la expresión booleana
dentro del bucle while

39
00:01:44,310 --> 00:01:47,980
como resultado true, las líneas de
código entre las llaves

40
00:01:47,980 --> 00:01:51,900
ejecutará repetidamente una y otra
y otra vez hasta expresión booleana

41
00:01:51,900 --> 00:01:55,174
evalúa a falso.

42
00:01:55,174 --> 00:01:57,340
Así, por ejemplo, es posible que
tener algún tipo de contador.

43
00:01:57,340 --> 00:02:01,440
Así que decir que al principio de
este bucle decir int x es igual a cero.

44
00:02:01,440 --> 00:02:06,370
Mientras que x es menor que 100, hacer un par
cosas dentro que las llaves,

45
00:02:06,370 --> 00:02:10,570
a continuación, en el final de su ciclo, usted dice
x plus plus, que están incrementando x.

46
00:02:10,570 --> 00:02:13,360
Finalmente x obtendrán
100 y usted

47
00:02:13,360 --> 00:02:15,760
parar porque la condición
x es menor que 100

48
00:02:15,760 --> 00:02:19,416
ya no será cierto como
pronto como x es igual a 100.

49
00:02:19,416 --> 00:02:21,820
100 es no menor de 100.

50
00:02:21,820 --> 00:02:25,870
>> Ahora un tanto confusamente, el comportamiento
del bloque cero se invierte.

51
00:02:25,870 --> 00:02:29,110
Así que tener mucho cuidado si se trata de
su primera incursión en el uso de bucles.

52
00:02:29,110 --> 00:02:33,630
Básicamente, la repetición
hasta el bloque en Rasguño

53
00:02:33,630 --> 00:02:35,970
se repetirá algo
Una y otra vez,

54
00:02:35,970 --> 00:02:40,460
hasta que la expresión, el operador booleano
expresión en el hexágono es cierto.

55
00:02:40,460 --> 00:02:43,860
Así será seguir haciendo
hasta que sea cierto.

56
00:02:43,860 --> 00:02:48,881
Mientras tanto, el bucle while voluntad
continuará hasta que es falsa.

57
00:02:48,881 --> 00:02:51,630
Así que son muy similares, pero
hay esa poca distinción solo

58
00:02:51,630 --> 00:02:55,140
tener cuidado de todo lo que hagas
su primera incursión de la transición

59
00:02:55,140 --> 00:02:58,149
Scratch en c.

60
00:02:58,149 --> 00:03:00,190
El siguiente tipo de bucle es
en realidad bastante similar.

61
00:03:00,190 --> 00:03:02,860
Se llama el do while.

62
00:03:02,860 --> 00:03:07,060
Este bucle se ejecutará todas las líneas
de código entre las llaves una vez,

63
00:03:07,060 --> 00:03:09,530
y luego se comprobará
la expresión booleana.

64
00:03:09,530 --> 00:03:11,700
Si la expresión booleana
evalúa como true,

65
00:03:11,700 --> 00:03:14,340
que va a volver atrás y repetir
ese proceso una y otra

66
00:03:14,340 --> 00:03:17,690
y otra vez hasta la Booleana
expresión se evalúa como falsa.

67
00:03:17,690 --> 00:03:23,370
Así que este bucle, a diferencia de un bucle while, es
garantizado para funcionar al menos una vez.

68
00:03:23,370 --> 00:03:26,080
Esto puede ser muy útil.

69
00:03:26,080 --> 00:03:28,011
>> Por último, tenemos un bucle for.

70
00:03:28,011 --> 00:03:30,010
Para bucles son tipo de
sintácticamente poco atractivo

71
00:03:30,010 --> 00:03:32,330
y hay mucho que hacer
de aquí, así que tengan paciencia conmigo

72
00:03:32,330 --> 00:03:34,640
como tratamos de romper estas piezas separadas.

73
00:03:34,640 --> 00:03:36,810
En general, el caso de uso
de un bucle for es usted

74
00:03:36,810 --> 00:03:40,136
quiero repetir algo un
número específico de veces.

75
00:03:40,136 --> 00:03:42,010
En este ejemplo aquí,
Tengo el bloque de repetición

76
00:03:42,010 --> 00:03:44,010
desde cero, que es
análoga a la de bucle

77
00:03:44,010 --> 00:03:47,340
en C, repitiendo algo 10 veces.

78
00:03:47,340 --> 00:03:49,250
Y el bucle for en
la izquierda hay que

79
00:03:49,250 --> 00:03:51,410
es un bucle de cuatro que
haría lo mismo.

80
00:03:51,410 --> 00:03:52,570
Esto iría 10 veces.

81
00:03:52,570 --> 00:03:56,720
Contando desde cero,
incrementar cada paso del bucle.

82
00:03:56,720 --> 00:03:59,220
Y seguimos haciendo eso
hasta que i es menor que 10.

83
00:03:59,220 --> 00:04:00,134
>> Entonces, ¿qué sucede?

84
00:04:00,134 --> 00:04:01,550
Hay un montón de código de allí.

85
00:04:01,550 --> 00:04:03,424
Vamos a romper hacia abajo para
lo que está sucediendo paso

86
00:04:03,424 --> 00:04:05,684
a paso a medida que cavar a través de un bucle for.

87
00:04:05,684 --> 00:04:08,350
La primera cosa que pasó es
la variable contador es central.

88
00:04:08,350 --> 00:04:11,970
Todo a la izquierda de la primera
punto y coma dentro del paréntesis

89
00:04:11,970 --> 00:04:12,970
se ejecuta.

90
00:04:12,970 --> 00:04:15,180
En este caso, estamos
diciendo int i es igual a 0.

91
00:04:15,180 --> 00:04:18,709
Declarar una nueva variable llamada i,
que las variables es un tipo entero

92
00:04:18,709 --> 00:04:22,570
y estamos diciendo que el valor en el interior
esa variable va a ser cero.

93
00:04:22,570 --> 00:04:25,480
>> La segunda cosa que hacemos es
entonces evaluamos inmediatamente

94
00:04:25,480 --> 00:04:26,750
la expresión booleana.

95
00:04:26,750 --> 00:04:30,100
Expresión booleana se encuentra en la
medio de los dos puntos y comas.

96
00:04:30,100 --> 00:04:31,360
I es menos de 10.

97
00:04:31,360 --> 00:04:32,410
Eso es verdad, ¿no?

98
00:04:32,410 --> 00:04:36,030
Acabamos de decir i es igual a
cero, y así 0 es menor que 10,

99
00:04:36,030 --> 00:04:38,040
y de modo que la condición
que es verdadero y lo haremos ahora

100
00:04:38,040 --> 00:04:40,640
proceder a ejecutar el cuerpo del bucle.

101
00:04:40,640 --> 00:04:41,480
Si era falsa.

102
00:04:41,480 --> 00:04:46,380
Si, por ejemplo, le dije en lugar de
i es igual a 0 no me dijo i es igual a 15,

103
00:04:46,380 --> 00:04:47,820
int i es igual a 15.

104
00:04:47,820 --> 00:04:51,450
Bueno 15 es no menos de 10, por lo que
nunca entrar en el cuerpo del bucle

105
00:04:51,450 --> 00:04:55,450
debido a que la expresión booleana
habría evaluar que es falsa.

106
00:04:55,450 --> 00:04:59,060
>> Después vamos a través de arriba a abajo,
nos encontramos con que el cierre de corchete,

107
00:04:59,060 --> 00:05:00,830
una tercera cosa sucede.

108
00:05:00,830 --> 00:05:03,840
La variable contador es
incrementado, o más bien, las líneas

109
00:05:03,840 --> 00:05:07,790
del código de un comunicado después de la
segundo punto y coma dentro del

110
00:05:07,790 --> 00:05:10,500
para bucles paréntesis se ejecuta.

111
00:05:10,500 --> 00:05:13,250
Así que empezamos a cabo por
diciendo int i es igual a 0.

112
00:05:13,250 --> 00:05:15,770
Luego comprobamos si o no
la expresión booleana es verdadera.

113
00:05:15,770 --> 00:05:17,469
0 es menor que, 10 por lo que es verdad.

114
00:05:17,469 --> 00:05:19,510
Así que vamos a proceder
en el cuerpo del bucle.

115
00:05:19,510 --> 00:05:22,676
Las cosas van a suceder dentro del bucle, y
cuando nos encontramos con que el rizado cerrar

116
00:05:22,676 --> 00:05:25,660
corsé, la próxima cosa que
hacer es que decimos i plus, plus.

117
00:05:25,660 --> 00:05:28,860
Yo era cero ahora i es uno.

118
00:05:28,860 --> 00:05:33,100
Entonces, volvemos a comprobar el valor de
la expresión booleana en el medio.

119
00:05:33,100 --> 00:05:34,900
Uno de ellos es menos de 10.

120
00:05:34,900 --> 00:05:38,325
Así que vamos a ir a través de este
procesar una y otra vez.

121
00:05:38,325 --> 00:05:40,590
Vamos a llegar a la clausura
llave de nuevo.

122
00:05:40,590 --> 00:05:44,090
Vamos a incrementamos i de
1 a 2 y 2-3.

123
00:05:44,090 --> 00:05:48,290
Y así sucesivamente y así sucesivamente y así sucesivamente, hasta que
finalmente el valor de i se convierte en 10.

124
00:05:48,290 --> 00:05:49,950
Es 10 menos de 10?

125
00:05:49,950 --> 00:05:51,200
No.

126
00:05:51,200 --> 00:05:53,800
Contando desde 0, hemos ido
a través de 10 iteraciones del bucle.

127
00:05:53,800 --> 00:05:57,204
Hemos repetido 10 veces, simplemente
como lo hicimos en el bloque de Scratch.

128
00:05:57,204 --> 00:05:59,370
Y eso es básicamente el
proceso para un bucle de cuatro.

129
00:05:59,370 --> 00:06:01,630
>> Ahora quitar la
código real y poniéndolo

130
00:06:01,630 --> 00:06:05,120
en tan sólo algunas declaraciones generales básicos.

131
00:06:05,120 --> 00:06:06,550
Esto es lo que sucede.

132
00:06:06,550 --> 00:06:09,290
Todas las declaraciones en
comenzar se ejecutan primero.

133
00:06:09,290 --> 00:06:11,260
Es posible que haya más de uno.

134
00:06:11,260 --> 00:06:13,440
Entonces, la expresión booleana se comprueba.

135
00:06:13,440 --> 00:06:17,850
Si la expresión se evalúa como verdadera,
ejecutar el cuerpo del bucle de una sola vez.

136
00:06:17,850 --> 00:06:21,060
Si la expresión se evalúa
false, hemos terminado.

137
00:06:21,060 --> 00:06:23,040
Nosotros no ejecutamos el
cuerpo del bucle en absoluto.

138
00:06:23,040 --> 00:06:25,530
Después de que hemos ejecutado el
cuerpo del bucle de una sola vez,

139
00:06:25,530 --> 00:06:29,487
entonces hacemos lo que está en
la parte de la subasta no.

140
00:06:29,487 --> 00:06:31,820
Que suele ser va a ser
algo así como i plus, plus

141
00:06:31,820 --> 00:06:34,510
o algo así, que
modifica una variable de contador.

142
00:06:34,510 --> 00:06:37,390
Entonces, después de incrementamos, nos
comprobar la expresión de nuevo

143
00:06:37,390 --> 00:06:41,120
y repetir los pasos una y otra
y otra vez hasta la expresión es

144
00:06:41,120 --> 00:06:42,890
ya no es cierto.

145
00:06:42,890 --> 00:06:44,469
>> ¿Cuáles son los casos de uso de un bucle?

146
00:06:44,469 --> 00:06:46,760
Utilice utiliza un bucle while cuando
quieres un bucle para repetir

147
00:06:46,760 --> 00:06:51,200
un número indeterminado de veces, pero
que posiblemente podría no funcionar todo.

148
00:06:51,200 --> 00:06:53,940
Un ejemplo muy común de
un tiempo de bucle se utiliza

149
00:06:53,940 --> 00:06:56,480
es ejecutar el flujo de control para un juego.

150
00:06:56,480 --> 00:06:59,040
Usted puede no saber cuánto tiempo la
usuario va a estar jugando,

151
00:06:59,040 --> 00:07:01,440
pero desea conservar
haciendo lo mismo.

152
00:07:01,440 --> 00:07:04,970
Actualización de las posiciones de
varios sprites en el tablero.

153
00:07:04,970 --> 00:07:07,490
Usted quiere mantener las cosas
movimiento en todo momento,

154
00:07:07,490 --> 00:07:09,110
pero usted no sabe cuando el
usuario va a dejar de jugar

155
00:07:09,110 --> 00:07:10,450
o cuando van
que se quede sin vidas.

156
00:07:10,450 --> 00:07:12,741
Así que un bucle while es realmente
bueno para algo así.

157
00:07:12,741 --> 00:07:14,130
Eso es un buen caso de uso.

158
00:07:14,130 --> 00:07:16,230
>> Para un do while,
es bastante similar.

159
00:07:16,230 --> 00:07:19,746
¿Quieres un bucle para repetir un desconocido
número de veces, pero al menos una vez.

160
00:07:19,746 --> 00:07:22,370
Usted puede usar esto para un juego
también, pero un caso de uso muy común

161
00:07:22,370 --> 00:07:24,420
es preguntar al usuario para la entrada.

162
00:07:24,420 --> 00:07:28,609
En general, se podría decir algo
al igual que, me da un número entero positivo,

163
00:07:28,609 --> 00:07:30,650
y es posible poner ese
dentro de un do while.

164
00:07:30,650 --> 00:07:33,900
Por lo que siempre les pedirá a
menos una vez para un número entero positivo.

165
00:07:33,900 --> 00:07:36,850
Si te dan un número entero positivo,
es posible romper el bucle.

166
00:07:36,850 --> 00:07:37,599
Usted puede ser hecho.

167
00:07:37,599 --> 00:07:39,900
La expresión booleana en
al mismo tiempo que hacer podría ser falso.

168
00:07:39,900 --> 00:07:41,137
>> Y no te pregunte de nuevo.

169
00:07:41,137 --> 00:07:44,470
Si te dan un número negativo donde
que escriba alguna palabra o algo que es

170
00:07:44,470 --> 00:07:46,630
no es realmente útil para
usted, es posible utilizar la

171
00:07:46,630 --> 00:07:49,770
do while para volver y hacer
una y otra vez y otra vez.

172
00:07:49,770 --> 00:07:52,410
Usted definitivamente quiere pedir
que te den un número una vez,

173
00:07:52,410 --> 00:07:56,350
pero usted no sabe cuántas veces
después de que fueran plagas.

174
00:07:56,350 --> 00:08:00,540
Y así un do, mientras que es un gran uso
caso para preguntar al usuario para la entrada.

175
00:08:00,540 --> 00:08:03,060
Y una de bucles uso
caso típicamente es cuando

176
00:08:03,060 --> 00:08:06,230
desea repetir un bucle
un número discreto de veces,

177
00:08:06,230 --> 00:08:08,230
aunque puede que no
conocer el número de veces

178
00:08:08,230 --> 00:08:10,040
Actualmente el programa se compila.

179
00:08:10,040 --> 00:08:15,510
>> Así, por ejemplo, tal vez usted tiene un programa
donde se solicita al usuario un número.

180
00:08:15,510 --> 00:08:17,660
Y entran 100.

181
00:08:17,660 --> 00:08:20,510
Y entonces su ciclo for voluntad
en ese caso, correr 100 veces.

182
00:08:20,510 --> 00:08:22,480
O tal vez que entren
1000 en su programa

183
00:08:22,480 --> 00:08:24,570
y ejecute el bucle de 1.000 veces.

184
00:08:24,570 --> 00:08:26,987
Es un número específico de veces.

185
00:08:26,987 --> 00:08:28,820
Ellos no lo hacen necesariamente
saber lo que ese número

186
00:08:28,820 --> 00:08:31,010
es el programa actualmente está compilado.

187
00:08:31,010 --> 00:08:35,010
No es como un bucle while
donde podría ser infinito.

188
00:08:35,010 --> 00:08:37,127
Es más bien un número
que simplemente no sabe.

189
00:08:37,127 --> 00:08:39,210
Ahora a pesar de que tengo
esbozados todos estos casos de uso,

190
00:08:39,210 --> 00:08:41,501
usted debe saber que en muy
mucho cada circunstancia,

191
00:08:41,501 --> 00:08:44,110
usted puede intercambiar todo
tres de estos bucles.

192
00:08:44,110 --> 00:08:46,890
Puede utilizar un bucle en el que
de lo contrario, utilizar un bucle while.

193
00:08:46,890 --> 00:08:49,860
Puede utilizar un bucle donde quiera
tendrá que utilizar un do while y así sucesivamente.

194
00:08:49,860 --> 00:08:53,680
Puede ser un poco difícil a veces,
por lo general, es una buena práctica

195
00:08:53,680 --> 00:08:55,140
para adherirse a un caso de uso típico.

196
00:08:55,140 --> 00:08:57,599
Utilice un do while si
quería algo una vez, por lo menos.

197
00:08:57,599 --> 00:09:00,514
Utilice un bucle for si quieres hacer
algo un número específico de veces.

198
00:09:00,514 --> 00:09:03,730
Después de todo, es por eso que hay
tres tipos diferentes de bucles.

199
00:09:03,730 --> 00:09:06,172
>> Así que se pueden utilizar
en el contexto adecuado.

200
00:09:06,172 --> 00:09:07,880
Pero usted puede intercambiar
ellos si quieren.

201
00:09:07,880 --> 00:09:10,790
Si usted se siente cómodo con bucles mientras
y siempre se desea utilizar mientras bucles.

202
00:09:10,790 --> 00:09:12,623
Es algo que
usted puede hacer, aunque

203
00:09:12,623 --> 00:09:15,590
podría ser un poco sintácticamente
complicado, donde un bucle for

204
00:09:15,590 --> 00:09:17,850
sería mucho más sencillo.

205
00:09:17,850 --> 00:09:21,100
>> Mi nombre es Doug Lloyd y esto es CS50.

206
00:09:21,100 --> 00:09:22,688