Estructura del sistema de archivos de un proyecto de Go

Estructura de carpetas

Los proyectos Go están compuestos porpaquetes. Llamamoscomandoslos paquetes que tienen elmainidentificador.

Un proyecto puede tener

  • 1paquete
  • npaquetes
  • 1mando
  • 1comando y1paquete
  • ncomandos y1paquete
  • 1comando ynpaquetes
  • ncomandos ynpaquetes

Dependiendo de la naturaleza de su proyecto, necesita organizar la estructura de carpetas de cierta manera.

Algunos ejemplos del mundo real

Veamos algunos ejemplos del mundo real de esto en la naturaleza, aquí abajo. Los tomé deCinco sugerencias para configurar un proyecto de Gopor Dave Cheney.

Ejemplo de un proyecto con1paquete:

https://github.com/kr/fs

Ejemplo de un proyecto connpaquetes

https://github.com/pkg/term

Ejemplo de un proyecto con1mando

https://github.com/tools/godep

Ejemplo de un proyecto con1comando y1paquete

https://github.com/monochromegane/the_platinum_searcher

Ejemplo de un proyecto conncomandos ynpaquetes

https://github.com/golang/tools

Convenciones para la estructura de archivos dentro de un proyecto

De esos ejemplos podemos deducir estas convenciones:

Si tiene un comando, puede vivir en unmain.goarchivo en la raíz del proyecto.

Con más de un comando, cree uncmd/carpeta, y debajo de esta, cree una carpeta con el nombre del comando. En cada carpeta, idealmente una.goarchivo con el mismo nombre contendrá elmain()función, aunque no es obligatorio.

Los paquetes van en su propia carpeta, a menos que solo tenga un paquete.

Ubicación del sistema de archivos para los paquetes instalados

Cualquier proyecto de Go se puede instalar usandogo get.go getinstalará paquetes bajo$GOPATH/src. Por ejemplo escribiendo

go get github.com/kr/fs

descargará e instalará el repositorio de 1 paquete ubicado enhttps://github.com/kr/fs, y lo pondrá bajo$GOPATH/src/github.com/kr/fs. Podemos hacer referencia a él en nuestros programas usandoimport github.com/kr/fs.

¿Y si escribimos?

go get github.com/tools/godep

¿en lugar de? Recuerde, este es el repositorio de un comando que enumeramos antes.

go getlo descargará como lo hizo paragithub.com/kr/fsy ponerlo debajo$GOPATH/src, PERO como es un comando, también compilará y creará un$GOPATH/bin/godepbinario.

Los comandos Go se compilan con el nombre de la carpeta adjunta, en este caso la carpeta era la raíz, por lo que esgodep. En el caso de varios comandos, tomará elúltima subcarpetanombre. Por ejemplo, un idealgithub.com/flaviocopes/tools/cmd/unzipsería compilado paraunzip. Lo hacenotomar el nombre del archivo que contiene elmain()función.

Espacios de trabajo

Go tiene un concepto bastante único deespacio de trabajo. Un espacio de trabajo es la estructura de carpetas que$GOPATHpuntos a. Cuando cree un nuevo espacio de trabajo, agregue el$GOPATH/bincarpeta a su ruta también. Por ejemplo, si desea configurar su espacio de trabajo en~/go(que por cierto es el predeterminado):

export GOPATH=~/go
export PATH=~/go/bin:$PATH

Ahora, cualquier código de Go que ejecute hará referencia a esta carpeta. Esto le permite crear espacios de trabajo separados, aunque como se indicóen los documentos oficiales,

Los programadores de Go suelen mantener todo su código de Go en un solo espacio de trabajo.

Tenga en cuenta que esto difiere de otros entornos de programación en los que cada proyecto tiene un espacio de trabajo independiente y los espacios de trabajo están estrechamente vinculados a los repositorios de control de versiones.

Este es un ejemplo de un espacio de trabajo, que se enumera en los documentos oficiales:

    bin/
        hello                          # command executable
        outyet                         # command executable
    pkg/
        linux_amd64/
            github.com/golang/example/
                stringutil.a           # package object
    src/
        github.com/golang/example/
            .git/                      # Git repository metadata
        hello/
            hello.go               # command source
        outyet/
            main.go                # command source
            main_test.go           # test source
        stringutil/
            reverse.go             # package source
            reverse_test.go        # test source
        golang.org/x/image/
            .git/                  # Git repository metadata
        bmp/
            reader.go              # package source
            writer.go              # package source
        #... (many more repositories and packages omitted) ...

Sabiendo esto, veamos ...

Dónde colocar sus comandos y paquetes

Al ejecutar comandos usandogo run, puede tener su proyecto en cualquier lugar que desee, pero este es un enfoque útil solo para pruebas rápidas.

Debes crear tus programas dentro del$GOPATH/srccarpeta, con su espacio de nombres exclusivo, por ejemplo

$GOPATH/src/github.com/flaviocopes/hello

Cuando se ejecuta (desde cualquier lugar del sistema)

go install github.com/flaviocopes/hello

Go compilará y pondrá elhellobinario en$GOPATH/bin, listo para ejecutarse desde cualquier lugar del sistema.

Lo mismo ocurre con los paquetes,exceptoque al corrergo install, pondrá el paquete compilado en$GOPATH/pkg.

Referencia


Más tutoriales de go: