[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

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.

Recommended Posts

[Ruby] Liste des commandes de base
Connaissance de base de Ruby on Rails
Liste de gemmes pour chaque version Ruby 2.5.x
Termes de base de Ruby
Bases de Ruby
[Ruby] Connaissance de base des variables d'instance de classe, etc.
[Note] Une liste de commandes que j'ai vérifiées plusieurs fois après avoir essayé Ruby.
Points d'apprentissage Ruby (basique)
notes de syntaxe de base ruby
Liste des mémos débutants (Liste)
définition de la méthode ruby
[Ruby] Liste de codes de base. Gardez les bases avec des exemples
Liste de choses que j'ai utilisées sans bien comprendre: Ruby
Liste des commandes Docker que j'utilise souvent (opération de conteneur)
Passez en revue les connaissances de base du rubis souvent oubliées
[Docker] Introduction de l'instruction de base de Docker
Supprimer tout le contenu de la page de liste [Ruby on Rails]
[Java] Résumé de base de Java non couvert par Progate ~ Partie 2 ・ Liste ~
J'ai brièvement résumé la grammaire de base de Ruby
Utilisation super basique d'Eclipse
Liste des emplacements des fichiers hôtes
Résumé des fonctions de base d'ImageJ
Méthodes et classes Ruby (basiques)
Mémorandum de base Ruby on Rails
À propos du comportement de ruby Hash # ==
[Java] Supprimer les éléments de la liste
Comprendre le mécanisme de base de log4j2.xml
Énumération des modèles de combinaison à l'aide de List
[Rails] Répertorier les instances de plusieurs modèles
Une liste de rawValues pour UITextContentType.
Utilisation de base de Java Facultatif Partie 1
Résumé des commandes Docker fréquemment utilisées
Ruby 5 ou plus somme d'entiers
Liste des membres ajoutés dans Java 9
Bases de Ruby ~ Revue de difficile à comprendre ~
Coopération rubis / rouille (6) Extraction de morphologie
Impressions de faire Black Jack-cli avec Ruby
Flux de traitement de base de Java Stream
Mémorandum Ruby (acquisition de valeur clé)
Liste des types ajoutés dans Java 9
Explique les objets Ruby Array
[Connaissance de base de Java] Portée des variables
Bases de Ruby 2 ~ Revue des points difficiles ~