Ruby 速查表

# Debian, Ubuntu
$ sudo apt-get install ruby-full
# Windows
$ winget install RubyInstallerTeam.Ruby
$ brew install ruby # macOS
$ docker run -it --rm ruby:latest # Docker

$ gem install bundler -v 2.4.20
$ gem install minitest -v 5.22.3

# 使用 Bundler 更新单个 gem
$ bundle update nokogiri
# 使用 Bundler 更新 Gemfile 中的每个 gem
$ bundle update

从高到低，这是 ruby 的优先级表。高优先级操作在低优先级操作之前发生。

• !, ~, 一元 +
• **
• 一元 -
• *, /, %
• +, -
• <<, >>
• &
• |, ^

• , >=, <, <=

• <=>, ==, ===, !=, =~, !~
• &&
• ||
• .., ...
• ?, :
• 修饰符-rescue
• =, +=, -=, 等.
• defined?
• not
• or, and
• 修饰符-if, 修饰符-unless, 修饰符-while, 修饰符-until
• { } 块

defined? count
"local-variable"
defined? @id
"instance-variable"
defined? @@name
"class variable"
defined? $version
"global-variable"
defined? PI
"constant"

# 两者都是同义词
a = 37
a.kind_of? Integer
# true
a.is_a? Integer
# true

week_days = {sunday: 11, monday: 222}

2.even?
# true
3.even?
# false

.. 用于创建包含性范围

range = 1..10
range.to_a
# 输出 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

... 用于创建排除性范围

range = 1...10
range.to_a
# 输出 => [1, 2, 3, 4, 5, 6, 7, 8, 9]

一些有用的方法

(1..20).step(2) { |number| puts "#{number}"}
# 输出
# 1
# 3
# 5
# 7
# 9
# 11
# 13
# 15
# 17
# 19

num = 2
puts 'two' if num == 2

如果条件为真，则执行代码

temp = 19
if temp >= 25
  puts "热"
elsif temp < 25 && temp >= 18
  puts "正常"
else
  puts "冷"
end
# 输出 => 正常

# Unless 与 if 相反，当语句为 false 时求值
name = "rob"
# if name != "bob"
unless name == "bob"
  puts "你好，陌生人"
else
  puts "你好，bob"
end
# 输出 => 你好，陌生人
num = 6
puts '不是二' unless num == 2
# 输出 => 不是二

case input
  when 19 then puts "它是 19"
end

case input
  when 19 then puts "它是 19"
else
  puts "它不是 19"
end

marks = 86
result = case marks
        when 0..49 then "不及格"
        when 50..64 then "及格"
        when 65..74 then "良好"
        when 75..84 then "优秀"
        when 85..100 then "特优"
        else "无效分数"
        end

puts result
# 特优

name = "World"
puts "Hello #{name}"
puts "总数是 #{1+1}"
# "总数是 2"

字符串插值允许您将字符串组合在一起

string = "abc123"
string[0,3]
# "abc"
string[3,3]
# "123"
string[0..-2]
# "abc12"
#移除或替换子字符串
string[0..2] = ""
puts string
# "123"

子字符串是字符串的一小部分，如果您只需要特定部分（例如开头、中间或结尾），则非常有用。

"HELLO World".downcase  # "hello world"
"hello worlD".upcase    # "HELLO WORLD"
"hEllo wOrlD".capitalize # "Hello world"
"hEllo WOrlD".swapcase  # "HeLLO woRLd"

res = method_name(parameter1, parameter2)
# 方法可以不带括号调用
res = method_name parameter1, parameter2

def method_name(num1, num2 = num1)
    return num1 + num2
end
res = method_name(10)
# 输出 => 20

def method_name(parameter1, parameter2, type = "ADD")
    puts "#{parameter1} #{parameter2}"
    return parameter1 + parameter2 if type == "ADD"
    return parameter1 - parameter2 if type == "SUB"
end
res = method_name(20, 10)
# 输出 => 30

def method_name(type, *values)
    return values.reduce(:+) if type == "ADD"
    return values.reduce(:-) if type == "SUB"
end
numbers = [2, 2, 2, 3, 3, 3]
res = method_name("ADD", *numbers)
# 输出 => 15
res = method_name("SUB", *numbers)
# 输出 => -11
# 或者你可以像这样提供一个值
res = method_name("ADD", 2, 2, 2, 3, 3, 3)
# 输出 => 15

