《ruby基础教程》提取

写在前面：这里的提取是个人的提取（一些本人熟知的知识点不会在这里记录）。如果你也是新手级RoR选手，那这个提取能提供不少帮助。

开始：

1. 程序语言有很多，各自目的不同：有的为了运行快速，有的为了一次编写，可以在从多平台使用，有的为了让小孩也能简单编程。而ruby：为了让编程更快乐！
2. 什么是脚本语言：不需要经常翻译（编译），电脑能直接运行的语言。

第 1 部分 Ruby 初探

1. 执行单个ruby文件xxx.rb，方法：

   • ruby helloruby.rb

2. 直接打开irb:

   • $irb

3. \n是换行符。

4. \ ：转义字符。

   • 程序会对这个\后的字体做特殊的处理。

     print("hello,\"ruby\".)   #=> hello, "ruby".

     print("hello \\ ruby!")   #=> hello \ ruby!

5. ""和''，单引号和双引号的区别：

   ''里的东西，会原封不动地输出！（但，有两个符号除外：' & \）

6. puts和print方法的区别：

   • puts后面默认会带有换行符。
   • print后面默认不带换行符。

7. p方法可以做什么：（这个方法一般是程序员在用！）

   • 能从输出结果分辨字符串与数值。
   • 不会转义。

8. 编码的规则称为 encoding

9. 用这条指令开启irb可以开启简洁模式：

   $irb --simple-prompt

10. 要用sin sqrt等方法时，可以这样：（使用Math这个类方法）

=> irb
>> Math.sin(3.1415)   #=> 9.26535896604902e-05

1. 注释：

   • 单行注释：以#开头的注释。

   • 多行注释：

     =begin
     这是一个例子
     2017-7-5日
     =end

   • 还有一个作用：暂时不执行

2. while语句：

   i = 1
   while i <= 10
     puts i
     i = i + 1
   end

3. times语句：（迭代器）

   5.times do
     p "example"
   end

4. 像数组、散列这样保存对象的对象,我们称为容器(container)。

数组：

1. 什么是数组： 按顺序保存多个对象的对象。

2. 数组的大小 ：size

   a = [1,2,3]
   a.size         #=> 3

散列：

1. 散列是键值对(key-value pair)的一种数据结构。

正则表达式：

1. 什么正则表达式：

   /abc/ =~ "eacbcefg"

   • 左边：模式，用/ /包起来。
   • 右边：要匹配的字体串。

   /abc/i =~ "aAbcdefg"

   • 在/后面加一个i表示忽略大小写。

从命令中拿到参数：

1. 使用ruby内置的方法：ARGV[X] 就像数组一样用。
2. 什么叫库：大部分的编程语言都提供了把多个不同程序组合为一个程序的功能。像这样,被其他程序引用的程序,我们称为库(library)。
3. require "./grep"中的./表示：当前目录下。
4. pp方法和p的区别：
   • pp可以适当地换行调整输出结果，让显示更漂亮。

第2部分 Ruby的基础：

1. 什么是对象：在RUBY中， 靓丽数据的基本单位称为对象。

   • 数值对象
   • 字符串对象
   • 数组对象，散列对象
   • 正则表达式对象
   • 时间对象
   • 文件对象
   • 符号对象

2. 什么是类：表示对象的种类。

   

3. 什么是伪变量：代表某特定值的特殊量。

   • nil true false self

4. 常量：

   • 常量以大写英文字母开头。
   • 给常量重复定义时，ruby会做出警告。

5. 多重赋值里还可以这样用：

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

6. 比较值是否相等时，通常用== ，但如果要严谨一点的，就用eql?

7. 一些控制循环的语句：

   

8. 语法糖(syntaxsugar),是指一种为了照顾一般人习惯而产生的特殊语法

方法：

1. 什么是方法：把一系统参数传递给对象的过程。（对象会返回结果值）

2. 方法的调用：

   对象.方法名(参数1， 参数2， ...， 参数n)

3. 方法的分类：

   • 实例方法：作用在实例上的方法。

   • 类方法：作用在类上的方法。调用：

     类名.方法名

     类名::方法名

   • 函数式方法：没有作用对象的方法，也没有回传值。

4. 参数个数不确定的方法，使用带*号的参数：

   这个参数组会被封装为数组供内部使用。

   def	foo(*args)
     args
   end
   
   p foo(1,2,3)       #=> [1,2,3]
   p foo(1,2)         #=> [1,2]

   至少需要一个参数的方法：

   def	meth(arg, *args)
     [arg, args]
   end
   
   p meth(1)     #=> [1, []]
   p meth(1,2,3) #=> [1, [2,3]]

   首尾确定，中间不确定时：

   def	a(a, *b, c)
     [a,b,c]
   end
   
   p a(1,2,3,4,5)     #=> [1, [2,3,4], 5]
   p a(1,2)           #=> [1, [], 2]

5. 关键字参数：以hash形式传递参数：

   def	a(a: 1, b: 2, c: 3)
     [a,b,c]
   end

   如果想传递未定义的参数：

   def a(a:1, **args)
     [a, args]
   end
   
   p a(a: 2, k: 3, v: 4)    #=> [2, {:k => 3, :v => 4}]

类与模块：

1. 判断某个对象是否属于某个类时：instance_of?

   ary = []
   str = "Hello world."
   p ary.instance_of?(Array)      #=> true
   p str.instance_of?(String)     #=> true
   p ary.instance_of?(String)     #=> false
   p ary.instance_of?(Array)      #=> false

2. 判断某个对象是否属于某个类时：is_a?

   str = "This is a String."
   p str.is_a?(String)        #=> true
   p str.is_a?(Object)        #=> true

3. 常量：

   class HelloWorld
     Version = "1.0"
   end

   调用时：

   p HelloWorld::Version     #=> "1.0"

4. @@xxx：类变量，可以多次修改。

5. 限制访问级别：

   • public 公开，外部可以访问。一般默认方法都是public的，但initialize方法除外。
   • private内部使用。外部无法访问。
   • protected同一类中可以使用。外部无法使用。

6. 想知道一个类下有什么方法可以 被调用 ？

   类名.instance_methods

7. 为方法设置多个名字：alias

   alias 别名 原名
   alias :别名 :原名

8. 删除方法: undef 方法名 or undef :方法名

9. 什么是单例类：只为了个实体对象服务的类和方法。

模块：

1. 使用方法：

   • 模块名.方法名
   • 在类中include 模块名， 然后就可以直接使用方法啦~

2. 如果希望在外部可以用模块名.方法名，你可以这样做：

   module_function :hello

3. 如果想知道继承关系 ，可以使用：ancestors这个方法，如果想知道父类，可以使用方法：superclass。

4. 调用时的优先级：

   • 类本身 => 引入的模块（最后引入模块的优先） => 父类
   • 重复引入，第二个引入的会被忽略。

5. extend方法：直接引入作用在对象上的模块。

   module  Edition
     def  edition(n)
       "#{self}第#{n}版"
     end
   end
   
   str = "Ruby 基础教程"
   str.extend(Edition)     #=> 将模块 Mix-in 进对象
   
   p str.edtion(4)         #=> "Ruby 基础教程第 4 版"

   • 也可以用extend来代替继承：

     class MyClass
       extend ClassMethods
     end

6. .ceil：进位的意思，会把对象变成大一位的整数。

   a=3.23
   b=5.8
   a.ceil     #=> 4
   b.ceil     #=> 6

运算符：

1. 一直以为||就是or的意思（visual basic中的or），今天才发现，我错了：

   其实这两个符号不仅可以用在判断，还可以用在运算！！！

   • || ：从左到右，返回第一个不为 fasle 或 nil 的值。

   a = false || nil || 2 || 3     #=> a = 2

   • && ：返回最后一个真值（期间不能出现假值）。

   a = 1 && 2 && 3 && 4     #=> a = 4
   a = nil && false && 1    #=> a = nil

   • ||= ：当为 false 或 nil 时，才进行赋值。（这可给变量赋予默认值 ）

     var ||= 1     #=> 当var为nil或false时，var = 1

2. 范围运算符succ 可以返回一个：进位到下一位的值。

   1.succ     #=> 2
   a.succ     #=> b

3. 原来ruby本身有优先级运算符：

   1 + 2 * 3     #=> 1 + (2 * 3)        #=> 7
   2 +3 < 5 + 4  #=> (2 + 3) < (5 + 4)  #=> true

   还有一些没见过的运算符，刚开始还是老实用括号吧，哈哈！

异常处理与错误提示：

1. 错误提示格式：

   文件名：行号：in 方法名：错误信息(异常类名)
         form 文件名：行号：in 方法名

   example:

   > ruby test.rb
   test.rb:2:in `initialize':No such file or directory - /no/file(Errno::ENOENT)
           form test.rb:2:in `open'
           form test.rb:2:in `foo'
           form test.rb:9:in `main'

2. 可以用这个格式来处理异常：

   begin
     可能会发生异常的处理
   rescue => 引用异常对象的变量
     发生异常时的处理
     sleep(10)             #=> 等待10秒
     retry                 #=> 再执行一次begin下的程式
   ensure
     不管是否发生异常都希望执行的处理
   end

   这样不至于遇到错误时立即爆掉！！！

3. 还可以：简化

   begin
     表达式 1
   rescue
     表达式 2
   end
   
   #=> 等同于下面这个：
   
   表达式1 rescue 表达式2

4. 还可以：再简化

   • 如果该方法是一整个begin ~ end 包含，可以省略begin end，可以直接用rescue ensure

5. 还可以指定需要捕捉的异常：
   

6. 主动抛出异常

   raise

   

   书中没有给出例子！差评！

7. sort方法可以对数组进行排序：
   

8. <=>排序运算符，可以进行排序。

9. 数组里如果要按照长度来排序，可以：

   array = ["rails", "ruby", "fullstack"]
   array.sort{ |a, b| a.length <=> b.length }
   #=> ["ruby", "rails", "fullstack"]

   解说：先利用sort让数组遍历两两相比较，再增加代码块！人才啊！

10. 要想把一段文字，直接切成一个个单词然后放入数组？可以这样：

ary = %w(This is a example, I love rails)

#=> ["This", "is", "a", "example,", "I", "love", "rails"]

1. upto把值按从小到大的顺序取出，这个是Integer#upto方法！

2. 判断使用方法时是否有带块？

   if block_given?

3. 在块中直接调用break next等方法控制流程，会直接返回nil，如果想返回带参数，可以使用：

   • break 0
   • next 0

4. 利用Proc把代码块变成对象后，就可以直接用cell方法来直接使用啦~

   hello = Proc.new do |new|
     puts "Hello, #{name}."
   end
   
   hello.call("World")          #=> Hello, World.
   hello.call("Ruby")           #=> Hello, Ruby.

5. 传参数的时候 ，有一种参数叫做：Proc参数是这样的：&block （要放在最后一个参数）

6. 判断是否有带block的另一个方法：

   if block #直接进行判断

7. 块变量的作用域：只在block中有效。如果跟局部变量同名，要小心赋值问题！

第三部分

数值类

1. 一些方法：

   • 返回商的整数：x.quo(y)

   • 返回一个数组，[商，余数]：x.divmod(y)

   • Math模块 你想得到的数学函数都在里面

   • 返回整数部分：.floor

   • 返回100以内的随机数：Random.rand(100) （比我以前学的VB方便太多了好嘛！）

   • Integer的迭代方法：

     • upto遍历
     • downto遍历

   • 以分数的形式存在：Rational(1, 10)

   • 按step迭代的方法：

     • 2到10，每次加3：

       2.step(10,3) do |i|
         p i
       end                      #=> 2, 5, 8

     • 10到2，每次减3：

       10.step(2,-3) do |i|
         p i
       end                      #=> 10, 7, 4

数组：

1. Array.new方法：

   Array.new          #=> []
   Array.new(5)       #=> [nil,nil,nil,nil,nil]
   Array.new(5,0)     #=> [0,0,0,0,0]

2. %w和%i

   • 创建不包含空白的字符串数组时，可以使用%w:

     lang = %w(Ruyb Perl Python Scheme Pike)
     p lang    #=>["Ruby","Perl","Python","Scheme","Pike"]

   • 创建不包含空白的符号数组时，可以使用%i:

     lang = %w(Ruyb Perl Python Scheme Pike)
     p lang    #=>[:Ruby,:Perl,:Python,:Scheme,:Pike]

   其中()可替换成其他符号：<> || !! @@ AA

3. 将散列转换成数组：

   a = {a: 1, b: 2}
   a.to_a              #=>  [[:a, 1], [:b, 2]]

4. 一次性拿到多个值：

   • a[n] or a[-n] 如果是负数，就倒着开始取值。超过总数值会报错。

• a[n..m] or a[n…m]
  • a[n,len] 从某个元素起，取n个字符。

1. 一次性赋多个值：

   • a = [1,2,3,4,5,6]
     a[2,3] = [c,d,e]     #=> [1,2,c,d,e,6]
     a[2,0] = [a,b]       #=> [1,2,a,b,3,4,5,6]

   • a = [1,2,3,4,5,6]
     a[2..3] = [a,b]      #=> [1,2,a,b,5,6]

   • .values_at方法：

     a = [1,2,3,4,5,6]
     a.values_at(1,3,5)     #=> [2,4,6]

2. 把数组当集合来运算：

   • 交集：ary = ary1 & ary2

   • 并集：ary = ary1 | ary2

   • 集合的差：ary = ary1 - ary2 （在1中找2没有的元素）

     ary1 = ["a","b","c"]
     ary2 = ["b","c","d"]
     p (ary1 - ary2)        #=> ["a"]

3. 把数组当列：

   数组结构：

   • 队列：以排列的顺序，先进先出。（像排队过关一样）
   • 栈：以相反的顺序，先进后出。（像堆东西一样，最慢放入的最容易取出）

   • 追加，删除，引用：

   | 操作 | 在头部开刀 | 在尾部开刀 |
   | :–: | :—–: | :—: |
   | 追加元素 | unshift | push |
   | 删除元素 | shift | pop |
   | 引用元素 | first | last |

   例子：

   a = [1,2,3,4,5]
   a.push("E")       #=> [1,2,3,4,5,E]
   a.shift           #=> 1       
   a                 #=> [2,3,4,5,E]

一些操作方法：

1. 为数组增加元素：

   • a.unshift(item)

   • a.push(item) ~= a << item

   • a.concat(b) & a+b

     这个concat方法是破坏性方法，会改变被引用的对象。

   什么是破坏性的方法？

   ：会改变接收对象值的方法！要注意：被引用的对象也会被破坏！如：

   > a = [1,2,3,4]
   > b = a
   > b.pop     #=> 4
   > p a       #=> [1,2,3]
   >

   >

   提示：这里b引用了a，并不是复制一个a，而是让a和b同时引用一个对象！这一点要纠正认识！

2. 从数组中删除元素：

   • a.compact & a.compact! ：会把a数组中的空元素nil去掉！区别：
     • 第一种会返回一个新的数组。
     • 第二种会直接替换掉原来的数组。
   • a.delete(x) ：从数组中删除x元素。
   • a.delete_at(n) : 从数组中删除a[n]元素。
   • a.delete_if {|item| … }
a.reject {|item| … }
a.reject! {|item| … }
     : 这三个方法表示：遍历所有元素，如何右边的block块成立就删掉，其中带感叹号表示破坏性的方法！
   • a.slice!(n)
a.slice!(n..m)
a.slice!K(n,len)
     : 这三个方法表示：从数组a中删除指定的部分，并返回被删除的部分的值。slice!是具有破坏性的方法。
   • a.uniq & a.uniq! ：表示：去掉重复的元素。
   • a.shift ：删除开头的元素。返回删除的值。
   • a.pop ：删除末尾的元素。返回删除的值。

3. 替换数组元素：

   • a.collect{|item| … }
a.collect!{|item| … }
a.map{|item| … }
a.map!{|item| … }
     : 遍历数组a和各元素传给block中的item,最后付出处理后的结果。

   • a.fill(value)
a.fill(value, begin)
a.fill(value, begin, len)
a.fill(value, n..m)
     ： 把数组指定元素全部替换成value，默认为全部。

   • a.flatten & a.flatten! ：平坦化数组a，就是把里面嵌套的数组展开成一个大数组。(soga，原来是这样啊！)

     a = [1,[2,[3]],[4],5]
     a.flatten!
     p a      #=> [1,2,3,4,5]

   • a.reverse & a.reverse! :反转数组a的元素顺序。

   • a.sort
a.sort!
a.sort {|i,j| … }
a.sort {|i,j| … }
     ：排序，其中block中的i & j 表示：从数组中两个两个拿出来的数据。

   • a.sort_by{|i| … } ：根据块的运行结果时序排序。

     a = [2,4,3,5,1]
     p a.sort_by{|i| -i }     #=> [5,4,3,2,1]  (这里的block只是参与计算而已，不会破坏原来的数组。)

4. 数组与迭代器：有些使用迭代器的对象不是数组，但处理后会返回一个数组:

   a = 1..5
   b = a.collect{|i| i += 2}
   p b          #=> [3,4,5,6,7]

5. 数组的初始化问题：

   a = Array.new(3, [0,0,0])    #=> [[0,0,0],[0,0,0],[0,0,0]]
   a[0][1] = 2                  #=> [[0,2,0],[0,2,0],[0,2,0]]
   数组的初始化就是有这些问题，要注意，可以使用block带解决：
   a = Array.new(3) {[0,0,0])}    #=> [[0,0,0],[0,0,0],[0,0,0]]
   a[0][1] = 2                    #=> [[0,2,0],[0,0,0],[0,0,0]]

