Tutorial de Golang

Aprenderemos todos os fundamentos do Golang neste tutorial de idiomas do Learn Go.

Como baixar e instalar o GO

Passo 1) Acesse https://golang.org/dl/. Baixe o binário para o seu sistema operacional.

Passo 2) Double clique no instalador e clique em Executar.

Passo 3) Clique em Avançar

Passo 4) Selecione a pasta de instalação e clique em Avançar.

Passo 5) Clique em Concluir quando a instalação estiver concluída.

Passo 6) Assim que a instalação for concluída, você pode verificá-la abrindo o terminal e digitando

go version

Isso exibirá a versão do go instalada

Seu programa First Go – Go Hello World!

Crie uma pasta chamada studyGo. Neste tutorial da linguagem Go, criaremos nossos programas go dentro desta pasta. Os arquivos Go são criados com a extensão .ir. Você pode executar programas Go usando a sintaxe

go run <filename>

Crie um arquivo chamado first.go e adicione o código abaixo nele e salve

package main
import ("fmt")

func main() {
	fmt.Println("Hello World! This is my first Go program\n")
}

Navegue até esta pasta em seu terminal. Execute o programa usando o comando

vá correr primeiro. vá

Você pode ver a impressão de saída

Hello World! This is my first Go program

Agora vamos discutir o programa acima.

package main – Todo programa Go Language deve começar com um nome de pacote. Go nos permite usar pacotes em outros programas go e, portanto, oferece suporte à reutilização de código. A execução de um programa Go começa com o código dentro do pacote denominado main.

importar fmt – importa o pacote fmt. Este pacote implementa as funções de E/S.

func main() – Esta é a função a partir da qual começa a execução do programa. A função principal deve sempre ser colocada no pacote principal. Sob main(), você pode escrever o código dentro de {}.

fmt.Println – Imprimirá o texto na tela pela função Println do fmt.

Nota: Nas seções abaixo deste tutorial Go, quando você menciona executar/executar o código, significa salvar o código em um arquivo com extensão .go e executá-lo usando a sintaxe

    go run <filename>

Tipos de dados

Tipos (tipos de dados) representam o tipo do valor armazenado em uma variável, o tipo do valor que uma função retorna, etc.

Existem três tipos básicos em Go Language

Tipos numéricos – Representa valores numéricos que incluem números inteiros, ponto flutuante e valores complexos. Vários tipos numéricos são:

int8 – inteiros com sinal de 8 bits.

int16 – inteiros com sinal de 16 bits.

int32 – inteiros com sinal de 32 bits.

int64 – inteiros com sinal de 64 bits.

uint8 – inteiros sem sinal de 8 bits.

uint16 – inteiros sem sinal de 16 bits.

uint32 – inteiros sem sinal de 32 bits.

uint64 – inteiros sem sinal de 64 bits.

float32 – números de ponto flutuante de 32 bits.

float64 – números de ponto flutuante de 64 bits.

complex64 – possui float32 partes reais e imaginárias.

complex128 – possui float32 partes reais e imaginárias.

Tipos de string – Representa uma sequência de bytes (caracteres). Você pode realizar várias operações em strings, como concatenação de strings, extração de substring, etc.

tipos booleanos – Representa 2 valores, verdadeiro ou falso.

Variáveis

Variáveis ​​apontam para um local de memória que armazena algum tipo de valor. O parâmetro type (na sintaxe abaixo) representa o tipo de valor que pode ser armazenado no local da memória.

A variável pode ser declarada usando a sintaxe

    var <variable_name> <type>

Depois de declarar uma variável de um tipo, você pode atribuir a variável a qualquer valor desse tipo.

Você também pode atribuir um valor inicial a uma variável durante a própria declaração usando

    var <variable_name> <type> = <value>

Se você declarar a variável com um valor inicial, vá e infira o tipo da variável a partir do tipo de valor atribuído. Então você pode omitir o tipo durante a declaração usando a sintaxe

    var <variable_name> = <value>

Além disso, você pode declarar múltiplas variáveis ​​com a sintaxe

    var <variable_name1>, <variable_name2>  = <value1>, <value2>

O programa abaixo neste tutorial Go tem alguns exemplos Golang de declarações de variáveis

 
package main
import "fmt"

func main() {
    //declaring a integer variable x
    var x int
    x=3 //assigning x the value 3 
    fmt.Println("x:", x) //prints 3
    
    //declaring a integer variable y with value 20 in a single statement and prints it
    var y int=20
    fmt.Println("y:", y)
    
    //declaring a variable z with value 50 and prints it
    //Here type int is not explicitly mentioned 
    var z=50
    fmt.Println("z:", z)
    
    //Multiple variables are assigned in single line- i with an integer and j with a string
    var i, j = 100,"hello"
    fmt.Println("i and j:", i,j)
}

A saída será

x: 3
y: 20
z: 50
i and j: 100 hello

Go Language também fornece uma maneira fácil de declarar variáveis ​​com valor, omitindo a palavra-chave var usando

    <variable_name> := <value>

Observe que você usou := em vez de =. Você não pode usar := apenas para atribuir um valor a uma variável que já está declarada. := é usado para declarar e atribuir valor.

Crie um arquivo chamado assign.go com o seguinte código

package main
import ("fmt")

