Concatenação de String de forma eficiente em Golang (Go)

Existem algumas maneiras de concatenar strings em Golang, porém a mais prática e rapida é com  a utilização do tipo Buffer que fica dentro da classe bytes.
O Buffer pode ser visto em go com uma espécie de StringBuffer em Java.

Exemplo:

package main

import ("fmt"
         "bytes")

func main(){

  var buf bytes.Buffer
 
  buf.WriteString("Menu nome é ")
 
  buf.WriteString("John")
 
  result := buf.String()


  fmt.Println(result)

}


Onde:

• var buf bytes.Buffer - Declaração da várivel tipo Buffer.
• buf.WriteString("Menu nome é ") 
• result := buf.String() - Obtenção da String já concatenada.

Como deixar todas letras maiscula (upper case) ou minusculas (lowercase) em Go (golang)

Para deixar todas letras de uma string maisculas (CAIXA ALTA) utilizamos o método strings.ToUpper(string) e para deixarmos todas letras minusculas utilizamos o strings.ToLower(string). Veja os exemplo abaixo:

package main

import ( "fmt"
         "strings"
        )
      
func main(){
 nome:="MagusCode"

 fmt.Println("\nOrignial: ")
 fmt.Println(nome)

 fmt.Println("\nTodas maiusculas: ")
 fmt.Println(strings.ToUpper(nome))

 fmt.Println("\nTodas minusculas: ")
 fmt.Println(strings.ToLower(nome))

 }

Saída:

Veja também:

Curso de Go Basico

Programando em Go (Golang) - Interface

Em golang uma interface é uma coleção de assinaturas de métodos. Em golango para se utilizar um intreface basta apenas implementar os métodos contidas na mesma.

Sintaxe:

type nome_interface interface{
  assinatura_metodo_1
  assinatura_metodo_2
  ...
  assinatura_metodo_n
}

Onde:

nome_interface - Nome da interface
assinatura_metodo_1 - Assinatura de um método.
assinatura_metodo_2 - Assinatura de um método.

assinatura_metodo_N - Assinatura de um método.

Exemplo:

package main

import ( "fmt"
         "strings")


type impressao interface{
    maiusculo() string
    minusculo() string
}

type usuario struct{
 nome, sobrenome string
}

type cidade struct{
 nome, estado string
}


func (c cidade) maiusculo() string{
  retorno:=strings.ToUpper(c.nome)+" - "+strings.ToUpper(c.estado)
  return retorno
}


func (c cidade) minusculo() string{
  retorno:=strings.ToLower(c.nome)+" - "+strings.ToLower(c.estado)
  return retorno
}


func (u usuario) maiusculo() string{
  retorno:=strings.ToUpper(u.nome)+" "+strings.ToUpper(u.sobrenome)
  return retorno
}


func (u usuario) minusculo() string{
  retorno:=strings.ToLower(u.nome)+" "+strings.ToLower(u.sobrenome)
  return retorno
}

func main(){
 cidade:= cidade{nome:"Lorena", estado:"São Paulo"}
 usuario:= usuario{nome:"Robson", sobrenome:"Gomes"}

 fmt.Println("\nDados da Usuario:\n")

 fmt.Println(" ",usuario.maiusculo())
 fmt.Println(" ",usuario.minusculo())

  fmt.Println("\nDados da Cidade:\n")


 fmt.Println(" ",cidade.maiusculo())
 fmt.Println(" ",cidade.minusculo())
 
}

Como foi possível ver acima foi criado um programa que conta com a interface  impressao:

type impressao interface{
    maiusculo() string
    minusculo() string
}

Nela é definida duas assinaturas de métodos simples, sendo que ambas retornam uma string. Logo os dois métodos são implementados pela estrutura usuario e cidade.

func (c cidade) maiusculo() string{
  retorno:=strings.ToUpper(c.nome)+" - "+strings.ToUpper(c.estado)
  return retorno
}


func (c cidade) minusculo() string{
  retorno:=strings.ToLower(c.nome)+" - "+strings.ToLower(c.estado)
  return retorno
}


