Fork me on GitHub

Básico

Preparar el entorno, tipos básicos y operaciones.

Tabla de contenidos

Preparar el entorno

Instalar Elixir

Las instrucciones para cada sistema operativo pueden ser encontradas en Elixir-lang.org en la guía Instalando Elixir.

Modo Interactivo

Elixir viene con iex, una consola interactiva, que nos permite evaluar expresiones Elixir.

Para empezar, Ejecutamos 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>

Tipos Básicos

Enteros

iex> 255
255

El soporte para números binarios, octales y hexadecimales también viene incluido:

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

Coma flotante

En Elixir, los números con coma flotante requieren un decimal después de al menos un dígito; estos tienen una precisión de 64 bits y soportan e para números exponenciales.

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

Booleanos

Elixir soporta true y false como booleanos; todo valor es verdadero a excepción de false y nil:

iex> true
true
iex> false
false

Átomos

Un Átomo es una constante cuyo nombre es su valor, si estás familiarizado con Ruby estos son equivalentes a los Símbolos:

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

NOTA: Booleanos true y false son también los átomos :true y :false respectivamente.

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

Cadenas

Las cadenas en Elixir están codificadas en utf-8 y están representadas con comillas dobles:

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

Las cadenas soportan saltos de línea y secuencias de escape:

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

Operaciones Básicas

Aritmética

Elixir soporta los operadores básicos +, -, *, y / como era de esperarse. Es importante resaltar que / siempre retornará un número con coma flotante:

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

Si tú necesitas una división entera o el resto de una división, Elixir viene con dos funciones útiles para para lograr esto:

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

Booleanas

Elixir provee los operadores booleanos: ||, &&, y !, estos soportan cualquier tipo:

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

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

iex> !42
false
iex> !false
true

Hay tres operadores adicionales cuyo primer argumento tiene que ser un booleano (true y 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

Comparación

Elixir viene con todos los operadores de comparación a los que estamos acostumbrados: ==, !=, ===, !==, <=, >=, < y >.

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

Para comparación estricta de enteros y flotantes usamos ===:

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

Una característica importante de Elixir es que cualquier par de tipos se pueden comparar, esto es útil particularmente en ordenación. No necesitamos memorizar el orden pero es importante ser consciente de este:

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

Esto puede conducir a algunas interesantes y válidas comparaciones que no puedes encontrar en otros lenguajes:

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

Interpolación de cadenas

Si has usado Ruby, la interpolación de cadenas en Elixir te parecerá muy familiar:

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

Concatenación de cadenas

La concatenación de cadenas usa el operador <>:

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

Share This Page