func main() {
	a := 20
	fmt.Println(a)

	//gives error since a is already declared
	a := 30
	fmt.Println(a)
}

Execute go run assign.go para ver o resultado como

./assign.go:7:4: no new variables on left side of :=		

Variáveis ​​declaradas sem valor inicial terão 0 para tipos numéricos, false para Boolean e string vazia para strings

Constante

Variáveis ​​constantes são aquelas variáveis ​​cujo valor não pode ser alterado depois de atribuído. Uma constante na linguagem de programação Go é declarada usando a palavra-chave “const”

Crie um arquivo chamado constante.go e com o seguinte código

package main
import ("fmt")

func main() {
	const b =10
	fmt.Println(b)
	b = 30
	fmt.Println(b)
}

Execute go run constante.go para ver o resultado como

.constant.go:7:4: cannot assign to b

Exemplos de loop para

Loops são usados ​​para executar um bloco de instruções repetidamente com base em uma condição. A maioria das linguagens de programação fornece 3 tipos de loops – for, while, do while. Mas a linguagem de programação Go oferece suporte apenas para loop.

A sintaxe de um loop for Golang é

for initialisation_expression; evaluation_expression; iteration_expression{
   // one or more statement
}

A expressão_de_inicialização é executada primeiro (e apenas uma vez) no loop for Golang.

Então a expressão_avaliação é avaliada e se for verdadeira o código dentro do bloco é executado.

O ID iteration_expression é executado e a avaliação_expression é avaliada novamente. Se for verdade, o bloco de instruções será executado novamente. Isso continuará até que a expressão_avaliação se torne falsa.

Copie o programa abaixo em um arquivo e execute-o para ver o Golang para imprimir números de loop de 1 a 5

package main
import "fmt"

func main() {  
var i int
for i = 1; i <= 5; i++ {
fmt.Println(i)
    }
}

A saída é

1
2
3
4
5

Se mais

If else é uma declaração condicional. A sinax é

if condition{
// statements_1
}else{
// statements_2
}

Aqui a condição é avaliada e se for verdadeira, as instruções_1 serão executadas, caso contrário, as instruções_2 serão executadas.

Você também pode usar a instrução if sem else. Você também pode ter instruções if else encadeadas. Os programas abaixo explicarão mais sobre o caso.

Execute o programa abaixo. Ele verifica se um número, x, é menor que 10. Nesse caso, imprimirá “x é menor que 10”

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x < 10
        fmt.Println("x is less than 10")
    } 
}

Aqui, como o valor de x é maior que 10, a instrução dentro da condição do bloco if não será executada.

Agora veja o programa abaixo. Neste tutorial da linguagem de programação Go, temos um bloco else que será executado em caso de falha na avaliação if.

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else {
        //Executes if x >= 10
        fmt.Println("x is greater than or equals 10")
    }
}

Este programa lhe dará uma saída

x is greater than or equals 10

Agora neste tutorial Go, veremos um programa com vários blocos if else (encadeados if else). Execute o exemplo Go abaixo. Ele verifica se um número é menor que 10, entre 10 e 90 ou maior que 90.

package main
import "fmt"

func main() {  
    var x = 100
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else if x >= 10 && x <= 90 {
        //Executes if x >= 10 and x<=90
        fmt.Println("x is between 10 and 90")
    } else {
        //Executes if both above cases fail i.e x>90
        fmt.Println("x is greater than 90")
    }
}

Aqui, primeiro, a condição if verifica se x é menor que 10 e não é. Portanto, ele verifica a próxima condição (caso contrário, se) se está entre 10 e 90, o que também é falso. Então ele executa o bloco na seção else que fornece a saída

x is greater than 90

Interruptor

Switch é outra declaração condicional. As instruções switch avaliam uma expressão e o resultado é comparado com um conjunto de valores disponíveis (casos). Depois que uma correspondência é encontrada, as instruções associadas a essa correspondência (caso) são executadas. Se nenhuma correspondência for encontrada, nada será executado. Você também pode adicionar um case padrão ao switch que será executado se nenhuma outra correspondência for encontrada. A sintaxe da opção é

switch expression {
    case value_1:
        statements_1
    case value_2:
        statements_2
    case value_n:
        statements_n
    default:
        statements_default
    }

Aqui o valor da expressão é comparado com os valores de cada caso. Assim que uma correspondência for encontrada, as instruções associadas a esse caso serão executadas. Se nenhuma correspondência for encontrada, as instruções da seção padrão serão executadas.

Execute o programa abaixo

package main
import "fmt"

func main() {  
    a,b := 2,1
    switch a+b {
    case 1:
        fmt.Println("Sum is 1")
    case 2:
        fmt.Println("Sum is 2")
    case 3:
        fmt.Println("Sum is 3")
    default:
        fmt.Println("Printing default")
    }
}

Você obterá a saída como

Sum is 3		

Altere o valor de a e b para 3 e o resultado será

Printing default

Você também pode ter vários valores em um caso, separando-os por vírgula.

Arrays

Array representa um tamanho fixo, denominado sequência de elementos do mesmo tipo. Você não pode ter um array que contenha números inteiros e caracteres. Você não pode alterar o tamanho de uma matriz depois de definir o tamanho.

A sintaxe para declarar um array é

var arrayname [size] type

Cada elemento da matriz pode receber um valor usando a sintaxe

arrayname [index] = value

