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

第2部分 Ruby的基础:
  1. 什么是对象:在RUBY中, 靓丽数据的基本单位称为对象。
  • 数值对象
  • 字符串对象
  • 数组对象,散列对象
  • 正则表达式对象
  • 时间对象
  • 文件对象
  • 符号对象
  1. 什么是类:表示对象的种类。

  1. 什么是伪变量:代表某特定值的特殊量。
  • nil true false self
  1. 常量:
  • 常量以大写英文字母开头。
  • 给常量重复定义时,ruby会做出警告。
  1. 多重赋值里还可以这样用:


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

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

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

  1. 语法糖(syntaxsugar),是指一种为了照顾一般人习惯而产生的特殊语法
方法:
  1. 什么是方法:把一系统参数传递给对象的过程。(对象会返回结果值)

  2. 方法的调用:


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

  1. 方法的分类:
  • 实例方法:作用在实例上的方法。

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


    类名.方法名


    类名::方法名

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

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

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

```
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]
```

  1. 关键字参数:以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

  1. 判断某个对象是否属于某个类时:is_a?


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

  1. 常量:


class HelloWorld
Version = "1.0"
end

调用时:


p HelloWorld::Version #=> "1.0"

  1. @@xxx:类变量,可以多次修改。

  2. 限制访问级别:

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


类名.instance_methods

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


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

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

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

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


module_function :hello

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

  2. 调用时的优先级:

  • 类本身 => 引入的模块(最后引入模块的优先) => 父类
  • 重复引入,第二个引入的会被忽略。
  1. 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

  1. .ceil:进位的意思,会把对象变成大一位的整数。


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

运算符:
  1. 一直以为||就是or的意思(visual basic中的or),今天才发现,我错了:

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

  • || :从左到右,返回第一个不为 faslenil 的值。


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

  • && :返回最后一个真值(期间不能出现假值)。


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

  • ||= :当为 falsenil 时,才进行赋值。(这可给变量赋予默认值 )


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

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


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

  1. 原来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'
```

  1. 可以用这个格式来处理异常:


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

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

  1. 还可以:简化

```
begin
表达式 1
rescue
表达式 2
end

#=> 等同于下面这个:

表达式1 rescue 表达式2
```

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

  2. 主动抛出异常

raise

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

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

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

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


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

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

  1. 要想把一段文字,直接切成一个个单词然后放入数组?可以这样:
 ary = %w(This is a example, I love rails)

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

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


if block_given?

  1. 在块中直接调用break next等方法控制流程,会直接返回nil,如果想返回带参数,可以使用:
  • break 0
  • next 0
  1. 利用Proc把代码块变成对象后,就可以直接用cell方法来直接使用啦~

```
hello = Proc.new do |new|
puts "Hello, #{name}."
end

hello.call("World") #=> Hello, World.
hello.call("Ruby") #=> Hello, Ruby.
```

  1. 传参数的时候 ,有一种参数叫做:Proc参数是这样的:&block (要放在最后一个参数)

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


if block #直接进行判断

  1. 块变量的作用域:只在block中有效。如果跟局部变量同名,要小心赋值问题!
comments powered by Disqus