Ce qui ne l'opérateur % faire en Ruby dans N % 2?

En réponse à la question "Quel est le symbole % faire ou dire en Ruby?" Il est:

1) Le modulo opérateur binaire (comme il a été mentionné)

17 % 10 #=> 7 

2) L'alternative délimiteur de chaîne de jeton

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

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

Indépendamment de la façon dont il fonctionne, l'opérateur modulo est probablement pas le meilleur code pour la fin (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.

Si c'est afficher le code et utilisé pour déterminer (par exemple) de la ligne alternant les couleurs, vous pouvez être en mesure de le faire sans le contre tout en utilisant le haut-Rails helper cycle(). Par exemple, vous pouvez utiliser cycle('odd','even') comme un nom de classe pour une ligne de tableau, éliminant le compteur et les environs si/alors logique.

Une autre pensée: si c'est dans un each bloc, vous pouvez être en mesure d'utiliser each_with_index et éliminer le superflu variable compteur.

Mon refactoring de 0,02$.

Son l'opérateur modulo.

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

C'est une question très simple. % est le modulo en chair et en os if counter % 2 == 1 résultats de true pour chaque nombre impair et false pour chaque nombre pair.

Si vous êtes en train d'apprendre ruby, tu dois 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 irb de la cisr de la console et de voir le résultat, ce qu'il devrait être clair que % n'.

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

Retourne un tableau contenant le quotient et le module obtenu en divisant num par aNumeric. > 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]