Ruby module (Module)

Syntax

module Identifier
   statement1
   statement2
   ...........
end

Module constant naming is similar to class constant naming, starting with a capital letter. Method definitions also look similar: module method definitions are similar to class method definitions.

With class methods, you can call module methods by placing the module name and a period in front of the class method name, and you can use the module name and two colons to reference a constant.

Example

#!/usr/bin/ruby

# 定义在 trig.rb 文件中的模块

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

We can define multiple modules with the same function name but different functions:

#!/usr/bin/ruby

# 定义在 moral.rb 文件中的模块

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

Just like class methods, when you define a method in a module, You can specify that the module name is followed by a period, and the period is followed by the method name.

Ruby require Statement

The require statement is similar to the include statement in C and C++ and the import statement in Java. If a third-party program wants to use any of the defined modules, it can simply use the Ruby require statement to load the module file:

Syntax

require filename

here , the file extension .rb is not required.

Example

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

Here, we use $LOAD_PATH << '.' to let Ruby know that it must search the current directory for the referenced file. If you don't want to use $LOAD_PATH, then you can use require_relative to reference files from a relative directory.

Note: Here, the files contain the same function name. So, this leads to code ambiguity when referencing the calling program, but modules avoid this code ambiguity and we can call the appropriate function using the name of the module.

Ruby include Statement

You can embed modules within a class. To embed a module in a class, you can use the include statement in the class:

Syntax

include modulename

If the module is defined in a separate file, then when embedding The module needs to use the require statement to reference the file.

Example

Assume that the following module is written in the support.rb file.

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

Now you can reference the module in your class like this:

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs=10
   def no_of_months
      puts Week::FIRST_DAY
      number=10*12
      puts number
   end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

This will produce the following result:

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Mixins in Ruby

Before reading this section, you need to have a preliminary understanding of object-oriented concepts.

When a class can inherit the characteristics of a class from multiple parent classes, the class displays multiple inheritance.

Ruby does not directly support multiple inheritance, but Ruby modules (Modules) have another magical feature. It almost eliminates the need for multiple inheritance, providing a device called mixin.

Ruby does not really implement multiple inheritance mechanisms, but uses mixin technology as a replacement. By including the module into the class definition, the methods in the module are mixed into the class.

Let’s look at the following sample code to understand the mixin in depth:

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

• Module A consists of methods a1 and a2.

• Module B consists of methods b1 and b2.

• Class Sample contains modules A and B.

• Class Sample has access to all four methods, namely a1, a2, b1 and b2.

So, you can see that the class Sample inherits two modules, you can say that the class Sample uses multiple inheritance or mixin .