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

Programando em Go (Golang) - Condicionais switch

Além do if/else em Go temos outro condicional que está presente em outras linguagens, no caso estou falando do switch. Com o switch é possível fazer uma especie de concatenação de if/else if e else.

Sintaxe:

switch varivel_comparacao:
{
case valor_1:
{
  acao_01
  break
}
case valor_2:
{
  acao_02
  break
}
case valor_3:
{
  acao_03
  break
}
case valor_n:
{
  acao_n 
  break
}
default:
acao_default
}

Onde:

• variavel_comparacao - Variável para comparação e execução dos blocos.
• valor_1,valor_2_valor_3,valor_n - São os possíveis valores de condição.
• acao_1, acao_2, acao_3, acao_n,acao_default - São os possíveis ações de acordo com a validação da variavel_comparacao.
• default - Caso nenhum valor seja aceito nos cases o mesmo o valor default é aceito.

Exemplo 1:

package main

import "fmt"

func main() {

 var resp string

 escolha := 32

switch escolha

{

case 32:

resp="Voce escolhe 32"

break;

case 45:

resp="Voce escolhe 45"

break;

case 65:

resp="Voce escolhe 65"

break;

case 25:

resp="Voce escolhe 25"

break;

default:

resp="Não é os valores acima"

}

fmt.Printf(resp)

}

Switch com case com mais de uma possíbilidade

Outra opção possível para facilitar a quantidade de case é colocar mais de uma condição ao mesmo.

Sintaxe:

switch varivel_comparacao:
{
case valor_1,valor_2:
{
  acao_01
  break
}
case valor_3:
{
  acao_03
  break
}
case valor_n:
{
  acao_n 
  break
}
default:
 acao_default
}

Onde:

• variavel_comparacao - Variável para comparação e execução dos blocos.
• valor_1,valor_2_valor_3,valor_n - São os possíveis valores de condição.
• acao_1, acao_2, acao_3, acao_n,acao_default - São os possíveis ações de acordo com a validação da variavel_comparacao.
• default - Caso nenhum valor seja aceito nos cases o mesmo o valor default é aceito.

Exemplo 2:

package main

import "fmt"

func main() {

 var resp string

 escolha := 32

switch escolha{

case 32,45:

resp="Voce escolhe 32 ou 45"

break;

case 65:

resp="Voce escolhe 65"

break;

case 25:

resp="Voce escolhe 25"

break;

default:

resp="Não é os valores acima";

}

fmt.Printf(resp)

}

Voltar para menu

Programando em Go (Golang) - Condicionais IF , ELSE e IF/ELSE IF/ElSE

Uma estrutura condicional é utilizada para verificar se uma condição é verdadeira, caso essa seja será executada uma determinada ação.

Em Go a estrutura de condicionais if, if/else e if/else if sãoess bem simples. Vale lembra que em Go as chaves "{" são obrigatórias.

Operadores Relacionais

Os operadores relacionais são utilizados para dois ou mais valores para verificar se o mesmo é verdadeiro.

Os operadores relacionais em Go são:

• == Igual a 
• != - Diferente de
• > - Maior que
• < - Menor que
• >= - Maior ou igual a
• <= - Menor ou igual a

if

No caso do if , o método do mesmo só será acessado se a condição verificada no mesmo for verdadeira.

Sintaxe:

if condição {

ação_ser_tomada

}

Onde:

• condição - Condição para entrar no bloco if.
• ação_ser_tomada - Grupo de ações a serem tomadas quando o usuário entrar nesse bloco.

Exemplo 1:

package main

import "fmt"

func main() {

idade:=33

if idade > 32{

  fmt.Println("A idade é maior que 32")

}

}

Nesse exemplo foi é possível verificar o trecho condicional com if na linha if idade => 32. Nesse exemplo o programa só entrará no bloco do condicional se a condição for verdadeira no caso o conteúdo da variável idade ser maior que 32.

if /else

No caso do if /else , o bloco de condição if será acessada se a condição contida na mesma for verdadeira, caso contrario será acessada o bloco da condição else.

Sintaxe:

if condição {

ação_ser_tomada

}

else{

 ação_ser_tomada

}

Onde:

• condição - Condição para entrar no bloco if.
• ação_ser_tomada - Grupo de ações a serem tomadas quando o usuário entrar nesse bloco.

Exemplo 2:

package main

import "fmt"

func main() {

idade:=33

if idade => 32{

  fmt.Println("A idade é maior que ou igual a 32")

}else{

  fmt.Println("Sua idade é diferente de 32")

}

}