a = ["戏剧", "悬疑", "犯罪",
"科幻", "灾难", "惊悚"]
a.sort
puts a
# 我们没有修改对象
# 戏剧
# 悬疑
# 犯罪
# 科幻
# 灾难
# 惊悚
a.sort!
puts a
# 修改对象
# 犯罪
# 灾难
# 戏剧
# 悬疑
# 科幻
# 惊悚

当您想修改对象时，请在方法后使用 !

在 ruby 中，以问号 (?) 结尾的方法称为布尔方法，它们返回 true 或 false

"some text".nil?
# false
nil.nil?
# true

你可以拥有自己的布尔方法

def is_vowel?(char)
    ['a','e','i','o','u'].include? char
end
is_vowel? 'a'
# true
is_vowel? 'b'
# false

# 返回值
def give_me_data
    data = yield
    puts "data = #{data}"
end
give_me_data { "大数据" }
# 输出 => data = 大数据

do 和 end（用于多行）或花括号 { 和 }（用于单行）之间的代码称为代码块，它们可以在两个管道 ( |arg1, arg2|) 之间定义多个参数。

salary = [399, 234, 566, 533, 233]
salary.each { |s| puts s }
# puts s = 代码块主体
# |s| = 代码块参数

salary.each do |s|
    a = 10
    res = a * s
    puts res
end
# 代码块
# a = 10
# res = a * s
# puts res
# 代码块参数
# |s|

代码块可以作为方法参数传递或与方法调用相关联。代码块返回最后求值的语句。

def give_me_data
    puts "我在 give_me_data 方法内部"
    yield
    puts "我回到了 give_me_data 方法"
end

give_me_data { puts "大数据" }

# 输出
# 我在 give_me_data 方法内部
# 大数据
# 我回到了 give_me_data 方法

def give_me_data
    yield
    yield
    yield
end

give_me_data { puts "大数据" }

# 输出
# 大数据
# 大数据
# 大数据

def give_me_data
    yield 10
    yield 100
    yield 30
end

give_me_data { |data| puts "大数据 #{data} TB" }

# 输出
# 大数据 10 TB
# 大数据 100 TB
# 大数据 30 TB

def give_me_data
    yield "大数据", 10, "TB"
    yield "大数据", 100, "GB"
    yield "大数据", 30, "MB"
end

give_me_data { |text, data, unit| puts "#{text} #{data} #{unit}" }

# 输出
# 大数据 10 TB
# 大数据 100 GB
# 大数据 30 MB

give_me_data
    puts "我在 give_me_data 方法内部"
end

def test
  puts "我在 test 方法内部"
  give_me_data { return 10 } # 代码从这里返回
  puts "我回到了 test 方法"
end

return_value = test

# 输出
# 我在 test 方法内部
# 我在 give_me_data 方法内部
# 10

def give_me_data(&block)
    block.call
    block.call
end

give_me_data { puts "大数据" }

# 输出
# 大数据
# 大数据

def give_me_data
    yield
end

give_me_data

# 输出
# LocalJumpError: 没有给出代码块 (yield)

def give_me_data
    return "没有代码块" unless block_given?
    yield
end

give_me_data { puts "大数据" }
give_me_data

# 输出
# 大数据

p = Proc.new { puts "Hello World" }

def give_me_data(proc)
    proc.call
end

give_me_data p

# 输出
# Hello World

proc 就像一个可以存储在变量中的代码块

p = Proc.new { return 10 }
p.call
# 输出
LocalJumpError: 意外的返回

def give_me_data
    puts "我在 give_me_data 方法内部"
    p = Proc.new { return 10 }
    p.call # 代码从这里返回
    puts "我回到了 give_me_data 方法"
end

return_value = give_me_data
puts return_value

# 输出
# 我在 give_me_data 方法内部
# 10

l = -> (count) { "Hello World " * count }
l.call 5
# 输出
# "Hello World Hello World Hello World Hello World Hello World "
l.call 5, 2
# 输出
参数数量错误 (给出 2, 期望 1)

l = -> { return 10 }
l.call

# 输出 => 10

array = Array.new   #=> []
# 或
array = []

array = [1, "two", 3.0]
#=> [1, "two", 3.0]

