[Ruby] Grundlegende Befehlsliste

[Ruby] Grundlegende Befehlsliste

Liste und Beispiele grundlegender Ruby-Befehle.

Inhaltsverzeichnis

1. [Unterschied zwischen Puts, Print, p](Unterschied zwischen # Puts-Print-P)
2. Konstante
3. [Anzeige der Objektklassenliste (.class)](Anzeigeklasse der Objektklassenliste)
4. [Anzeige der Objektmethodenliste (.methods)](# Methoden zur Anzeige der Objektmethodenliste)
5. [Berechnung nach dem Komma](# Berechnung nach dem Dezimalpunkt)
6. [Geben Sie die Anzahl der Stellen an, um den Dezimalpunkt anzuzeigen](# Geben Sie die Anzahl der Stellen an, um den Dezimalpunkt anzuzeigen)
7. [format (oder sprintf)](#format oder -sprintf)
8. [Rund-, Decken-, Bodenmethode](# Runddeckenmethode)
9. [Zeichenkette](# Zeichenkette)
10. [Ausdruckserweiterung](# Ausdruckserweiterung)
11. Verketten
12. [Wiederholen](# Zeichenfolge wiederholen)
13. [Anzahl der Zeichen (Länge)](Länge der Anzahl der Zeichen)
14. [Von Zeichenfolge in Zahl konvertieren (.to_i)](# Von Zeichenfolge in Nummer in_i konvertieren)
15. [Array](# Array)
16. [Element des Arrays abrufen](# Element des Arrays abrufen)
17. [Element hinzufügen (push oder <<)](# Element hinzufügen push-or-)
18. [Arraylänge abrufen (Größe, Länge, Anzahl)](# Arraylänge abrufen Größe-Länge-Anzahl)
19. Sortieren
20. [Hash-Objekt](# Hash-Objekt)
21. Erstellen und Anrufen (#Erstellen und Anrufen)
22. [Element hinzufügen](# Element hinzufügen)
23. [Element löschen (.delete (: Schlüsselname))](# Element löschen Schlüsselnamen löschen)
24. [Bedingter Zweig](# Bedingter Zweig) 13. if 14. case,when
25. [Wiederholen](# Wiederholen) 14. for in 15. each do 16. while 17. times do 18. loop + break
26. [Überspringen (wenn als nächstes)](#Skip if-next)
27. Methode erstellen und aufrufen (# Methode erstellen und aufrufen)
28. Klasse erstellen und Instanz erstellen (# Klasse erstellen und Instanz erstellen)

## Unterschied zwischen Puts, Print, S. Es gibt subtile Unterschiede zwischen ihnen, aber Sie müssen sich nur an p für Puts erinnern.

Der Unterschied zwischen ihnen ist das Vorhandensein oder Fehlen von Zeilenumbrüchen und das Vorhandensein oder Fehlen einer Typendarstellung.

Methode	puts	p	print
Verwenden	Für die Produktion	Zum Debuggen	Reste von Python?
Neue Zeile	Ja	Ja	Keiner
Typendarstellung	Keiner	Ja	Keiner

Unterschied zwischen Puts und Print (Vorhandensein oder Nichtvorhandensein von Zeilenumbrüchen)

puts "Hallo"
puts 123

#Hallo
#123


print "Hallo"
print 123

#Hallo 123

▼ Bei "p" wird der Text der Zeichenfolge in doppelte Anführungszeichen gesetzt.

Unterschied zwischen Puts und p (Vorhandensein oder Fehlen einer Typendarstellung)

puts "Hallo"
puts 123

#Hallo
#123


p "Hallo"
p 123

#"Hallo"
#123

## Konstante -Definieren Sie Variablen in Großbuchstaben ・ Verwenden Sie Ansco, um mehrere Wörter zu verbinden - Beim Überschreiben oder Neudefinieren tritt ein Fehler auf

TAX_RATE = 1.0
puts TAX_RATE

#Anweisung überschreiben
TAX_RATE = 1.5

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

## Anzeige der Objektklassenliste (.class) `p object.class`

p 1.1.class

#Float

## Methodenliste der Objekte anzeigen (.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,Unten weggelassen...

p "abc".methods

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

## Berechnung nach dem Dezimalpunkt Wenn der berechneten Ganzzahl ".0" hinzugefügt wird, wird sie bis zum Dezimalpunkt angezeigt. ┗ Entweder einer ┗ Gibt die Anzahl der Ziffern nicht an ┗ Wenn nicht, abschneiden

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

#2.6666666666666665
#2.6666666666666665
#2

## Rund-, Decken-, Bodenmethode `.round`: Rundung `.ceil`: Aufrunden `.floor`: Abschneiden

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

## Geben Sie die Anzahl der Stellen an, um den Dezimalpunkt anzuzeigen ### Format (oder Sprintf) `format ("%. Anzahl der Stellen f ", Zielnummer)`

calc = 8/3.0

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

#2.67
#2.67

Rund-, Decken-, Bodenmethode

Object.round (Anzahl der Stellen) Object.ceil (Anzahl der Stellen) Object .floor (Anzahl der Stellen)

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

## String

Ausdruckserweiterung

setzt" # {Formeln und Variablen} " ┗ Doppelte Anführungszeichen ┗ Ausgabe so wie sie ist, wenn sie einzeln ist

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

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

### Verknüpfen `setzt string + string`

puts "Hello" + "World"

#HelloWorld

### String wiederholen `setzt string * n`

puts "Hello★" * 5

#Hello★Hello★Hello★Hello★Hello★

### Zeichenanzahl (.Länge) `setzt string.length`

str = "hello world"
p str.length

#11

### Von Zeichenfolge in Zahl konvertieren (.to_i) `setzt string.to_i`

str = "123"

p str
p str.to_i

#"123"
#123

## Array ### Elemente eines Arrays abrufen `Variable = [,,,]`

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

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

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

### Element hinzufügen (drücken oder <<) · `Object.push (zusätzliches Element)` · `Objekt << (zusätzliches Element)`

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

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

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

### Array-Länge abrufen (Größe, Länge, Anzahl) ・ `Object.size` ・ `Objektlänge` ・ `Object.count`

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

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

#5
#5
#5

### Sortieren ・ `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]

## Hash-Objekt ### Erstellen und anrufen Es gibt drei Möglichkeiten, es zu schreiben, aber Sie müssen sich nur an die Abkürzung erinnern.

** Erstellen ** Variable = {Schlüssel: Wert, Schlüssel: Wert ,,,}

Anruf Variable [: Schlüsselname]

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

p scores
p scores[:sato]

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

▼ Andere Beschreibungsmethode

Trotzdem unten

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}

### Element hinzufügen `Variable [: Schlüsselname] = Wert`

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

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

### Element löschen (.delete (: Schlüsselname)) `Variable.delete (: Schlüsselname)`

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

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

## Bedingte Verzweigung

if Verzweigen Sie den Prozess mit ** bedingtem Ausdruck **. if, elsif, else, end

python

stock = 5  #Lager

if i >= 10
    puts 'Lagerbestand: ◎'
elsif i > 3
    puts 'Lagerbestand: △'
elsif i == 1
    puts 'Bestand: Letzte 1'
else 
    puts 'Lagerbestand: ×'
end

#Lagerbestand: △

case,when Verzweigen Sie den bedingten Ausdruck nach ** Wert **. `case, when, else, end`

Fallsyntaxstruktur

#case Variable, die Sie auswerten möchten
#wenn Nummer
#wird bearbeitet
#wenn Bereich (Startwert)..Schlusskurs)
#wird bearbeitet
#wenn Bereich (Startwert)..Schlusskurs)
#wird bearbeitet
#     else
#wird bearbeitet
# end

** ▼ Beispiel **

python

age = 6

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

#1800

・ Startpreis .. Schlusskurs ┗ Bereich vom Startpreis bis zum Schlusskurs

## Wiederholung for in `für Variable im Bereich`

Array

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

for i in x
    puts i
end

#A
#1
#b
#3

Fortlaufende Nummern

for i in 0..3
    puts i
end

#0
#1
#2
#3

each do Wiederholen Sie mit der esch-Methode. `Objekt.each do |Variable|Verarbeitungsende`

python

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

arrays.each do |array|
    puts array
end

#A
#1
#b
#3

while Wiederholen Sie innerhalb des Bedingungsbereichs. `während die Verarbeitung des bedingten Ausdrucks endet`

python

i = 0

while i < 3
    puts i
    i += 1
    # i++Kann nicht verwendet werden
end

#0
#1
#2

times do Geben Sie die Anzahl der Wiederholungen an. `Numerischer Wert.times do |Variable|` ┗ Die Indexnummer wird in die Variable eingegeben (ab 0).

python

3.times do |i|
    puts "#{i}Dies ist der zweite Prozess"
end


#Dies ist der 0. Prozess
#Dies ist der erste Prozess
#Dies ist der zweite Prozess

loop + break Wiederholen Sie dies mit einer Kombination aus Endlosschleifen und Endbedingungen. `loop {Verarbeitung bei Ende der Bedingungsunterbrechung}` ┗ Ein Fehler tritt auf, wenn keine Endbedingung vorliegt (Unterbrechung)

i = 0 

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

#0
#1
#2
#3

### Überspringen (falls als nächstes) Nur die angegebene Bedingung wird übersprungen. `wenn bedingter Ausdruck nächstes Ende` ┗ Wird in der iterativen Verarbeitung verwendet.

python

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

    puts "#{i}Dies ist der zweite Prozess"
end

#Dies ist der 0. Prozess
#Dies ist der zweite Prozess

## Methoden erstellen und aufrufen

▼ Erstellung def method name () verarbeitungsende ┗ () ist nicht erforderlich, wenn kein Argument vorhanden ist.

▼ Anrufen Methodenname ()

python

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

hello("Yuta")

#Hallo Yuta

▼ Fall 2

Mehrere Argumente

def ttl_price(price, n)
    return (price * n * 1.10).floor  #Rückgabe ist optional
end

puts ttl_price(500, 3)

#1650

## Klassen erstellen und Instanzen erstellen ### Eine Klasse erstellen

class class name end

--Klassennamen werden großgeschrieben. --Initialisierungsmethode: Eine Methode, die beim Erstellen einer Instanz automatisch aufgerufen wird. --Eigenschaften werden durch @ definiert.

Eine Klasse erstellen

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

    def say_name
        puts "ich#{@name}ist."
    end

end

## Instanzgenerierung

Variable = Klassenname.neu (Argument)

Instanzgenerierung

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

#Ich bin Tanaka


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

#Ich bin Yamada

das ist alles.