105 lines
7.0 KiB
Markdown
105 lines
7.0 KiB
Markdown
# 1.3 Comandos Go
|
|
|
|
## Comandos Go
|
|
|
|
El lenguaje Go viene con un conjunto completo de herramientas de comandos operacionales. Puedes ejecutar en la lína de comando `go` para verlas:
|
|
|
|
|
|
|
|
Imagen 1.3 El comando Go muestra información detallada.
|
|
|
|
Todos estos nos son muy útiles, veamos cómo usar algunos de ellos.
|
|
|
|
## go build
|
|
|
|
Este comando es para pruebas de compilación. Compilará paquetes dependientes de ser necesario.
|
|
|
|
- Si el paquete no es el paquete principal `main` como `mymath` en la sección 1.2, nada será generado después de ejecutar `go build`. Si necesitas el archivo de paquete `.a` en `$GOPATH/pkg`, mejor usa `go install`.
|
|
- Si el paquete es el paquete principal `main`, generará un archivo ejecutable en el mismo directorio. Si quieres que el archivo sea generado en `$GOPATH/bin`, usa `go install` o `go build -o ${PATH_HERE}/a.exe.`
|
|
- Si hay muchos archivos en el directorio, pero solamente deseas compilar uno de ellos, debes anexar el nombre del archivo después de `go build`. Por ejemplo, `go build a.go`. `go build` compilará todos los archivos en el directorio.
|
|
- También puedes asignar el nombre del archivo que será generado. Por ejemplo, en el proyecto `mathapp` (en la sección 1.2), usando `go build -o astaxie.exe` generará `astaxie.exe` en vez de `mathapp.exe`. El nombre por defecto es el nombre de tu directorio (en paquetes no principales non-main) o el primer nombre de archivo de código fuente (paquetes principales main).
|
|
|
|
(De acuerdo a la [Especificación del Lenguaje de Programación Go](https://golang.org/ref/spec), los nombres de paquetes deben ser el nombre después de la palabra `package` en la primera línea de tus archivos de código fuente. No tiene que ser el mismo que el nombre del directorio y el nombre del archivo ejecutable será, por defecto, el del nombre de tu directorio)
|
|
|
|
- `go build` ignora archivos cuyos nombres empiezan con `_` o `.`.
|
|
- Si deseas tener diferentes archivos fuentes para cada sistema operativo, puedes nombrar los archivos con el nombre del sistema operativo como sufijo. Supongamos que existen archivos fuentes para cargar arreglos. Pueden ser nombrados de la siguiente forma:
|
|
|
|
array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
|
|
|
|
`go build` escoge el que está asociado con tu sistema operativo. Por ejemplo, solamente compila array_linux.go en sistemas Linux e ignora todos los demás.
|
|
|
|
## go clean
|
|
|
|
Este comando es para limpiar los archivos que son generados por los compiladores, incluyendo los siguientes archivos:
|
|
```
|
|
_obj/ // viejo directorio de object, dejado por Makefiles
|
|
_test/ // viejo directorio de test, dejado por Makefiles
|
|
_testmain.go // viejo directorio de gotest, dejado por Makefiles
|
|
test.out // viejo directorio de test, dejado por Makefiles
|
|
build.out // viejo directorio de test, dejado por Makefiles
|
|
*.[568ao] // object files, dejado por Makefiles
|
|
|
|
DIR(.exe) // generado por go build
|
|
DIR.test(.exe) // generado por go test -c
|
|
MAINFILE(.exe) // generado por go build MAINFILE.go
|
|
```
|
|
Usualmente utilizo este comando para limpiar mis archivos antes de subir mi proyecto a Github. Estas son herramientas útiles para pruebas locales, pero inútiles para el control de versiones.
|
|
|
|
## go fmt
|
|
|
|
La gente que trabaja con C/C++ deben saber que la gente siempre están argumentando qué estilo de código es mejor: estilo K&R o ANSI. Sin embargo, en Go, solamente hay un estilo de código que es forzado. Por ejemplo, llave izquierda solamente debe ser insertada al final de las líneas y no pueden estar en sus propias líneas, de otra forma tendrás errores de compilación! Afortunadamente, no debes recordar estas reglas `go fmt` hace este trabajo por ti. Solamente ejecuta el comando `go fmt <Nombre de Archivo>.go` en la terminal. No uso mucho este comando, porque los IDEs usualmente ejecutan este comando automáticamente cuando guardas tu código fuente. Hablaré más respecto a los IDEs en la siguiente sección.
|
|
|
|
Usualmente usamos `gofmt -w` en vez de `go fmt`. El último, no rescribirá tus archivos después de formatearlos, `gofmt -w src` formatea todo el proyecto.
|
|
|
|
## go get
|
|
|
|
Este comando es para obtener paquetes remotos. Hasta el momento soporta BitBucket, GitHub, Google Code y Launchpad. Actualmente existen dos cosas que suceden después de ejecutar este comando. La primera es que Go descarga el código fuente, luego ejecuta `go install`. Antes de que utilices este comando, asegúrate que tienes instaladas todas las herramientas relacionadas.
|
|
```
|
|
BitBucket (Mercurial Git)
|
|
GitHub (git)
|
|
Google Code (Git, Mercurial, Subversion)
|
|
Launchpad (Bazaar)
|
|
```
|
|
Para poder usar este comando, debes instalar estas herramientas correctamente. No olvides establecer `$PATH`. Por cierto, también soporta nombres de dominios customizados. Usa `go help remote` para más detalles al respecto.
|
|
|
|
## go install
|
|
|
|
Este comando compila todos los paquetes y genera archivos, luego los mueve a `$GOPATH/pkg` o `$GOPATH/bin`.
|
|
|
|
## go test
|
|
|
|
Este comando carga todos los archivos cuyos nombres incluyen `*_test.go` y genera archivos de pruebas, luego muestra información que se ve de la siguiente forma.
|
|
```
|
|
ok archive/tar 0.011s
|
|
FAIL archive/zip 0.022s
|
|
ok compress/gzip 0.033s
|
|
...
|
|
```
|
|
Prueba todos tus archivos de prueba por defecto. Usa el comando `go help testflag` para más detalles.
|
|
|
|
## go doc
|
|
|
|
Muchas personas dicen que no necesitamos ninguna herramienta de documentación adicional para programar en Go (En realidad, ya he hecho un [CHM](https://github.com/astaxie/godoc)). Go tiene nativamente una herramienta de documentación poderosa.
|
|
|
|
Así que, cómo buscamos información de paquetes en la documentación? Por ejemplo, si deseas encontrar más detalles del paquete `builtin`, usa el comando `go doc builtin`. Similarmente, usa el comando `go doc net/http` para buscar la documentación del paquete `http`. Si quieres ver más detalles de funciones específicas, usa los comandos `godoc fmt Printf` y `godoc -src fmt Printf` para ver el código fuente.
|
|
|
|
Ejecuta el comando `godoc -http=:8080`, luego abre `127.0.0.1:8080` en tu navegador. Debes ver una versión localizada de golang.org. Puede no solamente mostrar la información de los paquetes estándar, sino también puede mostrar los paquetes en tu `$GOPATH/pkg`. Es grandiosa para aquellas personas que sufren del firewall en China.
|
|
|
|
## Otros comandos
|
|
|
|
Go provee comandos adicionales a los que ya mostramos.
|
|
```
|
|
go fix // actualiza código de una vieja versión antes de go1 a una nueva versión después de go1
|
|
go version // muestra información de tu versión de Go
|
|
go env // muestra las variables de entorno relacionadas a Go
|
|
go list // lista todos los paquetes instalados
|
|
go run // compila los archivos temporales y ejecuta la aplicación
|
|
```
|
|
También hay más detalles de los comandos que hemos hablado, puedes usar el comando `go help <nombre de comando>` para mostrarlos.
|
|
|
|
## Links
|
|
|
|
- [Índice](preface.md)
|
|
- Sección anterior: [$GOPATH y el ambiente de trabajo](01.2.md)
|
|
- Sección siguiente: [Herramientas de Desarrollo para Go](01.4.md)
|