One place for hosting & domains

      constantes

      Como usar variáveis e constantes em Go


      As variáveis são um importante conceito de programação a dominar. Tratam-se de símbolos que assumem um valor que você está usando em um programa.

      Este tutorial abordará alguns princípios básicos sobre as variáveis e melhores práticas para usá-las dentro dos programas em Go que você criar.

      Entendendo as variáveis

      Em termos técnicos, uma variável está atribuindo um local de armazenamento a um valor que é associado a um nome simbólico ou identificador. Usamos o nome da variável para referenciar aquele valor armazenado em de um programa de computador.

      Podemos pensar em uma variável como um rótulo que tem um nome nele, o qual você vincula a um valor.

      Sobre as variáveis na linguagem Go

      Vamos supor que temos um número inteiro, 1032049348 e queremos armazená-lo em uma variável em vez de ter que digitar esse número por repetidas vezes. Para alcançar isso, podemos usar um nome que seja fácil de lembrar, como a variável i. Para armazenar um valor em uma variável, usamos a seguinte sintaxe:

      i := 1032049348
      

      Podemos pensar nessa variável como um rótulo que está ligado ao valor.

      Exemplo de variável na linguagem Go

      O rótulo tem o nome da variável i escrito nele, e está ligado ao valor inteiro 1032049348.

      A frase i := 1032049348 é uma instrução de declaração e de atribuição que consiste em algumas partes:

      • o nome da variável (i)
      • a atribuição de uma declaração curta da variável (:=)
      • o valor que está sendo associado ao nome da variável (1032049348)
      • o tipo de dados inferido pela Go (int)

      Mais adiante, na próxima seção, veremos como definir o tipo de maneira explícita.

      Juntas, essas partes compõem a instrução que define a variável i como sendo igual ao valor do inteiro 1032049348.

      Assim que definimos uma variável como sendo igual a um valor, inicializamos ou criamos essa variável. Feito isso, estamos prontos para usar a variável em vez do valor.

      Assim que definirmos i como sendo igual ao valor 1032049348, poderemos usar i no lugar do número inteiro, então, vamos imprimi-la:

      package main
      
      import "fmt"
      
      func main() {
          i := 1032049348
          fmt.Println(i)
      }
      

      Output

      1032049348

      Também podemos usar as variáveis para fazer operações matemáticas de maneira rápida e fácil. Com i := 1032049348, podemos subtrair o valor inteiro 813 com a seguinte sintaxe:

      fmt.Println(i - 813)
      

      Output

      1032048535

      Neste exemplo, a linguagem Go faz a operação para nós, subtraindo 813 da variável i para retornar a soma 1032048535.

      A propósito da matemática, as variáveis podem ser definidas como sendo iguais aos resultados de uma equação matemática. Também podemos adicionar dois números juntos e armazenar o valor da soma na variável x:

      x := 76 + 145
      

      Você deve ter notado que esse exemplo se parece com álgebra. Da mesma forma que usamos letras e outros símbolos para representar números e quantidades em fórmulas e equações, as variáveis são nomes simbólicos que representam o valor de um tipo de dados. Para garantir o uso correto da sintaxe em Go, você precisará garantir que a sua variável esteja do lado esquerdo de qualquer equação.

      Vamos seguir em frente e imprimir x:

      package main
      
      import "fmt"
      
      func main() {
          x := 76 + 145
          fmt.Println(x)
      }
      

      Output

      221

      A linguagem Go retornou o valor 221 porque a variável x foi definida como sendo igual à soma de 76 e 145.

      As variáveis podem representar qualquer tipo de dados, não apenas os inteiros:

      s := "Hello, World!"
      f := 45.06
      b := 5 > 9 // A Boolean value will return either true or false
      array := [4]string{"item_1", "item_2", "item_3", "item_4"}
      slice := []string{"one", "two", "three"}
      m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}
      

      Se imprimir qualquer uma dessas variáveis, Go retornará o que for equivalente a essa variável. Vamos trabalhar com a instrução de atribuição para o tipo de dados slice da string:

      package main
      
      import "fmt"
      
      func main() {
          slice := []string{"one", "two", "three"}
          fmt.Println(slice)
      }
      

      Output

      [one two three]

      Atribuímos o valor da fatia da []string{"one", "two", "three"} para a slice da variável e, em seguida, usamos a função fmt.Println para imprimir aquele valor, chamando a slice.

      As variáveis funcionam criando uma pequena área na memória do seu computador – que aceita valores especificados que são, na sequência, associados com aquele espaço.

      Declarando as variáveis

      Em Go, existem diversas maneiras de declarar uma variável e, em alguns casos, mais de uma forma de declarar a mesma variável e valor.

      Podemos declarar uma variável chamada i de dados do tipo int sem inicialização. Isso significa que vamos declarar um espaço para colocar um valor, mas não dar a ele um valor inicial:

      var i int
      

      Isso cria uma variável declarada como i de dados do tipo int.

      Podemos inicializar o valor, usando o operador igual (=), assim como no exemplo a seguir:

      var i int = 1
      

      Em Go, ambas as formas de declaração são chamadas declarações longas de variáveis.

      Também podemos usar uma declaração curta de variável:

      i := 1
      

      Neste caso, temos uma variável chamada i e um tipo de dados int. Quando não especificarmos um tipo de dados, a Go irá inferir o tipo de dado.

      Com as três maneiras de declarar as variáveis, a comunidade Go adotou as seguintes expressões:

      • Use apenas a forma longa, var i int, quando não estiver inicializando a variável.

      • Use a forma curta, i :=1, ao declarar e inicializar.

      • Se não quiser que a Go infira o seu tipo de dados, mas ainda quiser usar uma declaração de variável curta, é possível encapsular seu valor no seu tipo desejado, com a seguinte sintaxe:

      i := int64(1)
      

      O uso da forma longa de declaração de variáveis não é considerado natural na linguagem Go, quando estamos inicializando o valor:

      var i int = 1
      

      É uma boa prática seguir a maneira como a comunidade Go normalmente declara as variáveis para que outros possam ler seus programas sem problemas.

      Valores zero

      Todos os tipos integrados têm um valor zero. Qualquer variável alocada é utilizável, mesmo se nunca tiver tido um valor atribuído. Podemos ver os valores zero com os seguintes tipos:

      package main
      
      import "fmt"
      
      func main() {
          var a int
          var b string
          var c float64
          var d bool
      
          fmt.Printf("var a %T = %+vn", a, a)
          fmt.Printf("var b %T = %qn", b, b)
          fmt.Printf("var c %T = %+vn", c, c)
          fmt.Printf("var d %T = %+vnn", d, d)
      }
      

      Output

      var a int = 0 var b string = "" var c float64 = 0 var d bool = false

      Usamos o verbo %T na instrução fmt.Printf. Isso diz à função para imprimir o data type da variável.

      Em Go, como todos os valores têm um valor zero, não podemos ter valores undefined [não definidos] como em algumas outras linguagens. Por exemplo, um boolean em algumas linguagens poderia ser undefined, true, ou false, o que permite three estados para a variável. Em Go, não podemos ter mais de two estados de um valor booleano.

      Nomeando variáveis: regras e estilo

      A nomeação de variáveis é bastante flexível, mas existem algumas regras a serem lembradas:

      • Os nomes das variáveis devem consistir em apenas uma palavra (ou seja, sem nenhum espaço).
      • Os nomes das variáveis devem ser constituídos apenas de letras, números e sublinhados (_).
      • Os nomes das variáveis não podem começar com um número.

      Seguindo essas regras, vejamos alguns exemplos de nomes de variáveis válidos e inválidos:

      Válidos Inválidos Por que inválidos
      userName user-name Hifens não são permitidos
      name4 4name Não é possível começar com um número
      user $user Não é possível usar símbolos
      userName user name Não é possível haver mais de uma palavra

      Além disso, ao nomear as variáveis, tenha em mente que elas diferenciam letras maiúsculas de minúsculas. Estes nomes userName, USERNAME, UserName e uSERnAME são todos de variáveis completamente diferentes. Como parte das melhores práticas, é melhor evitar o uso de nomes de variáveis semelhantes dentro de um programa, a fim de garantir que você e seus colaboradores — atuais e futuros — consigam ter clareza quanto às suas variáveis.

      Embora as variáveis diferenciem letras maiúsculas de minúsculas, a caixa (alta ou baixa) em que vem a primeira letra de uma variável tem um significado especial em Go. Se uma variável iniciar com uma letra em caixa alta, então essa variável é acessível fora do pacote em que foi declarada (ou exported [exportada]). Se uma variável iniciar com uma letra em caixa baixa, então ela está disponível apenas dentro do pacote em que foi declarada.

      var Email string
      var password string
      

      Email começa com uma letra em caixa alta e pode ser acessada por outros pacotes. password começa com uma letra minúscula e é acessível apenas dentro do pacote em que ela foi declarada.

      É comum usar nomes de variáveis bastante concisos (ou curtos) em Go. Frente às opções de escolha entre userName e user para uma variável, a escolha mais natural seria user.

      O escopo também desempenha um papel na concisão do nome da variável. A regra é que, quanto menor o escopo em que a variável existe, menor o nome da variável:

      names := []string{"Mary", "John", "Bob", "Anna"}
      for i, n := range names {
          fmt.Printf("index: %d = %qn", i, n)
      }
      

      Usamos a variável names em um escopo mais amplo. Dessa forma, seria comum dar a ela um nome mais significativo para ajudar a lembrar o que ela significa no programa. No entanto, usamos as variáveis i e n imediatamente na linha seguinte do código e, depois, não as usamos novamente. Por isso, a pessoa que estiver lendo o código não irá confundir-se quanto a onde as variáveis são usadas, ou o que significam.

      A seguir, vamos tratar de algumas observações a respeito do estilo da variável. O estilo consiste em usar MixedCaps (letras em caixas mistas) ou mixedCaps, em vez de usar sublinhados para nomes com várias palavras.

      Estilo convencional Estilo não convencional Por que não convencional
      userName user_name Sublinhados não são convencionais
      i index prefira i a index por ser mais curto
      serveHttp serveHttp os acrônimos devem ser em letras maiúsculas

      O mais importante na questão de estilo é a consistência, bem como que a equipe com quem trabalha concorde com o estilo.

      Reatribuindo variáveis

      Assim como a palavra “variável” indica, podemos alterar as variáveis do Go facilmente. Isso significa que podemos conectar um valor diferente com uma variável previamente atribuída através de uma reatribuição. Essa capacidade de reatribuir é útil porque, ao longo de um programa, podemos precisar aceitar valores gerados pelo usuário em variáveis já inicializadas. Também podemos precisar alterar a atribuição para algo definido anteriormente.

      Saber que podemos reatribuir uma variável facilmente pode ser útil ao trabalhar em um programa grande que outra pessoa escreveu, onde não está claro quais variáveis já foram definidas.

      Vamos atribuir o valor 76 a uma variável chamada i do tipo int e, então, atribuir a ela um novo valor de 42:

      package main
      
      import "fmt"
      
      func main() {
          i := 76
          fmt.Println(i)
      
          i = 42
          fmt.Println(i)
      }
      

      Output

      76 42

      Esse exemplo mostra que podemos atribuir primeiro a variável i com o valor de um número inteiro e, em seguida, reatribuir a variável i, atribuindo-lhe desta vez o valor 42.

      Nota: quando declarar e inicializar uma variável, você pode utilizar :=; no entanto, quando quiser simplesmente alterar o valor de uma variável já declarada, basta usar o operador igual (=).

      Como Go é uma linguagem typed, não é possível atribuir um tipo a outro. Por exemplo, não podemos atribuir o valor "Sammy" a uma variável do tipo int:

      i := 72
      i = "Sammy"
      

      Tentar atribuir diferentes tipos entre si resultará em um erro de tempo de compilação:

      Output

      cannot use "Sammy" (type string) as type int in assignment

      A linguagem Go não nos permitirá usar um nome de variável mais de uma vez:

      var s string
      var s string
      

      Output

      s redeclared in this block

      Se tentarmos usar uma declaração de variável curta mais de uma vez para o mesmo nome da variável, também receberemos um erro de compilação. Isso pode acontecer por engano, de modo que é útil entender o que a mensagem de erro significa:

      i := 5
      i := 10
      

      Output

      no new variables on left side of :=

      Assim como acontece com a declaração de uma variável, repensar os nomes de suas variáveis melhorará a legibilidade do seu programa para você e outros, quando revisitá-lo no futuro.

      Atribuição múltipla

      A linguagem Go também nos permite atribuir vários valores a várias variáveis na mesma linha. Cada um desses valores pode ser de um tipo de dados diferente:

      j, k, l := "shark", 2.05, 15
      fmt.Println(j)
      fmt.Println(k)
      fmt.Println(l)
      

      Output

      shark 2.05 15

      Neste exemplo, a variável j foi atribuída para a string "shark", a variável k foi atribuída para o número de float 2.05 e a variável l foi atribuída para o número inteiro 15.

      Com essa abordagem de atribuir várias variáveis a vários valores em uma linha, você conseguirá manter um número baixo de linhas no seu código. No entanto, é importante não comprometer a legibilidade apenas para reduzir o número de linhas do código.

      Variáveis globais e locais

      Ao usar variáveis dentro de um programa, é importante ter o escopo da variável em mente. O escopo de uma variável se refere aos lugares em que ela fica acessível dentro do código de um dado programa. Isso significa que nem todas as variáveis são acessíveis de todas as partes de um dado programa — algumas variáveis serão globais e algumas serão locais.

      As variáveis globais existem fora de funções. As variáveis locais existem dentro de funções.

      Vejamos as variáveis globais e locais em ação:

      package main
      
      import "fmt"
      
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
      }
      
      func main() {
          printLocal()
          fmt.Println(g)
      }
      

      Output

      local global

      Aqui, usamos o var g = "global" para criar uma variável global fora da função. Então, definimos a função printLocal(). Dentro da função, uma variável local chamada l é atribuída e, depois, impressa. O programa termina chamando o printLocal() na, na sequência, imprimindo a variável global g.

      Como o g é uma variável global, podemos referir-nos a ela em printLocal(). Vamos modificar o programa anterior para fazer isso:

      package main
      
      import "fmt"
      
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
          fmt.Println(g)
      }
      
      func main() {
          printLocal()
          fmt.Println(g)
      }
      

      Output

      local global global

      Começamos declarando uma variável global g, var g = "global". Na função main, chamamos a função printLocal, que declara uma variável local l e a imprime, fmt.Println(l). Na sequência, o printLocal imprime a variável global g, fmt.Println(g). Embora g não tenha sido definida dentro do printLocal, ainda assim ela ficaria acessível, pois ela já havia sido declarada em um escopo global. Por fim, a função main também imprime a variável g.

      Agora, vamos tentar chamar a variável local fora da função:

      package main
      
      import "fmt"
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
      }
      
      func main() {
          fmt.Println(l)
      }
      
      

      Output

      undefined: l

      Não podemos usar uma variável local fora da função para a qual ela foi atribuída. Se tentar fazer isso, receberá um erro undefined (indefinido) ao compilar.

      Vejamos outro exemplo em que usamos o mesmo nome de variável para uma variável global e uma variável local:

      package main
      
      import "fmt"
      
      var num1 = 5
      
      func printNumbers() {
          num1 := 10
          num2 := 7  
      
          fmt.Println(num1)
          fmt.Println(num2)
      }
      
      func main() {
          printNumbers()
          fmt.Println(num1)
      }
      

      Output

      10 7 5

      Neste programa, declaramos a variável num1 duas vezes. Primeiro, declaramos num1 no escopo global, var num1 = 5 e, novamente, dentro do escopo local da função printNumbers, num1 := 10. Ao imprimir num1 do programa main, vemos o valor de 5 impresso. Isso se dá devido ao fato de que o main enxerga somente a declaração da variável global. No entanto, quando imprimimos num1 a partir da função printNumbers, ela verá a declaração local e irá imprimir o valor de 10. Mesmo que o printNumbers crie uma nova variável chamada num1 e lhe atribua o valor de 10, ela não afeta a instância global do num1 com o valor de 5.

      Ao trabalhar com variáveis, você também precisa considerar quais partes do seu programa precisam de acesso a cada uma das variáveis e, desse modo, adotar variáveis globais ou locais,conforme o caso. Nos programas em Go, você descobrirá que as variáveis locais são normalmente mais comuns.

      Constantes

      Constantes são como variáveis, exceto pelo fato de não poderem ser modificadas, uma vez que tenham sido declaradas. Constantes são úteis para definir um valor que será usado mais de uma vez no seu programa, mas não devem ser passíveis de alteração.

      Por exemplo, se quiséssemos declarar a taxa de imposto de um sistema de carrinho de compra, poderíamos usar uma constante e então calcular o imposto em diferentes áreas do nosso programa. Dessa maneira, caso a taxa do imposto venha a ser alterada no futuro, somente teremos que alterar aquele valor em um ponto único de nosso programa. Se usássemos uma variável, correríamos o risco de alterar o valor por engano em algum lugar no nosso programa, o que, por sua vez, resultaria em um cálculo incorreto.

      Para declarar uma constante, podemos usar a seguinte sintaxe:

      const shark = "Sammy"
      fmt.Println(shark)
      

      Output

      Sammy

      Se tentarmos modificar uma constante depois de ela ter sido declarada, vamos obter um erro de tempo de compilação:

      Output

      cannot assign to shark

      As constantes podem ser untyped [sem tipo]. Essa característica pode ser útil no trabalho com números, como dados do tipo números inteiros. Se a constante é untyped, ela é convertida de maneira clara, ao passo que as constantes typed não. Vamos ver como usar constantes:

      package main
      
      import "fmt"
      
      const (
          year     = 365
          leapYear = int32(366)
      )
      
      func main() {
          hours := 24
          minutes := int32(60)
          fmt.Println(hours * year)    
          fmt.Println(minutes * year)   
          fmt.Println(minutes * leapYear)
      }
      

      Output

      8760 21900 21960

      Se declarar uma constante com um tipo, ela será daquele tipo exato. Aqui, quando declaramos a constante leapYear, nós a definimos como sendo do tipo de dados int32. Portanto, trata-se de uma constante typed, o que significa que ela só opera com tipos de dados int32. A constante year foi declarada sem tipo, assim, ela é considerada untyped. Por causa disso, é possível usá-la com qualquer tipo de dado de número inteiro.

      Quando a constante hours tiver sido definida, o programa vai* inferir* que se trata de uma constante do tipo int, pois não demos a ela – de maneira clara – um tipo, hours := 24. Por outro lado, ao declararmos minutes, nós a estaremos declarando explicitamente como sendo do tipo int32, minutes := int32(60).

      Agora, vejamos cada cálculo e o motivo pelo qual ele funciona:

      hours * year
      

      Nesse caso, hours é um int e years é untyped. Quando o programa compila, ele converte explicitamente years para um tipo int, o que permite que a operação de multiplicação seja bem-sucedida.

      minutes * year
      

      Nesse caso, minutes é um int32 e year é untyped. Quando o programa compila, ele converte explicitamente years para um int32, o que permite que a operação de multiplicação seja bem-sucedida.

      minutes * leapYear
      

      Nesse caso, minutes é um int32 e leapYear é uma constante typed de int32. Não há nada a ser feito pelo compilador desta vez, já que ambas as variáveis já são do mesmo tipo.

      Se tentarmos multiplicar dois tipos que sejam typed e não compatíveis, o programa não irá compilar:

      fmt.Println(hours * leapYear)
      

      Output

      invalid operation: hours * leapYear (mismatched types int and int32)

      Neste caso, hours foi inferida como sendo do tipo int e leapYear foi explicitamente declarada como sendo do tipo int32. Como Go é uma linguagem de tipos, um int e um int32 não são compatíveis em operações matemáticas. Para multiplicá-los, seria necessário converter um deles para int32 ou int.

      Conclusão

      Neste tutorial, analisamos alguns dos casos de uso comuns de variáveis dentro da linguagem Go. As variáveis consistem em um importante bloco de construção de programação, servindo como símbolos que representam o valor de um tipo de dado que usamos em um programa.



      Source link

      Cómo usar variables y constantes en Go


      Las variables son un concepto de programación que es importante dominar. Son símbolos que sustituyen valores que se usan en un programa.

      En este tutorial, se abarcarán algunos aspectos básicos de variables y las prácticas recomendadas para utilizarlos en los programas de Go que cree.

      Información sobre variables

      En términos técnicos, una variable asigna una ubicación de almacenamiento a un valor vinculado a un nombre o identificador simbólico. Usamos el nombre de variable para hacer referencia a ese valor almacenado en un programa informático.

      Podemos concebir una variable como una etiqueta con nombre, que se vincula a un valor.

      Variables en Go

      Supongamos que tenemos un número entero, 103204948, y queremos almacenar esta larga cifra en una variable en lugar de volver a escribirla una y otra vez. Para hacerlo, podemos usar un nombre fácil recordar, como la variable i. Para almacenar un valor en una variable, usaremos la siguiente sintaxis:

      i := 1032049348
      

      Podemos imaginar esta variable como una etiqueta que está vinculada al valor.

      Ejemplo de una variable Go

      La etiqueta tiene escrito el nombre de una variable i y está vinculada al valor entero 1032049348.

      La frase i := 1032049348 es una instrucción de declaración y asignación que consta de algunas partes:

      • el nombre de la variable (i)
      • la instrucción de declaración de variable corta (​​​​​​:=​​​​​​)
      • el valor vinculado al nombre de la variable (1032049348)
      • el tipo de datos inferido por Go (int)

      Más adelante, veremos la manera de establecer el tipo de forma explícita en la siguiente sección.

      Juntas, estas partes conforman la instrucción que establece que la variable i es igual al valor del número entero 1032049348.

      En el momento en que se establece una variable igual a un valor, se inicia o se crea esa variable. Una vez que lo hagamos, estaremos listos para usar la variable en lugar del valor.

      Una vez que establezcamos que i es igual al valor 1032049348, podremos usar i en lugar del número entero, por lo que lo imprimiremos:

      package main
      
      import "fmt"
      
      func main() {
          i := 1032049348
          fmt.Println(i)
      }
      

      Output

      1032049348

      Mediante variables también se pueden realizar cálculos de forma rápida y sencilla. Con i := 1032049348, podemos restar el valor entero 813 con la siguiente sintaxis:

      fmt.Println(i - 813)
      

      Output

      1032048535

      En este ejemplo, Go hace los cálculos por nosotros y resta 813 a la variable i para mostrar la suma 1032048535.

      Ya que mencionamos los cálculos, las variables pueden configurarse de modo que sean iguales al resultado de una ecuación matemática. También puede añadir dos números juntos y almacenar el valor de la suma en la variable x:

      x := 76 + 145
      

      Posiblemente haya observado que este ejemplo se asemeja a uno de álgebra. Así como usamos letras y otros símbolos para representar números y cantidades en fórmulas y ecuaciones, las variables son nombres simbólicos que representan el valor de un tipo de datos. Para corregir la sintaxis de Go, deberá asegurarse que su variable esté en el lado izquierdo de cualquier ecuación.

      Imprimiremos x:

      package main
      
      import "fmt"
      
      func main() {
          x := 76 + 145
          fmt.Println(x)
      }
      

      Output

      221

      Go mostró el valor 221 porque la variable x se estableció en un valor igual a la suma de 76 y 145.

      Las variables pueden representar cualquier tipo de datos, no solo números enteros:

      s := "Hello, World!"
      f := 45.06
      b := 5 > 9 // A Boolean value will return either true or false
      array := [4]string{"item_1", "item_2", "item_3", "item_4"}
      slice := []string{"one", "two", "three"}
      m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}
      

      Si imprime cualquiera de estas variables, Go mostrará lo que es equivalente a esa variable. Trabajar con la instrucción de asignación para el tipo de datos slice de cadena:

      package main
      
      import "fmt"
      
      func main() {
          slice := []string{"one", "two", "three"}
          fmt.Println(slice)
      }
      

      Output

      [one two three]

      Asignamos el valor de slice de []string{"one", "two", "three"} a la variable slice y luego usamos la función fmt.Println para imprimir ese valor llamando a slice.

      Las variables funcionan quitando una área pequeña de memoria de su computadora que acepta valores especificados, los cuales luego se asocian con ese espacio.

      Declarar variables

      En Go, hay varias formas de declarar una variable y, en algunos casos, más de una forma de declarar exactamente la variable y el valor idénticos.

      Podemos declarar una variable llamada i del tipo de datos int sin iniciarla. Esto significa que declararemos un espacio para ubicar un valor, pero no le daremos un valor inicial:

      var i int
      

      Esto crea una variable del tipo de datos int declarada como i.

      Podemos inicializar el valor usando el operador igual (=), como en el siguiente ejemplo:

      var i int = 1
      

      En Go, las dos formas de instrucción se denominan declaraciones variables largas.

      También podemos usar una declaración variable corta:

      i := 1
      

      En este caso, contamos con una variable llamada i y un tipo de datos int. Cuando no especifiquemos un tipo de datos, Go lo inferirá.

      Con las tres formas de declarar variables, la comunidad de Go adoptó los siguientes idiomas:

      • Utilice únicamente una forma larga, var i int, cuando no inicialice la variable.

      • Utilice la forma corta, i := 1, en la declaración y el inicio.

      • Si no desea que Go infiera su tipo de datos, pero de todos modos quiere usar una declaración variable corta, puede ajustar su valor en el tipo que desee con la siguiente sintaxis:

      i := int64(1)
      

      No se considera idiomático en Go el uso del formulario de instrucción variable larga cuando se inicia el valor:

      var i int = 1
      

      Es recomendable mantenerse al corriente sobre la manera en que la comunidad de Go declara variables para que otros puedan leer sus programas sin problemas.

      Valores cero

      Todos los tipos incorporados tienen un valor cero. Cualquier variable asignada se puede usar incluso cuando nunca tenga un valor asignado. Podemos ver los valores cero para los siguientes tipos:

      package main
      
      import "fmt"
      
      func main() {
          var a int
          var b string
          var c float64
          var d bool
      
          fmt.Printf("var a %T = %+vn", a, a)
          fmt.Printf("var b %T = %qn", b, b)
          fmt.Printf("var c %T = %+vn", c, c)
          fmt.Printf("var d %T = %+vnn", d, d)
      }
      

      Output

      var a int = 0 var b string = "" var c float64 = 0 var d bool = false

      Usamos el verbo %T en la instrucción fmt.Printf. Esto indica a la función que imprima el data type de la variable.

      En Go, debido a que todos los valores tienen un valor zero, no puede haber valores undefined como en otros lenguajes. Por ejemplo, un boolean en algunos lenguajes podría ser undefined, true o false, lo que permite tres estados para la variable. En Go, no podemos exceder el valor de estados two para un valor boolean.

      Nombrar variables: reglas y estilos

      La asignación de nombres a variables es bastante flexible, pero hay reglas que se deben tener en cuenta:

      • Los nombres de variables solo deben constar de una palabra (no deben llevar espacios).
      • Deben contener solo letras, números y guiones bajos (_).
      • No pueden comenzar con un número.

      Siguiendo estas reglas, observaremos los nombres de variables válidos y no válidos:

      Válido No válido Por qué no es válido
      userName user-name No se permiten a guiones.
      name4 4name No puede comenzar con un número.
      user $user No puede llevar símbolos.
      userName Nombre de usuario No puede constar de más de una palabra.

      Además, al asignar nombres a variables tenga en cuenta que se distinguen mayúsculas y minúsculas. Estos nombres ​​​1​​​userName​​​1​​​, ​​​2​​​USERNAME​​​2​​​, ​​​3​​​UserName​​​3​​​ y ​​​4​​​uSERnAME​​​4​​​ son variables completamente diferentes. Es recomendable evitar usar nombres de variables similares en un programa para garantizar que tanto usted como sus colaboradores, actuales y futuros, puedan mantener sus variables de forma correcta.

      Si bien para las variables se distinguen mayúsculas y minúsculas, el caso de la primera letra de una variable tiene un significado especial en Go. Si una variable comienza con una letra mayúscula, se puede acceder a dicha variable fuera del paquete en el que se declaró (o recibió el valor exported). Si una variable comienza con una letra minúscula, solo está disponible dentro del paquete en el que se declara.

      var Email string
      var password string
      

      Email comienza con una letra mayúscula y otros paquetes pueden acceder a él. password comienza con minúscula y el acceso a ella solo es posible dentro del paquete en el que se declara.

      En Go, es común utilizar nombres de variables muy concisos (o cortos). Dada la opción entre userName y user para una variable, sería idiomático elegir user.

      El ámbito también desempeña un papel en la unidad del nombre de variable. La regla es que cuanto más pequeño es el ámbito de la variable, más pequeño es el nombre de esta:

      names := []string{"Mary", "John", "Bob", "Anna"}
      for i, n := range names {
          fmt.Printf("index: %d = %qn", i, n)
      }
      

      Utilizamos la variable names en un ámbito más amplio, por lo que sería normal darle un nombre más significativo para ayudar a recordar lo que representa en el programa. Sin embargo, usamos las variables i y n inmediatamente en la siguiente línea de código, y luego no las volvemos a usar. Debido a esto, no confundirá a alguien que lea el código respecto de dónde se usan las variables o qué significan.

      A continuación, veremos algunas notas sobre el estilo de las variables. El estilo consiste en usar MixedCaps o mixedCaps en lugar de guiones bajos para nombres de varias palabras.

      Estilo convencional Estilo no convencional Por qué no convencional
      userName user_name Los guiones bajos no son convencionales.
      i Índice Priorizar i sobre index, ya que es más corto.
      serveHTTP serveHttp Los acrónimos se deben escribir con mayúsculas.

      Lo más importante respecto del estilo es preservar la uniformidad y que el equipo del que forma parte esté de acuerdo acerca de este.

      Volver a asignar variables

      Como la plantea la palabra “variable”, podemos cambiar variables de Go. Esto significa que podemos conectar un valor diferente y una variable previamente asignada realizando nuevamente una asignación. Es útil renovar una asignación porque durante el curso de un programa, es posible que debamos aceptar valores generados por los usuarios en variables ya inicializadas. Es posible que también deba cambiar la asignación por algo previamente definido.

      Saber que es posible podemos volver a asignar una variable puede ser útil al trabajar en un programa de gran magnitud que alguien más escribió y en el cual no están claras las variables ya definidas.

      Asignaremos el valor de 76 a una variable llamada i del tipo int y luego le asignaremos un nuevo valor de 42:

      package main
      
      import "fmt"
      
      func main() {
          i := 76
          fmt.Println(i)
      
          i = 42
          fmt.Println(i)
      }
      

      Output

      76 42

      En este ejemplo se muestra que podemos primero asignar a la variable i el valor de un número entero y luego podemos volver a asignar a esta variable i un valor; esta vez, el 42.

      Nota: Cuando declare *e *inicialice una variable, puede usar :=. Sin embargo, cuando quiera simplemente cambiar el valor de una variable ya declarada, solo necesita usar el operador “igual” (=).

      Debido a que Go es un lenguaje typed, no podemos asignar un tipo a otro. Por ejemplo, no podemos asignar el valor “Sammy” a una variable de tipo int:

      i := 72
      i = "Sammy"
      

      Tratar de asignar diferentes tipos entre sí provocará un error en el tiempo de compilación:

      Output

      cannot use "Sammy" (type string) as type int in assignment

      Go no nos permitirá usar un nombre de variable más de una vez:

      var s string
      var s string
      

      Output

      s redeclared in this block

      Si intentamos usar una instrucción variable corta más de una vez para el mismo nombre de variable, también observaremos un error de compilación. Esto puede ocurrir por equivocación, por lo cual entender el mensaje de error es útil:

      i := 5
      i := 10
      

      Output

      no new variables on left side of :=

      Casi como en el caso de una declaración de variable, tener en cuenta el nombre de sus variables mejorará la legibilidad de su programa para usted y otros, cuando la vuelva a revisarla en el futuro.

      Asignación múltiple

      Go también nos permite asignar varios valores a diferentes variables dentro de la misma línea. Cada uno de estos valores puede ser de un tipo de datos diferente:

      j, k, l := "shark", 2.05, 15
      fmt.Println(j)
      fmt.Println(k)
      fmt.Println(l)
      

      Output

      shark 2.05 15

      En este ejemplo, la variable j se asignó a la cadena “shark”, la variable k se asignó al flotante 2.05 y la variable l se asignó al número entero 15.

      Este enfoque para asignar varias variables a diferentes valores en una línea puede hacer que la cantidad de líneas de su código se mantenga en un valor bajo. Sin embargo, es importante no comprometer la legibilidad por menos líneas de código.

      Variables globales y locales

      Al usar variables dentro de un programa, es importante tener en cuenta el ámbito de variable. El ámbito de una variable se refiere a espacios concretos desde los cuales es posible acceder a ella dentro del código de un programa determinado. Esto es decir que no es posible el acceso a todas las variables desde todas las partes de un programa determinado; algunas variables serán globales y algunas locales.

      Las variables globales existen fuera de las funciones. Las locales existen dentro de las funciones.

      Veamos las variables globales y locales en acción:

      package main
      
      import "fmt"
      
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
      }
      
      func main() {
          printLocal()
          fmt.Println(g)
      }
      

      Output

      local global

      Aquí usamos var g = "global"para crear una variable global fuera de la función. Luego definimos la función ​​​1​​​printLocal(). Dentro de la función, se asigna una variable local llamada l que luego se imprime. El programa se cierra llamando a printLocal() e imprimiendo la variable global g.

      Debido a que g es una variable global, podemos hacer referencia a ella en printLocal(). Modificaremos el programa anterior para hacerlo:

      package main
      
      import "fmt"
      
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
          fmt.Println(g)
      }
      
      func main() {
          printLocal()
          fmt.Println(g)
      }
      

      Output

      local global global

      Comenzamos declarando una variable global g, var g = "global". En la función main, llamaremos a la función printLocal, que declara una variable local l e imprime fmt.Println(l). Luego, printLocal imprime la variable global g, fmt.Println(g). Aunque g no se definió en printLocal, podría acceder a ella debido a que se declaró en un alcance global. Por último, la función main imprime g también.

      Ahora, intentaremos invocar la variable local fuera de la función:

      package main
      
      import "fmt"
      
      var g = "global"
      
      func printLocal() {
          l := "local"
          fmt.Println(l)
      }
      
      func main() {
          fmt.Println(l)
      }
      
      

      Output

      undefined: l

      No podemos usar una variable local fuera de la función en la que se asigne. Si intenta hacerlo, verá un error undefined cuando realice la compilación.

      Veamos otro ejemplo en el que usamos el mismo nombre de variable para una variable global y una local:

      package main
      
      import "fmt"
      
      var num1 = 5
      
      func printNumbers() {
          num1 := 10
          num2 := 7  
      
          fmt.Println(num1)
          fmt.Println(num2)
      }
      
      func main() {
          printNumbers()
          fmt.Println(num1)
      }
      

      Output

      10 7 5

      En este programa, declaramos la variable num1 dos veces. Primero, declaramos num1 en el ámbito global, var num1 = 5, y otra vez dentro del alcance local de la función printNumbers, num1 := 10. Cuando imprimimos num1 desde el programa main, vemos el valor 5 impreso. Esto se debe a que main solo detecta la declaración de variable global. Sin embargo, cuando imprimimos num1 de la función printNumbers, esta detecta la instrucción local e imprime el valor 10. Aunque printNumbers crea una nueva variable llamada num1 y le asigna un valor de 10, esto no afecta a la instancia global de num1 con el valor 5.

      Al trabajar con variables, también deberá tener en cuenta las partes de su programa que necesitarán acceso a cada variable y adoptar una variable global o local correspondiente. En diferentes programas de Go, verá que las variables locales son normalmente más comunes.

      Constantes

      Las constantes son como variables, con la excepción de que no pueden modificarse una vez declaradas. Las constantes son útiles para definir un valor que se usará más de una vez en su programa, pero que no debería poder cambiar.

      Por ejemplo, si queremos declarar la tasa impositiva para un sistema de carritos de compras, podríamos usar una constante y luego calcular los impuestos en diferentes áreas de nuestro programa. En algún momento del futuro, si el impuesto se modifica solo deberemos cambiar ese valor en un punto de nuestro programa. Si usamos una variable, es posible que cambiemos el valor accidentalmente en algún lugar de nuestro programa, lo que provocaría un cálculo inadecuado.

      Para declarar una constante, podemos usar la siguiente sintaxis:

      const shark = "Sammy"
      fmt.Println(shark)
      

      Output

      Sammy

      Si intentamos modificar una constante después de que se declare, veremos un error en tiempo de compilación:

      Output

      cannot assign to shark

      Es posibe que las constantes no tengan el valor untyped. Esto puede ser útil al trabajar con números como los datos de tipo entero. Si la constante tiene el valor untyped, se convierte de forma explícita. esto no es posible en el caso de las constantes con el valor typed. Veamos la forma de usar constantes:

      package main
      
      import "fmt"
      
      const (
          year     = 365
          leapYear = int32(366)
      )
      
      func main() {
          hours := 24
          minutes := int32(60)
          fmt.Println(hours * year)    
          fmt.Println(minutes * year)   
          fmt.Println(minutes * leapYear)
      }
      

      Output

      8760 21900 21960

      Si declara una constante con un tipo, se tratará de ese tipo exacto. Aquí, cuando declaramos la constante leapYear la definimos como elemento del tipo de datos int32. Por lo tanto, es una constante typed. Esto significa que solo puede funcionar con tipos de datos int32. Declaramos la constante year sin tipo, por lo que se considera untyped. Debido a esto, puede utilizarla con cualquier tipo de datos de números enteros.

      Cuando se definió hours, infirió que era de tipo int porque no le asignamos de forma explícita un tipo, hours := 24. Cuando declaramos minutes, la declaramos de forma explícita como int32, minutes := int32(60).

      Ahora, revisaremos cada cálculo y la razón por la que funciona:

      hours * year
      

      En este caso, hours es int y years es untyped. Cuando el programa realiza la compilación, de forma explícita convierte years en int, lo cual permite que la operación de multiplicación tenga éxito.

      minutes * year
      

      En este caso, minutes es int32 y year es untyped. Cuando el programa realiza la compilación, de forma explícita convierte years en int32, lo cual permite que la operación de multiplicación tenga éxito.

      minutes * leapYear
      

      En este caso, minutes es int32 y leapYear es una constante typed de int32. En este caso, el compilador no deberá intervenir debido a que ambas variables ya son del mismo tipo.

      Si intentamos multiplicar dos tipos typed que no son compatibles, el programa no realizará la compilación:

      fmt.Println(hours * leapYear)
      

      Output

      invalid operation: hours * leapYear (mismatched types int and int32)

      En este caso, hours se infirió como int y leapYear se declaró explícitamente como int Debido a que Go es un lenguaje “typed”, int y un int32 no son compatibles para operaciones matemáticas. Para multiplicarlos, necesitaría convertir uno a int32 o int.

      Conclusión

      A lo largo de este tutorial, revisamos algunos de los casos de uso común de variables dentro de Go. Las variables son un componente importante de la programación y sirven como símbolos que reemplazan valores de tipos de datos que usamos en un programa.



      Source link