[RUBY] Traitement en boucle

Types de traitement itératif

Il semble qu'il existe ** chaque ** méthode, ** pour ** instruction, ** whil, jusqu'à ** instruction, ** times ** méthode, ** up_to ** méthode, etc. comme types de traitement itératif Ruby. Je ne comprends pas quel processus doit être utilisé lors de l'itération avec l'algorithme de paiza, je vais donc résumer l'utilisation et les fonctionnalités.

Première prémisse

Le traitement itératif est souvent utilisé avec des tableaux (objets pouvant stocker plusieurs données dans l'ordre (classe Array)) et des blocs (groupes de traitements pouvant être passés en tant qu'arguments de méthode). Dans la plupart des cas, Ruby effectue une itération en utilisant la méthode each. * Dans plusieurs langues, la syntaxe for et foreach est souvent utilisée.

chaque méthode

Plutôt que Ruby effectuant un traitement itératif en tant que fonction de langage, chaque méthode du tableau exécute un traitement itératif. Le rôle de chaque méthode est d'extraire les éléments du tableau jusqu'à la fin dans l'ordre. Comment gérer celui extrait est décrit dans ** block **.

#Exemple(Traitement pour ajouter des éléments d'un tableau)
numbers = [1, 2, 3, 4]
sum = 0
numbers.each do |n|
  sum += n
end
sum #=> 10

Qu'est-ce qu'un bloc

Le bloc est la partie suivante du code ci-dessus.|n|N estArgument de blocage(Le nom est gratuit)Les éléments du tableau transmis par chaque méthode sont saisis.

#Partie de bloc

             do |n|
  sum += n
end

Bloc (pas de version de saut de ligne)

#do ..Au lieu de la fin{}utilisation

numbers.each {|n| sum += n}

méthode des temps

Si vous souhaitez simplement répéter le processus n fois sans utiliser de tableau, utilisez la méthode times de la classe Integer.

sum = 0
#Répétez le processus 5 fois. 0 pour n,1,2,3,4 est entré.
5.times {|n| sum += n}  or  5.times{sum += 1}
sum #=> 10

méthodes up et downt

Si vous souhaitez traiter quelque chose tout en incrémentant le nombre de n à m par un, utilisez la méthode upto de la classe Integer. À l'inverse, une méthode downto qui réduit un par un.

#jusqu'à la méthode
a = []
10.upto(14) {|n| a << n}
a #=> [10, 11, 12, 13 ,14] 

#downto méthode
a = []
14.doentown(10){|n| a << n}
a #=> [14 ,13 ,12 ,11 ,10]

instructions while et until

Syntaxe pour le traitement itératif. Exécute si l'expression conditionnelle après while est vraie. Exécute si l'expression conditionnelle après jusqu'à est fausse.

• Si true est utilisé après while, un traitement en boucle infinie peut être effectué. Utilisez la pause pour vous échapper.

#déclaration while
a = []
while a.size < 5
  a << 1
end
a #=> [1 ,1 ,1 ,1 ,1]

#jusqu'à la déclaration
a = [10 ,20 ,30 ,40 ,50 ]
until a.size <= 3 #Continuez à effacer le dernier élément sauf s'il y a 3 éléments ou moins dans le tableau a.
  a.delete(-1)
end
a #=> [10 ,20 ,30]

pour déclaration

Vous pouvez penser que l'instruction for a le même objectif que chaque méthode. Cependant, Ruby semble être plus courant d'utiliser la méthode each.

numbers = [1 ,2 ,3 ,4]
sum = 0
for n in numbers 
  sum += n
end
sum #=> 10

#Il est également possible de mettre faire et écrire sur une seule ligne.
for n in numbers do sum += end

Impressions de résumer

Pour le moment, il semble bon d'apprendre diverses méthodes en utilisant d'autres méthodes cartographiques basées sur chaque méthode.