Tutorial de Golang – Aprende el lenguaje de programación Go

El lenguaje de programación Golang o Go es un lenguaje de programación de tipo estático y procedimental que tiene una sintaxis similar al lenguaje C. Fue desarrollado en 2007 por Robert Griesemer, Rob Pike y Ken Thompson en Google. Pero lo lanzaron en 2009 como un lenguaje de programación de código abierto. Proporciona una rica biblioteca estándar, recolección de basura y capacidad de escritura dinámica y también brinda soporte para que el entorno adopte patrones similares a los lenguajes dinámicos. La última versión de Golang es la 1.13.1 lanzada el 3 ^de septiembre de 2019. Aquí proporcionamos un tutorial completo de Golang con ejemplos adecuados.

 
Tópicos cubiertos:

¿Por qué Golang?

El objetivo principal del diseño de Golang fue eliminar los problemas de los idiomas existentes. Así que veamos los problemas que enfrentamos con los lenguajes de programación Python , Java , C / C++ :

• Python: es fácil de usar pero lento en comparación con Golang.
• Java: Tiene un sistema de tipos muy complejo.
• C/C++: tiene un tiempo de compilación lento y un sistema de tipo complejo.
• Además, todos estos lenguajes se diseñaron cuando las aplicaciones de subprocesos múltiples eran raras, por lo que no eran muy efectivas para aplicaciones paralelas, concurrentes y altamente escalables.
• Threading consume 1 MB, mientras que Goroutine consume 2 KB de memoria, por lo tanto, al mismo tiempo, podemos activar millones de goroutine.

Características clave

Descarga e instalación de Golang