6. zip方法 ：引进多个数组，然后同步遍历！：

   ary1 = [1,2,3,4,5]
   ary2 = [10,20,30,40,50]
   ary3 = [100,200,300,400,500]
   
   result = []
   ary1.zip(ary2,ary3) do |a, b, c|
     result << a + b + c
   end
   p  result     #=> [111, 222, 333, 444, 555]

7. 一个过滤数组的方法：.select

   a = (1..100).to_a
   a.select{|i| i % 3 == 0}    过滤3的倍数。

   ​

13章练习题：

1. 创建一个1到100的整数按升序排列的数组：

   (1..100).to_a

2. 累加1中的数组：

   a.reduce :+

3. inject方法：

   a.inject(0){|memo, i| memo += i}
   表示：遍历数组元素赋值给i，每次结果回传给memo.实现累加的效果。

字符串String

1. 什么是内嵌表达式？

   "String#{ruby}"      #=> 这个#{}里可以执行ruby表达式的东西就是啦！

2. 创建字符串

   • 使用%Q与%q

     desc = %Q{Ruby 的字符中也可以使用'' 和 "".}
     str = %q|Ruby said, 'Hello world!'|
     
     其中%Q相当于"",%q相当于''。

   • Here Document方法

     <<"结束标识"  
     内容
     结束标识
     
     #=> (这里更多的时候要换成<<-"结束标识"，这样能让结束的标识不一定在)
     
     这个方法应该很少用。

   • sprintf方法 & printf方法

     • printf

     n = 123
     printf("%d\n", n)       #=> %d表示以整数形式输出
     printf("%4d\n", n)      #=> %4d表示以4位数格式输出
     printf("%04d\n", n)     #=> %04d表示不够4位时被零
     printf("%+d\n", n)      #=> %+d表示输出结果带 + or -

     n = "Ruby"
     printf("Hello,%s!\n",n)     #=> %s表示以字符串形式输出
     printf("Hello,%8s!\n",n)    #=> %8s表示输出炎8位字符串
     printf("Hello,%-8s!\n",n)   #=> %-8s表示输出左对齐的8位字符

     • sprintf

     和printf一样的结果。但书中没有说明具体区别，差评！

