・ Le tutoriel Rails est la 4ème édition ・ Cette étude est le 3e tour (2e tour après le chapitre 9) ・ L'auteur est un débutant qui a fait tout Progate
・ Si vous le lisez, vous ne le comprendrez pas. ・ Recherchez et résumez les termes que vous ne comprenez pas (en bas de l'article, glossaire). ・ Plongez dans ce que vous ne comprenez pas. ・ Travaillez sur tous les exercices. ・ Ne copiez pas le code autant que possible.
Ceci est le chapitre 4. Je me souviens que ce chapitre était redondant. Je vais le faire sans rien dire. Cliquez ici pour la BGM d'aujourd'hui. matryoshka "zatracenie[full album]"
・ Méthode nouvellement créée = aide personnalisée ・ ** Helper utilisé sur toutes les pages: installé dans app / helpers / application_helper.rb ** ・ ** Helper utilisé uniquement par un contrôleur spécifique: installé dans app / helpers / (nom du contrôleur correspondant) .rb **
-La méthode put renvoie nil comme valeur de retour. Le caractère de saut de ligne \ n est ajouté à la fin de la sortie. -La méthode d'impression n'ajoute pas de caractère de saut de ligne. -Les expressions ne peuvent pas être développées entre guillemets simples. Utile lorsque vous souhaitez conserver les caractères saisis tels quels sans les échapper
Remplacez une ville / quartier / ville / village approprié dans la variable ville et une préfecture appropriée dans la variable préfecture. → city = "sapporo" prefecture = "hokkaido" (parce que je regarde le match à Consadore Sapporo maintenant)
Créons une chaîne de caractères pour une adresse telle que "Shinjuku-ku, Tokyo" en utilisant les variables et le développement de formule créés précédemment. Utilisez des mises pour la sortie. → Ci-dessous
>> puts prefecture + " " + city
hokkaido sapporo
=> nil
>> puts prefecture + "\t" + city
hokkaido sapporo
=> nil
>> puts prefecture + '\t' + city
hokkaido\tsapporo
=> nil
>> s = "racecar"
=> "racecar"
>> s.length
=> 7
>> s.reverse
=> "racecar"
>> s == s.reverse
=> true
>> puts "It's a palindrome!" if s == s.reverse
It's a palindrome!
=> nil
>> s = "onomatopoeia"
=> "onomatopoeia"
>> puts "It's a palindrome!" if s == s.reverse
=> nil
>> def palindrome_tester(s)
>> if s == s.reverse
>> puts "It's a palindrome!"
>> else
>> puts "It's not a palindrome."
>> end
>> end
=> :palindrome_tester
>> palindrome_tester("racecar")
It's a palindrome!
=> nil
>> palindrome_tester("onomatopoeia")
It's not a palindrome.
=> nil
>> palindrome_tester("racecar").nil?
It's a palindrome!
=> true
>> a = "A man, a plan, a canal, Panama".split(',')
=> ["A man", " a plan", " a canal", " Panama"]
2. Ensuite, essayez de remplacer le résultat (chaîne de caractères) de la concaténation des éléments de la variable a dans la variable s. → Ci-dessous
>> s = a.join
=> "A man a plan a canal Panama"
>> palindrome_tester(s.split(' ').join.downcase)
It's a palindrome!
=> nil
>> A = ("a".."z").to_a
=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
>> A[6]
=> "g"
>> A[-7]
=> "t"
>> (0..16).each { |i| puts i**2 }
0
1
4
9
16
25
36
49
64
81
100
121
144
169
196
225
256
=> 0..16
2. Définissez une méthode appelée hurler (crier fort). Cette méthode prend un tableau d'éléments de chaîne, concatène chaque élément, puis le met en majuscule et renvoie le résultat. Par exemple, lorsque vous exécutez yeller (['o', 'l', 'd']), il réussit si le résultat "OLD" est renvoyé. Conseil: essayez d'utiliser les méthodes map, upcase et join. → Ci-dessous. Je me demande si c'est une manière plus intelligente. Vous pouvez simplement mettre une chaîne de caractères dans l'argument au lieu d'un tableau.
>> def yeller(s)
>> s.map(&:upcase).join
>> end
=> :yeller
>> yeller(['o','l','d'])
=> "OLD"
>> def random_subdomain
>> ("a".."z").to_a.shuffle[0..7].join
>> end
=> :random_subdomain
>> random_subdomain
=> "unwdemsp"
>> def string_shuffle(s)
>> s.split('').shuffle.join
>> end
=> :string_shuffle
>> string_shuffle("foobar")
=> "arbfoo"
>> n = { one: 'uno', two: 'dos', three: 'tres' }
=> {:one=>"uno", :two=>"dos", :three=>"tres"}
>> n.each do |key, value|
?> puts "#{key}L'espagnol est#{value}"
>> end
L'espagnol pour un est uno
deux espagnol est dos
trois espagnol est tres
=> {:one=>"uno", :two=>"dos", :three=>"tres"}
2. Créez trois hachages, person1, person2 et person3, ajoutez les clés: first et: last à chaque hachage et entrez une valeur appropriée (nom, etc.). Ensuite, essayez de créer un hachage des paramètres de hachage comme ceci: 1.) Attribuez à person1 la valeur des paramètres clés [: père], 2). Attribuez à person2 la valeur des paramètres clés [: mère], 3). Attribuez à person3 la valeur des paramètres clés [: enfant]. Enfin, vérifiez le hachage du hachage pour voir s'il s'agit de la valeur correcte. (Par exemple, assurez-vous que les paramètres [: père] [: premier] correspondent à personne1 [: premier]) → Ci-dessous. Vous êtes un partisan de Gamba qui comprend la signification de chaque nom et clé. (De la formation de départ de la section 14 de la saison 2020)
>> person1 = { first: "Yuki", last: "Yamamoto" }
=> {:first=>"Yuki", :last=>"Yamamoto"}
>> person2 = { first: "Yosuke", last: "Ideguchi" }
=> {:first=>"Yosuke", :last=>"Ideguchi"}
>> person3 = { first: "Shu", last: "Kurata" }
=> {:first=>"Shu", :last=>"Kurata"}
>> params = { anchor: person1, rih: person2, lih: person3 }
=> {:anchor=>{:first=>"Yuki", :last=>"Yamamoto"}, :rih=>{:first=>"Yosuke", :last=>"Ideguchi"}, :lih=>{:first=>"Shu", :last=>"Kurata"}}
>> params[:anchor][:first] == person1[:first]
=> true
3. Essayez de définir un utilisateur appelé par hachage. Ce hachage a trois clés: nom ,: email et: password_digest, dont chaque valeur est attribuée à votre nom, votre adresse e-mail et une chaîne aléatoire de 16 caractères. → Ci-dessous
>> user = { name: "tk", email: "[email protected]", password_digest: ("a".."z").to_a.shuffle[0..15].join }
=> {:name=>"tk", :email=>"[email protected]", :password_digest=>"socxlgerjatyinbw"}
4. Utilisez l'API Ruby (ou Rurima Search) pour découvrir la méthode de fusion de la classe Hash. Pouvez-vous deviner quel sera le résultat sans exécuter le code suivant? Si vous pouvez le deviner, essayez d'exécuter le code pour voir si vous deviniez.
{ "a" => 100, "b" => 200 }.merge({ "b" => 300 })
→ Honnêtement, même si vous recherchez par Rurima Search Je ne comprends pas vraiment. Le japonais n'est pas japonais. Donc, si vous comptez normalement sur Google Sensei, la méthode de fusion est une méthode qui combine plusieurs hachages. Ensuite, le hachage de fusion "avant" est combiné avec le hachage de fusion "après", mais s'il existe un hachage en double, le hachage "après" est écrasé. Le résultat ci-dessus doit donc être b égal à 300. Les résultats réels sont ci-dessous. Ça rentre.
>> { "a" => 100, "b" => 200 }.merge({ "b" => 300 })
=> {"a"=>100, "b"=>300}
>> r = 1..10
=> 1..10
2. Utilisez maintenant la classe Range et la nouvelle méthode pour créer un objet range de 1 à 10. Conseil: vous devez transmettre deux arguments à la nouvelle méthode. → Ci-dessous
>> r2 = Range.new(1,10)
=> 1..10
3. Utilisez l'opérateur de comparaison == pour vérifier que les objets créés dans les deux tâches ci-dessus sont identiques. → Ci-dessous
>> r == r2
=> true
>> r = Range.new(1,3)
=> 1..3
>> r.class
=> Range
>> r.class.superclass
=> Object
>> r.class.superclass.superclass
=> BasicObject
>> r.class.superclass.superclass.superclass
=> nil
Puis Hash
>> h = {}
=> {}
>> h.class
=> Hash
>> h.class.superclass
=> Object
>> h.class.superclass.superclass
=> BasicObject
>> h.class.superclass.superclass.superclass
=> nil
Enfin symbole
>> s = :symbol
=> :symbol
>> s.class
=> Symbol
>> s.class.superclass
=> Object
>> s.class.superclass.superclass
=> BasicObject
>> s.class.superclass.superclass.superclass
=> nil
2. Omettez self.reverse self dans l'extrait 4.15 et écrivez reverse pour voir si cela fonctionne. → Ci-dessous
>> class Word < String
>> def palindrome?
>> self == reverse
>> end
>> end
=> :palindrome?
>> s = Word.new("level")
=> "level"
>> s.palindrome?
=> true
s = Word.new("racecar")
=> "racecar"
>> s.palindrome?
=> true
>> s = Word.new("onomatopoeia")
=> "onomatopoeia"
>> s.palindrome?
=> false
>> s.downcase.palindrome?
=> true
2. Reportez-vous au Listing 4.16 et essayez d'ajouter la méthode shuffle à la classe String. Astuce: le Listing 4.12 est également utile.
>> def shuffle
>> self.split('').shuffle.join
>> end
>> end
=> :shuffle
>> "foobar".shuffle
=> "fobaro"
>> class String
>> def shuffle
>> split('').shuffle.join
>> end
>> end
=> :shuffle
>> "foobar".shuffle
=> "boroaf"
$git clone https du référentiel distant correspondant
Et quand j'ai essayé d'entrer dans le sujet principal, j'ai eu diverses erreurs ... budle install - sans production ni rails db: migrer pour résoudre. Vous avez créé avec succès un objet utilisateur.
>> user = User.new
=> #<User id: nil, name: nil, email: nil, created_at: nil, updated_at: nil>
2. Vérifiez la hiérarchie d'héritage de la classe d'objets utilisateur générée. → Ci-dessous
>> user.class
=> User(id: integer, name: string, email: string, created_at: datetime, updated_at: datetime)
>> user.class.superclass
=> ApplicationRecord(abstract)
>> user.class.superclass.superclass
=> ActiveRecord::Base
>> user.class.superclass.superclass.superclass
=> Object
>> user.class.superclass.superclass.superclass.superclass
=> BasicObject
>> user.class.superclass.superclass.superclass.superclass.superclass
=> nil
example_user.rb
class User
attr_accessor :first_name, :last_name, :email
def initialize(attributes = {})
@first_name = attributes[:first_name]
@last_name = attributes[:last_name]
@email = attributes[:email]
end
def full_name
"#{@first_name} #{@last_name}"
end
def formatted_email
"#{self.full_name} <#{@email}>"
end
end
Sur la console
>> require './example_user'
=> true
user = User.new(first_name: "t" ,last_name: "k", email: "[email protected]")
=> #<User:0x00000000030715e0 @first_name="t", @last_name="k", @email="[email protected]">
>> user.formatted_email=> "t k <[email protected]>"
2. Définissons une méthode de nom alphabétique qui renvoie dans un format tel que "Hartl, Michael" (une chaîne de caractères dans laquelle le nom et le prénom sont séparés par une virgule + un espace demi-largeur). → Ci-dessous
def full_name
"#{@first_name} #{@last_name}"
end
>> require './example_user'=> true
>> user = User.new(first_name: "Ysuhito", last_name: "Endo", email: "[email protected]")
=> #<User:0x0000000003059968 @first_name="Ysuhito", @last_name="Endo", @email="[email protected]">
>> user.full_name.split=> ["Ysuhito", "Endo"]
>> user.alphabetical_name.split(', ').reverse
=> ["Ysuhito", "Endo"]
>> user.full_name.split == user.alphabetical_name.split(', ').reverse
=> true
-Utiliser correctement le fichier de définition d'assistance selon qu'il est utilisé dans son ensemble ou dans un contrôleur spécifique. ・ Imprimez l'orientation de l'objet dans vos sens. Tout est un objet. -Les classes peuvent être héritées. Il y a toujours une classe originale. Puisqu'il est hérité, diverses fonctions peuvent être utilisées. -La méthode de classe est définie dans la classe et la méthode d'instance est définie dans l'instance. ・ () Ou {} peut être omis. Par exemple, {} dans le dernier bloc de l'argument. -: Le nom est un symbole. La notation de hachage est généralement écrite comme ~~: "mojiretu". ・ Puisqu'il y avait des mots que je ne comprenais pas, je les ai résumés dans le glossaire.
Ce chapitre a été beaucoup de travail. Mais la connaissance des abréviations peut être importante pour la lecture de code. À partir du prochain chapitre 5, nous reviendrons sur le développement d'applications!
⇨ Allez au chapitre 5! ⇦ Cliquez ici pour le chapitre 3 Cliquez ici pour les conditions préalables et le statut de l'auteur pour l'apprentissage
・ Fonctions intégrées Une fonction qui est préparée à l'avance pour des spécifications telles que les langages de programmation et peut être utilisée en standard. En revanche, une fonction définie et implémentée par un programmeur en code est appelée "fonction définie par l'utilisateur".
・ API (interface de programmation d'application) Une convention qui définit la procédure et le format de données pour appeler et utiliser les fonctions d'un certain programme informatique (logiciel) et les données à gérer à partir d'un autre programme externe. L'utilisation de l'API présente les avantages de rationaliser le développement logiciel, d'améliorer la sécurité et d'obtenir facilement les dernières informations.
・ Escape (caractère d'échappement / traitement) Un caractère qui a une fonction (telle que ), telle que la transformation d'une chaîne de caractères significative en une simple chaîne de caractères ou vice versa.
・ Littéral Les lettres et les chiffres écrits dans le code source.
・ Nid Un état ou une structure dans lequel quelque chose de la même forme et du même type (une taille plus petite) est contenu dans quelque chose.
・ Accessir Une méthode fournie pour l'accès externe aux variables membres (attributs, propriétés) à l'intérieur d'un objet dans la programmation orientée objet. Il est prêt à masquer les variables membres à l'intérieur de l'objet et à les empêcher d'être directement référencées de l'extérieur.
・ Variables membres Une variable d'instance.
Recommended Posts