《Ruby基础教程》提取-第二部分

第2部分 Ruby的基础：

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

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

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

   image

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

   • nil true false self

4. 常量：

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

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

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

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

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

   image

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），今天才发现，我错了：

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

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

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

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

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

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

     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. 还可以指定需要捕捉的异常：

   
   image

6. <u>主动抛出异常</u>

   <u>raise</u>

   image

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

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

   image

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中有效。如果跟局部变量同名，要小心赋值问题！