Aprende a programar con Go (Golang)

• Estructura básica de un programa en Go:

  • package main

  • func main

    • Punto de entrada o inicio a tu programa

    • Cuando tu código sale de la función main, tu programa ha terminado

• Cantidad variable de parámetros

  • el “...<algún tipo>” es como especificamos un variadic parameter

  • El tipo “interface{}” es una interfaz vacía

    • Todos los tipos son de tipo “interface{}”

  • Entonces el parámetro  “...interface{}” significa “ingresa la cantidad de argumentos que quieras”

• Deshaciéndose de los returns

  • uso del caracter “_” para deshacerte de los returns

• No puedes tener variables sin usar en tu código

  • Esto es contaminación de código

  • El compilador no lo permite

• Usamos esta notación en Go

  • paquete.Identificador

    • ejemplo: fmt.Println()

      • Leeremos: “del paquete fmt Estoy usando la función Println”

  • Un identificador es el nombre de una variable, constante, función

• paquetes

  • Código que está ya escrito el cual puedes usar

  • imports

código: https://play.golang.org/p/8PslA-cHV0F

• Terminología

  • Palabras claves

    • Son palabras reservadas para uso interno de Go

      • Algunas veces se les llama  “palabras reservadas”

      • No puedes usar una palabra clave para algo distinto a lo que está destinada.

• Operador

  • En “2 + 4” el “+” es el OPERADOR

  • Un operador es un caracter que representa una acción, como por ejemplo “+” es un OPERADOR aritmético que representa adición.
    

• Operando

  • En “2 + 2” los “2” son OPERANDOS

• Declaración

  • En programación una declaración es el elemento más pequeño de un programa que expresa una acción que va a ser llevada a cabo. Es una instrucción que la cual le da el comando a la computadora para ejecutar una acción específica. Un programa es formado por una secuencia de una o más declaraciones.

• Expresión

  • En programación una expresión es una combinación de uno o más valores explícitos, constantes, variables, operadores y funciones que el lenguaje de programación interpreta y computa para producir otro valor. For ejemplo, 2+3 es una expresión el cual evalúa a 5.

• Mascota de golang

  • https://github.com/golang/go/tree/master/doc/gopher

  • Renne French

código: https://play.golang.org/p/5JEX1g2H9qb

• Parentesis

( )

• Llaves

{ }

• Dónde puede ser usada var

  • Cualquier lugar dentro del paquete

• scope

  • Dónde una variable existe y es accesible

  • Buena práctica: mantén el scope lo más “reducido” posible

código: https://play.golang.org/p/c_1zxUfGmQN

• DECLARAR una VARIABLE de un cierto TIPO, sólo puede contener VALORES de ese TIPO

• “Go suffers no fools.”

  • like “dead men tell no tales”

• var z int = 21

  • package scope

• Tipos de datos primitivos

  • En ciencias de computación, un tipo de datos primitivo es uno de los siguientes:

    • Un tipo de datos básico es un tipo de datos que proporcionado por un lenguaje de programación como un bloque básico de construcción de código. La mayoría de los lenguajes permiten recursivamente construir tipos de datos compuestos más complejos, utilizando como inicio tipos de datos básicos.

    • Un tipo de datos interno es un tipo de datos al cual el lenguaje proporciona soporte interno.

  • En la mayoría de los lenguajes de programación, todos los tipos de datos básicos son de incorporación interna del lenguaje. Además, muchos lenguajes también proporcionan un conjunto de tipos de datos compuestos. Hay varias opiniones de si un tipo de dato incorporado internamente en el lenguaje que no es básico debería ser considerado “primitivo”.

• https://en.wikipedia.org/wiki/Primitive_data_type

• Tipos de datos compuestos

  • En ciencias de computación,un tipo de datos compuesto es cualquier tipo de dato el cual puede ser construido en un programa usando los tipos de datos internos del lenguaje de programación u otros tipos de datos compuestos. Algunas veces es llamado structure o aggregate data type, aunque el último término puede referirse a arreglos, listas, entre otros. El acto de construir un tipo de datos compuesto es conocido como  composición