Nesse exemplo foi é possível verificar o trecho condicional com if na linha if idade => 32. Nesse exemplo o programa só entrará no bloco if do condicional se a condição for verdadeira no caso o conteúdo da variável idade ser maior ou igual a 32, caso contrário será acessado o conteúdo do bloco else.

.

if /else if/else

No caso do if /else if/else , o bloco de condição if será acessada se a condição contida na mesma for verdadeira, caso a condição do if não seja verdadeira é testada os blocos else if,  caso nenhum deles sejão verdadeiros é acessaod o bloco else.

Sintaxe:

if condição {

ação_ser_tomada

}

else if condição_2{

 ação_ser_tomada

}

//É possível que exita mais que 1 bloco else if

else if condição_N{

 ação_ser_tomada

}

else{

 ação_ser_tomada

}

Onde:

• condição - Condição para entrar no bloco if.
• condição_1 - condição_N - Condições a serem tomadas para entrar em cada bloco de código.
• ação_ser_tomada - Grupo de ações a serem tomadas quando o usuário entrar nesse bloco.

Exemplo 2:

package main

import "fmt"

func main() {

idade:=33

if idade > 32{

  fmt.Println("A idade é maior que 32")

}else if idade < 32{

  fmt.Println("A idade é menor que 32")

}else{

  fmt.Println("Sua idade é 32")

}

}

Nesse exemplo foi é possível verificar o trecho condicional com if na linha if idade => 32 e else. Nesse exemplo o programa só entrará no bloco if do condicional se a condição for verdadeira no caso o conteúdo da variável idade ser maior que 32, caso seja menor que 32 entra no bloco else if, casocontrário será acessado o conteúdo do bloco else.

Voltar para menu

Programando em Go (Golang) - Variáveis

Assim como em outras linguagens de programação uma variável é de suma importância em Go, para iniciar uma variável em Go utiliza a palavra chave var.

Sintaxe:

var nome_variavel tipo_variavel

Onde:

• nome_variavel - O nome propriamente dito da variável.
• tipo_variavel - Tipo da variável (int, string, etc)

Exemplos 1:

var idade int
var nome string
var nome,cpf string

Nível de acesso a variáveis

As variáveis em Go pode estar ao nível de pacote(package) ou local a uma função(func).

Sintaxe:

package pacoteX

var nome string //Variável ao nivel do pacote

func main()
{
var cpf string //Variável ao nivel da função main
...
}

func calculoX()
{
var numero1,numero2 int //Variável ao nivel da função calculoX
...
}

Exemplo 2: 

package main

import "fmt"

var nome, rg, cpf string

func main() {
var idade int
fmt.Println(nome, rg, cpf, idade)
}


Nesse exemplo as váriaveis nome, rg e cpf estão no nivel do pacote, já a idade está no nivel da função.

Variveis com inicialização

Em Go podemos inicializar multiplas váriveis em uma unica linha, uma por vez.

Sintaxe:

var var1,var2,var3 tipo_variavel = valor1,valor2,valor3

Onde:

• var1,var2,var3 - São as váriaveis a serem inicializadas.
• valor1,valor2,valor3 - Os valores que serão atribuidos as variáveis var1,var2,var3

Exemplo 3: 

No exemplo abaixo é possível ver multiplas váriaveis sendo inicializadas ao mesmo tempo.

package main

import "fmt"

var dia,mes,ano int = 1, 2, 2012

func main() {
var nome,sobreNome,habilitado = "Mario", true, "Kent"
fmt.Println(nome,habilitado,dia, mes, ano,  sobreNome)
}

Inicialização rápida de váriaveis

Em Go (golang) é possível inicializar variáveis de maneira rápida através da assinatura := . Utilizando a mesma ao invés da palavra chave var a variável é inicializada com um tipo implícito.

Sintaxe:

nome_variavel := valor

Onde:

• nome_variavel - Nome da váriavel propriamente dita.
• valor - Valor a ser atribuido intricicamente a váriavel nome_variavel.

Exemplo 4:

package main

import "fmt"

var dia int = 8

func main() {
ano:=1988
nome:="Mario"

fmt.Println(nome,dia, ano)
}


Não é possível inicializar uma váriavel de maneira "rápida" fora do corpo de uma função o exemplo abaixo não está correto.

Exemplo 5: 

Um exemplo com erro.

package main

import "fmt"

var dia int = 8
nome:="Mario" // trecho com erro

