Un paquete Go consta de archivos Go ubicados en el mismo directorio, al principio del cual existe la misma expresión de
package . Los paquetes que se conectan a los programas le permiten ampliar sus capacidades. Algunos paquetes son parte de la biblioteca Go estándar. Esto significa que si usa Go, ya están instalados. Otros paquetes se instalan usando el comando
go get . También puede escribir sus propios paquetes Go, crear archivos en directorios especiales y cumplir con las reglas de diseño de paquetes.
El material, cuya traducción publicamos hoy, es una guía para el desarrollo de paquetes Go que se pueden conectar a otros archivos.
Prerrequisitos
- Configure su entorno de software Go (aprenda cómo hacer esto aquí ). Cree un espacio de trabajo Ir (el quinto punto del material anterior está dedicado a esto). En la siguiente sección de este material puede encontrar ejemplos que se recomienda reproducir en casa. Para que pueda lidiar mejor con ellos.
- Para profundizar su conocimiento de
GOPATH , eche un vistazo a este material.
Escribir e importar paquetes
Escribir el código del paquete es lo mismo que escribir el código Go normal. Los paquetes pueden contener declaraciones de funciones, tipos y variables, que luego se pueden utilizar en otros programas Go.
Antes de que podamos comenzar a crear un nuevo paquete, debemos ir al espacio de trabajo Ir. Se encuentra en la ruta especificada por la variable
GOPATH . Por ejemplo, dejemos que nuestra organización se llame
gopherguides . Al mismo tiempo, nosotros, como repositorio, usamos
GitHub . Esto lleva al hecho de que, a lo largo de la ruta especificada por
GOPATH , tenemos la siguiente estructura de carpetas:
└── $GOPATH └── src └── github.com └── gopherguides
Saludaremos el nombre del paquete que desarrollaremos en esta guía. Para hacer esto, cree el directorio
greet en el directorio
gopherguides . Como resultado, la estructura de carpetas existente tomará la siguiente forma:
└── $GOPATH └── src └── github.com └── gopherguides └── greet
Ahora estamos listos para agregar el primer archivo al directorio de
greet . Normalmente, un archivo que es el punto de entrada de un paquete se llama igual que el directorio del paquete. En este caso, esto significa que nosotros, en el directorio
greet , creamos el archivo
greet.go :
└── $GOPATH └── src └── github.com └── gopherguides └── greet └── greet.go
En este archivo podemos escribir código que queremos reutilizar en nuestros proyectos. En este caso, crearemos la función
Hello , que muestra el texto
Hello, World! .
Abra el archivo
greet.go en un editor de texto y agregue el siguiente código:
package greet import "fmt" func Hello() { fmt.Println("Hello, World!") }
Analicemos el contenido de este archivo. La primera línea de cada archivo debe contener el nombre del paquete en el que trabajamos. Como estamos en el
package greet , la palabra clave del
package se usa aquí, seguida del nombre del paquete:
package greet
Esto le dice al compilador que acepte todo en el archivo como parte del paquete
greet .
A continuación, los paquetes necesarios se importan utilizando la declaración de
import . En este caso, solo necesitamos un paquete:
fmt :
import "fmt"
Y finalmente, creamos la función
Hello . Ella usará las capacidades del paquete
fmt para mostrar la cadena
Hello, World! :
func Hello() { fmt.Println("Hello, World!") }
Ahora, después de crear el paquete de
greet , puede usarlo en cualquier otro paquete. Creemos un nuevo paquete en el que usaremos el paquete
greet .
A saber, crearemos un paquete de
example . Para hacer esto, procederemos de los mismos supuestos de los que procedemos, creando el paquete de
greet . Primero, cree la carpeta de
example en la carpeta
gopherguides :
└── $GOPATH └── src └── github.com └── gopherguides └── example
Ahora cree un archivo que sea el punto de entrada del paquete. Consideramos este paquete como un programa ejecutable, y no como un paquete cuyo código está planeado para usarse en otros paquetes. Los archivos que son los puntos de entrada de los programas generalmente se denominan
main.go :
└── $GOPATH └── src └── github.com └── gopherguides └── example └── main.go
Abra el archivo
main.go en el editor y
main.go siguiente código en él, lo que le permite usar las capacidades del paquete
greet :
package main import "github.com/gopherguides/greet" func main() { greet.Hello() }
Importamos el paquete
greet en el archivo
main.go , lo que significa que para llamar a la función declarada en este paquete, debemos usar la notación de puntos. Una notación de punto es una construcción en la que se coloca un punto entre el nombre del paquete y el nombre del recurso de este paquete que se utilizará. Por ejemplo, en el paquete
greet , la función
Hello desempeña el papel de un recurso. Si necesita llamar a esta función, se utiliza la notación de puntos
: greet.Hello() .
Ahora puede abrir la terminal y ejecutar el programa:
go run main.go
Después de hacer esto, el terminal mostrará lo siguiente:
Hello, World!
Ahora hablemos sobre cómo usar variables declaradas en paquetes. Para hacer esto, agregue la declaración de variable al archivo
greet.go :
package greet import "fmt" var Shark = "Sammy" func Hello() { fmt.Println("Hello, World!") }
Abra el archivo
main.go y agregue una línea donde se
fmt.Println() función
fmt.Println() para mostrar el valor de la variable
Shark declarada en el paquete
greet.go . A saber, traiga
main.go al siguiente formulario:
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) }
Ejecute el programa nuevamente:
go run main.go
Ahora ella mostrará lo siguiente:
Hello, World! Sammy
Ahora hablemos sobre cómo declarar tipos en paquetes. Cree un tipo de
Octopus con los campos
Name y
Color , y cree un método de tipo. Este método, cuando se llama, devolverá el contenido especialmente procesado de los campos
Octopus . Traigamos
greet.go a la siguiente forma:
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() { fmt.Println("Hello, World!") }
Ahora abra
main.go , cree una instancia de la estructura del nuevo tipo en él y consulte su método
String() :
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) }
Después de crear una instancia de
Octopus usando una construcción que se parece a
oct := greet.Octopus , puede acceder a los métodos y propiedades del tipo desde el
main.go archivo
main.go Esto, en particular, le permite usar el
oct.String() ubicado al final del archivo
main.go sin recurrir a
greet . Además, podemos, por ejemplo, referirnos al campo de la estructura de
Color usando la construcción
oct.Color . Al mismo tiempo, nosotros, como cuando llamamos al método, no accedemos a
greet .
El método
String del tipo
Octopus usa la función
fmt.Sprintf para formar la oración y devuelve, usando
return , el resultado, la cadena, a la llamada al método (en este caso, este lugar está en
main.go ).
Ejecute el programa nuevamente:
go run main.go
Producirá lo siguiente en la consola:
Hello, World! Sammy The octopus's name is "Jesse" and is the color orange.
Ahora que hemos equipado Octopus con el método
String , tenemos un mecanismo de salida de información de tipo adecuado para su reutilización. Si en el futuro necesita cambiar el comportamiento de este método, que puede usarse en muchos proyectos, será suficiente editar su código en
greet.go .
Exportación de entidad
Es posible que haya notado que todo lo que trabajamos al referirnos al paquete de
greet tiene nombres que comienzan con una letra mayúscula. Go no tiene modificadores de acceso como
public ,
private o
protected , que están en otros idiomas. La visibilidad de las entidades para los mecanismos externos está controlada por el hecho de que las letras, con una letra grande o pequeña, comienzan con sus nombres. Como resultado, los tipos, variables, funciones cuyos nombres comienzan con una letra mayúscula están disponibles fuera del paquete actual. El código que está visible fuera del paquete se llama exportado.
Si equipa el tipo
Octopus con un nuevo método llamado
reset , entonces este método puede llamarse desde el paquete
greet , pero no desde el archivo
main.go , que está fuera del paquete
greet . Aquí hay una versión actualizada de
greet.go :
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() { o.Name = "" o.Color = "" } func Hello() { fmt.Println("Hello, World!") }
Intentemos llamar a
reset desde el archivo
main.go :
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) oct.reset() }
Esto dará como resultado el siguiente error de compilación:
oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset)
Para exportar el método de
reset tipo
Octopus , debe cambiarle el nombre, reemplazando la primera letra, minúscula
r , con
R mayúscula
R Hacemos esto editando
greet.go :
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() { o.Name = "" o.Color = "" } func Hello() { fmt.Println("Hello, World!") }
Esto llevará al hecho de que podremos llamar a
Reset desde otros paquetes y sin encontrar mensajes de error:
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) oct.Reset() fmt.Println(oct.String()) }
Ejecute el programa:
go run main.go
Esto es lo que llega a la consola:
Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color .
Al llamar al método
Reset , borramos los campos
Name y
Color de nuestra instancia de
Octopus . Como resultado, cuando se llama a
String , donde se mostraba anteriormente el contenido de los campos
Name y
Color , ahora no se muestra nada.
Resumen
Escribir paquetes Go no es diferente a escribir código Go regular. Sin embargo, colocar el código del paquete en sus propios directorios permite aislar el código, que puede usarse en cualquier otro proyecto Go. Aquí hablamos sobre cómo declarar funciones, variables y tipos en paquetes, examinamos cómo usar estas entidades fuera de los paquetes y descubrimos dónde almacenar paquetes diseñados para su uso repetido.
Estimados lectores! ¿Qué programas sueles escribir en Go? ¿Usas paquetes propietarios en ellos?
