1
00:00:00,000 --> 00:00:07,160
Vale, pues el modelo está en dos versiones,

2
00:00:07,240 --> 00:00:09,000
con una clase intermedia y otra que no.

3
00:00:09,099 --> 00:00:14,699
Ahora, la aplicación ahora tiene una serie de funcionalidades

4
00:00:14,699 --> 00:00:18,039
que tiene que dar, que son todo esto.

5
00:00:18,640 --> 00:00:21,059
Tiene que poder registrar envíos, listar envíos,

6
00:00:21,160 --> 00:00:22,879
dar el coste total de todos ellos,

7
00:00:23,719 --> 00:00:25,800
dar el coste total que se ha gastado en seguros,

8
00:00:25,980 --> 00:00:29,019
actualizar el estado de los envíos, que sean.

9
00:00:29,019 --> 00:00:31,339
bueno pues tiene un montón de funcionalidades

10
00:00:31,339 --> 00:00:33,299
esto es lo que se supone

11
00:00:33,299 --> 00:00:35,039
que la persona

12
00:00:35,039 --> 00:00:36,799
que está sentada con el ordenador

13
00:00:36,799 --> 00:00:38,460
trabajando con los envíos

14
00:00:38,460 --> 00:00:41,100
tiene que poder hacerlo, pues estas

15
00:00:41,100 --> 00:00:43,039
estas mismas, vale

16
00:00:43,039 --> 00:00:44,939
entonces

17
00:00:44,939 --> 00:00:46,479
esto

18
00:00:46,479 --> 00:00:49,020
lo vamos a recoger todo en una

19
00:00:49,020 --> 00:00:49,560
clase

20
00:00:49,560 --> 00:00:53,060
donde estén todos los métodos para hacer esto

21
00:00:53,060 --> 00:00:55,119
vale, que serán llamados

22
00:00:55,119 --> 00:00:57,000
ahora ya si de la aplicación principal

23
00:00:57,000 --> 00:00:59,179
interfaz gráfica, mail, lo que sea

24
00:00:59,179 --> 00:01:00,759
que sea lo siguiente a hacer

25
00:01:00,759 --> 00:01:03,200
bueno, pues esto es lo que se supone

26
00:01:03,200 --> 00:01:05,400
que se ha recopilado como las 5

27
00:01:05,400 --> 00:01:07,560
cosas que la persona que se siente a ordenador

28
00:01:07,560 --> 00:01:09,200
tiene que poder hacer con esos envíos

29
00:01:09,200 --> 00:01:10,579
meter uno nuevo

30
00:01:10,579 --> 00:01:13,299
mirar todos los que hay

31
00:01:13,299 --> 00:01:14,799
calcular

32
00:01:14,799 --> 00:01:17,219
el coste de todos ellos

33
00:01:17,219 --> 00:01:19,719
calcular el coste de todos los seguros

34
00:01:19,719 --> 00:01:21,400
y actualizar

35
00:01:21,400 --> 00:01:23,079
el estado de cualquiera de ellos

36
00:01:23,079 --> 00:01:24,579
bueno, esas 5 cosas

37
00:01:24,579 --> 00:01:26,859
vale, pero claro

38
00:01:26,859 --> 00:01:28,019
la pregunta natural

39
00:01:28,019 --> 00:01:30,700
que nos tendríamos que haber hecho muchísimo

40
00:01:30,700 --> 00:01:32,680
antes, muchísimo antes

41
00:01:32,680 --> 00:01:34,719
incluso de empezar a enunciar

42
00:01:34,719 --> 00:01:37,000
lo que el operador

43
00:01:37,000 --> 00:01:38,079
tiene que poder hacer

44
00:01:38,079 --> 00:01:39,000
es

45
00:01:39,000 --> 00:01:42,739
nuestros datos de trabajo

46
00:01:42,739 --> 00:01:44,879
¿cuáles son? pues nuestros datos de trabajo

47
00:01:44,879 --> 00:01:46,280
son los envíos

48
00:01:46,280 --> 00:01:48,819
esos envíos, un montón de envíos, son los datos

49
00:01:48,819 --> 00:01:50,959
de trabajo, ¿dónde van a estar?

50
00:01:51,359 --> 00:01:52,819
si son un montón de envíos

51
00:01:52,819 --> 00:01:54,879
Hasta ahora mismo

52
00:01:54,879 --> 00:01:56,340
Y esperemos que por poco tiempo

53
00:01:56,340 --> 00:01:58,480
Solamente pueden vivir en un array

54
00:01:58,480 --> 00:01:59,680
No pueden vivir en otro sitio

55
00:01:59,680 --> 00:02:00,680
Hasta ahora mismo

56
00:02:00,680 --> 00:02:02,879
¿Vale? Pues ese array

57
00:02:02,879 --> 00:02:04,120
¿Dónde lo vamos a colocar?

58
00:02:04,900 --> 00:02:07,480
Pues en lugar de colocarlo siempre en el main

59
00:02:07,480 --> 00:02:09,280
Para que esté ahí siempre metido en el main

60
00:02:09,280 --> 00:02:11,620
Vamos a colocarlo en una clase suya

61
00:02:11,620 --> 00:02:12,159
Para él

62
00:02:12,159 --> 00:02:15,419
Una clase suya donde viva ese array

63
00:02:15,419 --> 00:02:18,740
Y así vamos separando un poco

64
00:02:18,740 --> 00:02:21,780
Pues venga, nos hacemos otro paquete

65
00:02:21,780 --> 00:02:25,680
Por ejemplo, paquete

66
00:02:25,680 --> 00:02:28,219
Repositorio, por eso de que aquí están

67
00:02:28,219 --> 00:02:28,879
Los datos

68
00:02:28,879 --> 00:02:35,860
Ahí están los datos

69
00:02:35,860 --> 00:02:42,680
Y ahora

70
00:02:42,680 --> 00:02:46,099
Repositorio envíos

71
00:02:46,099 --> 00:02:46,759
Por ejemplo

72
00:02:46,759 --> 00:02:50,370
Repositorio envíos

73
00:02:50,370 --> 00:02:55,490
Y aquí van a estar nuestros envíos

74
00:02:55,490 --> 00:02:57,469
Colocados ahí, bien centralizados

75
00:02:57,469 --> 00:02:59,229
Para que sea un main

76
00:02:59,229 --> 00:03:01,069
Sea una interfaz gráfica, sea quien sea

77
00:03:01,069 --> 00:03:02,270
Tire de ellos

78
00:03:02,270 --> 00:03:04,949
Pues venga, public

79
00:03:04,949 --> 00:03:07,370
Como nuestra colección de envíos

80
00:03:07,370 --> 00:03:09,270
O array de envíos es única

81
00:03:09,270 --> 00:03:10,830
En toda la aplicación, es única

82
00:03:10,830 --> 00:03:13,389
Pues static desde el principio nos facilitamos

83
00:03:13,389 --> 00:03:13,909
Su acceso

84
00:03:13,909 --> 00:03:24,180
Y vamos a no tentar a la suerte

85
00:03:24,180 --> 00:03:25,780
De los null pointer exception

86
00:03:25,780 --> 00:03:28,620
Haciendo esto

87
00:03:28,620 --> 00:03:34,560
Vale, entonces

88
00:03:34,560 --> 00:03:36,979
Como tengo

89
00:03:36,979 --> 00:03:37,960
Dos modelos

90
00:03:37,960 --> 00:03:40,780
Yo voy a tirar del modelo