O índice da matriz começa em 0 a tamanho-1.

Você pode atribuir valores aos elementos do array durante a declaração usando a sintaxe

arrayname := [size] type {value_0,value_1,…,value_size-1} 

Você também pode ignorar o parâmetro size ao declarar o array com valores, substituindo size por ... e o compilador encontrará o comprimento a partir do número de valores. Sintaxe é

arrayname :=  […] type {value_0,value_1,…,value_size-1}

Você pode encontrar o comprimento do array usando a sintaxe

len(arrayname)

Execute o exemplo Go abaixo para entender o array

package main
import "fmt"

func main() {  
    var numbers [3] string //Declaring a string array of size 3 and adding elements 
    numbers[0] = "One"
    numbers[1] = "Two"
    numbers[2] = "Three"
    fmt.Println(numbers[1]) //prints Two
    fmt.Println(len(numbers)) //prints 3
    fmt.Println(numbers) // prints [One Two Three]

    directions := [...] int {1,2,3,4,5} // creating an integer array and the size of the array is defined by the number of elements 
    fmt.Println(directions) //prints [1 2 3 4 5]
    fmt.Println(len(directions)) //prints 5

    //Executing the below commented statement prints invalid array index 5 (out of bounds for 5-element array)
    //fmt.Println(directions[5]) 
}

saída

Two
3
[One Two Three]
[1 2 3 4 5]
5

Função Golang Slice e Append

Uma fatia é uma parte ou segmento de uma matriz. Ou é uma visão ou visão parcial de uma matriz subjacente para a qual aponta. Você pode acessar os elementos de uma fatia usando o nome da fatia e o número do índice, assim como faz em uma matriz. Você não pode alterar o comprimento de uma matriz, mas pode alterar o tamanho de uma fatia.

O conteúdo de uma fatia são, na verdade, ponteiros para os elementos de uma matriz. Isso significa se você alterar qualquer elemento em uma fatia, o conteúdo subjacente do array também será afetado.

A sintaxe para criar uma fatia é

var slice_name [] type = array_name[start:end]

Isso criará uma fatia chamada slice_name a partir de uma matriz chamada array_name com os elementos no índice do início ao fim-1.

Agora neste tutorial Golang, executaremos o programa abaixo. O programa criará uma fatia do array e a imprimirá. Além disso, você pode ver que modificar o conteúdo da fatia modificará a matriz real.

package main
import "fmt"

func main() {  
    // declaring array
    a := [5] string {"one", "two", "three", "four", "five"}
    fmt.Println("Array after creation:",a)

    var b [] string = a[1:4] //created a slice named b
    fmt.Println("Slice after creation:",b)

    b[0]="changed" // changed the slice data
    fmt.Println("Slice after modifying:",b)
    fmt.Println("Array after slice modification:",a)
}

Isso imprimirá o resultado como

Array after creation: [one two three four five]
Slice after creation: [two three four]
Slice after modifying: [changed three four]
Array after slice modification: [one changed three four five]

Existem certas funções como Golang len, Golang anexar que você pode aplicar em fatias

len(nome_da_fatia) – retorna o comprimento da fatia

anexar (nome_da fatia, valor_1, valor_2) – O acréscimo Golang é usado para anexar valor_1 e valor_2 a uma fatia existente.

acrescentar(fatia_nale1,slice_name2…) – anexa slice_name2 a slice_name1

Execute o seguinte programa.

package main
import "fmt"

func main() {  
	a := [5] string {"1","2","3","4","5"}
	slice_a := a[1:3]
	b := [5] string {"one","two","three","four","five"}
	slice_b := b[1:3]

    fmt.Println("Slice_a:", slice_a)
    fmt.Println("Slice_b:", slice_b)
    fmt.Println("Length of slice_a:", len(slice_a))
    fmt.Println("Length of slice_b:", len(slice_b))

    slice_a = append(slice_a,slice_b...) // appending slice
    fmt.Println("New Slice_a after appending slice_b :", slice_a)
    
    slice_a = append(slice_a,"text1") // appending value
    fmt.Println("New Slice_a after appending text1 :", slice_a)
}

A saída será

Slice_a: [2 3]
Slice_b: [two three]
Length of slice_a: 2
Length of slice_b: 2
New Slice_a after appending slice_b : [2 3 two three]
New Slice_a after appending text1 : [2 3 two three text1]

O programa primeiro cria 2 fatias e imprime seu comprimento. Em seguida, ele anexou uma fatia à outra e anexou uma string à fatia resultante.

Funções

Uma função representa um bloco de instruções que executa uma tarefa específica. Uma declaração de função nos informa o nome da função, tipo de retorno e parâmetros de entrada. A definição da função representa o código contido na função. A sintaxe para declarar a função é

func function_name(parameter_1 type, parameter_n type) return_type {
//statements
}

Os parâmetros e tipos de retorno são opcionais. Além disso, você pode retornar vários valores de uma função.

Agora, neste tutorial do Golang, vamos executar o seguinte exemplo do Golang. Aqui a função chamada calc aceitará 2 números e realizará a adição e subtração e retornará ambos os valores.

package main
import "fmt"

//calc is the function name which accepts two integers num1 and num2
//(int, int) says that the function returns two values, both of integer type.
func calc(num1 int, num2 int)(int, int) {  
    sum := num1 + num2
    diff := num1 - num2
    return sum, diff
}

