Tutorial de Golang

Aprenderemos todos los conceptos básicos de Golang en este tutorial de Learn Go Language.

Cómo descargar e instalar GO

Paso 1) Vaya a https://golang.org/dl/. Descarga el binario para tu sistema operativo.

Paso 2) Double Haga clic en el instalador y haga clic en Ejecutar.

Paso 3) Haga clic en Siguiente

Paso 4) Seleccione la carpeta de instalación y haga clic en Siguiente.

Paso 5) Haga clic en Finalizar una vez que se complete la instalación.

Paso 6) Una vez completada la instalación podrás verificarla abriendo el terminal y escribiendo

go version

Esto mostrará la versión de go instalada.

Su programa First Go: ¡Go Hello World!

Crea una carpeta llamada StudyGo. En este tutorial de lenguaje Go, crearemos nuestros programas Go dentro de esta carpeta. Los archivos Go se crean con la extensión .ir. Puede ejecutar programas Go usando la sintaxis

go run <filename>

Cree un archivo llamado first.go, agregue el siguiente código y guárdelo.

package main
import ("fmt")

func main() {
	fmt.Println("Hello World! This is my first Go program\n")
}

Navegue a esta carpeta en su terminal. Ejecute el programa usando el comando

Ve a correr primero.

Puedes ver la impresión de salida.

Hello World! This is my first Go program

Ahora analicemos el programa anterior.

paquete principal: cada programa de Go Language debe comenzar con un nombre de paquete. Go nos permite usar paquetes en otros programas de Go y, por lo tanto, admite la reutilización del código. La ejecución de un programa Go comienza con el código dentro del paquete llamado main.

import fmt: importa el paquete fmt. Este paquete implementa las funciones de E/S.

func main(): esta es la función desde la cual comienza la ejecución del programa. La función principal siempre debe colocarse en el paquete principal. En main(), puedes escribir el código dentro de {}.

fmt.Println: esto imprimirá el texto en la pantalla mediante la función Println de fmt.

Nota: En las secciones siguientes de este tutorial de Go, cuando mencionas ejecutar/ejecutar el código, significa guardar el código en un archivo con extensión .go y ejecutarlo usando la sintaxis.

    go run <filename>

Tipos de datos

Los tipos (tipos de datos) representan el tipo de valor almacenado en una variable, el tipo de valor que devuelve una función, etc.

Hay tres tipos básicos en Go Language

Tipos numéricos – Representan valores numéricos que incluyen valores enteros, de punto flotante y complejos. Los distintos tipos numéricos son:

int8: enteros de 8 bits con signo.

int16: enteros de 16 bits con signo.

int32: enteros de 32 bits con signo.

int64: enteros de 64 bits con signo.

uint8: enteros sin signo de 8 bits.

uint16: enteros sin signo de 16 bits.

uint32: enteros sin signo de 32 bits.

uint64: enteros sin signo de 64 bits.

float32: números de coma flotante de 32 bits.

float64: números de coma flotante de 64 bits.

complex64 – tiene partes reales e imaginarias float32.

complex128 – tiene partes reales e imaginarias float32.

Tipos de cuerdas – Representa una secuencia de bytes (caracteres). Se pueden realizar varias operaciones con cadenas, como concatenación de cadenas, extracción de subcadenas, etc.

Tipos booleanos – Representa 2 valores, verdadero o falso.

Variables

Las variables apuntan a una ubicación de memoria que almacena algún tipo de valor. El parámetro de tipo (en la sintaxis siguiente) representa el tipo de valor que se puede almacenar en la ubicación de la memoria.

La variable se puede declarar usando la sintaxis

    var <variable_name> <type>

Una vez que declara una variable de un tipo, puede asignar la variable a cualquier valor de ese tipo.

También puede dar un valor inicial a una variable durante la declaración misma usando

    var <variable_name> <type> = <value>

Si declara la variable con un valor inicial, vaya e infiera el tipo de variable a partir del tipo de valor asignado. Entonces puedes omitir el tipo durante la declaración usando la sintaxis

    var <variable_name> = <value>

Además, puedes declarar múltiples variables con la sintaxis

    var <variable_name1>, <variable_name2>  = <value1>, <value2>

El siguiente programa en este tutorial de Go tiene algunos ejemplos de declaraciones de variables en Golang.

 
package main
import "fmt"

func main() {
    //declaring a integer variable x
    var x int
    x=3 //assigning x the value 3 
    fmt.Println("x:", x) //prints 3
    
    //declaring a integer variable y with value 20 in a single statement and prints it
    var y int=20
    fmt.Println("y:", y)
    
    //declaring a variable z with value 50 and prints it
    //Here type int is not explicitly mentioned 
    var z=50
    fmt.Println("z:", z)
    
    //Multiple variables are assigned in single line- i with an integer and j with a string
    var i, j = 100,"hello"
    fmt.Println("i and j:", i,j)
}

La salida será

x: 3
y: 20
z: 50
i and j: 100 hello

Go Language también proporciona una manera fácil de declarar las variables con valor omitiendo la palabra clave var usando

    <variable_name> := <value>

Tenga en cuenta que utilizó := en lugar de =. No puedes usar := solo para asignar un valor a una variable que ya está declarada. := se utiliza para declarar y asignar valor.

Crea un archivo llamado allow.go con el siguiente código

package main
import ("fmt")

func main() {
	a := 20
	fmt.Println(a)

	//gives error since a is already declared
	a := 30
	fmt.Println(a)
}