temperature_data = [
              ["A908", 38],
              ["A909", 37],
              ["A910", 38],
          ]
temperature_data[0]    #=> ["A908", 38]
temperature_data[0][0] #=> "A908"
temperature_data[0][1] #=> 38

str_array = [
  "This", "is", "a", "small", "array"
]
str_array[0]            #=> "This"
str_array[1]            #=> "is"
str_array[4]            #=> "array"

str_array = [
  "This", "is", "a", "small", "array"
]
# 索引 -1 表示最后一个元素
str_array[-1]        #=> "array"
# 索引 -2 表示倒数第二个元素
str_array[-2]        #=> "small"
str_array[-6]        #=> nil

str_array = [
  "This", "is", "a", "small", "array"
]

puts str_array.at(0)      #=> "This"

arr = [1, 2, 3, 4, 5, 6]
arr[100]                  #=> nil
arr[-3]                   #=> 4
arr[2, 3]                 #=> [3, 4, 5]
arr[1..4]                 #=> [2, 3, 4, 5]
arr[1..-3]                #=> [2, 3, 4]

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100)
#=> IndexError: 索引超出数组范围 100：-6...6
arr.fetch(100, "oops")    #=> "oops"

超出范围，给出默认值

arr = [1, 2, 3, 4, 5, 6]

arr.first     # 第一个值 => 1
arr.last      # 最后一个值 => 6
# take 返回前 n 个元素
arr.take(3)   #=> [1, 2, 3]
# drop 删除 n 个元素后
arr.drop(3)   #=> [4, 5, 6]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.push(11)
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
numbers.push(12, 13, 14)
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

num_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
num_array.pop             #=> 10
num_array
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.unshift(0)
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.unshift(-3, -2, -1)
#=> [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.shift #=> 1
numbers
#=> [2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete_at(2) #=> 4
numbers
#=> [2, 3, 5, 6, 7, 8, 9, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete(2) #=> 2
numbers           #=> [3, 5, 6, 7, 8, 9, 10]

numbers = Array.new(10) { |n| n = n * 2 }
#=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

numbers = Array(100..110)
#=> [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

# 或者我们可以将范围转换为数组
(100..110).to_a
#=> [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

arr = ['foo', 0, nil, 'bar', 7, nil]
arr.compact  #=> ['foo', 0, 'bar', 7]
arr      #=> ['foo', 0, nil, 'bar', 7, nil]
arr.compact! #=> ['foo', 0, 'bar', 7]
arr      #=> ['foo', 0, 'bar', 7]

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]
arr # => [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq! #=> [2, 5, 6, 556, 8, 9, 0, 123]
arr #=> [2, 5, 6, 556, 8, 9, 0, 123]

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
planets.include? "火星"
# 输出 => true
planets.include? "冥王星"
# 输出 => false

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
planets.size
# 输出 => 8
planets.length
# 输出 => 8

您可以使用 size 或 length，两者都是同义词

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.clear
# 输出 => []

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers[0]
# 或
numbers.first
# 输出 => 1

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers[-1]
# 或
numbers.last
# 输出 => 10

a = ["tom", "mot", "otm"]
b = [2, 3, 5]
a.zip(b)
# 输出
# [["tom", 2], ["mot", 3], ["otm", 5]]

primes = [7, 2, 3, 5]
primes.max_by { |p| p }
# 输出 => 7

primes = [7, 2, 3, 5]
primes.take(3)
# [7, 2, 3]

primes = [7, 2, 3, 5]
primes.fetch(3)
# 5
# 如果元素不存在，Fetch 将引发错误
primes.fetch(10)
# (索引 10 超出数组范围：-4...4)
# 或获取默认值
primes.fetch(10, -1)
# -1

primes = [7, 2, 3, 5]
primes.drop(3)
# [5]

primes = [7, 2, 3, 5]
primes.shift
# [2, 3, 5]

primes = [7, 2, 3, 5]
primes.pop
# [7, 2, 3]

primes = [7, 2, 3, 5]
primes.delete_at(-1)
# [7, 2, 3]

primes = [7, 2, 3, 5, 5]
primes.delete(5)
# [7, 2, 3]

salary = [399, 234, 566, 533, 233]
salary.each_with_index { |value, index| puts "#{index} #{value}" }
# 输出
# 0 399
# 1 234
# 2 566
# 3 533
# 4 233