func main() {  
    x,y := 15,10

    //calls the function calc with x and y an d gets sum, diff as output
    sum, diff := calc(x,y) 
    fmt.Println("Sum",sum)
    fmt.Println("Diff",diff) 
}

A saída será

Sum 25
Diff 5

PACOTES

Pacotes são usados ​​para organizar o código. Em um projeto grande, não é viável escrever código em um único arquivo. A linguagem de programação Go nos permite organizar o código em diferentes pacotes. Isso aumenta a legibilidade e a reutilização do código. Um programa Go executável deve conter um pacote denominado main e a execução do programa começa a partir da função denominada main. Você pode importar outros pacotes em nosso programa usando a sintaxe

import package_name

Veremos e discutiremos neste tutorial Golang como criar e usar pacotes no seguinte exemplo Golang.

Passo 1) Crie um arquivo chamado package_example.go e adicione o código abaixo

package main
import "fmt"
//the package to be created
import "calculation"

func main() {  
	x,y := 15,10
	//the package will have function Do_add()
sum := calculation.Do_add(x,y)
fmt.Println("Sum",sum) 
}

No programa acima, fmt é um pacote que a linguagem de programação Go nos fornece principalmente para fins de E/S. Além disso, você pode ver um pacote chamado cálculo. Dentro de main() você pode ver uma soma de passos:=cálculo.Do_add(x,y). Isso significa que você está invocando a função Do_add do cálculo do pacote.

Passo 2) Primeiro, você deve criar o cálculo do pacote dentro de uma pasta com o mesmo nome na pasta src do go. O caminho instalado do go pode ser encontrado na variável PATH.

Para mac, encontre o caminho executando echo $PATH

Então o caminho é /usr/local/go

Para Windows, encontre o caminho executando echo %GOROOT%

Aqui o caminho é C:\Go\

Passo 3) Navegue até a pasta src (/usr/local/go/src para mac e C:\Go\src para windows). Agora, a partir do código, o nome do pacote é cálculo. Go requer que o pacote seja colocado em um diretório com o mesmo nome no diretório src. Crie um diretório chamado cálculo na pasta src.

Passo 4) Crie um arquivo chamado calc.go (você pode dar qualquer nome, mas o nome do pacote no código é importante. Aqui deve ser cálculo) dentro do diretório de cálculo e adicione o código abaixo

package calculation
  
func Do_add(num1 int, num2 int)(int) {
    sum := num1 + num2
    return sum
}

Passo 5) Execute o comando go install do diretório de cálculo que irá compilar o calc.go.

Passo 6) Agora volte para package_example.go e execute package_example.go. A saída será Soma 25.

Observe que o nome da função Do_add começa com letra maiúscula. Isso ocorre porque em Go, se o nome da função começar com uma letra maiúscula, significa que outros programas podem vê-lo (acessá-lo), caso contrário, outros programas não poderão acessá-lo. Se o nome da função fosse do_add , você teria recebido o erro

não é possível referir-se ao nome não exportado calculator.calc..

Adiar e empilhar adiamentos

As instruções defer são usadas para adiar a execução de uma chamada de função até que a função que contém a instrução defer conclua a execução.

Vamos aprender isso com um exemplo:

package main
import "fmt"

func sample() {  
    fmt.Println("Inside the sample()")
}
func main() {  
    //sample() will be invoked only after executing the statements of main()
    defer sample()
    fmt.Println("Inside the main()")
}

A saída será

Inside the main()
Inside the sample()

Aqui a execução de sample() é adiada até que a execução da função envolvente (main()) seja concluída.

O empilhamento defer usa várias instruções defer. Suponha que você tenha várias instruções defer dentro de uma função. Go coloca todas as chamadas de função adiadas em uma pilha e, quando a função envolvente retorna, as funções empilhadas são executadas no Ordem Last In First Out (LIFO). Você pode ver isso no exemplo abaixo.

Execute o código abaixo

package main
import "fmt"

func display(a int) {  
    fmt.Println(a)
}
func main() {  
    defer display(1)
    defer display(2)
    defer display(3)
    fmt.Println(4)
}

A saída será

4
3
2
1			

Aqui, o código dentro de main() é executado primeiro e, em seguida, as chamadas de função adiadas são executadas na ordem inversa, ou seja, 4, 3,2,1.

Ponteiros

Antes de explicar as dicas, vamos primeiro discutir o operador '&'. O operador '&' é usado para obter o endereço de uma variável. Significa que '&a' imprimirá o endereço de memória da variável a.

Neste tutorial Golang, executaremos o programa abaixo para exibir o valor de uma variável e o endereço dessa variável

package main
import "fmt"

func main() {
	a := 20
	fmt.Println("Address:",&a)
	fmt.Println("Value:",a)
}

O resultado será

Address: 0xc000078008
Value: 20

Uma variável de ponteiro armazena o endereço de memória de outra variável. Você pode definir um ponteiro usando a sintaxe

	var variable_name *type

O asterisco (*) representa que a variável é um ponteiro. Você entenderá mais executando o programa abaixo

package main
import "fmt"

