1
00:00:01,110 --> 00:00:03,360
Es muy común que actualicemos

2
00:00:03,360 --> 00:00:08,100
una variable de estado basada en el valor actual de ese estado.

3
00:00:08,100 --> 00:00:11,103
Entonces, aprendamos ahora cuál es la mejor manera de hacerlo.

4
00:00:12,750 --> 00:00:16,470
Y de hecho, estamos actualizando el estado en función de

5
00:00:16,470 --> 00:00:19,110
el estado actual todo el tiempo aquí.

6
00:00:19,110 --> 00:00:23,460
Así que aquí, por ejemplo, en dicho paso, damos el paso actual

7
00:00:23,460 --> 00:00:25,620
y luego restar uno.

8
00:00:25,620 --> 00:00:27,330
Y aquí lo mismo.

9
00:00:27,330 --> 00:00:30,365
Entonces, aquí tomamos el estado actual abierto.

10
00:00:30,365 --> 00:00:32,400
y alternarlo, básicamente.

11
00:00:32,400 --> 00:00:35,526
Y a esto me refiero con la actualización basada en el estado.

12
00:00:35,526 --> 00:00:37,680
sobre el estado actual.

13
00:00:37,680 --> 00:00:39,930
Ahora, la forma en que lo estamos haciendo ahora

14
00:00:39,930 --> 00:00:42,780
está funcionando bien, ¿verdad?

15
00:00:42,780 --> 00:00:45,813
Nuestra aplicación funciona bien, pero ahora imaginemos que

16
00:00:45,813 --> 00:00:49,250
Después de unos meses, volvemos a esta aplicación.

17
00:00:49,250 --> 00:00:52,080
y luego queremos cambiar algo.

18
00:00:52,080 --> 00:00:55,920
Entonces, digamos que queremos que esta función maneje la siguiente aquí.

19
00:00:55,920 --> 00:00:58,258
avanzar dos veces.

20
00:00:58,258 --> 00:01:03,258
Entonces, digamos que queremos establecer el estado del paso dos veces.

21
00:01:05,280 --> 00:01:08,073
Entonces, nada nos impide hacerlo.

22
00:01:09,690 --> 00:01:12,363
Entonces, podemos hacer esto una vez y duplicarlo.

23
00:01:13,290 --> 00:01:14,760
Entonces, esto está perfectamente bien.

24
00:01:14,760 --> 00:01:16,863
Podemos llamar a la misma función dos veces.

25
00:01:18,060 --> 00:01:20,040
¿pero que? ¿Que pasa ahora?

26
00:01:20,040 --> 00:01:21,641
Entonces, ¿qué crees que va a pasar?

27
00:01:21,641 --> 00:01:24,150
cuando hago clic en siguiente ahora?

28
00:01:24,150 --> 00:01:26,730
Entonces, en teoría, debería dar el paso,

29
00:01:26,730 --> 00:01:30,450
que actualmente es uno, a la una, entonces dos,

30
00:01:30,450 --> 00:01:32,160
y luego aquí debería hacer lo mismo

31
00:01:32,160 --> 00:01:34,350
de dos a tres, ¿no?

32
00:01:34,350 --> 00:01:36,153
Pero nuevamente, observe lo que sucede.

33
00:01:37,350 --> 00:01:40,590
Entonces, solo actualizó el estado una vez.

34
00:01:40,590 --> 00:01:44,640
Ahora, entraremos en detalles por qué sucede exactamente esto.

35
00:01:44,640 --> 00:01:46,680
Pero por ahora, lo que necesito que sepas es

36
00:01:46,680 --> 00:01:48,629
que no deberíamos actualizar según el estado

37
00:01:48,629 --> 00:01:51,450
sobre el estado actual como este.

38
00:01:51,450 --> 00:01:53,850
Entonces, la forma en que lo hemos estado haciendo.

39
00:01:53,850 --> 00:01:56,100
En cambio, lo que deberíamos hacer es aprobar

40
00:01:56,100 --> 00:01:58,200
en una función de devolución de llamada aquí.

41
00:01:58,200 --> 00:02:00,412
Entonces, en lugar de un valor, pasamos una función,

42
00:02:00,412 --> 00:02:02,721
que recibirá como argumento,

43
00:02:02,721 --> 00:02:05,249
el valor actual del estado.

44
00:02:05,249 --> 00:02:09,148
Entonces, eliminemos esto aquí y creemos una función,

45
00:02:09,148 --> 00:02:13,530
y aquí simplemente crearé una función de flecha simple.

46
00:02:13,530 --> 00:02:16,950
Y entonces como decía, esto recibirá, como insumo,

47
00:02:16,950 --> 00:02:19,440
el valor actual del estado.

48
00:02:19,440 --> 00:02:21,630
Ahora bien, existen múltiples convenciones sobre cómo

49
00:02:21,630 --> 00:02:23,490
para llamar a este argumento.

50
00:02:23,490 --> 00:02:27,030
Entonces, podríamos llamarlo nuevamente paso,

51
00:02:27,030 --> 00:02:29,144
pero esto podría resultar un poco confuso.

