Introdução à Linguagem GO

Mini-curso Gratuito

Eder Magalhães

Apresentação da Agenda

Agenda

•  Motivação
•  Configurar ambiente
•  Primeiro Exemplo
•  Estrutura da linguagem
•  Funções
•  Valores Compostos
•  Customizando Tipos
•  Módulos
•  Execução concorrente
•  Utilitários e Dificuldades
•  Perguntas

Introdução

Google

Sem falar nos serviços...

Introdução

Motivação

•  Computadores poderosos extramamente rápidos, mas o
desenvolvimento lento;
•  Suporte a concorrência e coleta de memória limitados;
•  Complexidade no controle de dependencia;
•  Modelo engessado, tipagem como tirania ;
•  Multi-core não é encairado/aproveitado como deveria

Introdução

O Que é o GO?

•  Nova linguagem de desenvolvimento do Google.

•  Desenvolvimento mais divertido, produtivo, concorrente e
performático.

Introdução

GO é uma linguagem:

•  Compilada;
•  Concorrente;
•  Garbage-collected
•  Type-safe
•  Modular
•  Expressiva
•  Experimental
•  Divertida
•  Open Source (BSD License)

Introdução

GO Team

•  Russ Cox
•  Rob Pike
•  Ken Thompson
•  Robert Griesemer
•  Adam Langley
•  Ian Taylor

Introdução

Compiladores

•  Sistemas Operacionais suportados:
o  Linux
o  Mac OS

•  Tipos de instruções
o  Amd64 (64 bits x86)
o  386 (32 bits x32)
o  ARM

Introdução

Instalando ambiente no Ubuntu (Linux) - Parte I
# Instalação do repositório de fontes do GO
$ sudo apt-get install mercurial

# Instalação do compilador (gcc)
$ sudo apt-get install bison gcc libc6-dev ed make

# Estrutura de diretórios para GO
$ mkdir $HOME/go
$ mkdir $HOME/go/bin
$ mkdir $HOME/go/src

Introdução

Instalando ambiente no Ubuntu (Linux)
# Configurar vars de ambiente no arquivo ˜/.bashrc
export GOROOT=$HOME/go/src
export GOBIN=$HOME/go/bin
export GOOS=linux
export GOARCH=386
export PATH=$PATH:$HOME/go/bin

# Download dos fontes do GO
$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

$ cd $GOROOT/src

# Montar a estrutura do GO
$ ./all.bash

Introdução

Compilando

fonte byte-code
8g (compila)
Arquivo GO Arquivo 8

Arquivo out

executável

Introdução

Código, HelloGO !

•  Rodando primeiro programa em GO...

Introdução

Características do código

•  Formato do código é UTF-8;

•  Suporte a Unicode;

•  O arquivo fonte deve declarar o pacote;

•  Função main é o ponto de partida para execução.

•  fmt é o módulo com funcões c/ formatação para I/O.

Introdução

Caracteristicas do código

•  O arquivo fonte deve declarar seu pacote;

•  Formato do codigo é UTF-8;

•  Suporte a unicode;

•  Função main é o ponto de partida para execução.

Introdução

Palavras reservadas

break default func interface select

case defer go map struct

chan else goto package switch

const fallthrough if range type
continue for import return var

Introdução

Identificadores

•  Inicia com letra ou _ seguido por letras ou digitos:

a
_x9
VariavelComposta
numeração

Introdução

Comentários

//comentario simples...

/* delimitando inicio e fim */

Introdução

Tipos

•  Boleanos: bool
  true ou false

•  Strings: string
o  Array de bytes
o  Imutável

  Normal
  `inicio e
  o fim`
  String em varios pedacos
  Valor /*isso nao */ string /*eh considerado*/ .

Introdução

Tipos Numéricos Inteiros
Tipo Range de Valores
uint8 / byte 0 a 255
uint16 0 a 65535
uint32 0 a 4294967295
uint64 0 a 18446744073709551615
int8 -128 a 127
int16 -32768 a 32767
int32 -2147483648 a 2147483647
int64 -9223372036854775808 a 9223372036854775807

** uint e int para 32 ou 64 bits

Introdução

Tipos Numéricos Ponto Flutuante

Tipo Range de Valores
float32 IEEE-754
float64 IEEE-754

** float para 32 ou 64 bits

Introdução

Declaração de Variáveis
var s string = ;

var x, y int32 = 10, 20;

var (
d float32 = 2.6;
f float32 = 5.7;
)

var i = 25; //sem tipagem

n := 15; //sem var e tipagem

var z int; //inicia com valor 0

Introdução

Conversores

•  Com números:
var x int = 100;

var i int32 = x; //ñ compila

var i int32 = int32(x); //ok

•  Com string:
string([]byte{'h', 'e', 'l', 'l', 'o'})

Introdução

Declaração de Constantes
const Pi float64 = 3.14159265358979323846

const zero = 0.0; //sem tipagem

const (
size int64 = 1024;
eof = -1; //sem tipagem
)

const a, b, c = 3, 4, "foo //sem tipagem

Introdução

Ponteiros: operadores & e *
var x int = 50; Valor * Memória &
//cópia 50 X0701
var i int = x;
50 X0809

&x == &i;
i++; //i é 51

//referência
var i *int = &x;

&x == &i;

(*i)++; //x é 51

Introdução

Condicional - if
if [resultado boolean] {
...
} [else - opcional] {
...
}

var b bool = true;

if b {
return true
}

Introdução