func main() {
	//Create an integer variable a with value 20
	a := 20
	
	//Create a pointer variable b and assigned the address of a
	var b *int = &a

	//print address of a(&a) and value of a  
	fmt.Println("Address of a:",&a)
	fmt.Println("Value of a:",a)

	//print b which contains the memory address of a i.e. &a
	fmt.Println("Address of pointer b:",b)

	//*b prints the value in memory address which b contains i.e. the value of a
	fmt.Println("Value of pointer b",*b)

	//increment the value of variable a using the variable b
	*b = *b+1

	//prints the new value using a and *b
	fmt.Println("Value of pointer b",*b)
	fmt.Println("Value of a:",a)}

A saída será

Address of a: 0x416020
Value of a: 20
Address of pointer b: 0x416020
Value of pointer b 20
Value of pointer b 21
Value of a: 21

Estruturas

Uma estrutura é um tipo de dados definido pelo usuário que contém mais um elemento do mesmo tipo ou de tipo diferente.

Usar uma estrutura é um processo de duas etapas.

Primeiro, crie(declare) um tipo de estrutura

Segundo, crie variáveis ​​desse tipo para armazenar valores.

As estruturas são usadas principalmente quando você deseja armazenar dados relacionados juntos.

Considere uma informação do funcionário que contém nome, idade e endereço. Você pode lidar com isso de duas maneiras

Crie 3 arrays – um array armazena os nomes dos funcionários, um armazena a idade e o terceiro armazena a idade.

Declare um tipo de estrutura com 3 campos: nome, endereço e idade. Crie uma matriz desse tipo de estrutura onde cada elemento é um objeto de estrutura com nome, endereço e idade.

A primeira abordagem não é eficiente. Nesses tipos de cenários, as estruturas são mais convenientes.

A sintaxe para declarar uma estrutura é

type structname struct {
   variable_1 variable_1_type
   variable_2 variable_2_type
   variable_n variable_n_type
}

Um exemplo de declaração de estrutura é

type emp struct {
    name string
    address string
    age int
}

Aqui um novo tipo definido pelo usuário denominado emp é criado. Agora você pode criar variáveis ​​do tipo emp usando a sintaxe

	var variable_name struct_name

Um exemplo é

var empdata1 emp 

Você pode definir valores para empdata1 como

empdata1.name = "John"
	empdata1.address = "Street-1, Bangalore"
	empdata1.age = 30

Você também pode criar uma variável de estrutura e atribuir valores por

empdata2 := emp{"Raj", "Building-1, Delhi", 25}

Aqui, você precisa manter a ordem dos elementos. Raj será mapeado para o nome, o próximo elemento a ser endereçado e o último a envelhecer.

Execute o código abaixo

package main
import "fmt"

//declared the structure named emp
type emp struct {
        name string
        address string
        age int
}       

//function which accepts variable of emp type and prints name property
func display(e emp) {
          fmt.Println(e.name)
}

func main() {
// declares a variable, empdata1, of the type emp
var empdata1 emp
//assign values to members of empdata1
empdata1.name = "John"
empdata1.address = "Street-1, London"
empdata1.age = 30

//declares and assign values to variable empdata2 of type emp
empdata2 := emp{"Raj", "Building-1, Paris", 25}

//prints the member name of empdata1 and empdata2 using display function
display(empdata1)
display(empdata2)
}

saída

John
Raj

Métodos (não funções)

Um método é uma função com um argumento receptor. Archiestruturalmente, está entre a palavra-chave func e o nome do método. A sintaxe de um método é

func (variable variabletype) methodName(parameter1 paramether1type) {  
}

Vamos converter o programa de exemplo acima para usar métodos em vez de funções.

package main
import "fmt"

//declared the structure named emp
type emp struct {
    name string
    address string
    age int
}

//Declaring a function with receiver of the type emp
func(e emp) display() {
    fmt.Println(e.name)
}

func main() {
    //declaring a variable of type emp
    var empdata1 emp
    
    //Assign values to members
    empdata1.name = "John"
    empdata1.address = "Street-1, Lodon"
    empdata1.age = 30

    //declaring a variable of type emp and assign values to members
    empdata2 := emp {
        "Raj", "Building-1, Paris", 25}

    //Invoking the method using the receiver of the type emp
   // syntax is variable.methodname()
    empdata1.display()
    empdata2.display()
}

Go não é uma linguagem orientada a objetos e não possui o conceito de classe. Os métodos dão uma ideia do que você faz em programas orientados a objetos, onde as funções de uma classe são invocadas usando a sintaxe objectname.functionname()

Concorrência

Go oferece suporte à execução simultânea de tarefas. Isso significa que Go pode executar várias tarefas simultaneamente. É diferente do conceito de paralelismo. No paralelismo, uma tarefa é dividida em pequenas subtarefas e executadas em paralelo. Mas em simultaneidade, várias tarefas são executadas simultaneamente. A simultaneidade é alcançada em Go usando Goroutines e Canais.

Goroutines

Uma goroutine é uma função que pode ser executada simultaneamente com outras funções. Normalmente, quando uma função é invocada, o controle é transferido para a função chamada e, uma vez concluída a execução, o controle retorna para a função chamadora. A função de chamada continua sua execução. A função chamadora espera que a função invocada conclua a execução antes de prosseguir com o restante das instruções.

Mas no caso de goroutine, a função chamadora não aguardará a conclusão da execução da função invocada. Ele continuará a ser executado com as próximas instruções. Você pode ter vários goroutines em um programa.

