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的方法可以分为三类：

1. 实例方法
2. 类方法
3. 函数式方法

实例方法
方法的调用者是一个对象
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)