Ejecute go run asignar.go para ver el resultado como

./assign.go:7:4: no new variables on left side of :=		

Las variables declaradas sin un valor inicial tendrán 0 para tipos numéricos, falso para booleanos y cadena vacía para cadenas.

Constantes

Las variables constantes son aquellas variables cuyo valor no se puede cambiar una vez asignado. Una constante en el lenguaje de programación Go se declara utilizando la palabra clave "const"

Crea un archivo llamado constant.go y con el siguiente código

package main
import ("fmt")

func main() {
	const b =10
	fmt.Println(b)
	b = 30
	fmt.Println(b)
}

Ejecute go run constante.go para ver el resultado como

.constant.go:7:4: cannot assign to b

Para ejemplos de bucles

Los bucles se utilizan para ejecutar un bloque de declaraciones repetidamente según una condición. La mayoría de los lenguajes de programación proporcionan 3 tipos de bucles: for, while y do while. Pero el lenguaje de programación Go solo admite bucles.

La sintaxis de un bucle for de Golang es

for initialisation_expression; evaluation_expression; iteration_expression{
   // one or more statement
}

La expresión_inicialización se ejecuta primero (y solo una vez) en el bucle for de Golang.

Luego se evalúa la expresión_evaluación y, si es verdadera, se ejecuta el código dentro del bloque.

Se ejecuta el ID de iteration_expression y se vuelve a evaluar la expresión_evaluación. Si es cierto, el bloque de instrucciones se ejecuta nuevamente. Esto continuará hasta que la expresión_evaluación se vuelva falsa.

Copie el siguiente programa en un archivo y ejecútelo para ver Golang for loop imprimiendo números del 1 al 5

package main
import "fmt"

func main() {  
var i int
for i = 1; i <= 5; i++ {
fmt.Println(i)
    }
}

La salida es

1
2
3
4
5

Si mas

Si no, es una declaración condicional. La sinaxis es

if condition{
// statements_1
}else{
// statements_2
}

Aquí se evalúa la condición y, si es verdadera, se ejecutarán las declaraciones_1; de lo contrario, se ejecutará la declaración_2.

También puedes usar la declaración if sin más. También puede tener declaraciones if else encadenadas. Los siguientes programas explicarán más sobre if else.

Ejecute el siguiente programa. Comprueba si un número, x, es menor que 10. Si es así, imprimirá "x es menor que 10".

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x < 10
        fmt.Println("x is less than 10")
    } 
}

Aquí, dado que el valor de x es mayor que 10, la declaración dentro de la condición del bloque if no se ejecutará.

Ahora vea el siguiente programa. En este tutorial del lenguaje de programación Go, tenemos un bloque else que se ejecutará si falla la evaluación if.

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else {
        //Executes if x >= 10
        fmt.Println("x is greater than or equals 10")
    }
}

Este programa le dará resultados.

x is greater than or equals 10

Ahora, en este tutorial de Go, veremos un programa con múltiples bloques if else (encadenados if else). Ejecute el siguiente ejemplo de Go. Comprueba si un número es menor que 10, entre 10 y 90 o mayor que 90.

package main
import "fmt"

func main() {  
    var x = 100
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else if x >= 10 && x <= 90 {
        //Executes if x >= 10 and x<=90
        fmt.Println("x is between 10 and 90")
    } else {
        //Executes if both above cases fail i.e x>90
        fmt.Println("x is greater than 90")
    }
}

Aquí primero la condición if verifica si x es menor que 10 y no lo es. Entonces verifica la siguiente condición (si no) si está entre 10 y 90, lo cual también es falso. Luego ejecuta el bloque en la sección else que proporciona la salida

x is greater than 90

Interruptor

Switch es otra declaración condicional. Las declaraciones de cambio evalúan una expresión y el resultado se compara con un conjunto de valores disponibles (casos). Una vez que se encuentra una coincidencia, se ejecutan las declaraciones asociadas con esa coincidencia (caso). Si no se encuentra ninguna coincidencia, no se ejecutará nada. También puede agregar un caso predeterminado para cambiar que se ejecutará si no se encuentran otras coincidencias. La sintaxis del interruptor es

switch expression {
    case value_1:
        statements_1
    case value_2:
        statements_2
    case value_n:
        statements_n
    default:
        statements_default
    }

Aquí el valor de la expresión se compara con los valores de cada caso. Una vez que se encuentra una coincidencia, se ejecutan las declaraciones asociadas con ese caso. Si no se encuentra ninguna coincidencia, se ejecutan las declaraciones de la sección predeterminada.

Ejecute el siguiente programa

package main
import "fmt"

func main() {  
    a,b := 2,1
    switch a+b {
    case 1:
        fmt.Println("Sum is 1")
    case 2:
        fmt.Println("Sum is 2")
    case 3:
        fmt.Println("Sum is 3")
    default:
        fmt.Println("Printing default")
    }
}

Obtendrá la salida como

Sum is 3		

Cambie el valor de a y b a 3 y el resultado será

Printing default

También puede tener varios valores en un caso separándolos con una coma.

Matrices

La matriz representa una secuencia nombrada de tamaño fijo de elementos del mismo tipo. No puede tener una matriz que contenga números enteros y caracteres. No puede cambiar el tamaño de una matriz una vez que define el tamaño.

La sintaxis para declarar una matriz es

var arrayname [size] type

