section | layout | title |
---|---|---|
getting-started |
getting-started |
Basic operators |
En el capítulo anterior, vimos que Elixir provee los operadores aritméticos: +
, -
, *
, /
. Además las funciones div/2
para división entera y rem/2
para obtener el resto de una división.
Elixir provee además ++
y --
para manipular listas:
iex> [1, 2, 3] ++ [4, 5, 6]
[1, 2, 3, 4, 5, 6]
iex> [1, 2, 3] -- [2]
[1, 3]
La concatenación de cadenas se realiza con <>
:
iex> "foo" <> "bar"
"foobar"
Elixir provee además tres operadores booleanos: or
, and
y not
:
iex> true and true
true
iex> false or is_atom(:example)
true
iex> not true
false
Estos operadores son estrictos en cuanto a que esperan operandos booleanos, es decir, algo que evalúe o bien a true
, o a false
, como primer argumento. Si se provee un operando no booleano, se emitirá una excepción:
iex> 1 and true
** (BadBooleanError) expected a boolean on left-side of "and", got: 1
iex> 1 or false
** (BadBooleanError) expected a boolean on left-side of "or", got: 1
iex> not 1
** (ArgumentError) argument error
or
y and
son operadores que evitan realizar la evaluación del segundo argumento si el primero resulta suficiente para determinar el resultado.
iex> false and raise("This error will never be raised")
false
iex> true or raise("This error will never be raised")
true
Además de estos operadores booleanos, Elixir provee además ||
, &&
y !
, que aceptan argumentos de cualquier tipo. Para estos operadores todos los valores, exceptuando false
y nil
evalúan a verdadero:
# or
iex> 1 || true
1
iex> false || 11
11
# and
iex> nil && 13
nil
iex> true && 17
17
# not
iex> !true
false
iex> !1
false
iex> !nil
true
Como regla general, usa and
, or
y not
cuando esperes booleanos. Y si cualquiera de los argumentos puede ser no-booleano, entonces usa &&
, ||
y !
.
Los operadores de comparación son: ==
, !=
, ===
, !==
, <=
, >=
, <
y >
:
iex> 1 == 1
true
iex> 1 != 2
true
iex> 1 < 2
true
La diferencia entre ==
y ===
es que el segundo es estricto al comparar entre números enteros y flotantes:
iex> 1 == 1.0
true
iex> 1 === 1.0
false
En Elixir podemos comparar dos tipos de datos diferentes:
iex> 1 < :atom
true
La razón de ser de esta característica es pragmatismo. De esta manera los algoritmos de ordenamiento no necesitan preocuparse de los distintos tipos de datos al ordenar. El orden de los distintos tipos de datos es el siguiente:
number < atom < reference < function < port < pid < tuple < map < list < bitstring
No es necesario memorizar esto, es suficiente saber que existe. Para mayor información mira la página de operadores en el manual de referencia.
En el próximo capítulo, discutiremos pattern matching mediante el uso de =
, que en Elixir se denomina "el operador de match (emparejamiento)".