Lenguaje de Programación GO

2. Introducción al Lenguaje de Programación Magister Víctor Andrade Soto

3. Logro • Al finalizar esta charla los participantes podrán usar los playground disponibles en la web y conocer la sintaxis de el lenguaje de programación GO de google para escribir pequeños programas

4. Utilidad • Conocer los playGround GO • Instalar Go para aplicaciones • Escribir programas GO • Involucrarse en los elementos iniciales de programación GO • Comprender la Sintaxis del lenguaje

5. Qué es GO Go es un lenguaje de programación concurrente y compilado inspirado en la sintaxis de C, que intenta ser dinámico como Python y con el rendimiento de C o C++. Ha sido desarrollado por Google (2009) Actualmente está disponible en formato binario para los sistemas operativos Windows, GNU/Linux, FreeBSD y Mac OS X, pudiendo también ser instalado en estos y en otros sistemas mediante el código fuente.

6. Go es un lenguaje de programación compilado, concurrente, imperativo, estructurado, orientado a objetos y con recolector de basura que de momento es soportado en diferentes tipos de sistemas UNIX, incluidos Linux, FreeBSD, Mac OS X y Plan 9 (puesto que parte del compilador está basado en un trabajo previo sobre el sistema operativo Inferno). Las arquitecturas soportadas son i386, amd64 y ARM.

7. ¿Por qué debería de aprender Go? 1 – Pocas palabras reservadas que facilitan el aprendizaje. 2 – Incorpora su propio recolector de basura. 3 – Sintaxis minimalista y simple. Con Go, menos es más. 4 – Fácil implementación de concurrencia vía Gorutinas. 5 – Estructurado principalmente en funciones. 6 – Sintaxis similar a C y C++. 7 – Strings y Maps incorporados al lenguaje. 8 – Rápido de compilar.

8. Aspectos previos a comenzar Hay que tener en cuenta algunos aspectos que han sido descartados de Go (cada uno descartado por alguna razón en específico) antes de comenzar: 1 – Herencia. 2 – Sobrecarga. 3 – Dependencias circulares entre paquetes. 4 – Aritmética de apuntadores. 5 – Aserciones. Recordemos, los aspectos anteriores NO están presentes en Go.

9. GoPlayGround GoPlayground es un servicio web que se ejecuta en los servidores de golang.org. El servicio recibe un programa Go, examina, compila, vincula y ejecuta el programa dentro de una caja de texto, luego devuelve el resultado. Existen limitaciones para los programas que se pueden ejecutar en el playGround. Puede usar la mayor parte de la biblioteca estándar, con algunas excepciones. La única comunicación que tiene un programa de juegos con el mundo exterior es escribiendo en la salida estándar y el error estándar. También existen límites en el tiempo de ejecución y en el uso de CPU y memoria.

10. https://tour.golang.org/welcome/4

11. https://goplay.space/

12. Estructura básica de un programa en Go Paquete básico Librería fmt Función básica

13. Detalles Todos los programas en Go inician por la función main en el paquete main. Además no es necesario terminar las sentencias con ; (punto y coma). En el programa anterior, podemos ver que la primera sección del programa compuesta por la primera línea contiene la declaración del package actual, que en nuestro caso es main. La segunda sección del programa compuesta por la tercera línea contiene la declaración de las rutas de importación que utiliza la palabra reservada import. Las rutas de importación cargan básicamente librerías (clases) propias del core o de terceros. La tercera parte del programa compuesta por las tres últimas líneas define la función main la cual es el punto de inicio del programa. Para agregar más de una ruta de importación se puede agregar las líneas que sean necesarias.

14. Formas de invocar librerías import "fmt" import "math/rand" O bien utilizar la sintaxis recomendada (factorizada). import ( "fmt" "math/rand" )

15. Documentación Go : https://golang.org/doc/

16. KeyWords

17. Tipos de Datos

19. ¿Cuándo utilizar el operador := en Go? El operador := es capaz de asignar el tipo de variable necesario para que cada una de las variables tenga un tipo asignado en base a su valor. Hay muchas formas de asignar una variable en Go. Esto si bien es una cuestión de estilos, también puede obedecer ciertas convenciones. Por ejemplo se suele utilizar la declaración corta dentro de las funciones y cuando se conoce el valor inicial se omite el tipo fuera de ellas.

21. La palabra clave VAR

23. Todo sobre variables En términos técnicos, una variable asigna una ubicación de almacenamiento a un valor vinculado a un nombre o identificador simbólico. Usamos el nombre de variable para hacer referencia a ese valor almacenado en un programa informático. Podemos concebir una variable como una etiqueta con nombre, que se vincula a un valor.