A cada elemento de la matriz se le puede asignar un valor usando la sintaxis

arrayname [index] = value

El índice de matriz comienza desde 0 a tamaño-1.

Puede asignar valores a elementos de matriz durante la declaración usando la sintaxis

arrayname := [size] type {value_0,value_1,…,value_size-1} 

También puede ignorar el parámetro de tamaño al declarar la matriz con valores reemplazando tamaño con ... y el compilador encontrará la longitud a partir del número de valores. La sintaxis es

arrayname :=  […] type {value_0,value_1,…,value_size-1}

Puede encontrar la longitud de la matriz usando la sintaxis

len(arrayname)

Ejecute el siguiente ejemplo de Go para comprender la matriz

package main
import "fmt"

func main() {  
    var numbers [3] string //Declaring a string array of size 3 and adding elements 
    numbers[0] = "One"
    numbers[1] = "Two"
    numbers[2] = "Three"
    fmt.Println(numbers[1]) //prints Two
    fmt.Println(len(numbers)) //prints 3
    fmt.Println(numbers) // prints [One Two Three]

    directions := [...] int {1,2,3,4,5} // creating an integer array and the size of the array is defined by the number of elements 
    fmt.Println(directions) //prints [1 2 3 4 5]
    fmt.Println(len(directions)) //prints 5

    //Executing the below commented statement prints invalid array index 5 (out of bounds for 5-element array)
    //fmt.Println(directions[5]) 
}

Salida

Two
3
[One Two Three]
[1 2 3 4 5]
5

Función Golang Slice y Append

Un sector es una porción o segmento de una matriz. O es una vista o vista parcial de una matriz subyacente a la que apunta. Puede acceder a los elementos de un sector utilizando el nombre del sector y el número de índice tal como lo hace en una matriz. No puede cambiar la longitud de una matriz, pero puede cambiar el tamaño de un segmento.

Los contenidos de un segmento son en realidad punteros a los elementos de una matriz. Significa Si cambia cualquier elemento en un segmento, el contenido de la matriz subyacente también se verá afectado.

La sintaxis para crear un sector es

var slice_name [] type = array_name[start:end]

Esto creará un segmento llamado nombre_sector a partir de una matriz llamada nombre_matriz con los elementos en el índice de principio a fin-1.

Ahora, en este tutorial de Golang, ejecutaremos el siguiente programa. El programa creará una porción de la matriz y la imprimirá. Además, puede ver que modificar el contenido del segmento modificará la matriz real.

package main
import "fmt"

func main() {  
    // declaring array
    a := [5] string {"one", "two", "three", "four", "five"}
    fmt.Println("Array after creation:",a)

    var b [] string = a[1:4] //created a slice named b
    fmt.Println("Slice after creation:",b)

    b[0]="changed" // changed the slice data
    fmt.Println("Slice after modifying:",b)
    fmt.Println("Array after slice modification:",a)
}

Esto imprimirá el resultado como

Array after creation: [one two three four five]
Slice after creation: [two three four]
Slice after modifying: [changed three four]
Array after slice modification: [one changed three four five]

Hay ciertas funciones como Golang len, Golang append que puedes aplicar en sectores

len(nombre_porción) – devuelve la longitud del segmento

agregar(nombre_porción, valor_1, valor_2) – Golang append se utiliza para agregar valor_1 y valor_2 a un segmento existente.

agregar(slice_nale1,slice_name2…) – añade nombre_porción2 a nombre_porción1

Ejecute el siguiente programa.

package main
import "fmt"

func main() {  
	a := [5] string {"1","2","3","4","5"}
	slice_a := a[1:3]
	b := [5] string {"one","two","three","four","five"}
	slice_b := b[1:3]

    fmt.Println("Slice_a:", slice_a)
    fmt.Println("Slice_b:", slice_b)
    fmt.Println("Length of slice_a:", len(slice_a))
    fmt.Println("Length of slice_b:", len(slice_b))

    slice_a = append(slice_a,slice_b...) // appending slice
    fmt.Println("New Slice_a after appending slice_b :", slice_a)
    
    slice_a = append(slice_a,"text1") // appending value
    fmt.Println("New Slice_a after appending text1 :", slice_a)
}

La salida será

Slice_a: [2 3]
Slice_b: [two three]
Length of slice_a: 2
Length of slice_b: 2
New Slice_a after appending slice_b : [2 3 two three]
New Slice_a after appending text1 : [2 3 two three text1]

El programa primero crea 2 cortes e imprime su longitud. Luego agregó un segmento a otro y luego agregó una cadena al segmento resultante.

Funciones

Una función representa un bloque de declaraciones que realiza una tarea específica. Una declaración de función nos dice el nombre de la función, el tipo de retorno y los parámetros de entrada. La definición de función representa el código contenido en la función. La sintaxis para declarar la función es

func function_name(parameter_1 type, parameter_n type) return_type {
//statements
}

Los parámetros y tipos de retorno son opcionales. Además, puede devolver varios valores de una función.

Ahora, en este tutorial de Golang, ejecutemos el siguiente ejemplo de Golang. Aquí, la función denominada calc aceptará dos números y realizará la suma y la resta y devolverá ambos valores.

package main
import "fmt"

//calc is the function name which accepts two integers num1 and num2
//(int, int) says that the function returns two values, both of integer type.
func calc(num1 int, num2 int)(int, int) {  
    sum := num1 + num2
    diff := num1 - num2
    return sum, diff
}

