Este documento cubre los operadores en Elixir, cómo se analizan, cómo se pueden definir y cómo se pueden anular.

Precedencia y asociatividad de operadores

La siguiente es una lista de todos los operadores que Elixir es capaz de analizar, ordenados de mayor a menor precedencia, junto con su asociatividad:

Operador Asociatividad
@ Unario
. Izquierda
+-!^not~~~ Unario
*/ Izquierda
+- Izquierda
++--+++---..<> Derecha
innot in Izquierda
|><<<>>><<~~>><~~><~><|> Izquierda
<><=>= Izquierda
==!==~===!== Izquierda
&&&&&and Izquierda
|||||or Izquierda
= Derecha
& Unario
=> (válido solo en el interior %) Derecha
| Derecha
:: Derecha
when Derecha
<-\ Izquierda

Operadores generales

Elixir proporciona los siguientes operadores integrados que se definen como funciones que se pueden anular:

  • + y - - unario positivo / negativo
  • +, -, *, y / - operaciones aritméticas básicas
  • ++ y -- - lista de concatenación y resta
  • and y && - booleano estricto y relajado "y"
  • or y || - booleano estricto y relajado "o"
  • not y ! - "no" booleano estricto y relajado
  • in y not in - afiliación
  • @ - módulo attribute
  • .. - creación de rango
  • <> - concatenación binaria
  • |> - tubería
  • =~ - coincidencia basada en texto

Muchos de ellos pueden usarse en guardias; consulte la lista de funciones y operadores de guardia permitidos.

Además, hay algunos otros operadores que Elixir analiza pero que en realidad no usa. Consulte Operadores personalizados y anulados a continuación para obtener una lista y las pautas sobre su uso.

Algunos otros operadores son formas especiales y no se pueden anular:

  • ^ - operador de clavija
  • . - operador de puntos
  • = - operador de coincidencia
  • & - operador de captura
  • :: - tipo operador

Finalmente, estos operadores aparecen en la tabla de precedencia anterior, pero solo son significativos dentro de ciertas construcciones:

  • => - ver %
  • when - ver Guardias
  • <- - ver for y with
  • \ - ver argumentos predeterminados

Operadores de comparación

Elixir proporciona los siguientes operadores de comparación integrados (todos los cuales se pueden usar en guardias):

  • == - igual a
  • === - estrictamente igual a
  • != - desigual a
  • !== - estrictamente desigual a
  • < - menos que
  • > - mas grande que
  • <= - Menos que o igual a
  • >= - Mayor qué o igual a

La única diferencia entre == y === es eso === es estricto cuando se trata de comparar enteros y flotantes:

iex>1==1.0true
iex>1===1.0false

!= y !== actuar como la negación de == y ===, respectivamente.

Orden de plazo

En Elixir, se pueden comparar diferentes tipos de datos utilizando operadores de comparación:

iex>1<:an_atomtrue

La razón por la que podemos comparar diferentes tipos de datos es el pragmatismo. Los algoritmos de clasificación no necesitan preocuparse por los diferentes tipos de datos para poder clasificar. Como referencia, el orden de clasificación general se define a continuación:

number < atom < reference < function < port < pid < tuple < map < list < bitstring

Al comparar dos números de diferentes tipos (un número es un entero o un flotante), siempre se producirá una conversión al tipo con mayor precisión, a menos que el operador de comparación utilizado sea === o !==. Un flotador se considerará más preciso que un número entero, a menos que el flotador sea mayor / menor que +/- 9007199254740992.0 respectivamente, en cuyo punto todas las cifras significativas del flotador están a la izquierda del punto decimal. Este comportamiento existe para que la comparación de números grandes siga siendo transitiva.

Los tipos de colección se comparan utilizando las siguientes reglas:

  • Las tuplas se comparan por tamaño, luego elemento por elemento.
  • Los mapas se comparan por tamaño, luego por keys en orden ascendente de términos, luego por valores en key pedido. En el caso específico de los mapas ' key Al ordenar, los enteros siempre se consideran menores que los flotantes.
  • Las listas se comparan elemento por elemento.
  • Las cadenas de bits se comparan byte a byte, los bytes incompletos se comparan bit a bit.
  • Los átomos se comparan utilizando su string valor, punto de código por punto de código.

Operadores personalizados y anulados

Definición de operadores personalizados

Elixir es capaz de analizar un conjunto predefinido de operadores; esto significa que no es posible definir nuevos operadores (como se podría hacer en Haskell, por ejemplo). Sin embargo, no todos los operadores que Elixir puede analizar son usó por Elixir: por ejemplo, + y || son utilizados por Elixir para sumar y booleano o, pero <~> no se utiliza (pero es válido).

Para definir un operador, puede utilizar el habitual def* constructosdef, defp, defmacro, etc.) pero con una sintaxis similar a como se usa el operador:

defmoduleMyOperatorsdo# We define ~> to return the maximum of the given two numbers,# and <~ to return the minimum.def a ~> b,do:max(a, b)def a <~ b,do:min(a, b)end

Para utilizar los operadores recién definidos, tengo que importar el módulo que los define:

iex>importMyOperators
iex>1 ~>22
iex>1<~ 21

La siguiente es una tabla de todos los operadores que Elixir es capaz de analizar, pero que no se utilizan de forma predeterminada:

  • |||
  • &&&
  • <<<
  • >>>
  • <<~
  • ~>>
  • <~
  • ~>
  • <~>
  • <|>
  • +++
  • ---
  • ~~~

Los siguientes operadores son utilizados por el Bitwise módulo cuando se importa: &&&, <<<, >>>, |||, ~~~. Consulte la documentación para Bitwise para más información.

Tenga en cuenta que la comunidad de Elixir generalmente desalienta a los operadores personalizados. Pueden ser difíciles de leer e incluso más de entender, ya que no tienen un nombre descriptivo como las funciones. Dicho esto, algunos casos específicos o lenguajes específicos de dominio personalizados (DSL) pueden justificar estas prácticas.

También es posible reemplazar operadores predefinidos, como +, pero hacerlo es extremadamente desaconsejable.

← Página anterior Convenciones de nombres Página siguiente → Patrones y guardias