[RUBY] Résumé des points de test de qualification rubis

Résumé des points d'examen Ruby Silver (pour moi-même)

C'est sale avec mon propre mémo, mais je vais résumer les points qui sont faciles à faire une erreur

2020/9/14 adopté. 94 points

―― Y a-t-il environ 5 questions qui sont exactement les mêmes que la simulation? ――Si vous effectuez un test simulé, il n'y a presque aucun problème à première vue. Même si je développe du rubis depuis 10 ans, je pense qu'il tombera si je ne me prépare pas au test

--split ('d'), split (/; |: /) Séparer et mettre dans le tableau --split Séparer sans argument par un espace --split ("") Fractionner caractère par caractère --- split (",", 2) 2 est le nombre à séparer ["1", "2,3,4,5"] --À propos de la gestion des exceptions

--Opérateur --A && B ... B bouge quand A est vrai --A && B ... Si A est faux, B se déplacera. - 　A || B ...B bouge quand A est faux - 　A || B ...B ne fonctionne pas si A est vrai --A B ou A | B ... A est vrai Demo false Démo B fonctionne

--Les constantes de rubis commencent par une majuscule

--Nom de la variable Ruby ――Le premier caractère doit commencer par un alphabet inférieur ou _. --Utilisez des alphabets ou des nombres après le deuxième caractère

--Variable de longueur variable -Déclarer avec * a etc. --Tout nombre d'arguments peut être pris et le tableau est stocké dans un

--À propos du chargement de modules externes

--Lorsque vous voulez changer 65 en "A" - 65.chr

--Effacer un \ r \ n avec la méthode Chomp

--eql est vrai si les chaînes sont identiques --equal voit si les objets sont identiques

-inject affecte un élément à un bloc ...|i,j|

foo = [1,2,3]
bar = foo
p foo === bar # => true　//Est-ce la même chose qu'égal?

Module Foo
  def foo			//Défini comme méthode d'instance
    puts("foo")
  end
end

Class Bar
  extend Foo		//Définissez la méthode d'instance du module Foo comme une méthode singulière de la classe Bar
end

Bar.foo  #=>Peut être utilisé comme foo

-Les constantes commençant par l'opérateur :: comme :: Foo sont des constantes définies de premier niveau

-slice! Désigne après le tranchage

--Comment réagir à la fin du fichier (EOF)

--Lors de la suppression d'une extension arbitraire d'un nom de fichier dont le nom de fichier et l'extension sont séparés par ".", Appelez File.basename avec ". *" Comme deuxième argument.

(1..5).each_cons(3) {|arr| p arr }
# <Résultat d'exécution>
# [1, 2, 3]
# [2, 3, 4]
# [3, 4, 5]

(1..10).each_slice(3) {|arr| p arr }
# <Résultat d'exécution>
# [1, 2, 3]
# [4, 5, 6]
# [7, 8, 9]
# [10]

arr = [1,2].zip([3,4])
p arr
# <Résultat d'exécution>
[[1, 3], [2, 4]]

a1 = [1,2,3]
a2 = [4,2,3]
p a1 - a2
# <Résultat d'exécution>
[1]

p ({a: 100, b: 100}).invert

# <Résultat d'exécution>
# {100 => :b}

1: s = ["one", "two", "three"]
2: s.shift
3: s.shift
4: s.unshift
5: s.push "four"
6: p s

# <Résultat d'exécution>
# 1: ["one", "two", "three"]
# 2: ["two", "three"]
# 3: ["three"]
# 4: ["three"]
# 5: ["three", "four"]

p "Ruby on Rails".delete("Rails")
# <Résultat d'exécution>
# "uby on "

a, b = 0    # a => 0, b => nil
c, a = 1    # c => 1, a => nil
a, d = 1, 2 # a => 1, d => 2
b, c = 3    # b => 3, c => nil

Je ne me connais pas donc je m'en souviens

