mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
252 lines
10 KiB
Markdown
252 lines
10 KiB
Markdown
---
|
|
filename: learnerlang-pt.erl
|
|
contributors:
|
|
- ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
|
|
translators:
|
|
- ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"]
|
|
---
|
|
|
|
```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)
|
|
|