ruby基础(二)
ruby语法基础
1.方法
方法时对象定义的与该对象相关的操作。在Ruby中，对象的所有的操作都被封装成
方法。
语法糖：语法糖是一种为了照顾一般人的习惯而产生的特殊语法。
ruby中一切数据都是对象，那么加法运算应该写成3.add(2).但是一般人更
习惯于2+2.这便时一种语法糖。
方法的调用
对象.方法名(参数1,参数2,...)
带块的方法的调用
对象.方法名(参数,...) do |变量1,变量2,...|
块内容
end
eg:each方法
(0..10).each do |i|
puts i #1 .... 10
if i==5 then
break
end
end
其中i被称作块块变量，不同的方法的块变量个数不同。
运算符方法
ruby中有些方法看起来像运算符
obj + arg1
obj[arg1]=arg2
其中的obj为调用方法的对象,arg1、arg2理解为参数
方法的分类
Ruby的方法可以分为三类：
- 实例方法
- 类方法
- 函数式方法
实例方法
方法的调用者是一个对象
eg:
p "ads".eql?"sdsa"
类方法
方法的调用者时类
eg:
File.open "hello.txt"
Ruby中调用类方法还可以使用“::”代替“.”。
函数式方法
没有调用对象的方法称为函数时方法,eg:
p "hello"
puts "aaa"
Ruby帮助文档中方法的标记方法
| 方法 | 标记法 | eg |
|---|---|---|
| 实例方法 | 类名#方法名 | Array#each、Array#inject |
| 类方法 | 类名.方法名或类名::方法名 | Array.new或者Array::new |
ruby中方法的定义
语法：
def 方法名 (参数1,参数2,...)
希望执行的处理
end
eg:定义一个方法，接受用户名作为参数，打印hello,用户名
def hello(name)
puts "hello,#{name}!"
end
hello('ruby') #hello,ruby!
给方法指定默认值
def hello(name="python")
puts "hello,#{name}!"
end
hello('ruby') #hello,ruby!
#使用默认参数调用方法
hello() #hello,python!
当有个多个参数时，指定默认值的参数只能放在最后面。
def cal(a,b=1,c=2)
puts a+b+c
end
cal(1) #=>4
cal(1,2) #=>5
cal(1,2,3) #=>6
方法的返回值
使用return方法指定返回值
def volume(x,y,z)
return x*y*z;
end
省略return语句时，使用最后方法的最后一条执行语句的执行的执行结果作为返回值。
def volume(x,y,z)
x*y*z;
end
p volume(1,2,3) #=>6
使用return语句提前终止方法的执行
def volume(x,y,z)
if x=0
puts "x不能为0"
return;
end
x*y*z;
end
p volume(0,2,3) #=>nil
省略return的参数，返回值为nil.
定义带块的方法
使用yield定义代块的方法
eg:定义一个myloop方法，实现loop的效果。
def myloop
while true
yield #执行块
end
end
num=1
myloop do
puts "hello"
if(num>10)
break
end
num*=2
end
参数个数不确定的方法
使用“*变量”的形式来定义参数个数不确定的方法,以数组的形式传入参数
def foo(*args)
args
end
p foo(1,2,3) #=>[1,2,3]
“*变量名”这种形式的参数只能在参数列表中出现一次。位置可以时开始、中间
、结束
def foo(b,*args,a)
puts a+b #=>5
args
end
p foo(1,2,3,4) #=>[2,3]
关键字参数
关键字参数名和参数值成对的传入方法内部使用。从而可以忽略参数的顺序.
当不传入关键字参数，还可以使用定义函数的时的默认值作为参数。
def 方法名 (参数1：值1,参数2:值2,...)
希望执行的处理
end
eg:
def volune(x:1,y:2,z:3)
x*y*z
end
p volune(x:1,y:2,z:3) #6
p volune(z:3,y:2,x:1) #6
p volune(x:2) #12
如何不需要指定默认值，可以使用“参数名:”,这样调用的时候必须传入参数
def volune(x:,y:2,z:3)
x*y*z
end
p volune(x:1,y:2,z:3) #6
p volune(y:2,z:3) #error
使用"**变量"收集未定义的参数(以散列的形式保存),
def volune(x:1,y:2,z:3,**args)
puts args #{:a=>1, :b=>2}
x*y*z
end
p volune(x:1,y:2,z:3,a:1,b:2) #6
关键字参数和普通的参数搭配使用
def func(a,b:1,c:2)
~~
end
func(1,b:2,c:3)
用散列传递参数
可以把散列作为个关键字参数传给方法。此时散列的健只能用符号，可以省略
定义了默认值的关键字参数，但是不能传递多余的参数。
def volune(x:1,y:2,z:3)
x*y*z
end
args1={x:1,y:2,z:3}
p volune args1 #6
args2={x:1,y:2}
p volune args2 #6
args3={x:1,y:2,z:3,a:4}
p volune args3 #error
把数组分解为参数，使用*数组分解参数，但是数组参数的个数要和方法的一致
def foo(a,b,c)
a+b+c
end
p foo(1,2,3)
args1=[2,3]
p foo(1,*args1)
args2=[1,2,3]
p foo *args2
散列作为普通参数传递给方法时,如果是最后一个参数可以省略{}.
def foo(a,hash)
puts hash
end
foo(1,{a:1,b:1})
foo(1,a:1,b:1)