class Blog
  def foo       #Méthode d'instance
  end

  def self.foo  #Méthode de classe(Ce moi est la classe elle-même(Blog)Pointer vers)
  end

  def bar           #Méthode d'instance
    self.foo        #La méthode d'instance foo est appelée(Ce moi est l'instance elle-même(Blog.new)Pointer vers)
    foo             #La méthode d'instance foo est appelée
    self.class.foo  #La méthode de classe foo est appelée(Avec une telle description, la classe elle-même peut être pointée même dans la méthode d'instance.)
  end

  def self.bar  #Méthode de classe(Ce moi fait référence à la classe elle-même)
    self.foo    #La méthode de classe foo est appelée
    foo         #La méthode de classe foo est appelée
  end
end

self = "Mon travail est une vente"

class String
  def change_job
    self.replace("I will become an engineer!")
  end
end

s = "My job is a sales"
s.change_job
p s

le moi est 4

class Interger
def aaaa
 return self
end
end

print 4.aaaa

Correspondance d'un personnage

a = ['3p', '913', 'Zx', 'ssr', 'M7', 'W']
a.grep(/[A-Z0-9]/)
["3p", "913", "Zx", "M7", "W"]

Sort de clé1, non destructif

h = { "def" => 2, "ghi" => 1, "abc" => 3 }
p h.sort
[["abc", 3], ["def", 2], ["ghi", 1]]

h = { "def" => 2, "ghi" => 1, "abc" => 3 }
p h.sort.reverse
[["ghi", 1], ["def", 2], ["abc", 3]]

tri par valeur, non destructif

ordre croissant
h = { "def" => 2, "ghi" => 1, "abc" => 3 }
p h.sort{ | a, b | a[1] <=> b[1] }
p h
[["ghi", 1], ["def", 2], ["abc", 3]]

Ordre décroissant
h = { "def" => 2, "ghi" => 1, "abc" => 3, "ddd" => 5 }
p h.sort{ | a, b | b[1] <=> a[1] }
[["ddd", 5], ["abc", 3], ["def", 2], ["ghi", 1]]

a,à b-Je ne comprends pas la signification du motif

Que peut-on lire avec inclure? Ajoutez à la classe qui définit la méthode d'instance, la variable d'instance et les informations de constante.

module Foo
  Bar = "bar"
end
 
class Baz
  include Foo
end
 
puts Baz::Bar  #=> bar　　//Puisqu'il s'agit d'une constante, la constante peut être utilisée pour une raison quelconque. La méthode est nouvelle

Que peut-on lire par extension? Ajoutez la méthode d'instance de à la classe en tant que méthode singulière. Traité comme une méthode de classe

module Foo
def foo
  puts("foo")
end
end
 
class Bar
  extend Foo
end
 
Bar.foo  #=> foo

a = "foo"
b = a
b.slice!(0, 1)  ->f sort.!Devenez un nano de oo
print(a, b) -> oooo

Dunce \ les espaces ne sont pas cassés

File.open("hats.txt", "w") do |f|
  f.puts(%w[Bowler Deerstalker Dunce\ cap Fedora Fez])
end

hats.txt
Bowler
Deerstalker
Dunce\ cap
Fedora
Fez

File.stat est un instantané lorsqu'il est ouvert

file = File.open("hello.rb", "w")
stat = file.stat
mtime1 = stat.mtime　　//onaji
file.puts("new data")
file.flush
mtime2 = stat.mtime　// onaji

Actuel, parent

["tmp", "tmp/lang",  "tmp/lang/ruby", "tmp/lang/python"].each do |dir|
  Dir.mkdir(dir)
end
Dir.chdir("tmp/lang")
Dir.new(".").each do |entry| // . , .. , ruby,4 répertoires de python
  filename = File.join(entry, "rocking.rb")
  File.open(filename, "w")
end
Dir.rmdir("python")

--File.basename (filename, ". *") // Prend l'extension du nom de fichier

File.open("fancy.txt", "w") do |f|
  f.write("R u b y\n")
  f.puts(["u","b","y"]) //Saut de ligne Tsutsutsu du tableau 1
end
puts File.read("fancy.txt")

R u b y
u
b
y

File. Les deux parties sont renvoyées sous la forme d'un tableau avec deux éléments. Le programme en question renvoie le tableau [«/ home / john», «bookmarks»]. La méthode join est appelée dans un tableau qui est la valeur renvoyée par File.split. Autrement dit, la jointure Array # est appelée, pas File.join. Array # join joint simplement les chaînes aux éléments du tableau, donc (d) est la bonne réponse.