3. 获取字符串的长度

   • length or size两种方法可以，随意！
   • bytesize可以获取字节数。
   • 判断是否为0：empty?

4. 字符串的索引

   • 当成数组一样用就可以了。

5. 连接字符串

   • 用 + 号

     a = "Hello,"
     b = "World!"
     a + b           #=> "Hello,World!"

   • 用 << 号

     a = "Hello,"
     b = "World!"
     a << b          #=> "Hello,World!"   (a会被改变！)

6. 字符串的比较

   • 判断两个字符串是否相同：== !=

   • 比较大小

     "aaaaa" < "b"     #=> true    一般按照a~z的顺序排序

   • 如果查看码位 : .ord

7. 字符串的分割：split(x) ：以x为分割点进行分割！

8. 换行符的操作：

   • 删掉

     | 属性 | 删掉最的一个字符 | 删掉挑选符 |
     | :—: | :——: | :—-: |
     | 非破坏性的 | chop | chomp |
     | 破坏性的 | chop! | chomp! |

     a = "abcde"
     b = "abcde\n"
     a.chop         #=> "abcd"
     b.chop         #=> "abcde"
     b.chomp        #=> "abcde"

9. 字符串的检索与置换

   • 字符串的检索

     • index方法 从左到右检索，返回第一个字母的索引
     • rindex方法 从右到左检索，返回第一字母的索引

     a = "abbbbbb"
     a.index("bb")     #=> 1
     a.rindex("bb")    #=> 5

   • 判断是否包含某个索引值: include?

     a = "abbbbbb"
     a.include?("bb")    #=> true

