What is the difference between include and require in Ruby?
What's the difference between
"include" and "require" in Ruby?Answer:
The include and require methods do
very different things.The require method does what include
does in most other programming
languages: run another file. It also
tracks what you've required in the
past and won't require the same file
twice. To run another file without
this added functionality, you can use
the load method.The include method takes all the
methods from another module and
includes them into the current module.
This is a language-level thing as
opposed to a file-level thing as with
require. The include method is the
primary way to "extend" classes with
other modules (usually referred to as
mix-ins). For example, if your class
defines the method "each", you can
include the mixin module Enumerable
and it can act as a collection. This
can be confusing as the include verb
is used very differently in other
languages.
Source
So if you just want to use a module, rather than extend it or do a mix-in, then you'll want to use require
.
Oddly enough, Ruby's require
is analogous to C's include
, while Ruby's include
is almost nothing like C's include
.
What is difference between require and include?
There is an excellent answer to this here:
What is the difference between include and require in Ruby?
Why use both require and include in Rails class?
require
loads a ruby file, making the BCrypt module available to your ruby code. It does not, necessarily have to be in the same file as the class you're including the module in.
require
can also be used to make a ruby class defined in that file available (for instance, other classes you've defined in your project). As it's in a gem, bcrypt is on the ruby path, if it's a file in your project you may need to reference the full path, or use require_relative
.
include
takes the code in the bCrypt module and includes it to your User class, providing User with the methods and attributes declared in the BCrypt module.
With a ruby-doc.org library how do you work out whether to require or include?
As Jörg Mittag already pointed our in this comment: require
and include
are doing totally different things and have nothing in common. They aren't related to each other nor they are interchangeable.
require
loads a file (reads the docs for details). Ruby doesn't magically find files or modules/classes that are defined in a file. Every piece of code that is defined in an external file requires the file to be loaded before the code is executed and can be used.
Modules in Ruby's core (like Math
- note the core
in the URL) are required automatically, therefore you do not need to load them yourself. But if you want to use a module or class from the standard library (like CSV
) or an external gem you need to require it by yourself. This might not be obvious because tools like bundler require files for you or a gem requires internally all other files it needs.
All Ruby files need to be loaded before they can be used. require
is the most common way to load Ruby files.
Imagine there is a file named foo.rb
that looks like this:
puts 'loading file...'
def foo_loaded?
true
end
module Foo
def self.bar
puts 'bar'
end
end
Playing around in the console:
# `foo` wasn't required yet
> foo_loaded?
#=> NoMethodError: undefined method `foo_loaded?' for main:Object
> Foo
#=> NameError: uninitialized constant Foo
# It doesn't find the file if it ist not in the current $LOAD_PATH
require 'foo'
#=> LoadError: cannot load such file -- foo
# It loads and executes (see the output from `puts`) the file when found
> require './foo'
#=> loading file...
#=> true
# Now we can start using the methods and modules defined in the file
> foo_loaded?
#=> true
> Foo
#=> Foo
> Foo.bar
#=> bar
There is no need to include
anything. Everything defined in the file is available to Ruby right away. There is not need to name give that file a special name matching the module, class or methods inside. But it is a common pattern and a good practice to name the file by its content.
include
doesn't work on file-level but on the language level. It basically takes all methods from a module and includes them into another module or class. Btw: If the module you want to include is defined in an external file then you need to require that file first, otherwise Ruby won't even know that the module exists and cannot include it.
Imagine a module and class structure like this:
module Bar
def bar
puts 'bar'
end
end
class Foo
end
Foo.new.bar
#=> NoMethodError: undefined method `bar' for #<Foo:...
# Bar is not related to Foo
Foo.ancestors
#=> [Foo, Object, Kernel, BasicObject]
And when we include Bar
into Foo
:
module Bar
def bar
puts 'bar'
end
end
class Foo
include Bar
end
Foo.new.bar
#=> bar
# Bar is now a superclass of Foo
Foo.ancestors
#=> [Foo, Bar, Object, Kernel, BasicObject]
Things to note: There is no need to use require
in this example because both the module and the class are defined in the same file. include
takes the module not a string defining a file or a module name.
Because include
does a very special thing it is not useful to ask: Do I need to require or include X before using it? Or: How do I know what to include? Ofter there is no need to include anything: A gem might only provide classes/modules to use directly or it might include its functionality itself. This depends on the design and the purpose of the module. You cannot tell without reading the documentation or the source code.
tl:dr
require
andinclude
do totally different things.- Ruby files must be
loaded
before usage.require
is one way to load a Ruby file. include
includes methods from a module into the current module/class.- You must read the documentation about how to use a library, there isn't just one way to implement things.
What is the difference between require and include with php?
require
requires, include
includes.
According to the manual:
require() is identical to include() except upon failure it will produce a fatal E_ERROR level error. In other words, it will halt the script whereas include() only emits a warning (E_WARNING) which allows the script to continue.
Difference between include and require in php
You find the differences explained in the detailed PHP manual on the page of require
:
require
is identical toinclude
except upon failure it will also produce a fatalE_COMPILE_ERROR
level error. In other words, it will halt the script whereas include only emits a warning (E_WARNING
) which allows the script to continue.
See @efritz's answer for an example
Understanding the difference between `load`, `require`, and `require_relative`
load
is used when you want to import a file irrespective of whether it has been already imported. require
or require_relative
is used when you want to import a file only if it has not been already.
From this, it follows that the former is used when the imported file is the object of analysis (data file), whereas the latter is used to provide some features to be used in the program (part of the program, library, framework).
While require
can only handle paths relative to $:
, require_relative
is an extension that can handle paths relative to current directory as well. require_relative
is a superset of require
, and require
can be dispensed (although require_relative
is written using require
, so it has to be rewritten if require
is to be dispensed).
Difference between require, include, require_once and include_once?
There are require
and include_once
as well.
So your question should be...
- When should I use
require
vs.include
? - When should I use
require_once
vs.require
The answer to 1 is described here.
The require() function is identical to include(), except that it handles errors differently. If an error occurs, the include() function generates a warning, but the script will continue execution. The require() generates a fatal error, and the script will stop.
The answer to 2 can be found here.
The require_once() statement is identical to require() except PHP will check if the file has already been included, and if so, not include (require) it again.
Related Topics
Why Use Symbols as Hash Keys in Ruby
Ruby: What Does 'Require: False' in Gemfile Mean
Using Sinatra For Larger Projects Via Multiple Files
Pass Parameter by Reference' in Ruby
Rails 4: Before_Filter Vs. Before_Action
How to Run a Rake Task from Capistrano
How to Search Within an Array of Hashes by Hash Values in Ruby
Is Ruby Pass by Reference or by Value
What's the Difference Between Equal, Eql, ===, and ==
Rails :Dependent =≫ :Destroy VS :Dependent =≫ :Delete_All