91
00:03:40,780 --> 00:03:42,460
Dos, todo el, vale

92
00:03:42,460 --> 00:03:44,960
Voy a hacerlo con el dos, no sé como lo habéis hecho vosotros

93
00:03:44,960 --> 00:03:45,460
Y ya está

94
00:03:45,460 --> 00:03:47,800
O sea, con la versión

95
00:03:47,800 --> 00:03:49,120
Con la intermedia

96
00:03:49,120 --> 00:03:50,960
Con la clase intermedia

97
00:03:50,960 --> 00:03:53,719
Con el envío rastreable

98
00:03:53,719 --> 00:03:55,060
Vale

99
00:03:55,060 --> 00:03:57,800
Entonces voy a tirar

100
00:03:57,800 --> 00:04:01,580
Vale, pues bueno

101
00:04:01,580 --> 00:04:02,439
Aquí van mis datos

102
00:04:02,439 --> 00:04:05,620
Entonces, lo normal

103
00:04:05,620 --> 00:04:07,259
Lo normal

104
00:04:07,259 --> 00:04:09,939
Esto como que simula un poquito

105
00:04:09,939 --> 00:04:11,800
Pero simula un poco de lejos todavía

106
00:04:11,800 --> 00:04:13,379
Simula un poco de lejos

107
00:04:13,379 --> 00:04:15,400
Un patrón de acceso a datos típico

108
00:04:15,400 --> 00:04:17,620
pero todavía está simulado un poco de lejos

109
00:04:17,620 --> 00:04:18,600
así de andar por casa

110
00:04:18,600 --> 00:04:21,500
lo normal es que si esta clase

111
00:04:21,500 --> 00:04:23,480
tiene una caja con cosas

112
00:04:23,480 --> 00:04:25,779
pues esta clase

113
00:04:25,779 --> 00:04:27,800
te ofrezca como sacar y meter

114
00:04:27,800 --> 00:04:28,579
cosas en ella

115
00:04:28,579 --> 00:04:31,019
es lo normal, que te lo ofrezca

116
00:04:31,019 --> 00:04:33,899
yo tengo mi caja y hombre no te voy a dar

117
00:04:33,899 --> 00:04:35,160
la caja es mi clase

118
00:04:35,160 --> 00:04:37,019
mi objeto repositorio envío

119
00:04:37,019 --> 00:04:39,399
pues hombre no te voy a dar mi caja hermética

120
00:04:39,399 --> 00:04:41,139
te doy una caja y además

121
00:04:41,139 --> 00:04:43,819
te doy la opción de que la abras y saques algo

122
00:04:43,819 --> 00:04:45,319
o la opción de que

123
00:04:45,319 --> 00:04:47,759
metas algo, o incluso la opción

124
00:04:47,759 --> 00:04:49,759
de que mires

125
00:04:49,759 --> 00:04:51,720
lo que hay, o la opción

126
00:04:51,720 --> 00:04:53,639
de que algo de lo que hay

127
00:04:53,639 --> 00:04:55,860
lo cambies, tengo una caja

128
00:04:55,860 --> 00:04:57,620
pues hombre, que menos que ofrecerte

129
00:04:57,620 --> 00:04:58,939
que accedas a ella

130
00:04:58,939 --> 00:05:01,500
y luego ya la aplicación

131
00:05:01,500 --> 00:05:03,800
que use eso como le dé

132
00:05:03,800 --> 00:05:05,540
la gana, pero al menos

133
00:05:05,540 --> 00:05:07,720
el acceso básico a la caja, vamos a

134
00:05:07,720 --> 00:05:08,620
dárselo desde aquí

135
00:05:08,620 --> 00:05:11,720
sería como simular un patrón

136
00:05:11,720 --> 00:05:13,699
más o menos de diseño, un poco así de acceso

137
00:05:13,699 --> 00:05:17,000
a datos un poco chapucero, pero bueno, ya como que empezamos a ver un poquito

138
00:05:17,000 --> 00:05:21,699
de qué van las cosas. Pues aquí aislamos,

139
00:05:21,860 --> 00:05:25,759
separamos en una clase nuestra cajita con la opción de meter y sacar

140
00:05:25,759 --> 00:05:29,360
cosas en ella. Lo dejamos ahí aisladito. Caja para meter y sacar cosas.

141
00:05:29,980 --> 00:05:33,600
Esa caja con posibilidad de meter y sacar, ya que la use quien sea y como sea.

142
00:05:34,500 --> 00:05:36,100
Bueno, vamos a hacer el método de

143
00:05:36,100 --> 00:05:41,699
recuperar envío. Vale. Entonces,

144
00:05:41,699 --> 00:05:46,500
recuperar

145
00:05:46,500 --> 00:05:48,079
envío, pues por ejemplo

146
00:05:48,079 --> 00:05:57,470
y vamos a ver

147
00:05:57,470 --> 00:05:58,850
envío tiene que tener

148
00:05:58,850 --> 00:06:01,449
una clave, algo que lo identifica

149
00:06:01,449 --> 00:06:03,329
porque si no, menos mal

150
00:06:03,329 --> 00:06:05,370
tenemos una propiedad que tiene toda la pinta de que es

151
00:06:05,370 --> 00:06:07,470
única, que es código, menos mal

152
00:06:07,470 --> 00:06:09,269
si no este diseño habría estado

153
00:06:09,269 --> 00:06:10,569
muy feo

154
00:06:10,569 --> 00:06:13,310
en los diseños, los objetos

155
00:06:13,310 --> 00:06:15,389
tienen que tener algo que los identifique de forma única

156
00:06:15,389 --> 00:06:17,610
porque si no, menos mal

157
00:06:17,610 --> 00:06:19,730
hay un código, venga pues entonces

158
00:06:19,730 --> 00:06:21,529
En repositorio envío

159
00:06:21,529 --> 00:06:25,850
Recupera mi envío por código

160
00:06:25,850 --> 00:06:27,189
Que el código es entero

161
00:06:27,189 --> 00:06:29,670
O es string, como es el código

162
00:06:29,670 --> 00:06:31,129
Es entero, vale

163
00:06:31,129 --> 00:06:33,389
Pues int código

164
00:06:33,389 --> 00:06:36,569
Pues que método tan bonito

165
00:06:36,569 --> 00:06:38,490
Si yo lo hago

166
00:06:38,490 --> 00:06:41,490
Ya sé que cualquiera puede coger

167
00:06:41,490 --> 00:06:42,649
Un envío de la caja

168
00:06:42,649 --> 00:06:44,990
Llamando a este método

169
00:06:44,990 --> 00:06:46,610
Y ya está, que menos, ¿no?

170
00:06:47,430 --> 00:06:48,930
Que menos que ofrecer un método

171
00:06:48,930 --> 00:06:51,290
Que te permita recuperar un envío de la caja

172
00:06:51,290 --> 00:06:55,540
Pues bueno

173
00:06:55,540 --> 00:06:56,660
Hacer este método

174
00:06:56,660 --> 00:06:59,180
Es muy fácil

175
00:06:59,180 --> 00:07:01,519
Vamos a recorrer la colección

176
00:07:01,519 --> 00:07:15,149
Si e.código

177
00:07:15,149 --> 00:07:18,860
Es igual

178
00:07:18,860 --> 00:07:19,540
Es un entero

179
00:07:19,540 --> 00:07:22,000
Es igual a código