func (u usuario) maiusculo() string{
  retorno:=strings.ToUpper(u.nome)+" "+strings.ToUpper(u.sobrenome)
  return retorno
}


func (u usuario) minusculo() string{
  retorno:=strings.ToLower(u.nome)+" "+strings.ToLower(u.sobrenome)
  return retorno
}


E a chamada as mesma é as mesmas são utilizadas no método main.

func main(){
 cidade:= cidade{nome:"Lorena", estado:"São Paulo"}
 usuario:= usuario{nome:"Robson", sobrenome:"Gomes"}

 fmt.Println("\nDados da Usuario:\n")

 fmt.Println(" ",usuario.maiusculo())
 fmt.Println(" ",usuario.minusculo())

  fmt.Println("\nDados da Cidade:\n")


 fmt.Println(" ",cidade.maiusculo())
 fmt.Println(" ",cidade.minusculo())
 
}


Abaixo é possível ver o resultado do método do programa acima:

Menu Principal

Gerar número aletório em Go (golang)

 

Uma maneira bem simples de gerar um número inteiro aleatório em Go é a utilização da classe math/rand.
Para isso utilizamos o rand.Intn(max).

Sintaxe:

variavel =  rand.Intn(MAX_VALUE)


Onde:

• variavel - Variavel na qual será guardado o valor gerado.

• MAX_VALUE - Valor máximo a ser gerado. (sendo que o mesmo não é incluso na geração. Ex: 25 gera de 0 a 24)

Exemplo:

package main

import (
"fmt"
"math/rand"
)

func main(){

  for i:=0;i<10;i++{<10 font="" i="">
    randonInt := rand.Intn(25)
    fmt.Println(randonInt)
  }

}

Veja também:

Curso de Go Basico

Pausar a execução em go golang

Caso seja necessário dar uma pausa em uma execução de um programa em golang go por algum motivo, podemos utilizar o método Sleep da classe Time.

Sintaxe:

 time.Sleep(tempo)

Exemplo:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Printf("%v\n", time.Now())

    time.Sleep(4 * time.Second)

    fmt.Printf("%v\n", time.Now())
}

Programando em Go (Golang) - Map

table, th, td { border: 1px solid black; } O mapa em golang assim como em outras linguagem é uma estrutura de dados onde é guardado um chave e um valor referente a mesma chave.

Exemplo:

O valor zero do mapa é considerado nulo (nil) e sendo assim não é possível adicionar novas chaves e valores no mesmo.

Criação de um mapa

Para criarmos um mapa utilizamos a sintaxe abaixo:

nome_mapa = make (map[tipo_chave]tipo_valor)

Onde:

nome_mapa - Nome do mapa a ser criado.
tipo_chave - Tipo de chave do mapa a ser criado
tipo_valor - Tipo do valor que será referenciado pela chave.

Adição de valores 

Para adicionar um valor a um mapa basta utilizar a sintaxe:

nome_mapa[nome_chave]=valor

Onde:

nome_mapa - Nome do mapa a ser criado.
nome_chave - Nome da chave referência do mapa
valor - Valor a ser referenciado pela chave.

Acesso a um valor 

Para acessarmos o conteúdo de uma chave do mapa basta utilizar a sintaxe abaido:

nome_mapa[nome_chave]

Onde:

nome_mapa - Nome do mapa a ser criado.
nome_chave - Nome da chave referência do mapa

Exemplo:

package main
import "fmt"

func main(){

  //Criação do mapa
  m:=make(map[string]string)

  //Adição de valores
  m["nome"]="Mario"
  m["cpf"]="333.213.333-35"
  
  //Acesso a um valor
  fmt.Println(m["cpf"])

}


Saída do programa acima:

Criação rapida (literal)

Para criarmos um mapa utilizamos a sintaxe abaixo:

nome_mapa = map[tipo_chave]tipo_valor{
chave_1:valor_1, chave_2:valor_2
}

Onde:

nome_mapa - Nome do mapa a ser criado.
tipo_chave - Tipo de chave do mapa a ser criado
tipo_valor - Tipo do valor que será referenciado pela chave.
chave_1 - Nome da  chave_1
valor_1 - Valor da chave_1