code:

• https://play.golang.org/p/1UVCK5QddGU

• https://play.golang.org/p/LrI7oRoVzz

• Entendiendo el valor cero

  • false para booleanos

  • 0 para integers

  • 0.0 para floats

  • "" para strings

  • nil para

    • pointers

    • funciones

    • interfaces

    • slices

    • channels

    • maps

• Usar el operador de declaración corta de variables mientras más sea posible

• Usar var para

  • Valor cero

  • package scope

código: https://play.golang.org/p/v3ez_kTwjn

• Configuración básica del código

  • usando var

    • usando valor cero

• Usando el operador de declaración corta

  • https://play.golang.org/p/jynLS_0Pal9

    
    

  • https://play.golang.org/p/j2NxD1wdgC6

• %v

• https://play.golang.org/p/51WOG55riI

• Caracteres de escape como  \n o \t

  • https://golang.org/ref/spec#Rune_literals

• Imprimiendo con format

  • https://play.golang.org/p/eTdCR8DzniO

  • Diferencia entre las funciones que encontramos en el paquete “fmt”

  • grupo #1 - Impresión general a la salida estándar

    • func Print(a ...interface{}) (n int, err error)

    • func Printf(format string, a ...interface{}) (n int, err error)

    • func Println(a ...interface{}) (n int, err error)t

  • grupo #2 - imprimiendo a un string el cual puede ser asignado a una variable

    • func Sprint(a ...interface{}) string

    • func Sprintf(format string, a ...interface{}) string

    • func Sprintln(a ...interface{}) string

  • group #3 - Imprimiendo a un archivo o a una a la respuesta de una petición hecha a un servidor web

    • func Fprint(w io.Writer, a ...interface{}) (n int, err error)

    • func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

    • func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

• Podemos crear nuestro propio tipo de dato en Go

  • https://play.golang.org/p/K2MC5M2Vk5E

Go tiene un lenguaje para hablar de su lenguaje. Algunos términos han sido descartados porque traen asociados conceptos diferentes. Una nueva mirada al futuro de la programación. Nuevas palabras para hablar de algunos conceptos. No hablamos de objetos, en Go hablamos de crear TIPOS y VALORES de ciertos TIPOS. No hablamos de casting, hablamos de CONVERSIÓN y ASERCIÓN.

