tutorial - ruby wikipedia

Tabla de precedencia del operador Ruby

Question

Muéstrame una tabla de precedencia de Ruby definitiva, revisada por pares / mantenida (de operadores , no operadores y modificadores ).

A lo largo de los años, he tenido que confiar en las siguientes fuentes para esta información:

1. http://phrogz.net/programmingruby/language.html#table_18.4 - El libro de Pico , que documenta a Ruby 1.6 , que se lanzó en septiembre de 2000, e incluye un error de formato o error tipográfico ( { aparece como una asignación operador).

2. http://www.techotopia.com/index.php/Ruby_Operator_Precedence - Una copia cercana de la tabla de Pico anterior, incluida la errónea { , y describe accidentalmente || como ''AND'' lógico .

3. http://www.tutorialspoint.com/ruby/ruby_operators.htm - También una copia cercana de la tabla de Pico , aunque corrige la descripción de || a "O" lógico , pero todavía enumera { como un operador de asignación . Además, enumera :: y lo describe incorrectamente como un operador de resolución constante ( :: no es un operador).

4. http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators - El libro Ruby Programming Language , que documenta Ruby 1.8 y 1.9 , que se lanzaron en agosto de 2003 y Diciembre de 2007, respectivamente. Este libro fue publicado en 2008 por David Flanagan y Yukihiro Matsumoto (también conocido como "Matz", el inventor de Ruby). Parece ser la lista más actualizada y precisa de operadores, no operadores, modificadores e información de respaldo. Por cierto, alrededor de 2005, el interés en Ruby aumentó en tándem con Rails, que se lanzó en julio de 2004.

5. http://romhack.wikia.com/wiki/Ruby_operators - También documenta operadores en Ruby 1.9 e incluye no operadores y modificadores en su tabla.

Ruby 2.0 fue lanzado en febrero de 2013, y fue diseñado para ser totalmente compatible con versiones anteriores de Ruby 1.9.3 . De las pocas incompatibilidades conocidas, ninguna está relacionada con los operadores.

Ruby 2.1.0 fue lanzado el día de Navidad en 2013 , y de manera similar, no se enumeran incompatibilidades de operadores.

Por lo tanto, decidí incluir una respuesta, basada en el libro Flanagan / Matz, y la convertí en una wiki comunitaria .

Answer 1

Ruby 2.1.0, 2.0, 1.9, 1.8

Un operador es un token que representa una operación (como adición o comparación) que se realizará en uno o más operandos. Los operandos son expresiones y los operadores nos permiten combinar estas expresiones de operandos en expresiones más grandes. ( http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators )

N = arity = La cantidad de operandos en los que opera el operador. ( http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators )

A = asociatividad = El orden de evaluación cuando el mismo operador (u operadores con la misma precedencia) aparece secuencialmente en una expresión. El valor L significa que las expresiones se evalúan de izquierda a derecha . El valor R significa que las expresiones se evalúan de derecha a izquierda . Y el valor N significa que el operador no es asociativo y no puede usarse varias veces en una expresión sin paréntesis para especificar el orden de evaluación. ( http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators )

M = definibilidad = Ruby implementa varios de sus operadores como métodos, lo que permite a las clases definir nuevos significados para esos operadores. La columna M de especifica qué operadores son métodos. Los operadores marcados con una Y se implementan con métodos y pueden redefinirse, y los operadores marcados con una N no pueden. ( http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators )

La siguiente tabla se ordena de acuerdo con la precedencia descendente ( precedencia más alta en la parte superior ).

N A M  Operator(s)            Description
- - -  -----------            -----------
1 R Y  ! ~ +                  boolean NOT, bitwise complement, unary plus
                              (unary plus may be redefined from Ruby 1.9 with +@)

2 R Y  **                     exponentiation
1 R Y  -                      unary minus (redefine with -@)

2 L Y  * / %                  multiplication, division, modulo (remainder)
2 L Y  + -                    addition (or concatenation), subtraction

2 L Y  << >>                  bitwise shift-left (or append), bitwise shift-right
2 L Y  &                      bitwise AND

2 L Y  | ^                    bitwise OR, bitwise XOR (exclusive OR)
2 L Y  < <= >= >              ordering

2 N Y  == === != =~ !~ <=>    equality, pattern matching, comparison
                              (!= and !~ may not be redefined prior to Ruby 1.9)

2 L N  &&                     boolean AND
2 L N  ||                     boolean OR

2 N N  .. ...                 range creation (inclusive and exclusive)
                              and boolean flip-flops

3 R N  ? :                    ternary if-then-else (conditional)
2 L N  rescue                 exception-handling modifier

2 R N  =                      assignment
2 R N  **= *= /= %= += -=     assignment
2 R N  <<= >>=                assignment
2 R N  &&= &= ||= |= ^=       assignment

1 N N  defined?               test variable definition and type
1 R N  not                    boolean NOT (low precedence)
2 L N  and or                 boolean AND, boolean OR (low precedence)
2 N N  if unless while until  conditional and loop modifiers

Answer 2

Precedencia de operadores de Ruby RE

Una lista útil también se puede encontrar en la parte inferior de esta página:

https://www.tutorialspoint.com/ruby/ruby_operators.htm

RE: Usando {}

Las variables locales comienzan con una letra minúscula o _. El alcance de una variable local varía entre clase, módulo, def o do hasta el extremo correspondiente o desde la llave de apertura de un bloque hasta su llave estrecha {}.

Cuando se hace referencia a una variable local no inicializada, se interpreta como una llamada a un método que no tiene argumentos.

La asignación a variables locales no inicializadas también sirve como declaración de variable. Las variables comienzan a existir hasta que se alcanza el final del alcance actual. La duración de las variables locales se determina cuando Ruby analiza el programa.

En el ejemplo anterior, las variables locales son id, name y addr.

TAMBIÉN: Puedes sustituir el valor de cualquier expresión de Ruby en una cadena usando la secuencia # {expr}. Aquí, expr podría ser cualquier expresión de rubí.

Fuente: https://www.tutorialspoint.com/ruby/ruby_variables.htm