1
00:00:05,160 --> 00:00:07,910
Bueno y tocó el turno de las rutinas.

2
00:00:07,950 --> 00:00:09,550
El híper Trevín.

3
00:00:09,990 --> 00:00:16,060
Vamos a ver todo lo que tiene que ver con la programación asíncrona.

4
00:00:16,170 --> 00:00:22,500
En realidad no queda muy claro si estas hiper Freddick porque en realidad todo va una pila de stack

5
00:00:22,560 --> 00:00:31,230
que se va ejecutando paulatinamente a medida que van consiguiendo memoria y procesador así que vamos

6
00:00:31,230 --> 00:00:39,240
a ver cómo maneja Goh la programación Asana quienes venimos del mundo de Notícies por ejemplo sabemos

7
00:00:39,240 --> 00:00:48,600
que existen las promesas los Cinca Weeds y que existe todo eso que no queda muy claro cómo se maneja

8
00:00:48,690 --> 00:00:56,370
realmente no me ha gustado es un poco complejo como lo maneja Nobbs si es obviamente son cosas que uno

9
00:00:56,370 --> 00:01:04,890
cuando las aprende y las maneja mejor pero no es muy amigable digamos lo que nos ha hecho esta tarea

10
00:01:04,890 --> 00:01:12,750
muy amigable y vamos a ver que son las Gough rutinas las rutinas son el equivalente a las promesas y

11
00:01:12,990 --> 00:01:14,160
así aguay.

12
00:01:14,220 --> 00:01:19,650
Vamos a ver como funciona vamos a crear nuestra Eger 14.

13
00:01:19,770 --> 00:01:25,140
Ya nos está quedando grande todo esto vamos a ir a nuestra carpeta.

14
00:01:25,290 --> 00:01:28,230
Vamos a crear la carpeta Eger 14.

15
00:01:28,230 --> 00:01:34,350
Muy bien ahora vamos a crear nuestro Main puntuó muy bien y vamos a copiar lo habitual.

16
00:01:34,410 --> 00:01:42,090
Bueno muy bien vamos a ver que en import vamos a traer nuestro FNT también nos vamos a atraerla el paquete

17
00:01:42,090 --> 00:01:42,990
strings.

18
00:01:42,990 --> 00:01:50,460
Luego vamos a ver por qué vamos a necesitar una función de este paquete y vamos a traer la FUR el paquete

19
00:01:50,460 --> 00:01:51,170
Time.

20
00:01:51,210 --> 00:01:53,360
Muy bien ya tenemos nuestros tres paquetes.

21
00:01:53,370 --> 00:01:54,990
Qué es lo que vamos a hacer ahora.

22
00:01:54,990 --> 00:02:00,060
Vamos a ver cómo maneja GOW el tema de la ejecución.

23
00:02:00,090 --> 00:02:06,780
Asíncrona lo primero que vamos a hacer es vamos a crear una función que se va a llamar mi nombre lento

24
00:02:06,930 --> 00:02:14,550
porque vamos a mostrar nuestro nombre de manera lenta caracter por caracter en pantalla y mientras esto

25
00:02:14,550 --> 00:02:21,640
va ocurriendo van a ir ocurriendo otras cosas vamos a colocar un nombre que vamos a recibir de parametro

26
00:02:21,780 --> 00:02:29,760
a nuestra función y lo que vamos a hacer aquí es crear una variable letras que lo que va a tener en

27
00:02:29,760 --> 00:02:36,690
realidad letras se va a convertir lo vamos a poner en plural porque van a ser varias letras letras se

28
00:02:36,690 --> 00:02:38,090
va a convertir en un vector.

29
00:02:38,100 --> 00:02:46,950
Cómo convierto letras en un vector con la función string por ejemplo con el paquete string y la función

30
00:02:46,950 --> 00:02:47,630
split.

31
00:02:47,640 --> 00:02:56,850
Esto va a hacer que nombre sea separado por jornada por cadena vacía esto va a lograr que cada caracter

32
00:02:56,850 --> 00:03:03,050
se separe cada caracter va a quedar separado muy bien y ahora vamos a hacer un fork.

33
00:03:03,060 --> 00:03:08,820
No me importa no me importa qué es lo que me va a devolver esta función.

34
00:03:08,820 --> 00:03:19,290
Sabemos que me va a devolver una letra como segundo parámetro y esa función es Ranes la función Ranes

35
00:03:19,750 --> 00:03:20,970
la instrucción.

36
00:03:21,030 --> 00:03:29,130
No es una función va a tomar a mi lector y por cada elemento me va a hacer una iteración muy bien ahora

37
00:03:29,130 --> 00:03:30,020
qué es lo que voy a hacer.

38
00:03:30,020 --> 00:03:32,580
Voy a hacer un time puntos lib.

39
00:03:32,700 --> 00:03:41,340
Esto va a provocar una pausa en la ejecución como está en milisegundos le voy a colocar 1000 milisegundos

40
00:03:41,460 --> 00:03:51,000
por Time Timely seco bien lo que va a hacer esto me va a ir ejecutando cada un segundo o sea en la medida

41
00:03:51,540 --> 00:03:58,840
de un milisegundo lo multiplica por mil y me termina haciendo un LEPP en un segundo.

42
00:03:58,890 --> 00:04:00,600
Cómo colocón segundones LEPP.

43
00:04:00,600 --> 00:04:08,750
Bueno tendría que colocar esto como está para que me lo multiplique y pueda obtener la pausa de un segundo