A medida que vayas avanzando en los ejercicios prácticos, si llegas a escribir código el cuál te gustaría compartir con el resto de la clase, envíame un tweet con el link ( https://twitter.com/eduartua ) y lo agregare al outline del curso.

1. Usando el operador de declaración corta, ASIGNA los siguientes VALORES a VARIABLES con los IDENTIFICADORES “x”, “y” y “z”

   1. 42

   2. “James Bond”

   3. true

2. Luego imprime los valores almacenados en esas variables usando

   1. Una sola declaración de la función println

   2. Múltiples declaraciones de println

1. Usa var para DECLARAR tres VARIABLES. Las variables deben tener scope a nivel de paquete. No asignar VALORES a las variables. Usa los siguientes IDENTIFICADORES para las variables y asegúrate de que las variables son de los siguientes TIPOS (lo quiere decir que pueden almacenar VALORES de ese TIPO).

   1. identificador “x” tipo int

   2. identificador “y” tipo string

   3. identificador “z” tipo bool

2. En main

   1. Imprime los valores de cada identificador

   2. El compilador asigna valores a las variables. ¿Cómo son llamados esos valores?

Usando el código del ejercicio anterior,

1. En scope a nivel de paquete, asigna los siguientes valores a las tres variables

   1. a x asignale 42

   2. a y asignale “James Bond”

   3. a z asignale true

2. en main

   1. Usa fmt.Sprintf para imprimir todos los VALORES en un solo string. ASIGNA el valor retornado de TIPO string usando el operador de declaración corta a  la VARIABLE con el IDENTIFICADOR “s”

   2. Imprime el valor almacenado por la variable “s”

• Información - documentación interesante y nueva terminología “tipo subyacente, raíz o tipo implícito”

  • https://golang.org/ref/spec#Types

Para este ejercicio

1. Crea tu propio tipo. Haz que el tipo subyacente, raíz o implícito sea un int.

2. Crea una VARIABLE de tu nuevo TIPO con el IDENTIFICADOR “x” usando la palabra clave “VAR”

3. En func main

   1. Imprime el valor de la variable “x”

   2. Imprime el tipo de la variable “x”

   3. Asigna 42 a la VARIABLE “x” usando el OPERADOR “=”

   4. Imprime el valor de la variable “x”

A partir del código del ejercicio anterior

1. A nivel de paquete usando la palabra clave “var”, crear una VARIABLE con el IDENTIFICADOR “y”. La variable debería ser del mismo TIPO SUBYACENTE que tu TIPO “x” creado anteriormente

2. en func main

   1. Esto lo debería tener listo

      1. Imprimir el valor de la variable “x”

      2. Imprimir el tipo de la variable “x”

      3. Asigna un VALOR a la VARIABLE “x” usando el OPERADOR “=”

      4. Imprime el valor de la variable “x”

   2. Ahora haces esto

      1. Ahora usa CONVERSIÓN para convertir el TIPO del VALOR almacenado en “x” al TIPO IMPLÍCITO

         1. Usa el operador “=” para ASIGNAR ese valor a “y”

         2. Imprime el valor almacenado en “y”

         3. Imprime el tipo de “y”

1. Un booleano es un TIPO binario el cual puede tener dos posibles valores “verdadero” y “falso”

2. Cuando usas un operador de comparación de igualdad, este es una expresión el cual evalúa a un valor booleano

   1. ==

   2. <=

   3. >=

   4. !=

   5. <

   6. >

• Las computadoras funcionan con electricidad

• La electricidad tiene dos estados discretos: encendido y apagado

• Podemos crear esquemas de codificación para estados "on" u "off"

• Enteros

  • Números sin decimales

    • También conocidos como enteros

  • int & uint

    • “Tamaños de implementación-específica”

  • Todos los tipos numéricos son diferentes excepto

    • byte el cual es un alias para uint8

    • Rune el cual es un alias para int32

  • Los tipos son únicos

    • “Esto es un lenguaje de programación estático”

    • “Las conversiones son requeridas cuando mezclamos diferentes tipos de datos numéricos en una expresión o asignación. Por ejemplo, int32 e int no son del mismo tipo aún cuando pueden tener el mismo tamaño en una arquitectura particular.” (fuente)

  • Regla de oro: solo usa int

• floating point

  • Números con decimales

    • También conocidos como números reales

  • Regla de oro: solo usa float64

• Overflows

• Lectura recomendada - Libro de Caleb Doxsey

código:

• https://play.golang.org/p/OdWUH8uva6

• https://play.golang.org/p/0JpmCYezs1

• Este no corre: https://play.golang.org/p/O7nFEn8nXz

• int8

  • https://play.golang.org/p/IcOtgm6YKA

  • No corre: https://play.golang.org/p/YbwTa1YT4i

  • https://play.golang.org/p/exwG0ijjRf

  • No corre: https://play.golang.org/p/sy16rgifWF

runtime package

• GOOS

• GOARCH

• https://play.golang.org/p/1vp5DImIMM

• Blog post de golang sobre strings

• “Un valor string es una (posiblemente vacía) secuencia de bytes. Los strings son inmutables: una vez creados, es imposible cambiar su contenido.”

código:

• Buenos ejemplos - lecture prep:

  • https://play.golang.org/p/LUbFEJEope

  • https://play.golang.org/p/JjWLMcAsCU

• live coding:

  • https://play.golang.org/p/iBen9LOcpBG

Continuación de tipo string.

Como humanos, tenemos diferentes sistemas para expresar las cantidades de algo. Usando el sistema numérico decimal, podemos decir que tenemos 7 naranjas; 42 manzanas o 20 dólares. Otros sistemas numéricos usados en computación incluyen el sistema numérico binario y el sistema numérico hexadecimal.

• Un simple valor que no cambia.

• Sólo existe en el momento de compilación..

• Hay constantes con TIPO y SIN TIPO

  • const hola = "Hola, mundo"

  • const typedHello string = "Hello, World"

• Constante SIN TIPO

  • Un valor constante que no tiene un tipo fijo

    • “constante de algún tipo”

    • No es forzada a obedecer las reglas estrictas que previenen combinar diferentemente valores con un tipo.

  • Una constante sin tipo puede ser implícitamente convertida por el compilador.

• Es este concepto de constante sin tipo lo que hace posible que usemos constantes en Go con libertad.

  • Muy útil, por ejemplo

    • Cuál es el tipo de 42?

      • int?

      • uint?

      • float64?

    • Si no tuviéramos constante SIN TIPO (constantes de algún tipo), tendríamos que hacer conversión en cada valor literal que usamos.

      • Y eso no sería muy agradable

• Código usado en el video

  • https://play.golang.org/p/GuCvb_xIvAo

• Preparación

  • https://play.golang.org/p/lVURPQe-N4

Dentro de una declaración, el identificador pre-declarado iota representa una sucesión de constantes enteras sin tipo. Es reiniciado a 0 cada vez que la palabra constante aparece en el código. Puede ser usada para construir un conjunto de constantes relacionadas:

• código usado en el video

  • https://play.golang.org/p/_cSkz_b28t

• lecture prep

  • https://play.golang.org/p/YOabnTj5OI

  • https://play.golang.org/p/c5SmcFzzBM

Bit shifting es cuando desplazan dígitos binarios a la izquierda o a la derecha. Podemos usar bit shifting junto con iota, para construir constantes creativas.

Buen artículo

• https://goo.gl/gnbjMQ

Código en video

• https://play.golang.org/p/YnMevatXlP

• https://play.golang.org/p/q_IGHQ2am4

• https://play.golang.org/p/IwNVlOcrLG

Código para preparación:

• https://play.golang.org/p/3oxB39hYJ_

• https://play.golang.org/p/7MOnbhx4R4

Este es instructivo, muestra todos los tipos de shifting: https://play.golang.org/p/DK6Ub7Sotx

Escribe un programa que imprima un número en decimal, binario, y hexadecimal

Usando los siguientes operadores, escribe expresiones y asigna sus valores a variables:

1. ==

2. <=

3. >=

4. !=

5. <

6. >

Imprime los valores de las variables.

Crea constantes CON TIPO y SIN TIPO. Imprime el valor de las mismas.

Escribe un programa que

• Asignar un int a una variable

• Imprímelo en decimal, binario, y hex

• Has shifts de bits de ese int una posición a la izquierda y asigna eso a una variable

• Imprime esa variable en decimal, binario, y hex

Crea una variable de tipo string usando un string literal no interpretado (raw string literal). Imprímelo.

Usando iota, crea 4 constantes para los PRÓXIMOS 4 años. Imprime los valores de las constantes.

Quiz.

La computadora lee los programas de cierta forma, así como nosotros leemos libros de cierta forma. Cuando, como humanos, leemos libros, en culturas occidentales, lo hacemos de la parte frontal hacia la trasera del libro, de izquierda a derecha y de arriba hacia abajo. Cuando las computadoras leen el código de un programa, lo hacen de arriba hacia abajo. Esto es conocido como lectura en SECUENCIA y a su vez conocido como control de flujo secuencial. Hay otras dos declaraciones el cuál pueden afectar cómo la computadora lee el código. Una computadora puede encontrarse con un BUCLE o LOOP. Si se encuentra con uno de esos entrará en un bucle e iterará sobre él de una manera específica. Por eso es también conocido como control de flujo ITERATIVO. Finalmente, hay también control de flujo CONDICIONAL. Cuando la computadora se encuentra con una CONDICIÓN, como una "declaración de if" o una "declaración de switch" la computadora tomará acciones diferentes dependiendo de alguna condición. Entonces las tres formas en la que la computadora lee el código son: SECUENCIAL, LOOP, CONDICIONAL

• secuencia

• loop / iterativo

  • for loop

    • init, cond, post

  • bool (con while)

    • infinite

  • Con do-while

    • break

  • contínuo

  • anidado

• condicionales

  • Declaraciones switch / case / default

    • Sin caída predeterminada

    • Creando caída (creating fall-through)

    • Casos múltiples

    • Casos pueden ser expresiones

      • Evaluar a true, ellos corren

    • tipo

  • if

    • El operador de negación

      • !

    • Declaración de inicialización

      • if / else

      • if / else if / else

      • if / else if / else if / … / else

• Ciclo for

• inicialización, condition, post

código:

• init,condition, post https://play.golang.org/p/Wp5cT2IaMx

for: https://play.golang.org/p/A0GUGbqi9_

• Ciclo for

• Ciclos anidados

• código:

  • https://play.golang.org/p/fZlnUiWE-YT

  • https://play.golang.org/p/z0nR4dtQqYb

Hay tres formas con las que puedes construir ciclos for en Go - todas usan la palabra clave “for”:

• for init; condición; post { }

• for condición { }

• for { }

Respecto a la documentación de la declaración “for”

• Especificaciones del lenguaje

• effective go

Ciclo For

• break

• continue

Encontrando el resto, también conocido como modulus

• %

código:

• resto: https://play.golang.org/p/_BNQa7c8d8

break & continue: https://play.golang.org/p/uqh2SDENAE

Podemos usar impresión con formato para imprimir:

• Valor decimal con %d

• Valor hexadecimal con %#x

• Código unipoint %#U

• Una tabulación con  \t

• Una línea nueva con \n

Declaraciones If

• booleano

  • true

  • false

• El operador de negación

  • !

• Declaración de inicialización

• if / else

  • https://play.golang.org/p/GrPgcCVvFDv

• if / else if / else

  • https://play.golang.org/p/UjQZylQa8jM

• if / else if / else if / … / else

Iteramos para mejorar nuestras vidas. Esto se cumple para cualquier cosa que estemos haciendo. Escribimos código con errores antes de que escribamos código sin errores. Un profesor una vez llamó a esto “perfección de la imperfección.”  “Tú eres perfecto de la manera que eres, y siempre habrá oportunidad de mejora.” El punto es-  el código que escribimos para imprimir número pares puede se hecho de una mejor manera. Vamos a escribir código que es más legible. Esto servirá como una revisión de los conceptos que estamos aprendiendo: loops, condicionales, sentencia if y el operador módulo.

Declaración Switch

• Declaraciones switch / case / default

  • Sin caer en la declaración fall-through

  • Creando  fall-through

  • multiples casos

  • cases pueden ser expresiones

    • Evalúan a verdadero, corren.

Sentirse cómodo mientras leemos la documentación es importante. Dedicar un poco de tiempo para que veamos la documentación de Go es importante, te será útil ver cómo se lee e interpreta la misma y te hará sentir más cómodo con ella.

A qué evalúan las siguientes expresiones :

• fmt.Println(2 == 2 && 3 == 3)

• fmt.Println(true && false)

• fmt.Println(5 == 5 || 6 == 6)

• fmt.Println(true || false)

• fmt.Println(!true)

Imprime todos los números del 1 al 10,000

Imprime el rune code point de las letras del alfabeto en mayúsculas tres veces. La salida debe ser como esto:

65

U+0041 'A'

U+0041 'A'

U+0041 'A'

66

U+0042 'B'

U+0042 'B'

U+0042 'B'

… hasta el resto de letras en el alfabeto.

Crea un ciclo usando la siguiente sintaxis

• for condición { }

Haz que imprima los años que has vivido.

Crea un ciclo for usando esta sintaxis

• for { }

Haz que imprima los años que has vivido.

Imprime el resto o módulo, el cual es resultado de dividir entre 4 cada número en el rango de 10 y 100.

Crea un programa que muestre el “if statement” en acción.

Usando el ejercicio anterior, crea un programa que use “else if” y “else”.

Crea un programa que use una declaración switch sin expresión especificada.

Crea un programa que use una declaración switch con la expresión de switch especificada como una variable de TIPO string y el IDENTIFICADOR “deporteFav”.

Escribe el resultado de las siguientes declaraciones:

• fmt.Println(true && true)

• fmt.Println(true && false)

• fmt.Println(true || true)

• fmt.Println(true || false)

• fmt.Println(!true)

Los arreglos son mayormente usados como un bloque constructor en el lenguaje de programación Go. En algunas circunstancias, podríamos usar un array, pero en la mayoría de los casos la recomendación es usar slices en vez de arreglos.

UN SLICE almacena VALORES del mismo TIPO. Si quisiéramos almacenar todos nuestros números favoritos usamos un SLICE de ints. Si quisiera almacenar todas mis comidas favoritas usaría un SLICE de strings. Usaremos un LITERAL COMPUESTO para crear un slice. Un literal compuesto es cuando colocamos el TIPO seguido de LLAVES y luego colocamos los valores en el área dentro de las llaves.

Podemos iterar sobre los valores en un slice con la cláusula range. También le podemos agregar elementos a un slice mediante el uso del índice.

Podemos dividir un Slice, lo que quiere decir que podemos cortar y desechar partes de un slice. Hacemos esto con el operador dos puntos ( : ).

Para añadir valores a un slice, debemos usar la función especial integrada append. Esta función retorna un slice del mismo tipo.

Podemos eliminar elementos de un slice usando append y slicing (dividiendo). Este es un maravilloso y elegante ejemplo de porqué Go es súper cool y cómo provee facilidad de programación.

Los slices son construidos sobre los arreglos. Un slice es dinámico, así este crecerá en tamaño. Sin embargo, el arreglo subyacente, no crece en tamaño. Cuando creamos un slice, podemos podemos usar la función predefinida interna make para especificar que tan grande debería ser nuestro slice y también qué tan grande debería ser el arreglo subyacente. Esto puede mejorar un poco el desempeño del programa.

• make([]T, length, capacity)

• make([]int, 50, 100)

Un slice multidimensional es como una hoja de cálculo. Puede tener un slice de slices de algún tipo. Suena confuso? En este video lo aclaramos.

Subyacente a cada slice habrá un arreglo (array). Un slice es realmente una estructura de datos el cual tiene tres partes:

1. Un puntero a un arreglo

2. Longitud (len)

3. Capacidad (cap)

En este video, vamos a explorar la relación entre el slice y el arreglo subyacente.

Un mapa es un tipo de dato de almacenamiento llave-valor. Esto quiere decir que almacenas algún valor y accedes al mismo con una llave. Por ejemplo, podría almacenar el valor “numeroTel” y acceder a él con la llave “nombreAmigo”. De esta manera puedo ingresar el nombre de mi amigo y el mapa me retornará su número telefónico. La sintaxis para el mapa es map[llave]valor. La llave puede ser de cualquier tipo que permita comparación (por ejemplo, podría usar un string o un int, ya que puedo comparar si dos strings son iguales o si dos enteros son iguales. Es importante denotar que los mapas son desordenados. Si imprimes todas las llaves y valores de un mapa se hará de forma aleatoria. El idioma comma ok es también cubierto en este video. Un mapa es la estructura de datos perfecta cuando necesitas buscar datos de manera rápida.

Aquí mostramos como agregar un elemento a un mapa. También muestro cómo usar el ciclo for range para imprimir las llaves y valores de un mapa.

Borras un elemento de un mapa usando delete(<nombre del mapa>, “llave”). No arroja ningún error si usas usa llave que no existe. Para confirmar que borraste un par llave-valor, verifica que el par existe con el idioma coma ok.

• Usando un COMPOSITE LITERAL:

1. Crea un ARREGLO el cual tenga 5 VALORES de TIPO int

2. Asigna VALORES de cada posición dada por los índices.

• Itera con Range sobre el arreglo e imprime los valores.

• Usando impresión del paquete fmt

• Imprime el TIPO del arreglo

• Usando un COMPOSITE LITERAL:

1. Crea un SLICE de TIPO int

2. Asigna 10 VALORES

• Haz Range sobre el slice e imprime los valores.

• Usando format para imprimir

• Imprime el TIPO del slice

Usando el código del ejercicio anterior, usa SLICING para crear los siguientes nuevos slices el cual serán impresos:

• [42 43 44 45 46]

• [47 48 49 50 51]

• [44 45 46 47 48]

• [43 44 45 46 47]

Sigue los siguientes pasos:

• Comienza con este slice

  • x := []int{42, 43, 44, 45, 46, 47, 48, 49, 50, 51}

• Agrégale el siguiente valor

  • 52

• Imprime el slice

• En UNA DECLARACIÓN agrega al slice los siguientes valores

  • 53

  • 54

  • 55

• Imprime el slice

• Agregale al Slice los siguientes valores

  • y := []int{56, 57, 58, 59, 60}

• print out the slice

Para BORRAR de un slice, usamos APPEND en conjunto con SLICING(dividir). Para este ejercicio sigue los siguientes pasos:

• Comienza con un slice

  • x := []int{42, 43, 44, 45, 46, 47, 48, 49, 50, 51}

• Usa APPEND & SLICING para obtener los siguientes valores el cual se los debes asignar a una variable “y” y luego imprimir:

• [42, 43, 44, 48, 49, 50, 51]

Crea un slice para almacenar los nombres de todos los estados en los Estados Unidos de América. ¿Cuál es la longitud del slice? ¿Cuál es la capacidad del Slice? Imprime todos los valores con su  índice de posición, sin utilizar la cláusula range. Aquí la lista de los estados:

` Alabama`, ` Alaska`, ` Arizona`, ` Arkansas`, ` California`, ` Colorado`, ` Connecticut`, ` Delaware`, ` Florida`, ` Georgia`, ` Hawaii`, ` Idaho`, ` Illinois`, ` Indiana`, ` Iowa`, ` Kansas`, ` Kentucky`, ` Louisiana`, ` Maine`, ` Maryland`, ` Massachusetts`, ` Michigan`, ` Minnesota`, ` Mississippi`, ` Missouri`, ` Montana`, ` Nebraska`, ` Nevada`, ` New Hampshire`, ` New Jersey`, ` New Mexico`, ` New York`, ` North Carolina`, ` North Dakota`, ` Ohio`, ` Oklahoma`, ` Oregon`, ` Pennsylvania`, ` Rhode Island`, ` South Carolina`, ` South Dakota`, ` Tennessee`, ` Texas`, ` Utah`, ` Vermont`, ` Virginia`, ` Washington`, ` West Virginia`, ` Wisconsin`, ` Wyoming`,

Crear un slice de slice de string ([][]string). Almacena los siguientes valores en un slice multi-dimensional:

"Batman", "Jefe", "Vestido de negro"

"Robin", "Ayudante", "Vestido de colores"

Haz range sobre los registros, luego sobre los datos de cada registro.

Crea un mapa con una llave TIPO string el cual representa el “nombre_apellido” de una persona y un valor de TIPO []string el cual almacena sus cosas favoritas. Almacena tres registros en tu mapa. Imprime todos sus valores con su índice de posición en el slice.

`eduar_tua`, `computadoras`, `montaña`, `playa`

`carlos_ramon`, `leer`, `comprar`, `música`

`juan_bimba`, `helado`, `pintar`, `bailar`

Usando el código del ejemplo anterior, agrega un registro a tu mapa, ahora imprime el mapa usando “range”

Usando el código del ejemplo anterior, elimina un registro a tu mapa, ahora imprime el mapa usando “range”

Un Struct es un tipo de datos compuesto. (tipo de datos compuestos, también, tipos de datos agregados o tipo de datos complejos). Los structs nos permiten componer valores con otros valores de diferentes tipos.

Podemos tomar un struct y embeberlo en otro struct. Cuando haces esto el tipo interno es promovido al tipo externo.

Es bueno familiarizarse con el lenguaje usado para hablar del lenguaje Go. Las “especificaciones del lenguaje” pueden resultar difíciles de leer. Me parece bueno que invirtamos algo de tiempo leyendo las especificaciones juntos, de esa manera puedes ir ganando  un poco de habilidad de ser capaz de leer la documentación por tus propia cuenta.

También podemos crear structs anónimos. Un struct anónimo es un struct el cual no es asociado con un identificador en específico.

• Es todo acerca de tipo

  • Es go un lenguaje orientado a objetos? Go tiene aspectos de OOP. Pero es todo acerca de  TIPO. Creamos TIPOS en Go; TIPOS definidos por el usuario. Entonces podemos tener VALORES de ese tipo. Podemos asignar VALORES de un TIPO definido por el usuario a VARIABLES.

• Go es Orientado a Objectos

1. Encapsulación

   1. Estado ("campos")

   2. Comportamiento ("métodos")

   3. Exportado & No exportado; visible & no visible

2. Reusabilidad

   1. herencia ("tipos embebidos")

3. Polimorfismo

   1. interfaces

4. Overriding

   1. "promoción"

• OOP Tradicional

1. Clases

   1. Estructura de dato describiendo un tipo de objeto

   2. Puedes crear “instancias”/ "objetos" de la clase / prototipo

   3. Las clases almacenan ambos:

      1. estado / datos / campos

      2. comportamiento / métodos

   4. público / privado

2. Herencia

• En Go:

1. No creas clases, creas un TIPO

2. No creas instancias, creas un VALOR  de un TIPO

• Tipos definidos por el usuario

• Podemos declarar un nuevo tipo

• foo

  • El tipo subyacente de foo es int

  • Conversión a int

    • int(miEdad)

    • Convirtiendo tipo foo a tipo int

• ES UNA MALA PRÁCTICA HACER ALIAS DE TIPOS

  • Excepción:

    • Si necesitas asignarle métodos a un tipo

    • Ver el paquete de tiempo para un ejemplo godoc.org/time

      • type Duration int64

      • Duration tiene métodos asignados

• Tipos Nombrados vs Tipos Anónimos

• Tipos anónimos son indeterminados. Aún no han sido declarados como un tipo. El compilador tiene flexibilidad con tipos anónimos. Puedes asignar un tipo anónimo a una variable declarada de cierto tipo. Si la asignación puede ocurrir, el compilador hará el trabajo de determinar el tipo; el compilador hará una conversión implícita. No puedes asignar un tipo nombrado a un tipo de diferente nombre.

• Alineamiento arquitectónico y más

• Convención: organiza tus campos lógicamente. Legibilidad y claridad ganan en rendimiento como punto crítico. Go será de buen rendimiento. Ve primero por legibilidad. Sin embargo, si estás en un situación donde necesitas darle prioridad al rendimiento: agrega los campos del más grande al de menor tamaño, por ejemplo: int 64, int64, float32, bool