Antes de comenzar con la instalación de Go, es bueno verificar si ya está instalado en su sistema. Para verificar si su dispositivo está preinstalado con Golang o no, simplemente vaya a la línea de comandos (para Windows , busque cmd en el cuadro de diálogo Ejecutar ( + R ).

Ahora ejecuta el siguiente comando:

go version

Si Golang ya está instalado, generará un mensaje con todos los detalles de la versión de Golang disponible; de ​​lo contrario, si Golang no está instalado, aparecerá un error que indicará un comando o nombre de archivo incorrecto.

Antes de comenzar con el proceso de instalación, debe descargarlo. Para eso, todas las versiones de Go para Windows están disponibles en golang.org .

Descargue Golang de acuerdo con la arquitectura de su sistema y siga las instrucciones adicionales para la instalación de Golang.

Paso 1: Después de la descarga, descomprima el archivo comprimido descargado. Después de descomprimir, obtendrá una carpeta llamada go en el directorio actual.

Paso 2: ahora copia y pega la carpeta extraída donde quieras instalarla. Aquí estamos instalando en la unidad C.

Paso 3: ahora configure las variables de entorno. Haga clic derecho en Mi PC y seleccione Propiedades . Elija la Configuración avanzada del sistema en el lado izquierdo y haga clic en Variables de entorno como se muestra en las capturas de pantalla a continuación.

Paso 4: Haga clic en Ruta desde las variables del sistema y luego haga clic en Editar . Luego haga clic en Nuevo y luego agregue la Ruta con el directorio bin donde ha pegado la carpeta Ir . Aquí estamos editando la ruta C:\go\bin y hacemos clic en Aceptar como se muestra en las siguientes capturas de pantalla.

Paso 5: Ahora cree una nueva variable de usuario que le indique al comando Go dónde están presentes las bibliotecas de Golang. Para eso, haga clic en Nuevo en Variables de usuario como se muestra en las capturas de pantalla a continuación.

Ahora complete el nombre de la variable como GOROOT y el valor de la variable es la ruta de su carpeta Golang. Así que aquí el valor de la variable es C:\go\ . Después de llenar, haga clic en Aceptar.

Después de eso, haga clic en Aceptar en Variables de entorno y su configuración estará completa. Ahora, verifiquemos la versión de Golang usando el comando go versionen el símbolo del sistema.

Después de completar el proceso de instalación, se puede usar cualquier IDE o editor de texto para escribir códigos Golang y ejecutarlos en el IDE o en el símbolo del sistema con el uso del comando:

go run filename.go

Ejecutando ¡Hola mundo! Programa

Para ejecutar un programa Go, necesita un compilador Go. En el compilador Go, primero crea un programa y lo guarda con la extensión .go , por ejemplo, first.go .

// First Go program
package main
  
import "fmt"
  
// Main function
func main() {
  
    fmt.Println("!... Hello World ...!")
}

Producción:

!... Hello World ...!

Ahora ejecutamos este archivo first.go en el compilador go usando el siguiente comando, es decir:

$ go run first.go

Para obtener más detalles sobre los diferentes términos utilizados en este programa, puede visitar Hello World! en Golang

Identificadores y palabras clave

Los identificadores son el nombre definido por el usuario de los componentes del programa. En el lenguaje Go, un identificador puede ser un nombre de variable, un nombre de función, una constante, etiquetas de instrucciones, un nombre de paquete o tipos.

Ejemplo:

// Valid identifiers:
_geeks23
geeks
gek23sd
Geeks
geeKs
geeks_geeks

// Invalid identifiers:
212geeks
if
default

Las palabras clave o palabras reservadas son las palabras en un idioma que se utilizan para algún proceso interno o representan algunas acciones predefinidas. Por lo tanto, no se permite el uso de estas palabras como identificador. Hacer esto resultará en un error de tiempo de compilación. Hay un total de 25 palabras clave presentes en el lenguaje Go de la siguiente manera:

Ejemplo:

// Go program to illustrate 
// the use of keywords
  
// Here package keyword is used to 
// include the main package
// in the program
package main
  
// import keyword is used to 
// import "fmt" in your package
import "fmt"
  
// func is used to
// create function
func main() {
  
    // Here, var keyword is used 
    // to create variables
    // Pname, Lname, and Cname 
    // are the valid identifiers
    var Pname = "GeeksforGeeks" 
    var Lname = "Go Language" 
    var Cname = "Keywords"
      
    fmt.Printf("Portal name: %s", Pname)
    fmt.Printf("\nLanguage name: %s", Lname)
    fmt.Printf("\nChapter name: %s", Cname)
  
}

Producción:

Portal name: GeeksforGeeks
Language name: Go Language
Chapter name: Keywords

Tipos de datos

Los tipos de datos especifican el tipo de datos que puede contener una variable Go válida. En el lenguaje Go, el tipo se divide en cuatro categorías, que son las siguientes:

1. Tipo básico: los números, las strings y los valores booleanos pertenecen a esta categoría.
2. Tipo agregado: la array y las estructuras pertenecen a esta categoría.
3. Tipo de referencia: los punteros, los cortes, los mapas, las funciones y los canales pertenecen a esta categoría.
4. Tipo de interfaz

Aquí, discutiremos los tipos de datos básicos en el lenguaje Go. Los tipos de datos básicos se clasifican además en tres subcategorías que son:

1. Números
2. Booleanos
3. Instrumentos de cuerda

Números: en el lenguaje Go, los números se dividen en tres subcategorías que son:

• Números enteros: en el lenguaje Go, los números enteros con y sin signo están disponibles en cuatro tamaños diferentes, como se muestra en la siguiente tabla. El int con signo está representado por int y el entero sin signo está representado por uint.

  

• Números de punto flotante: en el lenguaje Go, los números de punto flotante se dividen en dos categorías, como se muestra en la siguiente tabla:

  

• Números complejos: Los números complejos se dividen en dos partes que se muestran en la siguiente tabla. float32 y float64 también forman parte de estos números complejos. La función incorporada crea un número complejo a partir de su parte real e imaginaria y la función real e imaginaria incorporada extrae esas partes.

  

Ejemplo:

// Golang program to illustrate // the use of integers, floating // and complex numbers package main    import "fmt"    func main() {        // Using 8-bit unsigned int     var X uint8 = 225     fmt.Println(X+1, X)        // Using 16-bit signed int     var Y int16 = 32767     fmt.Println(Y+2, Y-2)        a := 20.45     b := 34.89        var m complex128 = complex(6, 2)     var n complex64 = complex(9, 2)        // Subtraction of two     // floating-point number     c := b - a        // Display the result     fmt.Printf("Result is: %f\n", c)        // Display the type of c variable     fmt.Printf("The type of c is : %T\n", c)        fmt.Println(m)     fmt.Println(n)        // Display the type     fmt.Printf("The type of m is %T and "+         "the type of n is %T", m, n)    }

Producción:

226 225
-32767 32765
Result is: 14.440000
The type of c is : float64
(6+2i)
(9+2i)
The type of m is complex128 and the type of n is complex64

Booleanos y strings:

El tipo de datos booleano representa solo un bit de información, ya sea verdadero o falso. Los valores de tipo booleano no se convierten implícita o explícitamente a ningún otro tipo.
El tipo de datos de string representa una secuencia de puntos de código Unicode. O, en otras palabras, podemos decir que una string es una secuencia de bytes inmutables, lo que significa que una vez que se crea una string, no puede cambiarla. Una string puede contener datos arbitrarios, incluidos bytes con valor cero en formato legible por humanos.

Ejemplo:

// Go program to illustrate
// the use of booleans and
// strings
package main
  
import "fmt"
  
func main() {
  
    // variables
    str1 := "GeeksforGeeks"
    str2 := "geeksForgeeks"
    result1 := str1 == str2
  
    // Display the result
    fmt.Println(result1)
  
    // Display the type of
    // result1
    fmt.Printf("The type of result1 is %T\n", result1)
  
    // str variable which stores strings
    str := "GeeksforGeeks"
  
    // Display the length of the string
    fmt.Printf("Length of the string is: %d", len(str))
  
    // Display the string
    fmt.Printf("\nString is: %s", str)
  
    // Display the type of str variable
    fmt.Printf("\nType of str is: %T", str)
  
}

Producción:

false
The type of result1 is bool
Length of the string is: 13
String is: GeeksforGeeks
Type of str is: string

Variables

Una variable es un marcador de posición de la información que se puede cambiar en tiempo de ejecución. Y las variables permiten Recuperar y Manipular la información almacenada.

Reglas para nombrar variables:

• Los nombres de las variables deben comenzar con una letra o un guión bajo (_). Y los nombres pueden contener las letras ‘a-z’ o ‘A-Z’ o dígitos 0-9 así como el carácter ‘_’.

  Geeks, geeks, _geeks23  // valid variable
  123Geeks, 23geeks      // invalid variable
  

• Un nombre de variable no debe comenzar con un dígito.

  234geeks  // illegal variable 

• El nombre de la variable distingue entre mayúsculas y minúsculas.

  geeks and Geeks are two different variables

• No se permite el uso de palabras clave como nombre de variable.
• No hay límite en la longitud del nombre de la variable, pero se recomienda utilizar una longitud óptima de 4 a 15 letras solamente.

Hay dos formas de declarar una variable en Golang de la siguiente manera:

1. Usando la palabra clave var: en el lenguaje Go, las variables se crean usando la palabra clave var de un tipo particular, conectado con el nombre y proporciona su valor inicial.

Sintaxis:

var variable_name type = expression

Ejemplo:

// Go program to illustrate 
// the use of var keyword
package main
  
import "fmt"
  
func main() {
  
// Variable declared and 
// initialized without the 
// explicit type
var myvariable1 = 20
  
// Display the value and the
// type of the variables
fmt.Printf("The value of myvariable1 is : %d\n",
                                  myvariable1)
                                      
fmt.Printf("The type of myvariable1 is : %T\n",
                                  myvariable1)
      
}

Producción:

The value of myvariable1 is : 20
The type of myvariable1 is : int

Para leer más sobre la palabra clave var, puede consultar el artículo palabra clave var en Golang

2. Usando declaración de variable corta: Las variables locales que se declaran e inicializan en las funciones se declaran usando declaración de variable corta.

Sintaxis:

variable_name:= expression

Nota: No confunda entre := y = ya que := es una declaración y = es una asignación.

Ejemplo:

// Go program to illustrate the
// short variable declaration 
package main
import "fmt"
  
func main() {
  
// Using short variable declaration
myvar1 := 39 
  
// Display the value and type of the variable
fmt.Printf("The value of myvar1 is : %d\n", myvar1)
fmt.Printf("The type of myvar1 is : %T\n", myvar1)
  
}

Producción:

The value of myvar1 is : 39
The type of myvar1 is : int

Para leer más sobre la palabra clave de declaración de variable corta, puede consultar el artículo Operador de declaración de variable corta (:=) en Golang

constantes

Como sugiere el nombre constantes significa fijo, en los lenguajes de programación también es lo mismo, es decir, una vez que se define el valor de la constante, no se puede modificar más. Puede haber cualquier tipo de datos básicos de constante como una constante entera, una constante flotante, una constante de carácter o una string literal.

¿Cómo declarar?
Las constantes se declaran como variables pero al usar una palabra clave const como prefijo para declarar constantes con un tipo específico. No se puede declarar usando la sintaxis := .

Ejemplo:

// Golang program to illustrate 
// the constants
package main
  
import "fmt"
  
const PI = 3.14
  
func main() {
    const GFG = "GeeksforGeeks"
    fmt.Println("Hello", GFG)
  
    fmt.Println("Happy", PI, "Day")
  
    const Correct = true
    fmt.Println("Go rules?", Correct)
}

Producción:

Hello GeeksforGeeks
Happy 3.14 Day
Go rules? true

Para leer más sobre Constantes en Golang, puede consultar el artículo Constantes en Golang .

Operadores

Los operadores son la base de cualquier lenguaje de programación. Por lo tanto, la funcionalidad del lenguaje Go está incompleta sin el uso de operadores. Los operadores nos permiten realizar diferentes tipos de operaciones en los operandos. En el lenguaje Go, los operadores se pueden clasificar en función de sus diferentes funciones:

• Operadores aritméticos
• Operadores relacionales
• Operadores logicos
• Operadores bit a bit
• Operadores de Asignación
• Operadores varios

Ejemplo:

// Golang program to illustrate
// the use of operators
package main
  
import "fmt"
  
func main() {
    p := 23
    q := 60
  
    // Arithmetic Operator - Addition
    result1 := p + q
    fmt.Printf("Result of p + q = %d\n", result1)
  
    // Relational Operators - ‘=='(Equal To)
    result2 := p == q
    fmt.Println(result2)
  
    // Relational Operators - ‘!='(Not Equal To)
    result3 := p != q
    fmt.Println(result3)
  
    // Logical Operators
    if p != q && p <= q {
        fmt.Println("True")
    }
  
    if p != q || p <= q {
        fmt.Println("True")
    }
  
    if !(p == q) {
        fmt.Println("True")
    }
  
    // Bitwise Operators - & (bitwise AND)
    result4 := p & q
    fmt.Printf("Result of p & q = %d\n", result4)
  
    // Assignment Operators - “=”(Simple Assignment)
    p = q
    fmt.Println(p)
  
}

Producción:

Result of p + q = 83
false
true
True
True
True
Result of p & q = 20
60

Flujo de control

Declaraciones de toma de decisiones

La toma de decisiones en la programación es similar a la toma de decisiones en la vida real. Un fragmento de código se ejecuta cuando se cumple la condición dada. A veces, estos también se denominan declaraciones de flujo de control. Un lenguaje de programación utiliza declaraciones de control para controlar el flujo de ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el flujo de ejecución avance y se bifurque en función de los cambios en el estado de un programa.

• if : Se utiliza para decidir si una determinada instrucción o bloque de instrucciones se ejecutará o no, es decir, si una determinada condición es verdadera , entonces se ejecutará un bloque de instrucciones; de lo contrario, no se ejecutará.

  Sintaxis:

  if(condition) {
  
     // Statements to execute if
     // condition is true
  }
  

  Diagrama de flujo:

  

• if-else : si queremos hacer otra cosa si la condición es falsa. Aquí viene la declaración else. Podemos usar la instrucción else con la instrucción if para ejecutar un bloque de código cuando la condición es falsa.

  Sintaxis:

   
  if (condition) {
  
      // Executes this block if
      // condition is true
  } else {
  
      // Executes this block if
      // condition is false
  }
  

  Diagrama de flujo:

  

• If anidado : las declaraciones if anidadas significan una declaración if dentro de una declaración if. Sí, Golang nos permite anidar sentencias if dentro de sentencias if. es decir, podemos colocar una sentencia if dentro de otra sentencia if.

  Sintaxis:

  if (condition1) {
  
     // Executes when condition1 is true
     
     if (condition2) {
  
        // Executes when condition2 is true
     }
  }
  

  Diagrama de flujo:

  

• if-else-if Ladder : Aquí, un usuario puede decidir entre múltiples opciones. Las declaraciones if se ejecutan de arriba hacia abajo. Tan pronto como una de las condiciones que controlan el if es verdadera, se ejecuta la declaración asociada con ese if y se omite el resto de la escalera. Si ninguna de las condiciones es verdadera, entonces se ejecutará la instrucción else final.

  Puntos importantes:

  • La declaración if puede tener cero o la de otra persona y debe ir después de cualquier if de otra cosa.
  • La declaración if puede tener de cero a muchos if y debe ir antes que el else.
  • Ninguno de los else if restantes o los else se probarán si un else if tiene éxito,

  Sintaxis:

  if(condition_1) {
  
       // this block will execute 
       // when condition_1 is true
  
  } else if(condition_2) {
  
      // this block will execute 
      // when condition2 is true
  }
  .
  .
  . else {
  
        // this block will execute when none
       // of the condition is true
  }
  

  Diagrama de flujo:

  

Ejemplo 1: Para demostrar la declaración if y if-else

// Golang program to illustrate
// the use of if and if-else
// statement
package main
  
import "fmt"
  
func main() {
  
    // taking local variables
    var a int = 100
    var b int = 175
  
    // using if statement for
    // checking the condition
    if a%2 == 0 {
  
        // print the following if
        // condition evaluates to true
        fmt.Printf("Even Number\n")
  
    }
  
    if b%2 == 0 {
  
        fmt.Printf("Even Number")
  
    } else {
  
        fmt.Printf("Odd Number")
    }
}

Producción:

Even Number
Odd Number

Ejemplo 2: para demostrar la declaración de escalera anidada-if y if-else-if

// Golang program to illustrate
// the use of nested if and
// if-else-if ladder statement
// statement
package main
  
import "fmt"
  
func main() {
  
    // taking two local variable
    var v1 int = 400
    var v2 int = 700
  
    // ----- Nested if Statement -------
  
    // using if statement
    if v1 == 400 {
  
        // if condition is true then
        // check the following
        if v2 == 700 {
  
            // if condition is true
            // then display the following
            fmt.Printf("Value of v1 is 400 and v2 is 700\n")
        }
    }
  
    // ----------- if-else-if ladder
      
    // checking the condition
    if v1 == 100 {
  
        // if condition is true then
        // display the following */
        fmt.Printf("Value of v1 is 100\n")
  
    } else if v1 == 200 {
  
        fmt.Printf("Value of a is 20\n")
  
    } else if v1 == 300 {
  
        fmt.Printf("Value of a is 300\n")
  
    } else {
  
        // if none of the conditions is true
        fmt.Printf("None of the values is matching\n")
    }
  
}

Producción:

Value of v1 is 400 and v2 is 700
None of the values is matching

en bucle

El lenguaje Go contiene solo un bucle único que es for-loop. Un bucle for es una estructura de control de repetición que nos permite escribir un bucle que se ejecuta un número específico de veces. Un bucle for simple es similar al que usamos en otros lenguajes de programación como C , C++ , Java , C# , etc.
Sintaxis:

for initialization; condition; post{
       // statements....
}

Aquí,

• La instrucción de inicialización es opcional y se ejecuta antes de que comience el bucle for. La declaración de inicialización siempre está en una declaración simple como declaraciones de variables, declaraciones de incremento o asignación, o llamadas a funciones.
• La declaración de condición contiene una expresión booleana, que se evalúa al comienzo de cada iteración del bucle. Si el valor de la declaración condicional es verdadero, entonces se ejecuta el bucle.
• La instrucción post se ejecuta después del cuerpo del bucle for. Después de la declaración posterior, la declaración de condición se evalúa nuevamente si el valor de la declaración condicional es falso, entonces el bucle finaliza.

Ejemplo:

// Go program to illustrate the  
// use of simple for loop 
package main
  
import "fmt"
  
// Main function
func main() {
      
    // for loop 
    // This loop starts when i = 0 
    // executes till i<4 condition is true
    // post statement is i++
    for i := 0; i < 4; i++{
      fmt.Printf("GeeksforGeeks\n")  
    }
    
}

Producción:

GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks

Nota: Este bucle for se puede utilizar como bucle infinito y bucle while. Para leer más sobre el bucle for, puede consultar el artículo Bucles en Golang .

Declaraciones de control de bucle

Las declaraciones de control de bucle en el lenguaje Go se utilizan para cambiar la ejecución del programa. Cuando la ejecución del bucle dado sale de su alcance, los objetos que se crean dentro del alcance también se eliminan. El lenguaje Go admite 3 tipos de sentencias de control de bucle:

1. descanso
2. ir
3. Seguir

declaración de ruptura

La sentencia break se utiliza para terminar el bucle o sentencia en la que se presenta. Después de eso, el control pasará a las sentencias que se presenten después de la sentencia break, si está disponible. Si la declaración de ruptura está presente en el bucle anidado, solo finaliza los bucles que contienen la declaración de ruptura.

Diagrama de flujo:

Ejemplo:

// Go program to illustrate 
// the use of break statement
package main
  
import "fmt"
  
// Main function
func main() {
   for i:=0; i<5; i++{
         
   fmt.Println(i)
     
   // For loop breaks when the value of i = 3
   if i == 3{
         break;
  }
   }
  
     
}

Producción:

0
1
2
3

ir a declaración

Esta sentencia se utiliza para transferir el control a la sentencia etiquetada en el programa. La etiqueta es el identificador válido y se coloca justo antes de la declaración desde donde se transfiere el control. En general, los programadores no utilizan la instrucción goto porque es difícil rastrear el flujo de control del programa.

Diagrama de flujo:

Ejemplo:

// Go program to illustrate 
// the use of goto statement
package main
  
import "fmt"
  
func main() {
   var x int = 0
     
   // for loop work as a while loop
  Lable1: for x < 8 {
      if x == 5 {
           
         // using goto statement
         x = x + 1;
         goto Lable1
      }
      fmt.Printf("value is: %d\n", x);
      x++;     
   }  
}

Producción:

value is: 0
value is: 1
value is: 2
value is: 3
value is: 4
value is: 6
value is: 7

continuar Declaración

Esta declaración se usa para saltarse la parte de ejecución del bucle en una determinada condición. Después de eso, transfiere el control al comienzo del bucle. Omite sus siguientes declaraciones y continúa con la siguiente iteración del bucle.

Diagrama de flujo:

Ejemplo:

// Go program to illustrate 
// the use of continue statement
package main
  
import "fmt"
  
func main() {
   var x int = 0
     
   // for loop work as a while loop
   for x < 8 {
      if x == 5 {
           
         // skip two iterations
         x = x + 2;
         continue;
      }
      fmt.Printf("value is: %d\n", x);
      x++;     
   }  
}

Producción:

value is: 0
value is: 1
value is: 2
value is: 3
value is: 4
value is: 7

Declaración de cambio

Una declaración de cambio es una declaración de bifurcación multivía. Proporciona una forma eficiente de transferir la ejecución a diferentes partes de un código en función del valor (también llamado caso) de la expresión. Incluso podemos agregar múltiples valores en la declaración del caso usando una coma.

Sintaxis:

switch expression {
    case value_1:
        statement......1
    case value_2:
        statement......2
    case value_n:
        statement......n
    default:
        statement......default
    }

Ejemplo:

// Go program to illustrate the  
// concept of switch statement 
package main 
    
import "fmt"
    
func main() { 
    var value string = "five"
        
    // Switch statement without default statement 
    // Multiple values in case statement 
   switch value { 
       case "one": 
       fmt.Println("C#") 
       case "two", "three": 
       fmt.Println("Go") 
       case "four", "five", "six": 
       fmt.Println("Golang") 
   }   
} 

Producción:

Golang

Para leer más sobre la declaración de cambio, puede consultar el artículo Declaración de cambio en Golang

arreglos

Una array es una secuencia de longitud fija que se utiliza para almacenar elementos homogéneos en la memoria. Debido a su array de longitud fija, no son tan populares como el lenguaje Slice in Go. En una array, puede almacenar cero o más de cero elementos en ella. Los elementos de la array se indexan mediante el uso del operador de índice [] con su posición de base cero, lo que significa que el índice del primer elemento es array[0] y el índice del último elemento es array[len(array)-1] .

Hay dos formas de crear una array en Golang de la siguiente manera:

1. Usando la palabra clave var: en el lenguaje Go, se crea una array usando la palabra clave var de un tipo particular con nombre, tamaño y elementos.

Sintaxis:

Var array_name[length]Type
or
var array_name[length]Typle{item1, item2, item3, ...itemN}

En el lenguaje Go, las arrays son mutables, por lo que puede usar la sintaxis de array[índice] en el lado izquierdo de la asignación para establecer los elementos de la array en el índice dado.

Var array_name[index] = element

2. Uso de la declaración abreviada: en el lenguaje Go, las arrays también se pueden declarar utilizando la declaración abreviada. Es más flexible que la declaración anterior.

Sintaxis:

array_name:= [length]Type{item1, item2, item3, ...itemN}

Ejemplo:

// Golang program to illustrate the arrays
package main
  
import "fmt"
  
func main() {
  
    // Creating an array of string type
    // Using var keyword
    var myarr [2]string
  
    // Elements are assigned using index
    myarr[0] = "GFG"
    myarr[1] = "GeeksforGeeks"
  
    // Accessing the elements of the array
    // Using index value
    fmt.Println("Elements of Array:")
    fmt.Println("Element 1: ", myarr[0])
    fmt.Println("Element 2: ", myarr[1])
  
    // Shorthand declaration of array
    arr := [4]string{"geek", "gfg", "Geeks1231", "GeeksforGeeks"}
  
    // Accessing the elements of
    // the array Using for loop
    fmt.Println("\nElements of the array:")
  
    for i := 0; i < 3; i++ {
        fmt.Println(arr[i])
  
    }
  
}

Producción:

Elements of Array:
Element 1:  GFG
Element 2:  GeeksforGeeks

Elements of the array:
geek
gfg
Geeks1231

Para leer más sobre arreglos, puede consultar el artículo Arreglos en Golang

rebanadas

Slice es más potente, flexible y conveniente que una array y es una estructura de datos liviana. Slice es una secuencia de longitud variable que almacena elementos de un tipo similar, no está permitido almacenar diferentes tipos de elementos en el mismo segmento. Es como una array que tiene un valor de índice y una longitud, pero el tamaño del segmento cambia de tamaño, no tienen un tamaño fijo como una array. Internamente, el segmento y una array están conectados; un segmento es una referencia a un arreglo subyacente. Se permite almacenar elementos duplicados en el segmento. La primera posición del índice en un segmento siempre es 0 y la última será (longitud del segmento – 1).

Sintaxis para Declaración:

[]T
or 
[]T{}
or 
[]T{value1, value2, value3, ...value n}

Aquí, T es el tipo de los elementos. Por ejemplo:

var my_slice[]int

El puntero, la longitud y la capacidad son los tres componentes principales del sector.

Ejemplo:

// Golang program to illustrate
// the working of the slice
package main
  
import "fmt"
  
func main() {
  
    // Creating an array
    arr := [7]string{"This", "is", "the", "tutorial",
                         "of", "Go", "language"}
  
    // Display array
    fmt.Println("Array:", arr)
  
    // Creating a slice
    myslice := arr[1:6]
  
    // Display slice
    fmt.Println("Slice:", myslice)
  
    // Display length of the slice
    fmt.Printf("Length of the slice: %d", len(myslice))
  
    // Display the capacity of the slice
    fmt.Printf("\nCapacity of the slice: %d", cap(myslice))
}

Producción:

Array: [This is the tutorial of Go language]
Slice: [is the tutorial of Go]
Length of the slice: 5
Capacity of the slice: 6

Explicación: En el ejemplo anterior, creamos un segmento a partir de la array dada. Aquí, el puntero del segmento apuntaba al índice 1 porque el límite inferior del segmento se establece en uno, por lo que comienza a acceder a los elementos del índice 1. La longitud del segmento es 5, lo que significa que el número total de elementos presentes en el segmento es 5 y la capacidad del slice 6 permite almacenar en él un máximo de 6 elementos.

Para leer más sobre los sectores, puede consultar el artículo Sectores en Golang

Funciones

Las funciones son generalmente el bloque de códigos o declaraciones en un programa que le brinda al usuario la capacidad de reutilizar el mismo código, lo que finalmente evita el uso excesivo de memoria, actúa como un ahorro de tiempo y, lo que es más importante, proporciona una mejor legibilidad del código. Básicamente, una función es una colección de declaraciones que realizan una tarea específica y devuelven el resultado a la persona que llama. Una función también puede realizar alguna tarea específica sin devolver nada.

Sintaxis:

func function_name(Parameter-list)(Return_type){
    // function body.....
}

Puede devolver varios valores de la función. Además, los parámetros y los tipos de devolución son opcionales.

Ejemplo:

// Go program to illustrate the
// use of function
package main
import "fmt"
  
// area() is used to find the 
// area of the rectangle
// area() function two parameters,
// i.e, length and width
func area(length, width int)int{
      
    Ar := length* width
    return Ar
}
  
// Main function
func main() {
    
   // Display the area of the rectangle
   // with method calling
   fmt.Printf("Area of rectangle is : %d", area(12, 10))
}

Producción:

Area of rectangle is : 120

Para leer más sobre las funciones, puede consultar el artículo Funciones en Golang .

Estructuras

Es un tipo definido por el usuario que permite agrupar/combinar elementos de tipos posiblemente diferentes en un solo tipo. Se puede denominar como una clase ligera que no admite la herencia pero sí la composición.

Primero, debe declarar un tipo de estructura usando la siguiente sintaxis:

type struct_name struct {
   variable_1 type_of_variable_1
   variable_2 type_of_variable_2
   variable_n type_of_variable_3
}

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

var variable_name struct_name

Ejemplo:

// Golang program to show how to
// declare and define the struct
  
package main
  
import "fmt"
  
// Defining a struct type
type Address struct {
    Name    string
    city    string
    Pincode int
}
  
func main() {
  
    // Declaring a variable of a `struct` type
    // All the struct fields are initialized 
    // with their zero value
    var a Address 
    fmt.Println(a)
  
    // Declaring and initializing a
    // struct using a struct literal
    a1 := Address{"Akshay", "Dehradun", 3623572}
  
    fmt.Println("Address1: ", a1)
  
    // Naming fields while 
    // initializing a struct
    a2 := Address{Name: "Anikaa", city: "Ballia",
                                 Pincode: 277001}
  
    fmt.Println("Address2: ", a2)
  
    // Uninitialized fields are set to
    // their corresponding zero-value
    a3 := Address{Name: "Delhi"}
    fmt.Println("Address3: ", a3)
}

Producción:

{  0}
Address1:  {Akshay Dehradun 3623572}
Address2:  {Anikaa Ballia 277001}
Address3:  {Delhi  0}

Para acceder a campos individuales de una estructura, debe usar el operador de punto (.). Para leer más sobre estructuras, puede consultar el artículo Estructura en Golang .

Paquetes

El propósito de un paquete es diseñar y mantener una gran cantidad de programas agrupando funciones relacionadas en unidades individuales para que puedan ser fáciles de mantener y comprender e independientes de los otros programas del paquete. En el lenguaje Go, cada paquete se define con un nombre diferente y ese nombre está cerca de su funcionalidad como paquete de «strings» y contiene métodos y funciones que solo se relacionan con strings.

Ejemplo:

// Go program to illustrate the
// concept of packages
// Package declaration
package main
  
// Importing multiple packages
import (
    "bytes"
    "fmt"
    "sort"
)
  
func main() {
  
    // Creating and initializing slice
    // Using shorthand declaration
    slice_1 := []byte{'*', 'G', 'e', 'e', 'k', 's', 'f',
        'o', 'r', 'G', 'e', 'e', 'k', 's', '^', '^'}
    slice_2 := []string{"Gee", "ks", "for", "Gee", "ks"}
  
    // Displaying slices
    fmt.Println("Original Slice:")
    fmt.Printf("Slice 1 : %s", slice_1)
    fmt.Println("\nSlice 2: ", slice_2)
  
    // Trimming specified leading
    // and trailing Unicode points
    // from the given slice of bytes
    // Using Trim function
    res := bytes.Trim(slice_1, "*^")
    fmt.Printf("\nNew Slice : %s", res)
  
    // Sorting slice 2
    // Using Strings function
    sort.Strings(slice_2)
    fmt.Println("\nSorted slice:", slice_2)
}

Producción:

Original Slice:
Slice 1 : *GeeksforGeeks^^
Slice 2:  [Gee ks for Gee ks]

New Slice : GeeksforGeeks
Sorted slice: [Gee Gee for ks ks]

Aplazar

Es una palabra clave que retrasa la ejecución de la función o método o un método anónimo hasta que regresan las funciones cercanas. O, en otras palabras, los argumentos de llamadas a métodos o funciones diferidas se evalúan instantáneamente, pero se ejecutan hasta que regresan las funciones cercanas.

Ejemplo:

// Go program to illustrate the
// concept of the defer statement
package main
  
import "fmt"
  
// Functions
func mul(a1, a2 int) int {
  
    res := a1 * a2
    fmt.Println("Result: ", res)
    return 0
}
  
func show() {
    fmt.Println("Hello!, GeeksforGeeks")
}
  
// Main function
func main() {
  
    // Calling mul() function
    // Here mul function behaves
    // like a normal function
    mul(23, 45)
  
    // Calling mul()function
    // Using defer keyword
    // Here the mul() function
    // is defer function
    defer mul(23, 56)
  
    // Calling show() function
    show()
}

Producción:

Result:  1035
Hello!, GeeksforGeeks
Result:  1288

Explicación: En el ejemplo anterior, tenemos dos funciones llamadas mul() y show() . Donde la función show() llama normalmente en la función main() , pero llamamos a la función mul() de dos maneras diferentes:

• Primero, llamamos a la función mul como la función normal, es decir, mul(23, 45) y se ejecuta cuando la función llama (Salida: Resultado: 1035).
• En segundo lugar, llamamos a la función mul() como una función diferida usando la palabra clave diferida, es decir, diferida mul(23, 56) y se ejecuta (Salida: Resultado: 1288) cuando regresan todos los métodos circundantes.

Para leer más sobre esto, puede consultar la palabra clave Defer Keyword en Golang .

Punteros

Es una variable que se utiliza para almacenar la dirección de memoria de otra variable. Los punteros en Golang también se denominan variables especiales. Antes de comenzar, hay dos operadores importantes que usaremos en punteros, es decir

* Operador también denominado operador de desreferenciación utilizado para declarar la variable de puntero y acceder al valor almacenado en la dirección.

& operador denominado como operador de dirección utilizado para devolver la dirección de una variable o para acceder a la dirección de una variable a un puntero.

Declarando un puntero :

var pointer_name *Data_Type

Ejemplo: a continuación se muestra un puntero de tipo string que puede almacenar solo las direcciones de memoria de las variables de string .

var s *string

Inicialización del puntero: para hacer esto, debe inicializar un puntero con la dirección de memoria de otra variable utilizando el operador de dirección como se muestra en el siguiente ejemplo:

// normal variable declaration
var a = 45

// Initialization of pointer s with 
// memory address of variable a
var s *int = &a

Ejemplo:

// Golang program to demonstrate the declaration
// and initialization of pointers
package main
  
    import "fmt"
  
    func main()
{
  
    // taking a normal variable
    var x int = 5748
  
        // declaration of pointer
        var p* int
  
        // initialization of pointer
        p
        = &x
  
           // displaying the result
           fmt.Println("Value stored in x = ", x)
               fmt.Println("Address of x = ", &x)
                   fmt.Println("Value stored in variable p = ", p)
}

Producción:

Value stored in x =  5748
Address of x =  0x414020
Value stored in variable p =  0x414020

Para leer más sobre los punteros, puede consultar el artículo Punteros en Golang .

Métodos

Los métodos no son funciones en Golang. El método contiene un argumento de receptor que se utiliza para acceder a las propiedades del receptor. El receptor puede ser de tipo estructura o no estructura. Cuando crea un método en su código, el receptor y el tipo de receptor deben presentarse en el mismo paquete. Y no puede crear un método en el que el tipo de receptor ya esté definido en otro paquete, incluido el tipo incorporado como int, string, etc. Si intenta hacerlo, el compilador dará un error.

Sintaxis:

func(reciver_name Type) method_name(parameter_list)(return_type){
// Code
}

Aquí, se puede acceder al receptor dentro del método.

Ejemplo:

// Go program to illustrate the
// method
package main
  
import "fmt"
  
// Author structure
type author struct {
    name      string
    branch    string
    particles int
    salary    int
}
  
// Method with a receiver
// of author type
func (a author) show() {
  
    fmt.Println("Author's Name: ", a.name)
    fmt.Println("Branch Name: ", a.branch)
    fmt.Println("Published articles: ", a.particles)
    fmt.Println("Salary: ", a.salary)
}
  
// Main function
func main() {
  
    // Initializing the values
    // of the author structure
    res := author{
        name:      "Sona",
        branch:    "CSE",
        particles: 203,
        salary:    34000,
    }
  
    // Calling the method
    res.show()
}

Producción:

Author's Name:  Sona
Branch Name:  CSE
Published articles:  203
Salary:  34000

Métodos vs Funciones

Para leer más sobre los métodos, puede consultar el artículo Métodos en Golang .

Interfaces

Las interfaces de idioma de Go son diferentes de otros idiomas. En el lenguaje Go, la interfaz es un tipo personalizado que se utiliza para especificar un conjunto de una o más firmas de métodos y la interfaz es abstracta, por lo que no puede crear una instancia de la interfaz. Pero se le permite crear una variable de un tipo de interfaz y esta variable se puede asignar con un valor de tipo concreto que tenga los métodos que requiere la interfaz.

Sintaxis:

type interface_name interface{

// Method signatures

}

Ejemplo:

// Golang program illustrates how
// to implement an interface
package main
  
import "fmt"
  
// Creating an interface
type tank interface {
  
    // Methods
    Tarea() float64
    Volume() float64
}
  
type myvalue struct {
    radius float64
    height float64
}
  
// Implementing methods of
// the tank interface
func (m myvalue) Tarea() float64 {
  
    return 2*m.radius*m.height +
        2*3.14*m.radius*m.radius
}
  
func (m myvalue) Volume() float64 {
  
    return 3.14 * m.radius * m.radius * m.height
}
  
// Main Method
func main() {
  
    // Accessing elements of
    // the tank interface
    var t tank
    t = myvalue{10, 14}
    fmt.Println("Area of tank :", t.Tarea())
    fmt.Println("Volume of tank:", t.Volume())
}

Producción:

Area of tank : 908
Volume of tank: 4396

Para leer más, consulte el artículo Interfaces en Golang .

Concurrencia – Gorrutinas

Una Goroutine es una función o método que se ejecuta de forma independiente y simultánea en conexión con cualquier otra Goroutine presente en su programa. O, en otras palabras, cada actividad que se ejecuta simultáneamente en el lenguaje Go se conoce como Goroutines. Puede considerar un Goroutine como un hilo de peso ligero. Cada programa contiene al menos un solo Goroutine y ese Goroutine se conoce como el Goroutine principal . Todos los Goroutines están trabajando bajo los Goroutines principales si el Goroutine principal terminó, entonces todos los goroutine presentes en el programa también terminaron. Goroutine siempre funciona en segundo plano.

Puede crear su propio Goroutine simplemente usando la palabra clave go como prefijo de la función o llamada al método, como se muestra en la siguiente sintaxis:

Sintaxis:

func name(){
// statements
}

// using go keyword as the 
// prefix of your function call
go name()

Ejemplo:

// Go program to illustrate
// the concept of Goroutine
package main
  
import "fmt"
  
func display(str string) {
    for w := 0; w < 6; w++ {
        fmt.Println(str)
    }
}
  
func main() {
  
    // Calling Goroutine
    go display("Welcome")
  
    // Calling normal function
    display("GeeksforGeeks")
}

Producción:

GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks

En el ejemplo anterior, simplemente creamos una función de visualización() y luego llamamos a esta función de dos maneras diferentes, la primera es una Goroutine, es decir, ir a mostrar («Bienvenido») y la otra es una función normal, es decir, mostrar («GeeksforGeeks» ) . Pero hay un problema, solo muestra el resultado de la función normal que no muestra el resultado de Goroutine porque cuando se ejecuta un nuevo Goroutine, la llamada de Goroutine regresa inmediatamente. El control no espera a que Goroutine complete su ejecución como una función normal, siempre avanza a la siguiente línea después de la llamada de Goroutine e ignora el valor devuelto por Goroutine. Entonces, para ejecutar Goroutine correctamente, hicimos algunos cambios en nuestro programa como se muestra en el siguiente código:

Ejemplo modificado:

// Go program to illustrate the concept of Goroutine
package main
  
import (
    "fmt"
    "time"
)
  
func display(str string) {
    for w := 0; w < 6; w++ {
        time.Sleep(1 * time.Second)
        fmt.Println(str)
    }
}
  
func main() {
  
    // Calling Goroutine
    go display("Welcome")
  
    // Calling normal function
    display("GeeksforGeeks")
}

Producción:

Welcome
GeeksforGeeks
GeeksforGeeks
Welcome
Welcome
GeeksforGeeks
GeeksforGeeks
Welcome
Welcome
GeeksforGeeks
GeeksforGeeks

Agregamos el método Sleep() en nuestro programa que hace que la Goroutine principal duerma durante 1 segundo entre 1 segundo que se ejecuta la nueva Goroutine, muestra » bienvenida » en la pantalla y luego finaliza después de 1 segundo Goroutine principal vuelve a programar y realizar su operación. Este proceso continúa hasta que el valor de z<6 después de eso finaliza la Goroutine principal. Aquí, tanto Goroutine como la función normal funcionan simultáneamente.

Para leer más sobre Goroutines, puede consultar el artículo Goroutines

Canales

Un canal es una técnica que permite que una gorutina envíe datos a otra gorutina. Por defecto, el canal es bidireccional, lo que significa que las rutinas pueden enviar o recibir datos a través del mismo canal, como se muestra en la siguiente imagen:

En el lenguaje Go, un canal se crea usando la palabra clave chan y solo puede transferir datos del mismo tipo, no se permite el transporte de diferentes tipos de datos desde el mismo canal.

Sintaxis:

var Channel_name chan Type

También puede crear un canal usando la función make() usando una declaración abreviada.

Sintaxis:

channel_name:= make(chan Type)

La siguiente declaración indica que los datos (elemento) se envían al canal (Mychannel) con la ayuda de un operador <- .

Mychannel <- element

La siguiente declaración indica que el elemento recibe datos del canal (Mychannel).

element := <-Mychannel

Si el resultado de la declaración recibida no se va a utilizar también es una declaración válida. También puede escribir una instrucción de recepción como:

<-Mychannel

Ejemplo:

// Go program to illustrate send
// and receive operation
package main
  
import "fmt"
  
func myfunc(ch chan int) {
  
    fmt.Println(234 + <-ch)
}
func main() {
    fmt.Println("start Main method")
    // Creating a channel
    ch := make(chan int)
  
    go myfunc(ch)
    ch <- 23
    fmt.Println("End Main method")
}

Producción:

start Main method
257
End Main method

Para leer más, puede consultar el artículo Canales en Golang .

Seleccionar estado de cuenta

La declaración de selección es como la declaración de cambio , pero en la declaración de selección, la declaración de caso se refiere a la comunicación, es decir, la operación de envío o recepción en el canal.

Sintaxis:

select{

case SendOrReceive1: // Statement
case SendOrReceive2: // Statement
case SendOrReceive3: // Statement
.......
default: // Statement

Ejemplo:

// Go program to illustrate the
// concept of select statement
package main
   
import("fmt"
 "time")
       
    // function 1
    func portal1(channel1 chan string) {
  
        time.Sleep(3*time.Second)
        channel1 <- "Welcome to channel 1"
    }
       
    // function 2
     func portal2(channel2 chan string) {
  
        time.Sleep(9*time.Second)
        channel2 <- "Welcome to channel 2"
    }
   
// main function
func main(){
       
    // Creating channels
   R1:= make(chan string)
   R2:= make(chan string)
      
   // calling function 1 and 
   // function 2 in goroutine
   go portal1(R1)
   go portal2(R2)
  
   select{
  
        // case 1 for portal 1
       case op1:= <- R1:
       fmt.Println(op1)
   
       // case 2 for portal 2
       case op2:= <- R2:
       fmt.Println(op2)
   }
      
}

Producción:

Welcome to channel 1

Explicación: En el programa anterior, el portal 1 duerme durante 3 segundos y el portal 2 duerme durante 9 segundos después de que termine su tiempo de sueño, estarán listos para continuar. Ahora, la declaración de selección espera hasta su hora de dormir, cuando el portal 2 se despierta, selecciona el caso 2 e imprime «Bienvenido al canal 1». Si el portal 1 se despierta antes que el portal 2, la salida es «bienvenido al canal 2».