One place for hosting & domains

      Como converter tipos de dados em Go


      Introdução

      Na linguagem Go, os tipos de dados são usados para classificar um tipo específico de dados, determinando os valores que você pode atribuir ao tipo e às operações que você pode realizar com ela. Ao programar, há momentos em que você terá que converter valores entre os no tipos, no intuito de manipular tais valores de maneira diferente. Por exemplo, talvez você necessite concatenar valores numéricos com strings, ou representar casas decimais em números que foram inicializados como valores de número inteiro. Com frequência, o tipo de dados da string é automaticamente atribuído aos dados gerados pelo usuário, mesmo se consistirem em números. Para realizar operações matemáticas nessa entrada, por exemplo, você teria que converter a string para um tipo de dados numéricos.

      Como o Go é uma linguagem de tipagem estática, os tipos de dados são vinculados às variáveis e não aos valores. Isso significa que, se você definir uma variável como int, ela só poderá ser uma int; você não poderá atribuir-lhe uma string sem converter o tipo de dados da variável. A natureza estática dos tipos de dados em Go confere ainda mais importância ao aprendizado das maneiras de convertê-los.

      Este tutorial explicará sobre como converter números e strings, além de fornecer exemplos para ajudar você a se familiarizar com os diferentes casos de uso.

      Convertendo os tipos de número

      O Go tem vários tipos numéricos dentre os quais escolher. Em princípio, eles se dividem em dois tipos gerais: os números inteiros e os números de ponto flutuante.

      Existem várias situações nas quais você pode querer converter entre os tipos numéricos. Converter entre diferentes tamanhos de tipos numéricos pode ajudar a otimizar o desempenho em relação a tipos específicos de arquiteturas de sistema. Se você tiver um número inteiro de outra parte do seu código e quiser fazer uma divisão com ele, você pode querer converter o número inteiro em um float, a fim de preservar a precisão da operação. Além disso, trabalhar com durações do tempo geralmente envolve uma conversão de número inteiro. Para resolver essas situações, o Go tem a função de conversões de tipo integrada para a maioria dos tipos numéricos.

      Convertendo entre os tipos de inteiros

      A linguagem Go tem muitos tipos de dados inteiros dentre os quais escolher. Quando escolher um e não o outro, normalmente, é uma questão de desempenho; no entanto, haverá momentos em que você precisará converter de um tipo de número inteiro para outro. Por exemplo, o Go gera valores numéricos de maneira automática, como int, o qual pode não corresponder ao valor de sua entrada. Se o valor de sua entrada fosse um int64, não seria possível usar números int e int64 na mesma expressão matemática até que você convertesse seus respectivos tipos de dados para que correspondessem.

      Suponha que você tem um int8 e que precisa convertê-lo em um int32. Você pode fazer isso encapsulando-o na conversão de tipo int32():

      var index int8 = 15
      
      var bigIndex int32
      
      bigIndex = int32(index)
      
      fmt.Println(bigIndex)
      

      Output

      15

      Esse bloco de código define index como um tipo de dados int8 e bigIndex como um tipo de dados int32. Para armazenar o valor index no bigIndex, ele converte o tipo de dados para um int32. Isso é feito encapsulando-se conversão de int32() em torno da variável index.

      Para verificar seus tipos de dados, você poderia usar a instrução fmt.Printf e o verbo %T com a seguinte sintaxe:

      fmt.Printf("index data type:    %Tn", index)
      fmt.Printf("bigIndex data type: %Tn", bigIndex)
      

      Output

      index data type: int8 bigIndex data type: int32

      Como esse procedimento usa o verbo %T, a instrução de impressão produz o tipo para a variável e não o valor real da variável. Desta forma, você pode confirmar o tipo de dados convertido.

      Você pode, ainda, converter de um número inteiro de bit maior para um número inteiro de bit menor.

      var big int64 = 64
      
      var little int8
      
      little = int8(big)
      
      fmt.Println(little)
      

      Output

      64

      Lembre-se de que ao converter números inteiros, haveria a possibilidade de você exceder o valor máximo do tipo do dados e do wraparound:

      var big int64 = 129
      var little = int8(big)
      fmt.Println(little)
      

      Output

      -127

      Um wraparound ocorre quando um valor é convertido para um tipo de dados de tamanho pequeno demais para contê-lo. No exemplo anterior, o tipo de dados de 8 bits int8 não tinha espaço suficiente para conter a variável de 64 bits big. Ao se converter de um tipo de dados de valor maior para um tipo de dados de valor menor, é necessário sempre tomar cuidado para não truncar acidentalmente os dados.

      Convertendo os números inteiros em floats

      A conversão de números inteiros em floats em Go é parecida com a conversão de um tipo de número inteiro para outro. Você pode usar as conversões de tipo integradas, fazendo com que os tipos float64() ou float32() envolvam o número inteiro que você estiver convertendo:

      var x int64 = 57
      
      var y float64 = float64(x)
      
      fmt.Printf("%.2fn", y)
      

      Output

      57.00

      Esse código declara uma variável x do tipo int64 e inicializa seu valor em 57.

      var x int64 = 57
      

      Com a conversão do float64() envolvendo a variável x, o valor de 57 será convertido a um valor float de 57,00.

      var y float64 = float64(x)
      

      O verbo de impressão %2f diz ao fmt.Printf para formatar o float com dois decimais.

      Também é possível usar esse processo em uma variável. O código a seguir declara um f igual a 57 e, em seguida, imprime o novo float:

      var f float64 = 57
      fmt.Printf("%.2fn", f)
      

      Output

      57.00

      Você pode converter inteiros em floats usando tanto o float32() como o float64(). A seguir, você irá aprender como converter de floats em inteiros.

      Convertendo floats em inteiros

      O Go pode converter os floats em inteiros, mas o programa perderá a precisão do float.

      Envolver os floats em int(), ou um de seus tipos de dados de arquitetura independente, funciona de maneira similar à que usou para converter de um tipo inteiro a outro tipo. É possível adicionar um número de ponto flutuante dentro dos parênteses para convertê-lo em um número inteiro:

      var f float64 = 390.8
      var i int = int(f)
      
      fmt.Printf("f = %.2fn", f)
      fmt.Printf("i = %dn", i)
      

      Output

      f = 390.80 i = 390

      Esta sintaxe converteria o float 390.8 no número inteiro 390, eliminando a casa decimal.

      Você também pode usar essa técnica com as variáveis. O código a seguir declara b igual a 125.0 e c igual a 390.8; depois, o código os imprime como inteiros. A declaração de variável curta (:=) abrevia a sintaxe:

      b := 125.0
      c := 390.8
      
      fmt.Println(int(b))
      fmt.Println(int(c))
      

      Output

      125 390

      Ao converter os floats em inteiros com o tipo int(), o Go corta a casa decimal e os números do float que restam são usados para criar um inteiro. Note que, embora talvez você queira arredondar 390,8 para 391, o Go não fará isso através do tipo int(). Em vez disso, ele vai simplesmente eliminar a casa decimal.

      Números convertidos através de divisão

      Ao dividir tipos inteiros em Go, o resultado também será um tipo inteiro, com o modulus (módulo), ou o resto, removido.

      a := 5 / 2
      fmt.Println(a)
      

      Output

      2

      Se, ao dividir, qualquer um dos tipos de número for um float, todos os tipos serão automaticamente declarados como float:

          a := 5.0 / 2
          fmt.Println(a)
      

      Output

      2.5

      Isso divide o float 5.0 pelo número inteiro 2, tendo como resposta 2.5, que é um float que retém a precisão decimal.

      Nesta seção, você converteu entre os tipos de dados numéricos diferentes, incluindo tamanhos diferentes de inteiros e os números de ponto flutuante. A seguir, você irá aprender como converter entre números e strings.

      Uma string é uma sequência de um ou mais caracteres (letras, números ou símbolos). As strings são uma forma comum de dados em programas de computador. Você pode precisar converter strings em números e números em strings com bastante frequência, especialmente quando estiver incluindo dados gerados pelo usuário.

      Convertendo números em strings

      Você pode converter números em strings, usando o método strconv.Itoa do pacote strconv da biblioteca padrão do Go. Se passar um número ou uma variável entre os parênteses do método, aquele valor numérico será convertido em um valor de string.

      Primeiro, vamos examinar a conversão de de números inteiros. Para converter o inteiro 12 em um valor de string, você pode enviar o número o 12 para o método strconv.Itoa:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := strconv.Itoa(12)
          fmt.Printf("%qn", a)
      }
      

      Durante a execução deste programa, você receberá o seguinte resultado:

      Output

      "12"

      As aspas ao redor do número 12 significam que o número já não é mais um inteiro, mas sim um valor de string.

      Você usou o operador de instrução := tanto para declarar uma nova variável com o nome de a, como para atribuir o valor retornado pela função strconv.Itoa(). Neste caso, você atribuiu o valor 12 para sua variável. Você também usou o verbo %q na função fmt.Printf, o qual diz à função para citar a string fornecida.

      Com variáveis, você pode começar a ver como é prático converter inteiros em strings. Digamos que você queira monitorar o progresso diário dos usuários na programação, além do número de linhas que eles estão inserindo a cada vez no código que estão escrevendo. Você quer mostrar esse feedback para o usuário. Para tanto, você vai imprimir os valores de string e inteiro ao mesmo tempo:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      }
      

      Ao executar este código, você receberá o seguinte erro:

      Output

      invalid operation: ("Congratulations, " + user + "! You just wrote ") + lines (mismatched types string and int)

      Você não pode concatenar strings e inteiros em Go, de modo que terá que converter a variável lines para se tornar um valor de string:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + strconv.Itoa(lines) + " lines of code.")
      }
      

      Agora, quando executar o código, receberá o resultado a seguir, parabenizando o seu usuário pelo progresso alcançado:

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Se você tiver planos de converter um float em uma string, em vez de um inteiro em uma string, você seguirá passos e formatos semelhantes. Ao enviar um float para o método fmt.Sprint, a partir do pacote fmt na biblioteca Go padrão, será retornado um valor de string do float. Você pode usar o valor do float em si ou uma variável:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          fmt.Println(fmt.Sprint(421.034))
      
          f := 5524.53
          fmt.Println(fmt.Sprint(f))
      }
      

      Output

      421.034 5524.53

      Você pode fazer um teste para se assegurar de que está correto, fazendo a concatenação com uma string:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          f := 5524.53
          fmt.Println("Sammy has " + fmt.Sprint(f) + " points.")
      }
      

      Output

      Sammy has 5524.53 points.

      Agora, você pode certificar-se que o float foi devidamente convertido em uma string porque a concatenação foi realizada sem erros.

      Convertendo strings em números

      As strings podem ser convertidas em números, usando-se o pacote strconv da biblioteca padrão do Go. O pacote strconv tem funções para converter tipos de números inteiros e float. Essa é uma operação muito comum quando o programa aceita entradas do usuário. Por exemplo, se você tiver um programa que pede a idade de uma pessoa e a pessoa digita uma resposta, essa resposta é capturada como uma string. Na sequência, você teria que converter a idade em um int para, assim, fazer qualquer operação matemática com ela.

      Se sua string não tiver casas decimais, você provavelmente vai querer convertê-la em um número inteiro, usando a função strconv.Atoi. Se você souber que usará o número como um float, usaria a strconv.ParseFloat.

      Vamos usar o exemplo do usuário Sammy, monitorando as linhas de código escritas a cada dia. Você pode querer manipular esses valores com operações matemáticas, no intuito de dar um feedback mais interessante para o usuário. Porém, no momento, tais valores estão armazenados em strings:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          lines_more := lines_today - lines_yesterday
      
          fmt.Println(lines_more)
      }
      

      Output

      invalid operation: lines_today - lines_yesterday (operator - not defined on string)

      Como os dois valores numéricos foram armazenados em strings, você recebeu um erro. O operando - para a subtração não é um operando válido para dois valores de string.

      Modifique o código para incluir o método strconv.Atoi() que converterá as strings em inteiros, permitindo, assim, que você faça operações matemáticas com os valores que eram originalmente strings. Como há uma falha em potencial ao se converter uma string em um inteiro, você tem que verificar se há algum erro. Você pode usar uma instrução if para verificar se sua conversão foi bem-sucedida.

      package main
      
      import (
          "fmt"
          "log"
          "strconv"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          yesterday, err := strconv.Atoi(lines_yesterday)
          if err != nil {
              log.Fatal(err)
          }
      
          today, err := strconv.Atoi(lines_today)
          if err != nil {
              log.Fatal(err)
          }
          lines_more := today - yesterday
      
          fmt.Println(lines_more)
      }
      

      Como é possível que uma string não seja um número, o método strconv.Atoi() retornará tanto o tipo convertido, quanto um erro em potencial. Ao converter a partir de lines_yesterday com a função strconv.Atoi, você tem que verificar o valor retornado err para assegurar que o valor foi convertido. Se o err não for nil, significa que o strconv.Atoi não conseguiu converter o valor string em um inteiro. Nesse exemplo, você usou uma instrução if para verificar quanto a algum erro. Se um erro foi retornado, você usou o log.Fatal para registrar o erro e sair do programa.

      Ao executar o código anterior, você receberá:

      Output

      58

      Agora, tente converter uma string que não seja um número:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := "not a number"
          b, err := strconv.Atoi(a)
          fmt.Println(b)
          fmt.Println(err)
      }
      

      Você receberá o seguinte erro:

      Output

      0 strconv.Atoi: parsing "not a number": invalid syntax

      Como o b foi declarado, mas o strconv.Atoi não conseguiu fazer uma conversão, o valor nunca foi atribuído a b. Note que o b tem o valor de 0. Isso acontece porque o Go tem valores padrão referidos como valores de zero em Go. O strconv.Atoi fornece um erro que descreve porque ele também não conseguiu converter a string.

      Convertendo strings e bytes

      As strings em Go são armazenadas em uma fatia de bytes. Na linguagem Go, você pode converter entre uma fatia de bytes e uma string encapsulando-a nas conversões correspondentes de []byte() e string():

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          a := "my string"
      
          b := []byte(a)
      
          c := string(b)
      
          fmt.Println(a)
      
          fmt.Println(b)
      
          fmt.Println(c)
      }
      

      Aqui,você armazenou um valor de string em a; depois, converteu-o em uma fatia de bytes b; na sequência, converteu a fatia de bytes de volta em uma string, como c. Em seguida, imprimiu a, b e c na tela:

      Output

      my string [109 121 32 115 116 114 105 110 103] my string

      A primeira linha do resultado é a string original my string. A segunda linha imprimida é a fatia byte que compõe a string original. A terceira linha mostra que a fatia byte pode ser convertida de volta com segurança em uma string e imprimida.

      Conclusão

      Este tutorial do Go demonstrou como converter vários dos tipos de dados nativos importantes em outros tipos de dados, principalmente através de métodos integrados. Poder converter tipos de dados em Go permitirá que você faça coisas como aceitar as entradas de usuários e realizar operações matemáticas entre os diferentes tipos de números. Mais tarde, quando estiver usando o Go para escrever programas que aceitam dados de várias fontes diferentes como bancos de dados e APIs, você usará esses métodos de conversão para garantir que possa atuar sobre os seus dados. Também será possível otimizar o armazenamento, convertendo dados em tipos de dados menores.

      Se você quiser uma análise mais profunda dos tipos de dados em Go, verifique nosso artigo Entendendo tipos de dados em Go.



      Source link

      Entendendo os tipos de dados em Go


      Introdução

      Os tipos de dados especificam os tipos de valores que variáveis específicas armazenarão quando estiver escrevendo um programa. O tipo de dados também determina quais operações podem ser realizadas nos dados.

      Neste artigo, vamos ver os tipos de dados importantes nativos para Go. Esta não é uma investigação exaustiva dos tipos de dados, mas ajudará você a se familiarizar com as opções disponíveis em Go. Entender alguns tipos básicos de dados permitirá que você escreva um código mais claro, que apresente desempenho eficiente.

      Contexto

      Uma forma de pensar sobre os tipos de dados é considerar os diferentes tipos de dados que usamos no mundo real. Um exemplo de dados no mundo real são números: podemos usar números naturais (0, 1, 2, …), inteiros (…, -1, 0, 1, …) e números irracionais (π), por exemplo.

      Normalmente, em matemática, podemos combinar números de tipos diferentes e obter algum tipo de resposta. Podemos querer adicionar 5 a π, por exemplo:

      5 + π
      

      Ou podemos manter a equação como a resposta para levar em conta o número irracional, ou arredondar π para um número com uma quantidade reduzida de casas decimais, para, depois, somar os números:

      5 + π = 5 + 3.14 = 8.14
      

      Mas,se começarmos a tentar avaliar os números com outro tipo de dados, como palavras, as coisas começam a fazer menos sentido. Como resolveríamos a seguinte equação?

      shark + 8
      

      Para os computadores, cada tipo de dados é bastante diferente, como palavras e números. Consequentemente, precisamos ter cuidado sobre como usamos tipos de dados diferentes para atribuir valores e como os manipulamos nas operações.

      Números inteiros

      Assim como ocorre na matemática, os números inteiros na programação de computadores são números inteiros que podem ser positivos, negativos, ou 0 (…, -1, 0, 1, …). Em Go, um inteiro é conhecido como int. Como com outras linguagens de programação, não se deve usar pontos em números de quatro dígitos ou mais, então quando for escrever 1.000 no seu programa, escreva como 1000.

      Podemos imprimir um inteiro de uma forma simples assim:

      fmt.Println(-459)
      

      Output

      -459

      Ou, podemos declarar uma variável que, neste caso, é um símbolo do número que estamos usando ou manipulando, desta forma:

      var absoluteZero int = -459
      fmt.Println(absoluteZero)
      

      Output

      -459

      Também podemos fazer operações matemáticas com inteiros em Go. No bloco de código a seguir, usaremos o operador de atribuição := para declarar e instanciar a variável sum:

      sum := 116 - 68
      fmt.Println(sum)
      

      Output

      48

      Como mostra o resultado, o operador matemático - subtraiu o número inteiro 68 de 116, resultando em 48. Você irá aprender mais sobre a declaração de variáveis na seção Declarando tipos de dados para variáveis.

      Os inteiros podem ser usados de várias maneiras dentro de programas em Go. Conforme você for aprendendo mais sobre a linguagem Go, você terá muitas oportunidades de trabalhar com inteiros e desenvolver seus conhecimentos sobre esse tipo de dado.

      Números de ponto flutuante

      Um número de ponto flutuante ou float é usado para representar números reais que não podem ser expressos como inteiros. Os números reais incluem todos os números racionais e irracionais e, por isso, os números de ponto flutuante podem conter uma parte fracionada, como 9.0 ou -116.42. [TN: embora na língua portuguesa nós utilizemos a “,” (vírgula) como separador de casas decimais, vamos manter a notação usada em inglês, ou seja, usaremos o “.” (ponto) como separador de casas decimais, a fim de evitar conflitos com a programação.] Para a finalidade de considerarmos um float em um programa em Go, podemos dizer que se trata de um número contendo um ponto como separador decimal.[TN: please see prior comment on this.]

      Como fizemos com os números inteiros, podemos imprimir um número de ponto flutuante de uma forma simples assim:

      fmt.Println(-459.67)
      

      Output

      -459.67

      Também podemos declarar uma variável que identifica um float, desta forma:

      absoluteZero := -459.67
      fmt.Println(absoluteZero)
      

      Output

      -459.67

      Assim como com inteiros, também podemos fazer matemática com floats em Go:

      var sum = 564.0 + 365.24
      fmt.Println(sum)
      

      Output

      929.24

      Com os números inteiros e os números de ponto flutuante, é importante ter em mente que 3 ≠ 3.0, já que 3 refere-se a um inteiro enquanto 3.0 se refere a um float.

      Tamanhos dos tipos numéricos

      Além da distinção entre inteiros e floats, a linguagem Go tem dois tipos de dados numéricos que são distinguidos pela natureza estática ou dinâmica dos seus tamanhos. O primeiro tipo é um tipo independente de arquitetura, o que significa que o tamanho dos dados em bits não é alterado, independentemente da máquina em que o código estiver executando.

      Atualmente, a maioria das arquiteturas dos sistemas é de 32 bits ou 64 bits. Por exemplo, você pode estar desenvolvendo para um notebook moderno em Windows, no qual o sistema operacional executa uma arquitetura de 64 bits. No entanto, se estiver desenvolvendo um dispositivo como um relógio fitness, você pode estar trabalhando com uma arquitetura de 32 bits. Caso use um tipo independente de arquitetura como int32, independentemente da arquitetura para a qual você compilar, o tipo terá um tamanho constante.

      O segundo tipo é um tipo específico da implementação. Nesse tipo, o tamanho do bit pode variar, dependendo da arquitetura em que o programa foi compilado. Por exemplo, se usarmos o tipo int, quando Go compilar para uma arquitetura de 32 bits, o tamanho do tipo de dados será de 32 bits. Se o programa for compilado para uma arquitetura de 64 bits, a variável terá um tamanho de 64 bits.

      Além dos tipos de dados terem tamanhos diferentes, tipos como inteiros também vêm em dois tipos básicos: assinados e não assinados. Um int8 é um número inteiro assinado e pode assumir valores entre -128 e 127. Um uint8 é um número inteiro não assinado e apenas pode ter valores positivos entre 0 a 255.

      Os intervalos se baseiam no tamanho do bit. Para os dados binários, 8 bits podem representar um total de 256 valores diferentes. Como um tipo int precisa oferecer suporte tanto a valores positivos como a negativos, um inteiro de 8 bits (int8) terá um intervalo entre -128 a 127, para um total de 256 valores únicos possíveis.

      A linguagem Go tem os seguintes tipos de inteiros independentes de arquitetura:

      uint8       unsigned  8-bit integers (0 to 255)
      uint16      unsigned 16-bit integers (0 to 65535)
      uint32      unsigned 32-bit integers (0 to 4294967295)
      uint64      unsigned 64-bit integers (0 to 18446744073709551615)
      int8        signed  8-bit integers (-128 to 127)
      int16       signed 16-bit integers (-32768 to 32767)
      int32       signed 32-bit integers (-2147483648 to 2147483647)
      int64       signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
      

      Os floats e os números complexos também vêm em diferentes tamanhos:

      float32     IEEE-754 32-bit floating-point numbers
      float64     IEEE-754 64-bit floating-point numbers
      complex64   complex numbers with float32 real and imaginary parts
      complex128  complex numbers with float64 real and imaginary parts
      

      Também há alguns tipos de alias (pseudônimos) de números, os quais atribuem nomes úteis a tipos de dados específicos:

      byte        alias for uint8
      rune        alias for int32
      

      A finalidade do alias do byte é deixar claro quando o seu programa está usando bytes como uma medição computacional comum em elementos de string de caracteres, ao contrário do que ocorre com números inteiros pequenos e não relacionados com a medição de dados byte. Embora o byte e uint8 fiquem idênticos assim que o programa está compilado, com frequência, o byte é usado para representar dados de caracteres em forma numérica, ao passo que o objetivo do uint8 ser um número em seu programa.

      O alias rune é um pouco diferente. Enquanto o byte e o uint8 são exatamente os mesmos dados, um rune pode ser um único byte ou quatro bytes, um intervalo determinado pelo int32. Um rune é usado para representar um caractere Unicode, enquanto os caracteres ASCII podem ser representados apenas por um tipo de dados int32.

      Além disso, a linguagem Go tem os seguintes tipos específicos de implementação:

      uint     unsigned, either 32 or 64 bits
      int      signed, either 32 or 64 bits
      uintptr  unsigned integer large enough to store the uninterpreted bits of a pointer value
      

      Os tipos específicos de implementação terão seu tamanho definido pela arquitetura para a qual o programa foi compilado.

      Escolhendo tipos de dados numéricos

      Escolher o tamanho correto geralmente tem mais a ver com o desempenho para a arquitetura alvo para a qual está programando, do que o tamanho dos dados com os quais está trabalhando. No entanto, sem a necessidade de conhecer as implicações específicas do desempenho para o seu programa, você pode seguir algumas dessas diretrizes básicas quando estiver começando.

      Como discutimos anteriormente neste artigo, há tipos independentes da arquitetura e tipos específicos da implementação. Para os dados de números inteiros, é comum em Go usar tipos da implementação como o int ou uint, em vez de int64 ou uint64. Normalmente, isso resultará em velocidade de processamento mais rápida para sua arquitetura alvo. Por exemplo, se você usar um int64 e compilar para uma arquitetura de 32 bits, levará, pelo menos, o dobro do tempo necessário para processar esses valores, uma vez que são necessários ciclos adicionais da CPU para mover os dados pela arquitetura. Se, em vez disso, você tivesse usado um int, o programa definiria o tipo de implementação como uma arquitetura com 32 bits em tamanho para uma arquitetura de 32 bits e seria significativamente mais rápido para processar.

      Se você sabe que não vai exceder um intervalo de tamanho específico, então escolher um tipo independente da arquitetura pode aumentar a velocidade e diminuir o uso de memória. Por exemplo, se você souber que seus dados não irão exceder o valor de 100 e será apenas um número positivo, então, escolher um uint8 tornaria seu programa mais eficiente, uma vez que ele precisará de menos memória.

      Agora que examinamos alguns dos intervalos possíveis para os tipos de dados numéricos, vamos ver o que acontecerá se excedermos esses intervalos em nosso programa.

      Exceder vs. Limitar

      A linguagem Go tem capacidade tanto de exceder um número quanto de limitar um número quando você tenta armazenar um valor maior do que o tipo de dado foi concebido para armazenar, dependendo de se o valor for calculado no momento da compilação ou no da execução. Um erro de tempo de compilação acontece quando o programa encontra um erro enquanto ele tenta compilar o programa. Um erro de tempo de execução acontece após o programa estar compilado, enquanto ele está realmente em execução.

      No exemplo a seguir, definimos maxUint32 como seu valor máximo:

      package main
      
      import "fmt"
      
      func main() {
          var maxUint32 uint32 = 4294967295 // Max uint32 size
          fmt.Println(maxUint32)
      }
      

      Ele será compilado e executado gerando o seguinte resultado:

      Output

      4294967295

      Se adicionarmos 1 ao valor no tempo de execução, ele ficará limitado em 0:

      Output

      0

      Por outro lado, vamos alterar o programa para adicionar 1 à variável quando a atribuirmos, antes do momento da compilação:

      package main
      
      import "fmt"
      
      func main() {
          var maxUint32 uint32 = 4294967295 + 1
          fmt.Println(maxUint32)
      
      }
      

      No momento da compilação, se o compilador puder determinar que um valor será demasiadamente elevado para se manter no tipo de dados especificado, ele gerará um erro de overflow. Isso significa que o valor calculado é demasiadamente elevado para o tipo de dados que você especificou.

      Como o compilador pode determinar que irá exceder o valor, agora ele irá gerar um erro:

      Output

      prog.go:6:36: constant 4294967296 overflows uint32

      Entender os limites dos seus dados ajudará você a evitar possíveis bugs em seu programa no futuro.

      Agora que abordamos tipos numéricos, vamos ver como armazenar valores booleanos.

      Booleanos

      O tipo de dados booleano pode ser um de dois valores, true [verdadeiro] ou false [falso] e é definido como bool ao declará-lo como um tipo de dados. Os booleanos são usados para representar os valores verdade que estão associados ao ramo lógico da matemática, o qual informa algoritmos na ciência da computação.

      Os valores true e false sempre estarão com as letras t e f minúsculas respectivamente, já que eles são identificadores pré-declarados em Go.

      Muitas operações em matemática nos dão respostas que são avaliadas como verdadeiras ou falsas:

      • maior que
        • 500 > 100 verdadeiro
        • 1 > 5 falso
      • menor que
        • 200 < 400 verdadeiro
        • 4 < 2 falso
      • igual
        • 5 = 5 verdadeiro
        • 500 = 400 falso

      Assim como com números, podemos armazenar um valor booleano em uma variável:

      myBool := 5 > 8
      

      Então, podemos imprimir o valor booleano com uma chamada para a função fmt.Println():

      fmt.Println(myBool)
      

      Como 5 não é maior que 8, receberemos o seguinte resultado:

      Output

      false

      Conforme você for escrevendo mais programas em Go, você se tornará mais familiarizado com o funcionamento dos booleanos e como diferentes funções e operações sendo avaliadas como true ou false podem alterar o curso do programa.

      Strings

      Uma string é uma sequência de um ou mais caracteres (letras, números, símbolos) que podem ser uma constante ou uma variável. As strings existem entre sinais de crase “”ou aspas duplas“` em Go e têm características diferentes dependendo de quais sinais gráficos utilizar.

      Se você usar sinais de crase, estará criando um literal de string bruta. Se você usar aspas duplas, estará criando um literal de string interpretada.

      Literais de string bruta

      Os literais de string bruta são sequências de caracteres entre sinais de crase, frequentemente chamadas de backticks. Entre aspas, qualquer caractere aparecerá simplesmente como for exibido entre sinais de crase, exceto o caractere da crase em si.

      a := `Say "hello" to Go!`
      fmt.Println(a)
      

      Output

      Say "hello" to Go!

      Geralmente, as barras invertidas são usadas para representar caracteres especiais em strings. Por exemplo, em uma string interpretada, o n representaria uma nova linha em uma string. No entanto, as barras invertidas não têm um significado especial dentro de literais de string bruta:

      a := `Say "hello" to Go!n`
      fmt.Println(a)
      

      Como a barra invertida não tem um significado especial em um literal de string, na verdade, ela imprimirá o valor n, em vez de criar uma nova linha:

      Output

      Say "hello" to Go!n

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

      a := `This string is on
      multiple lines
      within a single back
      quote on either side.`
      fmt.Println(a)
      

      Output

      This string is on multiple lines within a single back quote on either side.

      Nos blocos de código anteriores, as novas linhas foram literalmente transferidas da entrada para a saída.

      Literais de string interpretada

      As literais de string interpretada são sequências de caracteres entre aspas duplas, como em "bar". Qualquer caractere pode vir entre aspas, exceto as novas linhas e as aspas duplas sem escape. Para mostrar aspas duplas em uma string interpretada, é possível usar a barra invertida como um caractere de escape, desta forma:

      a := "Say "hello" to Go!"
      fmt.Println(a)
      

      Output

      Say "hello" to Go!

      Quase sempre você vai usar os literais de string interpretada porque eles permitem o escape de caracteres dentro deles. Para obter mais informações sobre o trabalho com strings, leia o artigo Uma introdução ao trabalho com strings em Go.

      Strings com caracteres UTF-8

      O UTF-8 é um esquema de codificação usado para codificar caracteres de largura variável em um a quatro bytes. A linguagem Go já vem totalmente compatível com os caracteres UTF-8, sem qualquer configuração especial, bibliotecas ou pacotes. Caracteres romanos – como a letra A, podem ser representados por um valor do código ASCII, como o número 65. No entanto, com caracteres especiais como um caractere internacional , seria necessário ter o UTF-8 instalado. A linguagem Go usa o tipo de alias rune para dados do código UTF-8.

      a := "Hello, 世界"
      

      Você pode usar a palavra-chave range em um loop for para indexar qualquer string em Go, mesmo uma string do UTF-8. Os loops for e o range serão abordados mais detalhadamente na série de tutoriais. Por ora, o importante é saber que podemos usar essas ferramentas para a contagem dos bytes de uma determinada string:

      package main
      
      import "fmt"
      
      func main() {
          a := "Hello, 世界"
          for i, c := range a {
              fmt.Printf("%d: %sn", i, string(c))
          }
          fmt.Println("length of 'Hello, 世界': ", len(a))
      }
      

      No bloco de código acima, declaramos a variável a e atribuímos o valor Hello, 世界 a ela. O texto atribuído possui caracteres do UTF-8.

      Na sequência, usamos um loop for padrão, bem como a palavra-chave range. Em Go, a palavra-chave range irá indexar através de uma string que retorna um caractere de cada vez, além do índice de bytes em que o caractere está na string.

      Ao usar a função fmt.Printf, fornecemos uma string de formato %d: %sn. O %d é o verbo de impressão para um dígito (neste caso, um número inteiro) e o %s é o verbo de impressão para uma string. Então, fornecemos os valores de i, que é o índice atual do loop for e de c, que é o caractere atual no loop for.

      Por fim, imprimimos toda a extensão da variável a, usando a função integrada len.

      Anteriormente, mencionamos que um rune é um alias para o int32 e pode ser constituído por um a quatro bytes. O caractere usa três bytes para definir e o índice se move de acordo quando varia pela string UTF-8. É por esse motivo que o i não fica em sequência quando é impresso.

      Output

      0: H 1: e 2: l 3: l 4: o 5: , 6: 7: 世 10: 界 length of 'Hello, 世界': 13

      Como pode ver, o comprimento é mais longo do que o número de vezes que ele levou para atravessar a string.

      Nem sempre você vai trabalhar com strings do UTF-8, mas – quando tiver que trabalhar – já vai saber por que se tratam de runes e não de um int32 único.

      Declarando tipos de dados para variáveis

      Agora que você conhece os diferentes tipos de dados primitivos, vamos examinar como atribuir esses tipos às variáveis em Go.

      Em Go, podemos definir uma variável com a palavra-chave var, seguida do nome da variável e do tipo de dados desejado.

      No exemplo a seguir, vamos declarar uma variável chamada pi do tipo float64.

      A palavra-chave var é a primeira coisa a ser declarada:

      var pi float64
      

      Seguida pelo nome de nossa variável, pi:

      var pi float64
      

      E, por fim, o tipo de dados float64:

      var pi float64
      

      Opcionalmente, também podemos especificar um valor inicial, como 3.14:

      var pi float64 = 3.14
      

      Go é uma linguagem do tipo estática. Ser do tipo estática significa que cada instrução no programa é verificada no momento da compilação. Significa, também, que o tipo de dados é ligado à variável, enquanto que em linguagens dinamicamente ligadas, o tipo de dados é ligado ao valor.

      Por exemplo, em Go, o tipo é declarado ao se declarar uma variável:

      var pi float64 = 3.14
      var week int = 7
      

      Cada uma dessas variáveis poderia ser de um tipo diferente de dados, caso você as declarasse de outro modo.

      É diferente do que ocorre com uma linguagem como a PHP, na qual o tipo de dados está associado ao valor:

      $s = "sammy";         // $s is automatically a string
      $s = 123;             // $s is automatically an integer
      

      No bloco de código anterior, o primeiro $s é uma string porque lhe foi atribuído o valor "sammy" e o segundo é um número inteiro, pois tem o valor 123.

      Em seguida, vamos examinar tipos de dados mais complexos, como as matrizes.

      Matrizes

      Uma matriz é uma sequência ordenada de elementos. A capacidade de uma matriz é definida na hora de sua criação. Assim que uma matriz tiver um tamanho alocado a ela, o tamanho já não poderá ser alterado. Como o tamanho de uma matriz é estático, isso significa dizer que a alocação de memória ocorre uma única vez. Isso torna as matrizes um pouco rígidas com que se trabalhar, mas aumenta o desempenho do seu programa. Por isso, as matrizes são tipicamente usadas na otimização de programas. As fatias, abordadas a seguir, são mais flexíveis e constituem o que você poderia considerar como matrizes em outras linguagens.

      As matrizes são definidas pela declaração do tamanho da matriz e, em seguida, o tipo de dados com os valores definidos entre chaves { }.

      Uma matriz de strings se parece com esta:

      [3]string{"blue coral", "staghorn coral", "pillar coral"}
      

      Podemos armazenar uma matriz em uma variável e imprimi-la:

      coral := [3]string{"blue coral", "staghorn coral", "pillar coral"}
      fmt.Println(coral)
      

      Output

      [blue coral staghorn coral pillar coral]

      Como mencionado anteriormente, as fatias se assemelham às matrizes, porém são bem mais flexíveis. Vamos dar uma olhada nesse tipo de dados mutável.

      Fatias

      Uma fatia é uma sequência ordenada de elementos cujo comprimento pode ser alterado. As fatias podem aumentar seu tamanho de maneira dinâmica. Se você adicionar novos itens a uma fatia e ela não tiver memória suficiente para armazenar os novos itens, ela solicitará mais memória do sistema, conforme necessário. Como a fatia pode ser expandida para adicionar mais elementos quando necessário, sua utilização é mais comum que a das matrizes.

      As fatias são definidas pela declaração do tipo de dados, antecedida de um par de colchetes [] e tendo valores entre chaves { }.

      Uma fatia de números inteiros se parece com esta:

      []int{-3, -2, -1, 0, 1, 2, 3}
      

      Uma fatia de floats se parece com esta:

      []float64{3.14, 9.23, 111.11, 312.12, 1.05}
      

      Uma fatia de strings se parece com esta:

      []string{"shark", "cuttlefish", "squid", "mantis shrimp"}
      

      Vamos definir nossa fatia de strings como seaCreatures:

      seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp"}
      

      Podemos imprimi-las chamando a variável:

      fmt.Println(seaCreatures)
      

      O resultado será exatamente como a lista que criamos:

      Output

      [shark cuttlefish squid mantis shrimp]

      Podemos usar a palavra-chave append para adicionar um item à nossa fatia. O comando a seguir adicionará o valor da string de seahorse à fatia:

      seaCreatures = append(seaCreatures, "seahorse")
      

      Você pode verificar se ele foi adicionado, imprimindo a fatia:

      fmt.Println(seaCreatures)
      

      Output

      [shark cuttlefish squid mantis shrimp seahorse]

      Como pode ver, caso precise gerenciar um tamanho desconhecido de elementos, uma fatia será muito mais versátil que uma matriz.

      Mapas

      O mapa é o tipo hash ou dicionário integrado da linguagem Go. Os mapas usam chaves e valores como um par para armazenar dados. Em programação, isso é útil quando precisamos fazer uma rápida busca de valores por meio de um índice ou, neste caso, de uma chave. Por exemplo, você pode querer manter um mapa de usuários, indexado pelos seus IDs de usuário. A chave seria o ID do usuário e o objeto do usuário seria o valor. Um mapa é construído pelo uso da palavra-chave map, seguida do tipo de dados-chave – entre colchetes [ ] – e, depois, pelo tipo de dados do valor e dos pares de valores-chave – entre chaves.

      map[key]value{}
      

      Normalmente usado para reter dados relacionados, como a informação contida em um ID, um mapa se parece com isto:

      map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
      

      Você verá que, além das chaves, há também sinais de dois pontos ao longo do mapa. As palavras à esquerda dos dois pontos são as chaves. As chaves podem ser de qualquer tipo comparável em Go. Tipos comparáveis são tipos primitivos como strings, ints etc. Um tipo primitivo é definido pela linguagem e não é compilado por meio da combinação de outros tipos. Embora possam ser tipos definidos pelo usuário, o recomendado como melhor prática é manter tudo simples para evitar erros de programação. As chaves no dicionário acima são: name, animal, color e location.

      As palavras à direita dos dois pontos são os valores. Os valores podem constituir-se de qualquer tipo de dados. Os valores no dicionário acima são: Sammy, shark, blue e ocean.

      Vamos armazenar o mapa dentro de uma variável e imprimi-lo:

      sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
      fmt.Println(sammy)
      

      Output

      map[animal:shark color:blue location:ocean name:Sammy]

      Se quisermos isolar a cor da Sammy, podemos fazer isso chamando sammy["color"]. Vamos imprimir isso:

      fmt.Println(sammy["color"])
      

      Output

      blue

      Como os mapas oferecem pares chave-valor para a armazenagem de dados, eles podem ser elementos importantes em seu programa Go.

      Conclusão

      Neste ponto, você já deverá ter uma melhor compreensão sobre alguns dos principais tipos de dados disponíveis para uso na linguagem Go. Cada um desses tipos de dados irá tornar-se importante, à medida que você desenvolver projetos de programação na linguagem Go.

      Assim que você tiver um domínio sólido dos tipos de dados disponíveis em Go, você poderá aprender Como converter tipos de dados para alterar seus tipos de dados de acordo com a situação.



      Source link

      Cómo convertir tipos de datos en Go


      Introducción

      En Go, los tipos de datos se utilizan para clasificar un tipo de dato concreto y determinan los valores que puede asignar al tipo y las operaciones que puede realizar en él. Cuando realice tareas de programación, a veces deberá aplicar conversiones de valores entre tipos para manipular los valores de forma diferente. Por ejemplo, es posible que deba concatenar valores numéricos con cadenas o representar lugares decimales en números que se iniciaron como valores enteros. Los datos generados por el usuario a menudo se asignan al tipo de datos de cadena, incluso si consisten en números; para realizar operaciones matemáticas en esta entrada, tendría que convertir la cadena a un tipo de dato numérico.

      Ya que Go es un lenguaje de tipo estático, los tipos de datos se vinculan a variables en lugar de valores. Esto significa que si define una variable como int, solo puede ser int; no puede asignar una string a ella sin convertir el tipo de datos de la variable. En la naturaleza estática de los tipos de datos de Go se da aún más importancia a las formas de convertirlos.

      Este tutorial le servirá como guía para convertir números y cadenas, y en él encontrará ejemplos que lo ayudarán a familiarizarse con los diferentes casos de uso.

      Convertir tipos de números

      Go tiene varios tipos numéricos que puede elegir. Principalmente, se dividen en dos tipos generales: enteros y números de punto flotante.

      Existen muchas situaciones en las cuales posiblemente desee aplicar conversiones entre tipos numéricos. Realizar conversiones a diferentes tamaños de tipos numéricos puede servir para optimizar el rendimiento para clases específicas de arquitecturas de sistema. Si dispone de un entero de otra parte de su código y desea hacer una división en él, es posible que desee convertir el entero a un flotante para preservar la precisión de la operación. Además, para trabajar con duraciones de tiempo normalmente es necesario realizar conversiones de enteros. Para abordar estas situaciones, Go tiene conversiones de tipo integradas para la mayoría de los tipos numéricos.

      Realizar conversiones a tipos de enteros

      Go tiene muchos tipos de datos enteros entre los que se puede elegir. La elección de uno u otro normalmente se relaciona más con el rendimiento; sin embargo, habrá veces en las que necesitará realizar conversiones de un tipo de entero a otro. Por ejemplo, Go a veces genera automáticamente valores numéricos como int, que posiblemente no sea su valor de entrada. Si su valor de entrada fuese int64, no podría usar int y los números int64 en la misma expresión matemática sin antes convertir sus tipos de datos para que coincidan.

      Suponga que tiene un inst8 y debe convertirlo en un int32. Puede hacer esto ajustándolo en la conversión de tipo int32():

      var index int8 = 15
      
      var bigIndex int32
      
      bigIndex = int32(index)
      
      fmt.Println(bigIndex)
      

      Output

      15

      Este bloque de código define index como un tipo de dato int8 y bigIndex como un tipo de dato int32. Para almacenar el valor de index en bigIndex, convierte el tipo de dato en int32. Esto se hace ajustando la conversión de int32() alrededor de la variable index.

      Para verificar sus tipos de datos, podría usar la instrucción fmt.Prntf y el verbo %T con la siguiente sintaxis:

      fmt.Printf("index data type:    %Tn", index)
      fmt.Printf("bigIndex data type: %Tn", bigIndex)
      

      Output

      index data type: int8 bigIndex data type: int32

      Debido a que esto utiliza el verbo %T, la instrucción de impresión produce el tipo para la variable, no el valor real de esta. De esta forma, puede confirmar el tipo de dato convertido.

      También puede realizar conversiones de un entero con un tamaño de bits mayor a un entero con un tamaño de bits menor:

      var big int64 = 64
      
      var little int8
      
      little = int8(big)
      
      fmt.Println(little)
      

      Output

      64

      Tenga en cuenta que al convertir enteros podría superar potencialmente el valor máximo del tipo de datos y del ajuste:

      var big int64 = 129
      var little = int8(big)
      fmt.Println(little)
      

      Output

      -127

      Un ajuste tiene lugar cuando el valor se convierte a un tipo de dato que es demasiado pequeño para contenerlo. En el ejemplo anterior, el tipo de dato de 8 bits int8 no tenía suficiente espacio para contener la variable big de 64 bits. Se debe tener cuidado cuando se realicen conversiones de un tipo de dato numérico más grande a un tipo de dato numérico más pequeño, para no truncar los datos por accidente.

      Convertir enteros en flotantes

      La conversión de enteros en flotantes en Go se asemeja a la conversión de un tipo de entero en otro. Puede usar las conversiones de tipo integradas ajustando float64() o float32() alrededor del entero que convertirá:

      var x int64 = 57
      
      var y float64 = float64(x)
      
      fmt.Printf("%.2fn", y)
      

      Output

      57.00

      Este código declara una variable x de tipo int64 e inicializa su valor en 57.

      var x int64 = 57
      

      Ajustar la conversión float64() alrededor de x convertirá el valor de 57 en un valor flotante de 57.00.

      var y float64 = float64(x)
      

      El verbo de impresión %.2f indica a fmt.Printf que aplique formato al flotante con dos decimales.

      También puede usar este proceso en una variable: Con el siguiente código, se declara f como igual a 57 y luego se imprime el nuevo flotante:

      var f float64 = 57
      fmt.Printf("%.2fn", f)
      

      Output

      57.00

      Usando float32() o float64(), puede convertir enteros en flotantes. A continuación, aprenderá a convertir flotantes en enteros.

      Convertir flotantes en enteros

      Go puede convertir flotantes en enteros, pero el programa perderá la precisión del flotante.

      El ajuste de flotantes en int(), o uno de sus tipos de datos independientes de la arquitectura, funciona de forma similar al que empleó para la conversión de un tipo de entero en otro. Puede añadir un número de punto flotante dentro del paréntesis para convertirlo en un entero.

      var f float64 = 390.8
      var i int = int(f)
      
      fmt.Printf("f = %.2fn", f)
      fmt.Printf("i = %dn", i)
      

      Output

      f = 390.80 i = 390

      Esta sintaxis convertiría el flotante 390.8 en el entero 390 y quitaría el lugar decimal.

      También puede usar esto con variables. Con el siguiente código se declara que b es igual a 125.0 y que c es igual a 390.8, y luego estos se imprimen como enteros. La declaración de variable corta (:=) acorta la sintaxis:

      b := 125.0
      c := 390.8
      
      fmt.Println(int(b))
      fmt.Println(int(c))
      

      Output

      125 390

      Cuando se convierten flotantes en enteros con el tipo int(), Go corta el decimal y los números restantes de un flotante para crear un entero. Tenga en cuenta que, aunque posiblemente desee redondear 390.8 a 391, Go no hará esto a través del tipo int(). En vez de eso, quitará el decimal.

      Números convertidos mediante división

      Cuando se dividan tipos de enteros en Go, el resultado será también un tipo de entero, sin el modulus o resto:

      a := 5 / 2
      fmt.Println(a)
      

      Output

      2

      Si, al realizar la división, cualquiera de los tipos numéricos son un flotante, todos los tipos se declararán automáticamente como flotante:

          a := 5.0 / 2
          fmt.Println(a)
      

      Output

      2.5

      Con esto se divide el flotante 5.0 por el entero 2, y la respuesta 2.5 es un flotante que conserva la precisión decimal.

      A lo largo de esta sección, realizó conversiones entre diferentes tipos de datos numéricos, como tamaños de enteros diferentes y números con punto flotante. A continuación, aprenderá a realizar conversiones de números a cadenas.

      Realizar conversiones con cadenas

      Una cadena es una secuencia de uno o más caracteres (letras, números o símbolos). Las cadenas son una forma de dato común en los programas informáticos y es posible que deba convertir cadenas en números o números en cadenas con bastante frecuencia, sobre todo si toma datos generados por el usuario.

      Convertir números en cadenas

      Puede convertir números en cadenas usando el método strconv.ltoa del paquete strconv de la biblioteca estándar de Go. Si pasa un número o una variable a los paréntesis del método, ese valor numérico se convertirá en un valor de cadena.

      Primero, veremos la forma de convertir enteros. Para convertir el entero 12 a un valor de cadena, puede pasar 12 al método strconv.ltoa:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := strconv.Itoa(12)
          fmt.Printf("%qn", a)
      }
      

      Al ejecutar este programa, recibirá el siguiente resultado:

      Output

      "12"

      Las comillas alrededor del número 12 implican que este ya no es un entero, sino que ahora es un valor de cadena.

      Utilizó el operador de asignación := para declarar una nueva variable con el nombre a y asignar el valor mostrado de la función strconv.ltoa(). En este caso, asignó el valor 12 a su variable. También usó el verbo %q en la función fmt.Printf, que indica a la función que cite la cadena proporcionada.

      Con las variables podrá observar la practicidad de la conversión de enteros en cadenas. Supongamos que desea realizar un seguimiento del progreso de la programación diaria por parte de un usuario e introduce la cantidad de líneas de código que este escribe a la vez. Desearía mostrar esto al usuario e imprimirá los valores de cadenas y enteros al mismo tiempo:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      }
      

      Cuando ejecute este código, verá el siguiente error:

      Output

      invalid operation: ("Congratulations, " + user + "! You just wrote ") + lines (mismatched types string and int)

      No puede concatenar cadenas ni enteros en Go. Por lo tanto, deberá convertir la variable lines en un valor de cadena:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + strconv.Itoa(lines) + " lines of code.")
      }
      

      Ahora, cuando ejecute el código verá el siguiente resultado en el que se felicita a su usuario por su progreso:

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Si desea convertir en una cadena un flotante en vez de un entero, aplicará pasos y un formato similares. Cuando pase un flotante al método fmt.Sprint, desde el paquete fmt de la biblioteca estándar de Go, se mostrará un valor de cadena del flotante. Puede usar el valor flotante o una variable:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          fmt.Println(fmt.Sprint(421.034))
      
          f := 5524.53
          fmt.Println(fmt.Sprint(f))
      }
      

      Output

      421.034 5524.53

      Puede realizar una comprobación para asegurarse de que esté bien realizando una concatenación con una cadena:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          f := 5524.53
          fmt.Println("Sammy has " + fmt.Sprint(f) + " points.")
      }
      

      Output

      Sammy has 5524.53 points.

      Puede estar seguro de que su flotante se convirtió adecuadamente en una cadena porque la concatenación se realizó sin errores.

      Convertir cadenas en números

      Las cadenas pueden convertirse en números usando el paquete strconv de la biblioteca estándar Go. El paquete strconv tiene funciones para convertir tipos numéricos enteros y flotantes. Ésta es una operación muy común al aceptar entradas del usuario. Por ejemplo, si su programa solicitara la edad de una persona, cuando esta escribiera la respuesta se capturaría como una string. Tendría que convertirla en un int para hacer cualquier operación matemática con ella.

      Si su cadena no tiene lugares decimales, probablemente querrá convertirla en un entero usando la función strconv.Atoi. Si sabe que usará el número como un flotante, empleará strconv.ParseFloat.

      Usaremos el ejemplo del usuario Sammy realizando un seguimiento de las líneas de código escritas cada día. Es posible que desee manipular esos valores con cálculos matemáticos para proporcionar una respuesta más interesante para el usuario, pero se almacenan actualmente en cadenas:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          lines_more := lines_today - lines_yesterday
      
          fmt.Println(lines_more)
      }
      

      Output

      invalid operation: lines_today - lines_yesterday (operator - not defined on string)

      Debido a que los dos valores numéricos se hallaban almacenados en cadenas, vio un error. El operando - para la sustracción no es un operando válido para dos valores de cadena.

      Modifique el código para incluir el método strconv.Atoi() que convertirá las cadenas en enteros, lo que le permitirá realizar cálculos matemáticos con valores que eran originalmente cadenas. Ya que existe la posibilidad de que se produzcan fallas al convertir una cadena en un entero, debe verificar si hay errores. Puede usar una instrucción if para comprobar si su conversión se realizó correctamente.

      package main
      
      import (
          "fmt"
          "log"
          "strconv"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          yesterday, err := strconv.Atoi(lines_yesterday)
          if err != nil {
              log.Fatal(err)
          }
      
          today, err := strconv.Atoi(lines_today)
          if err != nil {
              log.Fatal(err)
          }
          lines_more := today - yesterday
      
          fmt.Println(lines_more)
      }
      

      Debido a que es posible que una cadena no sea un número, el método strconv.Atoi() mostrará el tipo convertido y el posible error. Al realizar una conversión a partir de lines_yesterday con la función strconv.Atoi, debe verificar el valor de retorno err para asegurarse de que el valor se haya convertido. Si err no es nil, significa que strconv.Atoi no pudo convertir correctamente el valor de cadena en un entero. En este ejemplo, usó una instrucción if para verificar si se produjo un error y, si se observó uno, usó log.Fatal para registrarlo y salir del programa.

      Cuando ejecute el código anterior, obtendrá lo siguiente:

      Output

      58

      A continuación, intente convertir una cadena que no sea un número:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := "not a number"
          b, err := strconv.Atoi(a)
          fmt.Println(b)
          fmt.Println(err)
      }
      

      Observará el siguiente error:

      Output

      0 strconv.Atoi: parsing "not a number": invalid syntax

      Debido a que se declaró b, pero strconv.Atoi no pudo realizar la conversión, nunca se asignó un valor a b. Observe que b tiene el valor 0. Esto se debe a que Go tiene valores predeterminados, conocidos como valores cero en Go. strconv.Atoi proporciona un error en el que se describe la razón por la que no se pudo convertir también la cadena.

      Convertir cadenas y bytes

      Las cadenas en Go se almacenan como un segmento de bytes. En Go, puede realizar conversiones de un segmento de bytes a una cadena ajustándola en las conversiones correspondientes de []byte()​​​1​​​ y string().

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          a := "my string"
      
          b := []byte(a)
      
          c := string(b)
      
          fmt.Println(a)
      
          fmt.Println(b)
      
          fmt.Println(c)
      }
      

      Aquí almacenó un valor de cadena en a, luego lo convirtió a un segmento de bytes b y luego convirtió el segmento de bytes de nuevo en una cadena como c. Después, imprimirá a, b y c en la pantalla:

      Output

      my string [109 121 32 115 116 114 105 110 103] my string

      La primera línea del resultado es la cadena original my string. La segunda línea impresa es el segmento de bytes que forma la cadena original. En la tercera línea se muestra que el segmento de bytes puede convertirse de forma segura en una cadena e imprimirse de nuevo.

      Conclusión

      En este tutorial de Go se demostró la forma de convertir varios de los tipos importantes de datos nativos en otros tipos de datos, principalmente mediante métodos integrados. Poder convertir tipos de datos en Go le permitirá hacer cosas como aceptar la entrada de un usuario y realizar cálculos matemáticos en diferentes tipos numéricos. Posteriormente, cuando utilice Go para escribir programas que acepten datos desde muchas fuentes diferentes como bases de datos y API, usará estos métodos de conversión para asegurarse de poder aplicar acciones a sus datos. También podrá optimizar el almacenamiento convirtiendo datos a tipos de datos más pequeños.

      Si desea ver un análisis más profundo de los tipos de datos de Go, consulte nuestro artículo Información sobre los tipos de datos de Go.



      Source link