1月10日 ruby基础教程，查漏补缺； 2月22日 Exception补充

https://ruby-doc.org/core-2.5.0/Exception.html

1月20日练习完1,2章。

第一章 初探

‘’单引号不执行转义符。

\t 制表符。\n 换行符。

p mehtod ,类似于puts,但转义符不起效果,另外会对数字和string以不同形式输出。

2.3.1 :011 > p 100

100

 => 100

2.3.1 :012 > p "100"

"100"

 => "100"

---

数学运算符，如果是sin,cos，平方根。需要在函数前加Math.

例子：Math.sqrt(100)  =>10.0

9.2653e-05表示（小数） * 10的（整数）次幂

---

变量名 = 对象 ：这个过程称为将对象赋值给变量，变量相当于给对象贴上的标签。

例子：area = 100. area表示area这个变量引用的对象。

---

注释：

单行 #

行 =begin..=end

---

迭代器：iterator, 就是iterate循环的容器or.

times方法，each方法都是迭代器。

---

第二章  Object

array,hash, regular expression.

hash:的三种写法

1. hash = {:name => "Tom", :address => "xxx"} 这是符号的写法，可以省略为{name:"Tom",...}
2. hash = {"name" => "Tom", ...}  这是string的写法
3. hash = {1 => "xxx", 2 => "yyy"}  这是数值的写法。

re的匹配正则表达式与字符串的写法：

/pattern/ =~ "string"

/pattern/i =~ "string"   #忽略大小写

2.3.1 :033 > names = ["小林","王明","陈"]

 => ["小林", "王明", "陈"]

2.3.1 :034 > names.each do |name|

2.3.1 :035 >     if /陈/ =~ name

2.3.1 :036?>     puts name

2.3.1 :037?>     end

2.3.1 :038?>   end

陈

 => ["小林", "王明", "陈"]

---

第三章创建命令

name = ARGV[0]  #类似于gets ,共同点是得到的都是string。

代码：print File.read(ARGV[0])

#输入ruby read_text_oneline.rb 文件名（带后缀）

each_line 方法： 用于对文件进行逐行处理，或逐个处理数组元素。用在大文件时，减少占用内存的空间。

例子：

pattern = Regexp.new(ARGV[0])    #Regular expression正则表达式

filename = ARGV[1]

file = File.open(filename)

file.each_line do |line|

  if pattern =~ line    #查找 =～

    print line

  end

end

file.close

---

引用library库的方法：require

调用其他文件内的自定义方法def..end ,或者Ruby提供的标准库

require 希望使用的库名
和

require_relative 希望使用的库名   #根据执行中的程序目录（文件夹）来进行。

案例：use_grep.rb 和 grep.rb

---

---

第四章 object,variable,constant

类          对象     解释

Numeric   数值     整数，浮点，矩阵，复数，公式

String      字符串

Array

Hash

Regexp    正则表达式对象

File          文件      对文件进行读写操作的对象

Symbol    符号

Range      范围对象

expection 异常对象

Data        时间对象

---

变量：

local variable   英文小写 或 _开头

global variable  $开头，不常用

instance variable  @开头, 实例变量

class variable       @@开头  类变量

---

Constant 常量 ：大写字母开头

如果改变constant的值，Ruby会发出⚠️， 但还是会改变该值。

---

保留字：不能使用作为变量或常量的单词，Ruby已经占用了。会报告❌。

begin, end, alias ,and ,BEGIN ,END, break  case ,class ,def ,defined? ,do ,else ,elsif ,ensure, false ,for, if, in, module, next, nil, not, or, redo, rescue, retry, return, self, super, then, true, undef, unless, until, when, while, yield.

---

多重赋值：

> a, b, c = 1,2,3

 => [1, 2, 3]

> a

 => 1

> a, b,*c = 1,2,3,4,5     # 变量前加*，表示ruby将未分配的值封装为数组赋值给该变量。

 => [1, 2, 3, 4, 5]

> c

 => [3, 4, 5]

> b

 => 2

> p [a, b, c]

[1, 2, [3, 4, 5]]

 => [1, 2, [3, 4, 5]]

多重赋值的方便之处： 交换变量的值，无需再通过临时变量temp.直接一行搞定！

a,  b = 1, 2

a,  b = b, a

p [a,b]  #=> [2, 1]

---

---

第五章 条件判断

if,  unless, case.

unless 条件为假 then  处理  end

unless 条件

处理1

else

处理2

end

case:比较对象只有一个的时候，根据对象值的不同，执行不同处理结果 。when可以指定多个值。

