安装

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

使用包管理器安装 rbenv

$ brew install rbenv ruby-build # macOS# Debian、ubuntu 和其他衍生产品$ sudo apt install rbenv

使用 rbenv 安装 ruby

# 列出最新的稳定版本$ rbenv install -l# 列出所有本地版本$ rbenv install -L# 安装 Ruby 版本$ rbenv install 3.1.2$ rbenv global 3.1.2 # 为这台机器设置默认Ruby版本# 或者$ rbenv local 3.1.2 # 设置此目录的 Ruby 版本$ rbenv local --unset$ rbenv version # 显示当前活动的 Ruby 版本=> 1.9.3-p327 (set by /Users/sam/.rbenv/version)

使用 RVM 安装 ruby

$ curl -sSL https://get.rvm.io | bash -s stable$ rvm list          # Ruby 版本列表$ rvm install 3.0.1 # 安装 3.0.1$ rvm use 3.0.1     # 使用 3.0.1

如何安装 ruby gem 管理器, bundler gem

# 访问 bash 以执行以下命令$ docker run -it --rm ruby:latest bash$ gem install bundler$ bundle -v$ gem update bundler$ gem uninstall bundler

什么是 Gemfile 和 Gemfile.lock

Gemfile 是 Bundler(也是 gem)的配置文件，其中包含项目的 gem 列表(依赖项)

# 在项目根目录的 Gemfile 中指定 gemruby '2.5.6'source 'https://rubygems.org'gem 'nokogiri'gem 'rack', '~>1.1'gem 'rspec', :require => 'spec'

安装 Gemfile 中的所有 gem

$ bundle install

安装特定 ruby gem 的特定版本

$ gem install bundler -v 1.17$ gem install minitest -v 5.8.4

使用 Bundler 更新 gem

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

保留字

注释

# 单行注释=begin多行注释=end=begin 注释第 1 行 =endputs "Hello world!"  # 代码的内联注释

运算符

逻辑运算符

• and
• or
• not
• &&
• ||
• !

位运算符

• &
• |
• ^
• ~
• <<
• >>

算术运算符

• +
• -
• *
• /
• %
• **

比较运算符

• ==
• !=
• >
• <
• >=
• <=
• <=>
• ===
• eql?
• equal?

运算符示例

# 添加1 + 1   #=> 2# 减法2 - 1   #=> 1# 乘法2 * 2   #=> 4# 分配10 / 5  #=> 217 / 5    #=> 3, not 3.417 / 5.0  #=> 3.4# 指数2 ** 2  #=> 43 ** 4  #=> 81# 模数(求除法的余数)8 % 2   #=> 0  (8 / 2 = 4; 没有剩余)10 % 4  #=> 2  (10 / 4 = 2 余数为 2)a = 10b = 20a == b #=> falsea != b #=> truea > b #=> falsea < b #=> truea >= b #=> falsea <= b #=> true# 比较运算符a <=> b #=> -1c = 20c <=> b #=> 0c <=> a  #=> 1# 用于测试 case 语句的 when 子句中的相等性(1...10) === 5 #=> true# 如果接收者和参数具有相同的类型和相等的值，则为真1.eql?(1.0) #=> falsec = a + b  #=> 30c += a #=> 40c -= a #=> 30c *= a #=> 300c /= a #=> 30c %= a #=> 3c **= a #=> 59049# Ruby 并行赋值a = 10b = 20c = 30a, b, c = 10, 20, 30# Ruby 位运算符a = 60b = 13# & 如果两个操作数中都存在，则二进制 AND 运算符将位复制到结果中。a & b #=> 12# | 如果二进制或运算符存在于任一操作数中，则复制一个位。a | b #=> 61# ^ 二元异或操作符如果在一个操作数中设置，则复制该位，但不能同时在两个操作数中设置。a ^ b #=> 49# ~ 二进制补码运算符是一元的，具有“翻转”位的效果。~a# << 二进制左移运算符。 左操作数的值被移动# 左操作数指定的位数。a << 2# >> 二进制右移运算符。 左操作数的值被移动# 右操作数指定的位数。a >> 2# Ruby 逻辑运算符a and b #=> true.a or b #=> true.a && b #=> true.(a || b) #=> true.!(a && b) #=> false.not(a && b) #=> false.# Ruby 三元运算符# ? :# 如果条件为真？ 然后值 X ：否则值 Ya == 10 ? puts 'Right' : puts 'Wrong'# Ruby 范围运算符# .. 创建从起点到终点的范围(含)1..10 #=> 创建从 1 到 10 的范围(包括 1 到 10)# ... 创建一个从起点到终点的范围，不包括在内1...10 #=> 创建一个从 1 到 10 的独占范围

