Paradigmas de Linguagens de

Programação

Delano Oliveira
Janderson Jason
Luan Barbosa
Natã Melo

{delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br

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
Introdução
Introdução
 Motivação
 Sintaxe e Semântica
 Processador da Linguagem
 Outras Características

PLP - Linguagem Go
4
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
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
Processador da Linguagem
 Compilador: gccgo

 (6g, 6l, 8g, 8l)

Código Fonte *.8 ou *.6 Executável

PLP - Linguagem Go
7
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
Valores & Tipos
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
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
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
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
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
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
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
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
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
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
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
Armazenamento
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
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
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
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
 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
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 Locais
Sintático var numBombas = 15;
}
}

PLP - Linguagem Go
27
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
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
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
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
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
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 = false

Comando Colateral
 Não existem comandos colaterais.

PLP - Linguagem Go
33
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
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
Associações
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
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
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
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
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
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
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
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
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
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
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
Abstrações
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
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
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
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
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
Passagem de Parâmetros
 Em Go a passagem de parâmetros é por cópia\valor.

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
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
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
Unidades de Programa
Unidades de Programa
 Pacotes
 Tipos Abstratos de Dados
 Objetos e Classes
 Unidades Genéricas

PLP - Linguagem Go
58
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íveis

func (meuTabuleiro *Tabuleiro) AlguemGanhou(){

meuTabuleiro.ganhou = true;
}

func calculaNumDeMinas(tamanho int) int{

//... Função com
return numeroDeBombas; visibilidade privada
}/

PLP - Linguagem Go
59
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
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
Sistemas de Tipos
Sistema de Tipos
 Monomorfismo
 Sobrecarga
 Polimorfismo Paramétrico
 Polimorfismo por Inclusão
 Interfaces
 Coerção

PLP - Linguagem Go
63
 Monomorfismo
func (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ções
Println("---------------------------"); embutidas (built-in) não
são monomórficas.

PLP - Linguagem Go
64
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
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
Polimorfismo Paramétrico
func 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
Interface
package main
import . "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 tipo
type 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
Coersão
func 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
Sequenciadores
Sequenciadores
 Desvios Incondicionais
 Escapes
 Exceções

PLP - Linguagem Go
71
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
Escape
for 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
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
Exceções

 Go não dá suporte a exceções.

PLP - Linguagem Go
75
Concorrência
Concorrência
var 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 os
func rotina2(){ processos concorrentes é
for { através de channel.
msg := <- canal;
Println(msg);
if(msg == 100){
break;
}
}
}

PLP - Linguagem Go
77
Spin-Lock
func acquire(){
for(usandoRecurso){
}
usandoRecurso = true;
Flag
}
func relinquish(){
usandoRecurso = false;
}  O flag é uma variável global.
 Assim permitimos que apenas uma
func rotina1(){
acquire();
rotina tenha acesso ao recurso.
//regiao critica
relinquish(); Rotinas
}

func rotina2(){
acquire();
//regiao critica
relinquish();
}
PLP - Linguagem Go
78
Conclusão
PLP - Linguagem Go
80
PLP - Linguagem Go
81
Referências
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