Zusammenfassung der Ruby-Qualifikationstestpunkte

Ruby Silver Prüfungspunktzusammenfassung (für mich)

Es ist schmutzig mit meinem eigenen Memo, aber ich werde die Punkte zusammenfassen, die leicht einen Fehler machen können

2020/9/14 bestanden. 94 Punkte

―― Gibt es ungefähr 5 Fragen, die genau dem Mock entsprechen? ――Wenn Sie einen Mock-Test durchführen, gibt es auf den ersten Blick fast keine Probleme. Selbst wenn ich seit 10 Jahren Rubin entwickle, denke ich, dass es fallen wird, wenn ich mich nicht auf den Test vorbereite

--split ('d'), split (/; |: /) Trenne und füge das Array ein --split Trenne ohne Argument mit einem Leerzeichen --split ("") Teil für Zeichen teilen --- split (",", 2) 2 ist die zu trennende Zahl ["1", "2,3,4,5"]

--Operator --A && B ... B bewegt sich, wenn A wahr ist --A && B ... Wenn A falsch ist, bewegt sich B. - 　A || B ...B bewegt sich, wenn A falsch ist - 　A || B ...B funktioniert nicht, wenn A wahr ist --A B oder A | B ... A ist wahr Demo falsch Demo B funktioniert

--Variable Längenvariable -Deklarieren Sie mit * a usw.

--Wenn Sie 65 in "A" ändern möchten - 65.chr

--eql ist wahr, wenn die Zeichenfolgen gleich sind --equal sieht, ob die Objekte gleich sind

-Inject weist einem Block ein Element zu ...|i,j|

foo = [1,2,3]
bar = foo
p foo === bar # => true　//Ist es dasselbe wie gleich?

Module Foo
  def foo			//Als Instanzmethode definiert
    puts("foo")
  end
end

Class Bar
  extend Foo		//Definieren Sie die Instanzmethode des Foo-Moduls als singuläre Methode der Bar-Klasse
end

Bar.foo  #=>Kann als foo verwendet werden

-Konstanten, die mit dem Operator :: beginnen, wie :: Foo, sind definierte Konstanten der obersten Ebene

-slice! Bezieht sich auf nach dem Schneiden

(1..5).each_cons(3) {|arr| p arr }
# <Ausführungsergebnis>
# [1, 2, 3]
# [2, 3, 4]
# [3, 4, 5]

(1..10).each_slice(3) {|arr| p arr }
# <Ausführungsergebnis>
# [1, 2, 3]
# [4, 5, 6]
# [7, 8, 9]
# [10]

arr = [1,2].zip([3,4])
p arr
# <Ausführungsergebnis>
[[1, 3], [2, 4]]

a1 = [1,2,3]
a2 = [4,2,3]
p a1 - a2
# <Ausführungsergebnis>
[1]

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

# <Ausführungsergebnis>
# {100 => :b}

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

# <Ausführungsergebnis>
# 1: ["one", "two", "three"]
# 2: ["two", "three"]
# 3: ["three"]
# 4: ["three"]
# 5: ["three", "four"]

p "Ruby on Rails".delete("Rails")
# <Ausführungsergebnis>
# "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

Ich kenne mich selbst nicht, also erinnere ich mich daran

class Blog
  def foo       #Instanzmethode
  end

  def self.foo  #Klassenmethode(Dieses Selbst ist die Klasse selbst(Blog)Zeigen auf)
  end

  def bar           #Instanzmethode
    self.foo        #Die Instanzmethode foo wird aufgerufen(Dieses Selbst ist die Instanz selbst(Blog.new)Zeigen auf)
    foo             #Die Instanzmethode foo wird aufgerufen
    self.class.foo  #Die Klassenmethode foo wird aufgerufen(Mit einer solchen Beschreibung kann sogar in der Instanzmethode auf die Klasse selbst verwiesen werden.)
  end

  def self.bar  #Klassenmethode(Dieses Selbst bezieht sich auf die Klasse selbst)
    self.foo    #Die Klassenmethode foo wird aufgerufen
    foo         #Die Klassenmethode foo wird aufgerufen
  end
