Importar en GoLang

Prerrequisito de aprendizaje: Instalación de Go en Windows / Instalación de Go en MacOS 

Definiendo técnicamente, un paquete es esencialmente un contenedor de código fuente para algún propósito específico. Esto significa que el paquete es una cápsula que contiene múltiples elementos de fármaco/medicamento uniéndolos a todos y protegiéndolos en una mini cubierta. Esta cápsula es fácil de llevar a cualquier lugar y usarla como quieras, ¿verdad? Sí es cierto. Puede escribir miles de líneas de código, cientos de funciones, n cantidad de operaciones y mucho más en un paquete y almacenarlo para que pueda tomar el paquete en su archivo principal cuando lo necesite. Muchos paquetes vienen prediseñados con Go. 

Los paquetes son muy esenciales ya que en todos los programas se utilizan desde los programas más básicos hasta códigos complejos de alto nivel. Un paquete garantiza que no se repita ningún código y que el código principal sea lo más conciso posible de una manera bien estructurada.

Ejemplo:

package main

El paquete principal contiene el código responsable de hacer que el programa actual sea compilable y ejecutable. 

Importar palabra clave y su importancia

Los paquetes, como hemos discutido, son dulces que nos ayudan a codificar en Go. Ahora la pregunta es ¿cómo los usamos en nuestro programa? La respuesta es simple: usando la palabra clave “ importar ”. Como sugiere el nombre, esta palabra clave importa el paquete especificado desde el directorio de $GOPATH (si no se menciona ninguna ruta) o desde el directorio mencionado. Importar simplemente significa llevar el paquete especificado desde su ubicación de origen al código de destino, con el programa principal. Importar en Go es muy importante porque ayuda a traer los paquetes que son súper esenciales para ejecutar programas. Este artículo cubre varios aspectos de «Importaciones en Go».

Ejemplo:

import "fmt" --------------------------------> fmt is the name of a package
import "os" ---------------------------------> os is the name of a package
import "github.com/gopherguides/greet" ------> the underlined part is the path of the package

Tipos de importaciones en Golang

Pues sí, existen diferentes tipos de importaciones, muchas de las cuales son desconocidas para muchos usuarios. Vamos a discutir estos tipos en detalle. Consideremos un paquete: digamos matemáticas y observemos las diferencias en los estilos de importación.

1. Importación directa

Go admite la importación directa de paquetes siguiendo una sintaxis simple. Tanto los paquetes individuales como los múltiples se pueden importar uno por uno usando la palabra clave de importación.

Ejemplo:

Single:
import "fmt"

Multiple one-by-one:
import "fmt"
import "math"

// Golang program to demonstrate the 
// application of direct import
package main
    
import "fmt"
    
// Main function
func main() {
    fmt.Println("Hello Geeks")
}

2. Importación agrupada

Go también admite importaciones agrupadas. Esto significa que no tiene que escribir la palabra clave de importación varias veces; en su lugar, puede usar la palabra clave import seguida de llaves redondas(), y mencionar todos los paquetes dentro de las llaves redondas que desea importar. Esta también es una importación directa, pero la diferencia es que ha mencionado varios paquetes dentro de una importación() aquí. Mire el ejemplo para tener una idea de la sintaxis del comando de importación agrupado.

Ejemplo:

import(
    "fmt"
    "math"
)

// A program to demonstrate the
// application of grouped import
package main
    
import (
    "fmt"
    "math"
)
    
// Main function
func main() {
  
    // math.Exp2(5) returns 
    // the value of 2^5, wiz 32
    c := math.Exp2(5)
      
    // Println is a function in fmt package 
    // which prints value of c in a new
    // line on console
    fmt.Println(c)
      
}

3. Importación anidada

Go también admite importaciones anidadas. Justo cuando oímos el nombre de importación anidada, de repente pensamos en las sentencias if-else de escalera de bucles anidados, etc. Pero la importación anidada no es nada de eso: es diferente de esos elementos anidados. Aquí, la importación anidada significa importar un subpaquete desde un archivo de paquete más grande. Por ejemplo, hay momentos en los que solo necesita usar una función particular del paquete completo y, por lo tanto, no desea importar el paquete completo y aumentar el tamaño de la memoria del código y cosas por el estilo, en resumen, solo desea un sub -paquete. En tales escenarios, usamos la importación anidada. Mire el ejemplo para seguir la sintaxis y el código de ejemplo para una mejor comprensión.

Ejemplo:

import "math/rand"

// Golang Program to demonstrate
// application of nested import
package main
   
 import (
    "fmt"
    "math/rand"
)
  
func main() {
  
    // this generates & displays a
    // random integer value < 100
    fmt.Println(rand.Int(100))
}

4. Importación con alias

También admite importaciones con alias. Bueno, a veces estamos cansados ​​de escribir el nombre completo una y otra vez en nuestro código, ya que puede ser largo o aburrido o lo que sea, por lo que desea cambiarle el nombre. La importación de alias es solo eso. No cambia el nombre del paquete, pero usa el nombre que usted menciona para el paquete y crea un alias de ese paquete, lo que le da la impresión de que se ha cambiado el nombre del paquete. Considere el ejemplo de sintaxis y código de ejemplo para una mejor comprensión de la importación con alias.

