Introdução
O que é ir?
Go é uma linguagem de programação criada pelo Google em 2007 e lançada ao público em 2009. É uma linguagem compilada estaticamente tipada que possui uma sintaxe semelhante a C, mas com alguns recursos inspirados em outras linguagens, como Python, Java e Pascal. Algumas das principais características do Go são:
go download go
É simples e conciso, sem palavras-chave ou pontuação desnecessárias.
Ele possui suporte integrado para simultaneidade, o que significa que pode executar várias tarefas ao mesmo tempo.
Possui uma rica biblioteca padrão que fornece uma ampla gama de pacotes para tarefas comuns, como entrada/saída, rede, criptografia, teste, etc.
Possui uma poderosa cadeia de ferramentas que inclui ferramentas para formatação, teste, depuração, criação de perfil, documentação, etc.
Possui um sistema modular que permite aos desenvolvedores gerenciar dependências através de módulos.
Go é projetado para construir software simples, confiável e eficiente que pode rodar em qualquer plataforma que suporte a linguagem. É especialmente adequado para desenvolvimento web, simultaneidade e programação de sistemas. Alguns dos aplicativos mais conhecidos que usam Go são Docker, Kubernetes, Terraform, Uber, Netflix, etc.
Baixe e instale Go
Como obter o Go no seu sistema
Para começar a usar o Go em seu sistema, você precisa baixar e instalar a distribuição binária do idioma no site oficial: . Existem diferentes versões disponíveis para Windows de 64 bits, macOS, Linux e outros sistemas operacionais. Escolha aquele que corresponda aos requisitos do seu sistema.
Depois de baixar o arquivo de distribuição binária (por exemplo, go1.20.4.windows-amd64.msi para Windows), siga estas etapas para instalá-lo:
Execute o arquivo do instalador e siga as instruções na tela.
Escolha um local onde deseja instalar o Go (por exemplo, C:\Go).
Adicione o subdiretório bin do seu diretório de instalação (por exemplo, C:\Go\bin) à sua variável de ambiente PATH.Isso permitirá que você execute o comando go de qualquer diretório.
Verifique se você instalou o Go corretamente abrindo um prompt de comando ou janela de terminal e digitando: versão $ go. Você deve ver algo como: ir versão go1.20.4 windows/amd64.
Escreva algum código
Olá Mundo
O primeiro programa que escreveremos em Go é o clássico programa "Hello, World" que imprime uma mensagem para o console. Para fazer isso, siga estas etapas:
Crie um novo arquivo chamado hello.go em qualquer diretório de sua escolha.
Abra o arquivo com seu editor de texto ou IDE favorito e digite o seguinte código: package main import "fmt" func main() fmt.Println("Hello, World")
Salve o arquivo e volte para o prompt de comando ou janela do terminal.
Navegue até o diretório onde você salvou o arquivo e digite: $ vá correr olá.. Isso irá compilar e executar seu programa.
Você deve ver a saída: Olá Mundo.
Parabéns! Você acabou de escrever e executar seu primeiro programa em Go. Vamos detalhar o que esse código faz:
a primeira linha pacote principal declara o nome do pacote que contém o código. Todo programa Go deve ter um nome de pacote, e o pacote principal é aquele que contém o ponto de entrada do programa.
a segunda linha importar "fmt" importa o pacote fmt da biblioteca padrão, que fornece funções para entrada e saída formatadas.
a terceira linha função principal() define a função principal, que é o ponto de entrada do programa. Todo programa Go deve ter uma função principal no pacote principal.
a quarta linha fmt.Println("Olá, Mundo") chama a função Println do pacote fmt, que imprime uma linha de texto na saída padrão (o console).
a quinta linha fecha a função principal.
Variáveis e tipos
Em Go, uma variável é um nome que se refere a um valor armazenado na memória. Para declarar uma variável, você usa a palavra-chave var seguida do nome e, opcionalmente, do tipo da variável. Por exemplo: var x int declara uma variável chamada x do tipo int (inteiro). Você também pode atribuir um valor a uma variável ao mesmo tempo em que a declara, usando o operador =. Por exemplo: var y string = "Olá" declara e atribui uma variável chamada y do tipo string (uma sequência de caracteres) com o valor "Hello".
Se você omitir o tipo de uma variável, Go irá inferi-lo a partir do valor atribuído a ela. Por exemplo: var z = 3,14 declara e atribui uma variável chamada z com o valor 3.14 e infere que é do tipo float64 (um número de ponto flutuante com 64 bits de precisão).
Você também pode usar uma sintaxe de declaração curta para declarar e atribuir uma variável sem usar a palavra-chave var, usando o operador :=. Por exemplo: a := 10 declara e atribui uma variável chamada a com o valor 10 e infere que é do tipo int. Essa sintaxe só pode ser usada dentro de uma função, não no nível do pacote.
Go possui vários tipos básicos, como bool (booleano), int (inteiro), float64 (número de ponto flutuante), string (sequência de caracteres), etc. Você também pode criar seus próprios tipos usando declarações de tipo, como: tipo Pessoa struct nome string idade int que define um novo tipo chamado Person que é uma struct (uma coleção de campos) com dois campos: nome e idade.
Funções
Uma função é um bloco de código que executa uma tarefa específica e pode ser reutilizado em todo o programa. Para definir uma função, você usa a palavra-chave func seguida do nome e dos parâmetros da função. Por exemplo: func add(x int, y int) int return x + y define uma função chamada add que recebe dois parâmetros do tipo int e retorna um valor int. A palavra-chave return especifica qual valor retornar da função.
Para chamar uma função, você usa seu nome seguido de argumentos que correspondem a seus parâmetros. Por exemplo: soma := soma(5, 7) chama a função add com os argumentos 5 e 7 e atribui o valor de retorno a uma variável chamada sum.
Você também pode definir vários valores de retorno para uma função, colocando-os entre parênteses. Por exemplo: func swap(x string, y string) (string, string) return y, x define uma função chamada swap que recebe dois parâmetros do tipo string e retorna dois valores de string. Para atribuir vários valores de retorno a variáveis, você pode usar a sintaxe de atribuição múltipla: a, b := swap("Olá", "Mundo").
estruturas de controle
Uma estrutura de controle é uma instrução que controla o fluxo de execução do seu programa. Go tem algumas estruturas básicas de controle, como:
A instrução if, que executa um bloco de código se uma condição for verdadeira. Por exemplo: se x > 0 fmt.Println("x é positivo") imprime "x é positivo" se x for maior que zero.
A instrução for, que executa um bloco de código repetidamente até que uma condição seja falsa. Por exemplo: para i := 0; i imprime os números de 0 a 9.
A instrução switch, que executa um bloco de código com base no valor de uma expressão. Por exemplo: switch x case 0: fmt.Println("x é zero") case 1: fmt.Println("x é um") default: fmt.Println("x é outra coisa") imprime "x é zero" se x é 0, "x é um" se x é 1 e "x é outra coisa" caso contrário.
A instrução defer, que executa uma chamada de função no final da função atual. Por exemplo: func foo() adiar fmt.Println("Tchau") fmt.Println("Olá") imprime "Olá" e depois "Tchau" quando foo() retorna.
Matrizes e fatias
Uma matriz é uma sequência de comprimento fixo de valores do mesmo tipo. Para declarar um array, você usa a sintaxe [n]T, onde n é o tamanho e T é o tipo dos elementos. Por exemplo: var a [5]int declara um array de 5 inteiros. Você também pode inicializar uma matriz com valores usando a sintaxe .... Por exemplo: b := [3]string"vermelho", "verde", "azul" declara e atribui um array de 3 strings com os valores "red", "green" e "blue".
Para acessar ou modificar um elemento de um array, você usa a sintaxe [i], onde i é o índice do elemento. O índice começa em 0 e vai até n-1, onde n é o tamanho do array. Por exemplo: a[0] = 10 atribui o valor 10 ao primeiro elemento de a, e c := b[2] atribui o valor "azul" a c.
Uma fatia é uma sequência de comprimento variável de valores do mesmo tipo. É uma visualização de um array subjacente, o que significa que ele compartilha a mesma memória que o array. Para declarar uma fatia, você usa a sintaxe []T, onde T é o tipo dos elementos. Por exemplo: var s []int declara uma fatia de inteiros. Você também pode criar uma fatia a partir de um array existente usando a sintaxe [low:high], onde baixo e alto são os índices dos elementos a serem incluídos na fatia. Por exemplo: d := b[1:3] cria uma fatia de strings de b que contém os elementos nos índices 1 e 2 ("verde" e "azul").
Para alterar o tamanho de uma fatia, você pode usar a função append, que adiciona um ou mais elementos ao final de uma fatia e retorna uma nova fatia. Por exemplo: s = anexar(s, 1, 2, 3) adiciona os valores 1, 2 e 3 a s e atribui a nova fatia a s. Você também pode usar a função len para obter o comprimento de uma fatia. Por exemplo: n := len(s) atribui o valor 3 a n.
Mapas e estruturas
Um mapa é uma coleção de pares chave-valor que permite armazenar e recuperar valores por suas chaves. Para declarar um mapa, você usa a sintaxe map[K]V, onde K é o tipo das chaves e V é o tipo dos valores. Por exemplo: var m map[string]int declara um mapa que mapeia strings para inteiros. Você também pode inicializar um mapa com valores usando a sintaxe .... Por exemplo: n := mapa[string]int"um": 1, "dois": 2, "três": 3 declara e atribui um mapa que mapeia strings "um", "dois" e "três" para inteiros 1, 2 e 3.
Para acessar ou modificar um elemento de um mapa, você usa a sintaxe [k], onde k é a chave do elemento. Por exemplo: m["foo"] = 42 atribui o valor 42 à tecla "foo" em m, e v := n["dois"] atribui o valor 2 a v. Você também pode usar a função delete para remover um elemento de um mapa. Por exemplo: delete(n, "três") remove o par chave-valor "três": 3 de n.
Uma struct é uma coleção de campos que permite agrupar dados relacionados. Para declarar um struct, você usa a palavra-chave type seguida do nome e dos campos do struct. Por exemplo: tipo Pessoa struct nome string idade int declara um novo tipo chamado Person que é uma estrutura com dois campos: nome e idade. Você também pode inicializar uma estrutura com valores usando a sintaxe .... Por exemplo: p := Pessoanome: "Alice", idade: 25 declara e atribui uma variável chamada p do tipo Pessoa com os valores "Alice" e 25 para os campos nome e idade.
Para acessar ou modificar um campo de uma struct, você usa o . sintaxe, onde . é o nome do campo. Por exemplo: p.name = "Bob" atribui o valor "Bob" ao campo de nome de p, e a := p.age atribui o valor 25 a a.
Interfaces e métodos
Uma interface é um conjunto de métodos que define o comportamento de um tipo. Para declarar uma interface, você usa a palavra-chave type seguida do nome e dos métodos da interface. Por exemplo: type Shape interface Area() float64 Perimeter() float64 declara uma interface chamada Shape que possui dois métodos: Area e Perimeter, que retornam valores float64.
Um método é uma função associada a um tipo e pode ser chamada usando o . sintaxe. Para definir um método, você usa a palavra-chave func seguida do receptor, que é o tipo ao qual o método pertence e, em seguida, o nome e os parâmetros do método. Por exemplo: func (p Pessoa) Cumprimente() string return "Olá, " + p.nome define um método chamado Greet que pertence ao tipo Person e retorna um valor de string.
Para implementar uma interface, um tipo deve ter todos os métodos que a interface requer. Por exemplo, para implementar a interface Shape, um tipo deve ter os métodos Area e Perimeter.Aqui está um exemplo de como implementar a interface Shape para um tipo Rectangle: type Rectangle struct length float64 width float64 func (r Rectangle) Area() float64 return r.length * r.width func (r Rectangle) Perimeter() float64 return 2 * (r.length + r.width)
Para usar uma interface, você pode atribuir qualquer valor que implemente a interface a uma variável desse tipo de interface. Por exemplo: var s Forma declara uma variável chamada s do tipo Shape, que pode conter qualquer valor que implemente Shape. Você pode então chamar qualquer método que Shape tenha em s. Por exemplo: s = Retângulocomprimento: 10, largura: 5 atribui um valor Retângulo a s, e a := s.Area() chama o método Area em s e atribui o resultado a a.
Simultaneidade
Simultaneidade é a capacidade de executar várias tarefas ao mesmo tempo sem esperar que uma termine antes de iniciar outra. O Go possui suporte integrado para simultaneidade por meio de goroutines e canais. Uma goroutine é um thread leve de execução que pode ser executado simultaneamente com outras goroutines. Um canal é um mecanismo de comunicação entre goroutines que podem enviar e receber valores de um tipo especificado.
Para criar uma goroutine, você usa a palavra-chave go seguida por uma chamada de função. Por exemplo: vá foo () cria uma nova goroutine que executa foo() simultaneamente com a goroutine principal.
Para criar um canal, você usa a função make com a palavra-chave chan seguida do tipo de valores que o canal pode enviar e receber. Por exemplo: c := make(chan int) cria um novo canal chamado c que pode enviar e receber valores int.
Para enviar um valor para um canal, você usa o operador c envia o valor 1 para o canal c.
Para receber um valor de um canal, você usa o operador x := recebe um valor do canal c e o atribui a x.
Aqui está um exemplo de como usar goroutines e canais para calcular a soma de dois números simultaneamente: func sum(a int, b int, c chan int) c
Este programa cria um canal chamado c e duas goroutines que executam a função sum com diferentes argumentos. A função sum envia o resultado da adição de seus argumentos ao canal. A função principal recebe dois valores do canal e os imprime. A saída é: 7 11.
Comparar Go com outros idiomas
Python vs. Go
Python e Go são linguagens de programação populares que possuem algumas semelhanças e diferenças. Aqui estão alguns dos principais pontos de comparação:
Pitão
Ir
Digitado dinamicamente
Digitado estaticamente
interpretado
compilado
Sintaxe baseada em recuo
Sintaxe baseada em colchetes
Suporta múltiplos paradigmas (orientado a objetos, funcional, processual, etc.)
Suporta principalmente o paradigma procedural com alguns recursos funcionais e orientados a objetos
Possui suporte integrado para exceções e blocos try-except-finally
Não tem suporte integrado para exceções e usa valores de erro e mecanismo de recuperação de pânico adiado
Possui uma grande e diversificada biblioteca padrão e módulos de terceiros
Possui uma biblioteca padrão menor, mas rica, e um número crescente de módulos de terceiros
Possui um bloqueio de intérprete global (GIL) que limita a simultaneidade a um thread por vez
Não possui GIL e suporta simultaneidade por meio de goroutines e canais
Mais fácil de aprender e escrever, mas mais lento para executar e mais difícil de depurar e manter para projetos de grande escala
Mais difícil de aprender e escrever, mas mais rápido de executar e mais fácil de depurar e manter para projetos de grande escala
Tanto o Python quanto o Go têm seus pontos fortes e fracos, e a escolha de qual usar depende dos requisitos do projeto, preferência pessoal e nível de experiência. Python é mais adequado para prototipagem rápida, análise de dados, aprendizado de máquina, scripting, etc. Go é mais adequado para desenvolvimento web, simultaneidade, programação de sistemas, etc.
C vs. Ir
C e Go são linguagens de programação de baixo nível que possuem algumas semelhanças e diferenças. Aqui estão alguns dos principais pontos de comparação:
C
Ir
Digitado estaticamente
Digitado estaticamente
compilado
compilado
Sintaxe baseada em colchetes
Sintaxe baseada em colchetes
Suporta principalmente o paradigma procedural com alguns recursos orientados a objetos por meio de structs e ponteiros
Oferece suporte principalmente ao paradigma procedural com alguns recursos funcionais e orientados a objetos por meio de estruturas, interfaces e métodos
Não possui suporte integrado para simultaneidade e depende de bibliotecas externas ou chamadas de sistema para encadeamento e sincronização
Possui suporte integrado para simultaneidade por meio de goroutines e canais
Possui gerenciamento de memória manual e requer o uso de funções malloc e free para alocar e desalocar memória
Possui gerenciamento automático de memória e usa um coletor de lixo para recuperar a memória não utilizada
Possui uma pequena biblioteca padrão e um grande número de bibliotecas de terceiros para várias tarefas
Possui uma rica biblioteca padrão que fornece uma ampla gama de pacotes para tarefas comuns, como entrada/saída, rede, criptografia, teste, etc.
Mais rápido para executar, mas mais difícil de escrever, depurar e manter para projetos de grande escala
Um pouco mais lento para executar, mas mais fácil de escrever, depurar e manter para projetos de grande escala
Tanto C quanto Go têm seus pontos fortes e fracos, e a escolha de qual usar depende dos requisitos do projeto, preferência pessoal e nível de experiência. C é mais adequado para programação de baixo nível, sistemas embarcados, sistemas operacionais, etc. Go é mais adequado para desenvolvimento web, simultaneidade, programação de sistemas, etc.
Conclusão
Resumo do artigo
Neste artigo, aprendemos sobre a linguagem de programação Go, como baixá-la e instalá-la, como escrever alguns exemplos básicos de código e como compará-la com outras linguagens, como Python e C. Vimos que Go é uma linguagem simples, confiável e eficiente, com muitos recursos e vantagens que a tornam uma escolha popular para desenvolvimento web, simultaneidade e programação de sistemas. Vimos também que o Go tem alguns desafios e limitações que exigem muita atenção e prática para serem superados.
Esperamos que este artigo tenha lhe dado uma boa introdução ao Go e inspirado você a aprender mais sobre ele. Go é uma linguagem divertida e poderosa que pode ajudá-lo a criar softwares incríveis. Se você quiser se aprofundar no Go, pode conferir o site oficial: , onde você pode encontrar mais recursos, tutoriais, documentação, etc.
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre Go com respostas:
O que significa o nome "Go"?
O nome "Go" foi escolhido pelos criadores da linguagem por ser curto, fácil de digitar e sugerir movimento e ação. Também possui alguns outros significados em diferentes contextos, como o jogo de tabuleiro Go, o verbo "to go", o comando "go", etc.
Quem criou Go?
Go foi criado por Robert Griesemer, Rob Pike e Ken Thompson no Google em 2007. Eles foram motivados por sua frustração com as linguagens e ferramentas existentes para desenvolvimento de software no Google. Eles queriam criar uma linguagem que fosse simples, rápida, segura, simultânea e escalável.
Quais são algumas das vantagens do Go?
Algumas das vantagens do Go são:
É simples e conciso, sem palavras-chave ou pontuação desnecessárias.
Ele possui suporte integrado para simultaneidade, o que significa que pode executar várias tarefas ao mesmo tempo.
Possui uma rica biblioteca padrão que fornece uma ampla gama de pacotes para tarefas comuns, como entrada/saída, rede, criptografia, teste, etc.
Possui uma poderosa cadeia de ferramentas que inclui ferramentas para formatação, teste, depuração, criação de perfil, documentação, etc.
Possui um sistema modular que permite aos desenvolvedores gerenciar dependências através de módulos.
Quais são alguns dos desafios do Go?
Alguns dos desafios do Go são:
Ele não tem suporte integrado para exceções e, em vez disso, usa valores de erro e mecanismo de recuperação de pânico adiado.
Ele não tem suporte integrado para genéricos e, em vez disso, depende da geração de código ou do tipo de interface.
Ele não possui suporte integrado para herança e polimorfismo e, em vez disso, usa composição e interfaces.
Ele não tem suporte interno para sobrecarga de operador e sobrecarga de método e, em vez disso, usa nomes ou tipos diferentes.
Ele não possui suporte integrado para recursos de programação funcional, como funções de ordem superior, fechamentos, funções de filtro de redução de mapa, etc.
Quão popular é o Go?
Go é uma das linguagens de programação mais populares do mundo. De acordo com , Go classifica-se como a 9ª linguagem mais popular pelos contribuidores do repositório (com 1,9% de participação) e a 10ª linguagem mais popular pelos contribuidores de pull request (com 2,0% de participação). 0517a86e26
Comments