One place for hosting & domains

      Variables

      Working with Environment Variables in Vue.js


      While this tutorial has content that we believe is of great benefit to our community, we have not yet tested or
      edited it to ensure you have an error-free learning experience. It’s on our list, and we’re working on it!
      You can help us out by using the “report an issue” button at the bottom of the tutorial.

      In this post, we’ll learn how to work with distinct configurations between development and production mode for Vue.js projects that use the CLI’s webpack template.

      In a web app, we most likely have to access a backend API server through a URL. This URL can be something like http://localhost:8080/api while in development, and https://site.com/api in production when the project is deployed. Environment variables allow us for an easy way to change this URL automatically, according to the current state of the project.

      An easy way to use environment variables with Vue and the webpack template is through files with a .env extension. These files become responsible for storing information that’s specific to the environment (development, testing, production,…)

      The majority of this post applies to apps using v2.x of the Vue CLI, but environment variables are just as easy to manage in the Vue CLI v3.

      Using .env Files in Vue

      The simplest way to use .env files in Vue is to create an application that already supports environment files. Let’s use the vue-cli and the webpack template for that.

      With Node 8 or higher installed, run the following, where my-app is your app name:

      $ npx vue-cli init webpack my-app
      

      This command will create an application with several files ready for use. In this post, we’re focusing only on the environment configuration, which can be accessed in the config directory:

      Project file structure

      There are two files in the config directory: dev.env.js and prod.env.js, and you’ll also have a test.env.js file if you’ve configured tests while initiating the project. These files are used in development and production mode, or in other words, when you are running the application through the npm run dev command, the dev.env.js file is used, and when you compile the project for production with the npm run build command, the prod.env.js file is used instead.

      Let’s change the development file to:

      dev.env.js

      'use strict'
      const merge = require('webpack-merge')
      const prodEnv = require('./prod.env')
      
      module.exports = merge(prodEnv, {
        NODE_ENV: '"development"',
        ROOT_API: '"http://localhost/api"'
      })
      

      Our development environment file has an additional variable called ROOT_API, with the value http://localhost/api.

      Now let’s change the production file to:

      prod.env.js

      'use strict'
      module.exports = {
        NODE_ENV: '"production"',
        ROOT_API: '"http://www.site.com/api"'
      }
      

      Here we have the same ROOT_API variable, but with a different value, which should only be used in production mode. Note how string variables need the double quotes inside the single quotes.

      Using the Environment Files in Your Code

      After creating the ROOT_API variable, we can use it anywhere in Vue through the global process.env object:

      process.env.ROOT_API
      

      For example, open the src/components/HelloWorld.vue file and in the <script> tag add the following:

      mounted() {
        console.log(process.env.ROOT_API)
      }
      

      After running npm run dev, you will see the console.log information in the browser dev tools:

      Running the app

      If you run the npm run build command, the dist directory will be created with the application ready to be deployed to a production environment, and the variable ROOT_API will display the value http://www.site.com./api, as specified in prod.env.js.

      Thus, we can work with different variables for each different environment, using the ready-made configuration that the webpack template provides us. If you use another template, make sure you find an equivalent feature or use a library like dotenv to manage your environment variables.

      What About Vue CLI 3?

      If your app is using the new Vue CLI, you’ll want to instead have files like .env and .env.prod at the root of your project and include variables like this:

      .env

      VUE_APP_ROOT_API=http://localhost/api
      

      .env.prod

      VUE_APP_ROOT_API=http://www.site.com/api
      

      The VUE_APP_ prefix is important here, and variables without that prefix won’t be available in your app.



      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

      How To Use Variables and Constants in Go


      Variables are an important programming concept to master. They are symbols that stand in for a value you’re using in a program.

      This tutorial will cover some variable basics and best practices for using them within the Go programs you create.

      Understanding Variables

      In technical terms, a variable is assigning a storage location to a value that is tied to a symbolic name or identifier. We use the variable name to reference that stored value within a computer program.

      We can think of a variable as a label that has a name on it, which you tie onto a value.

      Variables in Go

      Let’s say we have an integer, 1032049348, and we want to store it in a variable rather than continuously retype the long number over and over again. To achieve this, we can use a name that’s easy to remember, like the variable i. To store a value in a variable, we use the following syntax:

      i := 1032049348
      

      We can think of this variable like a label that is tied to the value.

      Go Variable Example

      The label has the variable name i written on it, and is tied to the integer value 1032049348.

      The phrase i := 1032049348 is a declaration and assignment statement that consists of a few parts:

      • the variable name (i)
      • the short variable declaration assignment (:=)
      • the value that is being tied to the variable name (1032049348)
      • the data type inferred by Go (int)

      We’ll see later how to explicitly set the type in the next section.

      Together, these parts make up the statement that sets the variable i equal to the value of the integer 1032049348.

      As soon as we set a variable equal to a value, we initialize or create that variable. Once we have done that, we are ready to use the variable instead of the value.

      Once we’ve set i equal to the value of 1032049348, we can use i in the place of the integer, so let’s print it out:

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

      Output

      1032049348

      We can also quickly and easily do math by using variables. With i := 1032049348, we can subtract the integer value 813 with the following syntax:

      fmt.Println(i - 813)
      

      Output

      1032048535

      In this example, Go does the math for us, subtracting 813 from the variable i to return the sum 1032048535.

      Speaking of math, variables can be set equal to the result of a math equation. You can also add two numbers together and store the value of the sum into the variable x:

      x := 76 + 145
      

      You may have noticed that this example looks similar to algebra. In the same way that we use letters and other symbols to represent numbers and quantities within formulas and equations, variables are symbolic names that represent the value of a data type. For correct Go syntax, you’ll need to make sure that your variable is on the left side of any equations.

      Let’s go ahead and print x:

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

      Output

      221

      Go returned the value 221 because the variable x was set equal to the sum of 76 and 145.

      Variables can represent any data type, not just integers:

      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": "&"}
      

      If you print any of these variables, Go will return what that variable is equivalent to. Let’s work with the assignment statement for the string slice data type:

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

      Output

      [one two three]

      We assigned the slice value of []string{"one", "two", "three"} to the variable slice, and then used the fmt.Println function to print out that value by calling slice.

      Variables work by carving out a little area of memory within your computer that accepts specified values that are then associated with that space.

      Declaring Variables

      In Go, there are several ways to declare a variable, and in some cases, more than one way to declare the exact same variable and value.

      We can declare a variable called i of data type int without initialization. This means we will declare a space to put a value, but not give it an initial value:

      var i int
      

      This creates a variable declared as i of data type int.

      We can initialize the value by using the equal (=) operator, like in the following example:

      var i int = 1
      

      In Go, both of these forms of declaration are called long variable declarations.

      We can also use short variable declaration:

      i := 1
      

      In this case, we have a variable called i, and a data type of int. When we don’t specify a data type, Go will infer the data type.

      With the three ways to declare variables, the Go community has adopted the following idioms:

      • Only use long form, var i int, when you’re not initializing the variable.

      • Use short form, i := 1, when declaring and initializing.

      • If you did not desire Go to infer your data type, but you still want to use short variable declaration, you can wrap your value in your desired type, with the following syntax:

      i := int64(1)
      

      It’s not considered idiomatic in Go to use the long variable declaration form when we’re initializing the value:

      var i int = 1
      

      It’s good practice to follow how the Go community typically declares variables so that others can seamlessly read your programs.

      Zero Values

      All built-in types have a zero value. Any allocated variable is usable even if it never has a value assigned. We can see the zero values for the following types:

      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

      We used the %T verb in the fmt.Printf statement. This tells the function to print the data type for the variable.

      In Go, because all values have a zero value, we can’t have undefined values like some other languages. For instance, a boolean in some languages could be undefined, true, or false, which allows for three states to the variable. In Go, we can’t have more than two states for a boolean value.

      Naming Variables: Rules and Style

      The naming of variables is quite flexible, but there are some rules to keep in mind:

      • Variable names must only be one word (as in no spaces).
      • Variable names must be made up of only letters, numbers, and underscores (_).
      • Variable names cannot begin with a number.

      Following these rules, let’s look at both valid and invalid variable names:

      Valid Invalid Why Invalid
      userName user-name Hyphens are not permitted
      name4 4name Cannot begin with a number
      user $user Cannot use symbols
      userName user name Cannot be more than one word

      Furthermore, keep in mind when naming variables that they are case sensitive. These names userName, USERNAME, UserName, and uSERnAME are all completely different variables. It’s best practice to avoid using similar variable names within a program to ensure that both you and your collaborators—current and future—can keep your variables straight.

      While variables are case sensitive, the case of the first letter of a variable has special meaning in Go. If a variable starts with an uppercase letter, then that variable is accessible outside the package it was declared in (or exported). If a variable starts with a lowercase letter, then it is only available within the package it is declared in.

      var Email string
      var password string
      

      Email starts with an uppercase letter and can be accessed by other packages. password starts with a lowercase letter, and is only accessible inside the package it is declared in.

      It is common in Go to use very terse (or short) variable names. Given the choice between using userName and user for a variable, it would be idiomatic to choose user.

      Scope also plays a role in the terseness of the variable name. The rule is that the smaller the scope the variable exists in, the smaller the variable name:

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

      We use the variable names in a larger scope, so it would be common to give it a more meaningful name to help remember what it means in the program. However, we use the i and n variables immediately in the next line of code, and then do not use them again.. Because of this, it won’t confuse someone reading the code about where the variables are used, or what they mean.

      Next, let’s cover some notes about variable style. The style is to use MixedCaps or mixedCaps rather than underscores for multi-word names.

      Conventional Style Unconventional Style Why Unconventional
      userName user_name Underscores are not conventional
      i index prefer i over index as it is shorter
      serveHTTP serveHttp acronyms should be capitalized

      The most important thing about style is to be consistent, and that the team you work on agrees to the style.

      Reassigning Variables

      As the word “variable” implies, we can change Go variables readily. This means that we can connect a different value with a previously assigned variable through reassignment. Being able to reassign is useful because throughout the course of a program we may need to accept user-generated values into already initialized variables. We may also need to change the assignment to something previously defined.

      Knowing that we can readily reassign a variable can be useful when working on a large program that someone else wrote, and it isn’t clear what variables are already defined.

      Let’s assign the value of 76 to a variable called i of type int, then assign it a new value of 42:

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

      Output

      76 42

      This example shows that we can first assign the variable i with the value of an integer, and then reassign the variable i assigning it this time with the value of 42.

      Note: When you declare and initialize a variable, you can use :=, however, when you want to simply change the value of an already declared variable, you only need to use the equal operator (=).

      Because Go is a typed language, we can’t assign one type to another. For instance, we can’t assign the value "Sammy" to a variable of type int:

      i := 72
      i = "Sammy"
      

      Trying to assign different types to each other will result in a compile-time error:

      Output

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

      Go will not allow us to use a variable name more than once:

      var s string
      var s string
      

      Output

      s redeclared in this block

      If we try to use short variable declaration more than once for the same variable name we’ll also receive a compilation error. This can happen by mistake, so understanding what the error message means is helpful:

      i := 5
      i := 10
      

      Output

      no new variables on left side of :=

      Similarly to variable declaration, giving consideration to the naming of your variables will improve the readability of your program for you, and others, when you revisit it in the future.

      Multiple Assignment

      Go also allows us to assign several values to several variables within the same line. Each of these values can be of a different data type:

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

      Output

      shark 2.05 15

      In this example, the variable j was assigned to the string "shark", the variable k was assigned to the float 2.05, and the variable l was assigned to the integer 15.

      This approach to assigning multiple variables to multiple values in one line can keep the number of lines in your code down. However, it’s important to not compromise readability for fewer lines of code.

      Global and Local Variables

      When using variables within a program, it is important to keep variable scope in mind. A variable’s scope refers to the particular places it is accessible from within the code of a given program. This is to say that not all variables are accessible from all parts of a given program—some variables will be global and some will be local.

      Global variables exist outside of functions. Local variables exist within functions.

      Let’s take a look at global and local variables in action:

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

      Output

      local global

      Here we use var g = "global" to create a global variable outside of the function. Then we define the function printLocal(). Inside of the function a local variable called l is assigned and then printed out. The program ends by calling printLocal() and then printing the global variable g.

      Because g is a global variable, we can refer to it in printLocal(). Let’s modify the previous program to do that:

      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

      We start by declaring a global variable g, var g = "global". In the main function, we call the function printLocal, which declares a local variable l and prints it out, fmt.Println(l). Then, printLocal prints out the global variable g, fmt.Println(g). Even though g wasn’t defined within printLocal, it could still be accessed because it was declared in a global scope. Finally, the main function prints out g as well.

      Now let’s try to call the local variable outside of the function:

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

      Output

      undefined: l

      We can’t use a local variable outside of the function it is assigned in. If you try to do so, you’ll receive a undefined error when you compile.

      Let’s look at another example where we use the same variable name for a global variable and a local variable:

      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

      In this program, we declared the num1 variable twice. First, we declared num1 at the global scope, var num1 = 5, and again within the local scope of the printNumbers function, num1 := 10. When we print num1 from the main program, we see the value of 5 printed out. This is because main only sees the global variable declaration. However, when we print out num1 from the printNumbers function, it sees the local declaration, and will print out the value of 10. Even though printNumbers creates a new variable called num1 and assigned it a value of 10, it does not affect the global instance of num1 with the value of 5.

      When working with variables, you also need to consider what parts of your program will need access to each variables; adopting a global or local variable accordingly. Across Go programs, you’ll find that local variables are typically more common.

      Constants

      Constants are like variables, except they can’t be modified once they have been declared. Constants are useful for defining a value that will be used more than once in your program, but shouldn’t be able to change.

      For instance, if we wanted to declare the tax rate for a shopping cart system, we could use a constant and then calculate tax in different areas of our program. At some point in the future, if the tax rate changes, we only have to change that value in one spot in our program. If we used a variable, it is possible that we might accidentally change the value somewhere in our program, which would result in an improper calculation.

      To declare a constant, we can use the following syntax:

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

      Output

      Sammy

      If we try to modify a constant after it was declared, we’ll get a compile-time error:

      Output

      cannot assign to shark

      Constants can be untyped. This can be useful when working with numbers such as integer-type data. If the constant is untyped, it is explicitly converted, where typed constants are not. Let’s see how we can use constants:

      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

      If you declare a constant with a type, it will be that exact type. Here when we declare the constant leapYear, we define it as data type int32. Therefore it is a typed constant, which means it can only operate with int32 data types. The year constant we declare with no type, so it is considered untyped. Because of this, you can use it with any integer data type.

      When hours was defined, it inferred that it was of type int because we did not explicitly give it a type, hours := 24. When we declared minutes, we explicitly declared it as an int32, minutes := int32(60).

      Now let’s walk through each calculation and why it works:

      hours * year
      

      In this case, hours is an int, and years is untyped. When the program compiles, it explicitly converts years to an int, which allows the multiplication operation to succeed.

      minutes * year
      

      In this case, minutes is an int32, and year is untyped. When the program compiles, it explicitly converts years to an int32, which allows the multiplication operation to succeed.

      minutes * leapYear
      

      In this case, minutes is an int32, and leapYear is a typed constant of int32. There is nothing for the compiler to do this time as both variables are already of the same type.

      If we try to multiply two types that are typed and not compatible, the program will not compile:

      fmt.Println(hours * leapYear)
      

      Output

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

      In this case, hours was inferred as an int, and leapYear was explicitly declared as an int32. Because Go is a typed language, an int and an int32 are not compatible for mathematical operations. To multiply them, you would need to convert one to a int32 or an int.

      Conclusion

      In this tutorial we reviewed some of the common use cases of variables within Go. Variables are an important building block of programming, serving as symbols that stand in for the value of a data type we use in a program.



      Source link