运算符优先级表

• !, ~, unary +
• **
• unary -
• *, /, %
• +, -
• <<, >>
• &
• ^
• >, >=, <, <=
• <=>, ==, ===, !=, =~, !~
• &&
• ?, :
• modifier-rescue
• =, +=, -=, *=, /=, %=
• defined
• not
• or, and
• modifier-if, modifier-unless, modifier-while, modifier-until
• { } 块
• do ... end 块

变量和范围

有五种不同类型的变量。第一个字符确定范围

局部变量

current_weather = "rainy"_weather = "sunny"

必须以下划线或小写字母开头

实例变量

# 实例类变量@current_weather = "rainy"# 全局变量$current_weather = "rainy"# 常量变量WEATHER = "rainy".freeze

伪变量

选项变量

预定义变量

预定义的全局常量

检查变量的范围

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

数据类型

进一步阅读

检查数据类型

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

Symbol

week_days = {sunday: 11, monday: 222}

整数有用的方法

2.even?# true3.even?# false

范围

.. 用于创建包含范围

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

... 用于创建专属范围

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

一些有用的方法

在 Range 中使用 step

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

条件结构

if 修饰符

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

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

if elsif else 语句

temp = 19if temp >= 25  puts "hot"elsif temp < 25 && temp >= 18  puts "normal"else  puts "cold"end# 输出 => normal

除非语句

# 除非与 if 相反，当语句为假时进行评估name = "rob"# if name != "bob"unless name == "bob"  puts "hello stranger"else  puts "hello bob"end# 输出 => hello strangernum = 6puts 'not two' unless num == 2# 输出 => not two

case 陈述

# case 返回最后执行的表达式的值case input# 检查一个整数，19when 19  puts "It's 19"  # 检查浮点数，33.3when 33.3  puts "It's 33.3"  # 检查一个确切的字符串，“Zaman”when "Zaman"  puts "Hi Zaman"when 10  puts "It's 10"  # 检查范围when 7..11  puts "It's between 7 and 11"  # 检查多个值，“咖啡”when "tea", "coffee"  puts "Happy days"  # 检查正则表达式“aA6”when /^a[A-Z]+[0-6]+$/  puts "It's a valid match"  # 通过与 String 类“任何字符串”  # 进行比较来检查任何字符串when String  puts "It's a String"end

case 简短的语法

case input  when 19 then puts "It's 19"end

case 可选的失败

case input  when 19 then puts "It's 19"else  puts "It's not 19"end

case 获取返回值

marks = 86result = case marks        when 0..49 then "Fail"        when 50..64 then "Pass"        when 65..74 then "Credit"        when 75..84 then "Distinction"        when 85..100 then "High Distinction"        else "Invalid marks"        endputs result# High Distinction

字符串

字符串插值

name = "World"puts "Hello #{name}"puts "The total is #{1+1}"# "the total is 2"

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

提取子字符串

string = "abc123"string[0,3]# "abc"string[3,3]# "123"string[0..-2]# "abc12"#remove or replace the substringstring[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"

有用的方法

方法

声明一个方法

def method_name(parameter1, parameter2)    puts "#{parameter1} #{parameter2}"    parameter1 + parameter2end

