《ruby基础教程》提取

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

开始:

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

第 1 部分 Ruby 初探

  1. 执行单个ruby文件xxx.rb,方法:

    • 1
      ruby helloruby.rb
  2. 直接打开irb:

    • 1
      $irb
  3. \n是换行符。

  4. \ :转义字符。

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

      1
      print("hello,\"ruby\".) #=> hello, "ruby".
      1
      print("hello \\ ruby!") #=> hello \ ruby!
  5. ""'',单引号和双引号的区别:

    ''里的东西,会原封不动地输出!(但,有两个符号除外:' & \

  6. putsprint方法的区别:

    • puts后面默认会带有换行符。
    • print后面默认不带换行符。
  7. p方法可以做什么:(这个方法一般是程序员在用!)

    • 能从输出结果分辨字符串与数值。
    • 不会转义。
  8. 编码的规则称为 encoding

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

    1
    $irb --simple-prompt
  10. 要用sin sqrt等方法时,可以这样:(使用Math这个类方法)

1
2
=> irb
>> Math.sin(3.1415) #=> 9.26535896604902e-05
  1. 注释:

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

    • 多行注释:

      1
      2
      3
      4
      =begin
      这是一个例子
      2017-7-5日
      =end
    • 还有一个作用:暂时不执行

  2. while语句:

    1
    2
    3
    4
    5
    i = 1
    while i <= 10
    puts i
    i = i + 1
    end
  3. times语句:(迭代器)

    1
    2
    3
    5.times do
    p "example"
    end
  4. 像数组、散列这样保存对象的对象,我们称为容器(container)。

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

  2. 数组的大小 :size

    1
    2
    a = [1,2,3]
    a.size #=> 3
散列:
  1. 散列是键值对(key-value pair)的一种数据结构。
正则表达式:
  1. 什么正则表达式:

    1
    /abc/ =~ "eacbcefg"
    • 左边:模式,用/ /包起来。
    • 右边:要匹配的字体串。
    1
    /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. 多重赋值里还可以这样用:

    1
    2
    ary = [1,2]
    a,b = ary #=> a=1, b=2
  6. 比较值是否相等时,通常用== ,但如果要严谨一点的,就用eql?

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

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

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

  2. 方法的调用:

    1
    对象.方法名(参数1, 参数2, ..., 参数n)
  3. 方法的分类:

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

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

      1
      类名.方法名
      1
      类名::方法名
    • 函数式方法:没有作用对象的方法,也没有回传值。

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

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

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

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

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

    首尾确定,中间不确定时:

    1
    2
    3
    4
    5
    6
    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形式传递参数:

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

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

    1
    2
    3
    4
    5
    def a(a:1, **args)
    [a, args]
    end
    p a(a: 2, k: 3, v: 4) #=> [2, {:k => 3, :v => 4}]
类与模块:
  1. 判断某个对象是否属于某个类时:instance_of?

    1
    2
    3
    4
    5
    6
    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?

    1
    2
    3
    str = "This is a String."
    p str.is_a?(String) #=> true
    p str.is_a?(Object) #=> true
  3. 常量:

    1
    2
    3
    class HelloWorld
    Version = "1.0"
    end

    调用时:

    1
    p HelloWorld::Version #=> "1.0"
  4. @@xxx:类变量,可以多次修改。

  5. 限制访问级别:

    • public 公开,外部可以访问。一般默认方法都是public的,但initialize方法除外。
    • private内部使用。外部无法访问。
    • protected同一类中可以使用。外部无法使用。
  6. 想知道一个类下有什么方法可以 被调用 ?

    1
    类名.instance_methods
  7. 为方法设置多个名字:alias

    1
    2
    alias 别名 原名
    alias :别名 :原名
  8. 删除方法: undef 方法名 or undef :方法名

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

模块:
  1. 使用方法:

    • 模块名.方法名
    • 在类中include 模块名, 然后就可以直接使用方法啦~
  2. 如果希望在外部可以用模块名.方法名,你可以这样做:

    1
    module_function :hello
  3. 如果想知道继承关系 ,可以使用:ancestors这个方法,如果想知道父类,可以使用方法:superclass

  4. 调用时的优先级:

    • 类本身 => 引入的模块(最后引入模块的优先) => 父类
    • 重复引入,第二个引入的会被忽略。
  5. extend方法:直接引入作用在对象上的模块。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    module Edition
    def edition(n)
    "#{self}第#{n}版"
    end
    end
    str = "Ruby 基础教程"
    str.extend(Edition) #=> 将模块 Mix-in 进对象
    p str.edtion(4) #=> "Ruby 基础教程第 4 版"
    • 也可以用extend来代替继承:

      1
      2
      3
      class MyClass
      extend ClassMethods
      end
  6. .ceil:进位的意思,会把对象变成大一位的整数。

    1
    2
    3
    4
    a=3.23
    b=5.8
    a.ceil #=> 4
    b.ceil #=> 6
运算符:
  1. 一直以为||就是or的意思(visual basic中的or),今天才发现,我错了:

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

    • || :从左到右,返回第一个不为 faslenil 的值。
    1
    a = false || nil || 2 || 3 #=> a = 2
    • && :返回最后一个真值(期间不能出现假值)。
    1
    2
    a = 1 && 2 && 3 && 4 #=> a = 4
    a = nil && false && 1 #=> a = nil
    • ||= :当为 falsenil 时,才进行赋值。(这可给变量赋予默认值 )

      1
      var ||= 1 #=> 当var为nil或false时,var = 1
  2. 范围运算符succ 可以返回一个:进位到下一位的值。

    1
    2
    1.succ #=> 2
    a.succ #=> b
  3. 原来ruby本身有优先级运算符:

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

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

异常处理与错误提示:

  1. 错误提示格式:

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

    example:

    1
    2
    3
    4
    5
    > 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. 可以用这个格式来处理异常:

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

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

  3. 还可以:简化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    begin
    表达式 1
    rescue
    表达式 2
    end
    #=> 等同于下面这个:
    表达式1 rescue 表达式2
  4. 还可以:再简化

    • 如果该方法是一整个begin ~ end 包含,可以省略begin end,可以直接用rescue ensure
  5. 还可以指定需要捕捉的异常:

  6. 主动抛出异常

    raise

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

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

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

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

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

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

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

1
2
3
ary = %w(This is a example, I love rails)
#=> ["This", "is", "a", "example,", "I", "love", "rails"]
  1. upto把值按从小到大的顺序取出,这个是Integer#upto方法!

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

    1
    if block_given?
  3. 在块中直接调用break next等方法控制流程,会直接返回nil,如果想返回带参数,可以使用:

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

    1
    2
    3
    4
    5
    6
    hello = Proc.new do |new|
    puts "Hello, #{name}."
    end
    hello.call("World") #=> Hello, World.
    hello.call("Ruby") #=> Hello, Ruby.
  5. 传参数的时候 ,有一种参数叫做:Proc参数是这样的:&block (要放在最后一个参数)

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

    1
    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:

        1
        2
        3
        2.step(10,3) do |i|
        p i
        end #=> 2, 5, 8
      • 10到2,每次减3:

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

数组:

  1. Array.new方法

    1
    2
    3
    Array.new #=> []
    Array.new(5) #=> [nil,nil,nil,nil,nil]
    Array.new(5,0) #=> [0,0,0,0,0]
  2. %w%i

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

      1
      2
      lang = %w(Ruyb Perl Python Scheme Pike)
      p lang #=>["Ruby","Perl","Python","Scheme","Pike"]
    • 创建不包含空白的符号数组时,可以使用%i:

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

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

  3. 将散列转换成数组:

    1
    2
    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. 一次性赋多个值:

    • 1
      2
      3
      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]
    • 1
      2
      a = [1,2,3,4,5,6]
      a[2..3] = [a,b] #=> [1,2,a,b,5,6]
    • .values_at方法

      1
      2
      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没有的元素)

      1
      2
      3
      ary1 = ["a","b","c"]
      ary2 = ["b","c","d"]
      p (ary1 - ary2) #=> ["a"]
  3. 把数组当

    数组结构:

    • 队列:以排列的顺序,先进先出。(像排队过关一样)
    • 栈:以相反的顺序,先进后出。(像堆东西一样,最慢放入的最容易取出)
    • 追加,删除,引用:

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

    例子:

    1
    2
    3
    4
    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方法是破坏性方法,会改变被引用的对象。

    什么是破坏性的方法

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

    1
    2
    3
    4
    5
    > 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,原来是这样啊!)

      1
      2
      3
      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| … } :根据块的运行结果时序排序。

      1
      2
      a = [2,4,3,5,1]
      p a.sort_by{|i| -i } #=> [5,4,3,2,1] (这里的block只是参与计算而已,不会破坏原来的数组。)
  4. 数组与迭代器:有些使用迭代器的对象不是数组,但处理后会返回一个数组:

    1
    2
    3
    a = 1..5
    b = a.collect{|i| i += 2}
    p b #=> [3,4,5,6,7]
  5. 数组的初始化问题:

    1
    2
    3
    4
    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方法 :引进多个数组,然后同步遍历!:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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

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