Além disso, o programa principal será encerrado assim que concluir a execução de suas instruções e não aguardará a conclusão das goroutines invocadas.

Goroutine é invocada usando a palavra-chave go seguida por uma chamada de função.

Exemplo

go add(x,y)

Você entenderá goroutines com os exemplos de Golang abaixo. Execute o programa abaixo

package main
import "fmt"
    
func display() {
	for i:=0; i<5; i++ {
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	//The main() continues without waiting for display()
	for i:=0; i<5; i++ {
		fmt.Println("In main")
	}
}

A saída será

In main
In main
In main
In main
In main

Aqui, o programa principal concluiu a execução antes mesmo do início da goroutine. O display() é uma goroutine que é invocada usando a sintaxe

go function_name(parameter list)

No código acima, main() não espera a conclusão de display() e main() concluiu sua execução antes de display() executar seu código. Portanto, a instrução print dentro de display() não foi impressa.

Agora modificamos o programa para imprimir as instruções de display() também. Adicionamos um atraso de 2 segundos no loop for de main() e um atraso de 1 segundo no loop for de display().

package main
import "fmt"
import "time"
    
func display() {
	for i:=0; i<5; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	for i:=0; i<5; i++ {
		time.Sleep(2 * time.Second)
		fmt.Println("In main")
	}
}

A saída será um pouco semelhante a

In display
In main
In display
In display
In main
In display
In display
In main
In main
In main

Aqui você pode ver que ambos os loops estão sendo executados de forma sobreposta devido à execução simultânea.

Canais

Os canais são uma forma de as funções se comunicarem entre si. Pode ser pensado como um meio onde uma rotina coloca os dados e é acessada por outra rotina no servidor Golang.

Um canal pode ser declarado com a sintaxe

channel_variable := make(chan datatype)

Exemplo:

	ch := make(chan int)

Você pode enviar dados para um canal usando a sintaxe

channel_variable <- variable_name

Exemplo

    ch <- x

Você pode receber dados de um canal usando a sintaxe

    variable_name := <- channel_variable

Exemplo

   y := <- ch

Nos exemplos de goroutine da linguagem Go acima, você viu que o programa principal não espera pela goroutine. Mas esse não é o caso quando há canais envolvidos. Suponha que se uma goroutine envia dados para o canal, o main() aguardará a instrução que recebe os dados do canal até obter os dados.

Você verá isso nos exemplos de linguagem Go abaixo. Primeiro, escreva uma goroutine normal e veja o comportamento. Em seguida, modifique o programa para usar canais e veja o comportamento.

Execute o programa abaixo

package main
import "fmt"
import "time"
    
func display() {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
}

func main() {
	go display()
	fmt.Println("Inside main()")
}

A saída será

Inside main()

O main() finalizou a execução e saiu antes da execução da goroutine. Portanto, a impressão dentro de display() não foi executada.

Agora modifique o programa acima para usar canais e veja o comportamento.

package main
import "fmt"
import "time"
    
func display(ch chan int) {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
	ch <- 1234
}

func main() {
	ch := make(chan int) 
	go display(ch)
	x := <-ch
	fmt.Println("Inside main()")
	fmt.Println("Printing x in main() after taking from channel:",x)
}

A saída será

Inside display()
Inside main()
Printing x in main() after taking from channel: 1234

Aqui o que acontece é que main() ao atingir x := <-ch irá aguardar os dados no canal ch. O display() espera 5 segundos e depois envia os dados para o canal ch. O main() ao receber os dados do canal é desbloqueado e continua sua execução.

O remetente que envia os dados para o canal pode informar aos destinatários que nenhum outro dado será adicionado ao canal fechando o canal. Isso é usado principalmente quando você usa um loop para enviar dados para um canal. Um canal pode ser fechado usando

close(channel_name)

E no final do receptor, é possível verificar se o canal está fechado usando uma variável adicional enquanto busca dados do canal usando

variable_name, status := <- channel_variable

Se o status for True significa que você recebeu dados do canal. Se for falso, significa que você está tentando ler de um canal fechado

Você também pode usar canais para comunicação entre goroutines. É necessário usar 2 goroutines – uma envia os dados para o canal e a outra recebe os dados do canal. Veja o programa abaixo

package main
import "fmt"
import "time"

//This subroutine pushes numbers 0 to 9 to the channel and closes the channel
func add_to_channel(ch chan int) {	
	fmt.Println("Send data")
	for i:=0; i<10; i++ {
		ch <- i //pushing data to channel
	}
	close(ch) //closing the channel

}

//This subroutine fetches data from the channel and prints it.
func fetch_from_channel(ch chan int) {
	fmt.Println("Read data")
	for {
		//fetch data from channel
x, flag := <- ch

		//flag is true if data is received from the channel
//flag is false when the channel is closed
if flag == true {
			fmt.Println(x)
		}else{
			fmt.Println("Empty channel")
			break	
		}	
	}
}

func main() {
	//creating a channel variable to transport integer values
	ch := make(chan int)

	//invoking the subroutines to add and fetch from the channel
	//These routines execute simultaneously
	go add_to_channel(ch)
	go fetch_from_channel(ch)

	//delay is to prevent the exiting of main() before goroutines finish
	time.Sleep(5 * time.Second)
	fmt.Println("Inside main()")
}

Aqui existem 2 sub-rotinas, uma envia dados para o canal e a outra imprime dados para o canal. A função add_to_channel soma os números de 0 a 9 e fecha o canal. Simultaneamente, a função fetch_from_channel espera em

x, flag := <- ch e assim que os dados estiverem disponíveis, ele os imprime. Ele sai quando o sinalizador é falso, o que significa que o canal está fechado.

A espera em main() é dada para evitar a saída de main() até que as goroutines terminem a execução.

Execute o código e veja a saída como

Read data
Send data
0
1
2
3
4
5
6
7
8
9
Empty channel
Inside main()

Selecionar

Select pode ser visto como uma instrução switch que funciona em canais. Aqui as declarações case serão uma operação de canal. Normalmente, cada declaração de caso será uma tentativa de leitura do canal. Quando qualquer um dos casos estiver pronto (o canal for lido), a instrução associada a esse caso será executada. Se vários casos estiverem prontos, ele escolherá um aleatório. Você pode ter um caso padrão que será executado se nenhum dos casos estiver pronto.

Vamos ver o código abaixo

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)
    
    //Both case statements wait for data in the chan1 or chan2.
    //chan2 gets data first since the delay is only 2 sec in data2().
    //So the second case will execute and exits the select block
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    }
}

