La esencia de la entrevista en lenguaje GO: explicación detallada de los comandos relacionados con la compilación de Go

Ejecutar directamente en la terminal:

go

Puede obtener una breve introducción a los comandos relacionados con go:

Los principales comandos relacionados con la compilación son:

go build
go install
go run

ir a construir

go buildSe utiliza para compilar los archivos de código fuente en los paquetes especificados y sus paquetes dependientes. Durante la compilación, los $GoPath/src/packagearchivos de código fuente se encontrarán en la ruta. go buildTambién puede compilar directamente el archivo de código fuente especificado y especificar varios archivos al mismo tiempo.

El método de uso obtenido al ejecutar go help buildel comando go build:

usage: go build [-o output] [-i] [build flags] [packages]

-oSolo puede aparecer al compilar un solo paquete. Especifica el nombre del archivo ejecutable de salida.

-iSe instalarán los paquetes de los que depende el objetivo de compilación. La instalación se refiere a generar los archivos correspondientes a los paquetes de código .a, es decir, archivos de biblioteca estática (que se vincularán más adelante), y colocarlos en el directorio pkg del espacio de trabajo actual. y el nivel de directorio de los archivos de la biblioteca debe ser el mismo que El nivel del código fuente es consistente.

En cuanto a los parámetros de los indicadores de compilación, build, clean, get, install, list, run, testestos comandos compartirán el mismo conjunto:

parámetro	efecto
-a	Fuerce la recompilación de todos los paquetes involucrados, incluidos los paquetes de código en la biblioteca estándar, que reescribirá .alos archivos en el directorio /usr/local/go.
-norte	Imprime el proceso de ejecución del comando sin ejecutarlo realmente
-pn	Especifique la cantidad de comandos paralelos ejecutados durante el proceso de compilación, n por defecto es la cantidad de núcleos de CPU
-carrera	Detectar e informar problemas de carrera de datos en programas
-v	Imprima los nombres de los paquetes de código involucrados en la ejecución del comando.
-X	Imprima los comandos involucrados en el proceso de ejecución del comando y ejecútelos
-trabajar	Imprima la carpeta temporal durante la compilación. Normalmente, se eliminará una vez completada la compilación.

Sabemos que los archivos de código fuente del lenguaje Go se dividen en tres categorías: código fuente de comando, código fuente de biblioteca y código fuente de prueba.

Archivo de código fuente del comando: es el punto de entrada del programa Go, contiene func main()funciones y la primera línea package maindeclara que pertenece al paquete principal.

Archivos de código fuente de la biblioteca: principalmente varias funciones, interfaces, etc., como funciones de clase de herramienta.

Archivos de código fuente de prueba: archivos _test.gocon sufijo, utilizados para probar la función y el rendimiento del programa.

Tenga en cuenta que los archivos go buildse ignoran .*_test.go

Demostramos el comando a través de un ejemplo muy simple go build. Creé un nuevo hello-worldproyecto usando Goland (para mostrar la referencia del paquete personalizado, que es diferente del programa hello-world anterior). La estructura del proyecto es la siguiente:

En el extremo izquierdo, puedes ver la estructura del proyecto, que contiene tres carpetas: bin, pkg y src. Hay un main.go en el directorio src, que define la función principal, que es la entrada a todo el proyecto, que es el llamado archivo de código fuente de comando mencionado anteriormente; también hay un directorio util en el directorio src, que contiene el archivo util.go y se define una función que puede obtener la dirección IP local, que es el llamado archivo de código fuente de la biblioteca.

En el medio está el código fuente de main.go, que hace referencia a dos paquetes, uno es fmt de la biblioteca estándar; el otro es el paquete util y la ruta de importación de util es util. La llamada ruta de importación se refiere a la subruta en el directorio del código fuente de Go $GoRoot/srco . $GoPath/srcPor ejemplo, la ruta del código fuente de fmt a la que se hace referencia en el paquete principal es /usr/local/go/src/fmty la ruta del código fuente de util es /Users/qcrao/hello-world/src/utilexactamente el GoPath que configuramos = /Users/qcrao/hello-world.

