Aprende a programar con Go (Golang)
4.6 (572 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
19,390 students enrolled

Aprende a programar con Go (Golang)

Aprende a programar con el mejor lenguaje para construir software que es simple, confiable y eficiente.
4.6 (572 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
19,390 students enrolled
Last updated 11/2018
Spanish
Spanish [Auto-generated]
Current price: $23.99 Original price: $34.99 Discount: 31% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 27.5 hours on-demand video
  • 2 articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • 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
Course content
Expand all 204 lectures 27:34:33
+ Descripción del Curso
5 lectures 42:14
  • 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

Preview 19:44

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

Preview 09:34

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

Preview 04:55
  • 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

Documentación
05:29

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

Acelerando el Aprendizaje
02:32
+ Variables, Valores y Tipos
9 lectures 01:22:16
Playground
06:05
  • 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

Hola Mundo
14:06
  • 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

Operador de Declaración Corta
12:08
  • 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


La Palabra Clave Var
03:58
  • 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

Explorando Tipos de Datos
06:13
  • 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

Valor Cero
04:55
  • 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)

El Paquete fmt
22:26
  • Podemos crear nuestro propio tipo de dato en Go

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


Creando Tu Propio Tipo
07:23

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.

Conversión, no Casting
05:02
+ Ejercicios - Ninja Nivel 1
7 lectures 41:08

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.

Contribuye con tu Código
04:16
  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

Ejercicio Práctico #1
03:32
  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?


Ejercicio Práctico #2
06:17

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”

Ejercicio Práctico #3
03:59
  • 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”

Ejercicio Práctico #4
07:29

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”

Ejercicio Práctico #5
03:33
Ejercicio Práctico #6
12:02
+ Fundamentos de Programación
9 lectures 01:49:39
  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. >

Tipo Booleano
07:53
  • 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"

Cómo Funciona la Computadora
23:44
  • 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

Tipos Numéricos
11:57
  • 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


Tipo String Parte 1
14:42

Continuación de tipo string.

Tipo String Parte 2
13:50

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.

Sistemas Numéricos
17:54
  • 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

Constantes
07:13

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

IOTA
04:27

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

Bit Shifting
07:59
+ Ejercicios Prácticos - Ninja Nivel 2
7 lectures 21:44

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

Ejercicio Práctico #1
03:11

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

  1. ==

  2. <=

  3. >=

  4. !=

  5. <

  6. >

Imprime los valores de las variables.

Ejercicio Práctico #2
03:34

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

Ejercicio Práctico #3
01:11

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

Ejercicio Práctico #4
03:10

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

Ejercicio Práctico #5
01:56

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

Ejercicio Práctico #6
01:31

Quiz.

Ejercicio Práctico #7
07:11
+ Control de Flujo
12 lectures 01:12:32

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

Entendiendo el Control de Flujo
02:09
  • 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 - init, condition, post
05:22
  • Ciclo for

  • Ciclos anidados

  • código:

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

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

Ciclo - Ciclos Anidados
04:22

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 - Declaración For
08:35

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

Ciclo - Break y Continue
07:26

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

Ciclo - Imprimiendo Ascii
06:57

Declaraciones If

  • booleano

    • true

    • false

  • El operador de negación

    • !

  • Declaración de inicialización

Condicional - Declaración if
06:45
  • if / else

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

  • if / else if / else

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

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

Condicional - if, else if, else
04:25

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.

Ciclo - Condicional - Módulo
02:14

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.

Condicional - Declaración Switch
08:49

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.

Condicional - Documentación de Switch
08:41

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)

Operadores Lógicos Condicionales
06:47
+ Ejercicios - Ninja Nivel 3
10 lectures 23:45

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

Ejercicio Práctico #1
02:09

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.

Ejercicio Práctico #2
04:33

Crea un ciclo usando la siguiente sintaxis

  • for condición { }

Haz que imprima los años que has vivido.

Ejercicio Práctico #3
01:49

Crea un ciclo for usando esta sintaxis

  • for { }

Haz que imprima los años que has vivido.

Ejercicio Práctico #4
02:51

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

Ejercicio Práctico #5
02:50

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

Ejercicio Práctico #6
00:51

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

Ejercicio Práctico #7
01:43

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

Ejercicio Práctico #8
01:30

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

Ejercicio Práctico #9
02:38

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)

Ejercicio Práctico #10
02:51
+ Agrupando Datos
12 lectures 01:08:25

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.

Arreglos (arrays)
06:13

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.

Slice - Literal Compuesto
06:38

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.

Slice - for range
07:10

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

Slice - Dividiendo(Slicing) un slice
04:30

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


Slice - Añadiendo a un slice
05:38

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.

Slice - Eliminado Elementos de un Slice
04:54

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)


Slice - make
08:36

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.


Slice - Slices Multidimensionales
05:17

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.

Slice - El Arreglo Subyacente
06:10

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.


Mapa (map) - Introducción
06:25

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.


Map - Agregar Elemento y Range
02:46

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.


Map - Borrar
04:08
+ Ejercicios - Ninja Nivel 4
10 lectures 32:42
  • 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

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

Ejercicio Práctico #2
01:36

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]

Ejercicio Práctico #3
03:21

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

Ejercicio Práctico #4
02:50

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]

Ejercicio Práctico #5
03:32

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


Ejercicio Práctico #6
04:07

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.

Ejercicio Práctico #7
05:49

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`

Ejercicio Práctico #8
05:17

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


Ejercicio Práctico #9
01:55

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


Ejercicio Práctico #10
01:17
+ Structs
5 lectures 40:33

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.

Struct
04:42

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

Structs Embebidos
04:30

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.

Leyendo la Documentación
09:36

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.

Structs Anónimos
05:21
  • 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

Aclaración
16:24
Requirements
  • No se requieren conocimientos previos para tomar este curso. Este curso comienza desde el principio y te enseñará todo lo que necesitas.
Description

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.

Who this course is for:
  • Este es un curso de programación con el nivel de primer semestre de universidad.
  • Este curso es ideal para principiantes que quieran aprender aprogramar.
  • Este curso es perfecto para programadores con experiencia que quieran un introducción detallada al lenguage de programación Go
  • Este curso es ideal para programadores que quierean fortalecer sus conocimientos en programación.