A execução do programa acima fornecerá a saída:

from data2()

Aqui, a instrução select aguarda que os dados estejam disponíveis em qualquer um dos canais. O data2() adiciona dados ao canal após um sono de 2 segundos, o que fará com que o segundo caso seja executado.

Adicione um caso padrão ao select no mesmo programa e veja a saída. Aqui, ao chegar ao bloco select, se nenhum caso estiver com dados prontos no canal, ele executará o bloco padrão sem esperar que os dados estejam disponíveis em algum canal.

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values  
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)

    //Both case statements check for data in chan1 or chan2.
    //But data is not available (both routines have a delay of 2 and 4 sec)
    //So the default block will be executed without waiting for data in channels.
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    default:
    	fmt.Println("Default case executed")
    }
}

Este programa dará a saída:

Default case executed			

Isso ocorre porque quando o bloco selecionado foi alcançado, nenhum canal tinha dados para leitura. Portanto, o caso padrão é executado.

Mutex

Mutex é a abreviação de exclusão mútua. Mutex é usado quando você não deseja permitir que um recurso seja acessado por várias sub-rotinas ao mesmo tempo. Mutex possui 2 métodos – Bloquear e Desbloquear. Mutex está contido no pacote de sincronização. Então, você tem que importar o pacote de sincronização. As instruções que devem ser executadas mutuamente exclusivamente podem ser colocadas dentro de mutex.Lock() e mutex.Unlock().

Vamos aprender o mutex com um exemplo que conta o número de vezes que um loop é executado. Neste programa esperamos que a rotina execute o loop 10 vezes e a contagem seja armazenada em soma. Você chama essa rotina 3 vezes, então a contagem total deve ser 30. A contagem é armazenada em uma variável global count.

Primeiro, você executa o programa sem mutex

package main
import "fmt"
import "time"
import "strconv"
import "math/rand"
//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Veja o resultado

 Count after i=1 Count: 11
Count after i=3 Count: 12
Count after i=2 Count: 13
Final Count: 13

O resultado pode ser diferente ao executá-lo, mas o resultado final não será 30.

Aqui o que acontece é que 3 goroutines estão tentando aumentar a contagem de loops armazenada na variável count. Suponha que em um momento a contagem seja 5 e goroutine1 aumente a contagem para 6. As etapas principais incluem

Contagem de cópias para temperatura

Aumentar temperatura

Armazene a temperatura de volta à contagem

Suponha que logo após executar a etapa 3 do goroutine1; outra goroutine pode ter um valor antigo, digamos 3 executa as etapas acima e armazena 4 de volta, o que está errado. Isso pode ser evitado usando mutex, que faz com que outras rotinas esperem quando uma rotina já estiver usando a variável.

Agora você executará o programa com mutex. Aqui as 3 etapas mencionadas acima são executadas em um mutex.

package main
import "fmt"
import "time"
import "sync"
import "strconv"
import "math/rand"

//declare a mutex instance
var mu sync.Mutex

//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		//lock starts here
		mu.Lock()
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
		//lock ends here
		mu.Unlock()
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Agora a saída será

 Count after i=3 Count: 21
Count after i=2 Count: 28
Count after i=1 Count: 30
Final Count: 30

Aqui obtemos o resultado esperado como resultado final. Porque as instruções de leitura, incremento e reescrita da contagem são executadas em um mutex.

Tratamento de erros

Erros são condições anormais como fechar um arquivo que não está aberto, abrir um arquivo que não existe, etc. As funções geralmente retornam erros como o último valor de retorno.

O exemplo abaixo explica mais sobre o erro.

package main
import "fmt"
import "os"

//function accepts a filename and tries to open it.
func fileopen(name string) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        fmt.Println(er)
        return
    }else{
    	fmt.Println("file opened", f.Name())
    }
}

func main() {  
    fileopen("invalid.txt")
}

A saída será:

open /invalid.txt: no such file or directory

Aqui tentamos abrir um arquivo inexistente e ele retornou o erro para a variável er. Se o arquivo for válido, o erro será nulo

Erros personalizados