Exemplo:

package main

import "fmt"

func main(){

  //Criação do mapa
  m:=map[string]string{"nome":"Mario", "cpf":"333.213.333-35"}

  //Acesso a um valor
  fmt.Println(m["cpf"])

}


Deletando um valor do mapa

Para deletar um valor do mapa utilizamos a função delete

Sintaxe:

delete(nome_mapa,chave)

Onde:

nome_mapa - Nome do mapa a ter um item deletado
chave - Nome da chave a ser deletada.

Verificação de existência chave

Há caso que é necessário verificar se um elemento existe em um determinado mapa para isso usa sintaxe abaixo:

valor,verificador=nome_mapa[chave]

Onde:

valor - Valor da chave referenciado pela chave

verificador - Nome da variável que receberá o valor true (existe elemento) ou false (não existe o elemento)

Exemplo:

package main

import "fmt"

func main(){

  //Criação do mapa

  m:=map[string]string{"nome":"Mario", "cpf":"333.213.333-35"}

  //Acesso a um valor

  fmt.Println(m["cpf"])

  //Verificação da existencia do elemento

  valor,ok := m["cpf"]

  fmt.Println("O elemento[cpf] valor= ",valor," existe ? ",ok)

  //Remoção da chave cpf

  delete(m,"cpf")

  

  //Verificação da existencia do elemento

  valor,ok = m["cpf"]

  fmt.Println("O elemento[cpf] valor= ",valor," existe ? ",ok)

}

Abaixo é possível ver o resultado da execução do programa acima:

Voltar para menu

Finalizando um aplicação go

    os.Exit(3)

Há momentos que é necessário finalizar uma aplicação por algum motivo qualquer. Em golang utilizamos o método Exit da classe os.

Sintaxe:

os.Exit(codigo)

Onde:

codigo - Código para termino (exemplo:3)

Exemplo:

O programa abaixo finaliza o programa antes de executar o comando defer.

package main

import (
"os"

"fmt"
)

func main (){

 fmt.Println("Inicio\n")
 defer fmt.Println("\nFim\n")
 os.Exit(3)

}

Programando em Go (Golang) - Slice part 2

Adicionando itens a um slice

Para adicionar um novo item a um slice utilizamos a função append. A função append recebe com parâmetro slice, e o valor que será adicionado ao mesmo, sendo que é possível passar mais que um parâmetro de valor para o slice.

Sintaxe:

 append (slice,valor,...,valor_n)

Onde

slice  - Nome do slide a ser atribuído.
valor,...,valor_n - Valores a serem adicionado ao slice

Exemplo: 

No exemplo abaixo vemos dois exemplos onde é possível ver adição de itens a um determinado slice.

package main

import ( "fmt")

func main (){
 var sliceNomes []string


 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))

 //No exemplo abaixo é adicionado um item ao slice sliceNomes

 sliceNomes=append(sliceNomes,"Maria")

 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))

 //No exemplo abaixo é adicionado três itens ao slice sliceNomes

 sliceNomes= append(sliceNomes,"John", "Dany", "Sansa")


 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))


}

Abaixo é possível ver o resultado da execução do programa acima no powershell (pode escolher o cmd também)..

Range


O range é comando utilizado para acessar de maneira mais simples e rápida os valores de um slice em um laço for.
Quando utilizamos o range é tornado para o programador dois valores: um int e outro do tipo de dado de  seu slice, abaixo é possível ver essa ação na sintaxe e exemplo abaixo.


Sintaxe:

for contador,valor :range slice{
 /...Ações a  serem tomadas
}

Onde:

contador - Variável do contador do laço.
valor - Contido na posição explicitada pelo contador dentro do slice.
slice - Slice a ser percorrido



Exemplo:


package main

import "fmt"

var nomes = []string{"Bruce", "Tony","Pietro", "Vanda", "Logan", "Wade"}

func main() {
for i, v := range nomes{
fmt.Printf("[%d] = %s\n", i, v)
}
}

Voltar para o menu

Programando em Go (Golang) - Slice part 1