13章练习题:
  1. 创建一个1到100的整数按升序排列的数组:

    1
    (1..100).to_a
  2. 累加1中的数组:

    1
    a.reduce :+
  3. inject方法

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

字符串String

  1. 什么是内嵌表达式?

    1
    "String#{ruby}" #=> 这个#{}里可以执行ruby表达式的东西就是啦!
  2. 创建字符串

    • 使用%Q与%q

      1
      2
      3
      4
      desc = %Q{Ruby 的字符中也可以使用'' 和 "".}
      str = %q|Ruby said, 'Hello world!'|
      其中%Q相当于"",%q相当于''。
    • Here Document方法

      1
      2
      3
      4
      5
      6
      7
      <<"结束标识"
      内容
      结束标识
      #=> (这里更多的时候要换成<<-"结束标识",这样能让结束的标识不一定在)
      这个方法应该很少用。
    • sprintf方法 & printf方法

      • printf
      1
      2
      3
      4
      5
      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 -
      1
      2
      3
      4
      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. 连接字符串

    • +

      1
      2
      3
      a = "Hello,"
      b = "World!"
      a + b #=> "Hello,World!"
    • <<

      1
      2
      3
      a = "Hello,"
      b = "World!"
      a << b #=> "Hello,World!" (a会被改变!)
  6. 字符串的比较

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

    • 比较大小

      1
      "aaaaa" < "b" #=> true 一般按照a~z的顺序排序
    • 如果查看码位 : .ord

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

  8. 换行符的操作:

    • 删掉

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

      1
      2
      3
      4
      5
      a = "abcde"
      b = "abcde\n"
      a.chop #=> "abcd"
      b.chop #=> "abcde"
      b.chomp #=> "abcde"
  9. 字符串的检索与置换

    • 字符串的检索

      • index方法 从左到右检索,返回第一个字母的索引
      • rindex方法 从右到左检索,返回第一字母的索引
      1
      2
      3
      a = "abbbbbb"
      a.index("bb") #=> 1
      a.rindex("bb") #=> 5
    • 判断是否包含某个索引值: include?

      1
      2
      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相似,但这里可以一次转换多个字符。

      1
      "ABCDE".tr("BD", "bd") #=> "AbCdE"