res = method_name(20, 10)# 输出 => 30def method_name(parameter1, parameter2)    puts "#{parameter1} #{parameter2}"    return parameter1 + parameter2end# 输出 => 30

调用方法

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

类方法

类方法是类级别的方法。 有多种定义类方法的方法

class Mobile    def self.ring        "ring ring ring..."    endendMobile.ring

class Mobile    def Mobile.ring        "ring ring ring..."    endendMobile.ring

class Mobile    class << self    def ring        "ring ring ring..."       end    endendMobile.ring

类方法是类对象的实例方法。 当创建一个新类时，“Class”类型的对象被初始化并分配给一个全局常量（在本例中为 Mobile）

Mobile = Class.new do    def self.ring        "ring ring ring..."    endendMobile.ring

Mobile = Class.newclass << Mobile    def ring        "ring ring ring..."    endendMobile.ring

使用另一个参数作为默认值

def method_name(num1, num2 = num1)    return num1 + num2endres = 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"endres = method_name(20, 10)# 输出 => 30

将可变长度参数传递给方法参数

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

修改对象

a = ["Drama", "Mystery", "Crime","Sci-fi", "Disaster", "Thriller"]a.sortputs a# 我们没有修改对象# Drama# Mystery# Crime# Sci-fi# Disaster# Thrillera.sort!puts a# 修改对象# Crime# Disaster# Drama# Mystery# Sci-fi# Thriller

当您要修改对象时，在方法之后使用 !

布尔方法

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

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

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

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

Blocks (块)

块示例

# return valuedef give_me_data    data = yield    puts "data = #{data}"endgive_me_data { "Big data" }# 输出 => data = Big data

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

单行块

salary = [399, 234, 566, 533, 233]salary.each { |s| puts s }# puts s = block body# |s| = block arugments

多行块

salary.each do |s|    a = 10    res = a * s    puts resend# 块体# a = 10# res = a * s# puts res# 块参数# |s|

块可以作为方法参数传递，也可以与方法调用相关联。 块返回最后评估的语句

隐式传递一个块

def give_me_data    puts "I am inside give_me_data method"    yield    puts "I am back in give_me_data method"endgive_me_data { puts "Big data" }# 输出# I am inside give_me_data method# Big data# I am back in give_me_data method

多次调用

def give_me_data    yield    yield    yieldendgive_me_data { puts "Big data" }# 输出# Big data# Big data# Big data

使用块参数调用

def give_me_data    yield 10    yield 100    yield 30endgive_me_data { |data| puts "Big data #{data} TB" }# 输出# Big data 10 TB# Big data 100 TB# Big data 30 TB

使用多个块参数调用

def give_me_data    yield "Big data", 10, "TB"    yield "Big data", 100, "GB"    yield "Big data", 30, "MB"endgive_me_data { |text, data, unit| puts "#{text} #{data} #{unit}" }# 输出# Big data 10 TB# Big data 100 GB# Big data 30 MB

块将尝试从当前上下文返回

give_me_data    puts "我在 give_me_data 方法里面"enddef test  puts "我在测试方法里面"  give_me_data { return 10 } # 代码从这里返回  puts "I am back in test method"endreturn_value = test# 输出# 我在测试方法里面# 我在 give_me_data 方法里面# 10

通过使用 & 参数显式传递块

def give_me_data(&block)    block.call    block.callendgive_me_data { puts "Big data" }# 输出# Big data# Big data

检查是否给出了块

def give_me_data    yieldendgive_me_data# 输出# LocalJumpError: no block given (yield)

处理异常并使块可选的方法

def give_me_data    return "no block" unless block_given?    yieldendgive_me_data { puts "Big data" }give_me_data# 输出# Big data

Procs

Procs 示例

p = Proc.new { puts "Hello World" }def give_me_data(proc)    proc.callendgive_me_data p# 输出# Hello World

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

任意参数

