Você está na página 1de 8

Go (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.


Go é uma linguagem de programação criada pela Google e lançada em
código livre em novembro de 2009. É uma linguagem compilada e Go
focada em produtividade e programação concorrente,[4] baseada em
trabalhos feitos no sistema operacional chamado Inferno.[5] O projeto Paradigma compilada, concorrente,
imperativa, estruturada
inicial da linguagem foi feito em setembro de 2007 por Robert
Griesemer, Rob Pike e Ken Thompson.[4] Atualmente, há
Surgido em 2009[1]
implementações para Windows, Linux, Mac OS X e FreeBSD.[3] Última versão 1.12 (25 de fevereiro de 2019)
Criado por Robert Griesemer, Rob
Pike, and Ken Thompson[1]
Estilo de Estática[2]
Índice tipagem:

Descrição
Compiladores gc, gccgo[3]

Implementações Influenciada C, Pascal, Modula,


por Oberon, Newsqueak,
Hello World Limbo[4]
Orientado a Objeto? Licença: BSD[3]
Funções Extensão do .go
Exceções arquivo:
PANIC Página oficial golang.org (https://golang.
RECOVER org/)
DEFER
Métodos
Interface
Goroutines
Formatação automática de código
Exemplo para o gofmt
Exemplos
Disputa sobre o nome
Histórico de versões
Ver também
Referências
Ligações externas

Descrição
A sintaxe de Go é semelhante a C e suas declarações são feitas com base em Pascal limpo; uma variação é a declaração de tipos,
a ausência de parênteses em volta das estruturas for e if. Possui coletor de lixo. Seu modelo de concorrência é baseado no CSP
de Tony Hoare,[4] além de possuir características do cálculo pi, como passagem por canal.
Algumas funcionalidades ausentes são tratamento de exceção, Herança, programação genérica, assert e sobrecarga de
métodos.[4] Os autores expressam abertura para discutir programação genérica, mas argumentam abertamente contra asserções e
defendem a omissão de herança de tipos em favor da eficiência.[4] Ao contrário de Java, vetores associativos são parte intrínseca
da linguagem, assim como strings.

Implementações
Atualmente, há dois compiladores para Go. 6g e ferramentas complementares - conhecidos em conjunto como gc - são escritos
em C, usando yacc e bison para análise sintática. Além do gc, há o gccgo, um compilador de Go com front-end C++ (utilizando
um analisador sintático descendente recursivo) associado ao back-end padrão do GCC.[2]

Hello World
Abaixo, segue-se o Programa Olá Mundo em Go:

package main

import "fmt"

func main() {
fmt.Printf("Olá, Mundo!\n")
}

Orientado a Objeto?
É possível programar orientado a objetos, mas não da forma mais comum, pois Go não utiliza classes e sim estruturas. Na
orientação a objetos, são criados métodos sem classes, interface sem hierarquia, e reutilização de código sem herança.

type Pessoa struct {

Nome string

idade int

package main

import "fmt"

type Animal struct{

func (a Animal) Comer() {


fmt.Println("Comendo")
}

type MembroFamilia struct{

}
func (fm MembroFamilia) Nome() {
fmt.Println("Meu nome não é Johnny")
}
type Cachorro struct {
Animal // Struct incorporada/embedada
MembroFamilia // Struct incorporada/embedada
}
func main() {
d := Cachorro{}
d.Comer() // Printa "Comendo"
d.Nome() // Printa "Meu nome não é Johnny"
}
Funções
Go também possui funções como outras linguagem, as funções podem retornar valores únicos, múltiplos e até mesmo retornar
outra função.

package main

import "fmt"

func somar (a int ,b int) int{


return a + b
}

func main(){
res := somar(1, 2)
fmt.println("1 + 2 = ", res)
}

Exemplo de múltiplos retornos:

package main

import "fmt"

func atribuiValor (int, int){


return 15,22
}

func main(){
//Aqui queremos atribuir dois valores nas
//variaveis a e b
a, b:= atribuiValor()
fmt.println("A = ", a)
fmt.println("B = ", b)

//Podemos também apenas escolher um valor


//a ser retornado
_, c := atribuiValor()
fmt.println("C = ", c)
}

Em Go uma função pode receber um numero variável de parâmetros, ou seja, não se sabe ao certo quantos parâmetros serão
recebidos.

package main

import "fmt"

func variaveis(nums ...int)soma{


//Imprimindo os valores recebidos
fmt.Print(nums," ")
total := 0

for _, num := range nums{


//Fazendo a soma dos valores recebidos
total += num
}
fmt.println("Total = ", num)
}

func main(){
variaveis(1,4,7)// Resultado impresso "12"
variaveis(4,2)// Resultado impresso "6"

//Pode se enviar um vetor como parametro


v := []int{0,1,2,3,4,5,6}// Resultado impresso "21"
variaveis(v...)
}

Funções também podem receber outras funções como parâmetros.


package main

import "fmt"

func intSeq() func() int {


i := 0
return func() int {
i += 1
return i
}
}

func main() {
nextInt := intSeq() // Aqui "nextInt" recebe como valor a função intSeq
fmt.Println(nextInt()) // Printa 1
fmt.Println(nextInt()) // Printa 2
fmt.Println(nextInt()) // Printa 3
newInts := intSeq()
fmt.Println(newInts()) // Printa 1
}

Exceções
O Go (ao contrário do Java) não possui exceções como try / catch / finally blocks. Ele possui tratamento estrito de erros com
funções chamadas de panic e recover e uma instrução chamada defer.

PANIC
Um uso comum de pânico é abortar se uma função retornar um valor de erro que não sabemos como (ou queremos) manipular.
Executar este programa fará com que ele entre em pânico, imprima uma mensagem de erro e rastreie goroutine e saia com um
status diferente de zero.

package main
import "os"
func main() {
panic("a problem")

_, err := os.Create("/tmp/file")
if err != nil {
panic(err)
}
}

RECOVER
É uma função embutida que recupera o controle de uma gorout em pânico. Recuperar só é útil dentro de funções diferidas.
Durante a execução normal, uma chamada para recuperar retornará nula e não terá outro efeito. Se a gorout atual estiver em
pânico, uma chamada para recuperar capturará o valor dado ao pânico e retomará a execução normal.

DEFER
Um defer empurra uma chamada de função para uma lista. A lista de chamadas salvas é executada após a função circundante
retornar. Adiar é comumente usado para simplificar funções que executam várias ações de limpeza.

package main
import "fmt"
import "os"

func main() {
f := createFile("/tmp/defer.txt")
defer closeFile(f)
writeFile(f)
}
func createFile(p string) *os.File {
fmt.Println("creating")
f, err := os.Create(p)
if err != nil {
panic(err)
}
return f
}
func writeFile(f *os.File) {
fmt.Println("writing")
fmt.Fprintln(f, "data")
}
func closeFile(f *os.File) {
fmt.Println("closing")
f.Close()
}

Métodos
Go suporta métodos definidos em tipos struct. Métodos podem ser definidos para qualquer tipo de receptor ponteiro ou valor. Go
trata automaticamente conversões entre valores e ponteiros para métodos de chamada. Você pode querer usar um ponteiro do tipo
receptor para evitar a cópia de um método de chamada ou para permitir que o método faça mutação da estrutura recebida.

package main
import "fmt"
type rect struct {
width, height int
}

func (r *rect) area() int {


return r.width * r.height
}

func (r rect) perim() int {


return 2*r.width + 2*r.height
}
func main() {
r := rect{width: 10, height: 5}
fmt.Println("area: ", r.area()) // Printa area: 50
fmt.Println("perim:", r.perim()) // Printa perim: 30
rp := &r
fmt.Println("area: ", rp.area()) // Printa area: 50
fmt.Println("perim:", rp.perim()) // Printa perim: 30
}

Interface
Interface nada mais é que um conjunto de métodos.

package main
import "fmt"
import "math"

type geometria interface {


area() float64
perim() float64
}

type quadrado struct {


largura, altura float64
}

type círculo struct {


raio float64
}

func (q quadrado) area() float64 {


return q.largura * q.altura
}

func (q quadrado) perim() float64 {


return 2*q.largura + 2*q.altura
}

func (c círculo) area() float64 {


return math.Pi * c.raio * c.raio
}

func (c círculo) perim() float64 {


return 2 * math.Pi * c.raio
}

func medir(g geometria) {


fmt.Println(g) // Printa os valores da forma geometrica recebida ex: quadrado = altura e
largura
fmt.Println(g.area()) // Printa a area da forma recebida
fmt.Println(g.perim()) // Printa o perimetro da forma recebida
}
func main() {
q := quadrado{largura: 3, altura: 4}
c := círculo{raio: 5}
medir(q)
medir(c)
}

Goroutines
Goroutine é uma forma de implementação paralela, o comando usado é go, ele passa como parâmetro uma função para que ela
seja executada em paralelo.

package main

import "fmt"
func f(from string) {
for i := 0; i <3; i++{
fmt.Println(from,":",i)
}
}
func main() {
f("direct")
go f("goroutine") // Será executado por uma thread
go func(msg string) { // Será executado por outra thread
fmt.Println(msg)
}("going")
var input string
fmt.Scanln(&input)
fmt.Println("done")
}

Formatação automática de código


A comunidade Go considera muito importante o uso da ferramenta 'gofmt' para realizar a formatação do código-fonte uniforme e
automaticamente. [6][7]

“ O estilo do gofmt não é o favorito de ninguém, mas gofmt é o favorito de todos.



—Rob Pike

Exemplo para o gofmt


Vide abaixo um arquivo mal formatado:

package main

import "fmt"
func main() {
fmt.Printf("Olá, Mundo!\n")
}

Para aplicar o 'gofmt' em um arquivo chamado 'main.go' basta executar o seguinte comando:

gofmt -w main.go

Agora vide abaixo o mesmo arquivo corrigido pelo 'gofmt':

package main

import "fmt"

func main() {
fmt.Printf("Olá, Mundo!\n")
}

Exemplos
Exemplo de uma implementação do echo do Unix:[8]

package main

import (
"os"
"flag" // analisador sintático da linha de comando
)

var omitNewline = flag.Bool("n", false, "don't print final newline")

const (
Space = " "
Newline = "\n"
)

func main() {
flag.Parse() // escaneia a lista de argumentos e configura as bandeiras
var s string = ""

for i := 0; i < flag.NArg(); i++ {


if i > 0 {
s += Space
}

s += flag.Arg(i)
}

if !*omitNewline {
s += Newline
}

os.Stdout.WriteString(s)
}

Disputa sobre o nome


Poucos dias após o lançamento da linguagem, Fancis McCabe, desenvolvedor da linguagem chamada Go!, solicitou uma
mudança de nome da linguagem do Google, para evitar confusões. McCabe criou Go! em 2003, mas não registrou o nome.[9]

Histórico de versões
Go foi criado em 2009 e desde então vem recebendo muitas atualizações, sendo sua ultima em 25 de Fevereiro de 2019, a versão
Go 1.12, veja mais informaçoes sobre suas versoes anteriores em TimeLineGo (https://cdn.knightlab.com/libs/timeline3/latest/em
bed/index.html?source=16G9Wo-6UiEA6d18ew7d4iTVhi_yPxuAoXTYyva1XAPo&font=Default&lang=en&initial_zoom=2&h
eight=650).

Ver também
Lista de linguagens de programação
Rust (linguagem de programação)

Referências
1. Della Valle, James (12 de novembro de 2009). «Google apresenta linguagem GO» (http://info.abril.com.br/noticia
s/ti/google-apresenta-linguagem-go-12112009-34.shl). INFO Online. Editora Abril. Consultado em 12 de
novembro de 2009
2. «FAQ» (https://golang.org/doc/faq) (em inglês). Consultado em 12 de novembro de 2009
3. «Installing Go» (https://golang.org/doc/install.html) (em inglês). Consultado em 14 de setembro de 2012
4. «Language Design FAQ» (https://golang.org/doc/faq) (em inglês). Consultado em 9 de julho de 2016
5. «5.c - go - Project Hosting on Google Code» (https://code.google.com/p/go/source/browse/src/libmach/5.c).
Consultado em 12 de novembro de 2009
6. «go fmt your code» (https://blog.golang.org/go-fmt-your-code) (em inglês). Consultado em 30 de julho de 2019
7. «Gofmt knows best» (http://wordaligned.org/articles/gofmt-knows-best) (em inglês). Consultado em 30 de julho
de 2019
8. «A Tutorial for the Go Programming Language» (https://golang.org/doc/go_tutorial.html) (em inglês). Consultado
em 12 de novembro de 2009
9. Claburn, Thomas (11 de novembro de 2009). «Google 'Go' Name Brings Accusations Of 'Evil' » (http://www.infor
mationweek.com/news/software/web_services/showArticle.jhtml?articleID=221601351). InformationWeek (em
inglês). United Business Media. Consultado em 12 de novembro de 2009

Este artigo foi inicialmente traduzido do artigo da Wikipédia em inglês, cujo título é «Go (programming
language)», especificamente desta versão (https://en.wikipedia.org/w/index.php?title=Go_(programming_langua
ge)&oldid=325535804).
Este artigo incorpora material do tutorial oficial de Go Let's Go (https://golang.org/doc/go_tutorial.html), que é
licenciado sob Creative Commons Attribution 3.0 .

Ligações externas
Página oficial (https://golang.org/) (em inglês)
Go (https://github.com/golang/go) no GitHub
The Go Playground (https://play.golang.org/) (em inglês) - experimente Go online

Obtida de "https://pt.wikipedia.org/w/index.php?title=Go_(linguagem_de_programação)&oldid=55871322"

Esta página foi editada pela última vez às 22h05min de 30 de julho de 2019.

Este texto é disponibilizado nos termos da licença Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY-SA 3.0) da
Creative Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte as condições de
utilização.