Condicional - switch
switch t := x.(type) {
case nil:
fmt.Print( t nao eh nada");
case int:
fmt.Print( t eh int );
case float:
fmt.Print( t eh float );
case bool, string:
fmt.Print( t eh boolean ou string );
default:
fmt.Print( t eh um de um tipo desconhecido");
}

Introdução

Laços
for i := 0; i < 100; i++ {
if i == 50 {
continue;
}
fmt.Printf("%dn",i);
}
x := 10;
for x < 10 { //substituto do while
x++
}

Introdução

Funções
func soma(i int, x int) int {
return i + x
}

func divide(d int, v int) (int bool) {
if v > 0 { return d/v, true }

return 0, false;
}

fmt.Print(soma(10, 5)); //15
fmt.Print(divide(15,2)); //7

Introdução

Funções - Closures
func sum() (func (int) int) {
var x int;

return func (n int) int {
x += n; return n;
}
}

var s = sum();

fmt.Print(s(10)); //retorna e imprime 10

Introdução

Arrays

•  Indexado a partir de 0;
•  O tamanho é constante, e não pode ser negativo;
•  A função len retorna o tamanho;

var numeros [5]int; //inicializa com 0

var notas = [3]int {7,8,6};

var x = [10]int {5,2,4}; //outros elementos são 0

var d = [...]int {4};

fmt.Print(len(d)); //4

Introdução

Slices

•  Um pedaço de array;
•  Indexado, mas o tamanho pode ser alterado;
•  Mais barato do que o array;

var fatia = notas[0:2];

var n = []int {5, 7, 9};

var x = &notas;

for i:=0; i < len(x); i++ {
fmt.Print(x[i]);
}

Introdução

Map

•  Outra alternativa para estrutura de dados;

var m map[string] int //Java: Map<String, Integer>

m = map[string] int { a : 500, 1 :60 }

var x = m[ a ];
var e = m[ 2 ]; //erro em execução

m[ x ] = 77; //cria um novo elemento

x, ok := m[ a ]; //sem erro, ok é false

Introdução

Navegando em um Map

//recupera a chave e valor
for key, value := range m {
fmt.Printf("key %s, value %gn", key, value)
}

//recupera a chave
for key := range m {
fmt.Printf("key %s, value %gn", key, m[value])
}

Introdução

Struct

•  Customização de tipos;
•  Uma analogia a classe no Java;

type Pessoa struct {
nome, cpf string;
}

var p Pessoa;
p.nome = "Paula";
p.cpf = "9874458147";

outro := Pessoa { Ana , 213123131 }

Introdução

Struct e Ponteiros

p Pessoa := Pessoa{"Carlos", "154548484"};

ref := new (Pessoa); //ponteiro

ref = &p;

fmt.Print((*ref).nome)

Introdução

Struct, anonymous field - Relacionamento

type Endereco struct {
logradouro, cep string;
}

type Pessoa struct {
nome, cpf string;
Endereco;
}

p := Pessoa{
Endereco{ "Av. Bernardino","09789-111 },
"Ana", "1959478766"
};

Introdução

Métodos

•  Declarado fora do struct;
•  Pode ser criado para qualquer type;

func (p *Pessoa) formata() string {
return nome;
}

p := &Pessoa{ "Gustavo", "9809890078" }
fmt.Print(p.formata());

Introdução

Métodos

Customizando método em um array de int:

type arrayInt [ ]int; //type

func (v arrayInt) Sum() (s int) {
for i, x := range v {
s += x
}
//return vazio
return
}

fmt.Print(arrayInt{10, 5, 7}.Sum());

Introdução

Interface

•  Tipo totalmente abstrato, conceito próximo ao do Java
type Formatador interface { formata() string };

var f Formatador;

f := &Pessoa{"Carlos", "154548484"};
fmt.Print(f.formata());

type MeuInt int32;

func (i MeuInt) formata () string {
return string(i)
}
f = MeuInt(100);

Introdução

Módulos

Todo código GO é organizado em pacotes:
fmt à implementa funções para formtação de I/O;
os à provê uma abstração para o sistema operacional;
math à algumas constantes e funcionalidades matemáticas;
http à implementa parse de requisição e respostas http;
io à prove interface básica para manipulação I/O;
reflect à funcionalidades para reflexão;

time à funcionalidades para manipular e exibir informações de tempo;

outros ...

Introdução

Goroutines

•  É a terminologia do GO para um processo concorrente, a
Thread do Java;
•  Aciona uma função/método de forma assíncrona;
func preparar(conteudo string, segundos int32) {
time.Sleep(minutos*1e9);
fmt.Println(conteudo," pronto!");
}

go preparar("feijoada", 10);
go preparar("cafe", 5);
fmt.Println("aguardando ...");

Introdução

O que mais?

•  Documentação
•  Godoc - gerador de documentação html, assim como o javadoc;
•  Gofmt - formata o comentário para impressão;

•  Testes
•  Crie arquivos para testes unitários com sufixo *_test.go;
•  Defina as funções de teste com o prefixo TestXxx(t *testing.T)
•  Execute o gotest

Introdução

Dificuldades

•  Ambiente de desenvolvimento: IDE e Debug;

•  Bibliotecas e ferramentas ainda recentes;

•  Integração com Banco de Dados;

•  Comunidade pequena;

Introdução

Sites
http://golang.org

http://twitter.com/edermag

http://twitter.com/globalcode

eder@yaw.com.br

Introdução

Perguntas

?

Introdução à Linguagem GO

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (7)

Ähnlich wie Introdução à Linguagem GO

Ähnlich wie Introdução à Linguagem GO (20)

Mehr von Eder Magalhães

Mehr von Eder Magalhães (20)

Introdução à Linguagem GO