El extremo derecho es el código fuente de la función de la biblioteca, que implementa la función de obtener la IP local.

En el directorio src, ejecute go buildel comando directamente y se generará un archivo ejecutable en el directorio del mismo nivel. El nombre del archivo se ejecuta directamente srcusando el comando y el resultado es:./src

hello world!
Local IP: 192.168.1.3

También podemos especificar el nombre del ejecutable generado:

go build -o bin/hello

De esta manera, se generará un archivo ejecutable en el directorio bin y el resultado de la ejecución será srcel mismo que el anterior.

De hecho, el paquete util se puede compilar por separado. Podemos ejecutarlo en el directorio raíz del proyecto:

go build util

El compilador irá a la ruta $GoPath/src para encontrar el paquete de utilidades (en realidad, está buscando la carpeta). También puede ./src/utilrealizar la compilación directamente en el directorio go build.

Por supuesto, compilar directamente el archivo de código fuente de la biblioteca no generará un archivo .a porque:

Cuando el comando go build compila un paquete de código que solo contiene archivos fuente de la biblioteca (o compila varios paquetes de código al mismo tiempo), solo realizará una compilación de verificación y no generará ningún archivo de resultados.

Para mostrar todo el proceso de compilación y vinculación, ejecutamos el siguiente comando en el directorio raíz del proyecto:

go build -v -x -work -o bin/hello src/main.go

-vImprimirá el nombre del paquete compilado, -ximprimirá los comandos ejecutados durante la compilación e -workimprimirá la ruta del archivo temporal generado durante la compilación, y no se eliminará una vez completada la compilación.

Resultados de:

A juzgar por los resultados, las flechas marcan el proceso de compilación que involucra dos paquetes: util y command-line-arguments. El segundo paquete es extraño, no existe tal nombre en el código fuente, ¿de acuerdo? De hecho, esto se debe a que go buildel comando detecta que [paquetes] está lleno de un .goarchivo, por lo que se crea un paquete virtual: argumentos de línea de comando.

Al mismo tiempo, compilar y vincular están encerrados en un círculo en cuadros rojos, es decir, el paquete util y el archivo se compilan primero y se main.goobtienen los archivos respectivamente .a, y luego los dos se vinculan para finalmente generar un archivo ejecutable, que se mueve a el directorio bin y renombrado hola.

Además, la primera línea muestra el directorio de trabajo durante el proceso de compilación. La estructura de archivos de este directorio es:

Como puede ver, la jerarquía es básicamente la misma que la del directorio hola mundo. argumentos de línea de comando es el paquete donde se encuentra el archivo virtual main.go. Los archivos ejecutables en el directorio exe se movieron al directorio bin en el último paso, por lo que está vacío.

En general, go buildal ejecutarse, primero buscará recursivamente los paquetes de los que depende main.go, así como las dependencias dependientes, hasta llegar al paquete inferior. Esto puede ser un recorrido primero en profundidad o primero en amplitud. Si se encuentra una dependencia circular, saldrá directamente, lo que también es un error de compilación de referencia circular que ocurre con frecuencia.

En circunstancias normales, estas dependencias formarán un árbol que crece al revés. La raíz del árbol está en la parte superior, que es el archivo main.go, y en la parte inferior está el paquete sin ninguna otra dependencia. El compilador compilará uno por uno a partir del paquete representado por el nodo más a la izquierda y, una vez completado, compilará los paquetes en el nivel superior.

Aquí, cito el tutorial del comando go publicado por el profesor Hao Lin en github hace unos años. Puede encontrar la dirección original en los materiales de referencia.

Desde la perspectiva de la compilación del paquete de códigos, si el paquete de códigos A depende del paquete de códigos B, entonces se dice que el paquete de códigos B es el paquete de códigos dependiente del paquete de códigos A (en lo sucesivo denominado el paquete dependiente), y el paquete de códigos A es el paquete de códigos de activación del paquete de códigos B (en lo sucesivo denominado paquete de códigos dependientes). En lo sucesivo denominado paquete de activación).

