mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Tradução do Elixir para pt_br (#1421)
This commit is contained in:
Rodrigo Muniz
ven
parent
9b51e703c5
commit
13bddecbe4
411
pt-br/elixir.html.markdown
Normal file
411
pt-br/elixir.html.markdown
Normal file
@ -0,0 +1,411 @@
|
||||
---
|
||||
language: elixir
|
||||
contributors:
|
||||
- ["Joao Marques", "http://github.com/mrshankly"]
|
||||
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
|
||||
translators:
|
||||
- ["Rodrigo Muniz", "http://github.com/muniz95"]
|
||||
filename: learnelixir.ex
|
||||
---
|
||||
|
||||
Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
|
||||
É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
|
||||
e muitos outros recursos.
|
||||
|
||||
```elixir
|
||||
|
||||
# Comentários de linha única começam com um símbolo de número.
|
||||
|
||||
# Não há comentários de múltiplas linhas,
|
||||
# mas você pode empilhar os comentários.
|
||||
|
||||
# Para usar o shell do elixir use o comando `iex`.
|
||||
# Compile seus módulos com o comando `elixirc`.
|
||||
|
||||
# Ambos devem estar em seu path se você instalou o Elixir corretamente.
|
||||
|
||||
## ---------------------------
|
||||
## -- Tipos Básicos
|
||||
## ---------------------------
|
||||
|
||||
# Há números
|
||||
3 # integer
|
||||
0x1F # integer
|
||||
3.0 # float
|
||||
|
||||
# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
|
||||
:hello # atom
|
||||
|
||||
# Tuplas que são guardadas contiguamente em memória.
|
||||
{1,2,3} # tupla
|
||||
|
||||
# Podemos acessar um elemento de uma tupla om a função `elem`:
|
||||
elem({1, 2, 3}, 0) #=> 1
|
||||
|
||||
# Listas que são implementadas como listas ligadas.
|
||||
[1,2,3] # lista
|
||||
|
||||
# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
|
||||
[head | tail] = [1,2,3]
|
||||
head #=> 1
|
||||
tail #=> [2,3]
|
||||
|
||||
# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
|
||||
# e não uma atribuição.
|
||||
#
|
||||
# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
|
||||
# estiver à direita.
|
||||
#
|
||||
# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
|
||||
|
||||
# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
|
||||
# onde as tuplas tem diferentes tamanhos.
|
||||
# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
|
||||
|
||||
# Também há binários
|
||||
<<1,2,3>> # binary
|
||||
|
||||
# Strings e char lists
|
||||
"hello" # string
|
||||
'hello' # char list
|
||||
|
||||
# Strings de múltiplas linhas
|
||||
"""
|
||||
Strings
|
||||
de múltiplas
|
||||
linhas.
|
||||
"""
|
||||
#=> "Strings\nde múltiplas\nlinhas"
|
||||
|
||||
# Strings são sempre codificadas em UTF-8:
|
||||
"héllò" #=> "héllò"
|
||||
|
||||
# Strings são de fato apenas binários, e char lists apenas listas.
|
||||
<<?a, ?b, ?c>> #=> "abc"
|
||||
[?a, ?b, ?c] #=> 'abc'
|
||||
|
||||
# `?a` em elixir retorna o valor ASCII para a letra `a`
|
||||
?a #=> 97
|
||||
|
||||
# Para concatenar listas use `++`, para binários use `<>`
|
||||
[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
|
||||
'hello ' ++ 'world' #=> 'hello world'
|
||||
|
||||
<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
|
||||
"hello " <> "world" #=> "hello world"
|
||||
|
||||
# Ranges são representados como `início..fim` (ambos inclusivos)
|
||||
1..10 #=> 1..10
|
||||
menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
|
||||
[lower, upper] #=> [1, 10]
|
||||
|
||||
## ---------------------------
|
||||
## -- Operadores
|
||||
## ---------------------------
|
||||
|
||||
# Matemática básica
|
||||
1 + 1 #=> 2
|
||||
10 - 5 #=> 5
|
||||
5 * 2 #=> 10
|
||||
10 / 2 #=> 5.0
|
||||
|
||||
# Em elixir o operador `/` sempre retorna um float.
|
||||
|
||||
# Para divisão de inteiros use `div`
|
||||
div(10, 2) #=> 5
|
||||
|
||||
# Para obter o resto da divisão use `rem`
|
||||
rem(10, 3) #=> 1
|
||||
|
||||
# Há também operadores booleanos: `or`, `and` e `not`.
|
||||
# Estes operadores esperam um booleano como primeiro argumento.
|
||||
true and true #=> true
|
||||
false or true #=> true
|
||||
# 1 and true #=> ** (ArgumentError) argument error
|
||||
|
||||
# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
|
||||
# Todos os valores exceto `false` e `nil` serão avaliados como true.
|
||||
1 || true #=> 1
|
||||
false && 1 #=> false
|
||||
nil && 20 #=> nil
|
||||
!true #=> false
|
||||
|
||||
# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
|
||||
1 == 1 #=> true
|
||||
1 != 1 #=> false
|
||||
1 < 2 #=> true
|
||||
|
||||
# `===` e `!==` são mais estritos ao comparar integers e floats:
|
||||
1 == 1.0 #=> true
|
||||
1 === 1.0 #=> false
|
||||
|
||||
# Podemos comparar também dois tipos de dados diferentes:
|
||||
1 < :hello #=> true
|
||||
|
||||
# A regra de ordenação no geral é definida abaixo:
|
||||
# number < atom < reference < functions < port < pid < tuple < list < bit string
|
||||
|
||||
# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
|
||||
# mas que uma ordem total esteja bem definida é importante."
|
||||
|
||||
## ---------------------------
|
||||
## -- Fluxo de Controle
|
||||
## ---------------------------
|
||||
|
||||
# expressão `if`
|
||||
if false do
|
||||
"Isso nunca será visto"
|
||||
else
|
||||
"Isso será"
|
||||
end
|
||||
|
||||
# Também há `unless`
|
||||
unless true do
|
||||
"Isso nunca será visto"
|
||||
else
|
||||
"Isso será"
|
||||
end
|
||||
|
||||
# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
|
||||
|
||||
# `case` nos permite comparar um valor com muitos patterns:
|
||||
case {:um, :dois} do
|
||||
{:quatro, :cinco} ->
|
||||
"Isso não corresponde"
|
||||
{:um, x} ->
|
||||
"Isso corresponde e vincula `x` a `:dois`"
|
||||
_ ->
|
||||
"Isso corresponde a qualquer valor"
|
||||
end
|
||||
|
||||
# É comum vincular o valor a `_` se não precisamos dele.
|
||||
# Por exemplo, se apenas a head de uma lista nos interessa:
|
||||
[head | _] = [1,2,3]
|
||||
head #=> 1
|
||||
|
||||
# Para melhor legibilidade podemos fazer o seguinte:
|
||||
[head | _tail] = [:a, :b, :c]
|
||||
head #=> :a
|
||||
|
||||
# `cond` nos permite verificar várias condições ao mesmo tempo.
|
||||
# Use `cond` em vez de aninhar vários `if`'s.
|
||||
cond do
|
||||
1 + 1 == 3 ->
|
||||
"Nunca serei visto"
|
||||
2 * 5 == 12 ->
|
||||
"Nem eu"
|
||||
1 + 2 == 3 ->
|
||||
"Mas eu serei"
|
||||
end
|
||||
|
||||
# É comum definir a última condição igual a `true`, que sempre irá corresponder.
|
||||
cond do
|
||||
1 + 1 == 3 ->
|
||||
"Nunca serei visto"
|
||||
2 * 5 == 12 ->
|
||||
"Nem eu"
|
||||
true ->
|
||||
"Mas eu serei (isso é essencialmente um else)"
|
||||
end
|
||||
|
||||
# `try/catch` é usado para capturar valores que são lançados, também suporta uma
|
||||
# cláusula `after` que é invocada havendo um valor capturado ou não.
|
||||
try do
|
||||
throw(:hello)
|
||||
catch
|
||||
message -> "Deu #{mensagem}."
|
||||
after
|
||||
IO.puts("Sou o after.")
|
||||
end
|
||||
#=> Sou o after
|
||||
# "Deu :hello"
|
||||
|
||||
## ---------------------------
|
||||
## -- Módulos e Funções
|
||||
## ---------------------------
|
||||
|
||||
# Funções Anônimas (repare o ponto)
|
||||
square = fn(x) -> x * x end
|
||||
square.(5) #=> 25
|
||||
|
||||
# Elas também aceitam várias cláusulas e guards.
|
||||
# Guards permitem ajustes finos de pattern matching,
|
||||
# sendo indicados pela palavra `when`:
|
||||
f = fn
|
||||
x, y when x > 0 -> x + y
|
||||
x, y -> x * y
|
||||
end
|
||||
|
||||
f.(1, 3) #=> 4
|
||||
f.(-1, 3) #=> -3
|
||||
|
||||
# Elixir também fornece várias funções embutidas.
|
||||
# Estas estão disponíveis no escopo atual.
|
||||
is_number(10) #=> true
|
||||
is_list("ola") #=> false
|
||||
elem({1,2,3}, 0) #=> 1
|
||||
|
||||
# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
|
||||
# para definir suas funções.
|
||||
defmodule Math do
|
||||
def sum(a, b) do
|
||||
a + b
|
||||
end
|
||||
|
||||
def square(x) do
|
||||
x * x
|
||||
end
|
||||
end
|
||||
|
||||
Math.sum(1, 2) #=> 3
|
||||
Math.square(3) #=> 9
|
||||
|
||||
# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
|
||||
# em seu terminal: elixirc math.ex
|
||||
|
||||
# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
|
||||
# Uma função definida com `def` pode ser invocada por outros módulos,
|
||||
# já uma função privada pode ser invocada apenas localmente.
|
||||
defmodule PrivateMath do
|
||||
def sum(a, b) do
|
||||
do_sum(a, b)
|
||||
end
|
||||
|
||||
defp do_sum(a, b) do
|
||||
a + b
|
||||
end
|
||||
end
|
||||
|
||||
PrivateMath.sum(1, 2) #=> 3
|
||||
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
|
||||
|
||||
# Declarações de funções também suportam guards cláusulas múltiplas:
|
||||
defmodule Geometry do
|
||||
def area({:rectangle, w, h}) do
|
||||
w * h
|
||||
end
|
||||
|
||||
def area({:circle, r}) when is_number(r) do
|
||||
3.14 * r * r
|
||||
end
|
||||
end
|
||||
|
||||
Geometry.area({:rectangle, 2, 3}) #=> 6
|
||||
Geometry.area({:circle, 3}) #=> 28.25999999999999801048
|
||||
# Geometry.area({:circle, "not_a_number"})
|
||||
#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
|
||||
|
||||
# Devido à imutabilidade, recursão é uma grande parte do elixir
|
||||
defmodule Recursion do
|
||||
def sum_list([head | tail], acc) do
|
||||
sum_list(tail, acc + head)
|
||||
end
|
||||
|
||||
def sum_list([], acc) do
|
||||
acc
|
||||
end
|
||||
end
|
||||
|
||||
Recursion.sum_list([1,2,3], 0) #=> 6
|
||||
|
||||
# Módulos do elixir suportam atributos, hpa atributos embutidos e você
|
||||
# pode também adicionar os seus próprios.
|
||||
defmodule MyMod do
|
||||
@moduledoc """
|
||||
Este é um atributo embutido em um módulo de exemplo.
|
||||
"""
|
||||
|
||||
@my_data 100 # Este é um atributo customizado.
|
||||
IO.inspect(@my_data) #=> 100
|
||||
end
|
||||
|
||||
## ---------------------------
|
||||
## -- Structs e Exceptions
|
||||
## ---------------------------
|
||||
|
||||
# Structs são extensões no topo de mapas que trazem valores padrão,
|
||||
# garantias em tempo de compilação e polimorfismo para o Elixir.
|
||||
defmodule Pessoa do
|
||||
defstruct nome: nil, idade: 0, peso: 0
|
||||
end
|
||||
|
||||
joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
|
||||
#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
|
||||
|
||||
# Acessa o valor de nome
|
||||
joe_info.name #=> "Joe"
|
||||
|
||||
# Atualiza o valor de idade
|
||||
older_joe_info = %{ joe_info | idade: 31 }
|
||||
#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
|
||||
|
||||
# O bloco `try` com a palavra `rescue` é usado para manipular exceções
|
||||
try do
|
||||
raise "algum erro"
|
||||
rescue
|
||||
RuntimeError -> "resgatado um erro em tempo de execução"
|
||||
_error -> "isso resgatará qualquer erro"
|
||||
end
|
||||
|
||||
# Toda exceção possui uma mensagem
|
||||
try do
|
||||
raise "algum erro"
|
||||
rescue
|
||||
x in [RuntimeError] ->
|
||||
x.message
|
||||
end
|
||||
|
||||
## ---------------------------
|
||||
## -- Concorrência
|
||||
## ---------------------------
|
||||
|
||||
# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
|
||||
# escrever programas concorrentes em elixir são três primitivos: spawning processes,
|
||||
# sending messages e receiving messages.
|
||||
|
||||
# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
|
||||
# como argumento.
|
||||
f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
|
||||
spawn(f) #=> #PID<0.40.0>
|
||||
|
||||
# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
|
||||
# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
|
||||
# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
|
||||
# realizado com o mecanismo `receive`:
|
||||
defmodule Geometry do
|
||||
def area_loop do
|
||||
receive do
|
||||
{:rectangle, w, h} ->
|
||||
IO.puts("Area = #{w * h}")
|
||||
area_loop()
|
||||
{:circle, r} ->
|
||||
IO.puts("Area = #{3.14 * r * r}")
|
||||
area_loop()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# Compile o módulo e crie um processo que avalie `area_loop` no shell
|
||||
pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
|
||||
|
||||
# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
|
||||
send pid, {:rectangle, 2, 3}
|
||||
#=> Area = 6
|
||||
# {:rectangle,2,3}
|
||||
|
||||
send pid, {:circle, 2}
|
||||
#=> Area = 12.56000000000000049738
|
||||
# {:circle,2}
|
||||
|
||||
# O shell também é um processo, você pode usar `self` para obter o pid atual
|
||||
self() #=> #PID<0.27.0>
|
||||
```
|
||||
|
||||
## Referências
|
||||
|
||||
* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
|
||||
* [Elixir Documentation](http://elixir-lang.org/docs/master/)
|
||||
* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
|
||||
* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
|
||||
* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
|
||||
* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
|
||||
Loading…
Reference in New Issue
Block a user