Linguagem Go

  • 1,202 views
Uploaded on

 

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
1,202
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
44
Comments
0
Likes
1

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Paradigmas de Linguagens de Programação Delano Oliveira Janderson Jason Luan Barbosa Natã Melo {delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br
  • 2. Agenda Introdução Valores e Tipos Armazenamento Associações Abstrações Unidades de Programa Sistemas de Tipos Sequenciadores Concorrência Conclusão PLP - Linguagem Go 2
  • 3. Introdução
  • 4. Introdução Motivação Sintaxe e Semântica Processador da Linguagem Outras Características PLP - Linguagem Go 4
  • 5. Motivação Compilada Sensação de uma linguagem dinâmica Simula Orientação a Objetos Possui Garbage Collection Multi-processamento Open-source 18a linguagem mais usada no mundo segundo o site da Tiobe PLP - Linguagem Go 5
  • 6. Sintaxe e Semântica Go reúne características sintáticas de várias linguagens Possui uma Sintaxe simples e intuitiva A sintaxe é descrita por uma Gramática (Extended Backus-Naur Form) Semântica Operacional PLP - Linguagem Go 6
  • 7. Processador da Linguagem Compilador: gccgo (6g, 6l, 8g, 8l) Código Fonte *.8 ou *.6 Executável PLP - Linguagem Go 7
  • 8. Outras Características Criada pela Google e lançada em novembro de 2009 Equipe: Robert Griesemer, Rob Pike e Ken Thompson PLP - Linguagem Go 8
  • 9. Valores & Tipos
  • 10. Valores & Tipos Valores  Tipos  Boolean  Primitivos  Numérico  Compostos  String  Recursivo  Array  Struct  Checagem de Tipos  Equivalência de Tipos  Ponteiros  Princípio da Completude  Abstração de função e  Expressões procedimento  Mapa  Channel PLP - Linguagem Go 10
  • 11. Valores else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 11
  • 12. Valores Númericos Arrays Abstração de Função else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Abstração de Procedimento Ponteiro Booleanos Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 12
  • 13. Tipos Primitivos var barra string = "===== “ var contagemEmpate int = 0 var travou bool = false var porcentagem float = 10.5 Boolean – Representa o conjunto de valores booleanos Numeric – Representa o conjunto de valores inteiros ou valores de ponto- flutuante  uint(8, 16, 32, 64), int(8, 16, 32, 64), float(32, 64), complex(64, 128) String – Array de bytes. Imutável PLP - Linguagem Go 13
  • 14. Tipos Compostos Produtos Cartesianos : Structs type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 14
  • 15. Tipos Compostos Produtos Cartesianos : Structs [][]*Peca x int type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 15
  • 16. Tipos Compostos Tipos Recursivos: Structs type Node struct { valor Tupla next *Node }  Implementados através de ponteiros. Go não dá suporte:  União Disjunta  Conjuntos Potência PLP - Linguagem Go 16
  • 17. Checagem de Tipos Go é estaticamente e fortemente tipada. func main (){ var nome string = "plp" nome = 18 } prog.go:6: cannot convert 18 to type string prog.go:6: cannot use 18 (type int) as type string in assignment func main (){ Erro ao tentar Fortemente dez_decimal := 10.0 var dez int = dez_decimal compilar!!! } prog.go:6: cannot use dez_decimal (type float) as type int in assignment PLP - Linguagem Go 17
  • 18. Equivalência de Tipos Go dá suporte a equivalência nominal package main type Peca struct {cor int, dama bool} type Tupla struct {tamanho int,comida bool} func (peca *Peca) EhDama () (bool){ return peca.dama } func main (){ var tupla *Tupla = new(Tupla) Erro ao tentar tupla.EhDama() compilar!!! } prog.go:15: tupla.EhDama undefined (type Tupla has no field EhDama) Go não dá suporte a equivalência estrutural! PLP - Linguagem Go 18
  • 19. Princípio da Completude Go quebra o princípio da completude de tipo.  É necessário o uso do tipo File para manipular arquivos persistentes.  Funções só podem retornar valores primitivos ou ponteiros. func (tabuleiro *Tabuleiro) IsZerou (cor int) bool if (…){ return false } return true } PLP - Linguagem Go 19
  • 20. Expressões Literais: Valores dos tipos bool, int, uint, float, string Agregados: array, maps, structs Funções Go não dá suporte a:  Expressões Condicionais  Expressões Iterativas PLP - Linguagem Go 20
  • 21. Armazenamento
  • 22. Armazenamento Variáveis e Atualização  Tipos de Comandos Arrays  Skip Semântica de Cópia x  Atribuição Semântica de Referência  Chamada de Variáveis procedimento  Locais e Globais  Comandos  Heap  Sequencial  Persistentes  Colateral  Condicional  Expressões com Efeitos Colaterais PLP - Linguagem Go 22
  • 23. Variáveis e Atualização Os valores armazenáveis (storables) são os valores dos tipos primitivos e ponteiros Variáveis Temporárias  Todas as variáveis, com exceção do tipo File Variáveis Persistentes  Em Go, as variáveis persistentes são do tipo File PLP - Linguagem Go 23
  • 24. Variáveis e Atualização Go dá suporte a atualização seletiva e atualização total var posicaoFinal Coordenada; Seletiva posicaoFinal.x = 1; posicaoFinal.y = 2; var posicaoInicial Coordenada; Total posicaoInicial = posicaoFinal; PLP - Linguagem Go 24
  • 25. Arrays Go dá suporte a Arrays Estáticos. Os arrays possuem tamanho fixo e não podem armazenar valores de tipos diferentes. func (tabuleiro *Tabuleiro) GetPecas (cor int) ([12]*Tupla){ var pecas [12] *Tupla; (...) return pecas; } PLP - Linguagem Go 25
  • 26. Semântica de Cópia x Semântica de Referência Semântica de cópia – utilizada para valores de qualquer tipo. Semântica de Referência – utilizada apenas para ponteiros. var posicao1 Coordenada; posicao1.x = 1; posicao1.y = 2; var posicao2 *Coordenada; var posicao3 *Coordenada; Por Referência posicao2 = &posicao1; posicao3 = posicao2; posicao3.x = 5; posicao3.y = 5; Por Cópia PLP - Linguagem Go 26
  • 27. Variáveis Locais e Globais Variáveis Globais são declaradas da seguinte forma: var + nomeVariavel + tipo Para variáveis locais podem ser utilizados açúcares sintático var jogadorDaVez string = “tabuleiro” Variável Global func main() { tamanho := 10; Açúcar if (...){ Variáveis LocaisSintático var numBombas = 15; } } PLP - Linguagem Go 27
  • 28. Variáveis Heap Variáveis podem ser declaradas a partir da palavra reservada new. Não existe um mecanismo para o programador destruir as variáveis. Go possui Garbage Collection. Alocação de memória var tabuleiro_jogo *Tabuleiro = new (Tabuleiro) PLP - Linguagem Go 28
  • 29. Variáveis persistentes São do tipo “File” oldfile := "text.txt" newfile := "text2.txt" doc, _ := ioutil.ReadFile(oldfile) ioutil.WriteFile(newfile,doc,0644) PLP - Linguagem Go 29
  • 30. Skip e Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Não há atribuição múltipla em Go. PLP - Linguagem Go 30
  • 31. Skip e Atribuição Skip usado para separar expressões Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Açúcar sintático Atribuição simultânea Não há atribuição múltipla em Go. PLP - Linguagem Go 31
  • 32. Chamada de Procedimentos Chamada de procedimento peca := new (Peca) peca.SetCor(Preto) //... func (peca *Peca) SetCor (cor int) { peca.cor = cor } Procedimento PLP - Linguagem Go 32
  • 33. Comando Sequencial meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; meuTabuleiro.n = 0 Separados por ponto-e-vírgula, meuTabuleiro.m = 0 ou por quebra de linha. meuTabuleiro.ganhou = falseComando Colateral Não existem comandos colaterais. PLP - Linguagem Go 33
  • 34. Comando Condicional Go dá suporte através de: if ,else e switch. var jogada int; if (ehHumano) { var pos [2]int = JogarHumano(); jogada = tabuleiro.Jogada(pos); } else { var pos [2]int = JogarAutomatico(); jogada = tabuleiro.Jogada(pos); } var aux string; switch opcao{ case 1: aux = "Jogar“ case 2: aux = "Ajuda" case 3: aux = "Fechar" } PLP - Linguagem Go 34
  • 35. Comandos Iterativos Iteração definida for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS; i++ { nodeAtual = new(Node); nodeAtual.SetValor(tuplaAtual); //... } Iteração indefinida Palavra reservada for for i > 0 { funcionando como o var a int = Random(n); comando while em var b int = Random(n); outras linguagens. //... } PLP - Linguagem Go 35
  • 36. Associações
  • 37. Associações Entidades Associáveis  Comando Bloco Escopo  Expressão Bloco Estrutura de Blocos  Princípio da Qualificação Visibilidade Declarações  Definição  Declaração de Tipo  Declaração de Variável  Declarações Colaterais  Declarações Sequenciais  Declarações Recursivas PLP - Linguagem Go 37
  • 38. Entidades Associáveis Valores primitivos e compostos Abstrações de funções e procedimentos Variáveis e Tipos meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; var Numero int = calculaNumDeMinas(n); const( MAX_MOVIMENTOS int = 50); PLP - Linguagem Go 38
  • 39. Escopo const s = 2; func incremento ( d int ) int { return d∗s; } func executaIncremento ( valor int ) int { const s = 3; return incremento ( valor ); } Saída: 10 func main () { fmt.Println( executaIncremento(5) ); } Em Go, o corpo de um bloco é avaliado no ambiente em que foi definido (associação estática). PLP - Linguagem Go 39
  • 40. Blocos: Estrutura e Visibilidade var tamanhoTabuleiro int = 10; for { var tamanhoTabuleiro = 15; for { var tamanhoTabuleiro = 20; imprime 20 fmt.Println( tamanhoTabuleiro ); break; } imprime 15 fmt.Println( tamanhoTabuleiro ) ; break; } imprime 10 fmt.Println( tamanhoTabuleiro ); Estrutura: blocos aninhados. Visibilidade: variáveis declaradas em blocos de escopo internos não são visíveis a blocos de escopo externos. PLP - Linguagem Go 40
  • 41. Definição As definições em Go podem ser de tipo, abstração de funções, abstração de procedimentos, variáveis, constantes. const( MAX_MOVIMENTOS int = 50) func Jogada() (int,int) { //… } Constante var posJogada; var posX *int; Abstração de função var posAux *int; Variáveis PLP - Linguagem Go 41
  • 42. Declaração de Tipo type Peca struct {  Go dá suporte a declaração de tipos cor int; dama bool; através da palavra reservada type. } O tipo Peca sendo declarado.Declaração de Variável var vertical string = "Coordenada Vertical: “; var valor int = 1; var decimal float = 1.0; PLP - Linguagem Go 42
  • 43. Declaração sequencial  Como a maioria das linguagens imperativas, Go dá suporte à declaração sequencial. tamanhoMaiorCaminho := 0; tamanhoCaminhoTupla := 0; var pilha *Node = nil; var caminhoAtual [MAXIMO_CAMINHOS] *Node;Declarações Colaterais Go não dá suporte a este tipo de declaração. PLP - Linguagem Go 43
  • 44. Declaração recursiva  Go dá suporte a declaração recursiva.func TomadaMaximaPeca(tabuleiro *Tabuleiro, posX int, posY int, cor int)([MAXIMO_CAMINHOS] *Node, int) { caminhos := tabuleiro.GetOpcoesComida(posX, posY, cor); for ;pilha != nil; { caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp,tuplaAtual.FicarX, tuplaAtual.FicarY, cor); return caminhosMaximos, tamanhoMaiorCaminho;} Chamada recursiva PLP - Linguagem Go 44
  • 45. Comando bloco Go dá suporte a comando bloco. func ( pilha ∗Node ) PrintValorProximo( ) { Println ( "|" , pilha.GetValor( ) , "|" ); next := pilha.GetNext( ); Println(next.GetValor()); } Declaração que é usada apenas pra executar o comando PLP - Linguagem Go 45
  • 46. Expressão bloco Go dá suporte a expressão bloco. func (peca *Peca) GetValue(peca2 *Peca)(bool){ valor1 := peca.EhDama() valor2 := peca2.EhDama() return valor1 && valor2 } Declarações usadas apenas para avaliar a expressão. PLP - Linguagem Go 46
  • 47. Princípio da Qualificação Go não viola o princípio da qualificação, pois é possível realizar qualquer computação dentro de um bloco. func (pilha *Node) GetNext() (*Node, *Tupla){ next := pilha.GetNext() valor := next.GetValor() func nome(){ //Corpo da funcao } return next, valor } Um bloco dentro do outro. PLP - Linguagem Go 47
  • 48. Abstrações
  • 49. Abstrações Tipos de Abstrações  Argumentos  Abstração de Função  Passagem de Parâmetros  Abstração de  Princípio da Procedimento Correspondência  Ordem de Avaliação Princípio da Abstração Parâmetros PLP - Linguagem Go 49
  • 50. Abstração de Função Go dá suporte a abstrações de funções através da palavra reservada func. A presença do retorno caracteriza a abstração de função. func calculaNumDeMinas(tamanho int) int{ numeroDeBombas := int(tamanho*tamanho*20/100); if (numeroDeBombas%2 == 0) { numeroDeBombas += 1; } //m sempre impar if (tamanho <= 10) { numeroDeBombas += 2; } return numeroDeBombas; } PLP - Linguagem Go 50
  • 51. Abstração de Procedimento Go usa a mesma palavra reservada para caracterizar uma Abstração de Procedimento, como em Abstrações de Funções. (func) A diferença que caracteriza a Abstração de Procedimento é a falta do retorno. func inicializarJogo() { tabuleiro.ReiniciaTabuleiro(); ehHumano = true; } PLP - Linguagem Go 51
  • 52. Princípio da abstração  Go não viola o princípio da abstração, pois é possível construir abstração sobre qualquer categoria sintática da linguagem, como por exemplo: variáveis, funções e procedimentos. PLP - Linguagem Go 52
  • 53. Parâmetros Como Go é fortemente tipada, os parâmetros devem possuir tipos definidos. Podem ser de qualquer tipo. type Peca struct { cor int dama bool } func (peca *Peca) EhDama () (bool){ return peca.dama } PLP - Linguagem Go 53
  • 54. Passagem de Parâmetros Em Go a passagem de parâmetros é por cópiavalor. func Inverter (i int) int { if(i != 0) { return 0 } return 1 } Go não dá suporte a passagem de parâmetros por referência, mas simula com o uso de ponteiros. func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() } Ponteiro PLP - Linguagem Go 54
  • 55. Princípio da Correspondência Go viola o princípio da correspondência, pois não existe um mecanismo de passagem de parâmetro correspondente a definição de constante. Código abaixo não é compilável.const constante = 10;func funcao ( c const ) const { return c ;}func main ( ) { fmt.Println ("Imprimir constante:" , funcao ( constante ) ) ;} Dá erro de sintaxe PLP - Linguagem Go 55
  • 56. Ordem de Avaliação  Eager Evaluation var p int; func main () { p = 3; print ( p ) } Saída: func print ( n int ) { Println(n); 3 p = 100; 3 Println(n); } PLP - Linguagem Go 56
  • 57. Unidades de Programa
  • 58. Unidades de Programa Pacotes Tipos Abstratos de Dados Objetos e Classes Unidades Genéricas PLP - Linguagem Go 58
  • 59. Pacotes As funções e variáveis globais que começam com letra Maiúscula serão visíveis para quem importar esse pacote. Caso contrário, a função fica com visibilidade privada.package tabuleiro//...func (meuTabuleiro *Tabuleiro) Ganhou() bool { return meuTabuleiro.ganhou;} Funções visíveisfunc (meuTabuleiro *Tabuleiro) AlguemGanhou(){ meuTabuleiro.ganhou = true;}func calculaNumDeMinas(tamanho int) int{ //... Função com return numeroDeBombas; visibilidade privada}/ PLP - Linguagem Go 59
  • 60. Tipo Abstrato de Dados package tabuleiro import (. "fmt"; . "./pecaPkg"; . "./util") type Tabuleiro struct {matriz [8] [8] *Peca} func (tabuleiro *Tabuleiro) SetPecaDama (x int, y int){ tabuleiro.matriz[x][y].SetDama(true) } //... PLP - Linguagem Go 60
  • 61. Objetos e Classes  Go não tem Objetos e Classes, porém, simula-os através de structs e funções ligadas a esses tipos. type Node struct { valor Tupla next *Node } //... func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() }Unidades Genéricas  Go não dá suporte a unidades genéricas. PLP - Linguagem Go 61
  • 62. Sistemas de Tipos
  • 63. Sistema de Tipos Monomorfismo Sobrecarga Polimorfismo Paramétrico Polimorfismo por Inclusão Interfaces Coerção PLP - Linguagem Go 63
  • 64. Monomorfismofunc (meuTabuleiro *Tabuleiro) Ganhou() bool{ return meuTabuleiro.ganhou;}func (meuTabuleiro *Tabuleiro) AlguemGanhou() { meuTabuleiro.ganhou = true; As abstrações definidas pelo} programador, em Go, são monomórficas. Toda entidade tem um tipo específico associado.Println("---------------------------");Print("Linha: ");Println(posMaquina[0]+1);Print("Coluna: ");Println(posMaquina[1]+1); Mas, algumas abstraçõesPrintln("---------------------------"); embutidas (built-in) não são monomórficas. PLP - Linguagem Go 64
  • 65. Sobrecarga Go dá suporte a sobrecarga de operadores built-in. Entretanto, não dá suporte a sobrecarga de operaçoes. (Operadores: +, -, e outros)var barra string = "===== “;//...if (tabuleiro_jogo.IsZerou (jogador1.GetCor())){ Println(barra + "Jogador", jogador2.GetCor() + 1, "VENCEU! PARABÉNS", barra); break;}//... Para tipos da própria linguagem, um único identificador ou operador pode denotar diferentes abstrações. PLP - Linguagem Go 65
  • 66. Polimorfismo por Inclusão type Natural int; type Inteiro int; var x Natural = 1; var y Inteiro = -1; Println(x+y); //input.go:10: invalid operation: x + y (type Natural + Inteiro) Go não tem tipos que contenham subtipos que herdam operações aplicáveis a valores desses tipos. PLP - Linguagem Go 66
  • 67. Polimorfismo Paramétricofunc polimorfismoParametrico(a int64, b int64) { Println(a); Println(b);}func main() { var x int8 = 1; var y int8 = 2; polimorfismoParametrico(x, y);}//input.go:13: cannot use x (type int8) as type int64 in function argument//input.go:13: cannot use y (type int8) as type int64 in function argument Go não dá suporte a polimorfismo paramétrico. PLP - Linguagem Go 67
  • 68. Interfacepackage mainimport . "fmt";func main(){ jogador := new(Jogador); jogador.nome = "iza";  Go simula peca := new(Peca); peca.cor = "preto"; o uso de imprimir(jogador); imprimir(peca); interface} com o tipotype printer interface { Print(); } “interface”.func (p *Peca) Print() { Println(p.cor); }func (j *Jogador) Print() { Println(j.nome); }func imprimir (p printer) { p.Print(); }type Peca struct { cor string; }type Jogador struct { nome string; } PLP - Linguagem Go 68
  • 69. Coersãofunc Random(n int) int { sec, nsec, err := Time(); if err != nil { Seed(int64(n)); } else { Seed(int64(n)+(sec*1e9+nsec)); } return int(Int63n(int64(n)))} Não há mapeamento implícito de valores de um tipo para valores de um outro tipo. Em substituição às coerções, são adotados casts. PLP - Linguagem Go 69
  • 70. Sequenciadores
  • 71. Sequenciadores Desvios Incondicionais Escapes Exceções PLP - Linguagem Go 71
  • 72. Desvios Incondicionais I: Println(“Digite a dimensao: (N)"); var tam int = ReadInt(); if ( tam < 20 && tam > 4) { goto L; } Println(“N fora do limite [4,20]."); goto I; L: geraTabuleiro(tam); Para fazer Desvios Incondicionais usamos a palavra reservada “goto”  Só podemos fazer desvios incondicionais dentro do escopo da abstração de função. (Não podemos ir para pontos mais externos do programa). PLP - Linguagem Go 72
  • 73. Escapefor i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { Iteração afetada if (tabuleiro[i][j] == 9) { pelo escape Println("Achou bomba na linha ", i+1); break; } }}  Go dá suporte a escape através da palavra reservada“break” e “continue”.  Escape não rotulado apenas finaliza a iteração corrente. PLP - Linguagem Go 73
  • 74. Escape rotulado busca: for i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { if (tabuleiro[i][j] == 9) { Println("Achou bomba na linha ", i+1); break busca; } } } Rótulo  Go dá suporte a escape rotulado através da palavra reservada break mais o rótulo. PLP - Linguagem Go 74
  • 75. Exceções  Go não dá suporte a exceções. PLP - Linguagem Go 75
  • 76. Concorrência
  • 77. Concorrênciavar canal = make(chan int);func main() { go rotina1(); go rotina2(); Channel}func rotina1(){ Goroutines var i int = 0; for i = 0; i <= 100; i++ {  Go dá suporte a concorrência canal <- i; através de goroutines. }}  A comunicação entre osfunc rotina2(){ processos concorrentes é for { através de channel. msg := <- canal; Println(msg); if(msg == 100){ break; } }} PLP - Linguagem Go 77
  • 78. Spin-Lockfunc acquire(){ for(usandoRecurso){ } usandoRecurso = true; Flag}func relinquish(){ usandoRecurso = false;}  O flag é uma variável global.  Assim permitimos que apenas umafunc rotina1(){ acquire(); rotina tenha acesso ao recurso. //regiao critica relinquish(); Rotinas}func rotina2(){ acquire(); //regiao critica relinquish();} PLP - Linguagem Go 78
  • 79. Conclusão
  • 80. PLP - Linguagem Go 80
  • 81. PLP - Linguagem Go 81
  • 82. Referências
  • 83. Referências http://alovasconcelos.net/ http://golang.org http://tutorial.danielmazza.info/go RAMALHO, Franklin. Notas de Aula da disciplina Paradigmas de Linguagens de Programação, 2010. http://forum.zwame.pt/showthread.php?t=348920 PLP - Linguagem Go 83