14章节练习题提取:
  1. 一个打散的字符串数组,如何快速连接成句子:

    1
    2
    3
    a = ["Ruby", "is", "an", "object", "oriented", "programming", "language"]
    a.join(" ")
    #=> "Ruby is an object oriented programming language"
  2. 统计下面各个字母出现次数,并用*的个数来表示次数:

    1
    2
    3
    4
    5
    6
    7
    8
    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
      1
      2
      3
      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时指定默认值:

      1
      2
      3
      4
      h = Hash.new(1)
      h["a"] = 10
      h["a"] #=> 10
      h["b"] #=> 1
    • 创建hash时增加一个block:

      1
      2
      3
      4
      5
      6
      7
      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方法指定默认值:

      1
      2
      3
      4
      5
      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

      1
      2
      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. 正则表达式的创建:

    1
    re = Regexp.new("Ruby") #=> /Ruby/
    • %r(模式)
    • %r<模式>
    • %r|模式|
    • %r!模式!
  2. 判断某个字符串是否匹配:正则表达式 =~ 字符串

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

    • 不匹配:返回nil

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

    • 进一步应用:

      1
      2
      3
      4
      5
      if 正则表达式 =~ 字符串
      匹配时的处理
      else
      不匹配时的处理
      end
  3. 匹配行首与行尾:

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

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

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

    \z \Z 两者的区别

    1
    2
    3
    > 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方法来转义所有表达式所有字符:

1
2
3
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. 捕获:

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

      1
      2
      3
      4
      5
      6
      7
      /(.)(.)(.)/ =~ "abc"
      first = $1
      second = $2
      third = $3
      p first #=> "a"
      p second #=> "b"
      p third #=> "c"
    • 如果是有重复的匹配只会捕获最后一次的字符,如果此时我们想忽略它的捕获,可以这样:以(?:)开头就可以忽略捕获。

      1
      2
      3
      4
      5
      6
      7
      /(.)(\d\d)+(.)/ =~ "123456"
      p$1 #=> "1"
      p$2 #=> "45"
      p$3 #=> "6"
      /(.)(?:\d\d)+(.)/ =~ "123456"
      p $1 #=> "1"
      p $2 #=> "6"
    • 另外一种形式:

      1
      2
      3
      4
      5
      /C./ =~ "ABCDEF"
      p $` #=> "AB"
      p $& #=> "CD"
      p $' #=> "EF"
      这三种可以捕获整个匹配过程的字符
  3. sub方法与gsub方法:带block

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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方法

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

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

1
2
3
> /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. 指定特定时间:

    1
    2
    t = Time.mktime(2017,7,25,16.59,40)
    #=> 2017-07-25 16:40:00 +0800
  3. 时间的比较:

    • < > - 等,平常的计算比较方法都可以用啦。
  4. 时间的计算:默认直接计算秒数:

    1
    2
    3
    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 等) |
    | %% | 原封不动地输出 % |

    示例:

    1
    2
    t = Time.now.strftime("%Y-%m-%d")
    #=> "2017-7-25"
    另外两个冷门的格式:(需要引用time类)
    • t.rfc2822
    • t.iso8601f
    1
    2
    3
    4
    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
    1
    2
    3
    4
    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)

      1
      2
      3
      require "time"
      p Time.parse("2017-7-25") #=> 2017-07-25 00:00:00 +0800
  8. 日期的获取:Date类,适合只需日期不需时间的操作。

    • Date.today

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

    • 同样也有各种方法:

      1
      2
      3
      4
      5
      6
      7
      8
      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对象:

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

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

      1
      2
      3
      > 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[]方法

      1
      2
      3
      4
      5
      6
      sayhello = Proc.new do |name|
      puts "Hello, #{name}."
      end
      sayhello.call("World") #=> Hello, World.
      sayhello["World"] #=> Hello, World.
  4. 另一种写法:lambda

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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
    1
    2
    3
    4
    5
    6
    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
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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