180
00:07:22,000 --> 00:07:23,279
Ya lo tengo

181
00:07:23,279 --> 00:07:26,459
Return

182
00:07:26,459 --> 00:07:28,540
E

183
00:07:28,540 --> 00:07:39,529
¿Qué le falta a este método?

184
00:07:41,050 --> 00:07:42,629
¿Por qué sale aquí rojo?

185
00:07:42,949 --> 00:07:43,750
Tienes que retornar

186
00:07:43,750 --> 00:07:47,079
claro, creo que más que

187
00:07:47,079 --> 00:07:48,540
retornar, tendría que devolver

188
00:07:48,540 --> 00:07:50,879
claro

189
00:07:50,879 --> 00:07:54,060
si este

190
00:07:54,060 --> 00:07:57,079
es que si empezamos retornando llegamos a tal

191
00:07:57,079 --> 00:07:58,220
así

192
00:07:58,220 --> 00:08:00,779
este for

193
00:08:00,779 --> 00:08:03,459
podría ocurrir que jamás se encuentre

194
00:08:03,459 --> 00:08:04,879
un envío dentro

195
00:08:04,879 --> 00:08:06,800
con ese código, entonces

196
00:08:06,800 --> 00:08:09,139
el for termina, esto sigue

197
00:08:09,139 --> 00:08:11,079
por aquí y el completador

198
00:08:11,079 --> 00:08:12,500
te dice, ¿y ahora qué hago?

199
00:08:12,839 --> 00:08:15,199
yo no me voy de aquí, si no me das a alguien para devolver

200
00:08:15,199 --> 00:08:17,060
De ahí no me puedo ir, estoy ahí encerrado

201
00:08:17,060 --> 00:08:19,339
Bueno, pues ahora que abre

202
00:08:19,339 --> 00:08:20,879
Hay que ponerse de acuerdo

203
00:08:20,879 --> 00:08:22,379
Y decir, a ver que devolvemos

204
00:08:22,379 --> 00:08:23,540
Si no

205
00:08:23,540 --> 00:08:27,180
Si no existe el envío, lo normal es devolver un objeto null

206
00:08:27,180 --> 00:08:30,620
Peligrosísimo

207
00:08:30,620 --> 00:08:32,539
Los null dan mucho miedo

208
00:08:32,539 --> 00:08:35,679
Vale, yo devuelvo un null

209
00:08:35,679 --> 00:08:38,840
Y luego la clase que sea que me llame

210
00:08:38,840 --> 00:08:40,120
Se hace directamente un

211
00:08:40,120 --> 00:08:42,679
Fine envío by código 3 punto no sé qué

212
00:08:42,679 --> 00:08:43,279
Punto

213
00:08:43,279 --> 00:08:45,039
Null pointer exception

214
00:08:45,039 --> 00:08:46,980
si he puesto el código mal

215
00:08:46,980 --> 00:08:49,200
pero bueno, estas cosas

216
00:08:49,200 --> 00:08:50,840
esto, pues luego tiene una solución

217
00:08:50,840 --> 00:08:53,299
que es envolverlo en otra clase, etc

218
00:08:53,299 --> 00:08:53,899
pero bueno

219
00:08:53,899 --> 00:08:57,000
vamos aparcando esas cosas

220
00:08:57,000 --> 00:08:57,840
para el futuro

221
00:08:57,840 --> 00:09:01,059
vale, bueno pues ya está

222
00:09:01,059 --> 00:09:01,899
este método ya está

223
00:09:01,899 --> 00:09:04,779
menos mal

224
00:09:04,779 --> 00:09:05,779
menos mal

225
00:09:05,779 --> 00:09:08,419
que he hecho esta inicialización

226
00:09:08,419 --> 00:09:10,820
y así esto

227
00:09:10,820 --> 00:09:12,320
nunca me va a dar este for

228
00:09:12,320 --> 00:09:14,379
nunca va a petar, nunca va a explotar

229
00:09:14,379 --> 00:09:16,620
porque incluso

230
00:09:16,620 --> 00:09:18,519
cuando el array no tenga nada

231
00:09:18,519 --> 00:09:20,980
el array no tenga nada

232
00:09:20,980 --> 00:09:22,740
y llamemos a find

233
00:09:22,740 --> 00:09:24,639
envío by código con un array vacío

234
00:09:24,639 --> 00:09:26,299
que podría ocurrir con un array vacío

235
00:09:26,299 --> 00:09:28,100
este for

236
00:09:28,100 --> 00:09:30,759
que hace internamente entrar en el

237
00:09:30,759 --> 00:09:31,100
array

238
00:09:31,100 --> 00:09:34,639
como el array tendrá cero posiciones

239
00:09:34,639 --> 00:09:36,379
entra y se va

240
00:09:36,379 --> 00:09:38,620
pero no ha explotado, ha entrado, tienes

241
00:09:38,620 --> 00:09:40,639
cero, me voy, pero si

242
00:09:40,639 --> 00:09:41,700
esto no estuviera

243
00:09:41,700 --> 00:09:43,419
esto sería un null

244
00:09:43,419 --> 00:09:45,720
entonces el for este cuando entra

245
00:09:45,720 --> 00:09:47,659
el array como es un null, pum, le sale

246
00:09:47,659 --> 00:09:48,659
null pointer exception

247
00:09:48,659 --> 00:09:51,960
entonces esta inicialización

248
00:09:51,960 --> 00:09:52,700
viene muy bien

249
00:09:52,700 --> 00:09:55,460
para que nunca nunca jamás

250
00:09:55,460 --> 00:09:57,600
este array de envío sea null

251
00:09:57,600 --> 00:09:59,120
ni siquiera cuando no tiene nada

252
00:09:59,120 --> 00:10:00,379
ni siquiera cuando no tiene nada

253
00:10:00,379 --> 00:10:03,440
porque si fuera null, repito

254
00:10:03,440 --> 00:10:05,620
este for me daría null pointer exception al entrar

255
00:10:05,620 --> 00:10:07,820
vale, pues recuperar

256
00:10:07,820 --> 00:10:09,639
envío por código ya está, ya me han dado ese

257
00:10:09,639 --> 00:10:10,980
método en la cajita y ya está

258
00:10:10,980 --> 00:10:14,379
¿Qué otra cosa nos interesa hacer

259
00:10:14,379 --> 00:10:16,220
Con esta caja?

260
00:10:16,879 --> 00:10:17,460
Meter algo

261
00:10:17,460 --> 00:10:19,840
Estas son las operaciones de

262
00:10:19,840 --> 00:10:22,899
Consultar, insertar, recuperar

263
00:10:22,899 --> 00:10:23,580
Y modificar

264
00:10:23,580 --> 00:10:26,460
Las cuatro cosas básicas que se pueden hacer con unos datos

265
00:10:26,460 --> 00:10:27,360
¿Verdad?

266
00:10:28,039 --> 00:10:29,679
Cuando tenéis un conjunto de datos

267
00:10:29,679 --> 00:10:32,340
Hay cuatro acciones que se pueden hacer con ellos

268
00:10:32,340 --> 00:10:33,679
Punto, pelota, nada más

269
00:10:33,679 --> 00:10:35,799
Recuperar

270
00:10:35,799 --> 00:10:36,799
Por clave

271
00:10:36,799 --> 00:10:38,679
Eliminar

272
00:10:38,679 --> 00:10:41,220
por clave, insertar

273
00:10:41,220 --> 00:10:43,279
uno nuevo y modificar