case 比较对象

when 值1.. then

处理1

when 值2.. then

处理2

when 值3.. then

处理3

end

case value

when a

..

when b

..

else

..

end

等同于, ===是更广泛的相等。可以用于正则表达式，判断右边的对象是否属于左边的类，等等。

if a === value

..

elsif b === value

..

else

..

end

---

对象的同一性：

所以对象都有ID和value. 对象的ID可以用object_id方法来获得。

判断两个对数是否有为同一个对象，用equal?方法

---

---

第六章  循环

1.循环的目的，做什么？

2.停止循环的条件是什么？

循环语句： whlie, for, until

循环方法： times, each, loop

for 就是 each的语法糖，都是从对象中抽取元素时使用。

---

循环的次数.times do |i|

希望循环的处理

end

---

for 变量 in 对象 do

希望循环的处理

end

或者

for variable in 开始的数..结束的数 do

希望循环的处理

end

实际上，数值范围，也是对象范围。例子：

names = ["awk", "perl", "python", "ruby"]

for name in names do

  puts name

end

---

while语法

sum = 0

i = 1

while i < 5 do

sum = sum + i

i += 1

end

和for语句的程序有2个差别:

第一：条件的指定方式不一样，while用了比较运算符号

第二，i的累加方式不一样，for是自动累加.

---

Until语法

也有♻️，和while相反，否定条件下，进行循环。

sum = 0

i = 1

until sum >= 50 do

  sum += i

  i += 1

  puts sum

end

---

在Ruby中，for语句是用each方法来实现的。因此，可以使用each方法的对象，同样也可以指定为for语句的循环对象。

names = ["awk", "perl", "python", "ruby"]

for name in names do

  puts name

end

#等同

names.each do |name|

  puts name

end

#等同

names.each {|name| puts name}

---

Loop方法

不限制循环次数

loop do

print "ruby"

break

end

---

♻️控制

break：跳出循环。(终止整个循环程序)

next: 下一个循环（遇到next忽略本次循环的后面的语句，直接开始循环程序的下一次循环）

redo: 在相同条件下重复刚才的处理

#这是strip.rb 

file = File.open(ARGV[0])

file.each_line do |line|

  next if /^\s*$/ =~ line   #空行

  next if /^#/ =~ line       #以 #开头的行

  puts line

end

file.close

#这是hello.rb

#Hello, World

puts "Hello World"

#日元

puts "日元"

#人民币

puts "人民币"

#当输入 ruby strip.rb hello.rb 后返回：

puts "Hello World"

puts "日元"

puts "人民币"

总结：任何种类的循环都可以用while实现，但为了便于读写和理解ruby提供了其他语句和方法。

---

---

---

第七章 Method

7.1 object.method(parmeter1,par2,...)

object又被称为receiver,在面向对象的世界，调用方法被称为“向object发送messages”，调用的结果就是“Object received messages.”。简单来说，方法的调用就是把几个参数连同消息一起发送给Object的过程。

7.12带块的方法调用

Object.Method(参数，...) do |变量1，变量2...|

block 内容

end

7.13运算符形式的方法调用

obj =~ arg1

!obj

-obj

obj[arg1]

obj[arg1] = arg2   #给对象赋值

7.2M e h t o d 分类 

• Instance method
• Class method
• Function method

7.21 instance method

> p "10, 20, 33".split(",") #=> ["10", " 20", " 33"]

> p  ["a",12,"b"].index(12)          #=> 1  Return the index of the first object in []

7.22  Class method

Array.new

File.open("some_file")   #创建新的文件对象

Time.now                     #创建新的Time对象

7.23 函数式方法function method

没有接受者的方法。

print "hello"

sleep(10)

7.3 define method 

def hello(name="默认参数")     #方法名（参数1, 参数2...）

puts "hello, #{name}"    #希望执行的处理

end

hello(要传入的参数)

return 返回方法的值，省略的话，Method最后一个表达式的结果就会成为方法的返回值。

Ruby有很多返回值为nil的方法，如print

7.32 定义带块的方法

def myloop

  while true

    yield #yield 生产：执行块

  end

end

num = 1

myloop do

  break if num > 10      #类似于loop方法，遇到break终止循环

  puts "num is #{num}"

  num = num * 2

end

7.33 参数个数不确定的方法 

def foo(*args)

args

end

p foo(1,2,3)     #=> [1,2,3]

7.34 关键字参数

将参数名和值成对的传给method内部使用

>def area2(x:0,y:0,z:0)

>   xy = x * y