func main() {  
    x,y := 15,10

    //calls the function calc with x and y an d gets sum, diff as output
    sum, diff := calc(x,y) 
    fmt.Println("Sum",sum)
    fmt.Println("Diff",diff) 
}

La salida será

Sum 25
Diff 5

Paquetes

Los paquetes se utilizan para organizar el código. En un proyecto grande, no es factible escribir código en un solo archivo. El lenguaje de programación Go nos permite organizar el código en diferentes paquetes. Esto aumenta la legibilidad y reutilización del código. Un programa Go ejecutable debe contener un paquete llamado main y la ejecución del programa comienza desde la función llamada main. Puede importar otros paquetes en nuestro programa usando la sintaxis

import package_name

Veremos y discutiremos en este tutorial de Golang, cómo crear y usar paquetes en el siguiente ejemplo de Golang.

Paso 1) Cree un archivo llamado package_example.go y agregue el siguiente código

package main
import "fmt"
//the package to be created
import "calculation"

func main() {  
	x,y := 15,10
	//the package will have function Do_add()
sum := calculation.Do_add(x,y)
fmt.Println("Sum",sum) 
}

En el programa anterior, fmt es un paquete que el lenguaje de programación Go nos proporciona principalmente para fines de E/S. Además, puede ver un paquete llamado cálculo. Dentro de main() puedes ver una suma de pasos: = cálculo.Do_add(x,y). Significa que estás invocando la función Do_add desde el cálculo del paquete.

Paso 2) Primero, debe crear el cálculo del paquete dentro de una carpeta con el mismo nombre en la carpeta src de go. La ruta instalada de go se puede encontrar en la variable PATH.

Para mac, busque la ruta ejecutando echo $PATH

Entonces la ruta es /usr/local/go

Para Windows, busque la ruta ejecutando echo %GOROOT%

Aquí la ruta es C:\Go\

Paso 3) Vaya a la carpeta src (/usr/local/go/src para Mac y C:\Go\src para Windows). Ahora, según el código, el nombre del paquete es cálculo. Go requiere que el paquete se coloque en un directorio con el mismo nombre dentro del directorio src. Cree un directorio llamado cálculo en la carpeta src.

Paso 4) Cree un archivo llamado calc.go (puede darle cualquier nombre, pero el nombre del paquete en el código importa. Aquí debería estar el cálculo) dentro del directorio de cálculo y agregue el siguiente código

package calculation
  
func Do_add(num1 int, num2 int)(int) {
    sum := num1 + num2
    return sum
}

Paso 5) Ejecute el comando go install desde el directorio de cálculo que compilará calc.go.

Paso 6) Ahora regrese a package_example.go y ejecute go run package_example.go. La salida será Sum 25.

Tenga en cuenta que el nombre de la función Do_add comienza con una letra mayúscula. Esto se debe a que en Go, si el nombre de la función comienza con una letra mayúscula, significa que otros programas pueden verla (acceder), de lo contrario, otros programas no pueden acceder a ella. Si el nombre de la función fuera do_add, entonces habría recibido el error

no se puede hacer referencia al nombre no exportado cálculo.calc.

Aplazar y apilar aplazamientos

Las declaraciones diferidas se utilizan para diferir la ejecución de una llamada a función hasta que la función que contiene la declaración diferida complete su ejecución.

Aprendamos esto con un ejemplo:

package main
import "fmt"

func sample() {  
    fmt.Println("Inside the sample()")
}
func main() {  
    //sample() will be invoked only after executing the statements of main()
    defer sample()
    fmt.Println("Inside the main()")
}

La salida será

Inside the main()
Inside the sample()

Aquí la ejecución de sample() se difiere hasta que se completa la ejecución de la función adjunta (main()).

Apilar aplazar consiste en utilizar múltiples declaraciones de aplazar. Suponga que tiene varias declaraciones diferidas dentro de una función. Go coloca todas las llamadas a funciones diferidas en una pila y, una vez que regresa la función adjunta, las funciones apiladas se ejecutan en el Orden último en entrar, primero en salir (LIFO). Puedes ver esto en el siguiente ejemplo.

Ejecute el siguiente código

package main
import "fmt"

func display(a int) {  
    fmt.Println(a)
}
func main() {  
    defer display(1)
    defer display(2)
    defer display(3)
    fmt.Println(4)
}

La salida será

4
3
2
1			

Aquí el código dentro de main() se ejecuta primero, y luego las llamadas a funciones diferidas se ejecutan en orden inverso, es decir, 4, 3,2,1.

Punteros

Antes de explicar los punteros, analicemos primero el operador "&". El operador "&" se utiliza para obtener la dirección de una variable. Esto significa que "&a" imprimirá la dirección de memoria de la variable a.

En este tutorial de Golang, ejecutaremos el siguiente programa para mostrar el valor de una variable y la dirección de esa variable.

package main
import "fmt"

func main() {
	a := 20
	fmt.Println("Address:",&a)
	fmt.Println("Value:",a)
}

El resultado será

Address: 0xc000078008
Value: 20

Una variable de puntero almacena la dirección de memoria de otra variable. Puede definir un puntero usando la sintaxis

	var variable_name *type

El asterisco (*) representa que la variable es un puntero. Comprenderá más ejecutando el siguiente programa.

package main
import "fmt"

