Version Ruby: opération confirmée avec 2.5.1.
Jusqu'à présent, je n'ai utilisé la méthode ʻeach` que pour les méthodes de tableau. (Je suis un débutant environ 2 mois après avoir commencé à apprendre sérieusement la programmation.) Lors du développement d'une application personnelle avec Rails, je dis souvent: "Je veux bien traiter les données du tableau obtenues à partir de la table DB et n'afficher que les éléments nécessaires, mais je ne peux pas le faire correctement." En recherchant diverses choses pour résoudre le problème, j'ai beaucoup appris, "Y a-t-il une méthode aussi pratique!", Je vais donc l'écrire sous forme de mémorandum ainsi que pour établir mes connaissances.
J'espère que cela sera utile à n'importe qui.
["Introduction à Ruby pour les professionnels"] de Junichi Ito (https://gihyo.jp/book/2017/978-4-7741-9397-7)
Les articles, livres, etc. de M. Ito sur Qiita sont très faciles à comprendre et sont toujours redevables.
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
Je vais vous expliquer chaque méthode en vérifiant le fonctionnement ci-dessous.
La «méthode de sélection» effectue le traitement spécifié dans le bloc pour chaque élément du tableau. Renvoie un tableau d'éléments dont la valeur de retour est «true».
select.rb
#Je ne veux que des utilisateurs avec un score de 70 ou plus!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
#Utilisez Select pour collecter uniquement les utilisateurs avec un score de 70 ou plus
goukaku_users = users.select { |user| user[:score] >= 70 }
#Vérifiez le contenu de la variable nouvellement créée
p goukaku_users
# =>[{:name=>"Matsuda", :score=>80}, {:name=>"Koike", :score=>90}, {:name=>"Fujisawa", :score=>85}]
#J'ai pu créer un tableau uniquement pour les utilisateurs avec un score de 70 ou plus!
do ... end est écrit sur une ligne de notation en utilisant {}.
C'est dommage, mais je suis désolé s'il est difficile de comprendre le nom de la variable.La «méthode de rejet» est l'opposé de la «méthode de sélection» et est une méthode qui renvoie un tableau qui ne collecte que les éléments dont la valeur de retour du traitement dans le bloc est «false».
reject.rb
#Je ne veux que des utilisateurs avec un score de 70 ou moins!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
#Ne collectez que les utilisateurs avec un score de 70 ou moins avec la méthode de rejet
fugoukaku_users = users.reject { |user| user[:score] > 70 }
#Vérifiez le contenu de la variable nouvellement créée
p fugoukaku_users
# => [{:name=>"Otsuka", :score=>60}, {:name=>"Inoue", :score=>40}, {:name=>"Matsumoto", :score=>50}]
#J'ai pu créer un tableau uniquement pour les utilisateurs avec un score de 70 ou moins!
La méthode keep_if récupère également chaque élément du tableau dans l'ordre et effectue le traitement spécifié dans le bloc. En conséquence, si la valeur de retour est «true», l'élément passé au bloc est laissé dans le tableau, et si la valeur de retour est «false», il est supprimé du tableau.
keep_if.rb
#Je ne veux que des utilisateurs avec un score de 70 ou plus!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
# keep_Utilisez la méthode if pour traiter uniquement les utilisateurs avec un score de 70 ou plus
#Élément d'utilisateurs supprimé avec un score inférieur à 70
users.keep_if { |user| user[:score] >= 70 }
# keep_Après la méthode if
p users
# => [{:name=>"Matsuda", :score=>80}, {:name=>"Koike", :score=>90}, {:name=>"Fujisawa", :score=>85}]
#Les utilisateurs du tableau d'origine peuvent désormais être un tableau composé uniquement d'utilisateurs avec un score de 70 ou plus!
La méthode delete_if récupère également chaque élément du tableau dans l'ordre et effectue le traitement spécifié dans le bloc. En conséquence, si la valeur de retour est «true», l'élément passé au bloc est supprimé du tableau d'origine. Si la valeur de retour est «false», laissez-la dans le tableau.
delete_if.rb
#Je ne veux que des utilisateurs avec un score de 70 ou moins!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
# delete_Utilisez la méthode if pour traiter uniquement les utilisateurs avec un score de 70 ou moins
#Élément d'utilisateurs supprimé avec un score supérieur à 70
users.delete_if { |user| user[:score] > 70 }
# delete_Après la méthode if
p users
# => [{:name=>"Otsuka", :score=>60}, {:name=>"Inoue", :score=>40}, {:name=>"Matsumoto", :score=>50}]
#Les utilisateurs du tableau d'origine peuvent désormais être un tableau composé uniquement d'utilisateurs avec un score de 70 ou moins!
Les méthodes keep_if et delete_if sont les mêmes que la méthode select et la méthode de rejet expliquées en 1 et 2!?
J'ai pensé, mais comparé
select / reject Le tableau d'origine reste le même, mais les éléments qui remplissent les conditions sont collectés et un tout nouveau tableau est renvoyé. Par conséquent, lors de sa réutilisation, assignez-le à une variable. delete_if / keep_if Supprimez les éléments qui remplissent les conditions du tableau d'origine. En d'autres termes, la forme du tableau d'origine lui-même est modifiée. Par conséquent, il peut être réutilisé avec le nom de variable d'origine.
C'est similaire, mais il semble y avoir une telle différence.
La méthode find renvoie le premier élément pour lequel la valeur de retour du processus spécifié dans le bloc est true.
find.rb
#Je veux obtenir le premier utilisateur dont le score des utilisateurs du tableau est de 70 ou plus!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
#Obtenez le premier utilisateur avec un score de 70 ou plus avec la méthode de recherche
goukaku_user = users.find { |user| user[:score] >= 70 }
#Vérifiez le contenu de la variable nouvellement créée
p goukaku_user
# => {:name=>"Matsuda", :score=>80}
#J'ai pu obtenir le premier utilisateur avec un score de 70 ou plus dans le tableau!
Au cas où, essayez de changer la condition du score dans le bloc de 70 à 85 et vérifiez à nouveau.
find.rb
#Je veux obtenir le premier utilisateur avec un score de 85 ou plus parmi les utilisateurs du tableau!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
#Obtenez le premier utilisateur avec un score de 85 ou plus avec la méthode de recherche
goukaku_user = users.find { |user| user[:score] >= 85 }
#Vérifiez le contenu de la variable nouvellement créée
p goukaku_user
# => {:name=>"Koike", :score=>90}
#J'ai pu obtenir le premier utilisateur avec un score de 85 ou plus dans le tableau!
La méthode map renvoie la valeur de retour sous forme de nouveau tableau suite au traitement spécifié dans le bloc pour chaque élément.
map.rb
#Je veux ajouter "san" au nom des utilisateurs du tableau!
users = [
{name: 'Matsuda', score: 80},
{name: 'Otsuka', score: 60},
{name: 'Koike', score: 90},
{name: 'Inoue', score: 40},
{name: 'Matsumoto', score: 50},
{name: 'Fujisawa', score: 85}
]
san_users = users.map { |user| user[:name] + 'M.' }
#Vérifiez le contenu de la variable nouvellement créée
p san_users
# => ["M. Matsuda", "M. Otsuka", "M. Koike", "Inoue", "M. Matsumoto", "M. Fujisawa"]
cette? C'était un peu différent de ce à quoi je m'attendais.
La méthode map semble se comporter un peu différemment des méthodes de tableau décrites jusqu'ici.
En particulier, Au lieu d'évaluer les éléments du tableau d'origine et de transformer les éléments pour renvoyer les valeurs, les valeurs de retour des résultats du traitement sont stockées dans le tableau une par une et le tableau nouvellement créé est renvoyé.
Si vous connaissez la méthode map de javaScript, elle peut être facile à comprendre.
map.rb
#Donc, si vous souhaitez retourner au format de hachage tout en conservant la forme d'origine, écrivez comme suit
san_users = users.map { |user| {name: user[:name]+'M.', score: user[:score]} }
p san_users
# => [{:name=>"M. Matsuda", :score=>80}, {:name=>"M. Otsuka", :score=>60}, {:name=>"M. Koike", :score=>90}, {:name=>"Inoue", :score=>40}, {:name=>"M. Matsumoto", :score=>50}, {:name=>"M. Fujisawa", :score=>85}]
#J'ai pu créer un tableau avec "san" ajouté au nom!
Merci d'avoir lu l'article.
Je suis parfaitement conscient que développer avec Rails et savoir que je ne connais pas la méthode affectera grandement la gamme de choses que je peux faire et le refactoring du code. Je ressens à nouveau l'importance des bases.
Si vous trouvez des erreurs dans le contenu, n'hésitez pas à le signaler et à nous donner votre avis!
Recommended Posts