274
00:10:43,279 --> 00:10:44,139
uno que ya está

275
00:10:44,139 --> 00:10:47,279
son las cuatro acciones que se pueden hacer con los datos

276
00:10:47,279 --> 00:10:48,820
y esto es tan así

277
00:10:48,820 --> 00:10:50,240
que esto tiene un nombre

278
00:10:50,240 --> 00:10:53,279
que se llama así

279
00:10:53,279 --> 00:10:56,879
¿vale? cuando uno hace

280
00:10:56,879 --> 00:10:59,000
un cruz, hazme el cruz de esto

281
00:10:59,000 --> 00:11:01,039
pues ¿qué haces? los cuatro

282
00:11:01,039 --> 00:11:03,120
métodos que te hacen las únicas

283
00:11:03,120 --> 00:11:04,980
cuatro cosas que se pueden hacer con

284
00:11:04,980 --> 00:11:05,879
datos, que son

285
00:11:05,879 --> 00:11:07,840
insertar

286
00:11:07,840 --> 00:11:24,120
créate, consultar o recuperar, real, actualizar y borrar, ¿vale?

287
00:11:24,159 --> 00:11:31,039
Luego este es el acrónimo estándar que se usa continuamente cuando hablamos de trabajar con datos,

288
00:11:32,659 --> 00:11:38,039
porque son las cuatro cosas que se pueden hacer, crear, consultar, modificar y borrar.

289
00:11:38,039 --> 00:11:39,919
Pues eso justo

290
00:11:39,919 --> 00:11:42,039
Lo estamos incorporando

291
00:11:42,039 --> 00:11:43,500
A nuestra clase repositorio

292
00:11:43,500 --> 00:11:46,059
Las cuatro cosas que se van a poder hacer con esos datos

293
00:11:46,059 --> 00:11:46,960
No se puede hacer más

294
00:11:46,960 --> 00:11:49,899
Luego ya combinando esas acciones

295
00:11:49,899 --> 00:11:52,259
Cada aplicación que haga lo que le dé la gana

296
00:11:52,259 --> 00:11:53,759
Pero combinando esas acciones

297
00:11:53,759 --> 00:11:55,679
Pero esas son las cuatro básicas

298
00:11:55,679 --> 00:11:56,539
Las cuatro únicas

299
00:11:56,539 --> 00:11:59,159
Bueno, pues vamos, hemos hecho la de

300
00:11:59,159 --> 00:12:01,500
Consultar

301
00:12:01,500 --> 00:12:03,440
La R, hemos hecho la R

302
00:12:03,440 --> 00:12:04,840
Es la de Farina que se echó

303
00:12:04,840 --> 00:12:05,940
Sí

304
00:12:05,940 --> 00:12:09,019
¿Vale? Entonces

305
00:12:09,019 --> 00:12:12,279
Lo podemos incluso poner aquí

306
00:12:12,279 --> 00:12:17,419
Hacemos

307
00:12:17,419 --> 00:12:19,740
Las funciones

308
00:12:19,740 --> 00:12:22,700
Crud

309
00:12:22,700 --> 00:12:24,779
Que serían pues eso

310
00:12:24,779 --> 00:12:27,259
Create

311
00:12:27,259 --> 00:12:31,419
Reagudate

312
00:12:31,419 --> 00:12:35,250
Y delete

313
00:12:35,250 --> 00:12:39,730
Esto es lo que se puede hacer con datos

314
00:12:39,730 --> 00:12:40,230
Nada más

315
00:12:40,230 --> 00:12:43,450
Esta en particular sería la de

316
00:12:43,450 --> 00:12:44,769
Leer

317
00:12:44,769 --> 00:12:48,210
Vale, vamos a hacer ahora la de insertar un dato nuevo

318
00:12:48,210 --> 00:12:55,779
No se llaman por

319
00:12:55,779 --> 00:13:00,039
No es como un estándar

320
00:13:00,039 --> 00:13:01,399
Llamarle create

321
00:13:01,399 --> 00:13:02,460
Envío

322
00:13:02,460 --> 00:13:04,600
Como lo de create insert

323
00:13:04,600 --> 00:13:05,720
No es como un estándar

324
00:13:05,720 --> 00:13:08,700
Sí, insert

325
00:13:08,700 --> 00:13:10,620
Más bien, el nombre del método te refieres

326
00:13:10,620 --> 00:13:12,179
Sí, sí

327
00:13:12,179 --> 00:13:13,419
Insert

328
00:13:13,419 --> 00:13:15,159
Vale

329
00:13:15,159 --> 00:13:23,340
A ver que

330
00:13:23,340 --> 00:13:39,120
Vale, pues este de aquí

331
00:13:39,120 --> 00:13:42,710
Insert

332
00:13:42,710 --> 00:13:43,490
Envío

333
00:13:43,490 --> 00:13:47,580
Necesita un objeto envío entero

334
00:13:47,580 --> 00:13:51,100
Insert

335
00:13:51,100 --> 00:13:53,399
El sotaka o jirrey de siempre

336
00:13:53,399 --> 00:13:55,820
Hacemos el array grande

337
00:13:55,820 --> 00:14:05,070
New envío

338
00:14:05,070 --> 00:14:06,610
Con el tamaño que tiene

339
00:14:06,610 --> 00:14:08,809
Envíos

340
00:14:08,809 --> 00:14:12,250
Más uno

341
00:14:12,250 --> 00:14:21,470
copiamos el viejo en el nuevo

342
00:14:21,470 --> 00:14:35,190
que sería aux de i

343
00:14:35,190 --> 00:14:42,360
igual a envíos de i

344
00:14:42,360 --> 00:14:47,860
y ahora ya la nueva posición se va a la última

345
00:14:47,860 --> 00:14:52,179
posición de aux, que es aux.length-1

346
00:14:52,179 --> 00:14:55,879
esta es la última posición de aux, a esta le ponemos

347
00:14:55,879 --> 00:14:59,879
el envío nuevo, y ahora ya aux es el

348
00:14:59,879 --> 00:15:01,799
definitivo tiene lo viejo

349
00:15:01,799 --> 00:15:03,820
más el adicional que hemos

350
00:15:03,820 --> 00:15:05,159
copiado en la posición adicional

351
00:15:05,159 --> 00:15:07,399
con lo cual tenemos que sobre escribir

352
00:15:07,399 --> 00:15:10,320
envíos

353
00:15:10,320 --> 00:15:11,899
igual a aux

354
00:15:11,899 --> 00:15:22,600
si

355
00:15:22,600 --> 00:15:32,399
vale

356
00:15:32,399 --> 00:15:42,659
esto es lo de siempre que luego con colecciones

357
00:15:42,659 --> 00:15:45,980
es inmediato con colecciones

358
00:15:45,980 --> 00:15:47,399
haces un add y ya

359
00:15:47,399 --> 00:15:49,779
pero claro diréis uy que fácil con colecciones

360
00:15:49,779 --> 00:15:52,059
el problema de las colecciones es que es muy fácil

361
00:15:52,059 --> 00:15:53,580
porque con un método haces todo

362
00:15:53,580 --> 00:15:55,379
El problema son los efectos secundarios

363
00:15:55,379 --> 00:15:56,639
Si no las has diseñado bien

364
00:15:56,639 --> 00:15:59,679
Porque puede no estarte funcionando como crees

365
00:15:59,679 --> 00:16:02,220
Vale, esto ya lo habéis