10. 字符串与数组有很多共同的索引的方法：

• s[n] s[n..m] s.slice!(n)
• s.concat(s2) s+s2 s.delete(str) s.reverse

1. 其他方法：

   • strip : 删除头尾的空白字符

   • upcase ：小写转大写

   • downcase ：大写转小写

   • swapcase ：大的转小，小的转大

   • capitalize ：首字母大写，其余转小写

   • tr ：置换字符，与gsub相似，但这里可以一次转换多个字符。

     "ABCDE".tr("BD", "bd")    #=> "AbCdE"

14章节练习题提取：

1. 一个打散的字符串数组，如何快速连接成句子：

   a = ["Ruby", "is", "an", "object", "oriented", "programming", "language"]
   a.join(" ")   
   #=> "Ruby is an object oriented programming language"

2. 统计下面各个字母出现次数，并用*的个数来表示次数：

   a = "Ruby is an object oriented programming language"
   b = Hash.new(0)
   a.each_char do |c|
     b[c] += 1
   end
   b.sort.each do |k, v|
     printf("'%s': %s\n", c, "*" * v.to_i)
   end

   运行结果如图：

   

   很酷！

   • 散列直接用a[c]就可以拿到这个值，不需要进行检索
   • printf格式输出，方便！先定义好整个字符串样式，再后面定义各个引用值。

   ​