>   yz = y * z

>   zx = z * x

>   (xy+yz+zx)*2

>end                         

> p area2(x:2, y:2, z:3)

=> 32

可以用hash传递参数。

arg1 = {x:2, y:3, z:4}

p area2(arg1)    #=> 52

---

---

第八章， class and model

model模块是Ruby独有的概念。

类表示对象的种类。是对象的雏形或设计图。

ary = Array.new  #或者用 ary = []

p ary      #=> []

str = "Hello World"

p ary.class    #=> Array

p str.class #=> String  class方法返回变量的类型。

p ary.instance_of?(Array)  #=> true  instanc_of?() 方法判断对象是否是括号内的类的实例。等同is_a?

8.12 inheritance

通过扩展已经定义的类来创建新类，继承。subclass, superclass.

1.追加新功能

2.重新定义原有功能

3.扩展原有功能

BaseObject是Ruby中所有类的superclass父类。

8.2 create class

class HelloWorld   # class语句
 def initialize(myname = "Ruby") # initialize方法,生成新的对象时候用到
 @name = myname   # 初始化实例变量
 end
 def hello   # 实例方法
 puts "Hello, world. I am #{@name}."
 end
end
bob = HelloWorld.new("Bob")
alice = HelloWorld.new("Alice")
ruby = HelloWorld.new
bob.hello

注意⚠️ ：实例化对象的代码，不能在类内部写！

实例变量@name，只要他的实例对象存在，它就存在。而local variable 只在方法被调用时候存在。

8.24 attr_accessor  Method 存取器

在Ruby中，从对象外部不能直接访问实例变量或对实例变量赋值，需要通过Method来访问object的内部。

class HelloWorld
...

 attr_accessor :name #等同于下面两个method

 def name # 获取@name
 @name
 end

 def name=(value) # 修改@name
 @name = value
 end
...
end

bob = HelloWorld.new("Bob")

p bob.name  #读实例变量name

bob.name = "Robert"  #改写实例变量name 

p bob.name

8.25 self

在实例method中，可以用self这个特殊变量来引用方法的接受者object.

class HelloWorld
attr_accessor :name
...
def greet
puts "Hi, I am #{self.name}." # 这个是调用对象自身的name方法
end

 def hello 



puts "Hello, world. I am #{@name}"  #输出实例变量@name

end

end

8.26 class method

一共有4种写法 ，定义类方法

---

以定义实例方法的形式来定义类方法： (单例类定义)

class << HelloWorld

def hello

puts "xxx"

end

end

HelloWorld.hello #=> "xxx"

---

在类中嵌套： 使用class << self ~ end

class HelloWorld

class << self

def hello

puts "xxx"

end

end

end

HelloWorld.hello #=> "xxx"

---

用 def class_name.mehtod_name  ~ end

def HelloWorld.hello

puts "xxx"

end

HelloWorld.hello #=> "xxx"

---

使用self

def self.hello

puts "xxx"

end

HelloWorld.hello #=> "xxx"

---

8.27常量constant

在类中定义的常量，通过 class_name::constant_name来冲外部访问。

class HelloWorld

Version = "1.0"

...

end

p HelloWorld::Version    #=> "1.0"

8.28 class variable

同常量一样所以object实例可以共享，不过可以修改 变量的值。

和instance variable一样，从外部访问需要用到 accessor method (存取器或访问器)，但：

attr_accessor不支持@@variable,所以需要自定义存取方法。

class HelloCount
@@count = 0 # 调用hello方法的次数
def HelloCount.count # 读取调用次数的类方法,另一种写法self.count
@@count
end
def initialize(myname="Ruby")
@name = myname
end
def hello
@@count += 1 # 累加调用次数
puts "Hello, world. I am #{@name}.\n"
end
end
bob = HelloCount.new("Bob")
alice = HelloCount.new("Alice")
ruby = HelloCount.new
p HelloCount.count #=> 0
bob.hello
alice.hello
ruby.hello
p HelloCount.count #=> 3

8.29 限制方法的调用

public：以实例方法的形式向外部公开该方法。

protected：不能从实例外部访问，但在同一类中可以将该方法作为实例方法调用。

private : 无法从实例外部访问。（最严格）

class AccTest
def pub
puts "pub is a public method."
end
public :pub # 把pub方法设定为public（可省略）
def priv
puts "priv is a private method."
end
private :priv # 把priv方法设定为private
end
acc = AccTest.new
acc.pub
acc.priv

结果：

pub is a public method