366
00:16:02,220 --> 00:16:04,120
Otro segundo

367
00:16:04,120 --> 00:16:25,929
¿Vale?

368
00:16:28,529 --> 00:16:30,090
Vale, y aquí un momentito

369
00:16:30,090 --> 00:16:56,629
A ver

370
00:16:56,629 --> 00:16:59,389
Lo que cambia, lo que pasa es que

371
00:16:59,389 --> 00:17:01,110
Hay una cosa que me tiene

372
00:17:01,110 --> 00:17:04,920
Un segundito

373
00:17:04,920 --> 00:17:05,180
Sí

374
00:17:05,180 --> 00:17:12,180
Pero los métodos estáticos, porque cuando tú haces una propiedad estática, además dices que solo hay una, solo hay un envío, sí, ya está, no va a haber más.

375
00:17:12,700 --> 00:17:16,380
Claro, aunque tú instanciaras muchos de estos objetos, solo hay uno.

376
00:17:16,519 --> 00:17:24,500
Y no solo eso, sino que este objeto puede vivir independientemente de que exista un objeto de esta clase, no lo necesita para nada.

377
00:17:24,819 --> 00:17:28,769
Pero los métodos, entonces, estáticos...

378
00:17:28,769 --> 00:17:33,569
Los métodos estáticos son métodos que pueden ser llamados sin que exista ningún objeto previo.

379
00:17:34,009 --> 00:17:34,349
Vale.

380
00:17:34,349 --> 00:17:35,569
Esa es la diferencia

381
00:17:35,569 --> 00:17:37,410
Un método que no es estático

382
00:17:37,410 --> 00:17:40,170
Necesita la existencia de un objeto de esa clase

383
00:17:40,170 --> 00:17:41,009
Para ser llamado

384
00:17:41,009 --> 00:17:43,349
Aunque no use los métodos del objeto

385
00:17:43,349 --> 00:17:45,289
Lo necesita para ser llamado

386
00:17:45,289 --> 00:17:46,849
Un método estático

387
00:17:46,849 --> 00:17:50,309
Puede ser llamado sin que exista ningún objeto

388
00:17:50,309 --> 00:17:50,970
De la clase

389
00:17:50,970 --> 00:17:54,029
Y lo llamas con el nombre de la clase

390
00:17:54,029 --> 00:17:54,569
Sin más

391
00:17:54,569 --> 00:17:57,430
Pero claro, para que el compilador te lo permita

392
00:17:57,430 --> 00:18:00,049
Tienes que identificarlo con el static delante

393
00:18:00,049 --> 00:18:01,750
Tienes que identificarlo con el static delante

394
00:18:01,750 --> 00:18:04,329
Claro, si yo no lo he

395
00:18:04,329 --> 00:18:06,210
Identifico con el static delante, tengo que hacer un

396
00:18:06,210 --> 00:18:07,769
NewRepositorioEnvíos

397
00:18:07,769 --> 00:18:10,289
Que no me va a valer para nada, salvo

398
00:18:10,289 --> 00:18:11,849
Para llamar a este

399
00:18:11,849 --> 00:18:14,349
Pero si le pongo el static delante ya ni me hace

400
00:18:14,349 --> 00:18:16,309
Falta hacer el newRepositorioEnvíos

401
00:18:16,309 --> 00:18:17,470
¿Vale?

402
00:18:18,089 --> 00:18:20,410
Entonces el método de insertar envío ya lo tenemos

403
00:18:20,410 --> 00:18:23,579
Borrar

404
00:18:23,579 --> 00:18:29,859
Pues el método de borrar

405
00:18:29,859 --> 00:18:31,559
Se le pasa

406
00:18:31,559 --> 00:18:39,869
Un código

407
00:18:39,869 --> 00:18:42,630
Es borrar por clave primaria

408
00:18:42,630 --> 00:18:44,730
Y tendrá que borrar

409
00:18:44,730 --> 00:18:46,109
el elemento con ese código

410
00:18:46,109 --> 00:18:48,769
este es un poquito el más complicado

411
00:18:48,769 --> 00:18:49,950
el más lioso

412
00:18:49,950 --> 00:18:52,730
porque aquí se trata de

413
00:18:52,730 --> 00:18:54,670
copiar

414
00:18:54,670 --> 00:18:56,589
y pegar, hacer uno

415
00:18:56,589 --> 00:18:58,289
con una posición menos

416
00:18:58,289 --> 00:19:00,450
y copiar y pegar en el otro

417
00:19:00,450 --> 00:19:02,150
saltándome ese código

418
00:19:02,150 --> 00:19:04,509
y además convendría detectar si el código

419
00:19:04,509 --> 00:19:06,369
no está, pues no hacer nada

420
00:19:06,369 --> 00:19:08,529
entonces aquí tendríamos que hacer

421
00:19:08,529 --> 00:19:09,490
una raya auxiliar

422
00:19:09,490 --> 00:19:12,130
con una posición menos

423
00:19:12,130 --> 00:19:14,109
porque estamos borrando por clave primaria

424
00:19:14,109 --> 00:19:28,039
solo borro uno como mucho, que será un new envío, envíos.leds menos uno.

425
00:19:30,079 --> 00:19:41,789
Y ahora vamos a recorrer, menor que envíos.leds, incrementando y,

426
00:19:44,079 --> 00:19:50,599
llevamos dos índices por separado, porque el índice de envíos y el índice de aux

427
00:19:50,599 --> 00:19:52,519
No es el mismo porque en algún momento

428
00:19:52,519 --> 00:19:54,839
El índice de envíos

429
00:19:54,839 --> 00:19:56,900
Aumentará y el de aux no

430
00:19:56,900 --> 00:19:58,059
Porque no habremos copiado

431
00:19:58,059 --> 00:19:59,880
Entonces necesitamos otra

432
00:19:59,880 --> 00:20:08,400
Este es el índice de aux

433
00:20:08,400 --> 00:20:09,819
Y este es el índice de envíos

434
00:20:09,819 --> 00:20:11,539
Y ahora

435
00:20:11,539 --> 00:20:13,559
El índice de envíos va aumentando siempre

436
00:20:13,559 --> 00:20:15,460
Entonces aquí que hacemos

437
00:20:15,460 --> 00:20:17,259
Aux

438
00:20:17,259 --> 00:20:19,039
De j

439
00:20:19,039 --> 00:20:21,500
Perdón si el código es diferente

440
00:20:21,500 --> 00:20:22,440
Claro, si

441
00:20:22,440 --> 00:20:50,440
En envíos de i resulta que su código es distinto del que tengo que borrar, distinto del código a borrar, pues entonces aux de j igual a envíos de i.

442
00:20:50,440 --> 00:20:54,099
y j lo dejo incrementado

443
00:20:54,099 --> 00:20:55,599
para que la siguiente copia

444
00:20:55,599 --> 00:20:57,140
se haga en el siguiente

445
00:20:57,140 --> 00:20:59,359
e i no hace falta porque ya está aquí

446
00:20:59,359 --> 00:21:03,619
y ya está

447
00:21:03,619 --> 00:21:10,859
entonces esta parte del código

448
00:21:10,859 --> 00:21:12,220
este for lo entendéis

449
00:21:12,220 --> 00:21:15,319
si no

450
00:21:15,319 --> 00:21:19,589
aquí tenemos envíos

451
00:21:19,589 --> 00:21:22,390
que tiene por ejemplo