25. Supongamos que tenemos un número entero, 103204948, y queremos almacenar esta larga cifra en una variable en lugar de volver a escribirla una y otra vez. Para hacerlo, podemos usar un nombre fácil recordar, como la variable i. Para almacenar un valor en una variable, usaremos la siguiente sintaxis: i := 1032049348 Podemos imaginar esta variable como una etiqueta que está vinculada al valor.

27. La etiqueta tiene escrito el nombre de una variable i y está vinculada al valor entero 1032049348. La frase i := 1032049348 es una instrucción de declaración y asignación que consta de algunas partes: el nombre de la variable (i) la instrucción de declaración de variable corta (​​​​​​:=​​​​​​) el valor vinculado al nombre de la variable (1032049348) el tipo de datos inferido por Go (int)

28. Las variables pueden representar cualquier tipo de datos, no solo números enteros: • s := "Hola a todos!" • f := 45.06 • b := 5 > 9 // Un valor lógico es devuelto (boolean) • array := [4]string{"item_1", "item_2", "item_3", "item_4"} • slice := []string{"uno", "dos", "tres"} • m := map[string]string{"letra": "g", "numero": "siete", "símbolo": "&"}

29. Declarar variables En Go, hay varias formas de declarar una variable y, en algunos casos, más de una forma de declarar exactamente la variable y el valor idénticos. Podemos declarar una variable llamada i del tipo de datos int sin iniciarla. Esto significa que declararemos un espacio para ubicar un valor, pero no le daremos un valor inicial: vari int Esto crea una variable del tipo de datos int declarada como i. Podemos inicializar el valor usando el operador igual (=), como en el siguiente ejemplo: vari int = 1

30. En Go, las dos formas de instrucción se denominan declaraciones variables largas; también podemos usar una declaración variable corta: i := 1 En este caso, contamos con una variable llamada i y un tipo de datos int. Cuando no especifiquemos un tipo de datos, Go lo inferirá. Con las tres formas de declarar variables, la comunidad de Go adoptó los siguientes idiomas: Utilice únicamente una forma larga, var i int, cuando no inicialice la variable. Utilice la forma corta, i := 1, en la declaración y el inicio. Si no desea que Go infiera su tipo de datos, pero de todos modos quiere usar una declaración variable corta, puede ajustar su valor en el tipo que desee con la siguiente sintaxis: i := int64(1)

31. Valores cero packagemain import"fmt" funcmain() { var a int var b string var c float64 var d bool fmt.Printf("var a %T = %+v\n", a, a) fmt.Printf("var b %T = %q\n", b, b) fmt.Printf("var c %T = %+v\n", c, c) fmt.Printf("var d %T = %+v\n\n", d, d) } Todos los tipos incorporados tienen un valor cero. Cualquier variable asignada se puede usar incluso cuando nunca tenga un valor asignado. Podemos ver los valores cero para los siguientes tipos:

33. Usamos el verbo %T en la instrucción fmt.Printf. Esto indica a la función que imprima el data type de la variable. En Go, debido a que todos los valores tienen un valor zero, no puede haber valores undefined como en otros lenguajes. Por ejemplo, un boolean en algunos lenguajes podría ser undefined, true o false, lo que permite tres estados para la variable. En Go, no podemos exceder el valor de estados two para un valor boolean.

34. Verbos Generales %v // the value in a default format // when printing structs, the plus flag (%+v) adds field names %#v // a Go-syntax representation of the value %T // a Go-syntax representation of the type of the value %% // a literal percent sign; consumes no value Ejemplo: a:=40.00 fmt.Printf("Su edad es %v años, variable 'a' es de tipo %T", a,a)

35. Verbo booleano %t // the word true or false a:=40 b:=50 fmt.Printf("%v>%v=%t",a,b,a>b)

36. Verbos entero • %b // base 2 • %c // the character represented by the corresponding Unicode code point • %d // base 10 • %o // base 8 • %q // a single-quoted character literal safely escaped with Go syntax. • %x // base 16, with lower-case letters for a-f • %X // base 16, with upper-case letters for A-F • %U // Unicode format: U+1234; same as "U+%04X"

37. Ejemplos a:=1100 fmt.Printf("%v en base 2 es %b\n",a,a) fmt.Printf("%v en base 8 es %o\n",a,a) fmt.Printf("%v en base 16 min es %x\n",a,a) fmt.Printf("%v en base 16 may es %X\n",a,a)