O Slice é um array sem tamano fixo. O Slice quando criado é especificado a quantidade de itens que o mesmo tem, não a quantidade maxima que poderá ter como acontece com o array. Abaixo é possível ver a sintaxe básica para criação de um slice.

Sintaxe:

nome[inicio:fim]

Onde:

• nome - Nome do slice
• inicio - Índice Valor inicial do slice
• fim - Índice do valor final do slince

Exemplo:

package main

import (

"fmt"

)

func main (){

numeros := [8]int{1,2,3,4,5,6,7,8}

selecao:=numeros[1:4]

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

}

Neste exemplo é criado um slice que contém os valores 2,3,4 ou seja ele pegou os valores do índice 1 até o índice 4. Abaixo é possível visualizar o resultado da execução do programa acima.

Um slice não guarda nenhum tipo de dado ele apenas guarda uma parte do array, ou seja se o array for modificado o valor do mesmo também será alterado. Vide o exemplo abaixo:

package main

import (
"fmt"
)

func main (){

numeros := [8]int{1,2,3,4,5,6,7,8}
selecao:=numeros[1:4]

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

fmt.Println("Alteração do valor do índice 2 para 44")

numeros[2]=44 //Nesse trecho é alterado o valor da posição 2 de 3                  //para 44

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

}

Abaixo é possível ver a saída do programa acima:

Slice Incompletos

É possível criar slice com a omissão dos inicio e de fim:

Exemplos:

• nome[1:10] - Slice com todos os parâmetros
• nome[:10] - Slice com apenas o parâmetro de fim.
• nome[1:] - Slice com apenas o parâmetro de inicio.
• nome[:] - Slice sem ambos os parâmetros.

Slice literal

Um slice pode literal é como um array sem tamanho

Sintaxe:

nome:=[]tipo{va1,val2,..,valn}

Onde:

• nome - Nome do slice
• tipo - Tipo do slice
• va1,val2,..,valn - Valores

Exemplo:

package main

import (
"fmt"
)

func main (){
 nSliceLiteral := []int{1,2,3,4,5,6,7,8}
 fmt.Println("Numeros ",nSliceLiteral)
}

Slice:  tamanho e capacidade

É possível verificar o tamanho e a capacidade de um slice atraves dos métodos len(s) e cap(s).

Saber o tamanho do slice.

Sintaxe:

len(slice) 

Onde:

• slice - Nome do slice do qual será verificado o tamanho.

Para saber a capacidade de um slice utilizamos o método cap(s)

Sintaxe:

cap(slice) 

Onde:

• slice - Nome do slice do qual será verificado o tamanho.

Exemplo:

package main

import (

"fmt"

)

