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)

巴特西

ruby基础(二)

ruby语法基础

1.方法

最新文章

热门文章