Fork me on GitHub

Básico

Primeiros Passos, tipos básicos e operações básicas.

Sumário

Primeiros Passos

Instalando Elixir

As instruções para instalação em cada sistema operacional podem ser encontradas em Elixir-lang.org na aba Install.

Após instalar o Elixir, você pode facilmente confirmar a versão instalada.

	% elixir -v
	Erlang/OTP 20 [erts-8.0.1] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

	Elixir 1.3.4

Modo Interativo

Elixir vem com iex, um console interativo, que nos permite avaliar expressões em Elixir.

Para iniciar, executamos iex:

Erlang/OTP 20 [erts-8.0.1] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex>

Vamos testar e digitar algumas expressões simples:

iex> 2+3
5
iex> 2+3 == 5
true
iex> String.length("The quick brown fox jumps over the lazy dog")
43

Não se preocupe se não entender cada expressão, mas esperamos que você compreenda a ideia.

Tipos Básicos

Inteiros

iex> 255
255

O suporte para números binários, octais e hexadecimais também estão inclusos:

iex> 0b0110
6
iex> 0o644
420
iex> 0x1F
255

Pontos Flutuantes

Em Elixir, os números de ponto flutuante requerem um decimal depois de pelo menos um dígito; estes possuem uma precisão de 64 bits e suportam e para números exponenciais:

iex> 3.14
 3.14
iex> .14
** (SyntaxError) iex:2: syntax error before: '.'
iex> 1.0e-10
1.0e-10

Booleanos

Elixir suporta true e false como booleanos; todo valor é verdadeiro com excessão de false e nil:

iex> true
true
iex> false
false

Átomos

Um Átomo é uma constante cujo o nome é seu valor. Se está familiarizado com Ruby, estes são equivalentes aos Símbolos:

iex> :foo
:foo
iex> :foo == :bar
false

Booleanos true e false também são átomos :true e :false, respectivamente.

iex> true |> is_atom
true
iex> :true |> is_boolean
true
iex> :true === true
true

Nomes de módulos em Elixir também são átomos. MyApp.MyModule é um átomo válido, mesmo se tal módulo ainda não tenha sido declarado.

iex> is_atom(MyApp.MyModule)
true

Átomos também são usados para referenciar módulos de bibliotecas Erlang, incluindo as bibliotecas integradas.

iex> :crypto.rand_bytes 3
<<23, 104, 108>>

Strings

As strings em Elixir são codificadas em UTF-8 e são representadas com aspas duplas:

iex> "Hello"
"Hello"
iex> "dziękuję"
"dziękuję"

As strings suportam quebras de linha e caracteres de escape:

iex> "foo
...> bar"
"foo\nbar"
iex> "foo\nbar"
"foo\nbar"

Elixir também inclui tipos de dados mais complexos. Nós vamos aprender mais sobre estes quando aprendermos sobre Collections e Functions.

Operações Básicas

Aritmética

Elixir suporta os operadores básicos +, -, *, e / como era de esperar. É importante ressaltar que / sempre retornará um número ponto flutuante:

iex> 2 + 2
4
iex> 2 - 1
1
iex> 2 * 5
10
iex> 10 / 5
2.0

Se você necessita de uma divisão inteira ou o resto da divisão, Elixir vem com duas funcionalidades úteis para isto:

iex> div(10, 5)
2
iex> rem(10, 3)
1

Booleanos

Elixir provê os operadores booleanos: ||, &&, e !, estes suportam qualquer tipo:

iex> -20 || true
-20
iex> false || 42
42

iex> 42 && true
true
iex> 42 && nil
nil

iex> !42
false
iex> !false
true

Há três operadores adicionais cujo o primeiro argumento tem que ser um booleano (true e false):

iex> true and 42
42
iex> false or true
true
iex> not false
true
iex> 42 and true
** (ArgumentError) argument error: 42
iex> not 42
** (ArgumentError) argument error

Comparação

Elixir vem com todos os operadores de comparação que estamos acostumados a usar: ==, !=, ===, !==, <=, >=, < e >.

iex> 1 > 2
false
iex> 1 != 2
true
iex> 2 == 2
true
iex> 2 <= 3
true

Para comparação de inteiros e pontos flutuantes usa-se ===:

iex> 2 == 2.0
true
iex> 2 === 2.0
false

Uma característica importante de Elixir é que quaisquer dois tipos podem ser comparados, isto é particularmente útil em ordenação. Não precisamos memorizar a ordem de classificação, mas é importante estar ciente de que:

number < atom < reference < functions < port < pid < tuple < maps < list < bitstring

Isso pode levar a algumas comparações interessantes e válidas, que você pode não encontrar em outras linguagens:

iex> :hello > 999
true
iex> {:hello, :world} > [1, 2, 3]
false

Interpolação de Strings

Se você já usou Ruby, a interpolação de strings em Elixir parecerá muito familiar:

iex> name = "Sean"
iex> "Hello #{name}"
"Hello Sean"

Concatenação de Strings

A concatenação de strings usa o operador <>:

iex> name = "Sean"
iex> "Hello " <> name
"Hello Sean"

Compartilhe essa página