¿Qué hace el operador% en Ruby en N% 2?

Question

if counter % 2 == 1 Estoy tratando de decodificar esta línea - es un proyecto de Rails y estoy tratando de averiguar qué hace el % en esta declaración if.

Answer 1

% es el operador modulo. El resultado de counter % 2 es el resto de counter/2.

n % 2 es a menudo una buena manera de determinar si un número n es par o impar. Si es n % 2 == 0, el número es par (porque ningún resto significa que el número es divisible por 2); si es n % 2 == 1, el número es impar.

Answer 2

Es el operador de módulo.

http://en.wikipedia.org/wiki/Modulo_operation

Answer 3

Ese es el operador de módulo. Se le da al resto cuando el contador se divide por 2.

For example: 
3 % 2 == 1 
2 % 2 == 0 

Answer 4

Es el operador de módulo, que es una forma elegante de decir que es el operador resto.

Así que si divide un número por dos, y el número entero restante de ese número es uno, entonces sabrá que el número fue impar. Tu ejemplo verifica los números impares.

A menudo, esto se hace para resaltar las filas de números impares con un color de fondo diferente, lo que facilita la lectura de grandes listas de datos.

Answer 5

dar algunas maneras de decirlo:

• Modulo operador
• operador resto
• residuos modular

Estrictamente hablando, si a % b = c, c es la constante única de tal manera que

a == c (mod b) y 0 <= c < b

Donde x == y (mod m) iff x - y = km para alguna constante k.

Esto es equivalente al resto. Por algún conocido teorema, tenemos ese a = bk + c para alguna constante k, donde c es el resto, lo que nos da a - c = bk, lo que obviamente implica a == c (mod b).

(¿Hay una manera de utilizar látex en Stackoverflow?)

Answer 6

Ésta es una pregunta muy básica. % es el operador de módulo if counter % 2 == 1 resultados a true para cada número impar y a false para cada número par.

Si está aprendiendo ruby, debe aprender a usar irb, allí puede probar las cosas y quizás responder la pregunta usted mismo.

tratar de entrar

100.times{|i| puts "#{i} % 2 == 1 #=> #{i % 2 == 1}"} 

en su consola IRB irb y ver la salida, lo que debería ser claro qué hace %.

Y realmente debería echar un vistazo a la documentación de los carriles API (1.9, 1.8.7, 1.8.7), no se habría encontrado la respuesta dos pregunta % (Fixnum) con un enlace más de una descripción detallada de divmod (Numeric):

Devuelve una matriz que contiene el cociente y el módulo obtenido al dividir num por aNumeric. > Si q, r = x.divmod (y), entonces

q = floor(float(x)/float(y)) 
x = q*y + r 

El cociente se redondea hacia -infinito, como se muestra en la siguiente tabla:

a | b | a.divmod(b) | a/b | a.modulo(b) | a.remainder(b) 
------+-----+---------------+---------+-------------+--------------- 
13 | 4 | 3, 1  | 3  | 1  |  1 
------+-----+---------------+---------+-------------+--------------- 
13 | -4 | -4, -3  | -3  | -3  |  1 
------+-----+---------------+---------+-------------+--------------- 
-13 | 4 | -4, 3  | -4  | 3  | -1 
------+-----+---------------+---------+-------------+--------------- 
-13 | -4 | 3, -1  | 3  | -1  | -1 
------+-----+---------------+---------+-------------+--------------- 
11.5 | 4 | 2, 3.5 | 2.875 | 3.5  |  3.5 
------+-----+---------------+---------+-------------+--------------- 
11.5 | -4 | -3, -0.5 | -2.875 | -0.5  |  3.5 
------+-----+---------------+---------+-------------+--------------- 
-11.5 | 4 | -3, 0.5 | -2.875 | 0.5  | -3.5 
------+-----+---------------+---------+-------------+--------------- 
-11.5 | -4 | 2 -3.5 | 2.875 | -3.5  | -3.5 

Ejemplos

11.divmod(3)   #=> [3, 2] 
11.divmod(-3)  #=> [-4, -1] 
11.divmod(3.5)  #=> [3, 0.5] 
(-11).divmod(3.5) #=> [-4, 3.0] 
(11.5).divmod(3.5) #=> [3, 1.0] 

Answer 7

Independientemente de cómo funciona, el operador de módulo probablemente no sea el mejor código para este fin (aunque no se nos da mucho contexto). Como Jörg mencionó en un comentario, la expresión if counter.odd? es probablemente la intención, y es más legible.

Si se trata de un código de vista y se utiliza para determinar (por ejemplo) colores de filas alternas, entonces puede prescindir completamente del contador utilizando el ayudante Rails cycle() incorporado. Por ejemplo, puede usar cycle('odd','even') como nombre de clase para una fila de tabla, eliminando el contador y la lógica si/then circundante.

Otra idea: si se trata de un bloque each, puede utilizar each_with_index y eliminar la variable contraria extraña.

Mi refactorización $ 0.02.

Answer 8

También tenga en cuenta que, la definición de Ruby del operador de módulo (%) difiere de la de C y Java. En Ruby, -7%3 es 2. En C y Java, el resultado es -1 en su lugar. En Ruby, el signo del resultado (para el operador %) es siempre el mismo que el del segundo operando.

Answer 9

Respondiendo a la pregunta "¿Qué significa o hace el símbolo% en Ruby?" Es:

1) El operador binario de módulo (como se ha mencionado)

17 % 10 #=> 7 

2) La cadena alternativa delimitador contador

%Q{hello world} #=> "hello world" 
%Q(hello world) #=> "hello world" 
%Q[hello world] #=> "hello world" 
%Q!hello world! #=> "hello world" 
# i.e. choose your own bracket pair 
%q(hello world) #=> 'hello world' 
%x(pwd)   #=> `pwd` 
%r(.*)   #=> /.*/ 

3) El operador formato de cadena (abreviatura de Kernel :: sprintf)

"05d" % 123 #=> "00123"