func main (){

   array := [8]int{1,2,3,4,5,6,7,8}

   sl:=array[0:3]

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Slice com make

É possível criar um slice com metodo make , essa é uma maneira de criar um array dinamico.

Criando slice com tamanho e make

Sintaxe :

 s := make([] tipo, tamanho)

Onde: 

• s - Nome do slice.
• tipo - Tipo do slice.
• tamanho - Tamanho do slice.

Exemplo:

package main

import (

"fmt"

)

func main (){

   sl:= make([]int,2)

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Criando slice com tamanho e capaciade através do make

Sintaxe :

 s := make([] tipo, tamanho,capacidade)

Onde: 

• s - Nome do slice.
• tipo - Tipo do slice.
• tamanho - Tamanho do slice.
• capacidade - Capacidade do slice.

Exemplo:

package main

import (

"fmt"

)

func main (){

   sl:= make([]int,2,5)

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Saída do programa acima:

Voltar para menu

Programando em Go (Golang) - Arrays

Um array (arranjo) é um estrutura de dados onde é armazenado uma quantidade definida de valores e que podem serem acessados através de um índice.

Sintaxe:

var nome[tamanho] tipo

Onde:

• nome - Nome de variável array
• tamanho - Tamanho do array
• tipo - Tipo do array

No exemplo abaixo é criado um array de string com dez posições.

Exemplo 1: 

var nomes[10]string

Iniciando array com valores

É possível inicializar um array já com seus devidos valores

Sintaxe:

 nome := [tamanho]tipo{valor1,valor2,valorn}

Onde:

• nome - Nome do array.
• tamanho - Tamanho do Array
• valor1,valor2,valorn - Valores do array, lembrando que a quantidade de valor é a mesma citada no campo tamanho.

Exemplo:

idades :=[3]int{12,21,30}

Setar valor a uma posição especifica

É possível setar um valor para uma posição especifica de seu array para isso basta utilizar a sintaxe abaixo:

Sintaxe:

array[posicao]=valor

Onde:

array - Nome do array do qual terá um valor alterado.

posição - Posição no qual o valor será modificado.

valor - Valor a ser inserido na posição indicada pelo campo posição

Exemplo:

package main

import "fmt"

func main() {

var nomes [2]string

nomes[0] = "Mario"

nomes[1] = "Joaquim"

fmt.Println(nomes[0], nomes[1])

}

Acessando o valor de uma posição do array

Para pegar o valor de uma determinada posição do array basta usar a sintaxe abaixo:

Sintaxe:

array[posição]

Onde:

• array - nome do array a ter uma posição acessada.
• posição - Posição a ser acessada.

Exemplo:

Abaixo é possível ver um exemplo ver o acesso ao array, nos campos:   nomes[0], nomes[1]                                         

package main

import "fmt"

func main() {

var nomes [2]string

nomes[0] = "Mario"

nomes[1] = "Joaquim"

fmt.Println(nomes[0], nomes[1])

}

 0

Onservaçõe Finais

Programando em Go (Golang) - Estruturas Struct

Uma estrutura é uma coleção de campos.

Sintaxe:

type nome_estrutura struct {
var_1 tipo_1
var_2 tipo_2
...
var_n tipo_n
}

Onde:

• nome_estrutura - Nome da estrutura.
• var_1, var_2,var_n - Nome dos campos(váriveis) contidas na estrutura.
• tipo_1,tipo_2,tipo_n - Tipo da var_1,var_2,var_n

Uma maneira bem simples de iniciar uma estrutura e passar os valores para mesma através da sintaxe abaixo(nesse exemplo assumintos a estrutura acima:

nome_estrutura{valor1,valor2,..valorn}

Onde:

• nome_estrutura- Nome da estrutura.
• valor1 - Valor a ser adionado em var_1.
• valor2 - Valor a ser adionado em var_2.
• valorn - Valor a ser adionado em var_n.

Onde:

Exemplo.


package main

import "fmt"

type Pessoa struct {
nome string
cpf string
        idade int
}

func main() {
fmt.Println(Pessoa{"Nosbor", "392.231.334-40", 21})
}

Voltar para menu

Programando em Go (Golang) - Ponteiros (pointer)

Assim como em linguagens como C, C++ e Pascal, dente outras, Go também suporte para ponteiros.

A principal função de um ponteiro é apontar para um endereço de memoria, que no caso contém o valor de uma determinada variável.

Sintaxe:

nome_ponteiro *tipo_variavel

Onde:

• nome_ponteiro - Nome do ponteiro
• *tipo_variavel - Tipo do ponteiro.

O operador & gerar um ponteiro para seu operando

Sintaxe:

variavel := valor

ponteiro = &variavel

Onde:

• variavel - variavel(nesse caso operando) para qual o ponteiro apontará o local da memoria.
• valor - Valor a ser alocado na memória.
• ponteiro - Nome do ponteiro a ser utilizado
• &variavel - Nesse trecho é feito a referência de memoria da variavel ao ponteiro através do &.

Exemplo 1:

package main

import "fmt"

func main() {

 nome := "Julho"
 ponteiro := &nome

 fmt.Printf("Menu nome é %s",*ponteiro)

 }

Caso você queira desrreferência um ponteiro basta setar o valor no mesmo através da sintaxe abaixo:

Sintaxe:

*ponteiro = valor

Onde:

ponteiro - Nome do ponteiro que será desrreferênciado.

valor - Novo valor do ponteiro.

Exemplo 2:

package main

import "fmt"

func main() {

 nome := "Julho"
 ponteiro := &nome

 fmt.Printf("Menu nome é %s",*ponteiro)

 *ponteiro="Maria"

 fmt.Printf("Menu nome é %s",*ponteiro)


 }

Ai vem a dúvida por que usar um ponteiro ?

A resposta é simples você deseja que usar a referencia de uma valor de uma determinada variavel e não o valor em si.

Voltar para menu

Programando em Go (Golang) - Defer

A palavra chave defer faz com que uma determinada ação deseja executada somente no final da funçao no caso do retorno.

Sintaxe:

defer ação

Onde:

açao - Ação a ser tomada


Exemplo: No exemplo abaixo a exibição do string mundo só será exibida o final da função.


package main

import "fmt"

func main() {
defer fmt.Println("mundo")

fmt.Println("Olá ")
}


Saida do programa acima.

Vale lembra que pode ser usar mais de um defer dentro de uma função onde se segue o logica "o ultimo a ser executado é o primeiro a ser exibido"

Exemplo:


package main

import "fmt"

func main() {

for i:=0;i<10 font="" i="">
defer fmt.Printf("\n %d * %d = %d",i,2,i*2)
}
}


Sáida:

Voltar para o menu

Programando em Go (Golang) - Loop For

Uma estrutura de laço executa uma determinada ação até que um certo requisito deixe de ser verdadeiro e passe a ser false(falso).
Em Go (golang) existe somente a estrutura de laços for.

For completo

O laço completo é aquele no qual tem todos os três parâmetros do mesmo (inicializador, expressão_condicional, pos_execucao).

Sintaxe básica:

for inicializador; expressao_condicional; pos_execucao{
 //corpo do laço
}

Onde:

• inicializador - Ação incial na primeira integração do for
• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• pos_execucao - ação a se executada toda vez que o laço for integrado
• corpo do laço - Ações que serão executadas dentro do laço.

Observações

Vale lembrar que a variável criada no inicializador existe somente dentro do laço for. Ao contrário de outras linguagens é obrigatório a utilização das chaves { } para delimitar o corpo do laço.

Exemplo:

package main

import "fmt"

func main() {
mult := 2
for i := 0; i < 10; i++ {

fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
}
}

Saída da execução do programa:

For sem inicializador

O laço sem inicializador é aquele no qual tem dois dos três parâmetros do mesmo (expressão_condicional, pos_execucao).

Sintaxe básica:

for ; expressao_condicional; pos_execucao{
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• pos_execucao - ação a se executada toda vez que o laço for integrado
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variavel i do inicializador.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for ; i < 10; i++ {


fmt.Printf("\n%d * %d = %d",i,mult,mult*i)

}
}

For continuo

O laço no qual há apenas o parametro de expressao_condicional.

Sintaxe básica:

for ; expressao_condicional; {
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variável i do inicializador e também o do pos_execução.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for ; i < 10;  {



 fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
         i+=1   
}
}

Usando for como while

Assim como for continuo o for como while tem somente o bloco de condicional

Sintaxe básica:

for ; expressao_condicional; {
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variável i do inicializador e também o do pos_execução.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for i < 10  {


 fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
         i+=1   
}
}

For infinito

É aquele for que não nenhum de seus blocos.

Sintaxe básica:

for {
 //corpo do laço
}

Voltar para menu

Programando em Go (Golang) - Constantes (constant)

Uma constante é uma variável na qual o conteúdo da mesma não pode ser modificado.
Em Go é possível declarar constantes utilizando a palavra chave const.
As variáveis do tipo constante não podem ser declaradas com utilização do :=

Sintaxe:

const nome_variavel = valor 

Onde:

• const - palavra chave
• nome_variavel - Nome da constante
• valor - Valor da constante.

Exemplo:

 

package main

import "fmt"

const mult = 2

func mutiplicador(x int) int{

return mult*x;
}

func main() {

    multiplicando:=3
    resultado:=mutiplicador(multiplicando)

    fmt.Printf("Multiplicação %d x %d = %d",mult, multiplicando,resultado)

}

 

Anterior                                       Início                                                       Próximo