func main() {
	//Create an integer variable a with value 20
	a := 20
	
	//Create a pointer variable b and assigned the address of a
	var b *int = &a

	//print address of a(&a) and value of a  
	fmt.Println("Address of a:",&a)
	fmt.Println("Value of a:",a)

	//print b which contains the memory address of a i.e. &a
	fmt.Println("Address of pointer b:",b)

	//*b prints the value in memory address which b contains i.e. the value of a
	fmt.Println("Value of pointer b",*b)

	//increment the value of variable a using the variable b
	*b = *b+1

	//prints the new value using a and *b
	fmt.Println("Value of pointer b",*b)
	fmt.Println("Value of a:",a)}

La salida será

Address of a: 0x416020
Value of a: 20
Address of pointer b: 0x416020
Value of pointer b 20
Value of pointer b 21
Value of a: 21

Estructuras

Una estructura es un tipo de datos definido por el usuario que a su vez contiene un elemento más del mismo o diferente tipo.

Usar una estructura es un proceso de 2 pasos.

Primero, cree (declare) un tipo de estructura.

En segundo lugar, cree variables de ese tipo para almacenar valores.

Las estructuras se utilizan principalmente cuando se desea almacenar datos relacionados juntos.

Considere una información del empleado que tenga nombre, edad y dirección. Puedes manejar esto de 2 maneras.

Cree 3 matrices: una matriz almacena los nombres de los empleados, otra almacena la edad y la tercera almacena la edad.

Declare un tipo de estructura con 3 campos: nombre, dirección y edad. Cree una matriz de ese tipo de estructura donde cada elemento sea un objeto de estructura que tenga nombre, dirección y edad.

El primer enfoque no es eficiente. En este tipo de escenarios, las estructuras son más convenientes.

La sintaxis para declarar una estructura es

type structname struct {
   variable_1 variable_1_type
   variable_2 variable_2_type
   variable_n variable_n_type
}

Un ejemplo de declaración de estructura es

type emp struct {
    name string
    address string
    age int
}

Aquí se crea un nuevo tipo definido por el usuario llamado emp. Ahora puedes crear variables del tipo emp usando la sintaxis

	var variable_name struct_name

Un ejemplo es

var empdata1 emp 

Puede establecer valores para empdata1 como

empdata1.name = "John"
	empdata1.address = "Street-1, Bangalore"
	empdata1.age = 30

También puede crear una variable de estructura y asignar valores mediante

empdata2 := emp{"Raj", "Building-1, Delhi", 25}

Aquí es necesario mantener el orden de los elementos. Raj se asignará al nombre, el siguiente elemento a la dirección y el último a la edad.

Ejecute el siguiente código

package main
import "fmt"

//declared the structure named emp
type emp struct {
        name string
        address string
        age int
}       

//function which accepts variable of emp type and prints name property
func display(e emp) {
          fmt.Println(e.name)
}

func main() {
// declares a variable, empdata1, of the type emp
var empdata1 emp
//assign values to members of empdata1
empdata1.name = "John"
empdata1.address = "Street-1, London"
empdata1.age = 30

//declares and assign values to variable empdata2 of type emp
empdata2 := emp{"Raj", "Building-1, Paris", 25}

//prints the member name of empdata1 and empdata2 using display function
display(empdata1)
display(empdata2)
}

Salida

John
Raj

Métodos (no funciones)

Un método es una función con un argumento receptor. ArchiTécnicamente, está entre la palabra clave func y el nombre del método. La sintaxis de un método es

func (variable variabletype) methodName(parameter1 paramether1type) {  
}

Convirtamos el programa de ejemplo anterior para usar métodos en lugar de funciones.

package main
import "fmt"

//declared the structure named emp
type emp struct {
    name string
    address string
    age int
}

//Declaring a function with receiver of the type emp
func(e emp) display() {
    fmt.Println(e.name)
}

func main() {
    //declaring a variable of type emp
    var empdata1 emp
    
    //Assign values to members
    empdata1.name = "John"
    empdata1.address = "Street-1, Lodon"
    empdata1.age = 30

    //declaring a variable of type emp and assign values to members
    empdata2 := emp {
        "Raj", "Building-1, Paris", 25}

    //Invoking the method using the receiver of the type emp
   // syntax is variable.methodname()
    empdata1.display()
    empdata2.display()
}

Go no es un lenguaje orientado a objetos y no tiene el concepto de clase. Los métodos dan una idea de lo que se hace en los programas orientados a objetos donde las funciones de una clase se invocan usando la sintaxis nombreobjeto.nombrefunción()

Concurrencia

Go admite la ejecución simultánea de tareas, es decir, puede ejecutar varias tareas simultáneamente. Es diferente del concepto de paralelismo. En el paralelismo, una tarea se divide en pequeñas subtareas y se ejecutan en paralelo, pero en la concurrencia, se ejecutan varias tareas simultáneamente. La concurrencia se logra en Go mediante Goroutines y Canales.

gorutinas

Una gorutina es una función que puede ejecutarse simultáneamente con otras funciones. Por lo general, cuando se invoca una función, el control se transfiere a la función llamada y, una vez completada la ejecución, el control regresa a la función que llama. La función que llama luego continúa su ejecución. La función que llama espera a que la función invocada complete la ejecución antes de continuar con el resto de las declaraciones.

Pero en el caso de goroutine, la función que llama no esperará a que se complete la ejecución de la función invocada. Continuará ejecutándose con las siguientes declaraciones. Puede tener varias gorutinas en un programa.

