Que fait l'opérateur % dans Ruby dans n % 2?

En réponse à la question "Que signifie le symbole % dans Ruby?"C'est:

1) l'opérateur binaire modulo (comme cela a été mentionné)

17 % 10 #=> 7 

2) le jeton de délimiteur de chaîne alternatif

%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) l'opérateur de format de chaîne (raccourci pour Kernel:: sprintf)

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

C'est l'opérateur modulo. Il donne le reste lorsque le compteur est divisé par 2.

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

Peu importe comment cela fonctionne, l'opérateur modulo n'est probablement pas le meilleur code pour le but (même si on ne nous donne pas beaucoup de contexte). Comme Jörg mentionné dans un commentaire, l'expression if counter.odd? est probablement l'intention, et est plus lisible.

S'il s'agit d'un code de vue et utilisé pour déterminer (par exemple) des couleurs de ligne alternées, vous pourrez peut-être vous passer complètement du compteur en utilisant L'Assistant Rails intégré cycle(). Par exemple, vous pouvez utiliser cycle('odd','even') comme nom de classe pour une table ligne, éliminant le compteur et entourant la logique if/then.

Une autre pensée: si cela se trouve dans un bloc each, vous pourrez peut-être utiliser each_with_index et éliminer la variable de compteur étrangère.

Mon refactoring $ 0.02.

C'est l'opérateur modulo.

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

C'est l'opérateur modulo, qui est une façon élégante de dire que c'est l'opérateur restant.

Donc, si vous divisez un nombre par deux, et que le reste entier de ce nombre est un, alors vous savez que le nombre était Impair. Votre exemple vérifie les nombres impairs.

Souvent, cela est fait pour mettre en évidence les lignes de nombres impairs avec une couleur d'arrière-plan différente, ce qui facilite la lecture de grandes listes de données.

C'est une question très basique. % est l'opérateur modulo if counter % 2 == 1 donne true pour chaque nombre impair et false pour chaque nombre pair.

Si vous apprenez ruby, vous devriez apprendre à utiliser irb, là, vous pouvez essayer des choses et peut-être répondre à la question vous-même.

Essayez d'entrer

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

Dans votre console irb irb et voir la sortie, qu'il devrait être clair ce que fait %.

Et vous devriez vraiment jeter un oeil à l'api rails la documentation (1.9, 1.8.7, 1.8.7), là, vous auriez trouvé la réponse à deux votre question % (Fixnum) avec un autre lien pour une description détaillée de divmod (Numérique):

Renvoie un tableau contenant le quotient et le module obtenus en divisant num par anumérique. > Si q, r = X. divmod (y), alors

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

, Le quotient est arrondi vers -l'infini, comme indiqué dans le tableau suivant:

 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

Exemples

 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]

Pour donner quelques façons de le dire:

• opérateur Modulo
• opérateur restant
• résidu modulaire

, Strictement parlant, si a % b = c, c est l'unique constante telle que

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

Où x == y (mod m) ssi x - y = km pour certains constante k.

Ceci est équivalent au reste. Par un théorème bien connu, nous avons que a = bk + c pour une constante k, où {[1] } est le reste, ce qui nous donne a - c = bk, qui implique évidemment a == c (mod b).

(Existe-t-il un moyen d'utiliser LaTeX sur Stackoverflow?)

Gardez également à l'esprit que la définition de Ruby de l'opérateur modulo (%) diffère de celle de C et Java. Dans Ruby, -7%3 est 2. En C et Java, le résultat est -1 à la place. Dans Ruby, le signe du résultat (pour l'opérateur %) est toujours le même que le signe du deuxième opérande.