salary = [399, 234, 566, 533, 233]
salary.each_index { |i| puts i}
# 输出
# 0
# 1
# 2
# 3
# 4

salary = [399, 234, 566, 533, 233]
salary.map { |s|  s * 10  }
# 返回
# [3990, 2340, 5660, 5330, 2330]
# 另一方面，each 返回原始值
salary = [399, 234, 566, 533, 233]
salary.each { |s|  s * 10  }
# 返回
# [399, 234, 566, 533, 233]

salary = [399, 234, 566, 533, 233]
salary.collect { |s| s > 400 }
# 输出
# [false, false, true, true, false]

for value in [2, 3, 5, 7]
    puts value
end

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
index = 0
while index < planets.size
    puts "#{planets[index]}"
    index += 1
end

a = 1
star = '*'
while a <= 10
    puts star
    star += '*'
    a += 1
end

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
index = 0
loop do
    puts "#{planets[index]}"
    index += 1
    break if planets[index] == "火星" or index > planets.size
end

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
index = planets.size - 1
until index < 0
    puts "#{planets[index]}"
    index -= 1
end

a = 1
star = '*'
until star.length > 10
    puts star
    star += '*'
    a += 1
end

10.times { puts "#{rand(1..100)}"}
# 输出
# 将打印 10 个随机数

仅仅因为你可以，并不意味着你应该像这样迭代数组

data_sample = [2, 3, 5, 7]
data_sample.size.times { |index| puts "#{data_sample[index]}" }
# 输出
# 2
# 3
# 5
# 7

data_sample = [2, 3, 5, 7]
0.upto((data_sample.size - 1) / 2) { |index| puts "#{data_sample[index]}" }
# 输出
# 2
# 3

data_sample = [2, 3, 5, 7]
(data_sample.size - 1).downto(data_sample.size / 2) { |index| puts "#{data_sample[index]}" }
# 输出
# 7
# 5

numbers = [2, 2, 2, 2, 2]
numbers.reduce(11, :+)
# 输出
# 21

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
planets.detect { |name| name.start_with?("地") and name.end_with?("球") }
# 输出
# 地球
salary = [399, 234, 566, 533, 233]
salary.detect { |s| s > 1000 }
# 输出
# nil

planets = ["水星", "金星", "地球", "火星", "木星", "土星", "天王星", "海王星"]
planets.find { |name| name.start_with?("地") and name.end_with?("球") }
# 输出
# 地球

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.select { |n| n % 2 == 0 }
# 现在你有一个偶数数组
# [2, 4, 6, 8, 10]
# 如果没有满足你逻辑的值，则返回一个空数组
[1, 1, 1].select { |n| n % 2 == 0 }
# 没有偶数
# []

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.reject { |n| n % 2 == 0 }
# 如果数字是偶数则拒绝，所以现在我们有一个奇数数组
# [1, 3, 5, 7, 9]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.keep_if { |n| n % 2 == 0 }
# numbers 数组只包含偶数
# [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete_if { |n| n % 2 == 0 }
# numbers 数组只包含奇数
# [1, 3, 5, 7, 9]

numbers = [1, 2, 3, 1, 2, 3, 0]
numbers.drop_while { |n| n < 3 }
# 3 小于 3 吗？返回 false，所以删除 1, 2
# [3, 1, 2, 3, 0]

words = %w[第一 第二 第三 第四 第五 第六]
str = ""
words.reverse_each {|word| str += "#{word} "}
p str #=> "第六 第五 第四 第三 第二 第一 "

