One place for hosting & domains

      Introdução

      Uma Introdução ao Gerenciamento de Configuração


      Introdução

      Em um aspecto mais amplo, o gerenciamento de configuração (GC) refere-se ao processo de manipular sistematicamente as alterações em um sistema, de maneira a manter a integridade ao longo do tempo. Embora esse processo não tenha sido originado no setor de TI, o termo é amplamente usado para se referir ao gerenciamento de configuração de servidor.

      A automação desempenha um papel essencial no gerenciamento de configuração de servidor. É o mecanismo usado para fazer o servidor alcançar um estado desejável, definido anteriormente por scripts de provisionamento usando a linguagem e os recursos específicos de uma ferramenta. A automação é, de fato, o coração do gerenciamento de configurações de servidores, e é por isso que é comum também se referir às ferramentas de gerenciamento de configuração como Ferramentas de Automação ou Ferramentas de Automação de TI.

      Outro termo comum usado para descrever os recursos de automação implementados pelas ferramentas de gerenciamento de configuração é Orquestração de Servidor ou Orquestração de TI, uma vez que essas ferramentas geralmente são capazes de gerenciar de um a centenas de servidores a partir de uma máquina controladora central.

      Existem várias ferramentas de gerenciamento de configuração disponíveis no mercado. Puppet, Ansible, Chef e Salt são escolhas populares. Embora cada ferramenta tenha suas próprias características e funcione de maneiras ligeiramente diferentes, todas elas são orientadas pelo mesmo propósito: garantir que o estado do sistema corresponda ao estado descrito pelos seus scripts de provisionamento.

      Benefícios do Gerenciamento de Configuração para Servidores

      Embora o uso do gerenciamento de configuração geralmente exija mais planejamento e esforço iniciais do que a administração manual do sistema, todas as infraestruturas de servidor, exceto as mais simples, serão aprimoradas pelos benefícios que ele oferece. Para citar alguns:

      Provisionamento Rápido de Novos Servidores

      Sempre que um novo servidor precisa ser deployado, uma ferramenta de gerenciamento de configuração pode automatizar a maior parte, se não todo, do processo de provisionamento para você. A automação torna o provisionamento muito mais rápido e eficiente, pois permite que tarefas tediosas sejam executadas com mais rapidez e precisão do que qualquer ser humano poderia. Mesmo com a documentação adequada e completa, o deployment manual de um servidor web, por exemplo, pode levar horas em comparação a alguns minutos com o gerenciamento/automação da configuração.

      Recuperação Rápida de Eventos Críticos

      Com o provisionamento rápido, vem outro benefício: recuperação rápida de eventos críticos. Quando um servidor fica offline devido a circunstâncias desconhecidas, pode levar várias horas para se auditar adequadamente o sistema e descobrir o que realmente aconteceu. Em cenários como esse, fazer o deploy de um servidor substituto geralmente é a maneira mais segura de colocar seus serviços online novamente enquanto uma inspeção detalhada é feita no servidor afetado. Com o gerenciamento e a automação da configuração, isso pode ser feito de maneira rápida e confiável.

      Não mais Servidores Snowflake

      À primeira vista, a administração manual do sistema pode parecer uma maneira fácil de fazer deploy e corrigir rapidamente os servidores, mas isso geralmente tem um preço. Com o tempo, pode se tornar extremamente difícil saber exatamente o que está instalado em um servidor e quais alterações foram feitas quando o processo não é automatizado. Os hotfixes manuais, os ajustes de configuração e as atualizações de software podem transformar os servidores em snowflakes exclusivos, difíceis de gerenciar e ainda mais difíceis de replicar. Usando uma ferramenta de GC, o procedimento necessário para lançar um novo servidor ou atualizar um existente estará documentado nos scripts de provisionamento.

      Controle de Versão para o Ambiente do Servidor

      Depois de ter sua configuração do servidor traduzida em um conjunto de scripts de provisionamento, você poderá aplicar ao ambiente do seu servidor muitas das ferramentas e fluxos de trabalho que você normalmente usa para o código-fonte de software.

      Ferramentas de controle de versão como o Git, podem ser usadas para acompanhar as alterações feitas no provisionamento e manter ramificações separadas para as versões antigas dos scripts. Você também pode usar o controle de versão para implementar uma política de code review para os scripts de provisionamento, onde todas as alterações devem ser submetidas como um pull request e aprovadas pelo líder do projeto antes de serem aceitas. Essa prática adicionará consistência extra à sua configuração de infraestrutura.

      Ambientes Replicados

      O gerenciamento de configuração torna trivial replicar ambientes com exatamente o mesmo software e as mesmas configurações. Isso permite que você crie efetivamente um ecossistema de vários estágios, com servidores de produção, desenvolvimento e teste. Você pode até usar máquinas virtuais locais para desenvolvimento, criadas com os mesmos scripts de provisionamento. Essa prática minimizará os problemas causados por discrepâncias no ambiente que ocorrem com frequência quando as aplicações são deployadas na produção ou compartilhadas entre colegas de trabalho com diferentes configurações de máquina (sistema operacional diferente, versões de software e/ou configurações).

      Visão Geral das Ferramentas de Gerenciamento de Configuração

      Embora cada ferramenta de GC tenha seus próprios termos, filosofia e ecossistema, elas geralmente compartilham muitas características e têm conceitos semelhantes.

      A maioria das ferramentas de gerenciamento de configuração usa um modelo de controlador/mestre e node/agente. Essencialmente, o controlador direciona a configuração dos nodes, com base em uma série de instruções ou tasks definidas em seus scripts de provisionamento.

      Abaixo, você encontra os recursos mais comuns presentes na maioria das ferramentas de gerenciamento de configuração para servidores:

      Framework de Automação

      Cada ferramenta de gerenciamento de configuração fornece uma sintaxe específica e um conjunto de recursos que você pode usar para escrever scripts de provisionamento. A maioria das ferramentas possui recursos que tornam sua linguagem semelhante às linguagens de programação convencionais, mas de maneira simplificada. Variáveis, loops e condicionais são recursos comuns fornecidos para facilitar a criação de scripts de provisionamento mais versáteis.

      Comportamento Idempotente

      As ferramentas de gerenciamento de configuração controlam o estado dos recursos para evitar a repetição de tarefas que foram executadas anteriormente. Se um pacote já estiver instalado, a ferramenta não tentará instalá-lo novamente. O objetivo é que, após cada execução de provisionamento, o sistema atinja (ou mantenha) o estado desejado, mesmo que você o execute várias vezes. É isso que caracteriza essas ferramentas como tendo um comportamento idempotente. Esse comportamento não é necessariamente imposto em todos os casos, no entanto.

      Fatos do Sistema (Facts)

      As ferramentas de gerenciamento de configuração geralmente fornecem informações detalhadas sobre o sistema que está sendo provisionado. Esses dados estão disponíveis através de variáveis globais, conhecidas como facts. Eles incluem coisas como interfaces de rede, endereços IP, sistema operacional e distribuição. Cada ferramenta fornecerá um conjunto diferente de facts. Eles podem ser usados para tornar os scripts e templates de provisionamento mais adaptáveis a vários sistemas.

      Sistema de Templates

      A maioria das ferramentas de GC fornecerá um sistema de templates interno que pode ser usado para facilitar a criação de arquivos e serviços de configuração. Os templates geralmente suportam variáveis, loops e condicionais que podem ser usados para maximizar a versatilidade. Por exemplo, você pode usar um template para configurar facilmente um novo virtual host no Apache, enquanto reutiliza o mesmo template para várias instalações de servidores. Em vez de ter apenas valores estáticos codificados, um template deve conter espaços reservados (placeholders) para valores que podem mudar de host para host, como NameServer e DocumentRoot.

      Extensibilidade

      Embora os scripts de provisionamento possam ser muito especializados para as necessidades e demandas de um servidor específico, há muitos casos em que você tem configurações semelhantes de servidor ou partes de uma configuração que podem ser compartilhadas entre vários servidores. A maioria das ferramentas de provisionamento fornecerá maneiras pelas quais você pode reutilizar e compartilhar facilmente pequenos blocos de sua configuração de provisionamento como módulos ou plugins.

      Módulos e plugins de terceiros geralmente são fáceis de encontrar na Internet, especialmente para configurações comuns de servidores, como a instalação de um servidor web PHP. As ferramentas de GC tendem a ter uma comunidade forte criada em torno delas e os usuários são incentivados a compartilhar suas extensões personalizadas. O uso de extensões fornecidas por outros usuários pode economizar muito tempo, além de servir como uma excelente maneira de aprender como outros usuários resolveram problemas comuns usando a ferramenta de sua escolha.

      Escolhendo uma Ferramenta de Gerenciamento de Configuração

      Existem muitas ferramentas de GC disponíveis no mercado, cada uma com um conjunto diferente de recursos e diferentes níveis de complexidade. As escolhas populares incluem Chef, Ansible e Puppet. O primeiro desafio é escolher uma ferramenta que seja adequada às suas necessidades.

      Há algumas coisas que você deve levar em consideração antes de fazer uma escolha:

      Complexidade da Infraestrutura

      A maioria das ferramentas de gerenciamento de configuração requer uma hierarquia mínima composta por uma máquina controladora e um node que será gerenciado por ela. O Puppet, por exemplo, exige que uma aplicação agent seja instalada em cada node e um aplicação master seja instalada na máquina do controlador. O Ansible, por outro lado, possui uma estrutura descentralizada que não requer instalação de software adicional nos nodes, mas depende do SSH para executar as tarefas de provisionamento. Para projetos menores, uma infraestrutura simplificada pode parecer melhor, no entanto, é importante levar em consideração aspectos como escalabilidade e segurança, que podem não ser impostos pela ferramenta.

      Algumas ferramentas podem ter mais componentes e partes móveis, o que pode aumentar a complexidade da sua infraestrutura, impactando na curva de aprendizado e possivelmente aumentando o custo geral de implementação.

      Curva de Aprendizado

      Como mencionado anteriormente neste artigo, as ferramentas de GC fornecem uma sintaxe personalizada, às vezes usando uma linguagem de domínio específico (DSL) e um conjunto de recursos que compõem seu framework de automação. Como nas linguagens de programação convencionais, algumas ferramentas exigem uma curva de aprendizado mais alta para serem dominadas. Os requisitos de infraestrutura também podem influenciar a complexidade da ferramenta e a rapidez com que você poderá ver um retorno do investimento.

      Custo

      A maioria das ferramentas de GC oferece versões gratuitas ou open source, com assinaturas pagas para recursos e serviços avançados. Algumas ferramentas terão mais limitações que outras, portanto, dependendo de suas necessidades específicas e de como sua infraestrutura cresce, você pode acabar tendo que pagar por esses serviços. Você também deve considerar o treinamento como um custo extra em potencial, não apenas em termos monetários, mas também em relação ao tempo necessário para atualizar sua equipe com a ferramenta que você acabou escolhendo.

      Ferramentas Avançadas

      Como mencionado anteriormente, a maioria das ferramentas oferece serviços pagos que podem incluir suporte, extensões e ferramentas avançadas. É importante analisar suas necessidades específicas, o tamanho da sua infraestrutura e se há ou não a necessidade de usar esses serviços. Os painéis de gerenciamento, por exemplo, são um serviço comum oferecido por essas ferramentas e podem facilitar muito o processo de gerenciamento e monitoramento de todos os seus servidores a partir de um ponto central. Mesmo que você ainda não precise desses serviços, considere as opções para uma possível necessidade futura.

      Comunidade e Suporte

      Uma comunidade forte e acolhedora pode ser extremamente útil em termos de suporte e documentação, pois os usuários geralmente ficam felizes em compartilhar seu conhecimento e suas extensões (módulos, plugins e scripts de provisionamento) com outros usuários. Isso pode ser útil para acelerar sua curva de aprendizado e evitar custos extras com suporte ou treinamento pagos.

      Visão Geral das Ferramentas Populares

      A tabela abaixo deve lhe fornecer uma rápida visão geral das principais diferenças entre as três ferramentas de gerenciamento de configuração mais populares disponíveis no mercado atualmente: Ansible, Puppet e Chef.

      Ansible Puppet Chef
      Linguagem do Script YAML DSL personalizada baseada em Ruby Ruby
      Infraestrutura A máquina controladora aplica a configuração nos nodes via SSH O Puppet Master sincroniza a configuração nos Puppet Nodes As Workstations do Chef enviam a configuração para o Chef Server, a partir do qual os nodes do Chef serão atualizados
      Requer software especializado para os nodes Não Sim Sim
      Fornece ponto de controle centralizado Não. Qualquer computador pode ser um controlador Sim, via Puppet Master Sim, via Chef Server
      Terminologia do script Playbook / Roles Manifests / Modules Recipes / Cookbooks
      Ordem de Execução das Tarefas Sequencial Não-sequencial Sequencial

      Próximos Passos

      Até agora, vimos como o gerenciamento de configuração funciona para servidores e o que considerar ao escolher uma ferramenta para criar sua infraestrutura de gerenciamento de configuração. Nos guias subsequentes desta série, teremos uma experiência prática com três ferramentas populares de gerenciamento de configuração: Ansible, Puppet e Chef.

      Para que você possa comparar essas ferramentas por si mesmo, usaremos um exemplo simples de configuração de servidor que deve ser totalmente automatizado por cada ferramenta. Essa configuração consiste em um servidor Ubuntu 18.04 executando o Apache para hospedar uma página web simples.

      Conclusão

      O gerenciamento de configuração pode melhorar drasticamente a integridade dos servidores ao longo do tempo, fornecendo um framework para automatizar processos e acompanhar as alterações feitas no ambiente do sistema. No próximo guia dessa série, veremos como implementar uma estratégia de gerenciamento de configuração na prática usando Ansible como ferramenta.



      Source link

      Uma introdução ao pacote de Strings em Go


      Introdução

      O pacote stringem Go possui várias funções disponíveis para trabalhar com o string data type​​​. Essas funções nos permitem modificar e manipular strings facilmente. Podemos pensar em funções como ações que realizamos nos elementos do nosso código. Funções integradas são aquelas definidas na linguagem de programação Go e ficam prontamente disponíveis para o nosso uso.

      Neste tutorial, avaliaremos várias funções diferentes que podemos usar para trabalhar com as strings em Go.

      Criando strings em letras maiúsculas e minúsculas

      As funções strings.ToUpper e strings.ToLower vão retornar uma string com todas as letras de uma string original convertidas em letras maiúsculas ou minúsculas. Como as strings são tipos de dados imutáveis, a string retornada será uma nova string. Quaisquer caracteres na string que não sejam letras não serão alterados.

      Para converter a string "Sammy Shark" para ser toda em maiúscula, use a função strings.ToUpper:

      ss := "Sammy Shark"
      fmt.Println(strings.ToUpper(ss))
      

      Output

      SAMMY SHARK

      Para converter para minúsculas:

      fmt.Println(strings.ToLower(ss))
      

      Output

      sammy shark

      Como você está usando o pacote strings, primeiro você precisa importá-lo para um programa. Para converter a string em maiúsculas e minúsculas, o programa todo ficaria da seguinte forma:

      package main
      
      import (
          "fmt"
          "strings"
      )
      
      func main() {
          ss := "Sammy Shark"
          fmt.Println(strings.ToUpper(ss))
          fmt.Println(strings.ToLower(ss))
      }
      

      As funções strings.ToUpper e strings.ToLower facilitam a avaliação e comparação de strings, tornando consistente o uso de maiúsculas e minúsculas de ponta a ponta. Por exemplo, se um usuário escreve seu nome com todas as letras minúsculas, ainda assim conseguiremos saber se o nome dele está em nosso banco de dados, comparando-o com uma versão com todas as letras maiúsculas.

      Funções de busca de string

      O pacote strings tem uma série de funções que ajudam a determinar se uma string contém uma sequência específica de caracteres.

      Função Uso
      strings.HasPrefix Procura a string desde o início
      strings.HasSuffix Procura a string a partir do final
      strings.Contains Procura em qualquer lugar na string
      strings.Count Conta quantas vezes a string aparece

      As funções strings.HasPrefix e strings.HasSuffix permitem que você verifique se uma string começa ou termina com um conjunto específico de caracteres.

      Por exemplo, para verificar se a string "Sammy Shark" começa com Sammy e termina com o Shark:

      ss := "Sammy Shark"
      fmt.Println(strings.HasPrefix(ss, "Sammy"))
      fmt.Println(strings.HasSuffix(ss, "Shark"))
      

      Output

      true true

      Você usaria a função strings.Contains para verificar se "Sammy Shark"contém a sequência Sh:

      fmt.Println(strings.Contains(ss, "Sh"))
      

      Output

      true

      Por fim, para ver quantas vezes a letra S aparece na frase Sammy Shark:

      fmt.Println(strings.Count(ss, "S"))
      

      Output

      2

      Nota: todas as strings em Go diferenciam maiúsculas de minúsculas. Isso significa que Sammy não é o mesmo que sammy.

      Usar um s minúsculo para obter uma contagem do Sammy Shark não é o mesmo que usar o S maiúsculo:

      fmt.Println(strings.Count(ss, "s"))
      

      Output

      0

      Como S é diferente de s, a contagem será 0.

      As funções de string são úteis quando você quer comparar ou pesquisar strings no seu programa.

      Determinando o tamanho da string

      A função integrada len() retorna o número de caracteres em uma string. Essa função é útil para quando você tiver que impor o tamanho mínimo ou máximo de uma senha, por exemplo, ou para truncar strings maiores para que fiquem dentro de certos limites para usar como abreviações.

      Para demonstrar essa função, encontraremos o tamanho de uma string longa:

      import (
          "fmt"
          "strings"
      )
      
      func main() {
              openSource := "Sammy contributes to open source."
              fmt.Println(len(openSource))
      }
      

      Output

      33

      Definimos a variável openSource igual a string "Sammy contributes to open source." e então passamos essa variável para a função len() com len(openSource). Por fim, movemos a função para que faça parte da função fmt.Println() para que pudéssemos ver o resultado do programa na tela.

      Lembre-se de que a função len() contará qualquer caractere vinculado por aspas duplas – incluindo letras, números, espaços em branco e símbolos.

      Funções para a manipulação de string

      As funções strings.Join, strings.Split e strings.ReplaceAll são algumas maneiras adicionais de manipular as strings em Go.

      A função strings.Join é útil para combinar uma fração das strings em uma única e nova string.

      Para criar uma string separada por vírgulas de uma fatia de strings, usaríamos essa função de acordo com o seguinte:

      fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))
      

      Output

      sharks,crustaceans,plankton

      Se quisermos adicionar uma vírgula e um espaço entre os valores da string na nossa nova string, podemos simplesmente reescrever nossa expressão com um espaço em branco após a vírgula: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

      Assim como podemos juntar strings, também podemos dividir as strings. Para fazer isso, podemos usar a função strings.Split e dividir nos espaços:

      balloon := "Sammy has a balloon."
      s := strings.Split(balloon, " ")
      fmt.Println(s)
      

      Output

      [Sammy has a balloon]

      O resultado é uma fatia de strings. Como a função strings.Println foi usada, é difícil distinguir o que seja o resultando apenas olhando para ele. Para verificar que se trata, de fato, de strings, utilize a função fmt.Printf com o verbo %q para citar as strings:

      fmt.Printf("%q", s)
      

      Output

      ["Sammy" "has" "a" "balloon."]

      Outra função útil, além de strings.Split é a strings.Fields. A diferença é que a função strings.Fields irá ignorar todos os espaços em branco e irá dividir apenas os fields em questão em uma string:

      data := "  username password     email  date"
      fields := strings.Fields(data)
      fmt.Printf("%q", fields)
      

      Output

      ["username" "password" "email" "date"]

      A função strings.ReplaceAll pode tomar uma string original e retornar uma string atualizada com algumas substituições.

      Digamos que o balão de Sammy esteja perdido. Como Sammy já não tem esse balão, mudaríamos a substring "has"(tem) da string original balloon (balão) para "had" (tinha) em uma nova string:

      fmt.Println(strings.ReplaceAll(balloon, "has", "had"))
      

      Dentro dos parênteses, primeiro está a variável balloon que armazena a string original; a segunda substring "has" é a que gostaríamos de substituir e a terceira substring "had" é o que iria substituir a segunda substring. Nosso resultado ficaria parecida com a seguinte, depois que incorporarmos isto em um um programa:

      Output

      Sammy had a balloon.

      Usar as funções string strings.Join, strings.Split e strings.ReplaceAll fornecerá a você um maior controle para manipular strings em Go.

      Conclusão

      Este tutorial examinou algumas das funções comuns do pacote string quanto ao tipo de dados de string que você pode usar para trabalhar e manipular strings em seus programas em Go.

      Você pode aprender mais sobre outros tipos de dados em Entendendo os tipos de dados e ler mais sobre strings em Uma introdução para trabalhar com strings.



      Source link

      Uma introdução ao trabalho com Strings em Go


      Uma string é uma sequência de um ou mais caracteres (letras, números, símbolos) que podem ser uma constante ou uma variável. Criadas com o padrão de codificação de caracteres Unicode, as strings são sequências imutáveis, o que significa que elas não podem ser modificadas.

      Como o texto é uma forma tão comum de dados que usamos no dia a dia, o tipo de dados da string é um bloco de construção muito importante da programação.

      Este tutorial sobre a linguagem Go revisará como criar e imprimir strings, como concatenar e replicar strings e como armazenar strings em variáveis.

      Literais de string

      Na linguagem Go, as strings ficam entre sinais de crase (ou diacrítico de acento grave). ` (às vezes chamadas de acento à esquerda) ou aspas duplas ". Dependendo de quais aspas você utilizar, a string terá características diferentes.

      Usar sinais de crase, como em `bar`criará uma literal de string *raw *(bruta). Em uma literal de string bruta, qualquer caractere pode aparecer entre aspas, com a exceção dos sinais de crase. Aqui está um exemplo de uma literal de string bruta:

      `Say "hello" to Go!`
      

      As barras invertidas não possuem significado especial dentro de literais de string brutas. Por exemplo, o n aparecerá como os caracteres existentes, a barra invertida e a letra n – ao contrário do que ocorre com as literais de string interpretadas, em que a letra n efetivamente inseriria uma nova linha.

      As literais de string brutas também podem ser usadas para criar strings de várias linhas:

      `Go is expressive, concise, clean, and efficient.
      Its concurrency mechanisms make it easy to write programs
      that get the most out of multi-core and networked machines,
      while its novel type system enables flexible and modular
      program construction. Go compiles quickly to machine code
      yet has the convenience of garbage collection and the power
      of run-time reflection. It's a fast, statically typed,
      compiled language that feels like a dynamically typed,
      interpreted language.`
      

      As literais de string interpretadas são sequências de caracteres entre aspas duplas, como em "bar". Dentro das aspas, qualquer caractere pode aparecer com a exceção de nova linha e aspas duplas sem sequência de escape.

      "Say "hello" to Go!"
      

      Quase sempre você usará as literais de string interpretadas pois elas permitem o uso de caracteres de escape dentro delas.

      Agora que entende como as strings são formatadas em Go, vamos ver como imprimir strings em programas.

      Imprimindo strings

      Você pode imprimir strings usando o pacote fmt da biblioteca do sistema e chamando a função Println():

      fmt.Println("Let's print out this string.")
      

      Output

      Let's print out this string.

      Você precisa import (importar) os pacotes de sistema ao usá-los, de modo que para imprimir uma string, um progama simples ficaria parecido com este:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Let's print out this string.")
      }
      

      Concatenação de string

      *Concatenação *significa unir strings, de ponta a ponta, para criar uma nova string. Você pode concatenar strings com o operador +. Lembre-se de que quando trabalhar com números, o + será um operador de adição, mas quando usado com strings ele é um operador de união.

      Vamos combinar os literais de string "Sammy" e "Shark" junto com a concatenação através de uma instrução fmt.Println():

      fmt.Println("Sammy" + "Shark")
      

      Output

      SammyShark

      Se quiser um espaço em branco entre as duas strings, simplesmente inclua o espaço em branco dentro de uma string. Neste exemplo, adicione o espaço em branco dentro das aspas após Sammy:

      fmt.Println("Sammy " + "Shark")
      

      Output

      Sammy Shark

      O operador + não pode ser usado entre dois tipos de dados diferentes. Como exemplo, não é possível concatenar strings e números inteiros juntos. Se você tivesse que tentar escrever o seguinte:

      fmt.Println("Sammy" + 27)
      

      Você receberia os seguintes erros:

      Output

      cannot convert "Sammy" (type untyped string) to type int invalid operation: "Sammy" + 27 (mismatched types string and int)

      Se quisesse criar a string "Sammy27", poderia fazer isso colocando o número 27 entre aspas ("27") de modo que não mais seria um número inteiro, mas sim uma string. Converter os números em strings para concatenação pode ser útil ao se lidar com códigos de CEP ou números de telefone. Por exemplo, você não quer fazer uma soma entre um código de país e um código de área, mas quer que eles fiquem juntos.

      Ao combinar duas ou mais strings através de concatenação, você está criando uma nova string que pode usar ao longo do seu programa.

      Armazenando strings e variáveis

      Variáveis são símbolos que você pode usar para armazenar dados no programa. Você pode pensar nelas como uma caixa vazia que pode preencher com dados ou valores. As strings são dados, então você pode usá-las para preencher uma variável. Declarar strings como variáveis pode tornar o trabalho com strings mais fácil durante seus programas em Go.

      Para armazenar uma string dentro de uma variável, basta atribuir uma variável a uma string. Neste caso, declare s como sua variável:

      s := "Sammy likes declaring strings."
      

      Nota: se estiver familiarizado com outras linguagens de programação, você pode ter escrito a variável como sammy. A linguagem Go, entretanto, favorece nomes de variáveis mais curtos. Escolher s para o nome de variável neste caso seria considerado mais apropriado para o estilo no qual a linguagem Go é escrita.

      Agora que tem a variável s definida para essa string específica, você pode imprimir a variável dessa forma:

      fmt.Println(s)
      

      Então, você receberá o seguinte resultado:

      Output

      Sammy likes declaring strings.

      Ao usar variáveis para substituir strings, não será necessário digitar novamente uma string sempre que quiser usá-la, o que tornará o trabalho e a manipulação das strings mais simples dentro dos seus programas.

      Conclusão

      Este tutorial revisou os fundamentos do trabalho com o tipo de dados de string na linguagem de programação Go. Criar e imprimir strings, concatenar e replicar strings e armazenar strings em variáveis fornecerá a você os fundamentos para usar strings nos seus programas em Go.



      Source link