J'ai combiné while et refait dans mon entreprise, je l'ai implémenté pour qu'il boucle jusqu'à ce que les conditions soient remplies, et j'ai fait le travail dans l'environnement de production, donc la sortie pour écrire une boucle appropriée. (Même avec paiza, c'était une question de temps, ...)
Au moment de la révision du code, on m'a souvent demandé de réécrire avec une seule ligne, donc j'écrirai une notation de ligne pour autant que je puisse comprendre.
for (Je ne pense pas qu'il soit beaucoup utilisé en Ruby ...) L'instruction for est utilisée lorsque vous souhaitez répéter le traitement pour la plage de l'objet de plage spécifié ou obtenir les éléments du tableau dans l'ordre.
ruby.rb
for i in 1..3 do
p "#{i}Deuxième boucle"
end
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
Il est possible de mettre les éléments du tableau dans l'ordre, mais je ne pense pas qu'il y ait beaucoup de gens qui écrivent pour, et il n'y a aucun mérite, alors je vais l'omettre.
each C'est un chacun familier en Ruby.
Chaque méthode est une méthode qui peut être utilisée dans les tableaux, les objets de plage, le hachage et l'énumérateur, et vous pouvez obtenir les éléments contenus dans l'objet dans l'ordre.
ruby.rb
#Tableau
[1,2,3].each do |i|
p "#{i}Deuxième boucle"
end
#Array une doublure
[1,2,3].each {|i| p "#{i}Deuxième boucle"}
#Objet Range
(1..3).each do |i|
p "#{i}Deuxième boucle"
end
#Range object one liner
(1..3).each {|i| p "#{i}Deuxième boucle"}
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
«Chacun» est principalement utilisé plutôt que «pour».
while Ensuite, c'est pendant (je l'ai fait pendant) while boucle tant que la condition spécifiée est vraie.
L'instruction for et chaque méthode répètent le processus pour l'élément spécifié, tandis que l'instruction while répète le processus jusqu'à ce que l'expression conditionnelle devienne fausse.
ruby.rb
i = 1
while i <= 3 do #faire est facultatif et fonctionne sans écrire
p "#{i}Deuxième boucle"
i += 1
end
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
Je pense qu'il y a plus de risques que chaque fois que ce sera le cas à l'avenir. Il n'y a pas de limite supérieure claire et fiable, et vous définissez vous-même les conditions, alors utilisez-la systématiquement ...
Si vous le comprenez et l'utilisez, il sera flexible et incroyablement facile à utiliser.
until Pensez-y comme l'exact opposé de while. Ce n'est peut-être pas très utile, mais pour le moment.
ruby.rb
i = 1
until i > 3 do #faire est facultatif et fonctionne sans écrire
p "#{i}Deuxième boucle"
i += 1
end
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
La condition est inversée par rapport à la précédente et elle tournera à moins que le i prédéfini ne dépasse 3. Je ne le recommande pas car c'est difficile à comprendre, mais si vous n'utilisez pas la valeur numérique comme condition, cela semble utile.
loop Cela ne sortira que si vous le terminez par une pause. Vous pouvez définir des conditions flexibles, mais je pense que c'est aussi une boucle assez risquée.
ruby.ruby.rb
i = 1
loop{
p "#{i}Deuxième boucle"
i += 1
break if i == 4
}
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
Lorsque la variable définie "i" devient égale à 4, elle se rompt.
times Je l'utilise beaucoup ces derniers temps, mais je l'aime vraiment (rires) Je pense qu'il est préférable de le tourner le nombre de fois spécifié.
ruby.rb
#Lors de l'utilisation d'une valeur de degré de boucle
3.times do |i|
p i
end
#Bon mot
3.times {|i| p i}
#=>"0"
#=>"1"
#=>"2"
#Lorsque vous n'utilisez pas la valeur de degré de boucle
3.times do
p "C'est une boucle, ça tourne 3 fois"
end
#Bon mot
3.times {p "C'est une boucle, ça tourne 3 fois"}
#=>"C'est une boucle, ça tourne 3 fois"
#=>"C'est une boucle, ça tourne 3 fois"
#=>"C'est une boucle, ça tourne 3 fois"
Elle est recommandée car elle est la plus explicite et la plus intuitive lorsque vous tournez le nombre de fois spécifié.
upto downto Ceci est également souvent utilisé lorsque vous voulez une valeur numérique tout en tournant dans une boucle. Je l'aime personnellement.
upto est une boucle jusqu'à ce que le nombre spécifié soit atteint, dans laquelle la variable est incrémentée de 1, et downto est l'opposé de upto, qui est une boucle jusqu'à ce que le nombre spécifié soit atteint, au cours de laquelle la variable est décrémentée de 1.
ruby.rb
#upto
1.upto(3) do |i|
p "#{i}Deuxième boucle"
end
#jusqu'à une doublure
1.upto(3) {|i| p "#{i}Deuxième boucle"}
#=>"1ère boucle"
#=>"Deuxième boucle"
#=>"3e boucle"
#downto
3.downto(1) do |i|
p i
end
#jusqu'à une doublure
3.downto(1) {|i| p i}
#=>3
#=>2
#=>2
map map parcourt les blocs autant de fois qu'il y a d'éléments dans le tableau et renvoie le tableau résultant. map! n'affecte pas la valeur d'origine, tandis que map! réécrit la valeur d'origine. En outre, Ruby a une méthode de collecte, qui est un autre nom pour la méthode de carte.
Il est pratique de traiter dans un tableau et de recevoir le résultat sous forme de tableau.
ruby.rb
arr = [1, 2, 3]
arr_new = arr.map { |x| x * 2 }
p arr_new
#=>[2, 4, 6]
Au fur et à mesure que je m'habitue à Ruby, je pense que j'ai tendance à tout écrire dans chacun (j'essaye aussi de ne pas faire ça). Cependant, il existe étonnamment de nombreux modèles qui peuvent être appliqués avec précision lorsque vous utilisez la carte plutôt que chacun.
each.rb
#each
int_list = (1..3).to_a
int_to_double = []
int_list.each do |i|
int_to_double << i * 2
end
p int_to_double
#=>[2, 4, 6]
Je définis un tableau juste pour générer une nouvelle liste. C'est en utilisant la carte ...
map.rb
#map
int_list = (1..3)
int_to_double = int_list.map do |i|
i * 2
end
p int_to_double
#Bon mot
int_list = (1..3)
int_to_double = int_list.map {|i| i * 2}
p int_to_double
#=>[2, 4, 6]
Vous pouvez écrire si proprement.
De plus, il existe encore de nombreuses syntaxes et méthodes répétitives dans Ruby, je les ajouterai donc à nouveau après avoir vérifié le timing.
Si vous souhaitez traiter un tableau et générer un nouveau tableau, utilisez map. Si vous souhaitez retirer le contenu du tableau un par un et effectuer un branchement conditionnel, etc., utilisez chaque Si vous souhaitez définir des conditions flexibles et exécuter une boucle, utilisez while (utilisez-le systématiquement) Si vous connaissez le nombre de boucles à l'avance, réglez les heures Si vous voulez obtenir une valeur qui augmente ou diminue de 1 tout en tournant la boucle, utilisez upto, downto.
Je l'utilise correctement comme ça.
Il y a beaucoup de choses que vous voulez faire tout en tournant la boucle, donc le moyen le plus intuitif est de sélectionner et d'implémenter la boucle intelligente.
Recommended Posts