func main() {
ano:=1988

fmt.Println(nome,dia, ano)
}

Tipos de variáveis em Go 

Os tipos básicos de variáveis em Go são:

• bool
• byte 
• complex64 complex128
• float32 float64
• int  int8  int16  int32  int64
• rune 
• string
• uint uint8 uint16 uint32 uint64 uintptr

Variável inicializada sem valor

Em Go váriveis inicializadas sem um valor inicial explicito é dado o valor default para o mesma.

• Para tipos números é atribuido o valor 0
• Para tipo booleano é atribuido o valor false
• Para tipo string é atribuído o valor "" (string vazia)

Exemplo 6:

package main

import "fmt"

func main() {
var idade int
var altura float64
var habilitado bool
var nome string
fmt.Printf("%v, %v, %v , %v, %v", nome,idade, altura, habilitado, nome)
}

Conversão de tipo

Em Go é possível converter o tipo de várivel utilizando a seguinte sintaxe:


tipo(valor)

Onde:

• tipo - Tipo para o qual o "valor" será convertido.
• valor - Valor a ser convertido.

Exemplo:

var idade int = 30
var fidade float64 = float64(idade)
var uIdade uint = uint(fidade)




Anterior                                       Início                                                       Próximo

Programando em Go (Golang) - Funções

A função nada mais é que um conjunto de ações que um determinado programa deve executar. Em Go podemos ter funções com zero ou mais argumentos.

Sintaxe:

func nome_funcao(variavel_entrada_1,variavel_entrada_n) retorno{

corpo_da_função

}

Onde:

• func - Palavra chave para identificar uma função. 

• nome_funcao - Nome da função.

• variavel_entrada_1,variavel_entrada_n - Argumentos da função, pode ter um ou mais.

• retorno - Retorno da função, pode ter um ou mais ao mesmo tempo.

• corpo_da_função - Informações e medidas que serão tomadas na função.

Exemplo 1 - Nesse exemplo é possível ver uma função sum(x int, y int) que recebe dois valores int e devolve um int como retorno.

package main

import "fmt"

//Função que soma x e y 

func sum(x int, y int) int{

return x+y;

}

func main() {

    fmt.Println("Soma 2+3=",sum(2,3))

}

Abaixo é possível ver a execução do programa acima.

Exemplo 2 - É possível passar dois argumentos consecutivos, desde que os dois sejam do mesmo tipo abaixo é possível ver esse caso na função sum(x, y int) que recebe dois valores int e devolve um int como retorno.

package main

import "fmt"

//Função que soma x e y 

func sum(x, y int) int{

return x+y;

}

func main() {

    fmt.Println("Soma 2+3=",sum(2,3))

}

Funções com multiplos resultados

Em Go é possível que uma função retorne vários resutados ao mesmo tempo, para isso basta utilizar a sintaxe abaixo:

Sintaxe:

func nome_funcao(variavel_entrada_1,variavel_entrada_n) (retorno1,retorno2,retornon){

corpo_da_função

}

Onde:

• func - Palavra chave para identificar uma função. 

• nome_funcao - Nome da função.

• variavel_entrada_1,variavel_entrada_n - Argumentos da função, pode ter um ou mais.

• retorno1,retorno2,retornon- Retornos da função, vale lembrar que pode ser mais que três retornos.

• corpo_da_função - Informações e medidas que serão tomadas na função.

Exemplo 3 - Nesse exemplo é possível ver uma função sum(x int, y int) que recebe dois valores int e devolve dois int como retorno.

package main

import "fmt"

//Função que retorna multiplos valores 

func sumEsubtracao(x int, y int) (int,int){

return x+y, x-y;

}

func main() {

    soma,sub:=sumEsubtracao(2,3)

    fmt.Println("Soma 2+3=",soma," e a subtração é 2-3=",sub)

}

As funções com múltiplos retornos também podem especificar quais variáveis retornar.

Exemplo 4 - Nesse exemplo é possível ver uma função sum(x int, y int) que recebe dois valores int e devolve dois int como retorno através de um retorno naked (retorno onde não te uma variável de retorno após a palavra chave return)

package main

import "fmt"

//Função que retorna multiplos valores 

func sumEsubtracao(x int, y int) (soma,sub int){

soma=x+y

        sub=x-y

        return

}

func main() {

    soma,sub:=sumEsubtracao(2,3)

    fmt.Println("Soma 2+3=",soma," e a subtração é 2-3=",sub)

}

Anterior                                       Início                                                       Próximo