Ejemplo:

import m "math"
import f "fmt"

// Golang Program to demonstrate
// the application of aliased import
package main
    
import (
    f "fmt"
    m "math"
)
    
// Main function
func main() {
  
    // this assigns value 
    // of 2^5 = 32 to var c
    c := m.Exp2(5)    
      
    // this prints the 
    // value stored in var c
    f.Println(c)                
}

5. Importación de puntos

Go admite importaciones de puntos. La importación de puntos es algo de lo que la mayoría de los usuarios no han oído hablar. Básicamente es un tipo raro de importación que se usa principalmente para fines de prueba. Los evaluadores utilizan este tipo de importación para comprobar si sus estructuras/funciones/elementos de paquetes públicos funcionan correctamente. La importación de puntos proporciona las ventajas de usar elementos de un paquete sin mencionar el nombre del paquete y se puede usar directamente. Por muchas ventajas que ofrece, también trae consigo un par de inconvenientes, como las colisiones de espacios de nombres. Consulte el ejemplo de sintaxis y código de ejemplo para comprender mejor la importación de puntos.

Ejemplo:

import . "math"

// Golang Program to demonstrate 
// the application of dot import
package main
  
import (
    "fmt"
    . "math"
)
   
func main() {
  
    // this prints the value of
    // 2^5 = 32 on the console
    fmt.Println(Exp2(5))      
}

6. Importación en blanco

Go admite importaciones en blanco. En blanco significa vacío. Así es. Muchas veces no planificamos todos los paquetes que requerimos o el blueprint de un código que vamos a escribir en el futuro. Como resultado, a menudo importamos muchos paquetes que nunca usamos en el programa. Entonces Go surge errores ya que cualquier cosa que importemos en Go, debemos usarla. La codificación es un proceso impredecible, en un momento necesitamos algo y en el siguiente caso, no. 

Pero go no hace frente a esta inconsistencia y es por eso que ha proporcionado la instalación de importaciones en blanco. Podemos importar el paquete y no usarlo colocando un espacio en blanco. De esta manera, su programa se ejecuta con éxito y puede eliminar el espacio en blanco cada vez que desee usar ese paquete. Consulte el código para ver la sintaxis y el código de ejemplo para una mejor comprensión de la importación en blanco.

Ejemplo:

import _ "math"

// PROGRAM1
package main
// Program to demonstrate importance of blank import
   
import (
    "fmt"
    "math/rand"
)
   
func main() {
    fmt.Println("Hello Geeks")
}
  
// -------------------------------------------------------------------------------------
// Program1 looks accurate and everything 
// seems right but the compiler will throw an
// error upon building this code. Why? Because 
// we imported the math/rand package but
// We didn't use it anywhere in the program. 
// That's why. The following code is a solution.
//-------------------------------------------------------------------------------------
  
// PROGRAM2
package main
// Program to demonstrate application of blank import
   
import (
    "fmt"
    _ "math/rand"
)
   
func main() {
    fmt.Println("Hello Geeks")
    // This program compiles successfully and
    // simply prints Hello Geeks on the console.
}

7. Importación relativa

Cuando creamos nuestros paquetes y los colocamos en un directorio local o en el directorio de la nube, en última instancia, el directorio $GOPATH o dentro de eso, encontramos que no podemos importar directamente el paquete con su nombre a menos que lo convierta en su $GOPATH. Entonces, menciona una ruta donde está disponible el paquete personalizado. Este tipo de importaciones se denominan importaciones relativas. A menudo usamos este tipo, pero es posible que no sepamos su nombre (importación relativa). Consulte el ejemplo de sintaxis y código de ejemplo para comprender mejor la importación relativa.

Ejemplo:

import "github.com/gopherguides/greet"

package main
    
import "github.com/gopherguides/greet"
    
// Main function
func main() {
    // The hello function is in
    // the mentioned directory
    greet.Hello()
    // This function simply prints 
    // hello world on the console screen
}

8. Importación circular

Al igual que un círculo, un bucle, también existe una importación circular. Esto significa definir un paquete que importe implícitamente un segundo paquete y definir el segundo paquete de manera que importe implícitamente el primer paquete. Esto crea un bucle oculto que se llama » bucle de importación «. Muchos también desconocen este tipo y eso se debe a que Go no admite explícitamente las importaciones circulares. Al compilar dichos paquetes, el compilador Go arroja un error que genera una advertencia: «ciclo de importación no permitido». Considere los siguientes ejemplos para entender esto mejor.

// First package file code. Imagine that name of first package is "first"
package first

import "second"
// Imagine that the second package's name is "second"

var a = second.b
// Assigning value of variable b from second package to a in first package

// Second package file code. Imagine that name of second package is "second"
package second

import "first"
// Imagine that the first package's name is "first"

var b = first.a
// Assigning value of variable a from first package to b in second package

Upon building any one of these packages, you will find an error like this:
> go build
can't load package: import cycle not allowed
...