Además, el programa principal saldrá una vez que complete la ejecución de sus declaraciones y no esperará a que se completen las rutinas invocadas.

Goroutine se invoca utilizando la palabra clave go seguida de una llamada a función.

Ejemplo

go add(x,y)

Comprenderá las gorutinas con los siguientes ejemplos de Golang. Ejecute el siguiente programa

package main
import "fmt"
    
func display() {
	for i:=0; i<5; i++ {
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	//The main() continues without waiting for display()
	for i:=0; i<5; i++ {
		fmt.Println("In main")
	}
}

La salida será

In main
In main
In main
In main
In main

Aquí el programa principal completó la ejecución incluso antes de que comenzara la rutina. display() es una rutina que se invoca usando la sintaxis

go function_name(parameter list)

En el código anterior, main() no espera a que se complete display(), y main() completó su ejecución antes de que display() ejecutara su código. Entonces la declaración de impresión dentro de display() no se imprimió.

Ahora modificamos el programa para imprimir también las declaraciones desde display(). Agregamos un retraso de 2 segundos en el bucle for de main() y un retraso de 1 segundo en el bucle for de display().

package main
import "fmt"
import "time"
    
func display() {
	for i:=0; i<5; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	for i:=0; i<5; i++ {
		time.Sleep(2 * time.Second)
		fmt.Println("In main")
	}
}

La salida será algo similar a

In display
In main
In display
In display
In main
In display
In display
In main
In main
In main

Aquí puede ver que ambos bucles se ejecutan de forma superpuesta debido a la ejecución simultánea.

Canales

Los canales son una forma para que las funciones se comuniquen entre sí. Se puede pensar como un medio donde una rutina coloca los datos y otra rutina accede a ellos en el servidor Golang.

Un canal se puede declarar con la sintaxis

channel_variable := make(chan datatype)

Ejemplo:

	ch := make(chan int)

Puedes enviar datos a un canal usando la sintaxis

channel_variable <- variable_name

Ejemplo

    ch <- x

Puede recibir datos de un canal usando la sintaxis

    variable_name := <- channel_variable

Ejemplo

   y := <- ch

En los ejemplos de goroutine del lenguaje Go anteriores, ha visto que el programa principal no espera a la goroutine. Pero ese no es el caso cuando se trata de canales. Supongamos que si una gorutina envía datos al canal, main() esperará la declaración que recibe los datos del canal hasta que obtenga los datos.

Verá esto en los siguientes ejemplos de lenguaje Go. Primero, escriba una rutina normal y observe el comportamiento. Luego modifique el programa para usar canales y vea el comportamiento.

Ejecute el siguiente programa

package main
import "fmt"
import "time"
    
func display() {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
}

func main() {
	go display()
	fmt.Println("Inside main()")
}

La salida será

Inside main()

main() finalizó la ejecución y salió antes de que se ejecutara la rutina. Entonces la impresión dentro de display() no se ejecutó.

Ahora modifique el programa anterior para usar canales y ver el comportamiento.

package main
import "fmt"
import "time"
    
func display(ch chan int) {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
	ch <- 1234
}

func main() {
	ch := make(chan int) 
	go display(ch)
	x := <-ch
	fmt.Println("Inside main()")
	fmt.Println("Printing x in main() after taking from channel:",x)
}

La salida será

Inside display()
Inside main()
Printing x in main() after taking from channel: 1234

Aquí lo que sucede es que main() al llegar a x := <-ch esperará datos en el canal ch. El display() tiene una espera de 5 segundos y luego envía datos al canal ch. El main() al recibir los datos del canal se desbloquea y continúa su ejecución.

El remitente que envía datos al canal puede informar a los receptores que no se agregarán más datos al canal al cerrarlo. Esto se utiliza principalmente cuando se utiliza un bucle para enviar datos a un canal. Un canal se puede cerrar usando

close(channel_name)

Y en el extremo del receptor, es posible verificar si el canal está cerrado usando una variable adicional mientras se obtienen datos del canal usando

variable_name, status := <- channel_variable

Si el estado es Verdadero, significa que recibió datos del canal. Si es falso, significa que estás intentando leer desde un canal cerrado.

También puede utilizar canales para la comunicación entre gorutinas. Es necesario utilizar 2 gorutinas: una envía datos al canal y la otra recibe los datos del canal. Vea el programa a continuación

package main
import "fmt"
import "time"

//This subroutine pushes numbers 0 to 9 to the channel and closes the channel
func add_to_channel(ch chan int) {	
	fmt.Println("Send data")
	for i:=0; i<10; i++ {
		ch <- i //pushing data to channel
	}
	close(ch) //closing the channel

}

//This subroutine fetches data from the channel and prints it.
func fetch_from_channel(ch chan int) {
	fmt.Println("Read data")
	for {
		//fetch data from channel
x, flag := <- ch

		//flag is true if data is received from the channel
//flag is false when the channel is closed
if flag == true {
			fmt.Println(x)
		}else{
			fmt.Println("Empty channel")
			break	
		}	
	}
}

func main() {
	//creating a channel variable to transport integer values
	ch := make(chan int)

	//invoking the subroutines to add and fetch from the channel
	//These routines execute simultaneously
	go add_to_channel(ch)
	go fetch_from_channel(ch)

	//delay is to prevent the exiting of main() before goroutines finish
	time.Sleep(5 * time.Second)
	fmt.Println("Inside main()")
}

Aquí hay 2 subrutinas, una envía datos al canal y la otra los imprime. La función add_to_channel suma los números del 0 al 9 y cierra el canal. Simultáneamente, la función fetch_from_channel espera

x, flag := <- ch y una vez que los datos estén disponibles, los imprime. Sale una vez que la bandera es falsa, lo que significa que el canal está cerrado.

La espera en main() se da para evitar la salida de main() hasta que las gorutinas finalicen la ejecución.

Ejecute el código y vea el resultado como

Read data
Send data
0
1
2
3
4
5
6
7
8
9
Empty channel
Inside main()

Seleccione

Seleccionar puede verse como una declaración de cambio que funciona en canales. Aquí las declaraciones del caso serán una operación de canal. Por lo general, las declaraciones de cada caso se leerán desde el canal. Cuando cualquiera de los casos está listo (se lee el canal), se ejecuta la declaración asociada con ese caso. Si hay varios casos listos, elegirá uno al azar. Puede tener un caso predeterminado que se ejecute si ninguno de los casos está listo.

Veamos el siguiente código.

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)
    
    //Both case statements wait for data in the chan1 or chan2.
    //chan2 gets data first since the delay is only 2 sec in data2().
    //So the second case will execute and exits the select block
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    }
}

