Go
Paquetes

Inicialización de paquetes

El paquete puede tener métodos de init que se ejecutan solo una vez antes de main.

package usefull

func init() {
    // init code
}

Si solo desea ejecutar la inicialización del paquete sin hacer referencia a nada, use la siguiente expresión de importación.

import _ "usefull"

Gestionando dependencias de paquetes.

Una forma común de descargar las dependencias de Go es mediante el comando go get <package> , que guardará el paquete en el directorio global / shared $GOPATH/src . Esto significa que una única versión de cada paquete se vinculará a cada proyecto que lo incluya como una dependencia. Esto también significa que cuando un nuevo desarrollador implemente su proyecto, go get la última versión de cada dependencia.

Sin embargo, puede mantener el entorno de compilación consistente, adjuntando todas las dependencias de un proyecto en el directorio del vendor/ . Mantener las dependencias vendidas comprometidas junto con el repositorio de su proyecto le permite realizar versiones de dependencia por proyecto y proporcionar un entorno coherente para su compilación.

Así se verá la estructura de tu proyecto:

$GOPATH/src/
├── github.com/username/project/
|   ├── main.go 
|   ├── vendor/
|   |   ├── github.com/pkg/errors
|   |   ├── github.com/gorilla/mux

Usando diferentes paquetes y nombres de carpetas

Está perfectamente bien usar un nombre de paquete que no sea el nombre de la carpeta. Si lo hacemos, todavía tenemos que importar el paquete en función de la estructura del directorio, pero después de la importación debemos referirnos a él por el nombre que usamos en la cláusula del paquete.

Por ejemplo, si tiene una carpeta $GOPATH/src/mypck , y en ella tenemos un archivo a.go :

package apple

const Pi = 3.14

Utilizando este paquete:

package main

import (
    "mypck"
    "fmt"
)

func main() {
    fmt.Println(apple.Pi)
}

A pesar de que esto funciona, debería tener una buena razón para desviar el nombre del paquete del nombre de la carpeta (o puede convertirse en una fuente de malentendidos y confusión).

¿Para qué sirve esto?

Sencillo. Un nombre de paquete es un identificador Go:

identifier = letter { letter | unicode_digit } .

Lo que permite usar letras Unicode en identificadores, por ejemplo, αβ es un identificador válido en Go. Los nombres de carpetas y archivos no son manejados por Go, sino por el sistema operativo, y los diferentes sistemas de archivos tienen diferentes restricciones. En realidad, hay muchos sistemas de archivos que no permitirían todos los identificadores Go válidos como nombres de carpetas, por lo que no podría nombrar sus paquetes lo que de otro modo permitiría la especificación de idioma.

Al tener la opción de usar nombres de paquetes diferentes a los de las carpetas que contienen, tiene la opción de nombrar realmente a sus paquetes lo que permite la especificación de idioma, independientemente del sistema operativo y de archivos subyacente.

Importando paquetes

Puede importar un solo paquete con la declaración:

import "path/to/package"

o agrupar múltiples importaciones juntas:

import (
    "path/to/package1"
    "path/to/package2"
)

Esto se verá en los correspondientes import caminos en el interior de la $GOPATH para .go archivos y le permite acceder a los nombres exportados a través packagename.AnyExportedName .

También puede acceder a los paquetes locales dentro de la carpeta actual introduciendo los paquetes con ./ . En un proyecto con una estructura como esta:

project
├── src
│   ├── package1
│   │   └── file1.go
│   └── package2
│       └── file2.go
└── main.go

Puede llamar a esto en main.go para importar el código en file1.go y file2.go :

import (
    "./src/package1"
    "./src/package2"
)

Dado que los nombres de paquetes pueden colisionar en diferentes bibliotecas, es posible que desee asignar un alias de un paquete a un nombre nuevo. Puede hacer esto prefijando su declaración de importación con el nombre que desea usar.

import (
    "fmt" //fmt from the standardlibrary
    tfmt "some/thirdparty/fmt" //fmt from some other library
)

Esto le permite acceder a la antigua fmt paquete mediante fmt.* Y el segundo fmt paquete utilizando tfmt.* .

También puede importar el paquete en el propio espacio de nombres, de modo que puede hacer referencia a los nombres exportados sin el package. prefijo usando un solo punto como alias:

import (
    . "fmt"
)

El ejemplo anterior importa fmt en el espacio de nombres global y le permite llamar, por ejemplo, directamente a Printf : Playground

Si importa un paquete pero no utiliza ninguno de sus nombres exportados, el compilador Go imprimirá un mensaje de error. Para evitar esto, puede establecer el alias en el guión bajo:

import (
    _ "fmt"
)

Esto puede ser útil si no accede directamente a este paquete pero necesita las funciones de init para ejecutarse.

Nota:

Como los nombres de los paquetes se basan en la estructura de la carpeta, cualquier cambio en los nombres de las carpetas y las referencias de importación (incluida la distinción entre mayúsculas y minúsculas) causará un error de compilación "colisión de importación insensible a mayúsculas y minúsculas" en Linux y OS-X, que es difícil de rastrear y corregir (el mensaje de error es un tanto críptico para simples mortales, ya que trata de transmitir lo contrario: la comparación falló debido a la sensibilidad del caso).

ej: "ruta / a / paquete1" vs "ruta / a / paquete1"

Ejemplo en vivo: https://github.com/akamai-open/AkamaiOPEN-edgegrid-golang/issues/2