Ce qui m'a impressionné en tant que débutant dans l'écriture de Ruby

Lors de la création d'un portfolio en Ruby Impressionné lors des allers-retours avec les bases de Ruby Je vais résumer comment écrire Ruby et les règles.

Mettez à jour de temps en temps pour vous-même.

Ecrire des variables dans le cas du serpent

special_price = 200

Lors de l'utilisation du développement d'expression, "" guillemets doubles

puts "#{special_price}"

Lors de l'utilisation de guillemets simples (doubles) dans une chaîne

puts "\"Hello\""
#=> "Hello"

Le nombre _ est ignoré

1_000_000_000
#=> 1000000000

La division entre les nombres entiers est une solution et un entier

1 / 2 #=>0
1.0 / 2 #=>0.5

++ n'est pas valide en tant que syntaxe

n += 1 #=>2
n *= 3 #=>6
n /= 2 #=>3
n **= 2 #=>9

Nombre raisonnable

0.1 * 3.0 == 0.3 #=>false
0.1 * 3.0 <= 0.3 #=>false

3/10 au lieu de quelques-uns avec la classe Rational

0.1r * 3.0r #=>(3/10)

&&Est||Plus de priorité

L'instruction if renvoie la dernière expression évaluée

greeting =
    if
        
    elsif
        
    else
        
    end

Si alors vous pouvez une seule ligne de votre code

if (En traitement) then (Valeur de retour)

%notation

%q!! #=> ' '
%Q!! #=> " "
%!! #=> " "

Ici document

a = <<TEXT
Chaîne
TEXT

Chaîne de format

'%0.3f' % 1.2 #=>"1.200"

Expression exponentielle

2e-3 #=> 0.002
#2×10^-3

Opérateur conditionnel (opérateur ternaire)

message = n > 10 ? 'true' : 'false'

GC (nettoyage de la mémoire)

Collectez des objets qui ne sont plus utilisés Libérer automatiquement la mémoire

Méthode d'alias

Méthodes de la même implémentation avec des noms différents

dvimod renvoie les quotients et les restes sous forme de tableau

14.divmod(3) #=> [4,2]

Omettre les arguments de bloc s'ils ne sont pas nécessaires

numbers.each do
    sum += 1
end

Vous pouvez écrire du code ruby à l'intérieur du bloc

numbers = [1,2,3,4]
sum = 0
    
numbers.each do |number|
    sum_value = n.even? ? n * 10 : n #Opérateur conditionnel
    sum += sum_value #sum_la valeur n'est valide que dans le bloc
end

sum #=> 64

Au fait, quand un professionnel l'écrit, c'est tellement concis ...! !! !! @scivola, je vais étudier.

numbers = [1,2,3,4]
sum = numbers.sum{ |n| n.even? ? n * 10 : n }

Référence: Array # sum (Manuel de référence de Ruby 2.7.0)

Évaluer les éléments du tableau et faire de la valeur de retour un nouveau tableau

numbers = [1,2,3,4]
new_numbers = numbers.map { |n| n * 10 }

new_numbers #=> [10,20,30,40]

Méthode pour effectuer une opération de convolution

numbers = [1,2,3,4]
sum = numbers.inject(0) { |result, n| result + n }
#1er résultat résultat=>0, n=>1, 0+1=1
#2ème résultat résultat=>1, n=>2, 1+2=3

sum #=> 10

Plus concis avec la méthode &:

[1,2,3,4].select { |n| n.odd? } #=> [1,3]
[1,2,3,4].select(&:odd?) #=> [1,3]
#1.Lorsqu'il n'y a qu'un seul argument de bloc
#2.Lorsque la méthode n'a pas d'arguments
#3.Possible lorsque la méthode est une phrase pour l'argument bloc
#&:L'opérateur est inutile

La plage peut également être utilisée pour les chaînes

('a'...'e').to_a #=>["a","b","c","d"] ...Ne finit pas

Spécifiez le nombre de chiffres

'0'.rjust(5) 		#=> "    0"
'0'.rjust(5, '0')	#=> "00000"

Obtenez la fin d'un tableau

a = [1,2,3]
a[-1] #=> 3

Remplacement d'éléments dans un tableau

a = [1,2,3,4,5]
a[1,3] = 100
#=> [1,100,5]Stupide...

Ensemble de produits somme et différence de séquences

a = [1,2,3]
b = [3,4,5]

a | b #=> [1,2,3,4,5]
a - b #=> [1,2]
a & b #=> [3]

Recevoir tous les éléments restants sous forme de tableau avec affectation multiple

e, f = 100, 200, 300
e #=> 100
f #=> 200

e, *f = 100, 200, 300
e #=> 100
f #=> [200, 300]

Synthétiser la séquence

a = [1,2]
b = [3,4]

a.push(b) #=> [1,2,[3,4]]
a.push(*b) #=> [1,2,3,4]

Créez de manière concise un tableau de chaînes en notation%

['apple', 'melon', 'orange']
#=> ['apple', 'melon', 'orange']

%W!apple melon orange!

%W(apple melon orange)

%W(
	apple
	melon
	orange
)

Valeur initiale du tableau

a = Array.new(5, 'nil')
#=>[nil, nil, nil, nil, nil]
a = Array.new(5){'default'}
#=>["default", "default", "default", "default", "default"]
#=>Tous les éléments sont des objets différents

Rejoignez le tableau avec join

names = ['Sato', 'Tanaka', 'plage']
honorific = names.map{ |name| "#{name}M."}
honorific.join('Quand') #=>"佐藤さんQuand田中さんQuand浜辺さん"

Échappez à la zone mondiale avec catch and throw

last_names = ['Sato', 'Tanaka', 'plage']
first_names = ['Taro', 'Jiro', 'Minami']
catch :myfavorite do
    last_names.shuffle.each do |last_name|
        first_names.shuffle.each do |first_name|
            puts "#{last_name} #{first_name}M."
            if last_name == "plage" && first_name == "Minami"
				throw :myfavorite #symbole
            end
        end
    end
end