end

self = "Mein Job ist ein Verkauf"

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

Selbst ist 4

class Interger
def aaaa
 return self
end
end

print 4.aaaa

Ein Zeichen stimmt überein

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

Schlüsselsortierung sort1, zerstörungsfrei

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]]

Wertesortierung, zerstörungsfrei

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

absteigende Reihenfolge
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,zu b-Ich verstehe die Bedeutung des Musters nicht

Was kann mit include gelesen werden? Fügen Sie der Klasse hinzu, die die Instanzmethode, die Instanzvariable und die konstanten Informationen definiert.

module Foo
  Bar = "bar"
end
 
class Baz
  include Foo
end
 
puts Baz::Bar  #=> bar　　//Da es sich um eine Konstante handelt, kann die Konstante aus irgendeinem Grund verwendet werden. Die Methode ist neu

Was kann durch Erweitern gelesen werden? Fügen Sie der Klasse die Instanzmethode als singuläre Methode hinzu. Als Klassenmethode behandelt

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 kommt heraus.!Werde ein Nano de Oo
print(a, b) -> oooo

Dunce \ Leerzeichen sind nicht kaputt

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 ist beim Öffnen ein Schnappschuss

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

Aktuell, Elternteil

["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 Verzeichnisse von Python
  filename = File.join(entry, "rocking.rb")
  File.open(filename, "w")
end
Dir.rmdir("python")

--File.basename (Dateiname, ". *") // Die Erweiterung aus dem Dateinamen übernehmen

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

R u b y
u
b
y

File.split teilt die Argumente des Zeichenfolgenobjekts in einen Verzeichnis- und einen Dateiteil auf und entfernt den abschließenden Schrägstrich von beiden. Die beiden Teile werden als ein Array mit zwei Elementen zurückgegeben. Das betreffende Programm gibt das Array ["/ home / john", "Lesezeichen"] zurück. Die Join-Methode wird in einem Array aufgerufen, das der von File.split zurückgegebene Wert ist. Das heißt, Array # join wird aufgerufen, nicht File.join. Array # join verbindet einfach die Zeichenfolgen mit den Elementen des Arrays, sodass (d) die richtige Antwort ist.

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

-Im Block|a,0| |b,1| |c,2| ....

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

--0% 3 ... zu viel 0 ―― 3% 3 ... nicht viel 0 -6% 5 ... zu viel 1

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] } #Ich füge der Zahl ein Minus hinzu, aber ich verstehe die Bedeutung nicht

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 scheint nicht zuzunehmen. /// Ein Trigger, der nicht wird

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"  #Ausführung auf der rechten Seite unabhängig von der linken Seite
puts a # We
false | b = "are"　#Ausführung auf der rechten Seite unabhängig von der linken Seite
puts b # are
2 == 1 && c = "Ruby" #Linke Seite ist falsch Nanode, Owar
puts "c=nil" if c.nil?　#nil
5 > 3 || d = "Engineer" #Die linke Seite ist wahr Nano Deowal
puts "d=nil" if d.nil?  # nil

p = a + b + c + d # we + are +Ich bekomme einen Fehler mit Null

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

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

Recommended Posts

Zusammenfassung der Ruby-Qualifikationstestpunkte
Zusammenfassung der Ruby-Syntax
Liste der technischen Qualifikationstests ①
[Ruby] Zusammenfassung der Methodendefinitionen
Zusammenfassung der Ruby on Rails-Validierung
Bestanden den Ruby Engineer Zertifizierungstest Silber
Ruby on Rails-Variablen, konstante Zusammenfassung
Zusammenfassung der Ruby-Umgebungskonstruktion ~ Mac-Version ~
[Ruby] Common-Key-Verschlüsselungs-Benchmark-Test