44
00:04:08,760 --> 00:04:16,990
lo que quiero es que cada letra tarde un segundo en mostrar lo que hacemos ahora es un FNT Freundt Elene

45
00:04:17,760 --> 00:04:19,610
de que deletrea muy bien.

46
00:04:19,650 --> 00:04:24,670
Esta es nuestra función si ahora vamos a llamarla de manera normal.

47
00:04:24,780 --> 00:04:29,370
Mi nombre lento lo voy a enviar a la función es mi nombre.

48
00:04:29,370 --> 00:04:38,040
Vamos a grabar esto vamos a ir a nuestro Eger 14 vamos a hacer un borrador de Maine puntocom y vamos

49
00:04:38,040 --> 00:04:38,670
a ver qué pasa.

50
00:04:38,770 --> 00:04:43,380
Bueno fijense aquí me aparece en una ventana de Avast.

51
00:04:43,380 --> 00:04:50,120
No sé porqué del antivirus funciona como consola lo vamos a desactivar.

52
00:04:50,400 --> 00:04:57,300
Vamos a desactivarlo por una hora y aquí me está ejecutando en mi consola cada un segundo cada un segundo

53
00:04:57,810 --> 00:04:59,830
una letra de mi nombre.

54
00:04:59,880 --> 00:05:06,300
Muy bien ahora es lenta Ustedes imagínense que yo voy a mandar.

55
00:05:06,300 --> 00:05:12,780
Voy a pedir que se ejecute una función que internamente va a estar conectada a base de datos va a estar

56
00:05:12,780 --> 00:05:17,940
haciendo muchas operaciones pero yo no quiero que mi ejecución se detenga.

57
00:05:17,970 --> 00:05:22,950
Yo no quiero que la ejecución se detenga quiero que siga haciendo cosas porque si no voy a tener que

58
00:05:22,950 --> 00:05:30,120
esperar varios segundos por lo menos diez segundos para que mi nombre se escriba en pantalla.

59
00:05:30,390 --> 00:05:35,750
Lo que vamos a hacer es anteponerse al llamado de la función.

60
00:05:35,940 --> 00:05:42,330
La instrucción Go tan simple como esto esto es lo que va a hacer es ejecutar mi nombre lento pero lo

61
00:05:42,330 --> 00:05:44,910
voy a ejecutar de manera asíncrona.

62
00:05:45,480 --> 00:05:52,100
Fíjense que Golo maneja muy sencillo con dos letras no hay ni Cinca guay ni promesa.

63
00:05:52,110 --> 00:05:58,650
Luego vamos a ver en el próximo capítulo cuando veamos channels Cómo puedo tomar el control de esas

64
00:05:58,650 --> 00:06:00,610
llamadas asíncronas.

65
00:06:00,660 --> 00:06:09,920
Cómo puedo obtener asegurarme de que han terminado de ejecutarse lo que serían los aguajes no íbamos

66
00:06:09,940 --> 00:06:17,790
a ver cómo podemos tener el circuito completo de programación asíncrona y totalmente manejado vamos

67
00:06:17,790 --> 00:06:19,170
ahora aquí debajo.

68
00:06:19,170 --> 00:06:27,480
Vamos a hacer un FNT un print LN que diga estoy aquí y vamos debajo de esto vamos a ir más allá.

69
00:06:27,510 --> 00:06:36,480
Vamos a hacer vamos a crear una variable de tipo string le vamos a decir vamos a pedirla por pantalla

70
00:06:36,690 --> 00:06:43,110
vamos a hacer una Scan ln x qué es lo que va a hacer esto va a mostrar por pantalla el mensaje estoy

71
00:06:43,110 --> 00:06:52,140
aquí y va a pedir por teclado que ingrese un valor pero paralelamente se va a ir ejecutando esta función

72
00:06:52,140 --> 00:06:57,000
de manera asíncrona vamos a salvarlo y vamos a ejecutar nuevamente.

73
00:06:57,180 --> 00:07:05,970
Estoy aquí me pide perdón algo me faltó aquí me faltó el puntero en escala tengo que poner un puntero

74
00:07:06,000 --> 00:07:07,560
por eso ha fallado.

75
00:07:07,560 --> 00:07:11,580
Vamos nuevamente vamos a hacer un gol nuevamente.

76
00:07:11,670 --> 00:07:19,360
Ahora estoy aquí pero yo puedo escribir y ahí terminó la ejecución de mi programa.

77
00:07:19,360 --> 00:07:19,960
Por qué.

78
00:07:19,970 --> 00:07:26,520
Porque la última instrucción de main es la que me pide por teclado no termina de ejecutarse.

79
00:07:26,520 --> 00:07:31,170
Mi nombre lento porque yo aquí ya he terminado la ejecución del programa.

80
00:07:31,230 --> 00:07:33,000
Hay que tener mucho cuidado con esto.

81
00:07:33,060 --> 00:07:40,890
El Randa indagó no se queda esperando a que la función asíncrona termine mientras estoy ejecutando la

82
00:07:40,890 --> 00:07:42,540
rutina asíncrona.

83
00:07:42,540 --> 00:07:46,700
El sistema termina la ejecución y aborta el programa.

84
00:07:46,770 --> 00:07:52,260
Esto es muy importante entenderlo por eso vamos a ver en el siguiente capítulo todo lo que tiene que

85
00:07:52,260 --> 00:07:59,610
ver con Channels y cómo manejar ahora de manera correcta la programación asíncrona nos vemos en el próximo

86
00:07:59,610 --> 00:08:00,210
capítulo.
