diff options
Diffstat (limited to 'pt-br')
| -rw-r--r-- | pt-br/erlang-pt.html.markdown | 253 | ||||
| -rw-r--r-- | pt-br/go-pt.html.markdown | 308 |
2 files changed, 561 insertions, 0 deletions
diff --git a/pt-br/erlang-pt.html.markdown b/pt-br/erlang-pt.html.markdown new file mode 100644 index 00000000..6a86aafc --- /dev/null +++ b/pt-br/erlang-pt.html.markdown @@ -0,0 +1,253 @@ +--- +language: erlang +filename: learnerlang-pt.erl +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] + - ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"] +lang: pt-br +--- + +```erlang +% Símbolo de porcento começa comentários de uma linha. + +%% Dois caracteres de porcento devem ser usados para comentar funções. + +%%% Três caracteres de porcento devem ser usados para comentar módulos. + +% Nós usamos três tipos de pontuação em Erlang. +% Vírgulas (`,`) separam argumentos em chamadas de função, construtores de +% dados, e padrões. +% Pontos finais (`.`) separam totalmente funções e expressões no prompt. +% Ponto e vírgulas (`;`) separam cláusulas. Nós encontramos cláusulas em +% vários contextos: definições de função e em expressões com `case`, `if`, +% `try..catch` e `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Variáveis e casamento de padrões. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Num = 42. % Todos nomes de variáveis devem começar com uma letra maiúscula. + +% Erlang tem atribuição única de variáveis, se você tentar atribuir um valor +% diferente à variável `Num`, você receberá um erro. +Num = 43. % ** exception error: no match of right hand side value 43 + +% Na maioria das linguagens, `=` denota um comando de atribuição. Em Erlang, no +% entanto, `=` denota uma operação de casamento de padrão. `Lhs = Rhs` realmente +% significa isso: avalia o lado direito (Rhs), e então casa o resultado com o +% padrão no lado esquerdo (Lhs). +Num = 7 * 6. + +% Número de ponto flutuante. +Pi = 3.14159. + +% Átomos são usados para representar diferentes valores constantes não +% numéricos. Átomos começam com letras minúsculas seguidas por uma sequência de +% caracteres alfanuméricos ou sinais de subtraço (`_`) ou arroba (`@`). +Hello = hello. +OtherNode = example@node. + +% Átomos com valores alfanuméricos podem ser escritos colocando aspas por fora +% dos átomos. +AtomWithSpace = 'some atom with space'. + +% Tuplas são similares a structs em C. +Point = {point, 10, 45}. + +% Se nós queremos extrair alguns valores de uma tupla, nós usamos o operador `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% Nós podemos usar `_` para ocupar o lugar de uma variável que não estamos interessados. +% O símbolo `_` é chamado de variável anônima. Ao contrário de variáveis regulares, +% diversas ocorrências de _ no mesmo padrão não precisam se amarrar ao mesmo valor. +Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. +{_, {_, {_, Who}, _}, _} = Person. % Who = joe + +% Nós criamos uma lista colocando valores separados por vírgula entre colchetes. +% Cada elemento de uma lista pode ser de qualquer tipo. +% O primeiro elemento de uma lista é a cabeça da lista. Se removermos a cabeça +% da lista, o que sobra é chamado de cauda da lista. +ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. + +% Se `T` é uma lista, então `[H|T]` também é uma lista, com cabeça `H` e cauda `T`. +% A barra vertical (`|`) separa a cabeça de uma lista de sua cauda. +% `[]` é uma lista vazia. +% Podemos extrair elementos de uma lista com uma operação de casamento de +% padrão. Se temos uma lista não-vazia `L`, então a expressão `[X|Y] = L`, onde +% `X` e `Y` são variáveis desamarradas, irá extrair a cabeça de uma lista para +% `X` e a cauda da lista para `Y`. +[FirstThing|OtherThingsToBuy] = ThingsToBuy. +% FirstThing = {apples, 10} +% OtherThingsToBuy = {pears, 6}, {milk, 3} + +% Não existe o tipo string em Erlang. Strings são somente listas de inteiros. +% Strings são representadas dentro de aspas duplas (`"`). +Name = "Hello". +[72, 101, 108, 108, 111] = "Hello". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Programação sequencial. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Módulos são a unidade básica de código em Erlang. Todas funções que +% escrevemos são armazenadas em módulos. Módulos são armazenados em arquivos +% com extensão `.erl`. +% Módulos devem ser compilados antes que o código possa ser rodado. Um módulo +% compilado tem a extensão `.beam`. +-module(geometry). +-export([area/1]). % lista de funções exportadas de um módulo. + +% A função `area` consiste de duas cláusulas. As cláusulas são separadas por um +% ponto e vírgula, e a cláusula final é terminada por um ponto final. +% Cada cláusula tem uma cabeça em um corpo; a cabeça consiste de um nome de +% função seguido por um padrão (entre parêntesis), e o corpo consiste de uma +% sequência de expressões, que são avaliadas se o padrão na cabeça é um par bem +% sucedido dos argumentos da chamada. Os padrões são casados na ordem que +% aparecem na definição da função. +area({rectangle, Width, Ht}) -> Width * Ht; +area({circle, R}) -> 3.14159 * R * R. + +% Compila o código no arquivo geometry.erl. +c(geometry). % {ok,geometry} + +% Nós precisamos incluir o nome do módulo junto com o nome da função de maneira +% a identificar exatamente qual função queremos chamar. +geometry:area({rectangle, 10, 5}). % 50 +geometry:area({circle, 1.4}). % 6.15752 + +% Em Erlang, duas funções com o mesmo nome e diferentes aridades (números de +% argumentos) no mesmo módulo representam funções totalmente diferentes. +-module(lib_misc). +-export([sum/1]). % exporta a função `sum` de aridade 1 aceitando um argumento: lista de inteiros. +sum(L) -> sum(L, 0). +sum([], N) -> N; +sum([H|T], N) -> sum(T, H+N). + +% Funs são funções "anônimas". Elas são chamadas desta maneira por que elas não +% têm nome. No entanto podem ser atribuídas a variáveis. +Double = fun(X) -> 2*X end. % `Double` aponta para uma função anônima com referência: #Fun<erl_eval.6.17052888> +Double(2). % 4 + +% Funções aceitam funs como seus argumentos e podem retornar funs. +Mult = fun(Times) -> ( fun(X) -> X * Times end ) end. +Triple = Mult(3). +Triple(5). % 15 + +% Compreensão de lista são expressões que criam listas sem precisar usar funs, +% maps, ou filtros. +% A notação `[F(X) || X <- L]` significa "a lista de `F(X)` onde `X` é tomada +% da lista `L`." +L = [1,2,3,4,5]. +[2*X || X <- L]. % [2,4,6,8,10] +% Uma compreensão de lista pode ter geradores e filtros que selecionam +% subconjuntos dos valores gerados. +EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% Sentinelas são contruções que podemos usar para incrementar o poder de +% casamento de padrão. Usando sentinelas, podemos executar testes simples e +% comparações nas variáveis em um padrão. +% Você pode usar sentinelas nas cabeças das definições de função onde eles são +% introduzidos pela palavra-chave `when`, ou você pode usá-los em qualquer +% lugar na linguagem onde uma expressão é permitida. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Um sentinela é uma série de expressões sentinelas, separadas por +% vírgulas (`,`). +% O sentinela `GuardExpr1, GuardExpr2, ..., GuardExprN` é verdadeiro se todas +% expressões sentinelas `GuardExpr1, GuardExpr2, ...` forem verdadeiras. +is_cat(A) when is_atom(A), A =:= cat -> true; +is_cat(A) -> false. +is_dog(A) when is_atom(A), A =:= dog -> true; +is_dog(A) -> false. + +% Uma `sequência sentinela` é um sentinela ou uma série de sentinelas separados +% por ponto e vírgula (`;`). A sequência sentinela `G1; G2; ...; Gn` é +% verdadeira se pelo menos um dos sentinelas `G1, G2, ...` for verdadeiro. +is_pet(A) when is_dog(A); is_cat(A) -> true; +is_pet(A) -> false. + +% Registros provêem um método para associar um nome com um elemento particular +% em uma tupla. +% Definições de registro podem ser incluídas em arquivos fonte Erlang ou em +% arquivos com extensão `.hrl`, que então são incluídos em arquivos fonte Erlang. +-record(todo, { + status = reminder, % Default value + who = joe, + text +}). + +% Nós temos que ler definições de registro no prompt antes que possamos definir +% um registro. Nós usamos a função de prompt `rr` (abreviação de read records) +% para fazer isso. +rr("records.hrl"). % [todo] + +% Criando e atualizando registros: +X = #todo{}. +% #todo{status = reminder, who = joe, text = undefined} +X1 = #todo{status = urgent, text = "Fix errata in book"}. +% #todo{status = urgent, who = joe, text = "Fix errata in book"} +X2 = X1#todo{status = done}. +% #todo{status = done,who = joe,text = "Fix errata in book"} + +% Expressões `case`. +% A função `filter` retorna uma lista de todos elementos `X` em uma lista `L` +% para qual `P(X)` é verdadeiro. +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% Expressões `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil; + end. + +% Aviso: pelo menos um dos sentinelas na expressão `if` deve retornar +% verdadeiro; Caso contrário, uma exceção será levantada. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Exceções. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Exceções são levantadas pelo sistema quando erros internos são encontrados ou +% explicitamente em código pela chamada `throw(Exception)`, `exit(Exception)` +% ou `erlang:error(Exception)`. +generate_exception(1) -> a; +generate_exception(2) -> throw(a); +generate_exception(3) -> exit(a); +generate_exception(4) -> {'EXIT', a}; +generate_exception(5) -> erlang:error(a). + +% Erlang tem dois métodos para capturar uma exceção. Uma é encapsular a chamada +% para a função que levanta uma exceção dentro de uma expressão `try...catch`. +catcher(N) -> + try generate_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% O outro é encapsular a chamada em uma expressão `catch`. Quando você captura +% uma exceção, é convertida em uma tupla que descreve o erro. +catcher(N) -> catch generate_exception(N). + +``` + +## Referências + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang2/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) + diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown new file mode 100644 index 00000000..41a02c37 --- /dev/null +++ b/pt-br/go-pt.html.markdown @@ -0,0 +1,308 @@ +--- +name: Go +category: language +language: Go +filename: learngo-pt.go +lang: pt-pt +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] +translators: + - ["Nuno Antunes", "https://github.com/ntns"] +--- + +A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não +é a última moda em ciências da computação, mas é a mais recente e mais rápida +forma de resolver os problemas do mundo real. + +Tem conceitos familiares de linguagens imperativas com tipagem estática. É +rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência +fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem +recursos para ajudar com a programação em larga escala. + +Go vem com uma biblioteca padrão exaustiva e uma comunidade entusiasta. + +```go +// Comentário de uma linha +/* Comentário de + várias linhas */ + +// A cláusula package aparece no início de cada arquivo. +// Main é um nome especial declarando um executável ao invés de uma biblioteca. +package main + +// A cláusula Import declara os pacotes referenciados neste arquivo. +import ( + "fmt" // Um pacote da biblioteca padrão da linguagem Go + "net/http" // Sim, um servidor web! + "strconv" // Conversão de Strings +) + +// Definição de uma função. Main é especial. É o ponto de entrada para o +// programa executável. Goste-se ou não, a linguagem Go usa chavetas. +func main() { + // A função Println envia uma linha para stdout. + // É necessário qualifica-la com o nome do pacote, fmt. + fmt.Println("Olá Mundo!") + + // Chama outra função dentro deste pacote. + beyondHello() +} + +// As funções declaram os seus parâmetros dentro de parênteses. Se a função +// não receber quaisquer parâmetros, é obrigatório usar parênteses vazios. +func beyondHello() { + var x int // Declaração de variável. Tem de ser declarada antes de usar. + x = 3 // Atribuição de variável. + // Declarações "curtas" usam := para inferir o tipo, declarar e atribuir. + y := 4 + sum, prod := learnMultiple(x, y) // a função retorna dois valores + fmt.Println("soma:", sum, "produto:", prod) + learnTypes() // continuar a aprender! +} + +// As funções podem receber parâmetros e retornar (vários!) valores. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // retorna dois valores +} + +// Alguns tipos e literais básicos. +func learnTypes() { + // Declarações "curtas" geralmente servem para o que pretendemos. + s := "Aprender Go!" // tipo string + + s2 := `Uma string em "bruto" +pode incluir quebras de linha.` // mesmo tipo string + + // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8. + g := 'Σ' // tipo rune, um alias para uint32, que contém um código unicode + + f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754) + c := 3 + 4i // complex128, representado internamente com dois float64s + + // Declaração de variáveis, com inicialização. + var u uint = 7 // inteiro sem sinal, tamanho depende da implementação do Go + var pi float32 = 22. / 7 + + // Sintaxe de conversão de tipo, com declaração "curta". + n := byte('\n') // byte é um alias para uint8 + + // Os arrays têm tamanho fixo e definido antes da compilação. + var a4 [4]int // um array de 4 ints, inicializado com ZEROS + a3 := [...]int{3, 1, 5} // um array de 3 ints, inicializado como mostrado + + // As slices têm tamanho dinâmico. Os arrays e as slices têm cada um as + // suas vantagens mas o uso de slices é muito mais comum. + s3 := []int{4, 5, 9} // compare com a3. sem reticências aqui + s4 := make([]int, 4) // aloca uma slice de 4 ints, inicializada com ZEROS + var d2 [][]float64 // declaração apenas, nada é alocado + bs := []byte("uma slice") // sintaxe de conversão de tipos + + p, q := learnMemory() // learnMemory retorna dois apontadores para int. + fmt.Println(*p, *q) // * segue um apontador. isto imprime dois ints. + + // Os maps são um tipo de matriz associativa, semelhante aos tipos hash + // ou dictionary que encontramos noutras linguagens. + m := map[string]int{"três": 3, "quatro": 4} + m["um"] = 1 + + // As variáveis não usadas são um erro em Go. + // O traço inferior permite "usar" uma variável, mas descarta o seu valor. + _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs + // Enviar para o stdout conta como utilização de uma variável. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() +} + +// A linguagem Go é totalmente garbage collected. Tem apontadores mas não +// permite que os apontadores sejam manipulados com aritmética. Pode-se cometer +// um erro com um apontador nulo, mas não por incrementar um apontador. +func learnMemory() (p, q *int) { + // A função retorna os valores p e q, que são do tipo apontador para int. + p = new(int) // a função new aloca memória, neste caso para um int. + // O int alocado é inicializado com o valor 0, p deixa de ser nil. + s := make([]int, 20) // alocar 20 ints como um único bloco de memória + s[3] = 7 // atribui o valor 7 a um deles + r := -2 // declarar outra variável local + return &s[3], &r // & obtém o endereço de uma variável. +} + +func expensiveComputation() int { + return 1e6 +} + +func learnFlowControl() { + // As instruções if exigem o uso de chavetas, e não requerem parênteses. + if true { + fmt.Println("eu avisei-te") + } + // A formatação do código-fonte é "estandardizada" através do comando + // da linha de comandos "go fmt." + if false { + // reclamar + } else { + // exultar + } + // Preferir o uso de switch em vez de ifs em cadeia. + x := 1 + switch x { + case 0: + case 1: + // os cases não fazem "fall through" + case 2: + // esta linha só é executada se e só se x=2 + } + // Tal como a instrução if, a instrução for não usa parênteses. + for x := 0; x < 3; x++ { // x++ é uma instrução, nunca uma expressão + fmt.Println("iteração", x) + } + // note que, x == 1 aqui. + + // A instrução for é a única para ciclos, mas assume várias formas. + for { // ciclo infinito + break // brincadeirinha + continue // nunca executado + } + // O uso de := numa instrução if permite criar uma variável local, + // que existirá apenas dentro do bloco if. + if y := expensiveComputation(); y > x { + x = y + } + // As funções podem ser closures. + xBig := func() bool { + return x > 100 // referencia x, declarado acima da instrução switch. + } + fmt.Println("xBig:", xBig()) // true (1e6 é o último valor de x) + x /= 1e5 // agora temos x == 10 + fmt.Println("xBig:", xBig()) // false + + // Quando for mesmo necessário, pode usar o velho goto. + goto love +love: + + learnInterfaces() // Mais coisas interessantes chegando! +} + +// Define Stringer como uma interface consistindo de um método, String. +type Stringer interface { + String() string +} + +// Define pair como uma struct com dois campos ints chamados x e y. +type pair struct { + x, y int +} + +// Define um método para o tipo pair. O tipo pair implementa agora a +// interface Stringer. +func (p pair) String() string { // p é chamado de "receptor" + // Sprintf é outra função pública no pacote fmt. + // Uso de pontos para referenciar os campos de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Uma struct pode ser inicializada com os valores dos seus campos dentro + // de chavetas, seguindo a mesma ordem com que os campos foram definidos. + p := pair{3, 4} + fmt.Println(p.String()) // chama o método String de p, que tem tipo pair. + var i Stringer // declara i do tipo interface Stringer. + i = p // válido, porque pair implementa Stringer + // Chama o método String de i, que tem tipo Stringer. Mesmo que acima. + fmt.Println(i.String()) + + // As funções no pacote fmt chamam o método String para pedir a um objecto + // uma representação textual de si mesmo. + fmt.Println(p) // mesmo que acima. Println chama o método String. + fmt.Println(i) // mesmo que acima. + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" forma idiomática usada para saber se algo funcionou ou não. + m := map[int]string{3: "três", 4: "quatro"} + if x, ok := m[1]; !ok { // ok vai ser false porque 1 não está no map m. + fmt.Println("ninguem lá") + } else { + fmt.Print(x) // x seria o valor, se 1 estivesse no map. + } + // Um valor de erro comunica mais informação sobre o problema. + if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta o valor + // imprime "strconv.ParseInt: parsing "non-int": invalid syntax" + fmt.Println(err) + } + // Vamos revisitar as interfaces um pouco mais tarde. Entretanto, + learnConcurrency() +} + +// c é um channel, um objecto para comunicação concurrency-safe. +func inc(i int, c chan int) { + c <- i + 1 // <- é operador "enviar" quando um channel aparece à esquerda. +} + +// Vamos usar a função inc para incrementar números de forma concorrente. +func learnConcurrency() { + // A mesma função make usada anteriormente para alocar uma slice. + // Make aloca e inicializa slices, maps, e channels. + c := make(chan int) + // Inicia três goroutines concorrentes. Os números serão incrementados de + // forma concorrente, talvez em paralelo se a máquina for capaz e estiver + // configurada correctamente. As três goroutines enviam para o mesmo canal. + go inc(0, c) // go é a instrução para iniciar uma goroutine. + go inc(10, c) + go inc(-805, c) + // Lê três resultados do channel c e imprime os seus valores. + // Não se pode dizer em que ordem os resultados vão chegar! + fmt.Println(<-c, <-c, <-c) // channel na direita, <- é operador "receptor". + + cs := make(chan string) // outro channel, este lida com strings. + cc := make(chan chan string) // channel que lida com channels de strings. + go func() { c <- 84 }() // inicia uma goroutine para enviar um valor + go func() { cs <- "palavroso" }() // outra vez, para o channel cs desta vez + // A instrução select tem uma sintaxe semelhante à instrução switch mas + // cada caso envolve uma operação com channels. Esta instrução seleciona, + // de forma aleatória, um caso que esteja pronto para comunicar. + select { + case i := <-c: // o valor recebido pode ser atribuído a uma variável + fmt.Printf("é um %T", i) + case <-cs: // ou o valor recebido pode ser descartado + fmt.Println("é uma string") + case <-cc: // channel vazio, não se encontra pronto para comunicar. + fmt.Println("não aconteceu") + } + // Neste ponto um valor foi recebido de um dos channels c ou cs. Uma das + // duas goroutines iniciadas acima completou, a outra continua bloqueada. + + learnWebProgramming() // Go faz. Você quer faze-lo também. +} + +// Basta apenas uma função do pacote http para iniciar um servidor web. +func learnWebProgramming() { + // O primeiro parâmetro de ListenAndServe é o endereço TCP onde escutar. + // O segundo parâmetro é uma interface, especificamente http.Handler. + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // não ignorar erros +} + +// Tornar pair um http.Handler ao implementar o seu único método, ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Servir dados com um método de http.ResponseWriter + w.Write([]byte("Aprendeu Go em Y minutos!")) +} +``` + +## Leitura Recomendada + +A principal fonte de informação é o [web site oficial Go](http://golang.org/). +Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito. + +A própria especificação da linguagem é altamente recomendada. É fácil de ler e +incrivelmente curta (em relação ao que é habitual hoje em dia). + +Na lista de leitura para os aprendizes de Go deve constar o [código fonte da +biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é +a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da +sua escrita idiomática. Ou então clique no nome de uma função na [documentação] +(http://golang.org/pkg/) e veja o código fonte aparecer! + |