《Ruby基础教程》学习笔记

Ruby简介

Ruby，一种为简单快捷的面向对象编程（面向对象程序设计）而创的脚本语言，在20世纪90年代由日本人松本行弘(Yukihiro Matsumoto)开发，遵守GPL协议和Ruby License。它的灵感与特性来自于 Perl、Smalltalk、Eiffel、Ada以及 Lisp 语言。由 Ruby 语言本身还发展出了JRuby（Java平台）、IronRuby（.NET平台）等其他平台的 Ruby 语言替代品。Ruby的作者于1993年2月24日开始编写Ruby，直至1995年12月才正式公开发布于fj（新闻组）。因为Perl发音与6月诞生石pearl（珍珠）相同，因此Ruby以7月诞生石ruby（红宝石）命名。

百度百科—Ruby
Ruby官网
Ruby China

安装

安装Ruby

运行

• 通过Ruby命令

ruby HelloRuby.rb

• 通过irb

irb>
irb(main):001:0>print "Hello World!\n"
Hello World!

字符串

• 双引号——处理转义字符

print( "Hello World!\n" )   #==>Hello World！

• 单引号——不处理转义字符，但如果想输入\号，前面还得加一个\

print( 'Hello World!\n' )   #==>Hello World\n!

print( 'Hello \\ \World!' ) #==>Hello \ World!

方法

• puts方法：
  末尾一定输出换行符
  多参数时，各字符串末尾都会加上换行符

puts "Hello World!","Hello Ruby!"
#==>Hello World!
#==>Hello Ruby!

• p 方法:
  数值结果和字符串结果会以不同的形式输出
  特殊字符不转义

p "100" #==> "100"
p 100   #==> 100

编码方式

• Ruby的默认编码方式为UTF-8
• 程序中，首行代码添加注释 #encoding:XXX

平台	编码方式
Windows	#encoding:GBK
OS X	#encoding:UTF-8
Linux	#encoding:UTF-8

• 命令行中，用-E 选项

ruby -E UTF-8 XXX
irb -E UTF-8 XXX

输出变量

area = 100
puts "表面积 = #{area}"    #==>100

注释

• 单行注释

# 这是注释
puts "Hello World!"

• 多行注释

=begin
这些都是注释
这些还是注释
=end
puts "Hello World!"

数组

• Ruby中的数组大小，是可以动态调整的

a = [ "C", "C++", "Ruby" ]
p a #==>["C", "C++", "Ruby"] 
a[0] = "Shell"
p a #==>["Shell", "C++", "Ruby"]

• Ruby的数组，可以存放各种类型的对象

a = [ 1, 2, "string"]
p a[0]  #==> 1
p a[1]  #==> 2
p a[2]  #==> "string"

---

一、对象、变量、常量

• 对象

对象	类
数值	Numeric
字符串	String
数组	Array
散列	Hash
正则表达式	Regexp
文件	File
符号	Symbol

• 变量
  
  1. 局部变量
     以英文字母或_开头
     如果引用了未初始化的局部变量，程序会抛出异常
  2. 全局变量
     以$开头
     多个文件同时定义全局变量，ruby会将相同的全局变量当做一个
     不推荐使用全局变量
  3. 实例变量
     以@开头
  4. 类变量
     以@@开头
  5. 伪变量
     nil
     true
     false
     self
  6. 预定义变量
     ？？？
• 常量
  以大写字母开头
  如果对已经赋值的常量再次赋值，会出现警告
• 多重赋值

a = 1
b = 2
c = 3

可以合并为

a, b, c = 1, 2, 3

如果变量比值多，则给多余的变量赋nil

a, b, c, d = 1, 2
p [a, b, c, d]  #==> [1, 2, nil, nil]

如果值比变量多，则给忽略多余的值

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

如果在变量前加上*，则把未分配的值封装成数组赋给该变量

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

• 置换变量

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

• 获取数组元素

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

• 获取嵌套的数组元素

ary = [1, [2, 3], 4]
a, b, c = ary
p a #==>1
p b #==>[2, 3]
p c #==>4

ary = [1, [2, 3], 4]
a, (b1, b2), c = ary
p a     #==>1
p b1    #==>2
p b2    #==>3
p c     #==>4

---

二、条件判断

• Ruby的真假值

  真假值	范围
  假	nil false
  真	除nil和false以外的所有对象

• if

#  then可以省略
if condition1 then
    process1
elsie condition2 then
    process2
elsie condition3 then
    process3
else
    process4
end

• unless
  unless跟if相反，条件为假时执行

#  then可以省略
unless condition then
    process1
else
    process2
end

• case..when
  在case语句中，when判断值是否相等时，实际使用===运算符判断

#  then可以省略
case 比较对象
when 值1 then
    process1
when 值2 then
    process2
when 值3 then
    process3
else
    process4
end

• if和unless可以写在执行代码的后面

puts "a比b大"  if a > b

等价于

if a > b
    puts "a比b大"
end

