Ruby 趣学笔记（一）

本文写于 2020 年 5 月 6 日

• Ruby 趣学笔记（一）
  • 变量
    • 变量声明
    • 变量类型
  • 常量
  • 输出
  • 字符串
  • 字符串操作
  • Array
    • 数组的遍历
    • 数组的衔接
    • 怎样判别该变量是否是数组
  • 函数
    • 一般函数
    • 传参的函数
    • 解包参数
    • 部分参数解包
    • 参数的默许值
    • 传入一个散列
  • class
    • class 下面有啥办法？
    • 怎样判别这个办法是否存在呢？

最近在 mac 上探究到了 homebrew 的运用办法，对 ruby 的爱好直线上升，所以来学一学。

最近几年的确咱们一向在唱衰 Ruby，整个社区的生态的确也不如 python 那么巨大，可是这都不阻碍 ruby 被称作“高兴编程”。

这几年越来越着重言语的功能，可是 Ruby 的作者松本行弘却以为，人才是最重要的！

自看到这句话的第一眼，我就深以为同！

其实这便是一个价值观的问题：人更值钱，那么就应该尽量节约人力；机器算力更值钱，那么就应该用人力去优化程序，来节约机器的算力。可是国内的大环境咱们也懂，人多爆了......

自然而然，从上面的定论来看，Ruby 在国内不会盛行。

作为多范式编程言语，Ruby 会比 Java 等更难协作；作为解说型言语，运转速度必定比不上 C++ 超级慢……可许多人关于 Ruby 的点评仍然是：程序员的一把尖刀！

而且在 web 开发范畴，还有一些大公司（GitHub）坚持在运用 Ruby，这足以阐明 Ruby 的强壮了！

变量

变量声明

Ruby 的变量声明不需求关键字，也不需求类型信息。

message = 'hello world'
_num = 0

$h = [1, 2, 3]

小写最初、_ 最初的变量是局部变量；$ 最初的单词是全局变量。

而且默许 Ruby 不存在闭包。

在函数内拜访上级效果域的局部变量会报错。

变量类型

Ruby 不存在所谓的“根本类型”，比方 int / float / char...Ruby 只存在一个类型：目标。

全部皆目标的准则被严厉遵循！咱们能够不谨慎的以为：Ruby 的类型便是目标。

什么意思呢？

print(1.to_s)

to_s 天然生成的便是 1 的办法！数字 1 其实便是 Number 目标的实例。

Ruby 的数据类型有 Number、String、Ranges、Symbols，以及 true、false 和 nil，以及 Array、Hash。

其间比较有意思的是 true 和 false，他们的 class 并不是 Boolean，而是 TrueClass 和 FalseClass。

甚至连 class 都有 class——Class。

事实上，一切变量的 class 的 class，都是 Class 类。

常量

好像变量相同，Ruby 的常量声明也是经过约好。

一切首字母大写就代表常量，一般咱们习气将常量全大写（也有例如 GOLANG 以及一些其他言语引荐运用大驼峰命名）。

MAX_COUNT = 100

但 Ruby 究竟仍是个动态言语，即使是常量，咱们也是能够强行修正的，仅仅会正告你罢了。

MAX_COUNT = 100
MAX_COUNT = 101

p MAX_COUNT # 101

输出

Ruby 存在三种输出句子 print puts p。

其间，p 句子的输出能够让咱们看到更多的信息，例如

p "hello" # "hello"
puts "hello" # hello

p 能够让咱们看到是否是字符串，puts 则不能够。

所以一般程序中输出时会用 p，日志输出用 print 或 puts。

字符串

Ruby 能够用单引号或许双引号标示字符串，单引号中不会主动将转义字符转义、双引号会主动转义。

p "a\nb" # 会换行
p 'a\nb' # 不会换行，直接输出 \n

双引号中还能够进行相似 JS 的模板字符串的插值："hello #{userName}"。

Ruby 也支撑多行字符串。

str = <<fuck
1
2
3
3
fuck

在 << 后跟上某一个字符串，直到遇见相同的字符串，多行字符串就会完毕。

str = <<fuck
1
2
3
3fuck

但这种状况不会完毕，所以完毕符有必要坐落单行。

字符串操作

• +：字符衔接
• <<：字符带入
• *：字符循环

a = "hello";
b = "world";
puts a + " " + b;

# <<：字符带入
a << b
puts a
puts b

# 这个其实相当于 a = a + b

# *：字符循环
a = "A"
puts a * 4

Array