452
00:21:22,390 --> 00:21:24,450
cuatro posiciones

453
00:21:24,450 --> 00:21:26,950
vamos a suponer que envíos tiene 4 ahora mismo

454
00:21:26,950 --> 00:21:29,630
y aus que en este caso tendría 3

455
00:21:29,630 --> 00:21:31,430
porque aus se declara

456
00:21:31,430 --> 00:21:33,029
con una posición menos

457
00:21:33,029 --> 00:21:34,730
entonces i

458
00:21:34,730 --> 00:21:37,529
va avanzando

459
00:21:37,529 --> 00:21:38,950
por envíos y j

460
00:21:38,950 --> 00:21:40,890
va avanzando por aus

461
00:21:40,890 --> 00:21:43,069
entonces vamos copiando i igual a 0

462
00:21:43,069 --> 00:21:45,430
su código es el mismo, no, no es

463
00:21:45,430 --> 00:21:47,490
distinto, copiado en j igual a 0

464
00:21:47,490 --> 00:21:49,150
y j se incrementa también

465
00:21:49,150 --> 00:21:51,450
j se incrementa, el i también

466
00:21:51,450 --> 00:21:53,450
porque está aquí, i igual a 1

467
00:21:53,450 --> 00:21:54,950
¿su código es el mismo?

468
00:21:55,589 --> 00:21:58,130
no, no es el mismo, pues no se copia

469
00:21:58,130 --> 00:22:00,170
pero el i se incrementa

470
00:22:00,170 --> 00:22:01,970
pero el j no, el j se queda aquí esperando

471
00:22:01,970 --> 00:22:03,569
todavía, el j se queda aquí esperando

472
00:22:03,569 --> 00:22:05,529
el j solo se incrementa cuando se copia en el

473
00:22:05,529 --> 00:22:06,569
el i siempre

474
00:22:06,569 --> 00:22:10,049
igual a 2, ¿el código es distinto?

475
00:22:10,130 --> 00:22:11,930
si es distinto, pues lo copio

476
00:22:11,930 --> 00:22:13,410
y j se incrementa

477
00:22:13,410 --> 00:22:14,470
aquí

478
00:22:14,470 --> 00:22:17,190
igual a 3, ¿el código es distinto?

479
00:22:17,769 --> 00:22:18,930
sí, pues

480
00:22:18,930 --> 00:22:21,950
se copia y j se incrementa

481
00:22:21,950 --> 00:22:22,970
ya habríamos terminado

482
00:22:22,970 --> 00:22:26,049
¿Vale? Este es este for sin más

483
00:22:26,049 --> 00:22:33,240
Entonces

484
00:22:33,240 --> 00:22:36,180
Una vez que hemos terminado este for

485
00:22:36,180 --> 00:22:38,019
En aux se han copiado todos

486
00:22:38,019 --> 00:22:40,559
Salvo el que coincida en código

487
00:22:40,559 --> 00:22:43,680
Pero hombre, convendría distinguir

488
00:22:43,680 --> 00:22:44,640
Oye, ¿qué ha pasado?

489
00:22:45,299 --> 00:22:45,619
Si

490
00:22:45,619 --> 00:22:48,559
¿Qué pasa?

491
00:22:49,400 --> 00:22:49,920
Si

492
00:22:49,920 --> 00:22:53,859
Si no hay código

493
00:22:53,859 --> 00:23:01,039
Claro, si no hay código

494
00:23:01,039 --> 00:23:02,880
Este for va a tener un problema, ¿verdad?

495
00:23:03,140 --> 00:23:04,299
¿Qué problema va a tener?

496
00:23:05,359 --> 00:23:10,240
va a tener un problema que es

497
00:23:10,240 --> 00:23:12,579
que cuando toque copiar el último

498
00:23:12,579 --> 00:23:13,779
o sea

499
00:23:13,779 --> 00:23:16,299
al acceder a esta

500
00:23:16,299 --> 00:23:18,380
posición va a decir uy que esta posición

501
00:23:18,380 --> 00:23:18,940
no existe

502
00:23:18,940 --> 00:23:22,099
entonces en algún momento

503
00:23:22,099 --> 00:23:23,839
deberíamos distinguir aquí

504
00:23:23,839 --> 00:23:25,980
este for cuando va a terminar

505
00:23:25,980 --> 00:23:27,279
este for tiene que terminar

506
00:23:27,279 --> 00:23:31,920
¿cuándo tiene que terminar

507
00:23:31,920 --> 00:23:32,480
este for?

508
00:23:32,480 --> 00:23:33,759
¿Pero cómo no va a haber código?

509
00:23:34,759 --> 00:23:35,740
Porque te lo dan mal.

510
00:23:36,019 --> 00:23:39,299
Podría, te pueden dar un código mal, tú le das a delete y no se ha borrado.

511
00:23:40,140 --> 00:23:46,720
Entonces, ¿cómo incorporaríais la opción de que este for no dé null,

512
00:23:46,839 --> 00:23:48,819
pues no dé a rain, desvaun, excepción?

513
00:23:49,400 --> 00:23:55,079
Con un team que te busque primero en el for el índice que quieres eliminar.

514
00:23:55,339 --> 00:23:57,240
O sea, el control de un índice se convierte en el índice,

515
00:23:57,240 --> 00:23:59,059
por ejemplo, el índice lo puedes inicializar en menos uno

516
00:23:59,059 --> 00:24:01,700
y si después de terminar el primer foro

517
00:24:01,700 --> 00:24:03,319
en el que busca el código y sigue el menos uno

518
00:24:03,319 --> 00:24:05,279
es que el código no se ha encontrado y por lo tanto no existe

519
00:24:05,279 --> 00:24:06,539
y no se hace nada

520
00:24:06,539 --> 00:24:15,240
yo me complicaría menos la vida

521
00:24:15,240 --> 00:24:15,880
no lo sé

522
00:24:15,880 --> 00:24:17,720
haciendo aquí

523
00:24:17,720 --> 00:24:21,259
si J ha terminado

524
00:24:21,259 --> 00:24:22,599
marcarlo con un fin

525
00:24:22,599 --> 00:24:23,359
y salir

526
00:24:23,359 --> 00:24:25,579
y luego fuera a comprobar

527
00:24:25,579 --> 00:24:29,079
si ahí le ha dado tiempo

528
00:24:29,079 --> 00:24:30,160
a llegar al final o no

529
00:24:30,160 --> 00:24:32,700
no lo sé

530
00:24:32,700 --> 00:24:35,099
sobre la marcha

531
00:24:35,099 --> 00:24:36,460
pero sobre la marcha igual

532
00:24:36,460 --> 00:24:39,200
se os ocurre algo más fácil a vosotros

533
00:24:39,200 --> 00:24:41,680
no, que igual visto lo tuyo escrito

534
00:24:41,680 --> 00:24:43,079
igual lo tuyo es más sencillo

535
00:24:43,079 --> 00:24:44,660
¿vale?

536
00:24:45,960 --> 00:24:47,079
no sé, yo aquí

537
00:24:47,079 --> 00:24:48,220
yo qué sé, haría

538
00:25:01,079 --> 00:25:04,839
Y si luego, si terminas al final

539
00:25:04,839 --> 00:25:06,200
Sigue siendo menos uno

540
00:25:06,200 --> 00:25:08,019
Vale, vale, vale

541
00:25:08,019 --> 00:25:11,700
Mejor así

542
00:25:11,700 --> 00:25:13,059
O sea, tienes un menos uno