La ejecución del programa anterior dará el resultado:

from data2()

Aquí la declaración de selección espera a que los datos estén disponibles en cualquiera de los canales. data2() agrega datos al canal después de un período de suspensión de 2 segundos, lo que hará que se ejecute el segundo caso.

Agregue un caso predeterminado a la selección en el mismo programa y vea el resultado. Aquí, al llegar al bloque de selección, si ningún caso tiene datos listos en el canal, ejecutará el bloque predeterminado sin esperar a que los datos estén disponibles en ningún canal.

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values  
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)

    //Both case statements check for data in chan1 or chan2.
    //But data is not available (both routines have a delay of 2 and 4 sec)
    //So the default block will be executed without waiting for data in channels.
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    default:
    	fmt.Println("Default case executed")
    }
}

Este programa dará el resultado:

Default case executed			

Esto se debe a que cuando llegó el bloque de selección, ningún canal tenía datos para leer. Entonces, se ejecuta el caso predeterminado.

Mutex

Mutex es la forma abreviada de exclusión mutua. Mutex se utiliza cuando no se desea permitir que varias subrutinas accedan a un recurso al mismo tiempo. Mutex tiene dos métodos: bloquear y desbloquear. Mutex está incluido en el paquete sync, por lo que hay que importar el paquete sync. Las instrucciones que se deben ejecutar de forma mutuamente exclusiva se pueden colocar dentro de mutex.Lock() y mutex.Unlock().

Aprendamos mutex con un ejemplo que cuenta el número de veces que se ejecuta un bucle. En este programa esperamos que la rutina ejecute el bucle 10 veces y el recuento se almacene en suma. Llamas a esta rutina 3 veces, por lo que el recuento total debe ser 30. El recuento se almacena en una variable global.

Primero, ejecuta el programa sin mutex.

package main
import "fmt"
import "time"
import "strconv"
import "math/rand"
//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Ver el resultado

 Count after i=1 Count: 11
Count after i=3 Count: 12
Count after i=2 Count: 13
Final Count: 13

El resultado podría ser diferente cuando lo ejecutes pero el resultado final no será 30.

Aquí lo que sucede es que 3 gorutinas intentan aumentar el recuento de bucles almacenado en la variable recuento. Supongamos que en un momento el recuento es 5 y goroutine1 va a incrementar el recuento a 6. Los pasos principales incluyen

Copiar recuento a temperatura

Incrementar temperatura

Almacenar la temperatura nuevamente para contar

Supongamos que poco después de realizar el paso 3 de goroutine1; otra gorutina podría tener un valor antiguo, digamos que 3 realiza los pasos anteriores y almacena 4 nuevamente, lo cual es incorrecto. Esto se puede evitar usando mutex, que hace que otras rutinas esperen cuando una rutina ya está usando la variable.

Ahora ejecutará el programa con mutex. Aquí los 3 pasos mencionados anteriormente se ejecutan en un mutex.

package main
import "fmt"
import "time"
import "sync"
import "strconv"
import "math/rand"

//declare a mutex instance
var mu sync.Mutex

//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		//lock starts here
		mu.Lock()
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
		//lock ends here
		mu.Unlock()
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Ahora la salida será

 Count after i=3 Count: 21
Count after i=2 Count: 28
Count after i=1 Count: 30
Final Count: 30

Aquí obtenemos el resultado esperado como resultado final. Porque las declaraciones de lectura, incremento y reescritura del recuento se ejecutan en un mutex.

Manejo de errores

Los errores son condiciones anormales como cerrar un archivo que no está abierto, abrir un archivo que no existe, etc. Las funciones generalmente devuelven errores como último valor de retorno.

El siguiente ejemplo explica más sobre el error.

package main
import "fmt"
import "os"

//function accepts a filename and tries to open it.
func fileopen(name string) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        fmt.Println(er)
        return
    }else{
    	fmt.Println("file opened", f.Name())
    }
}

func main() {  
    fileopen("invalid.txt")
}

La salida será:

open /invalid.txt: no such file or directory

Aquí intentamos abrir un archivo que no existe y devolvió el error a la variable er. Si el archivo es válido, entonces el error será nulo.

Errores personalizados

Con esta función, puede crear errores personalizados. Esto se hace usando New() del paquete de error. Reescribiremos el programa anterior para utilizar errores personalizados.

