[Ruby] Liste des commandes de base

[Ruby] Liste des commandes de base

Liste et exemples de commandes Ruby de base.

table des matières

1. [Différence entre put, print, p](Différence entre # met-print-p)
2. Constante
3. [Affichage de la liste des classes d'objets (.class)](Classe d'affichage de la liste des classes d'objets #Object)
4. [Affichage de la liste des méthodes d'objet (.methods)](Méthodes d'affichage de la liste des méthodes #Object)
5. [Calcul après la virgule décimale](#Calcul après la virgule décimale)
6. [Spécifiez le nombre de chiffres pour afficher le point décimal](# Spécifiez le nombre de chiffres pour afficher le point décimal)
7. [format (ou sprintf)](#format ou -sprintf)
8. [méthode ronde, plafond, plancher](# méthode ronde-plafond-plancher)
9. [Chaîne de caractères](# chaîne de caractères)
10. [Expression expansion](#Expression expansion)
11. Concaténer
12. [Répéter](chaîne de caractères #Repeat)
13. [Nombre de caractères (.length)](# Longueur du nombre de caractères)
14. [Convertir de chaîne en nombre (.to_i)](#Convertir de chaîne en nombre en_i)
15. [Array](# array)
16. [Obtenir l'élément du tableau](# Obtenir l'élément du tableau)
17. [Add element (push ou <<)](#Add element push-or-)
18. [Get array length (size, length, count)](# Get array length size-length-count)
19. Trier
20. [Objet Hash](#Hash Object)
21. Créer et appeler (#Create and Call)
22. [Add Element](#Add Element)
23. [Supprimer l'élément (.delete (: nom de la clé))](# Supprimer l'élément supprimer le nom de la clé)
24. [Branche conditionnelle](# Branche conditionnelle) 13. if 14. case,when
25. [Répéter](# Répéter) 14. for in 15. each do 16. while 17. times do 18. loop + break
26. [Skip (if next)](#Skip if-next)
27. Méthode Create and Call (méthode #Create and Call)
28. Créer une classe et créer une instance (#Create Class et Create Instance)

## Différence entre met, print, p Il existe des différences subtiles entre eux, mais il suffit de se souvenir de p pour les put.

La différence entre eux est la présence ou l'absence de sauts de ligne et la présence ou l'absence de représentation de type.

Méthode	puts	p	print
Utilisation	Pour la production	Pour le débogage	Des restes de python?
nouvelle ligne	Oui	Oui	Aucun
Représentation de type	Aucun	Oui	Aucun

Différence entre put et print (présence ou absence de sauts de ligne)

puts "Bonjour"
puts 123

#Bonjour
#123


print "Bonjour"
print 123

#Bonjour 123

▼ Dans le cas de "p", des guillemets doubles sont ajoutés au texte de la chaîne de caractères.

Différence entre put et p (présence ou absence de représentation de type)

puts "Bonjour"
puts 123

#Bonjour
#123


p "Bonjour"
p 123

#"Bonjour"
#123

## constant -Définir les variables en majuscules ・ Utilisez Ansco pour connecter plusieurs mots -Une erreur se produit lors de l'écrasement ou de la redéfinition

TAX_RATE = 1.0
puts TAX_RATE

#Écraser l'instruction
TAX_RATE = 1.5

#warning: already initialized constant TAX_RATE
#warning: previous definition of TAX_RATE was here

## Affichage de la liste des classes d'objets (.class) `p objet.classe`

p 1.1.class

#Float

## List, méthode d'objet (.methods) `p object.methods`

p 1.1.methods

#[:-@, :**, :<=>, :<=, :>=, :==, :===, :eql?, :%, :inspect, :*, :+, :-, :/, :<, :>, :to_int, :coerce, :to_s, :divmod, :to_i, :to_f, :to_r, :fdiv, :modulo, :abs, :magnitude, :zero?, :finite?, :infinite?, :floor, :ceil, :round, :truncate, :positive?, :negative?, :numerator, :denominator, :rationalize, :arg,Omis ci-dessous...

p "abc".methods

#[:encode, :encode!, :unpack, :unpack1, :include?, :%, :*, :+, :count, :partition, :to_c, :sum, :next, :casecmp, :casecmp?, :insert, :bytesize, :match, :match?, :succ!, :<=>, :next!, :upto,Omis ci-dessous...

## Calcul après la virgule décimale Si ".0" est ajouté à l'entier calculé, il sera affiché jusqu'à la virgule décimale. ┗ L'un ou l'autre ┗ Ne spécifie pas le nombre de chiffres ┗ Tronquer sinon

p 8.0 / 3
p 8/3.0
p 8/3

#2.6666666666666665
#2.6666666666666665
#2

## méthode ronde, au plafond, au sol `.round`: arrondi `.ceil`: Arrondir `.floor`: tronquer

p 8.0/7
p (8.0/7).round
p (8.0/7).ceil
p (8.0/7).floor

#1.1428571428571428
#1   round
#2   ceil
#1   floor

## Spécifiez le nombre de chiffres pour afficher la virgule décimale ### format (ou sprintf) `format ("%. Nombre de chiffres f ", numéro cible)`

calc = 8/3.0

puts format("%.2f", calc)
puts sprintf("%.2f", calc)

#2.67
#2.67

méthode ronde, au plafond, au sol

ʻObject.round (nombre de chiffres) ʻObject.ceil (nombre de chiffres) ʻObjet .floor (nombre de chiffres) `

puts calc.round(2)
puts calc.round(3)

#2.67
#2.667


puts calc.ceil(2)
puts calc.ceil(3)

#2.67
#2.667


puts calc.floor(2)
puts calc.floor(3)

#2.66
#2.666

## Chaîne

Expression d'expression

met" # {formules et variables} " ┗ Double devis ┗ Sortie telle quelle si elle est unique

puts "tax #{1000 * 0.10}"
#tax 100.0

puts 'tax #{1000 * 0.10}'
#tax #{1000 * 0.10}

### Mise en relation `met chaîne + chaîne`

puts "Hello" + "World"

#HelloWorld

### Répéter la chaîne `met la chaîne * n`

puts "Hello★" * 5

#Hello★Hello★Hello★Hello★Hello★

### Nombre de caractères (.length) `met string.length`

str = "hello world"
p str.length

#11

### Convertir de chaîne en nombre (.to_i) `met string.to_i`

str = "123"

p str
p str.to_i

#"123"
#123

## Tableau ### Obtenir les éléments d'un tableau `Variable = [,,,]`

colors = ["red", "blue", "white"]

p colors[0]
p colors[3] #nil
p colors

#"red"
#nil
#["red", "blue", "white"]

### Ajouter un élément (push ou <<) · ʻObject.push (élément supplémentaire) ` · ʻObject << (élément supplémentaire) `

colors = ["red", "blue", "white"]

p colors.push("green")
#["red", "blue", "white", "green"]

p colors << ("black")
#["red", "blue", "white", "green", "black"]

### Obtenir la longueur du tableau (taille, longueur, nombre) ・ ʻObject.size` ・ ʻObjet .longueur` ・ ʻObject.count`

colors = ["red", "blue", "white", "green", "black"]

p colors.length
p colors.size
p colors.count

#5
#5
#5

### Trier ・ ʻObject.sort` ・ ʻObject.sort.reverse`

colors = ["red", "blue", "white", "green", "black"]

p colors.sort
p colors.sort.reverse

#["black", "blue", "green", "red", "white"]
#["white", "red", "green", "blue", "black"]

numbers = [5, 8, 1, 4, 9]

p numbers.sort
p numbers.sort.reverse

#[1, 4, 5, 8, 9]
#[9, 8, 5, 4, 1]

## Objet de hachage ### Créer et appeler Il y a trois façons de l'écrire, mais il suffit de se souvenir de l'abréviation.

** Créer ** Variable = {clé: valeur, clé: valeur ,,,}

appel Variable [: nom de la clé]

scores = {tanaka:100, sato:80, ito:50}

p scores
p scores[:sato]

#{:tanaka=>100, :sato=>80, :ito=>50}
#80

▼ Autre méthode de description

Tout de même ci-dessous

score1 = {"tanaka" => 100, "sato"=>80, "ito"=>50 }
score2 = {:tanaka =>100, :sato=>80, :ito=>50}
score3 = {tanaka:100, sato:80, ito:50}

p score1
p score2
p score3

#{:tanaka=>100, :sato=>80, :ito=>50}
#{:tanaka=>100, :sato=>80, :ito=>50}
#{:tanaka=>100, :sato=>80, :ito=>50}

### Ajouter un élément `Variable [: nom de la clé] = valeur`

scores = {tanaka:100, sato:80, ito:50}

scores[:suzuki] = 40
p scores
 
#{:tanaka=>100, :sato=>80, :ito=>50, :suzuki=>40}

### Supprimer un élément (.delete (: nom de la clé)) `Variable.delete (: nom de la clé)`

scores = {tanaka:100, sato:80, ito:50, suzuki:40}

scores.delete(:suzuki)
p scores
 
#{:tanaka=>100, :sato=>80, :ito=>50}

## Branche conditionnelle

if Branchez le processus avec ** expression conditionnelle **. if, elsif, else, end

python

stock = 5  #Stock

if i >= 10
    puts 'Stock: ◎'
elsif i > 3
    puts 'Stock: △'
elsif i == 1
    puts 'Stock: 1 dernier'
else 
    puts 'Stock: ×'
end

#Stock: △

case,when Branche l'expression conditionnelle par ** valeur **. `case, when, else, end`

Structure de la syntaxe de cas

#case Variable que vous souhaitez évaluer
#quand nombre
#En traitement
#quand plage (valeur de départ)..le dernier prix)
#En traitement
#quand plage (valeur de départ)..le dernier prix)
#En traitement
#     else
#En traitement
# end

** ▼ Exemple **

python

age = 6

case age 
    when 0..5
        puts 800
    when 6..11
        puts 1800
    else 
        puts 2500
end 

#1800

・ Prix de départ .. Prix de clôture ┗ Gamme du prix de départ au prix de clôture

## répétition for in `pour variable dans la plage`

Tableau

x = ["A", 1, "b", 3]

for i in x
    puts i
end

#A
#1
#b
#3

Nombres consécutifs

for i in 0..3
    puts i
end

#0
#1
#2
#3

each do Répétez avec la méthode esch. `objet.each do |variable|Fin du traitement`

python

arrays = ["A", 1, "b", 3]

arrays.each do |array|
    puts array
end

#A
#1
#b
#3

while Répétez dans la plage de conditions. `pendant que le traitement des expressions conditionnelles se termine

python

i = 0

while i < 3
    puts i
    i += 1
    # i++Ne peut pas être utilisé
end

#0
#1
#2

times do Spécifiez le nombre de répétitions. `Valeur numérique.times do |variable|` ┗ Le numéro d'index est entré dans la variable (à partir de 0)

python

3.times do |i|
    puts "#{i}C'est le deuxième processus"
end


#C'est le 0ème processus
#C'est le premier processus
#C'est le deuxième processus

loop + break Répétez avec une combinaison de boucle infinie et de condition de fin. `boucle {traitement si la condition break end}` ┗ Erreur s'il n'y a pas de condition de fin (rupture)

i = 0 

loop{
    puts i
    i += 1
    
    if  i >=3
        break
    end
}

#0
#1
#2
#3

### Ignorer (si suivant) Seule la condition spécifiée est ignorée. ʻSi l'expression conditionnelle se termine ensuite` ┗ Utilisé dans le traitement itératif.

python

3.times do |i|
    if i == 1 
        next
    end

    puts "#{i}C'est le deuxième processus"
end

#C'est le 0ème processus
#C'est le deuxième processus

## Créer et appeler des méthodes

▼ Création def method name () processing end ┗ () est inutile lorsqu'il n'y a pas d'argument.

▼ Appeler Nom de la méthode ()

python

def hello(name)
    puts "Hello #{name}M."
end

hello("Yuta")

#Bonjour Yuta

▼ Cas 2

Arguments multiples

def ttl_price(price, n)
    return (price * n * 1.10).floor  #le retour est facultatif
end

puts ttl_price(500, 3)

#1650

## Créer des classes et créer des instances ### Créer une classe

classe nom de classe fin

• Les noms de classe sont en majuscules. --initialization method: méthode qui est automatiquement appelée lorsqu'une instance est créée. --Les propriétés sont définies par @.

Créer une classe

class User
    def initialize(name)
        @name = name
    end

    def say_name
        puts "je#{@name}est."
    end

end

## Génération d'instance

Variable = nom de classe.new (argument)

Génération d'instance

tanaka = User.new("tanaka")
tanaka.say_name

#Je suis tanaka


yamada = User.new("yamada")
yamada.say_name

#Je suis yamada

c'est tout.