4.53 de 5
4.53
569 valoraciones en Udemy

Aprende a programar con Go (Golang)

Aprende a programar con el mejor lenguaje para construir software que es simple, confiable y eficiente.
Profesor:
Todd McLeod
19.381 Estudiantes apuntados
Spanish [Auto-generated]
Un curso completo para aprender a programar.
Para desarrolladores principiantes y experimentados.
Desde conceptos básicos hasta temas avanzados.
Concurrencia, canales, beckmarking
Testing, errror handling, documentation
Ejercicios prácticos con soluciones
Acceso a código base valioso
Curso verificado y provado por cientos de estudiantes.
Hemos enseñado a mas de 1.65 millones de estudiantes
Acceso al curso de por vida
100% satisfacción garantizada

Go es un lenguaje de programación open-source que hace muy fácil construir software que es simple, confiable y eficiente.

Go es una excelente selección como lenguaje de programación porque fue desarrollado por los mismos profesionales que crearon el lenguaje de programación C, Unix y UTF-8, elementos considerados unas de las contribuciones con mayor influencia en las ciencias de computación. Robert Griesemer, Rob Pike, and Ken Thompson crearon Go para que fuera un lenguaje moderno que use eficientemente los múltiples núcleos de un procesador, fácilmente implemente concurrencia, funcione en entornos distribuidos y permita a los programadores escribir de manera fácil programas – tiene una sintaxis muy amigable y fácil de adoptar por el usuario.

Go fue creado por iluminados en las ciencias de computación en una de las mejores, sino la mejor, empresa de ingeniería de software que ha existido – Google.

Las credenciales de Go son insuperables.

Pero, ¿Por qué creó Google un nuevo lenguaje?

Palabras de Google, “Go nace de la frustración con existentes lenguajes y entornos para sistemas de programación. La programación se había vuelto demasiado difícil y la elección de los idiomas era en parte culpable. Había que elegir entre una compilación eficiente, una ejecución eficiente o la facilidad de programación; los tres no estaban disponibles en el mismo lenguaje de moda. Los programadores que podían optaban por la facilidad sobre seguridad (safety) y la eficiencia al cambiar a lenguajes con sistemas de tipo dinámico como Python y JavaScript en lugar de C++ o, en menor medida, Java. Go es un intento de combinar la facilidad de programación de un lenguaje interpretado y tipado dinámico con la eficiencia y la seguridad de un lenguaje compilado y sistema de tipos estático. También pretende ser moderno, con soporte para computación en red y multinúcleo. Finalmente, trabajar con Go tiene la intención de ser rápido: debería tomar como mucho unos pocos segundos para construir un ejecutable grande en una sola computadora. Para cumplir con estos objetivos era necesario abordar una serie de cuestiones lingüísticas: un sistema de tipo expresivo pero ligero; concurrencia y garbage collertor; especificación de dependencia rígida; entre otras. Estas no pueden ser tratadas bien por bibliotecas o herramientas; se necesitaba un nuevo lenguaje “.

En mi opinión, Go es el mejor lenguaje de programación que puedes aprender hoy.

Venga y aprenda sobre el mejor lenguaje de programación jamás creado. Se irá con recursos y muestras de código para comenzar a hacer que todo su software y aplicaciones realmente funcionen.

Descripción del Curso

1
¿Por qué Go?
  • Go es uno de los lenguajes mejor pagados en América

    • Credenciales de Go

    • Google

    • Rob Pike

      • Unix, UTF-8

    • Robert Griesemer

      • Estudio bajo la tutela del creador de Pascal

    • Ken Thompson

      • Único responsable del diseño e implementación del sistema operativo original Unix.

      • Inventó el lenguaje de programación B, El predecesor directo del lenguaje C. Si, leíste bien - el inventó el lenguaje de programación que vino antes de C.

  • Por Qué Go

    • Compilación eficiente

      • Go crea programas compilados

        • Hay un garbage collector (GC)

        • No hay máquina virtual

    • Ejecución eficiente

    • Fácil de programar

  • El propósito de Go

  • Para que es bueno Go

    • Lo que hace Google / Servicios web en escala

      networking

      • http, tcp, udp

    • Concurrencia / paralelismo

    • Sistemas

    • Automatización, herramientas de línea de comandos

    • Principios Guía de diseño

    • Expresivo, exhaustivo, sofisticado.

    • Limpio, claro, fácil de leer.

    • Compañías usando Go

    • Google, YouTube, Google Confidential, Docker, Kubernetes, InfluxDB, Twitter, Apple

2
Como Tener Éxito

