Modules are a way of combining methods, classes, and constants. Modules offer you two benefits.
- module provides an namespace and avoids name collisions. The
- module implements the mixin device.
Modules define a namespace, equivalent to a sandbox, where your methods and constants don't conflict with method constants elsewhere.
The module is similar to the class, but there is a difference:
- Module cannot be instantiated
- Module has no subclasses
- Modules can only be defined by another module
Module constant naming is similar to class constant naming, starting with an uppercase letter. Method definitions look similar: module method definitions are similar to class method definitions.
Through the class method, you can call the module method by placing the module name and a dot before the class method name. You can use the module name and two colons to reference a constant.
We can define multiple modules with the same function name but different functions:
Just like the class method, when you define a method in a module, you can specify that the module name is followed by a dot followed by the method name.
Ruby require statementThe
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, you can simply load the module file using the Ruby require statement:
The file extension .rb is not required here.
Here, we use $LOAD_PATH << '.' to let Ruby realize that the ebb and flow catalog must be hunt down the referenced record. On the off chance that you would prefer not to utilize $LOAD_PATH, you can utilize require_relative to reference a record from a relative registry.
Note: Here, the record contains a similar capacity name. Along these lines, this prompts code uncertainty when alluding to the calling program, however the module dodges this code equivocalness, and we can call the fitting capacity with the name of the module.
Ruby include statement
You can insert modules in your class. To implant a module in a class, you can utilize the include articulation in your class:
If the module is defined in a separate file, you need to reference the file with the require statement before embedding the module.
Assume the following modules are written in the support.rb file.
Now, you can reference the module in a class as follows:
This will produce the following results:
Sunday You have four weeks in a month You have 52 weeks in a year Sunday 120
Mixins in Ruby
Before perusing this segment, you have to get a look at item situated ideas.
When a class can acquire the properties of a class from various parent classes, the class shows up as numerous legacy.
Ruby doesn't legitimately bolster various legacy, however Ruby's module has another mysterious component. It for all intents and purposes wipes out the requirement for different legacy and gives a gadget called mixin.
Ruby doesn't generally execute numerous legacy instruments, yet rather utilizes mixin innovation as a substitution. The module is incorporated into the class definition, and the techniques in the module are blended into the class.
Let's investigate the example code underneath to become familiar with mixin:
- Module A comprises of strategies a1 and a2.
- Module B comprises of strategies b1 and b2.
- Class Sample contains modules An and B.
- Class Sample approaches each of the four techniques, a1, a2, b1, and b2. So, you can see that the class Sample acquires two modules, you can say that the class Sample utilizes various legacy or mixin .