One place for hosting & domains

      binarios

      Personalizando binários em Go com build tags


      Introdução

      No Go, um build tag, ou uma restrição de compilação, é um identificador adicionado a um pedaço de código que determina quando o arquivo deve ser incluído em um pacote durante o processo de build. Isso permite que você compile diferentes versões de seu aplicativo em Go a partir do mesmo código fonte e para alternar entre eles de maneira rápida e organizada. Muitos desenvolvedores usam os build tags (sinalizadores de compilação) para melhorar o fluxo de trabalho da compilação de aplicativos compatíveis entre plataformas, tais como os programas que necessitam de mudanças no código para explicar as variações entre diferentes sistemas operacionais. Os build tags também são usados para testes de integração, permitindo que você alterne rapidamente entre o código integrado e o código com um serviço fictício ou stub e para diferenciar os níveis dos conjuntos de recursos dentro de um aplicativo.

      A título de exemplo, vamos considerar o problema dos diferentes conjuntos de recursos do cliente. Ao escrever alguns aplicativos, você pode querer controlar quais recursos incluir no binário, como um aplicativo que oferece níveis Free (Livre), Pro (Profissional) e Enterprise (Empresarial). À medida que o cliente aumenta seu nível de assinatura nesses aplicativos, mais recursos se tornam desbloqueados e disponíveis. Para resolver esse problema, você poderia manter projetos separados e tentar mantê-los em sincronia uns com os outros através do uso de instruções de import. Embora essa abordagem iria funcionar,com o tempo ela se tornaria entediante e propensa a erros. Uma abordagem alternativa seria usar os build tags (sinalizadores de compilação).

      Neste artigo, você usará os build tags no Go para gerar diferentes binários executáveis que oferecem conjuntos de recursos Free, Pro e Enterprise de um aplicativo exemplo. Cada binário terá um conjunto diferente de recursos disponíveis, com a versão Free sendo a padrão.

      Pré-requisitos

      Para seguir o exemplo neste artigo, será necessário:

      Compilando a versão Free

      Vamos começar compilando a versão Free do aplicativo, uma vez que ela será a versão padrão durante a execução do go build, sem quaisquer build tags. Mais tarde, usaremos os build tags para adicionar seletivamente outras partes ao nosso programa.

      No diretório src, crie uma pasta com o nome do seu aplicativo. Este tutorial usará o nome app:

      Mova para esta pasta:

      Em seguida, crie um novo arquivo de texto, chamado main.go, no editor de texto de sua preferência:

      Agora, vamos definir a versão Free do aplicativo. Adicione o conteúdo a seguir ao main.go:

      main.go

      package main
      
      import "fmt"
      
      var features = []string{
        "Free Feature #1",
        "Free Feature #2",
      }
      
      func main() {
        for _, f := range features {
          fmt.Println(">", f)
        }
      }
      

      Neste arquivo, criamos um programa que declara uma fatia chamada features, que contém duas strings que representam os recursos de nosso aplicativo Free. A função main() no aplicativo usa um loop for para o range (intervalo) dentro da fatia de features e depois imprime todos os recursos disponíveis na tela.

      Salve e saia do arquivo. Agora que este arquivo está salvo, não precisaremos mais editá-lo pelo resto do artigo. Em vez disso, usaremos os build tags para alterar as características dos binários que vamos compilar a partir dele.

      Compile e execute o programa:

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2

      O programa imprimiu nossos nossos dois recursos gratuitos, completando a versão Free do nosso aplicativo.

      Até agora, você criou um aplicativo que tem um conjunto de características bem básicas. Em seguida, você irá criar uma maneira de adicionar mais recursos no aplicativo no momento da compilação.

      Até agora, evitamos fazer alterações no main.go, simulando um ambiente de produção comum no qual o código precisa ser adicionado, sem alterar e possivelmente quebrar o código principal. Como não podemos editar o arquivo main.go, precisaremos usar outro mecanismo para injetar mais recursos na fatia de features usando os build tags.

      Vamos criar um novo arquivo chamado pro.go que usará uma função init() para acrescentar mais recursos na fatia de features:

      Assim que o editor abrir o arquivo, adicione as seguintes linhas:

      pro.go

      package main
      
      func init() {
        features = append(features,
          "Pro Feature #1",
          "Pro Feature #2",
        )
      }
      

      Neste código, usamos o init() para executar o código antes da função main() do nosso aplicativo, seguido pelo append() para adicionar os recursos Pro à fatia features. Salve e saia do arquivo.

      Compile e execute o aplicativo usando o go build:

      Como agora existem dois arquivos em nosso diretório atual (pro.go e main.go), o go build criará um binário de ambos. Execute este binário:

      Isso dará a você o seguinte conjunto de recursos:

      Output

      > Free Feature #1 > Free Feature #2 > Pro Feature #1 > Pro Feature #2

      Agora, o aplicativo agora inclui tanto os recursos da versão Pro como os recursos da Free. No entanto, isso não é desejável: uma vez que não há distinção entre as versões, a versão Free agora inclui os recursos que deveriam estar disponíveis apenas na versão Pro. Para corrigir isso, você poderia incluir mais códigos para gerenciar os diferentes níveis do aplicativo ou usar os build tags para dizer à cadeia de ferramentas Go quais arquivos .go compilar e quais ignorar. Vamos adicionar os build tags no próximo passo.

      Agora, é possível usar os build tags para distinguir a versão Pro do seu aplicativo da versão Free.

      Vamos começar examinando como se parece um build tag:

      // +build tag_name
      

      Ao colocar essa linha de código como a primeira linha do seu pacote e substituir o tag_name pelo nome do seu build tag, você irá sinalizar esse pacote como um código que pode ser incluído seletivamente no binário final. Vamos ver como isso funciona na prática, adicionando um build tag ao arquivo pro.go para dizer ao comando go build ignorá-lo, a menos que o tag seja especificado. Abra o arquivo no seu editor de texto:

      Então, adicione a linha destacada a seguir:

      pro.go

      // +build pro
      
      package main
      
      func init() {
        features = append(features,
          "Pro Feature #1",
          "Pro Feature #2",
        )
      }
      

      No topo do arquivo pro.go, adicionamos // +build pro, seguido de uma nova linha em branco. Esta essa nova linha no final é necessária, caso contrário o Go interpreta o comando como um comentário. As declarações de build tag também devem estar na parte superior do arquivo .go. Nada, nem mesmo comentários, pode estar acima dos build tags.

      A declaração +build diz ao comando go build que este não é um comentário, mas sim um build tag. A segunda parte é o sinalizador pro. Ao adicionar esse sinalizador na parte superior do arquivo pro.go, o comando go build agora só incluirá o arquivo pro.go se o sinalizador pro estiver presente.

      Compile e execute o aplicativo novamente:

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Como o arquivo pro.go exige que um sinalizador pro esteja presente, o arquivo é ignorado e o aplicativo compila sem ele.

      Ao executar o comando go build, podemos usar o sinalizador -tags para incluir, por condição, o código na fonte compilada, adicionando o sinalizador propriamente dito como um argumento. Vamos fazer isso para o sinalizador pro:

      Isso irá mostrar o seguinte:

      Output

      > Free Feature #1 > Free Feature #2 > Pro Feature #1 > Pro Feature #2

      Agora, vamos obter recursos extra quando compilarmos o aplicativo usando build tag pro.

      Não haverá problemas nisso caso houver apenas duas versões, mas as coisas ficam complicadas quando você adicionar mais sinalizadores. Para adicionar na versão Enterprise de nosso aplicativo no próximo passo, usaremos vários build tags juntos com a lógica booleana.

      Quando há vários build tags em um pacote Go, eles interagem entre si usando a Lógica booleana. Para demonstrar isso, adicionaremos o nível Enterprise do nosso aplicativo usando os sinalizadores pro e enterprise.

      Para compilar um binário Enterprise, precisaremos incluir os recursos padrão, os recursos de nível Pro e um novo conjunto de recursos para o Enterprise. Primeiro, abra um editor e crie um novo arquivo, o enterprise.go, que adicionará os novos recursos de Enterprise:

      O conteúdo do enterprise.go ficará quase idêntico ao pro.go, mas terá novos recursos. Adicione as seguintes linhas ao arquivo:

      enterprise.go

      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Salve e saia do arquivo.

      No momento, o arquivo enterprise.go não possui nenhum build tag e, como você aprendeu ao adicionar recursos no pro.go, isto significa que esses recursos serão adicionados à versão Free durante a execução do go.build. Para o pro.go, você adicionou // + build pro e uma nova linha na parte superior do arquivo para dizer ao go build que ele deve ser incluído somente quando -tags pro for usada. Nessa situação, você precisa apenas de um build tag para atingir o objetivo. No entanto, ao adicionar os novos recursos de Enterprise, você primeiro deve ter os recursos Pro.

      Vamos primeiro adicionar o suporte para build tag pro ao enterprise.go. Abra o arquivo com seu editor de texto:

      Em seguida, adicione o build tag antes da declaração package main e certifique-se de incluir uma nova linha após o build tag:

      enterprise.go

      // +build pro
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Salve e saia do arquivo.

      Compile e execute o aplicativo sem quaisquer sinalizadores:

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Os recursos Enterprise não vão mais aparecer na versão Free. Agora, vamos adicionar o build tag pro, compilar e executar o aplicativo novamente:

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2 > Pro Feature #1 > Pro Feature #2

      Isso ainda não é exatamente o que precisamos: os recursos da versão Enterprise agora aparecem quando tentamos compilar a versão Pro. Para resolver isso, precisamos usar outro build tag. No entanto, ao contrário do sinalizador pro, precisamos agora garantir que os recursos pro e enterprise estejam disponíveis.

      O sistema de compilação Go é responsável por essa situação, permitindo o uso de uma lógica básica booleana no sistema de build tags.

      Vamos abrir o enterprise.go novamente:

      Adicione outro build tag, enterprise, na mesma linha do identificador pro:

      enterprise.go

      // +build pro enterprise
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Salve e feche o arquivo.

      Agora, vamos compilar e executar o aplicativo com o novo build tag enterprise.

      • go build -tags enterprise
      • ./app

      Isso resultará no seguinte:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2

      Agora, perdemos os recursos Pro. Isso acontece porque quando colocarmos vários build tags na mesma linha em um arquivo .go, o go build os interpreta como se estivesse usando uma lógica OR. Com a adição da linha // + build pro enterprise, o arquivo enterprise.go será compilado caso tanto o build tag pro quanto o enterprise estiverem presentes. Em vez disso, precisamos configurar os build tags corretamente para exigir ambos e usar a lógica AND.

      Em vez de colocar ambos sinalizadores na mesma linha, se os colocarmos em linhas separadas, o go build irá, então, interpretar esses identificadores usando a lógica AND.

      Abra o enterprise.go novamente e vamos separar os build tags em várias linhas.

      enterprise.go

      // +build pro
      // +build enterprise
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Agora, compile e execute o aplicativo com o novo build tag enterprise.

      • go build -tags enterprise
      • ./app

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Ainda não chegamos lá: como uma instrução AND exige que ambos os elementos sejam considerados true, precisamos usar os build tags pro e enterprise juntos.

      Vamos tentar novamente:

      • go build -tags "enterprise pro"
      • ./app

      Você receberá o seguinte resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2 > Pro Feature #1 > Pro Feature #2

      Agora, nosso aplicativo pode ser compilado a partir da mesma árvore de várias maneiras, desbloqueando os recursos do aplicativo corretamente.

      Neste exemplo, usamos um novo sinalizador // + build para significar uma lógica AND, mas existem maneiras alternativas de representar a lógica booleana com os build tags. A tabela a seguir contém alguns exemplos de formatação sintática para build tags, junto com suas equivalentes booleanas:

      Sintaxe do build tag Amostra de build tag Instrução booleana
      Elementos separados por espaço // +build pro enterprise pro OU enterprise
      Elementos separados por vírgula // +build pro,enterprise pro E enterprise
      Elementos com ponto de exclamação // +build ! pro NÃO é pro

      Conclusão

      Neste tutorial, você usou build tags para permitir que você controle qual de seus códigos será compilado no binário. Primeiro, você declarou os build tags e os usou com o go build; depois, combinou vários identificadores com a lógica booleana. Em seguida, você compilou um programa que representava os diferentes conjuntos de recursos de uma versão Free, Pro e Enterprise, mostrando o poderoso nível de controle sobre o seu projeto que os build tags podem dar a você.

      Se quiser aprender mais sobre os build tags, consulte a documentação do Golang sobre o assunto, ou continue a explorar nossa série de artigos sobre Como codificar em Go.



      Source link

      Personalizar los binarios de Go con etiquetas de compilación


      Introducción

      En Go, una etiqueta de compilación, o una restricción de compilación, es un identificador añadido a un fragmento de código que determina el momento en que debería incluirse el archivo en un paquete durante el proceso build. Esto le permite compilar diferentes versiones de su aplicación de Go a partir del mismo código fuente y alternar entre ellas de forma rápida y organizada. Muchos desarrolladores utilizan etiquetas de compilación para mejorar el flujo de trabajo de creación de aplicaciones compatibles entre plataformas, como programas que requieren cambios de código para tener en cuenta las variaciones entre diferentes sistemas operativos. Las etiquetas de compilación también se utilizan para pruebas de integración, lo que le permite pasar rápidamente del código integrado al código con un servicio mock o stub, y para diferentes niveles de conjuntos de funciones en una aplicación.

      Tomaremos como ejemplo el problema de los diferentes conjuntos de funciones de los clientes. Al escribir algunas aplicaciones, es posible que desee controlar las funciones que se incluirán en el binario, como en el caso de una aplicación que ofrece niveles Gratis, Pro y Empresarial. A medida que el cliente aumente su nivel de suscripción en esas aplicaciones, más funciones se desbloquearán y estarán disponibles. Para resolver este problema, podría tener proyectos separados e intentar mantenerlos sincronizados entre ellos a través de instrucciones import. Aunque este enfoque funcionaría, con el tiempo se volvería tedioso y estaría expuesto a errores. Un enfoque alternativo consistiría en usar etiquetas de compilación.

      A través de este artículo, usará etiquetas de compilación en Go para generar binarios ejecutables diferentes que ofrezcan conjuntos de funciones Gratis, Pro y Empresarial de una aplicación de ejemplo. Cada uno tendrá un conjunto diferente de funciones disponibles y la versión Gratis será la predeterminada.

      Requisitos previos

      Para seguir el ejemplo de este artículo, necesitará lo siguiente:

      Compilar la versión Gratis

      Comenzaremos creando la versión Gratis de la aplicación, ya que será la predeterminada cuando se ejecute go build sin etiquetas de compilación. Más adelante, usaremos las etiquetas de compilación para añadir otras partes a nuestro programa.

      En el directorio src, cree una carpeta con el nombre de su aplicación. En este tutorial se usará app:

      Posiciónese en esta carpeta:

      A continuación, cree en su editor de texto un nuevo archivo de texto llamado main.go:

      A continuación, definiremos la versión Gratis de la aplicación. Añada el siguiente contenido a main.go:

      main.go

      package main
      
      import "fmt"
      
      var features = []string{
        "Free Feature #1",
        "Free Feature #2",
      }
      
      func main() {
        for _, f := range features {
          fmt.Println(">", f)
        }
      }
      

      En este archivo, creamos un programa que declara un segmento llamado features, el cual contiene dos cadenas que representan las funciones de nuestra aplicación Gratis. La función main() de la aplicación utiliza un bucle for para aplicar range en el segmento features e imprimir todas las funciones disponibles en la pantalla.

      Guarde el archivo y ciérrelo. Ahora que se guardó el archivo, ya no tendremos que editarlo durante el resto del artículo. Como alternativa, utilizaremos etiquetas de compilación para cambiar las funciones de los binarios que crearemos a partir de él.

      Cree y ejecute el programa:

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2

      El programa imprimió nuestras dos funciones gratuitas y completó la versión Gratis de nuestra aplicación.

      Hasta ahora, creó una aplicación que tiene un conjunto de funciones muy básico. A continuación, compilará una alternativa para añadir más funciones a la aplicación en el tiempo de compilación.

      Añadir las funciones Pro con go build

      Hasta ahora, evitamos realizar cambios en main.go y simulamos un entorno de producción común en el cual se debe agregar código sin cambiar ni posiblemente dañar el código principal. Debido a que no podemos editar el archivo main.go, tendremos que usar otro mecanismo para inyectar más funciones en el segmento features usando etiquetas de compilación.

      Vamos a crear un nuevo archivo llamado pro.go que usará una función init() para añadir más funciones al segmento features:

      Una vez que el editor haya abierto el archivo, añada las siguientes líneas:

      pro.go

      package main
      
      func init() {
        features = append(features,
          "Pro Feature #1",
          "Pro Feature #2",
        )
      }
      

      En este código, usamos init() para ejecutar código antes de la función main() de nuestra aplicación, seguido de append() para añadir las funciones Pro al segmento features. Guarde el archivo y ciérrelo.

      Compile y ejecute la aplicación usando go build:

      Debido a que ahora hay dos archivos en nuestro directorio actual (pro.go y main.go), go build creará un binario a partir de ambos. Ejecute este binario:

      Esto le proporcionará el siguiente conjunto de funciones:

      Output

      > Free Feature #1 > Free Feature #2 > Pro Feature #1 > Pro Feature #2

      En la aplicación ahora se incluirán las funciones Pro y Gratis. Sin embargo, esto no es conveniente. Debido a que no existe una distinción entre las versiones, la Gratis ahora incluye las funciones que, según se supone, solo deben estar disponibles en la versión Pro. Para solucionar esto, podría incluir más código para administrar los diferentes niveles de la aplicación o podría usar etiquetas de compilación para indicar a la cadena de herramientas de Go los archivos .go que desea crear e ignorar. Añadiremos etiquetas de compilación en el siguiente paso.

      Agregar etiquetas de compilación

      Ahora puede usar las etiquetas de compilación para distinguir la versión Pro y la Gratis de su aplicación.

      Comenzaremos examinando el aspecto que tiene una etiqueta de compilación:

      // +build tag_name
      

      Al disponer esta línea de código como la primera de su paquete y sustituir tag_name por el nombre de su etiqueta de compilación, etiquetará este paquete como un código que puede incluirse selectivamente en el binario final. Veremos esto en acción añadiendo una etiqueta de compilación al archivo pro.go para indicar al comando go build que lo ignore a menos que se especifique la etiqueta. Abra el archivo en su editor de texto:

      A continuación, añada la siguiente línea resaltada:

      pro.go

      // +build pro
      
      package main
      
      func init() {
        features = append(features,
          "Pro Feature #1",
          "Pro Feature #2",
        )
      }
      

      En la parte superior del archivo pro.go, añadimos // +build pro seguido de una nueva línea en blanco. Esta nueva línea final es necesaria; de lo contrario, Go interpreta esto como un comentario. En la parte superior de un archivo .go también declaraciones de etiquetas de compilación. No puede haber nada, ni siquiera comentarios, sobre las etiquetas de compilación.

      La declaración +build indica al comando go build que esto no es un comentario, sino una etiqueta de compilación. La segunda parte es la etiqueta pro. Al añadirse esta etiqueta a la parte superior del archivo pro.go, el comando go build ahora incluirá únicamente el archivo pro.go cuando la etiqueta pro esté presente.

      Compile y ejecute la aplicación de nuevo:

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Debido a que requiere que haya una etiqueta pro presente, el archivo pro.go se ignora y la aplicación realiza la compilación sin él.

      Cuando se ejecuta el comando go build, podemos usar el indicador -tags para incluir condicionalmente código en la fuente compilada añadiendo la etiqueta como argumento. Haremos esto para la etiqueta pro:

      Esto dará el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Pro Feature #1 > Pro Feature #2

      Ahora, solo obtendremos las funciones adicionales cuando compilemos la aplicación usando la etiqueta de compilación pro.

      Esto está bien si solo hay dos versiones, pero la situación se complica cuando añade más etiquetas. Para añadir la versión Empresarial de nuestra aplicación en el siguiente paso, utilizaremos varias etiquetas de compilación unidas con lógica booleana.

      Lógica de booleanos para etiquetas de compilación

      Cuando hay varias etiquetas de compilación en un paquete de Go, las etiquetas interactúan entre ellas usando lógica de booleanos. Para demostrar esto, añadiremos el nivel Empresarial de nuestra aplicación usando las etiquetas pro y enterprise.

      Para crear un binario de Empresarial, debemos incluir las funciones predeterminadas, las funciones del nivel Pro y un nuevo conjunto de funciones para Empresarial. Primero, abra un editor y cree un nuevo archivo, enterprise.go, que añadirá las nuevas funciones Empresarial:

      El contenido de enterprise.go tendrá un aspecto casi idéntico a pro.go, pero contendrá nuevas funciones. Añada las líneas siguientes al archivo:

      enterprise.go

      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Guarde el archivo y ciérrelo.

      Actualmente, el archivo enterprise.go no tiene ninguna etiqueta de compilación y, tal como aprendió cuando añadió pro.go, esto significa que estas funciones se añadirán a la versión Gratis cuando se ejecuta go.build. Para pro.go, agregó // +build pro y una nueva línea en la parte superior del archivo a fin de indicar a go build que solo debería incluirse cuando se utilice -tags pro. En esta situación, solo necesitó una etiqueta de compilación para lograr el objetivo. Cuando se añaden las nuevas funciones Empresarial, sin embargo, primero debe también disponer de las funciones Pro.

      Añadiremos primero compatibilidad con la etiqueta de compilación pro a enterprise.go. Abra el archivo con su editor de texto:

      A continuación, añada la etiqueta de compilación antes de la declaración package main y asegúrese de incluir una línea nueva después de la etiqueta de compilación:

      enterprise.go

      // +build pro
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Guarde el archivo y ciérrelo.

      Compile y ejecute la aplicación sin etiquetas:

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Las funciones Empresariales ya no se muestran en la versión Gratis. Ahora, añadiremos la etiqueta de compilación pro, y compilaremos y ejecutaremos la aplicación de nuevo:

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2 > Pro Feature #1 > Pro Feature #2

      Esto no es exactamente lo que necesitamos: las funciones Empresarial ahora se muestran cuando intentamos compilar la versión Pro. Para resolver esto, debemos usar otra etiqueta de compilación. A diferencia de lo que sucede con la etiqueta pro, sin embargo, debemos asegurarnos de que las funciones pro y enterprise estén disponibles.

      El sistema de compilación de Go tiene en cuenta esta situación al permitir el uso de lógica de booleanos básica en el sistema de etiquetas de compilación.

      Abriremos de nuevo enterprise.go:

      Añada otra etiqueta de compilación, enterprise, en la misma línea de la etiqueta pro:

      enterprise.go

      // +build pro enterprise
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Guarde y cierre el archivo.

      Ahora, compilaremos y ejecutaremos la aplicación con la nueva etiqueta de compilación enterprise.

      • go build -tags enterprise
      • ./app

      Esto dará el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2

      Con esto, habremos perdido las funciones Pro. Esto se debe a que cuando disponemos varias etiquetas de compilación en la misma línea en un archivo .go, go build interpreta que usan la lógica OR. Con la adición de la línea // +build pro enterprise, el archivo enterprise.go se compilará si cualquiera de las etiquetas de compilación pro o enterprise están presentes. Debemos configurar las etiquetas de compilación correctamente para requerir ambas y usar, por el contrario, la lógica AND.

      Si en vez de disponer ambas etiquetas en la misma línea las situamos en líneas separadas, go build interpretará esas etiquetas usando la lógica AND.

      Abra enterprise.go de nuevo. Separaremos las etiquetas de compilación en varias líneas.

      enterprise.go

      // +build pro
      // +build enterprise
      
      package main
      
      func init() {
        features = append(features,
          "Enterprise Feature #1",
          "Enterprise Feature #2",
        )
      }
      

      Ahora, compile y ejecute la aplicación con la nueva etiqueta de compilación enterprise.

      • go build -tags enterprise
      • ./app

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2

      Aun no terminamos: debido a que una instrucción AND requiere que ambos elementos se consideren como true, debemos usar las etiquetas de compilación pro y enterprise.

      Haremos un nuevo intento:

      • go build -tags "enterprise pro"
      • ./app

      Obtendrá el siguiente resultado:

      Output

      > Free Feature #1 > Free Feature #2 > Enterprise Feature #1 > Enterprise Feature #2 > Pro Feature #1 > Pro Feature #2

      Ahora, nuestra aplicación puede crearse a partir del mismo árbol de origen de varias formas desbloqueando las funciones de la aplicación de manera correspondiente.

      En este ejemplo, usanos una nueva etiqueta // +build para representar la lógica AND, pero existen formas alternativas de representar la lógica de booleanos con etiquetas de compilación. La siguiente tabla contiene algunos ejemplos de otros formatos sintácticos para etiquetas de compilación, junto con su equivalente booleano:

      Sintaxis de la etiqueta de compilación Ejemplo de etiqueta de compilación Instrucción booleana
      Elementos separados por espacios // +build pro enterprise pro OR enterprise
      Elementos separados por comas // +build pro enterprise pro AND enterprise
      Elementos con signo de exclamación // + build ! pro NOT pro

      Conclusión

      A lo largo de este tutorial, utilizó etiquetas de compilación para controlar la parte de su código que se compilaría en el binario. Primero, declaró las etiquetas de compilación y las utilizó con go build, y luego combinó varias etiquetas con lógica de booleanos. Luego creó un programa que representó los tres conjuntos diferentes de funciones de una versión Gratis, Pro y Empresarial, y mostró el potente nivel de control que las etiquetas de compilación pueden proporcionarle en sus proyectos.

      Si desea obtener más información sobre las etiquetas de compilación, consulte la documentación de Golang relacionada con este tema o siga explorando nuestra serie Cómo crear código en Go.



      Source link