p = Proc.new { |count| "Hello World " * count }def give_me_data(proc)    proc.call 5, 2endgive_me_data p# 输出# "Hello World Hello World Hello World Hello World Hello World "

proc 将尝试从当前上下文返回

p = Proc.new { return 10 }p.call# 输出LocalJumpError: unexpected return

不能从顶级上下文返回

def give_me_data    puts "我在 give_me_data 方法里面"    p = Proc.new { return 10 }    p.call # 代码从这里返回    puts "I am back in give_me_data method"endreturn_value = give_me_dataputs return_value# 输出# 我在 give_me_data 方法里面# 10

Lambdas

声明一个 lambda

l = lambda { puts "Hello World" }# 速记l = -> { puts "Hello World" }# 调用 lambdal.call# 输出 => Hello World

有多种方法可以调用 lambda

l.()l[]

严格的 arguments

l = -> (count) { "Hello World " * count }l.call 5# 输出# "Hello World Hello World Hello World Hello World Hello World "l.call 5, 2# 输出wrong number of arguments (given 2, expected 1)

块中声明一个 lambda

def give_me_data    puts "I am inside give_me_data method"    l = -> { return 10 }    l.call    puts "I am back in give_me_data method"endreturn_value = give_me_dataputs return_value# 输出# I am inside give_me_data method# I am back in give_me_data method# nil # because puts return nil

lambdas 从 lambda 本身返回，就像常规方法一样

l = -> { return 10 }l.call# 输出 => 10

数组

初始化一个空数组

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

包含不同类型的对象的数组

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

用初始大小和默认对象填充数组

numbers = Array.new(3)       #=> [nil, nil, nil]numbers = Array.new(3, 7)    #=> [7, 7, 7]numbers = Array.new(3, true) #=> [true, true, true]numbers = []numbers.fill(7, 0..2)   #=> [7, 7, 7]

不同哈希值的数组

array_with_hashes = Array.new(2) { {} } #=> [{}, {}]array_with_hashes[0][:name] = "Bob"array_with_hashes[0][:id] = 10          #=> [{:name=>"Bob", :id=>10}, {}]

二维数组

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

数组方法 at

str_array = [  "This", "is", "a", "small", "array"]puts str_array.at(0)      #=> "This"

范围获取

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

数组方法 fetch

arr = ['a', 'b', 'c', 'd', 'e', 'f']arr.fetch(100)#=> IndexError: 数组边界外的索引 100：-6...6arr.fetch(100, "oops")    #=> "oops"

超出边界，给默认值

获取数组元素

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

在数组末尾添加值 push

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]

数组末尾删除值 pop

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

在数组的开头添加值 unshift

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]

检索并同时删除第一个元素 shift

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

删除特定索引处的元素 delete_at

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

删除数组中任意位置的特定元素

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

在给定索引处插入值 insert

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

一个块来填充数组的值

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]

从数组中删除 nil 值

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]

去重 uniq

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

检查数组中是否存在值（include？）

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]planets.include? "Mars"# 输出 => trueplanets.include? "Pluto"# 输出 => false

获取数组大小

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]planets.size# 输出 => 8planets.length# 输出 => 8

您可以使用大小或长度，两者都是同义词

清除数组

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]# ornumbers.first# 输出 => 1

获取数组的最后一个元素

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

合并两个数组

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

对数组进行排序

primes = [7, 2, 3, 5]sorted_primes = primes.sortputs "#{sorted_primes}"# 输出 => [2, 3, 5, 7]

or in-place sort

primes = [7, 2, 3, 5]primes.sort!puts "#{primes}"# 输出 => [2, 3, 5, 7]

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]planets.sort# 输出# ["Earth", "Jupiter", "Mars", "Mercury", "Neptune", "Saturn", "Uranus", "Venus"]planets.sort_by { |p| p }# 输出# ["Earth", "Jupiter", "Mars", "Mercury", "Neptune", "Saturn", "Uranus", "Venus"]planets.sort_by { |p| p.length }# 输出# ["Mars", "Earth", "Venus", "Saturn", "Uranus", "Neptune", "Jupiter", "Mercury"]

