go - sociales - proyectos pdf ejemplos

¿Cuál es una forma sensata de diseñar un proyecto Go?

Question

Tengo un proyecto de ir que se está empezando a volver más complejo, y quiero establecer el sistema de archivos de tal manera que se reduzca el dolor.

¿Hay algunos buenos ejemplos de lo que tiene sentido?

Answer 1

Hay un enfoque recomendado de los autores de Golang que define cómo diseñar su código para que funcione mejor con las herramientas go y para admitir sistemas de control de fuente

Answer 2

Probablemente también deberías echar un vistazo a este repositorio. Muestra muchas ideas sobre cómo estructurar las aplicaciones: https://github.com/golang-standards/project-layout

Answer 3

Supongo que con ''proyecto'' no significa un paquete Go, sino un software que desarrolla. De lo contrario, puedes obtener ayuda here y here . Sin embargo, no es tan diferente a escribir paquetes para Go: use paquetes, cree una carpeta para cada paquete y combine esos paquetes en su aplicación.

Para formarse una opinión, puede consultar los repositorios de Go en github: https://github.com/trending/go . Ejemplos notables son cayley y zeus .

El esquema más popular probablemente sea tener un archivo Go principal y muchos módulos y submódulos en sus propios directorios. En caso de que tenga muchos archivos meta (documento, licencia, plantillas, ...), puede colocar el código fuente en un subdirectorio. Eso es lo que hice hasta ahora.

Answer 4

Actualización de mayo de 2013: la documentación oficial se encuentra en la sección " Organización del código "

El código de Go debe mantenerse dentro de un espacio de trabajo .
Un espacio de trabajo es una jerarquía de directorios con tres directorios en su raíz:

• src contiene archivos fuente de Go organizados en paquetes (un paquete por directorio),
• pkg contiene objetos del paquete, y
• bin contiene comandos ejecutables.

La go tool crea paquetes fuente e instala los binarios resultantes en los directorios pkg y bin .

El subdirectorio src típicamente contiene múltiples repositorios de control de versiones (como Git o Mercurial) que rastrean el desarrollo de uno o más paquetes fuente.

bin/
    streak                         # command executable
    todo                           # command executable
pkg/
    linux_amd64/
        code.google.com/p/goauth2/
            oauth.a                # package object
        github.com/nf/todo/
            task.a                 # package object
src/
    code.google.com/p/goauth2/
        .hg/                       # mercurial repository metadata
        oauth/
            oauth.go               # package source
            oauth_test.go          # test source

Actualización de julio de 2014: ver " Estructuración de aplicaciones en Go " de Ben Johnson

Ese artículo incluye consejos como:

Separe su binario de su aplicación

combinar el archivo main.go y la lógica de mi aplicación en el mismo paquete tiene dos consecuencias:

• Hace que mi aplicación no se pueda usar como una biblioteca.
• Solo puedo tener una aplicación binaria.

La mejor manera que he encontrado para solucionar esto es simplemente usar un directorio " cmd " en mi proyecto donde cada uno de sus subdirectorios es una aplicación binaria.

camlistore/
  cmd/
    camget/
      main.go
    cammount/
      main.go
    camput/
      main.go
    camtool/
      main.go

Desarrollo impulsado por la biblioteca

Al mover el archivo main.go desde su raíz, puede crear su aplicación desde la perspectiva de una biblioteca. El binario de su aplicación es simplemente un cliente de la biblioteca de su aplicación.

En ocasiones, es posible que desee que los usuarios interactúen de múltiples maneras para que pueda crear varios binarios.
Por ejemplo, si tiene un paquete " adder " que le permite a los usuarios agregar números juntos, es posible que desee liberar una versión de línea de comando y una versión web.
Puede hacerlo fácilmente organizando su proyecto de esta manera:

adder/
  adder.go
  cmd/
    adder/
      main.go
    adder-server/
      main.go

Los usuarios pueden instalar sus binarios de aplicación "adder" con "go get" usando puntos suspensivos:

$ go get github.com/benbjohnson/adder/...

¡Y listo, su usuario tiene instalados " adder " y " adder-server "!

No te vuelvas loco con subpaquetes

Por lo general, los tipos de mi proyecto están muy relacionados, por lo que se ajusta mejor desde el punto de vista de usabilidad y API.
Estos tipos también pueden aprovechar la llamada no exportada entre ellos, lo que mantiene la API pequeña y clara.

1. Agrupe los tipos y códigos relacionados en cada archivo. Si sus tipos y funciones están bien organizados, entonces creo que los archivos tienden a estar entre 200 y 500 SLOC. Esto puede parecer mucho, pero me resulta fácil de navegar. 1000 SLOC suele ser mi límite superior para un solo archivo.
2. Organice el tipo más importante en la parte superior del archivo y agregue tipos en importancia decreciente hacia la parte inferior del archivo.
3. Una vez que su aplicación comience a superar los 10.000 SLOC, debe evaluar seriamente si se puede dividir en proyectos más pequeños.

Nota: esa última práctica no siempre es buena:

Lo siento, simplemente no puedo estar de acuerdo con esta práctica.
Separar el tipo de archivo ayuda a la gestión del código, la legibilidad, la capacidad de mantenimiento y la capacidad de prueba.
También puede garantizar la responsabilidad individual y el seguimiento del principio abierto / cerrado ...
La regla para no permitir la dependencia circular es forzar que tengamos una estructura clara de los paquetes.

(Alternativa febrero 2013, con respecto a src solamente)
Puede encontrar el diseño clásico ilustrado en " Disposición del código GitHub ":

La aplicación y ambas bibliotecas viven en Github, cada una en su propio repositorio.
$GOPATH es la raíz del proyecto: cada uno de sus repositorios de Github se analizará en varias carpetas debajo de $GOPATH .

El diseño de tu código sería así:

$GOPATH/
    src/
        github.com/
            jmcvetta/
                useless/
                    .git/
                    useless.go
                    useless_test.go
                    README.md
                uselessd/
                    .git/
                    uselessd.go
                    uselessd_test.go
                    README.md

Cada carpeta bajo src/github.com/jmcvetta/ es la raíz de un pago de git por separado.

Eso atrajo algunas críticas, en esta página de reddit :

Recomiendo encarecidamente no estructurar el repositorio de la manera que tiene, se romperá " go get ", que es una de las cosas más útiles acerca de Go.
Es mucho mejor escribir su código para las personas que sí conocen Go, ya que es más probable que sean ellos los que lo compilan.
Y para las personas que no lo hacen, al menos tendrán una idea del idioma.

Coloque el paquete principal en la raíz del repositorio.
Tener los activos en un subdirectorio (para mantener las cosas ordenadas).
Mantenga la carne del código en un subpaquete (en caso de que alguien quiera reutilizarlo fuera de su binario).
Incluya un script de instalación en la raíz del repositorio para que sea fácil de encontrar.

Todavía es solo un proceso de dos pasos para descargar, construir, instalar y configurar .:

• " go get <your repo path> ": descarga e instala el código go, con un subdir para los activos
• $GOPATH/<your repo path>/setup.sh : distribuye los activos en el lugar correcto e instala el servicio