Ejecute el siguiente programa

package main
import "fmt"
import "os"
import "errors"

//function accepts a filename and tries to open it.
func fileopen(name string) (string, error) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        //created a new error object and returns it  
        return "", errors.New("Custom error message: File name is wrong")
    }else{
    	return f.Name(),nil
    }
}

func main() {  
    //receives custom error or nil after trying to open the file
    filename, error := fileopen("invalid.txt")
    if error != nil {
        fmt.Println(error)
    }else{
    	fmt.Println("file opened", filename)
    }  
}

La salida será:

Custom error message:File name is wrong

Aquí el área() devuelve el área de un cuadrado. Si la entrada es menor que 1, entonces area() devuelve un mensaje de error.

Leer archivos

Los archivos se utilizan para almacenar datos. Go nos permite leer datos de los archivos

Primero cree un archivo, data.txt, en su directorio actual con el siguiente contenido.

Line one
Line two
Line three

Ahora ejecute el siguiente programa para ver cómo imprime el contenido del archivo completo como salida.

package main
import "fmt"
import "io/ioutil"

func main() {  
    data, err := ioutil.ReadFile("data.txt")
    if err != nil {
        fmt.Println("File reading error", err)
        return
    }
    fmt.Println("Contents of file:", string(data))
}

Aquí los datos, err := ioutil.ReadFile(“data.txt”) lee los datos y devuelve una secuencia de bytes. Mientras se imprime, se convierte al formato de cadena.

Escribir archivos

Verás esto con un programa.

package main
import "fmt"
import "os"

func main() {  
    f, err := os.Create("file1.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    l, err := f.WriteString("Write Line one")
    if err != nil {
        fmt.Println(err)
        f.Close()
        return
    }
    fmt.Println(l, "bytes written")
    err = f.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
}

Aquí se crea un archivo, test.txt. Si el archivo ya existe, su contenido se trunca. Writeline() se utiliza para escribir el contenido del archivo. Después de eso, cerró el archivo usando Close().

Hoja de trucos

En este tutorial de Go, cubrimos,

Tema	Descripción	Sintaxis
Tipos basicos	Numérico, cadena, bool
Variables	Declarar y asignar valores a variables.	var tipo nombre_variable var nombre_variable tipo = valor var nombre_variable1, nombre_variable2 = valor1, valor2 nombre_variable := valor
Constantes	Variables cuyo valor no se puede cambiar una vez asignado	variable constante = valor
En bucle	Ejecutar declaraciones en un bucle.	para inicialización_expresión; expresión_evaluación; iteración_expresión{ // una o más declaraciones }
Si mas	Es una declaración condicional.	si condición { // declaraciones_1 Else {} // declaraciones_2 }
cambiar	Declaración condicional con múltiples casos.	cambiar de expresión { valor de caso_1: declaraciones_1 valor de caso_2: declaraciones_2 valor de caso_n: declaraciones_n por defecto: declaraciones_predeterminadas }
Formación	Secuencia con nombre de tamaño fijo de elementos del mismo tipo	nombre de matriz: = [tamaño] escriba {valor_0, valor_1,…, valor_tamaño-1}
Rebanada	Porción o segmento de una matriz	var nombre_porción [] tipo = nombre_matriz[inicio:fin]
Funciones	Bloque de declaraciones que realiza una tarea específica.	func nombre_función (tipo parámetro_1, tipo parámetro_n) tipo_retorno { //declaraciones }
Paquetes	Se utilizan para organizar el código. Aumenta la legibilidad y reutilización del código.	importar nombre_paquete
Aplazar	Difiere la ejecución de una función hasta que la función que la contiene finaliza su ejecución.	diferir nombre_función(lista_parámetros)
Punteros	Almacena la dirección de memoria de otra variable.	var nombre_variable *tipo
Estructura	Tipo de datos definido por el usuario que a su vez contiene un elemento más del mismo o diferente tipo	escriba nombre de estructura estructura { variable_1 variable_1_tipo variable_2 variable_2_tipo variable_n variable_n_tipo }
Métodos	Un método es una función con un argumento receptor.	func (variable tipo de variable) nombre_método(lista_parámetros) { }
gorutina	Una función que puede ejecutarse simultáneamente con otras funciones.	ir nombre_función(lista_parámetros)
Channel	Manera de que las funciones se comuniquen entre sí. Medio en el que una rutina coloca datos y al que otra rutina accede.	Declarar: ch:= hacer(chan int) Enviar datos al canal: variable_canal <- nombre_variable Recibir del canal: nombre_variable := <- variable_canal
Seleccione	Declaración de cambio que funciona en canales. Las declaraciones del caso serán una operación de canal. Cuando cualquiera de los canales está listo con datos, se ejecuta la declaración asociada con ese caso.	seleccionar { caso x := <-chan1: fmt.Println(x) caso y := <-chan2: fmt.Println(y) }
Mutex	Mutex se utiliza cuando no se desea permitir que varias subrutinas accedan a un recurso al mismo tiempo. Mutex tiene 2 métodos: bloquear y desbloquear	mutex.Lock() //declaraciones mutex.Desbloquear().
Leer archivos	Lee los datos y devuelve una secuencia de bytes.	Datos, err := ioutil.ReadFile(nombre de archivo)
Escribir archivo	Escribe datos en un archivo.	l, errar := f.WriteString(text_to_write)