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 Go2
Introdução
Introdução
Motivação
Sintaxe e Semântica
Processador da Linguagem
Outras Características
PLP - Linguagem Go4
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 Go5
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 Go6
Processador da Linguagem
PLP - Linguagem Go7
Código Fonte *.8 ou *.6 Executável
Compilador: gccgo
(6g, 6l, 8g, 8l)
Outras Características
Criada pela Google e lançada em novembro de
2009
Equipe: Robert Griesemer, Rob Pike e Ken
Thompson
PLP - Linguagem Go8
Valores & Tipos
Valores & Tipos
Valores
Boolean
Numérico
String
Array
Struct
Ponteiros
Abstração de função e
procedimento
Mapa
Channel
Tipos
Primitivos
Compostos
Recursivo
Checagem de Tipos
Equivalência de Tipos
Princípio da Completude
Expressões
PLP - Linguagem Go10
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
}
Valores
PLP - Linguagem Go11
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.
Valores
PLP - Linguagem Go12
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.
Abstração de FunçãoNúmericos
BooleanosAbstração de Procedimento Ponteiro
Arrays
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
}
Tipos Primitivos
PLP - Linguagem Go13
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
var barra string = "===== “
var contagemEmpate int = 0
var travou bool = false
var porcentagem float = 10.5
Tipos Compostos
PLP - Linguagem Go14
type Tabuleiro struct {
matriz [8] [8] *Peca
int totalPecas
}
Struct – Sequência de elementos.
Campos: possuem nome e tipo.
Produtos Cartesianos : Structs
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.
Tipos Compostos
PLP - Linguagem Go15
Struct – Sequência de elementos.
Campos: possuem nome e tipo.
Produtos Cartesianos : Structs
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.
[][]*Peca x inttype Tabuleiro struct {
matriz [8] [8] *Peca
int totalPecas
}
type Tabuleiro struct {
matriz [8] [8] *Peca
int totalPecas
}
Tipos Compostos
Tipos Recursivos: Structs
Go não dá suporte:
União Disjunta
Conjuntos Potência
PLP - Linguagem Go16
Implementados através de ponteiros.
type Node struct {
valor Tupla
next *Node
}
Checagem de Tipos
Go é estaticamente e fortemente tipada.
PLP - Linguagem Go17
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 (){
dez_decimal := 10.0
var dez int = dez_decimal
}
prog.go:6: cannot use dez_decimal (type
float) as type int in assignment
FortementeErro ao tentar
compilar!!!
Equivalência de Tipos
Go dá suporte a equivalência nominal
PLP - Linguagem Go18
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)
tupla.EhDama()
}
prog.go:15: tupla.EhDama undefined
(type Tupla has no field EhDama)
Erro ao tentar
compilar!!!
Go não dá suporte a equivalência estrutural!
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.
PLP - Linguagem Go19
func (tabuleiro *Tabuleiro) IsZerou (cor int) bool
if (…){
return false
}
return true
}
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 Go20
Armazenamento
Armazenamento
Variáveis e Atualização
Arrays
Semântica de Cópia x
Semântica de Referência
Variáveis
Locais e Globais
Heap
Persistentes
Tipos de Comandos
Skip
Atribuição
Chamada de
procedimento
Comandos
Sequencial
Colateral
Condicional
Expressões com Efeitos
Colaterais
PLP - Linguagem Go22
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 Go23
Variáveis e Atualização
Go dá suporte a atualização seletiva e atualização
total
PLP - Linguagem Go24
Seletiva
Total
var posicaoFinal Coordenada;
posicaoFinal.x = 1;
posicaoFinal.y = 2;
var posicaoInicial Coordenada;
posicaoInicial = posicaoFinal;
Arrays
PLP - Linguagem Go25
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;
}
Semântica de Cópia x
Semântica de Referência
PLP - Linguagem Go26
Por Referência
Por Cópia
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;
posicao2 = &posicao1;
posicao3 = posicao2;
posicao3.x = 5;
posicao3.y = 5;
Variáveis Locais e Globais
PLP - Linguagem Go27
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”
func main() {
tamanho := 10;
if (...){
var numBombas = 15;
}
}
Variável Global
Variáveis LocaisAçúcar
Sintático
Variáveis Heap
PLP - Linguagem Go28
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.
var tabuleiro_jogo *Tabuleiro = new (Tabuleiro)
Alocação de
memória
Variáveis persistentes
PLP - Linguagem Go29
oldfile := "text.txt"
newfile := "text2.txt"
doc, _ := ioutil.ReadFile(oldfile)
ioutil.WriteFile(newfile,doc,0644)
São do tipo “File”
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++
Skip e Atribuição
PLP - Linguagem Go30
Não há atribuição múltipla em Go.
Skip e Atribuição
PLP - Linguagem Go31
Skip usado para separar expressões
Não há atribuição múltipla em Go.
Atribuição simultâneaAçúcar sintático
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++
Atribuição
Chamada de Procedimentos
PLP - Linguagem Go32
Chamada de procedimento
Procedimento
peca := new (Peca)
peca.SetCor(Preto)
//...
func (peca *Peca) SetCor (cor int) {
peca.cor = cor
}
Comando Sequencial
PLP - Linguagem Go33
meuTabuleiro.n = 0
meuTabuleiro.m = 0
meuTabuleiro.ganhou = false
Comando Colateral Não existem comandos colaterais.
meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false;
Separados por ponto-e-vírgula,
ou por quebra de linha.
Comando Condicional
PLP - Linguagem Go34
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"
}
Comandos Iterativos
PLP - Linguagem Go35
for i > 0 {
var a int = Random(n);
var b int = Random(n);
//...
}
for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS;
i++ {
nodeAtual = new(Node);
nodeAtual.SetValor(tuplaAtual);
//...
}
Iteração definida
Iteração indefinidaPalavra reservada for
funcionando como o comando while em
outras linguagens.
Associações
Associações
Entidades Associáveis
Escopo
Estrutura de Blocos
Visibilidade
Declarações
Definição
Declaração de Tipo
Declaração de Variável
Declarações Colaterais
Declarações Sequenciais
Declarações Recursivas
Comando Bloco
Expressão Bloco
Princípio da Qualificação
PLP - Linguagem Go37
Entidades Associáveis
PLP - Linguagem Go38
meuTabuleiro.m = 0;
meuTabuleiro.ganhou = false;
var Numero int = calculaNumDeMinas(n);
const( MAX_MOVIMENTOS int = 50);
Valores primitivos e compostos
Abstrações de funções e procedimentos
Variáveis e Tipos
Escopo
Em Go, o corpo de um bloco é avaliado no
ambiente em que foi definido (associação
estática).
PLP - Linguagem Go39
const s = 2;
func incremento ( d int ) int {
return d∗s;}
func executaIncremento ( valor int ) int {
const s = 3;
return incremento ( valor );
}
func main () {
fmt.Println( executaIncremento(5) );
}
Saída: 10
Blocos: Estrutura e Visibilidade
PLP - Linguagem Go40
var tamanhoTabuleiro int = 10;
for {
var tamanhoTabuleiro = 15;
for {
var tamanhoTabuleiro = 20;
fmt.Println( tamanhoTabuleiro );
break;
}
fmt.Println( tamanhoTabuleiro ) ;
break;
}
fmt.Println( tamanhoTabuleiro );
imprime 20
imprime 15
imprime 10
Estrutura: blocos aninhados.
Visibilidade: variáveis declaradas em blocos
de escopo internos não são visíveis a blocos
de escopo externos.
Definição
PLP - Linguagem Go41
const( MAX_MOVIMENTOS int = 50)
func Jogada() (int,int) {
//…
}
var posJogada;
var posX *int;
var posAux *int;
As definições em Go podem ser de tipo, abstração
de funções, abstração de procedimentos, variáveis,
constantes.
Constante
Abstração de função
Variáveis
Declaração de Tipo
PLP - Linguagem Go42
type Peca struct {
cor int;
dama bool;
}
Declaração de Variável
var vertical string = "Coordenada Vertical: “;
var valor int = 1;
var decimal float = 1.0;
Go dá suporte a declaração de tipos
através da palavra reservada type.
O tipo Peca sendo declarado.
Como a maioria das linguagens imperativas,
Go dá suporte à declaração sequencial.
Declaração sequencial
PLP - Linguagem Go43
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.
Go dá suporte a declaração recursiva.
Declaração recursiva
PLP - Linguagem Go44
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
Comando bloco
PLP - Linguagem Go45
Go dá suporte a comando bloco.
Declaração que é usada apenas pra executar o comando
func ( pilha ∗Node ) PrintValorProximo( ) {
Println ( "|" , pilha.GetValor( ) , "|" );
next := pilha.GetNext( );
Println(next.GetValor());
}
Expressão bloco
func (peca *Peca) GetValue(peca2 *Peca)(bool){
valor1 := peca.EhDama()
valor2 := peca2.EhDama()
return valor1 && valor2
}
PLP - Linguagem Go46
Go dá suporte a expressão bloco.
Declarações usadas apenas para avaliar a expressão.
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.
PLP - Linguagem Go47
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.
Abstrações
Abstrações
Tipos de Abstrações
Abstração de Função
Abstração de
Procedimento
Princípio da Abstração
Parâmetros
Argumentos
Passagem de Parâmetros
Princípio da
Correspondência
Ordem de Avaliação
PLP - Linguagem Go49
Abstração de Função
PLP - Linguagem Go 50
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;
}
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.
Abstração de Procedimento
PLP - Linguagem Go51
func inicializarJogo() {
tabuleiro.ReiniciaTabuleiro();
ehHumano = true;
}
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.
Princípio da abstração
PLP - Linguagem Go52
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.
Parâmetros
PLP - Linguagem Go53
type Peca struct {
cor int
dama bool
}
func (peca *Peca) EhDama () (bool){
return peca.dama
}
Como Go é fortemente tipada, os parâmetros devem possuir
tipos definidos.
Podem ser de qualquer tipo.
Passagem de Parâmetros
PLP - Linguagem Go54
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
Princípio da Correspondência
PLP - Linguagem Go55
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
Ordem de Avaliação
PLP - Linguagem Go56
Eager Evaluation
var p int;
func main () {
p = 3;
print ( p )
}
func print ( n int ) {
Println(n);
p = 100;
Println(n);
}
Saída:
3
3
Unidades de Programa
Unidades de Programa
Pacotes
Tipos Abstratos de Dados
Objetos e Classes
Unidades Genéricas
PLP - Linguagem Go58
Pacotes
PLP - Linguagem Go59
package tabuleiro
//...
func (meuTabuleiro *Tabuleiro) Ganhou() bool {
return meuTabuleiro.ganhou;
}
func (meuTabuleiro *Tabuleiro) AlguemGanhou(){
meuTabuleiro.ganhou = true;
}
func calculaNumDeMinas(tamanho int) int{
//...
return numeroDeBombas;
}/
Função com
visibilidade privada
Funções visíveis
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.
Tipo Abstrato de Dados
PLP - Linguagem Go60
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)
}
//...
Objetos e Classes
PLP - Linguagem Go61
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.
Go não tem Objetos e Classes, porém, simula-os através de
structs e funções ligadas a esses tipos.
Sistemas de Tipos
Sistema de Tipos
Monomorfismo
Sobrecarga
Polimorfismo Paramétrico
Polimorfismo por Inclusão
Interfaces
Coerção
PLP - Linguagem Go63
func (meuTabuleiro *Tabuleiro) Ganhou() bool{
return meuTabuleiro.ganhou;
}
func (meuTabuleiro *Tabuleiro) AlguemGanhou() {
meuTabuleiro.ganhou = true;
}
Println("---------------------------");
Print("Linha: ");
Println(posMaquina[0]+1);
Print("Coluna: ");
Println(posMaquina[1]+1);
Println("---------------------------");
Monomorfismo
PLP - Linguagem Go64
As abstrações definidas pelo
programador, em Go, são
monomórficas. Toda
entidade tem um tipo
específico associado.
Mas, algumas abstrações
embutidas (built-in) não
são monomórficas.
Sobrecarga
PLP - Linguagem Go65
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.
Go dá suporte a sobrecarga de operadores built-in.
Entretanto, não dá suporte a sobrecarga de operaçoes.
(Operadores: +, -, e outros)
Polimorfismo por Inclusão
PLP - Linguagem Go66
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.
Polimorfismo Paramétrico
PLP - Linguagem Go67
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.
Interface
PLP - Linguagem Go68
package main
import . "fmt";
func main(){
jogador := new(Jogador);
jogador.nome = "iza";
peca := new(Peca);
peca.cor = "preto";
imprimir(jogador);
imprimir(peca);
}
type printer interface { Print(); }
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; }
Go simula
o uso de
interface
com o tipo
“interface”.
Coersão
PLP - Linguagem Go69
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.
Sequenciadores
Sequenciadores
Desvios Incondicionais
Escapes
Exceções
PLP - Linguagem Go71
Desvios Incondicionais
PLP - Linguagem Go72
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).
Escape
PLP - Linguagem Go73
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;
}
}
}
Iteração afetada
pelo escape
Go dá suporte a escape através da palavra
reservada“break” e “continue”.
Escape não rotulado apenas finaliza a iteração
corrente.
Escape rotulado
PLP - Linguagem Go74
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;
}
}
}
Go dá suporte a escape rotulado através da
palavra reservada break mais o rótulo.
Rótulo
Exceções
PLP - Linguagem Go75
Go não dá suporte a exceções.
Concorrência
Concorrência
PLP - Linguagem Go77
var canal = make(chan int);
func main() {
go rotina1();
go rotina2();
}
func rotina1(){
var i int = 0;
for i = 0; i <= 100; i++ {
canal <- i;
}
}
func rotina2(){
for {
msg := <- canal;
Println(msg);
if(msg == 100){
break;
}
}
}
Go dá suporte a concorrência
através de goroutines.
A comunicação entre os
processos concorrentes é
através de channel.
Goroutines
Channel
Spin-Lock
PLP - Linguagem Go78
func acquire(){
for(usandoRecurso){
}
usandoRecurso = true;
}
func relinquish(){
usandoRecurso = false;
}
func rotina1(){
acquire();
//regiao critica
relinquish();
}
func rotina2(){
acquire();
//regiao critica
relinquish();
}
Flag
Rotinas
O flag é uma variável global.
Assim permitimos que apenas uma
rotina tenha acesso ao recurso.
Conclusão
PLP - Linguagem Go80
PLP - Linguagem Go81
Referências
Referências
PLP - Linguagem Go83
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