games = ['魔兽国际', '塞尔达传说', '金庸群侠传']
puts games

这个 games 的界说，假如你在 RubyMine 或许其他强壮的 IDE 中编写，他就会告知你，有更好的办法：games = %w[魔兽国际 塞尔达传说 金庸群侠传]

这便是为什么 Ruby 不易协作，一千个程序员有一千种写法与完成办法！

数组的遍历

这是永久的要点，编程中最为常用的办法。

Ruby 能够经过 each 来遍历数组，详细语法如下：

games.each do |game|
  puts "我喜爱#{game}"
end

这个当地略微提一句，我曾在某个当地看到过，写单引号的程序最终会比写双引号的小（文件巨细）。可是这儿这种模板字符串的写法，有必要要双引号。

带上数组下标的遍历

games.each_with_index do |game, i|
  puts "第#{i}个游戏是#{game}"
end

数组的衔接

games.join(',')，这个办法其实许多言语都有，能够回来一个由逗号衔接的、由数组每个元素次序组成的字符串。

怎样判别该变量是否是数组

这个怎样判别呢？？？

很简略，仍是运用 respond_to?。

怎样用？

刚刚的 each 办法就能够！

games.respond_to?('each') && puts '这是一个数组！'

函数

一般函数

def sayHello
  puts "Hello World."
end

sayHello() # Hello World.
sayHello # Hello World.

这儿能够看到，Ruby 的函数既能够带括号的调用，也能够直接调用。

传参的函数

def sayHello(name)
  puts "Hello, #{name}."
end

解包参数

函数会主动解包传入的数组。

def foo(p1, p2, p3)
  p p1 + p2 + p3
end

foo [1, 2, 3]

留意，这种将数组解包的函数，假如传入的数组长度大于参数数量，那么会直接报错。

部分参数解包

传入的剩余参数转化为数组。

def foo(base, *rest)
  rest.each do |item|
    base += item
  end

  return base
end

foo 1, 2, 3, 4, 5

*rest 参数能够不在结尾。

def foo(base, *rest, final)
  p base
  p rest
  p final
end

foo 1, 2, 3, 4, 5 # base 1, rest [2, 3, 4], final 5
foo 1, 2 # base 1, rest [], final 2
foo 1 # 报错

参数的默许值

def sayHello(name = 'world')
  puts "Hello, #{name}."
end

sayHello "啦啦啦"

传入一个散列

该方式有必要供给默许值。

def sayHello(url: "", id: 0)
  puts "#{url}?id=#{id}."
end

sayHello url: "xxx", id: 5

这就相似于 JS 中的：

function foo({ a, b } = { a: 1, b: 1 }) {}

这种方式还能够直接传入一个散列，可是有必要确保 key 类型是 Symbol 类型，String 或许其他类型都会导致报错：

h = {
  :p1 => 100,
  :p2 => 200
}

h_err = {
  'p1' => 100,
  'p2' => 200
}

class

让咱们来界说一个手机类：

class Phone
  def initialize(brand = '苹果', name = '刘好', number = 15_527_782_945)
    @brand = brand
    @name = name
    @number = number
  end

  def call
    puts "#{@name}运用#{@brand}手机，拨打了#{@number}的号码。"
  end
end

iPhone = Phone.new

iPhone2 = Phone.new('三星', '王自若', 1123321)

与函数相同，class 实例化时调用 new 办法也不需求括号。

Ruby 管 @ 最初的变量叫做实例变量，@@ 最初的叫做类变量。但其实相似于 Java 的成员变量和静态成员变量。

但不同的是，Ruby 自带封装性。

实例变量默许外部不能够拜访，需求咱们自界说一下 getter/setter。

• attr_accessor :xxx 为 getter/setter
• attr_reader :xxx 为 getter
• attr_writer :xxx 为 setter

class Game
    attr_accessor :price
    attr_reader :name
    def initialize(name = "怪物猎人国际", price = 200)
        @name = name
        @price = price
    end
end

class 下面有啥办法？

Phone.instance_methods(false)

这个办法，能够让咱们知道该类下，有什么办法是咱们自界说的。

关于上面写的 Phone 类，输出成果就会是：

call

就这么简略。

假如参数为 true 呢，则会显现一切的办法，包含自带的办法。

怎样判别这个办法是否存在呢？

iphone = Phone.new
iphone.respond_to?("call")

respond_to? 这个办法能够判别该目标是否具有某个办法，能够回来一个布尔值。

所以咱们一般能够这么用：iPhone.respond_to?("call") && iPhone.call

（未完待续）