A method definition is started with the def keyword and ended with the end keyword. Some programmers find the method definition notation in Ruby very similar to the one of Python.
def myMethod end
To define a method that takes a parameter, you can put the name of the variable in parantheses after the method name. When the method is invoked, the code in the method will be run with a local variable with the name of the specified parameter.
def myMethod(msg) puts msg end
If you need multiple parameters you can separate them with a comma.
def myMethod(msg, person) puts "Hi, my name is " + person + ". Some information about myself: " + msg end
You can invoke methods with or without parentheses although it can be considered bad style if you omit them, so the safe way is to always write them in the beginning until you know when it's safe to leave them away.
# With parentheses myMethod() # Without parentheses myMethod
If you want to invoke a method with parameters you need to put the parameter(s) between the brackets (or if you omit them, between the invisible brackets) and separate them with commas if there are more than one.
def myMethod(a, b) puts a + b end myMethod(1, 2) myMethod 1, 2 myMethod("abc", "xyz")
You can also use the value of a variable as a parameter.
def myMethod(a) puts "Hello " + a end name = "World" myMethod(name)
Often a method may have many parameters of which many, if not all, could have clever defaults to avoid wasting time always having to specify all of the parameters every time you invoke the method. Because of this it's possible to define default values. This can be actually quite easily. You simply assign the parameter a value in the definition. You can combine parameters with and without default values.
def myMethod(message="This is a default value") puts message end myMethod() myMethod("Where has the default value gone?")
Really often you want a method to return a value. You can do so by using the return statement.
def myMethod return "Hello" end puts myMethod()
However because Ruby developers are lazy they developed a feature that always returns the last evaluated statement (sometimes it's a bit tricky to know which one this is). Knowing this you can turn the above example into this:
def myMethod "Hello" end puts myMethod()
Note that a return statement finishes the execution of a method. Combined with the fact that you can return without a value this is often useful to stop a method from further execution if certain conditions are met.
def myMethod while true puts "Because the condition of this while loop is 'true' it will run forever, right?" return end end
This page was only meant to give some introduction how to work with methods in Ruby because this is a very important concept. However there is a more detailed page about methods and some other cool things that weren't mentioned here.