从数组中获取最大值

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

使用范围获取数组元素

# numbers[start..end], both index are inclusiveputs numbers[0..3]# 1# 2# 3# 4# numbers[start..end], end index is exclusiveputs numbers[0...3]# 1# 2# 3# or numbers[start..length]puts numbers[0, 1]# 1

获取数组的前n个元素

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

访问元素

primes = [7, 2, 3, 5]primes.fetch(3)# 5# Fetch will throw an error if the element does not existprimes.fetch(10)# (index 10 outside of array bounds: -4...4)# or get an default valueprimes.fetch(10, -1)# -1

从数组中删除重复元素

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

删除前 n 个元素

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]

each

# 当你有单行块时salary = [399, 234, 566, 533, 233]salary.each { |s| puts s }# 输出# 399# 234# 566# 533# 233

当你有一个多行块时，你可以用 do 和 end 替换花括号 {}

salary.each do |s|  a = 10  res = a * s  puts resend# 输出# 3990# 2340# 5660# 5330# 2330

或者您可以使用大括号 {} 和分号作为分隔符而不是换行符来做同样的事情

salary.each { |s| a = 10 ; res = a * s ; puts res }

each_with_index

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

each_index

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

map

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

collect

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

for

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

each_with_object

colors = [  {color: "red", count: 3}, {color: "red", count: 5}, {color: "black", count: 4}]colors.each_with_object(Hash.new(0)) { |color, hash| hash["color_"+color[:color]] = color[:color].upcase; hash["count_"+color[:color]] += color[:count] }# 输出{"color_red"=>"RED", "count_red"=>8, "color_black"=>"BLACK", "count_black"=>4}[1, 2, 3].each_with_object(0) { |number, sum| sum += number}# 输出# 0# 因为0是不可变的，由于初始对象是0，所以方法返回0

while

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]index = 0while index < planets.size    puts "#{planets[index]}"    index += 1end

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

do while

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]index = 0loop do    puts "#{planets[index]}"    index += 1    break if planets[index] == "Mars" or index > planets.sizeend

until

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]index = planets.size - 1until index < 0    puts "#{planets[index]}"    index -= 1end

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

times

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

upto

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

downto

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

step

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

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

inject

numbers = [2, 2, 2, 2, 2]numbers.inject{ |res, n| res + n }# 输出是所有数字之和的结果# 如果不给res设置初始值，则数组的第一个元素作为res的初始值# 10# 现在将 res 的值设置为 11numbers = [2, 2, 2, 2, 2]numbers.inject(11) { |res, n| res + n }# so 11 + 2, 13 + 2, 15 + 2, 17 + 2 and 19 + 2# 21# using symbolnumbers = [2, 2, 2, 2, 2]numbers.inject(:+)# 输出# 10

使用初始值和符号

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

reduce

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

detect

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]planets.detect { |name| name.start_with?("E") and name.end_with?("h") }# output# Earthsalary = [399, 234, 566, 533, 233]salary.detect { |s| s > 1000 }# output# nil

find

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]planets.find { |name| name.start_with?("E") and name.end_with?("h") }# output# Earth

select

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 }# no even numbers# []

reject

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

keep_if

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

delete_if

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

drop_while

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

reverse_each

words = %w[first second third fourth fifth sixth]str = ""words.reverse_each {|word| str += "#{word} "}p str #=> "sixth fifth fourth third second first "

布尔可枚举方法

布尔可枚举方法

all?

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

any?

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

one?

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

none?

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

empty?

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

组合方法

组合方法