543
00:25:13,059 --> 00:25:16,619
Y si no se encuentra

544
00:25:16,619 --> 00:25:18,119
Sigue siendo menos uno

545
00:25:18,119 --> 00:25:19,680
Como una R y con posición menos uno

546
00:25:19,680 --> 00:25:20,660
Entiendo lo que dices

547
00:25:20,660 --> 00:25:22,799
¿Eso es lo que dices?

548
00:25:23,700 --> 00:25:25,299
Bueno, allí me vas a explicar

549
00:25:25,299 --> 00:25:25,819
Como chavismo

550
00:25:25,819 --> 00:25:29,640
Vale, bueno

551
00:25:29,640 --> 00:25:31,259
Yo aquí

552
00:25:31,259 --> 00:25:33,759
Yo aquí, que es una opción

553
00:25:33,759 --> 00:25:35,099
No digo que sea mejor ni peor que

554
00:25:35,099 --> 00:25:37,160
Yo aquí he marcado

555
00:25:37,160 --> 00:25:39,059
Que el bucle salga

556
00:25:39,059 --> 00:25:41,220
Cuando este array esté completo

557
00:25:41,220 --> 00:25:43,519
Entonces con eso, sí o sí

558
00:25:43,519 --> 00:25:45,480
Nos ahorramos el array index

559
00:25:45,480 --> 00:25:46,519
Va a una excepción, ¿verdad?

560
00:25:47,240 --> 00:25:48,960
Porque cuando ya este

561
00:25:48,960 --> 00:25:50,559
Se ha rellenado del todo

562
00:25:50,559 --> 00:25:51,640
Salimos

563
00:25:51,640 --> 00:25:55,119
Ahora afuera, simplemente

564
00:25:55,119 --> 00:25:57,500
Tenemos que distinguir

565
00:25:57,500 --> 00:25:59,660
si el código se encontró

566
00:25:59,660 --> 00:26:01,160
o no se encontró

567
00:26:01,160 --> 00:26:05,099
¿y ahora cómo lo podemos distinguir

568
00:26:05,099 --> 00:26:05,359
aquí?

569
00:26:08,380 --> 00:26:10,099
si fin sigue siendo

570
00:26:10,099 --> 00:26:12,359
si fin es false es que se ha encontrado

571
00:26:12,359 --> 00:26:15,680
bueno no, porque se podría haber encontrado

572
00:26:15,680 --> 00:26:17,859
claro, es que fin

573
00:26:17,859 --> 00:26:20,420
va a salir siempre así

574
00:26:20,420 --> 00:26:22,400
la diferencia es si llegó

575
00:26:22,400 --> 00:26:23,759
al final o no llegó al final

576
00:26:23,759 --> 00:26:26,220
si es true significa que llegó al final y no hay código

577
00:26:26,220 --> 00:26:30,400
a ver, si este va a llegar

578
00:26:30,400 --> 00:26:31,339
siempre al final

579
00:26:31,339 --> 00:26:33,640
el problema es si va a llegar al final

580
00:26:33,640 --> 00:26:36,200
antes de que envíos se haya recorrido

581
00:26:36,200 --> 00:26:37,039
entero o no

582
00:26:37,039 --> 00:26:39,960
es decir, tenemos dos posibilidades

583
00:26:39,960 --> 00:26:42,630
uy

584
00:26:42,630 --> 00:26:49,480
esto, esto, vale

585
00:26:49,480 --> 00:26:51,599
este es

586
00:26:51,599 --> 00:26:53,240
envíos y este es outs

587
00:26:53,240 --> 00:26:55,160
entonces

588
00:26:55,160 --> 00:26:57,380
posibilidad en el que el código se encontró

589
00:26:57,380 --> 00:26:59,640
este se ha copiado

590
00:26:59,640 --> 00:27:01,559
este se ha copiado

591
00:27:01,559 --> 00:27:03,599
este no se ha copiado pero ha avanzado

592
00:27:03,599 --> 00:27:04,680
y este se ha copiado

593
00:27:04,680 --> 00:27:06,900
y ha acabado siendo

594
00:27:06,900 --> 00:27:08,500
la longitud de envíos

595
00:27:08,500 --> 00:27:10,859
¿verdad? envíos.len

596
00:27:10,859 --> 00:27:13,599
posibilidad 2

597
00:27:13,599 --> 00:27:14,880
el envío no está

598
00:27:14,880 --> 00:27:15,819
¿vale?

599
00:27:19,819 --> 00:27:21,000
está rápida

600
00:27:21,000 --> 00:27:23,240
posibilidad 2

601
00:27:23,240 --> 00:27:24,480
este se ha copiado

602
00:27:24,480 --> 00:27:26,920
este se ha copiado

603
00:27:26,920 --> 00:27:28,940
este se ha copiado

604
00:27:28,940 --> 00:27:30,720
el bucle finalizó

605
00:27:30,720 --> 00:27:33,220
porque el bucle finaliza en cuanto

606
00:27:33,220 --> 00:27:35,240
j ya ha llegado al final, el bucle finalizó

607
00:27:35,240 --> 00:27:37,420
y este se ha quedado sin copiar

608
00:27:37,420 --> 00:27:39,180
luego en la posibilidad

609
00:27:39,180 --> 00:27:40,619
dos y

610
00:27:40,619 --> 00:27:42,660
se ha quedado una posición antes

611
00:27:42,660 --> 00:27:43,980
en envíos.led

612
00:27:43,980 --> 00:27:45,339
menos un

613
00:27:45,339 --> 00:27:48,819
luego la forma de distinguir

614
00:27:48,819 --> 00:27:50,279
si hemos salido del bucle

615
00:27:50,279 --> 00:27:52,579
habiendo copiado o no habiendo copiado

616
00:27:52,579 --> 00:27:54,619
sería como se ha quedado

617
00:27:54,619 --> 00:27:56,180
valiendo y

618
00:27:56,180 --> 00:27:57,480
¿vale?

619
00:28:04,799 --> 00:28:05,319
¿vale?

620
00:28:05,400 --> 00:28:05,920
es una posibilidad

621
00:28:05,920 --> 00:28:08,319
Pero que problema tenemos

622
00:28:08,319 --> 00:28:11,359
Que i es local al bucle

623
00:28:11,359 --> 00:28:14,759
Claro

624
00:28:14,759 --> 00:28:16,460
Que i es local al bucle

625
00:28:16,460 --> 00:28:18,440
Entonces

626
00:28:18,440 --> 00:28:29,970
A ver lo más fácil es guardarlo en una variable

627
00:28:29,970 --> 00:28:30,529
Y ya está

628
00:28:30,529 --> 00:28:34,950
Fin es igual a true

629
00:28:34,950 --> 00:28:36,170
O

630
00:28:36,170 --> 00:28:37,589
Si

631
00:28:37,589 --> 00:28:39,130
Vale

632
00:28:39,130 --> 00:28:44,180
Es igual a

633
00:28:44,180 --> 00:28:45,859
true

634
00:28:45,859 --> 00:28:54,859
y podemos hacerlo aquí para

635
00:28:54,859 --> 00:28:56,180
if

636
00:28:56,180 --> 00:28:58,059
y es igual

637
00:28:58,059 --> 00:29:01,640
a la última de las posiciones

638
00:29:01,640 --> 00:29:03,579
que sería envíos

639
00:29:03,579 --> 00:29:06,779
punto

640
00:29:06,779 --> 00:29:08,720
led