Usando este recurso, você pode criar erros personalizados. Isso é feito usando New() do pacote de erros. Reescreveremos o programa acima para usar erros personalizados.

Execute o programa abaixo

package main
import "fmt"
import "os"
import "errors"

//function accepts a filename and tries to open it.
func fileopen(name string) (string, error) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        //created a new error object and returns it  
        return "", errors.New("Custom error message: File name is wrong")
    }else{
    	return f.Name(),nil
    }
}

func main() {  
    //receives custom error or nil after trying to open the file
    filename, error := fileopen("invalid.txt")
    if error != nil {
        fmt.Println(error)
    }else{
    	fmt.Println("file opened", filename)
    }  
}

A saída será:

Custom error message:File name is wrong

Aqui a area() retorna a área de um quadrado. Se a entrada for menor que 1, area() retornará uma mensagem de erro.

Lendo arquivos

Arquivos são usados ​​para armazenar dados. Go nos permite ler dados dos arquivos

Primeiro crie um arquivo, data.txt, em seu diretório atual com o conteúdo abaixo.

Line one
Line two
Line three

Agora execute o programa abaixo para ver se ele imprime o conteúdo de todo o arquivo como saída

package main
import "fmt"
import "io/ioutil"

func main() {  
    data, err := ioutil.ReadFile("data.txt")
    if err != nil {
        fmt.Println("File reading error", err)
        return
    }
    fmt.Println("Contents of file:", string(data))
}

Aqui os dados, err := ioutil.ReadFile(“data.txt”) lê os dados e retorna uma sequência de bytes. Durante a impressão, ele é convertido para o formato string.

Escrevendo arquivos

Você verá isso com um programa

package main
import "fmt"
import "os"

func main() {  
    f, err := os.Create("file1.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    l, err := f.WriteString("Write Line one")
    if err != nil {
        fmt.Println(err)
        f.Close()
        return
    }
    fmt.Println(l, "bytes written")
    err = f.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
}

Aqui é criado um arquivo, test.txt. Se o arquivo já existir, o conteúdo do arquivo será truncado. Writeline() é usado para gravar o conteúdo do arquivo. Depois disso, você fechou o arquivo usando Close().

Folha de fraude

Neste tutorial do Go, abordamos,

Tema	Descrição	Sintaxe
Tipos básicos	Numérico, string, bool
Variáveis	Declarar e atribuir valores a variáveis	var tipo nome_variável var nome_variável tipo = valor var nome_variável1, nome_variável2 = valor1, valor2 nome_variável := valor
Constante	Variáveis ​​cujo valor não pode ser alterado depois de atribuído	variável const = valor
Para Loop	Execute instruções em um loop.	para expressão_de_inicialização; expressão_avaliação; iteração_expressão{ // uma ou mais instruções }
Se mais	É uma declaração condicional	se condição{ // declarações_1 Else {} // declarações_2 }
interruptor	Declaração condicional com vários casos	mudar expressão { valor do caso_1: declarações_1 valor do caso_2: declarações_2 valor do caso_n: declarações_n default: declarações_default }
Ordem	Tamanho fixo nomeado sequência de elementos do mesmo tipo	nome da matriz: = [tamanho] tipo {valor_0, valor_1,…, valor_tamanho-1}
Fatia	Parte ou segmento de uma matriz	var slice_name [] tipo = array_name[início:fim]
Funções	Bloco de instruções que executa uma tarefa específica	func nome_da_função(tipo parâmetro_1, tipo parâmetro_n) tipo_retorno { //declarações }
PACOTES	São usados ​​para organizar o código. Aumenta a legibilidade e a reutilização do código	importar pacote_nome
Adiar	Adia a execução de uma função até que a função que a contém termine a execução	adiar nome_da_função(lista_de_parâmetros)
Ponteiros	Armazena o endereço de memória de outra variável.	var nome_variável *tipo
Estrutura	Tipo de dados definido pelo usuário que contém mais um elemento do mesmo tipo ou de tipo diferente	digite nome da estrutura estrutura { variável_1 variável_1_tipo variável_2 variável_2_tipo variável_n variável_n_tipo }
De Depósito	Um método é uma função com um argumento receptor	func (variável tipovariável) nome_método(lista_parâmetro) { }
Gorotina	Uma função que pode ser executada simultaneamente com outras funções.	vá nome_função(lista_parâmetros)
Canal	Maneira de as funções se comunicarem entre si. Um meio no qual uma rotina coloca dados e é acessado por outra rotina.	Declarar: ch := make(chan int) Envie dados para o canal: variável_canal <- nome_variável Receba do canal: nome_variável := <- variável_canal
Selecionar	Instrução switch que funciona em canais. As declarações de caso serão uma operação de canal. Quando qualquer canal estiver pronto com dados, a instrução associada a esse caso será executada	selecione { caso x := <-chan1: fmt.Println(x) caso y := <-chan2: fmt.Println(y) }
Mutex	Mutex é usado quando você não deseja permitir que um recurso seja acessado por várias sub-rotinas ao mesmo tempo. Mutex tem 2 métodos – Bloquear e Desbloquear	mutex.Lock() //declarações mutex.Unlock().
Ler arquivos	Lê os dados e retorna uma sequência de bytes.	Dados, err := ioutil.ReadFile (nome do arquivo)
Gravar arquivo	Grava dados em um arquivo	l, err := f.WriteString(text_to_write)