• 对象的同一性
  所有的对象都有标识和值
  标识用来表示对象同一性。Ruby中所有对象都是唯一的，对象的ID可以通过object_id( id )方法取得

ary1 = []
ary2 = []
p ary1.object_id    #==>70206634588740
p ary2.object_id    #==>70201072843340

equal?方法判断两个对象是否是同一个对象

str1 = "foo"
str2 = str1
str1 = "f" + "o" + "o"
p str1.equal?(str2) #==>true
p str1.equal?(str3) #==>false

eql?方法判断对象的值是否相等

p 1.0 == 1      #==>true
p 1.0.eql?(1)   #==>false

惯例：返回真假值的方法，一般在方法名称的末尾加上?

---

三、循环

• for 语句

# do可以省略
for 变量 in 对象 do
    process
end

a = [1, 2, 3, 4]
for i in a
    puts i
end

# do可以省略
for 变量 in 开始的数值..结束的数值 do
    process
end

sum = 0
for i in 1..5
    sum += i
end

• while 语句

# do可以省略
while 条件 do
    process
end

i = 0
while i < 3
    puts i
    i += 1
end

• until 语句
  until跟while相反，条件为假时才执行

# do可以省略
until 条件 do
    process
end

i = 0
until i > 3
    puts i
    i += 1
end

• times 方法

循环次数.times do
    process
end

循环次数.times {
    process
}

获取循环次数

5.times do | i |
    puts i
end

• each 方法

对象.each do |变量|
    process
end

对象.each { |变量|
    process
end

• loop 方法

loop do
    process
end

• 循环控制

命令	用途
break	终止程序，跳出循环
next	跳到下一次循环
redo	在相同条件下重复刚才的处理(一般不用)

- 各种循环的用途

从理论上，任何种类的循环都可以用while实现
在ruby内部，for是用each方法实现的

循环	用途
while 语句	希望自由指定循环条件时使用
until 语句	使用while难懂时使用
each 方法	从对象取出元素时使用
for 语句	从对象取出元素时使用(each的语法糖)
times 方法	确定循环次数时使用
loop 方法	不限制循环次数时使用

- do ~ end 与 { ~ }

程序是跨行写的时候用do ~ end
程序写在1行的时候用{ ~ }

---

四、方法

• 带块的方法调用

对象.方法名(参数)  do | 变量 |
    块内容
end

对象.方法名(参数)  { | 变量 |
    块内容
}

• 运算符形式的方法调用

  obj + arg1
  !obj
  obj[arg1]
  obj[arg1] = arg2

• 方法的分类
  实例方法

p [1,2,3,4].index(2)  ==>  1

类方法

Array.new
File.open(“XXX”)
# 可以使用::代替.
File::open(“XXX”)

函数式方法

puts a
sleep(10)

• 方法的定义

def 方法名 ( 参数1, 参数2, … )
    process
end

• 参数的默认值

  有多个参数时，从参数列表的右边开始依次指定默认值
  只省略左边的参数或中间的参数是不行的

def func( a, b = 1, c = 2 )
    process
end

• 方法的返回值

  在方法的实现中，return value
  如果没有return，返回最后一个表达式的值(不一定是最后一行，也可能是最后一个if)
  如果只有return没有value，则返回nil

• 定义带块的方法

  yield

def  myloop
    while true
        yield
    end
end

num = 1
myloop do
    puts “num is #{num}”
    break if num > 100
    num *= 2
end

• 不定参的方法

def 方法名 ( *args )
    process
end
#Ruby把所有参数封装成数组
# *变量名 只能出现一次
def func(a, *b, c)
    [a, b, c]
end

p func(1, 2, 3, 4, 5)   #==> [1, [2, 3, 4], 5]
p func(1, 2)            #==> [1, [], 2]

• 关键字参数

def 方法名 ( arg1:value1, arg2:value2, … )
    process
end

# **args 会接收未定义的参数，ruby会将所有未定义的参数保存在一个散列对象中
def func(x:0, y:1, z:2, **args)
    [x, y, z, args]
end

p func(z:4, y:3, x:2)       #==> [2, 3, 4, {}]
p func(z:4, y:3, x:2, w:8)  #==> [2, 3, 4, {:w=>8}]

• 关键字参数与普通参数搭配

def 方法名 ( x, arg1:value1, arg2:value2, … )
    process
end

• 可以用散列传递参数
• 把数组分解为参数

def foo ( a, b, c )
    puts a, b, c
end

args1 = [2, 3]
# *数组 表示传给方法的不是数组本身，而是数组元素
foo( 1, *args1 )

• 把散列作为参数传递

# 用{ ~ }这样的形式表示散列的字面量
def foo ( arg )
    arg
end

p foo( {“a” = 1, “b” = 2} )  #==> {“a” = 1, “b” = 2}

• 书写简明易懂的程序
  
  1. 换行和“ ; ”，都表示语句的结束
  2. 缩进，ruby默认的缩进是两个空格
  3. 空白，保持代码整齐