[2, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
# true
[1, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
# false

[1, 3, 5, 7, 10].any? { |num| num % 2 == 0 }
# true
[1, 3, 5, 7, 19].any? { |num| num % 2 == 0 }
# false

[1, 3, 2, 5, 7].one? { |num| num % 2 == 0 }
# true
[1, 3, 2, 5, 4].one? { |num| num % 2 == 0 }
# false

[1, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
# true
[2, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
# false

[].empty?
# true
[1, 3, 5, 7, 9].empty?
# false

[0, 1, 2, 3] & [1, 2] # => [1, 2]
[0, 1, 0, 1] & [0, 1] # => [0, 1]

[0, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3])
# => [0, 1]
[0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3])
# => [0, 1]

a = [0, 1] + [2, 3]
a # => [0, 1, 2, 3]

[0, 1, 1, 2, 1, 1, 3, 1, 1] - [1]
# => [0, 2, 3]
[0, 1, 2, 3] - [3, 0]
# => [1, 2]
[0, 1, 2] - [4]
# => [0, 1, 2]

[0, 1, 2, 3].union([4, 5], [6, 7])
# => [0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 1].union([2, 1], [3, 1])
# => [0, 1, 2, 3]
[0, 1, 2, 3].union([3, 2], [1, 0])
# => [0, 1, 2, 3]

[0, 1, 1, 2, 1, 1, 3, 1, 1].difference([1])
# => [0, 2, 3]
[0, 1, 2, 3].difference([3, 0], [1, 3])
# => [2]
[0, 1, 2].difference([4])
# => [0, 1, 2]

a = [0, 1, 2]
a1 = [3, 4]
p = a.product(a1)
p.size # => 6 # a.size * a1.size
p # => [[0, 3], [0, 4], [1, 3], [1, 4], [2, 3], [2, 4]]

# 变量 count
count = 4
# 使用 while 循环
# 这里的条件是 count 即 4
while count >= 1
  # 要执行的语句
  puts "Ruby 速查表"
  count = count - 1
  # while 循环在此结束
end

输出

Ruby 速查表
Ruby 速查表
Ruby 速查表
Ruby 速查表

# 使用范围作为表达式的循环
text = "Ruby 速查表"
# 使用 for 循环和范围
for count in 1..5 do
  puts text
end

输出

Ruby 速查表
Ruby 速查表
Ruby 速查表
Ruby 速查表
Ruby 速查表

# do..while 循环的开始
loop do
  puts "Ruby 速查表"
  val = '7'
  # 使用布尔表达式
  if val == '7'
    break
  end
  # ruby do..while 循环的结束
end

输出

Ruby 速查表

var = 7
# 这里的 do 是可选的
until var == 11 do
  # 要执行的代码
  puts var * 10
  var = var + 1
  # 循环在此结束
end

输出

70
80
90
100

salary = [399, 234, 566, 533, 233]
salary.each do |s|
  break if s == 566
  puts s
end
# 输出
# 399
# 234

通过使用 break 关键字

salary = [399, 234, 566, 533, 233]
salary.each do |s|
  next if s == 533
  puts s
end
# 输出
# 399
# 234
# 566
# 233

通过使用 next 关键字

data = [456, 3000]
retry_count = 0
status = "网络故障"
sum = 0
data.each do |d|
    if retry_count == 3
        status = "连接已建立"
        retry_count = 0
        redo
    elsif status == "网络故障" and retry_count < 5
        puts "网络故障 #{retry_count}"
        retry_count += 1
        redo
    elsif status == "连接已建立"
        puts d
        sum += d
    end
end
# sum 的输出
# 3456

numbers = [2, 2, 44, 44]
sum = 0
begin
    numbers.each do |s|
        if rand(1..10) == 5
            puts "嗨 5，让我们再来一次！"
            sum = 0
            raise "嗨 5"
        end
        puts s
        sum += s
    end
rescue
    retry
end

class Person
    attr_accessor :name, :number
end
# 使用 < 符号从父类继承方法和属性
class Student < Person
    attr_accessor :id
end
s = Student.new
s.name = "詹姆斯·邦德"
s.number = 700
s.id = 678
puts "#{s.name}" # 更正：应该是 s.name 而不是 p.name
# 詹姆斯·邦德
puts "#{s.number}" # 更正：应该是 s.number 而不是 p.number
# 700
puts "#{s.id}" # 更正：应该是 s.id 而不是 p.id
# 678

class Vehicle; end
class Car < Vehicle; end
class Audi < Car; end
car = Car.new
car.instance_of? Vehicle
false
car.instance_of? Car
true
car.instance_of? Audi
false
a = 7
a.instance_of? Integer
true
a.instance_of? Numeric
false

如果对象是给定类的实例而不是子类或超类，则返回 true

puts (String.methods).sort
# 排除从 Object 类继承的方法
puts (String.methods - Object.public_instance_methods).sort

String.respond_to?(:prepend)
true
String.respond_to?(:append)
false