• & 返回一个新数组，其中包含在数组和数组 other_array 中找到的每个元素；省略重复；使用 eql? 比较项目
• intersection 返回一个新数组，其中包含在 self 和所有给定数组 other_arrays 中找到的每个元素；省略重复；使用 eql? 比较项目
• + 返回一个数组，该数组包含 self 的所有元素，后跟给定数组的所有元素
• - 返回一个数组，其中包含在给定数组中找不到的所有 self 元素
• union 返回一个数组，其中包含 self 的所有元素和给定数组的所有元素，已删除重复项
• difference 返回一个数组，其中包含在任何给定数组中找不到的所有 self 元素
• product 返回或产生来自 self 和给定数组的所有元素组合

&

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

intersection

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

union

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

difference

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

product

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

循环

while 循环

# variable countcount = 4# using while loop# here conditional is count i.e. 4while count >= 1  # statements to be executed  puts "Ruby Cheatsheet"  count = count - 1  # while loop ends hereend

输出

Ruby CheatsheetRuby CheatsheetRuby CheatsheetRuby Cheatsheet

for 循环

# loop using range as expressiontext = "Ruby Cheatsheet"# using for loop with the rangefor count in 1..5 do  puts textend

输出

Ruby CheatsheetRuby CheatsheetRuby CheatsheetRuby CheatsheetRuby Cheatsheet

do..while 循环

# starting of do..while looploop do  puts "Ruby Cheatsheet"  val = '7'  # using boolean expressions  if val == '7'    break  end  # ending of ruby do..while loopend

输出

Ruby Cheatsheet

until 循环

var = 7# here do is optionaluntil var == 11 do  # code to be executed  puts var * 10  var = var + 1  # here loop endsend

输出

708090100

跳出循环

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

通过使用 break 关键字

在循环内跳过

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

通过使用 next 关键字

重复当前迭代

data = [456, 3000]retry_count = 0status = "network failure"sum = 0data.each do |d|    if retry_count == 3        status = "connection established"        retry_count = 0        redo    elsif status == "network failure" and retry_count < 5        puts "network failure #{retry_count}"        retry_count += 1        redo    elsif status == "connection established"        puts d        sum += d    endend# output of sum# 3456

重新开始循环

numbers = [2, 2, 44, 44]sum = 0begin    numbers.each do |s|        if rand(1..10) == 5            puts "hi 5, let's do it again!"            sum = 0            raise "hi 5"        end        puts s        sum += s    endrescue    retryend

Classes

Classes 示例

class Person    # when you create a new object, it looks for a method named initialize and executes it, like a constructor in java    # def initialize(name, number)    #    @name = name    #    @number = number    # end    # instance variable    # @name    # class variable    # @@count    # attr_accessor acts as a getter and setter for the following instance attributes    attr_accessor :name, :number    # class variable must be initialized    @@count = 0    def self.count        @@count    end    def self.count=(count)        @@count = count    end    def initialize        @@count += 1    endend# create an instance of the Person classp1 = Person.new# set attributes of the Person classp1.name = "Yukihiro Matsumoto"p1.number = 9999999999# get attributes of the Person classputs "#{p1.name}"puts "#{p1.number}"puts "#{Person.count}"# Yukihiro Matsumoto# 9999999999# 1p2 = Person.newp2.name = "Yukihiro Matsumoto"p2.number = 9999999999# get attributes of the Person classputs "#{p2.name}"puts "#{p2.number}"puts "#{Person.count}"# Yukihiro Matsumoto# 9999999999# 2# set class variablePerson.count = 3puts "#{Person.count}"# 3

继承一个类

class Person    attr_accessor :name, :numberend# 使用 < 符号从父类继承方法和属性class Student < Person    attr_accessor :idends = Student.news.name = "James Bond"s.number = 700s.id = 678puts "#{p.name}"James Bondputs "#{p.number}"700puts "#{p.id}"678

检查实例类型

class Vehicle; endclass Car < Vehicle; endclass Audi < Car; endcar = Car.newcar.instance_of? Vehiclefalsecar.instance_of? Cartruecar.instance_of? Audifalsea = 7a.instance_of? Integertruea.instance_of? Numericfalse

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

打印一个类的所有方法名

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

检查一个类是否有特定的方法

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

官网 ruby-lang.org