641
00:29:08,720 --> 00:29:10,180
bueno

642
00:29:10,180 --> 00:29:12,660
es que es muchísimo más fácil

643
00:29:12,660 --> 00:29:14,400
de forma de complicarlo tan tonta

644
00:29:14,400 --> 00:29:17,019
de verdad es mucho más fácil marcarlo con la variable

645
00:29:17,019 --> 00:29:18,819
si se encontró, ¿no? que tontería

646
00:29:18,819 --> 00:29:22,410
alce

647
00:29:22,410 --> 00:29:23,829
claro

648
00:29:23,829 --> 00:29:26,549
Lo que hemos hecho de toda la vida

649
00:29:26,549 --> 00:29:29,210
Encontrado igual a false

650
00:29:29,210 --> 00:29:30,450
Y aquí marcarlo con true

651
00:29:30,450 --> 00:29:31,029
Y ya está

652
00:29:31,029 --> 00:29:35,009
Que forma más tonta de complicarnos

653
00:29:35,009 --> 00:29:36,730
Con variables que no significaban nada

654
00:29:36,730 --> 00:29:38,690
Así muchísimo mejor

655
00:29:38,690 --> 00:29:43,009
Ahora ya nada

656
00:29:43,009 --> 00:29:44,309
Si lo he encontrado

657
00:29:44,309 --> 00:29:45,470
Claro

658
00:29:45,470 --> 00:29:50,019
Si lo hemos encontrado entonces fenomenal

659
00:29:50,019 --> 00:29:52,000
Ahora ya envíos

660
00:29:52,000 --> 00:29:53,200
Igual a aux

661
00:29:53,200 --> 00:29:56,680
Y si no lo hemos encontrado

662
00:29:56,680 --> 00:29:57,579
En BIOS no se toca

663
00:29:57,579 --> 00:29:59,259
No se ha borrado nada

664
00:29:59,259 --> 00:30:00,579
¿Vale?

665
00:30:03,099 --> 00:30:03,960
Es decir

666
00:30:03,960 --> 00:30:05,920
Hacemos uno con una posición menos

667
00:30:05,920 --> 00:30:08,519
Copiamos el uno en el otro

668
00:30:08,519 --> 00:30:10,599
Saltándonos el borrado

669
00:30:10,599 --> 00:30:11,900
Marcando si lo hemos borrado

670
00:30:11,900 --> 00:30:13,940
Y salimos

671
00:30:13,940 --> 00:30:15,900
Salimos de aquí

672
00:30:15,900 --> 00:30:17,220
Si

673
00:30:17,220 --> 00:30:20,519
Entonces esta condición

674
00:30:20,519 --> 00:30:21,660
Para que este código

675
00:30:21,660 --> 00:30:23,240
Esto no quede aquí tan feo

676
00:30:23,240 --> 00:30:25,420
esto lo natural sería meterlo aquí

677
00:30:25,420 --> 00:30:27,240
mientras j

678
00:30:27,240 --> 00:30:28,240
sea diferente

679
00:30:28,240 --> 00:30:31,299
y aquí no meto este if tan feo

680
00:30:31,299 --> 00:30:33,019
esto sería mientras

681
00:30:33,019 --> 00:30:35,119
j

682
00:30:35,119 --> 00:30:36,500
sea menor

683
00:30:36,500 --> 00:30:38,839
que aux

684
00:30:38,839 --> 00:30:40,440
punto len

685
00:30:40,440 --> 00:30:44,740
menor que aux punto len

686
00:30:44,740 --> 00:30:45,819
y aquí quito este if

687
00:30:45,819 --> 00:30:47,960
y ya esto tiene mucho más sentido

688
00:30:47,960 --> 00:30:57,640
y bueno es que

689
00:30:57,640 --> 00:30:59,279
cuando esta sea

690
00:30:59,279 --> 00:31:00,519
FALSE

691
00:31:00,519 --> 00:31:03,079
Esta va a ser TRUE siempre

692
00:31:03,079 --> 00:31:04,799
Entonces voy a entrar en la segunda

693
00:31:04,799 --> 00:31:07,660
Pero sí, lo dices porque te ahorras una evaluación

694
00:31:07,660 --> 00:31:19,529
No, error no

695
00:31:19,529 --> 00:31:21,730
La duda es

696
00:31:21,730 --> 00:31:22,630
Si

697
00:31:22,630 --> 00:31:26,089
Esta sobra en realidad

698
00:31:26,089 --> 00:31:29,240
Esta sobra

699
00:31:29,240 --> 00:31:32,640
Porque va a salir por esta antes siempre

700
00:31:32,640 --> 00:31:33,859
¿Verdad?

701
00:31:33,859 --> 00:31:37,160
Pero entonces ahí la variable FIN

702
00:31:37,160 --> 00:31:37,839
Ya no vale para nada

703
00:31:37,839 --> 00:31:40,079
La variable FIN ya no sirve para nada

704
00:31:40,079 --> 00:31:42,559
no, porque la variable fin la he puesto

705
00:31:42,559 --> 00:31:44,539
para coger ese valor, entonces si lo pongo aquí

706
00:31:44,539 --> 00:31:46,680
ya no la necesito, entonces la puedo borrar de aquí

707
00:31:46,680 --> 00:31:48,480
vale

708
00:31:48,480 --> 00:31:54,720
entonces yo creo

709
00:31:54,720 --> 00:31:55,980
que esto ahora

710
00:31:55,980 --> 00:31:57,180
creo que aquí no pinta nada

711
00:31:57,180 --> 00:31:58,700
esta

712
00:31:58,700 --> 00:32:01,599
cláusula, porque

713
00:32:01,599 --> 00:32:03,700
esta cláusula

714
00:32:03,700 --> 00:32:06,000
va a ser siempre true

715
00:32:06,000 --> 00:32:08,019
si la otra lo es, si la otra lo es

716
00:32:08,019 --> 00:32:09,059
esa lo va a ser sí o sí

717
00:32:09,059 --> 00:32:11,099
con lo cual esa ahí no pinta nada

718
00:32:11,099 --> 00:32:14,500
Yo creo que esto así estaría bien

719
00:32:14,500 --> 00:32:19,190
Creo que esto estaría bien

720
00:32:19,190 --> 00:32:21,089
Recorremos el bucle

721
00:32:21,089 --> 00:32:23,329
Mientras no nos hayamos salido

722
00:32:23,329 --> 00:32:25,710
Del array más pequeñito

723
00:32:25,710 --> 00:32:28,809
Y ahora vamos copiando

724
00:32:28,809 --> 00:32:30,910
Saltándonos, vamos copiando

725
00:32:30,910 --> 00:32:32,670
Marcamos si lo encontramos o no

726
00:32:32,670 --> 00:32:35,049
Y ahora ya sí que esto de aquí

727
00:32:35,049 --> 00:32:37,769
Creo que esta es la mejor versión posible

728
00:32:37,769 --> 00:32:45,400
Creo que se va a saltar una posición

729
00:32:45,400 --> 00:32:54,660
No, es que es la J

730
00:32:54,660 --> 00:32:55,519
Con la que estoy

731
00:32:55,519 --> 00:33:05,250
Envíos

732
00:33:05,250 --> 00:33:07,049
Porque Aux tiene menos 1

733
00:33:07,049 --> 00:33:08,710
Si el Bios tiene 5

734
00:33:08,710 --> 00:33:09,089
Y Aux