38. Verbos de coma flotante y complejos • %b // decimallessscientificnotationwithexponent a power of two, • // in themanner of strconv.FormatFloatwiththe 'b' format, • // e.g. -123456p-78 • %e // scientificnotation, e.g. -1.234456e+78 • %E // scientificnotation, e.g. -1.234456E+78 • %f // decimal pointbut no exponent, e.g. 123.456 • %F // synonymfor %f • %g // %e forlargeexponents, %f otherwise • %G // %E forlargeexponents, %F otherwise

39. Cadena y segmento de bytes (tratados de manera equivalente con estos verbos): %s // the uninterpreted bytes of the string or slice %q // a double-quoted string safely escaped with Go syntax %x // base 16, lower-case, two characters per byte %X // base 16, upper-case, two characters per byte a:="Víctor" fmt.Printf("Victor = %s ; Victor = %q ",a,a)

40. Ejemplos text1 := fmt.Sprintf("Hello %s", "World") text2 := fmt.Sprintf("%d + %d = %d", 2, 3, 5) text3 := fmt.Sprintf("%s, %s (Age: %d)", "Obama", "Barack", 55) fmt.Println(text1) fmt.Println(text2) fmt.Println(text3)

41. Nombrar variables: reglas y estilos La asignación de nombres a variables es bastante flexible, pero hay reglas que se deben tener en cuenta: Los nombres de variables solo deben constar de una palabra (no deben llevar espacios). Deben contener solo letras, números y guiones bajos (_). No pueden comenzar con un número.

43. Variables globales y locales Al usar variables dentro de un programa, es importante tener en cuenta el ámbito de variable. El ámbito de una variable se refiere a espacios concretos desde los cuales es posible acceder a ella dentro del código de un programa determinado. Esto es decir que no es posible el acceso a todas las variables desde todas las partes de un programa determinado; algunas variables serán globales y algunas locales. Las variables globales existen fuera de las funciones. Las locales existen dentro de las funciones. Veamos las variables globales y locales en acción:

44. packagemain import "fmt" varg = "global" funcprintLocal() { l := "local" fmt.Println(l) } funcmain() { printLocal() fmt.Println(g) }

45. Aquí usamos var g = "global“ para crear una variable global fuera de la función. Luego definimos la función ​​​​​​printLocal(). Dentro de la función, se asigna una variable local llamada “l” que luego se imprime. El programa se cierra llamando a printLocal() e imprimiendo la variable global “g”. Debido a que “g” es una variable global, podemos hacer referencia a ella en printLocal(). Modificaremos el programa anterior para hacerlo:

46. packagemain import "fmt" varg = "global" funcprintLocal() { l := "local" fmt.Println(l) fmt.Println(g) } funcmain() { printLocal() fmt.Println(g) }

47. Comenzamos declarando una variable global g, var g = "global". En la función main, llamaremos a la función printLocal, que declara una variable local l e imprime fmt.Println(l). Luego, printLocal imprime la variable global g, fmt.Println(g). Aunque g no se definió en printLocal, podría acceder a ella debido a que se declaró en un alcance global. Por último, la función main imprime g también. Ahora, intentaremos invocar la variable local fuera de la función:

48. packagemain import "fmt" var g = "global" funcprintLocal() { l := "local" fmt.Println(l) } funcmain() { fmt.Println(l) }

49. Veamos otro ejemplo en el que usamos el mismo nombre de variable para una variable global y una local: packagemain import"fmt" varnum1 = 5 funcprintNumbers() { num1 := 10 num2 := 7 fmt.Println(num1) fmt.Println(num2) } funcmain() { printNumbers() fmt.Println(num1) }

50. En este programa, declaramos la variable num1 dos veces. Primero, declaramos num1 en el ámbito global, var num1 = 5, y otra vez dentro del alcance local de la función printNumbers, num1 := 10. Cuando imprimimos num1 desde el programa main, vemos el valor 5 impreso. Esto se debe a que main solo detecta la declaración de variable global. Sin embargo, cuando imprimimos num1 de la función printNumbers, esta detecta la instrucción local e imprime el valor 10. Aunque printNumbers crea una nueva variable llamada num1 y le asigna un valor de 10, esto no afecta a la instancia global de num1 con el valor 5. Al trabajar con variables, también deberá tener en cuenta las partes de su programa que necesitarán acceso a cada variable y adoptar una variable global o local correspondiente. En diferentes programas de Go, verá que las variables locales son normalmente más comunes.