Si la computadora que ejecuta go buildel comando tiene múltiples núcleos de CPU lógicos, puede haber cierta incertidumbre en el orden en que se compilan los paquetes de código. Sin embargo, debe satisfacer las siguientes restricciones: paquete de código dependiente -> paquete de código actual -> paquete de código de activación.

Por cierto, recomiendo un complemento de navegador llamado Octotree. Al mirar proyectos de GitHub, este complemento puede mostrar directamente la estructura de archivos de todo el proyecto en el navegador, lo cual es muy conveniente:

En este punto, definitivamente encontrará que el directorio pkg en la carpeta hello-wrold parece nunca haber estado involucrado.

De hecho, lo que debería almacenarse en el directorio pkg es el paquete compilado de los archivos de la biblioteca involucrados, es decir, algunos .aarchivos. Sin embargo, durante la ejecución de go build, estos .aarchivos se colocan en la carpeta temporal y se eliminarán directamente después de que se complete la compilación, por lo que generalmente no se utilizan.

Como mencionamos antes, agregar -iparámetros al comando go build instalará los paquetes compilados por estos archivos de biblioteca, es decir, estos .aarchivos se colocarán en el directorio pkg.

Después de ejecutar en el directorio raíz del proyecto go build -i src/main.go, el archivo util.a se agrega al directorio pkg:

darwin_amd64medio:

GOOS y GOARCH. No necesitamos configurar estas dos variables de entorno, el sistema las establece de forma predeterminada.

GOOS es el tipo de sistema operativo donde se encuentra Go y GOARCH es la arquitectura informática donde se encuentra Go.

El nombre del directorio en la plataforma Mac es darwin_amd64.

Una vez generado el archivo util.a, al volver a compilar, el archivo util.go no se volverá a compilar, lo que acelera la compilación.

Al mismo tiempo, se genera un archivo ejecutable llamado main en el directorio raíz, que recibe el comando con el nombre de archivo main.go.

El código del proyecto hello-world se ha subido al proyecto github Go-Questions. Este proyecto se importó de la pregunta e intenta conectar todos los puntos de conocimiento de Go. Se está mejorando y esperamos su estrella. Para obtener la dirección, consulte el material de referencia [Proyecto hola-mundo Go-Questions].

ir a instalar

go installSe utiliza para compilar e instalar paquetes de código específicos y sus paquetes dependientes. En comparación go build, solo tiene un paso más: "instalar el archivo de resultados compilado en el directorio especificado".

Aún usando el ejemplo anterior del proyecto hello-world, primero eliminamos el directorio pkg y lo ejecutamos en el directorio raíz del proyecto:

go install src/main.go

或者

go install util

Ambos crearán un nuevo directorio en el directorio raíz pkgy generarán un util.aarchivo.

Además, al ejecutar el primero, se generará un archivo ejecutable denominado main en el directorio GOBIN.

Por lo tanto, cuando ejecuta go installel comando, los archivos correspondientes al paquete de código fuente de la biblioteca .ase colocarán en pkgel directorio y los archivos ejecutables generados por el paquete de código fuente del comando se colocarán en el directorio GOBIN.

go installCuando GoPath tiene varios directorios, ocurrirán algunos problemas. Para más detalles, puede leer el trabajo del Sr. Hao Lin Go 命令教程, que no se discutirá aquí.

corre

go runSe utiliza para compilar y ejecutar archivos de código fuente de comandos.

En el directorio raíz del proyecto hello-world, ejecute el comando go run:

go run -x -work src/main.go

-x puede imprimir los comandos involucrados en todo el proceso y -work puede ver el directorio de trabajo temporal:

Como puede ver en la imagen de arriba, primero se compila, luego se conecta y finalmente se ejecuta directamente y se imprimen los resultados de la ejecución.

La primera línea impresa es el directorio de trabajo, donde se coloca el archivo ejecutable final generado:

main es el archivo ejecutable final generado.