acc_test.rb:15:in `<main>': private method `priv' called for #<AccTest:0x007fc6a4807218> (NoMethodError)

class Point
attr_accessor :x, :y # 定义存取器
protected :x=, :y= # 把x=与y=设定为protected

  #如果设为private :x=, :y= 则方法swap(other)也不管用了。
def initialize(x=0.0, y=0.0)
@x, @y = x, y
end
def swap(other) # 置换x、y值的方法
tmp_x, tmp_y = @x, @y
@x, @y = other.x, other.y
other.x, other.y = tmp_x, tmp_y # 在同一个类中可以被调用
return self
end
end
p0 = Point.new
p1 = Point.new(1.0, 2.0)
p [ p0.x, p0.y ] #=> [0.0, 0.0]
p [ p1.x, p1.y ] #=> [1.0, 2.0]
p0.swap(p1)
p [ p0.x, p0.y ] #=> [1.0, 2.0]
p [ p1.x, p1.y ] #=> [0.0, 0.0]
p0.x = 10.0 #=> 错误（NoMethodError）

---

8.3扩展class

8.31在原有class的基础上 添加新的方法

8.32 继承类

class subclass < superclass

定义

end

class RingArray < Array # 指定父类
def [](i) # 重定义运算符[]
idx = i % size # 计算新索引值
super(idx) # 调用父类中同名的方法
end
end
wday = RingArray["日", "月", "火", "水", "木", "金", "土"]
#定义数组可以省略.new  wday = RingArray.new(["日", "月", "火", "水", "木", "金", "土"])

p wday[6] #=> "土"
p wday[11] #=> "木"
p wday[15] #=> "月"
p wday[-1] #=> "土"

p wday.[](6) #等同于p wday[6], 因为string 和 array经常用,所以有简写的写法.

8.41 alias

设置别名 alias 别名 原名

class C1 # 定义C1
def hello # 定义hello
"Hello"
end
end
class C2 < C1 # 定义继承了C1 的子类C2
alias old_hello hello # 设定别名old_hello
def hello # 重定义hello
"#{old_hello}, again"
end
end
obj = C2.new
p obj.old_hello #=> "Hello"
p obj.hello #=> "Hello, again 

如果： 在子类中有，和父类相同的方法名，并没有设置别名，调用的时候，用子类的方法。

class C1

  def hello

    "Hello"

  end

end

class C2 < C1

  # alias old_hello hello

  def hello

    "sadf, again"

  end

end

obj = C2.new

p obj.hello     #=> "sadf, again"

8.42 undef 用于删除已定义的方法。

例如：在子类中删除父类定义的方法。

class C1

  def hello

    "Hello"

  end

end

class C2 < C1

  undef hello

end

obj = C2.new

p obj.hello   #=>undefined method `hello'

8.5单例类

Ruby基础教程100页

class 类名 << ~ end 这种写法定义称为单例类定义，里面的方法称为单例方法。

---

8.6模块

模块是事物的行为部分。和类有2点不同。

• 模块不能拥有实例
• 模块不能被继承

8.7使用方法2个

8.71利用Min-in扩展功能

Min-in用于解决2个问题：

• Ruby不支持父类的多重继承，因此无法对已经继承的类添加共通的功能
• 虽然两个类拥有相似的功能，但不希望把它们视作相同的class来考虑

单一继承的优点是简单，不会因为多重继承而导致类之间的关系变得复杂。但有时，我们希望更灵活的重用已有的类，或者把多个类的特性合并为更高级的类，在这种情况下，灵活运用 单一继承 和 Mix-in,既能使类结构简单易懂，又能灵活地应对各种需求。

module MyModule
# 希望提供的共通方法等
end
class MyClass1
include MyModule
# MyClass1中特有的方法等
end
class MyClass2
include MyModule
# MyClass2中特有的方法等
end

8.72提供namespace

module_function：模块函数。用 模块名.方法名调用在模块中定义的方法。

例子：

p FileTest.exist?("/usr/bin/ruby")  #=> true

p Math.sqrt(2) #=> 1.414...

p Math::PI #=> 3.1415926..  ⚠️ PI是常量，所以用::

---

8.8创建模块module

module HelloModule # module关键字
 Version = "1.0"
 def hello(name)
 puts "Hello, #{name}."
end
module_function :hello # 指定hello方法为模块函数 
end  # 如果不指定为模块函数，则不能公开给外部使用，即不能通过模块名调用
p HelloModule::Version #=> "1.0" 模块中的常量，也通过模块名访问。
HelloModule.hello("Alice") #=> Hello, Alice.