散列类

1. 新建hash:

   • a = {} a = {键: 值}
   • a = Hash.new(x) （这里可以设置一个默认值）。

2. 值的获取与设定

   • fetch & store 一个用来取一个用来存，基本和a["s"]的作法一样，但：

     用下面两个方法可以

     • 设默认值
     • 添加block

     a.store("s1", "Ruby")
     a.fetch("s2", "undef")     #=> "undef"   (找不到，所以默认值)
     a.fetch("s2"){String.new}  #=> ""    (这里还可以用block)

3. hash的迭代器。

   | 数组形式 | 迭代器形式 |
   | :—-: | :——————-: |
   | keys | each_key{|键| …… } |
   | Values | each_value{|值| …… } |
   | to_a | each{|键，值| …… } |
   | | each{|数组| …… } |

4. hash的默认值。好处：取不存在的值时，不至于发生错误。

   • 创建hash时指定默认值：

     h = Hash.new(1)
     h["a"] = 10
     h["a"]          #=> 10
     h["b"]          #=> 1

   • 创建hash时增加一个block：

     h = Hash.new do |hash,key|
       hash[key] = key.upcase
     end
     h ["a"] = "b"
     p h["a"]      #=> "b"
     p h["b"]      #=> "B"
     p h["c"]      #=> "C"  当找不到这个值时，就会自动去执行这个block

   • 用fetch方法指定默认值：

     h = Hash.new do |hash.key|
      hash[key] = key.upcase
     end
     p h.fetch("x", "(undef)")      #=> "(undef)"
     同时两个默认值的方法，fetch的优级级会高