52
00:02:29,144 --> 00:02:34,144
Podemos llamarlo paso actual, por ejemplo, o simplemente S.

53
00:02:35,160 --> 00:02:37,380
Y esto es lo que voy a hacer ahora.

54
00:02:37,380 --> 00:02:39,630
Entonces, sólo una abreviatura.

55
00:02:39,630 --> 00:02:44,010
Y entonces, aquí podemos hacer S menos uno, como antes.

56
00:02:44,010 --> 00:02:48,092
Y ahora esto funcionará exactamente de la misma manera, ¿verdad?

57
00:02:48,092 --> 00:02:51,644
Entonces, la vista aquí se actualizó de la misma manera que antes,

58
00:02:51,644 --> 00:02:54,010
pero esto es un poco más correcto,

59
00:02:54,010 --> 00:02:56,223
porque si hacemos esto aquí,

60
00:02:58,350 --> 00:03:02,430
así que nuevamente, recibiendo el paso actual como entrada,

61
00:03:02,430 --> 00:03:05,793
que simplemente llamamos S, pero podría llamarse cualquier cosa.

62
00:03:08,100 --> 00:03:12,060
Y aquí volvemos a ese paso actual más uno.

63
00:03:12,060 --> 00:03:16,320
y lo mismo aquí, más uno.

64
00:03:16,320 --> 00:03:21,320
Y si ejecutamos esto nuevamente, entonces funciona.

65
00:03:21,390 --> 00:03:24,093
Entonces, está actualizando el estado dos veces.

66
00:03:25,170 --> 00:03:28,080
Entonces, empezó a la una, entonces, por lo tanto,

67
00:03:28,080 --> 00:03:30,990
esta devolución de llamada aquí recibió el valor de uno,

68
00:03:30,990 --> 00:03:32,700
y luego uno más uno eran dos.

69
00:03:32,700 --> 00:03:34,770
Y luego aquí en el siguiente estado,

70
00:03:34,770 --> 00:03:37,800
ese valor actualizado ya se pasó aquí

71
00:03:37,800 --> 00:03:38,880
en esta devolución de llamada.

72
00:03:38,880 --> 00:03:41,940
Y entonces tenemos dos más uno, lo que da tres.

73
00:03:41,940 --> 00:03:45,450
Ahora bien, aquí realmente no queremos esto, por supuesto,

74
00:03:45,450 --> 00:03:48,090
así que sólo queremos avanzar uno.

75
00:03:48,090 --> 00:03:50,424
Pero para estar seguro para futuras actualizaciones,

76
00:03:50,424 --> 00:03:54,081
Es una buena idea utilizar siempre una devolución de llamada como esta.

77
00:03:54,081 --> 00:03:57,747
cuando queremos actualizar el estado según el valor actual

78
00:03:57,747 --> 00:03:59,490
de ese estado.

79
00:03:59,490 --> 00:04:01,263
Entonces, hagamos lo mismo aquí.

80
00:04:02,160 --> 00:04:04,860
Así que aquí también estamos haciendo lo mismo.

81
00:04:04,860 --> 00:04:08,160
Entonces, también estamos configurando este estado abierto basado

82
00:04:08,160 --> 00:04:09,213
sobre el actual.

83
00:04:10,740 --> 00:04:15,740
Entonces, llamémoslo S y luego cambiemos eso ahora, ¿verdad?

84
00:04:19,410 --> 00:04:21,724
Y eso funciona maravillosamente.

85
00:04:21,724 --> 00:04:24,660
Ahora, cuando no estamos configurando estados basados

86
00:04:24,660 --> 00:04:27,840
en el estado actual, entonces, por supuesto, podemos simplemente pasar

87
00:04:27,840 --> 00:04:29,430
en el valor como normal.

88
00:04:29,430 --> 00:04:32,190
Entonces, tal como lo hicimos aquí, por ejemplo.

89
00:04:32,190 --> 00:04:34,230
Entonces eso también pasa a veces.

90
00:04:34,230 --> 00:04:37,050
Y entonces, en ese caso, no necesitamos devolución de llamada.

91
00:04:37,050 --> 00:04:39,639
Luego, simplemente pasamos el nuevo valor de estado,

92
00:04:39,639 --> 00:04:43,721
como lo hacemos aquí, y como también lo hemos hecho aquí anteriormente.

93
00:04:43,721 --> 00:04:47,703
Nuevamente, en muchas situaciones, eso funcionaría bien.

94
00:04:48,540 --> 00:04:52,290
Entonces, antes solo teníamos la S menos uno aquí.

95
00:04:52,290 --> 00:04:54,830
y nada más y eso funcionó también.

96
00:04:54,830 --> 00:04:57,493
Pero para estar seguro para futuras actualizaciones

97
00:04:57,493 --> 00:05:02,493
o para trabajar con compañeros de trabajo, es mejor actualizar el estado

98
00:05:03,240 --> 00:05:05,820
de una manera más segura como esta.

99
00:05:05,820 --> 00:05:08,248
Y de ahora en adelante haré esto cada vez.

100
00:05:08,248 --> 00:05:12,270
que actualizamos el estado en función del valor actual

101
00:05:12,270 --> 00:05:13,143
del Estado.