创建方法

中关村村草

转：Lipton  

创建方法

如果说对象是名词的话，那么方法就是动词，代表了一个对象要执行什么动作。
方法是和对象相对应的，“.”前面的对象就是方法所属的对象。
但是有时候可以省略对象名，比如puts，gets是直接使用的，前面没有对象名。
在对象内部调用对象自己的方法时，是可以省略对象名的。
但是有时候我们不知道在哪个对象里（当前对象），可以使用self方法查看。
注意：ruby会自动生成一个main对象。
更多self细节，查看这儿。
下面我们学着自己写一个方法。方法体需要包括在def和end中间，参数列表需要括在括号里。
puts self
注意：方法中并没有定义返回类型，一个方法的返回值就是该方法的最后一行。
多个方法定义之间最好用空行隔开，方便区分。
ruby规范说明，方法的参数需要用括号括起来。
但是看以前的例子，比如puts，p，gets等方法的参数都没有括起来。以后会讲到参数不需要括起来的情况。

1. def hello
   
2. puts 'Hello'
   
3. end
   
4. #use the method
   
5. hello
   
6. # Method with an argument - 1
   
7. def hello1(name)
   
8. puts 'Hello ' + name
   
9. return 'success'
   
10. end
    
11. puts(hello1('satish'))
    
12. # Method with an argument - 2
    
13. def hello2 name2
    
14. puts 'Hello ' + name2
    
15. return 'success'
    
16. end
    
17. puts(hello2 'talim')

复制代码

这段代码在我机器上的运行结果如下：
可以看到，参数没有括在括号中，一样输出了结果，但是给出了警告。
定义方法时，可以给参数定义默认值。如果调用方法时，没有传参数值过来，方法会使用这些默认值。看下面的例子：
在我的机器上，输出结果如下：
在上面的例子中，有‘#{...}’这样的代码，它的作用是，计算{}中表达式的结果，并把结果转换成字符串。运行这样的代码后，可以得到结果字符串，并不会看到’#{}‘在输出结果中。
再比如下面的例子：
输出结果为：
在ruby中可以给一个方法指定别名。别名对应的是原方法的一个拷贝，如果原方法改变了，别名不会跟着变化，看例子：

1. Hello
   
2. test2.rb:32 warning: parenthesize argument(s) for future version
   
3. Hello satish
   
4. success
   
5. Hello talim
   
6. success
   
7. # interpolation refers to the process of inserting the result of an
   
8. # expression into a string literal
   
9. # the interpolation operator #{...} gets calculated separately
   
10. def mtd(arg1="Dibya", arg2="Shashank", arg3="Shashank")
    
11. "#{arg1}, #{arg2}, #{arg3}."
    
12. end
    
13. puts mtd
    
14. puts mtd("ruby")
    
15. Dibya, Shashank, Shashank
    
16. ruby, Shashank, Shashank
    
17. puts "100 * 5 = #{100 * 5}"
    
18. 100 * 5 = 500
    
19. def oldmtd
    
20. "old method"
    
21. end
    
22. alias newmtd oldmtd
    
23. def oldmtd
    
24. "old improved method"
    
25. end
    
26. puts oldmtd
    
27. puts newmtd

复制代码

运行结果为(别名并没有变化)：
ruby支持可变数量参数的用法吗？答案是肯定的。
'*'会接受传过来的所有参数，并且把他们放到数组my_string中。
do end是程序块。
通过使用‘*’，即可以传递多个参数，也可以一个参数也不传。
上面例子的结果如下：
如果你想包含多个可选参数的话，一定要把可选参数放在最后，比如
那么一共可以给方法传递多少参数？数目是没有限制的，这个问题，可以参考这篇文档。
参数的排列顺序是从左至右排列的，比如：
那么传过去的参数是值传递还是引用传递？请参考这儿。再看下面的例子：
结果是: "hello"。可以看出是按引用传递，但是这个问题一直在讨论中。

1. old improved method
   
2. old method
   
3. # variable number of parameters example
   
4. # The asterisk is actually taking all arguments you send to the method
   
5. # and assigning them to an array named my_string as shown below
   
6. # The do end is a Ruby block which we talk in length later
   
7. def foo(*my_string)
   
8. my_string.each do |words|
   
9. puts words
   
10. end
    
11. end
    
12. foo('hello','world')
    
13. foo()
    
14. hello
    
15. world
    
16. def opt_args(a,b,*x) # right
    
17. def opt_args(a,*x,b) # wrong
    
18. def mtd(a=99, b=a+1)
    
19. [a,b]
    
20. end
    
21. puts mtd
    
22. def downer(string)
    
23. string.downcase!
    
24. end
    
25. a = "HELLO" # -> "HELLO"
    
26. downer(a) # -> "hello"
    
27. puts a

复制代码

重磅方法：（bang or ! methods）
Ruby中，方法名后跟一个‘!’的方法叫重磅方法。带上‘!’标志，就说明这个方法是比较危险的，当然这个危险是相对于同名不带‘!’的方法而言的。
你会经常发现这样成对的方法，有相同的方法名，但是一个带‘!’标志，一个不带。执行不带‘!’的方法后，会返回一个全新的对象。但是如果带‘!’的方法，返回的是原来的对象。这就是他们的区别。
看几个这样的例子，数组的sort/sort!方法，字符串的upcase/upcase!，chomp/chomp!方法，字符串和数组的reverse/reverse!方法。

2gua

不错啊，村艹。