5. 判断是否为某个Hash的键 or 值

   • 键
     • h.key?(key)
     • h.has_key?(key)
     • h.include?(key)
     • h.member?(key)
   • 值
     • h.value?(value)
     • h.has_value?(value)

6. 查看Hash的大小

   • h.size & h.length

     h = {"a" => "b", "c" => "d"}
     h.size      #=> 2

   • h.empty?

7. 删除值：

   • h.delete(key)

   • h.delete_if{|key, val| … }

   • h.reject!{|key, val| … }

     当不符合时，delete_if会返回原来的Hash,reject!会返回一个nil

8. 初始化散列

   • h.clear 清空使用过的散列

     那这个东西和h = Hash.new 有什么区别呢？在引用的时候要注意下，请看图：
     

   • 我忘记了一个超级方便的排序方法：sort
     PS:比起之学VB时的什么泡沫排序法之类的，这里简直不能太好！

正在表达式(Regexp类)

1. 正则表达式的创建：

   re = Regexp.new("Ruby")      #=> /Ruby/

   • %r(模式)
   • %r<模式>
   • %r|模式|
   • %r!模式!

2. 判断某个字符串是否匹配：正则表达式 =~ 字符串

   • 匹配：返回匹配的起始位置

   • 不匹配：返回nil

     还可以：用!~来颠倒结果。

   • 进一步应用:

     if 正则表达式 =~ 字符串
       匹配时的处理
     else
       不匹配时的处理
     end

3. 匹配行首与行尾：

   ^, $分别表示匹配行首与行尾：

   像这样的特殊字符称为：元字符。

   \A,\z分别表示匹配字符串头与尾：

   \z \Z 两者的区别

   > p "abc\n".gsub(/\z/, "!") => "abc\n!"
   > p "abc\n".gsub(/\Z/, "!") => "abc!\n!"
   >

   >

   ：大写的\Z，如果最后一个是换行符，则会同时匹配换行符与前一个字符。

4. 匹配某一个字符：

   • [AB] ：匹配A 或B
   • [ABC] ：匹配A,B,C中的一个
   • [012ABC] ：匹配0,1,2,A,B,C中的一个
   • [A-Z] ：匹配A~Z中的一个
   • [ABC][BC] ： 匹配一个两位数，第一个数为A,B,C中的一个，第二位数为B,C中的一个。
   • [A_-] ：匹配A _ - 中的一个。
   • [^ABC] ：匹配除A,B,C外的任意一位数。
   • . ：万能通配符，相当于五笔中的z