Entendiendo lo que ha convertido a algunos en  personas exitosas, puede ayudarnos a convertirnos en personas exitosas también. Éstos son principios que me han ayudado a ser más exitoso. Aprendiendo de otros y de experiencia propia. Los comparto para que te ayuden a ser también muy exitoso en el curso y en el día a día de nuestra vida cotidiana:

  • Enfocarse

    • Bill Gates y Warren Buffett

  • Ejecutar toda tarea tiempo

  • Firmeza y determinación

  • Bill Gates, “Ponte en frente de lo que viene y deja que te golpee.”

  • 7 Hábitos de personas efectivas

  • profesores

    • Gota a gota se llena el recipiente.

    • persistentemente, pacientemente, encontrarás el éxito

    • Cómo lograr ver el futuro

    • Técnica Pomodoro

    • Video de Richard St. John: 8 secrets of success

3
Recursos del Curso

Por favor lea todas las descripciones de los videos en esta guía. Esto forma parte del proceso de aprendizaje. Cuando lees la descripciones:

  • Los conceptos que estás aprendiendo se fortalecen

  • Te aprendes el material más rápido


Además, algunas veces proveo información adicional en las descripciones de los videos. Algunas veces grabo una clase, luego recuerdo que hay algún recurso u otro tipo de información, el cuál deberías saber. Algunos de esos recursos son bastante valiosos.


Ejemplos de Código

  • downloading zip

  • searching for code


Sitio Web de Caleb Doxsey y su libro

http://www.doxsey.net/

http://amzn.to/1OnFtPY


go by example

https://gobyexample.com/


Libro de Bill Kennedy

http://amzn.to/1kGGsPv


Libro de Donovan and Kernighan

http://amzn.to/1RIM5HP


Eduar Tua en YouTube

https://www.youtube.com/user/eduartua


En Twitter

https://twitter.com/eduartua


Archivos:  

  • Outline del curso: https://goo.gl/RxVxBJ

  • Recursos: https://goo.gl/3zbj7y

4
Documentación
  • Documentación oficial

    • especificaciones del languaje

    • effective go

  • golang.org vs godoc.org

    • golang.org

      • Librería estándar

      • src

    • godoc.org

      • Librería estándar Y paquetes de terceros

5
Acelerando el Aprendizaje

Puedes incrementar la velocidad de los videos que estás reproduciendo. No todos lo sabemos. Es algo que deberías incluir y practicar cuando comienzas tus cursos. Ver video con velocidad aumentada ayuda a muchos estudiantes. También si en el Outline del curso la tabla de contenido no está activada, puedes activarla yendo a vista y luego show document outline (mostrar outline del documento).

Variables, Valores y Tipos

1
Playground
2
Hola Mundo
  • 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

3
Operador de Declaración Corta
  • 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

4
La Palabra Clave Var
  • 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


5
Explorando Tipos de Datos
  • 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

6
Valor Cero
  • 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

7
El Paquete fmt
  • 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)

8
Creando Tu Propio Tipo
  • Podemos crear nuestro propio tipo de dato en Go

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


9
Conversión, no Casting

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.

Ejercicios - Ninja Nivel 1

1
Contribuye con tu Código

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.

2
Ejercicio Práctico #1
  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

3
Ejercicio Práctico #2
  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?


4
Ejercicio Práctico #3

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”

5
Ejercicio Práctico #4
  • 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”

6
Ejercicio Práctico #5

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”

7
Ejercicio Práctico #6

Fundamentos de Programación

1
Tipo Booleano
  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. >

2
Cómo Funciona la Computadora
  • 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"

3
Tipos Numéricos
  • 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

4
Tipo String Parte 1
  • 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


5
Tipo String Parte 2

Continuación de tipo string.

6
Sistemas Numéricos

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.

7
Constantes
  • 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

8
IOTA

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

9
Bit Shifting

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

Ejercicios Prácticos - Ninja Nivel 2

1
Ejercicio Práctico #1

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

2
Ejercicio Práctico #2

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

  1. ==

  2. <=

  3. >=

  4. !=

  5. <

  6. >

Imprime los valores de las variables.

3
Ejercicio Práctico #3

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

4
Ejercicio Práctico #4

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

5
Ejercicio Práctico #5

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

6
Ejercicio Práctico #6

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

7
Ejercicio Práctico #7

Quiz.

Control de Flujo

1
Entendiendo el Control de Flujo

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

2
Ciclo - init, condition, post
  • Ciclo for

  • inicialización, condition, post

código:

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

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

