Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Metaprogramming

Erlang y Elixir, Parte 4: Flujo de Control

by
Read Time:4 minsLanguages:
This post is part of a series called Introduction to Erlang and Elixir.
Erlang and Elixir, Part 3: Functions
Erlang and Elixir, Part 5: Phoenix Framework

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

If, else y operadores lógicos son probablemente la similitud más común entre los lenguajes populares, y de manera no sorpresa que Elixir los tiene, también. Los macros if, case y cond son proporcionados para darnos estructura de flujo de control.

Para emparejamiento de patrón, mencionamos antes de eso que usar case proporciona coincidencias contra cualquier patrón de manera iterativa:

Aquí vale la pena notar el _ case, que es esencialmente un case atrapa-todo por defecto. El case puede ser también usado con un atom o cualquier tipo de variable.

Expresiones de Cláusula de Guardia

Elixir proporciona muchas operadores para revisar nuestra expresión como una guardia en lugar de atrapar los datos incorrectos. Por defecto, los siguientes son soportados:

  • operadores de comparación (==!====!==>>=<<=)
  • operadores booleanos (andornot)
  • operaciones aritméticas (+-*/)
  • operadores aritméticos unarios (+, -)
  • el operador binario de concatenación <>
  • el operador in siempre y cuando el lado derecho sea un rango o una lista
  • todas las siguientes funciones de tipo check:
    • is_atom/1
    • is_binary/1
    • is_bitstring/1
    • is_boolean/1
    • is_float/1
    • is_function/1
    • is_function/2
    • is_integer/1
    • is_list/1
    • is_map/1
    • is_nil/1
    • is_number/1
    • is_pid/1
    • is_port/1
    • is_reference/1
    • is_tuple/1
  • mas estas funciones:
    • abs(number)
    • binary_part(binary, start, length)
    • bit_size(bitstring)
    • byte_size(bitstring)
    • div(integer, integer)
    • elem(tuple, n)
    • hd(list)
    • length(list)
    • map_size(map)
    • node()
    • node(pid | ref | port)
    • rem(integer, integer)
    • round(number)
    • self()
    • tl(list)
    • trunc(number)
    • tuple_size(tuple)

Podemos usarlas como:

Adicionalmente, una función anónima puede tener múltiples guardias. Por ejemplo, para calcular un punto de pivote de datos de un mercado financiero usando los valores alto, bajo y cercano, podemos hacer esto:

Aquí, si el valor alto es menos que el bajo, la función anónima de pivote devolverá un mensaje de Error. Esta manera de una línea de escribir guardias es fenomenalmente poderosa.

Cond

Como una declaración switch, el cond de Elixir es donde podemos ejecutar una cadena de if else como bloques y ejecutar en la coincidencia.

Dentro de un bloque cond, todo se evalúa a true excepto nil o false. Todos los valores numéricos y cadenas incluidos.

Por ejemplo, podemos revisar el estado actual para varias posibilidades con un bloque cond:

Cuando el valor de estado se establece a string, evaluará; de otro modo, un mensaje de error será mostrado por defecto vía el último caso true.

If y Unless

Elixir también proporciona unless, que es una parte por defecto del bloque if else y puede ser demostrado como:

Cuando el caso if evalúa como true, unless te permitirá tener acceso al opuesto. Como se demostró, podemos atrapar el otro lado del condicional de esta manera.

En un ejemplo de la vida real, esto puede ser usado para mostrar información condicional durante una revisión condicional, a manera de recordatorio o pista.

Bloques Do/End

A través de estos ejemplos, hemos visto el uso de macros do y end. Echemos un vistazo más cercano a estos ahora antes de concluir esta sección:

La coma después de true es para la sintaxis regular de Elixir, en donde cada argumento es separado por comas. Esta sintaxis usa listas de palabras clave, y cuando se usa en conjunto con el macro else se verá así:

Para hacer esto más agradable para desarrollo, podemos usar el bloque do/end, el cuál no requiere la coma para una aproximación directa:

Conclusión

Elixir tiene las estructuras de flujo de control if/else y case, también tiene unless y el bloque do/end.

Podemos lograr cualquier lógica vía manipulación del flujo de control con estas estructuras. Cuando las usas en conjunto con macros, funciones anónimas y módulos, tienes un gran suministro de opciones para hacer el trabajo.

Para lectura continuada sobre el tema, el manual proporciona más ideas en algunas de las advertencias de usar el bloque do/end, tales como limitaciones de alcance de función.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.