创建方法
如果说对象是名词的话，那么方法就是动词，代表了一个对象要执行什么动作。
方法是和对象相对应的，“.”前面的对象就是方法所属的对象。
但是有时候可以省略对象名，比如puts，gets是直接使用的，前面没有对象名。
在对象内部调用对象自己的方法时，是可以省略对象名的。
但是有时候我们不知道在哪个对象里（当前对象），可以使用self方法查看。
注意：ruby会自动生成一个main对象。
更多self细节，查看这儿。
下面我们学着自己写一个方法。方法体需要包括在def和end中间，参数列表需要括在括号里。
puts self
注意：方法中并没有定义返回类型，一个方法的返回值就是该方法的最后一行。
多个方法定义之间最好用空行隔开，方便区分。
ruby规范说明，方法的参数需要用括号括起来。
但是看以前的例子，比如puts，p，gets等方法的参数都没有括起来。以后会讲到参数不需要括起来的情况。
def hello
puts 'Hello'
end
#use the method
hello
# Method with an argument - 1
def hello1(name)
puts 'Hello ' + name
return 'success'
end
puts(hello1('satish'))
# Method with an argument - 2
def hello2 name2
puts 'Hello ' + name2
return 'success'
end
puts(hello2 'talim')
这段代码在我机器上的运行结果如下：
可以看到，参数没有括在括号中，一样输出了结果，但是给出了警告。
定义方法时，可以给参数定义默认值。如果调用方法时，没有传参数值过来，方法会使用这些默认值。看下面的例子：
在我的机器上，输出结果如下：
在上面的例子中，有‘#{...}’这样的代码，它的作用是，计算{}中表达式的结果，并把结果转换成字符串。运行这样的代码后，可以得到结果字符串，并不会看到’#{}‘在输出结果中。
再比如下面的例子：
输出结果为：
在ruby中可以给一个方法指定别名。别名对应的是原方法的一个拷贝，如果原方法改变了，别名不会跟着变化，看例子：
Hello
test2.rb:32 warning: parenthesize argument(s) for future version
Hello satish
success
Hello talim
success
# interpolation refers to the process of inserting the result of an
# expression into a string literal
# the interpolation operator #{...} gets calculated separately
def mtd(arg1="Dibya", arg2="Shashank", arg3="Shashank")
"#{arg1}, #{arg2}, #{arg3}."
end
puts mtd
puts mtd("ruby")
Dibya, Shashank, Shashank
ruby, Shashank, Shashank
puts "100 * 5 = #{100 * 5}"
100 * 5 = 500
def oldmtd
"old method"
end
alias newmtd oldmtd
def oldmtd
"old improved method"
end
puts oldmtd
puts newmtd
运行结果为(别名并没有变化)：
ruby支持可变数量参数的用法吗？答案是肯定的。
'*'会接受传过来的所有参数，并且把他们放到数组my_string中。
do end是程序块。
通过使用‘*’，即可以传递多个参数，也可以一个参数也不传。
上面例子的结果如下：
如果你想包含多个可选参数的话，一定要把可选参数放在最后，比如
那么一共可以给方法传递多少参数？数目是没有限制的，这个问题，可以参考这篇文档。
参数的排列顺序是从左至右排列的，比如：
那么传过去的参数是值传递还是引用传递？请参考这儿。再看下面的例子：
结果是: "hello"。可以看出是按引用传递，但是这个问题一直在讨论中。
old improved method
old method
# variable number of parameters example
# The asterisk is actually taking all arguments you send to the method
# and assigning them to an array named my_string as shown below
# The do end is a Ruby block which we talk in length later
def foo(*my_string)
my_string.each do |words|
puts words
end
end
foo('hello','world')
foo()
hello
world
def opt_args(a,b,*x) # right
def opt_args(a,*x,b) # wrong
def mtd(a=99, b=a+1)
[a,b]
end
puts mtd
def downer(string)
string.downcase!
end
a = "HELLO" # -> "HELLO"
downer(a) # -> "hello"
puts a
重磅方法：（bang or ! methods）
Ruby中，方法名后跟一个‘!’的方法叫重磅方法。带上‘!’标志，就说明这个方法是比较危险的，当然这个危险是相对于同名不带‘!’的方法而言的。
你会经常发现这样成对的方法，有相同的方法名，但是一个带‘!’标志，一个不带。执行不带‘!’的方法后，会返回一个全新的对象。但是如果带‘!’的方法，返回的是原来的对象。这就是他们的区别。
看几个这样的例子，数组的sort/sort!方法，字符串的upcase/upcase!，chomp/chomp!方法，字符串和数组的reverse/reverse!方法。
方法是和对象相对应的，“.”前面的对象就是方法所属的对象。
但是有时候可以省略对象名，比如puts，gets是直接使用的，前面没有对象名。
在对象内部调用对象自己的方法时，是可以省略对象名的。
但是有时候我们不知道在哪个对象里（当前对象），可以使用self方法查看。
注意：ruby会自动生成一个main对象。
更多self细节，查看这儿。
下面我们学着自己写一个方法。方法体需要包括在def和end中间，参数列表需要括在括号里。
puts self
注意：方法中并没有定义返回类型，一个方法的返回值就是该方法的最后一行。
多个方法定义之间最好用空行隔开，方便区分。
ruby规范说明，方法的参数需要用括号括起来。
但是看以前的例子，比如puts，p，gets等方法的参数都没有括起来。以后会讲到参数不需要括起来的情况。
def hello
puts 'Hello'
end
#use the method
hello
# Method with an argument - 1
def hello1(name)
puts 'Hello ' + name
return 'success'
end
puts(hello1('satish'))
# Method with an argument - 2
def hello2 name2
puts 'Hello ' + name2
return 'success'
end
puts(hello2 'talim')
这段代码在我机器上的运行结果如下：
可以看到，参数没有括在括号中，一样输出了结果，但是给出了警告。
定义方法时，可以给参数定义默认值。如果调用方法时，没有传参数值过来，方法会使用这些默认值。看下面的例子：
在我的机器上，输出结果如下：
在上面的例子中，有‘#{...}’这样的代码，它的作用是，计算{}中表达式的结果，并把结果转换成字符串。运行这样的代码后，可以得到结果字符串，并不会看到’#{}‘在输出结果中。
再比如下面的例子：
输出结果为：
在ruby中可以给一个方法指定别名。别名对应的是原方法的一个拷贝，如果原方法改变了，别名不会跟着变化，看例子：
Hello
test2.rb:32 warning: parenthesize argument(s) for future version
Hello satish
success
Hello talim
success
# interpolation refers to the process of inserting the result of an
# expression into a string literal
# the interpolation operator #{...} gets calculated separately
def mtd(arg1="Dibya", arg2="Shashank", arg3="Shashank")
"#{arg1}, #{arg2}, #{arg3}."
end
puts mtd
puts mtd("ruby")
Dibya, Shashank, Shashank
ruby, Shashank, Shashank
puts "100 * 5 = #{100 * 5}"
100 * 5 = 500
def oldmtd
"old method"
end
alias newmtd oldmtd
def oldmtd
"old improved method"
end
puts oldmtd
puts newmtd
运行结果为(别名并没有变化)：
ruby支持可变数量参数的用法吗？答案是肯定的。
'*'会接受传过来的所有参数，并且把他们放到数组my_string中。
do end是程序块。
通过使用‘*’，即可以传递多个参数，也可以一个参数也不传。
上面例子的结果如下：
如果你想包含多个可选参数的话，一定要把可选参数放在最后，比如
那么一共可以给方法传递多少参数？数目是没有限制的，这个问题，可以参考这篇文档。
参数的排列顺序是从左至右排列的，比如：
那么传过去的参数是值传递还是引用传递？请参考这儿。再看下面的例子：
结果是: "hello"。可以看出是按引用传递，但是这个问题一直在讨论中。
old improved method
old method
# variable number of parameters example
# The asterisk is actually taking all arguments you send to the method
# and assigning them to an array named my_string as shown below
# The do end is a Ruby block which we talk in length later
def foo(*my_string)
my_string.each do |words|
puts words
end
end
foo('hello','world')
foo()
hello
world
def opt_args(a,b,*x) # right
def opt_args(a,*x,b) # wrong
def mtd(a=99, b=a+1)
[a,b]
end
puts mtd
def downer(string)
string.downcase!
end
a = "HELLO" # -> "HELLO"
downer(a) # -> "hello"
puts a
重磅方法：（bang or ! methods）
Ruby中，方法名后跟一个‘!’的方法叫重磅方法。带上‘!’标志，就说明这个方法是比较危险的，当然这个危险是相对于同名不带‘!’的方法而言的。
你会经常发现这样成对的方法，有相同的方法名，但是一个带‘!’标志，一个不带。执行不带‘!’的方法后，会返回一个全新的对象。但是如果带‘!’的方法，返回的是原来的对象。这就是他们的区别。
看几个这样的例子，数组的sort/sort!方法，字符串的upcase/upcase!，chomp/chomp!方法，字符串和数组的reverse/reverse!方法。