5. 反斜杠模式

   • \s ： 匹配空格，制表符， 换行符，换页符

   • \d ：匹配0到9的数字。

   • \w ：匹配英文字与数字。

   • \A ：匹配字符串的开头。

   • \z ：匹配字符串的末尾。

   • \ ：后面如果跟着：^ $ [ 等字符时，可以为这些字符转义再匹配。如：

     | 模式 | 字符串 | 匹配部分 |
     | ——- | ——— | ———— |
     | /ABC[/ | “ABC[“ | “▶ ABC[ ◀” |
     | /\^ABC/ | “ABC” | (不匹配) |
     | /\^ABC/ | “012^ABC” | “012▶^ABC ◀” |

6. 重复模式：(单个字符)

   • * ：重复0次以上。可以重复很多次也可以直接没有
   • + ：重复1次以上。至少有一次以上
   • ? ：重复0次或1次。可有可无不重复，前后的匹配还是要的！

7. 最短匹配：

   • 上面6中和重复匹配会最可能匹配更多的字符。

   • 最短匹配：加上一个? ，在第一次匹配时就停止，匹配最短的字符。

     也叫贪婪匹配与懒惰匹配。

8. 使用()来重复匹配多个字符。

   | 模式 | 字符串 | 匹配部分 |
   | ———- | ———- | ———– |
   | /^(ABC)$/ | “ABC” | “▶ABC ◀” |
   | /^(ABC)$/ | “” | “▶◀” |
   | /^(ABC)$/ | “ABCABC” | “▶ABCABC ◀” |
   | /^(ABC)$/ | “ABCABCAB” | (不匹配) |

9. 使用|来多一个匹配选项，可以多选一，也可以全中。

   | 模式 | 字符串 | 匹配部分 |
   | ————– | —– | ——– |
   | /^(ABC|DEF)$/ | “ABC” | “▶ABC ◀” |
   | /^(ABC|DEF)$/ | “DEF” | “▶DEF ◀” |
   | /^(ABC|DEF)$/ | “AB” | (不匹配) |

10. 使用quote方法来转义所有表达式所有字符：

re1 = Regexp.new("abc*def")
re2 = Regexp.new(Regexp.quote("abc*def")) p (re1 =~ "abc*def") #=> nil
p (re2 =~ "abc*def") #=> 0

1. 正则表达式的一些选项：

   形式：/ … / im

   • i ：忽略英文有大小写
   • x ：忽略正则表达式中的空白字符以及 # 后面的字符的选项。指定这个选项后，我们就可以使用 # 在正则表达式中写注释了。
   • m ：使用后可以：用.匹配换行符了。

2. 捕获：

   • 查看匹配的部分是什么字符串：以()的形式

     /(.)(.)(.)/ =~ "abc"
     first = $1
     second = $2
     third = $3
     p first      #=> "a"
     p second     #=> "b"
     p third      #=> "c"

   • 如果是有重复的匹配只会捕获最后一次的字符，如果此时我们想忽略它的捕获，可以这样：以(?:)开头就可以忽略捕获。

     /(.)(\d\d)+(.)/ =~ "123456"
     p$1 #=> "1"
     p$2 #=> "45"
     p$3 #=> "6"
     /(.)(?:\d\d)+(.)/ =~ "123456"
     p $1 #=> "1"
     p $2 #=> "6"

   • 另外一种形式：

     /C./ =~ "ABCDEF"
     p $`   #=> "AB"
     p $&   #=> "CD"
     p $'   #=> "EF"
       这三种可以捕获整个匹配过程的字符

3. sub方法与gsub方法：带block

   str = "abracatabra"
   nstr = str.sub(/.a/) do |matched|
     '<'+matched.upcase+'>'
   end
   p nstr #=> "ab<RA>catabra"
   nstr = str.gsub(/.a/) do |matched|
     '<'+matched.upcase+'>'
   end
   p nstr #=> "ab<RA><CA><TA>b<RA>"

   可以带block，然后把匹配的部分传入block，最后block处理后的结果置换匹配的字符串。

4. 直接返回的字符串数组：scan方法

   p "abracatabra".scan(/.a/) #=> ["ra", "ca", "ta", "ra"]

这是纠正一点：转义符号增加的顺序：

>  /http:\/\// =~ "http://baidu.com"   
>  $&    #=> "http://"        
>

>

纠正：\+要转义的符号 这才是正确的格式。

章节：IO类

这一章节主要对文件内容的操作。暂时不会用到，理解起来也费劲。

章节：File类与Dir类

这一章节主要是对文件夹的操作。暂时不会用到，记起来也很费劲。

章节：Encoding类

这一章节主要是编码类的讲解。暂时不会用到，要用到时再来查看。

第20章 Time类与Date类

1. 获取当前时间：

   • Time.new
   • Time.now

   时间相关的方法：

   | 方法名 | 意义 |
   | —– | ———————— |
   | year | 年 |
   | month | 月 |
   | day | 日 |
   | hour | 时 |
   | min | 分 |
   | sec | 秒 |
   | usec | 秒以下的位数(以毫秒为单位) |
   | to_i | 从 1970 年 1 月 1 日到当前时间的秒数 |
   | wday | 一周中的第几天(0 表示星期天) |
   | mday | 一个月中的第几天(与 day 方法一样) |
   | yday | 一年中的第几天(1 表示 1 月 1 日) |
   | zone | 时区(JST 等) |

2. 指定特定时间：

   t = Time.mktime(2017,7,25,16.59,40)
   #=> 2017-07-25 16:40:00 +0800

3. 时间的比较：

   • < > - 等，平常的计算比较方法都可以用啦。

4. 时间的计算：默认直接计算秒数：

   t = Time.now
   p t #=> 2013-03-30 03:11:44 +0900 t2=t+60*60*24 #=>增加24小时的秒数
   p t2 #=> 2013-03-31 03:11:44 +0900

5. 时间输出的格式：

   • t.strftime(format)
   • t.to_s

   | 格式 | 意义与范围 |
   | —- | ——————————– |
   | %A | 星期的名称(Sunday 、 Monday ……) |
   | %a | 星期的缩写名称(Sun 、 Mon ……) |
   | %B | 月份的名称(January 、 February ……) |
   | %b | 月份的缩写(Jan 、 Feb ……) |
   | %c | 日期与时间 |
   | %d | 日(01 ~ 31) |
   | %H | 24 小时制(00 ~ 23) |
   | %I | 12 小时制(01 ~ 12) |
   | %j | 一年中的天(001 ~ 366) |
   | %M | 分(00 ~ 59) |
   | %m | 表示月的数字(01 ~ 12) |
   | %p | 上午或下午(AM、PM) |
   | %S | 秒(00 ~ 60) |
   | %U | 表示周的数字。以星期天为一周的开始(00 ~ 53) |
   | %W | 表示周的数字。以星期一为一周的开始(00 ~ 53) |
   | %w | 表示星期的数字。0 表示星期天(0 ~ 6) |
   | %X | 时间 |
   | %x | 日期 |
   | %Y | 表示西历的数字 |
   | %y | 西历的后两位(00 ~ 99) |
   | %Z | 时区( JST 等) |
   | %z | 时区(+0900 等) |
   | %% | 原封不动地输出 % |

   示例：

   t = Time.now.strftime("%Y-%m-%d")
   #=> "2017-7-25"

   另外两个冷门的格式：(需要引用time类)

   • t.rfc2822
   • t.iso8601f

   require "time"
   t = Time.now
   p t.rfc2822      #=> "Tue, 25 Jul 2017 17:19:00 +0800"
   p t.iso8601      #=> "2017-07-25T17:19:42+08:00"

6. 本地时间与国际时间的切换：

   • t.utc
   • t.localtime

   t = Time.now
   p t            #=>  2017-07-25 17:21:35 +0800
   t.utc          #=>  2017-07-25 09:21:35 UTC
   t.localtime    #=>  2017-07-25 17:21:35 +0800

7. 从字符串中获取时间：

   • Time.parse(str)

     require "time"
     
     p Time.parse("2017-7-25")   #=> 2017-07-25 00:00:00 +0800

8. 日期的获取：Date类，适合只需日期不需时间的操作。

   • Date.today

   • 计算：直接加减默认计算天数

   • 同样也有各种方法：

     d = Date.today
     p d.year pd.month pd.day
     p d.wday p d.mday pd.yday
     # 年 => 2017
     #月 => 7
     #日 => 25
     # 一周中的第几天(0 表示星期天)
     # 一个月中的第几天(与 day 方法一样) => 30 #一年中的第几天(1表示 1月 1日) =>206

   • 用指定日期生成Date对象：

     d = Date.new(2017,7,25)
     puts d     #=> 2017-7-25

     还可以用-1 -2 表示末尾的第几天：

     > d = Date.new(2017,7,-1)   #=> 2017-7-31   7月月尾
     > d = Date.new(2017,7,-2)   #=> 2017-7-30   7月月尾前一天
     >

9. Date类的运算：

   • 正常的加减，默认会以天数为单位计算
   • >> << 会以月份为单位进行运算。

10. Date类的格式：

• 与前面的Time类一致。

1. 从字符串中获取Date类：
   • 和Time类一致： Date.parse(str)

Proc类

1. 什么是proc类，

   把block块变成一个对象，这个对象所属的类就是Proc类。这样可以方便我们在后面的调用。

2. 创建方法：

   • Proc.new(…)
   • proc{}

3. 调用方法：

   • 利用Proc#call方法

   • 利用Proc[]方法

     sayhello = Proc.new do |name|
       puts "Hello, #{name}."
     end
     
     sayhello.call("World")    #=> Hello, World.
     sayhello["World"]         #=> Hello, World.

4. 另一种写法：lambda

   lambda 还有另外一种写法：-> (块变量){处理}

   prc1 = Proc.new do |a, b, c|
     p [a, b, c]
   end
   prc1.call(1,2)     #=> [1, 2, nil]
   
   prc2 = lambda do |a, b, c|
     p [a, b, c]
   end
   prc2.call(1,2)     #=> 错误 (ArgumentError)

   lambda proc 两者的区别：

   • lambda的参数数量要对应否则会出错，proc的参数数量则没有那么严格。
   • lambda可以使用return将值从块中返回。

5. proc类可以接收块

6. proc的特征：

   具有闭包的特征。 闭包：将处理内容、变量等环境同时进行保存的对象，在编程语言中称为闭包(closure)。

7. proc的实例方法：

   • prc.call(args,…)
   • prc[args, … ]
   • prc.yield(args, … )
   • prc.(args, … )
   • prc === arg

   prc = Proc.new{|a, b| a + b}
   p prc.call(1, 2)    #=> 3
   p prc[3, 4]         #=> 7
   p prc.yield(5, 6)   #=> 11
   p prc.(7, 8)        #=> 15
   p prc === [9, 10]   #=> 19

   fizz = proc{|n| n % 3 == 0 }
   buzz = proc{|n| n % 5 == 0 }
   fizzbuzz = proc{|n| n % 3 == 0 && n % 5 == 0}
   (1..100).each do |i|
     case i
       when fizzbuzz then puts "Fizz Buzz"
       when fizz then puts "Fizz"
       when buzz then puts "Buzz"
     else
       puts i
     end
   end

   • prc.arity ： 返回块变量的个数。
   • prc.parameters