3
Ciclo - Ciclos Anidados
  • Ciclo for

  • Ciclos anidados

  • código:

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

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

4
Ciclo - Declaración For

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

5
Ciclo - Break y Continue

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

6
Ciclo - Imprimiendo Ascii

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

7
Condicional - Declaración if

Declaraciones If

  • booleano

    • true

    • false

  • El operador de negación

    • !

  • Declaración de inicialización

8
Condicional - if, else if, else
  • if / else

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

  • if / else if / else

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

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

9
Ciclo - Condicional - Módulo

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.

10
Condicional - Declaración Switch

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.

11
Condicional - Documentación de Switch

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.

12
Operadores Lógicos Condicionales

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)

Ejercicios - Ninja Nivel 3

1
Ejercicio Práctico #1

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

2
Ejercicio Práctico #2

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.

3
Ejercicio Práctico #3

Crea un ciclo usando la siguiente sintaxis

  • for condición { }

Haz que imprima los años que has vivido.

4
Ejercicio Práctico #4

Crea un ciclo for usando esta sintaxis

  • for { }

Haz que imprima los años que has vivido.

5
Ejercicio Práctico #5

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

6
Ejercicio Práctico #6

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

7
Ejercicio Práctico #7

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

8
Ejercicio Práctico #8

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

9
Ejercicio Práctico #9

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”.

10
Ejercicio Práctico #10

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)

Agrupando Datos

1
Arreglos (arrays)

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.

2
Slice - Literal Compuesto

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.

3
Slice - for range

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.

4
Slice - Dividiendo(Slicing) un slice

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

5
Slice - Añadiendo a un slice

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


6
Slice - Eliminado Elementos de un Slice

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.

7
Slice - make

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)


8
Slice - Slices Multidimensionales

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.


9
Slice - El Arreglo Subyacente

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.

10
Mapa (map) - Introducción

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.


11
Map - Agregar Elemento y Range

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.


12
Map - Borrar

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.


Ejercicios - Ninja Nivel 4

1
Ejercicio Práctico #1
  • 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

2
Ejercicio Práctico #2
  • 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

3
Ejercicio Práctico #3

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]

4
Ejercicio Práctico #4

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

5
Ejercicio Práctico #5

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]

6
Ejercicio Práctico #6

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`,


7
Ejercicio Práctico #7

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.

8
Ejercicio Práctico #8

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`

9
Ejercicio Práctico #9

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


10
Ejercicio Práctico #10

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


Structs

1
Struct

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.

2
Structs Embebidos

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

3
Leyendo la Documentación

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.

4
Structs Anónimos

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.

5
Aclaración
  • 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

Ejercicios - Ninja Nivel 5

1
Ejercicio Práctico #1

Crea tu propio tipo “persona” el cual tendrá un tipo subyacente tipo “struct” de manera que pueda almacenar la siguiente data:

  • Nombre

  • Apellido

  • Sabores de helados favoritos

Crea dos VALORES de TIPO persona. Imprime los valores, usa range sobre los elementos en el slice el cual almacena los valores de helados favoritos.

2
Ejercicio Práctico #2

Usa el código del ejemplo anterior y almacena los valores de tipo persona en un mapa con la llave apellido. Accede a cada valor en el mapa. Imprime los valores. Imprime también los valores haciendo range sobre el slice.


3
Ejercicio Práctico #3
  • Crea un nuevo tipo: vehículo.

    • El tipo subyacente es un struct.

    • Los campos:

      • puertas

      • color

  • Crea dos nuevos tipos: camión & sedán.

    • El tipo subyacente de cada uno de esos tipo es un struct.

    • Embebe el tipo “vehículo” en ambos camión y sedán.

    • Dale al camión el campo “cuatroRuedas” el cual será un booleano.

    • Dale al sedán el campo “lujoso” el cual será un booleano.

  • Con los structs vehículo, camión y sedán:

    • Usando un composite literal, crea un valor de tipo camión y asígnale valor a los campos.

    • Usando un composite literal, crea un valor de tipo sedan y asígnale valor a los campos.

  • Imprime cada uno de los valores.

  • Imprime un solo valor de cada uno de eso valores.

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.5
4.5 de 5
Calificaciones 569

Calificación Detallada

5 estrellas
310
4 estrellas
181
3 estrellas
58
2 estrellas
10
1 estrellas
10
ec75af33667b3081127a1a9d726963a9
DEBES ESTAR REGISTRADO PARA ACCEDER AL CURSO

Contenido

28 horas de video online
2 Articulos
Acceso sin limites
Acceso desde Móvil y Smart TV
Certificado de finalización

Newsletter