Une boucle dans un tableau à l'étape

Je veux regarder tous les n-ième élément d'un tableau. En C++, je ferais ceci:

for(int x = 0; x<cx; x+=n){
    value_i_care_about = array[x];
    //do something with the value I care about.  
}

Je veux faire la même chose en Ruby, mais ne peut pas trouver un moyen de "step". Un while boucle pourrait faire le travail, mais je trouve ça de mauvais goût de l'utiliser pour une taille connue, et qu'il y ait un mieux (plus de Ruby) manière de faire.

Semble que google pourrait avoir répondu à ce un
Rien à propos de l'étape a pu être trouvé 🙂 chaque.. ou pour boucle est facile à trouver.. je veux faire tous les 5 ou 10 ou le 9 élément dans le tableau
Benjamin réponse est incorrecte. Vous devriez regarder Levi's ou David réponse.
Oui, il est logique que 1.step(3, 2) donne 1 et 3. Dans ce code, l'étape est de 2, de sorte que le deuxième élément est ignoré. Qui vous laisse avec 1 et 3.
Ouais je vois comment cela fonctionne maintenant. Merci à tous.
Par ailleurs, cela n'a rien à voir avec des Rails, c'est un Rubis question.

InformationsquelleAutor baash05 | 2012-10-23

40

Gammes ont un step méthode que vous pouvez utiliser pour passer à travers les indices:
```
(0..array.length - 1).step(2).each do |index|
  value_you_care_about = array[index]
end
```
Ou si vous êtes à l'aise à l'aide de ... avec les plages de la suite est un peu plus concis:
```
(0...array.length).step(2).each do |index|
  value_you_care_about = array[index]
end
```
- Vous pouvez utiliser (0...array.length) au lieu de (0..array.length - 1)
InformationsquelleAutor

array.each_slice(n) do |e, *_|
  value_i_care_about = e
end

InformationsquelleAutor sawa

5

Suffit d'utiliser l'étape() la méthode de l'aire de classe qui retourne un agent recenseur
```
(1..10).step(2) {|x| puts x}
```
- nice. Pas en amour avec l'idée de la création d'un million d'habitants et où un int pour faire le travail en c++.. mais cool
InformationsquelleAutor boctulus
1

Nous pouvons itérer tout en sautant sur une plage de numéros à chaque itération par exemple:
```
1.step(10, 2) { |i| print "#{i} "}
```
http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators/

Donc quelque chose comme:
```
array.step(n) do |element|
  # process element
end
```
- Vous avez manqué le peu sur l'étape. C'était l'important.
- Juste se sentir un peu sous le temps ce soir =D
- Cela ne fonctionne pas. Array n'ont pas de step méthode, de sorte que vous aurez "Undefined method pour l'étape". 1.step(10,2) fonctionne, mais qui n'a pas d'itérer sur un tableau. Levi a la bonne réponse.
- absolument vrai
- Ouais.. mais en Ben de la défense.. c'était assez pour le comprendre. Et de Levi's n'a pas d'itérer sur le tableau. Deux excellentes réponses.
InformationsquelleAutor bdeonovic
0

Ce est un excellent exemple de l'utilisation de l'opérateur modulo %

Lorsque vous saisissez ce concept, vous pouvez l'appliquer dans un grand nombre de différents langages de programmation, sans avoir à les connaître et à l'extérieur.
```
step = 2
["1st","2nd","3rd","4th","5th","6th"].each_with_index do |element, index|
  puts element if index % step == 1
end

#=> "2nd"
#=> "4th"
#=> "6th"
```
- a voter pour toi en bas... si n est de 1000 et je l'ai 10000 éléments que je viens de faire 10000 si je n'ai pas besoin d'obtenir 10 éléments.
- Je me demandais juste pourquoi il a obtenu downvoted.. merci de me laisser savoir
- Bien sûr, vous êtes tout à fait à droite avec qui. L'impact négatif devient plus grand, le plus grand que votre taille est. Si vous êtes aussi curieux que moi tout à l'heure, voir l'important résultats des tests dans ce résumé: gist.github.com/3936015
- excellente recherche de dave. Chaque fois qu'une comparaison est dans la boucle, il est exécuté à chaque fois.. si vous pouvez obtenir si est hors de votre boucle, elle s'exécute plus rapidement. J'aime regarder mes cycles et de laisser l' .... prendre soin d'eux-mêmes.
- alors, je vais juste remplacer mon ifs avec unless... jk 😉
InformationsquelleAutor doesterr

class Array
def step(interval, &block)
    ((interval -1)...self.length).step(interval) do |value|
        block.call(self[value])
    end
end
end

Vous pouvez ajouter la méthode à la classe Array

InformationsquelleAutor syllabix

0

Ce sujet:
```
> [1, 2, 3, 4, 5, 6, 7].select.each_with_index { |_,i| i % 2 == 0 }
=> [1, 3, 5, 7]
```
Chaînage des itérateurs est très utile.
- Euh, peut-être, mais dans ce cas tout à fait inutile. Suffit d'utiliser la forme de bloc de sélectionner: [1, 2, 3, 4, 5, 6, 7].select(&:odd?)
InformationsquelleAutor Jurriaan

Vous devez vous connecter pour publier un commentaire.