p File.split("/home/john/bookmarks/").join
“/home/johnbookmarks”

-Dans le bloc|a,0| |b,1| |c,2| .... --Si l'argument de méthode break est spécifié, cette valeur sera la valeur renvoyée par l'appel de méthode bloqué. L'index commence à compter à partir de 0 et le premier index impair est 1. La méthode each_with_index termine l'itération en renvoyant un "b" avec un index de 1. Ensuite, le "b" renvoyé est affecté à la variable locale foo.

foo = ('a'..'z').each_with_index {|i, n| break(i) if n.odd? }
  p foo.succ

--0% 3 ... trop 0 ―― 3% 3 ... Pas beaucoup 0 -6% 5 ... trop 1

--Sort de tableau

score = [["kobayashi", 86],["murata", 54],["azuma", 72]]
puts "a-shoujun"
p score.sort { |a, b| a[0] <=> b[0] }
p score.sort { |a, b| -a[0] <=> -b[0] } #J'ajoute un moins au nombre, mais je ne comprends pas le sens

puts "a-koujun"
p score.sort { |a, b| a[0] <=> b[0] }.reverse
p score.sort { |a, b| b[0] <=> a[0] }
p score.sort { |a, b| -b[0] <=> -a[0] } # musi

puts "b-shoujun"
p score.sort { |a, b| a[1] <=> b[1] }
p score.sort { |a, b| -b[1] <=> -a[1] } # musi

puts "b-koujun"
p score.sort { |a, b| a[1] <=> b[1] }.reverse
p score.sort { |a, b| b[1] <=> a[1] }
p score.sort { |a, b| -a[1] <=> -b[1] } #Oboete Okou

a-shoujun
[["azuma", 72], ["kobayashi", 86], ["murata", 54]]
[["azuma", 72], ["kobayashi", 86], ["murata", 54]]
a-koujun
[["murata", 54], ["kobayashi", 86], ["azuma", 72]]
[["murata", 54], ["kobayashi", 86], ["azuma", 72]]
[["murata", 54], ["kobayashi", 86], ["azuma", 72]]
b-shoujun
[["murata", 54], ["azuma", 72], ["kobayashi", 86]]
[["murata", 54], ["azuma", 72], ["kobayashi", 86]]
b-koujun
[["kobayashi", 86], ["azuma", 72], ["murata", 54]]
[["kobayashi", 86], ["azuma", 72], ["murata", 54]]
[["kobayashi", 86], ["azuma", 72], ["murata", 54]]

Slashha ne semble pas augmenter. /// Un déclencheur qui ne devient pas

https="https://"
domain="example.jp"
dir="index.html"
puts File.join(https, domain, dir)

https://example.jp/index.html

# https:/ ->Sonomama
# https: -> https:/

true & a = "We"  #Exécution du côté droit indépendamment du côté gauche
puts a # We
false | b = "are"　#Exécution du côté droit indépendamment du côté gauche
puts b # are
2 == 1 && c = "Ruby" #Le côté gauche est un faux Nanode, Owar
puts "c=nil" if c.nil?　#nil
5 > 3 || d = "Engineer" #Le côté gauche est vrai Nano Deowal
puts "d=nil" if d.nil?  # nil

p = a + b + c + d # we + are +J'obtiens une erreur avec nul

h = {:name => 'sato', :club => 'tennis'}.fetch(:name, 'error')
print h # sato

h = {:name => 'sato', :club => 'tennis'}.fetch(:nam, 'error')
print h # error

Recommended Posts

Résumé des points de test de qualification rubis
Résumé de la syntaxe Ruby
Liste de tests de qualification de type ingénieur ①
[Ruby] Résumé des définitions de méthode
Résumé de la validation Ruby on Rails
Passé le test de certification d'ingénieur Ruby Silver
Variables Ruby on Rails, résumé constant
Résumé de la construction de l'environnement Ruby ~ Version Mac ~
[Ruby] Test de référence de chiffrement de clé commune