In Ruby 1.9.2 + `require_relative` is probably the more correct way to do it. 

`require` was changed to not include your `&#39;.&#39;` directory for security reasons. `require_relative` was added to provide a local-file solution for modules relative to your *calling script&#39;s* path.

You can [search here on StackOverflow][1], particularly in &quot;[What is require_relative in Ruby?][3]&quot;, and the internets and find usage tricks and the [why-for messages][2] explaining how it came about.

[1]: https://stackoverflow.com/search?q=require_relative
[2]: https://web.archive.org/web/20110817002255/http://www.ruby-forum.com/topic/148978
[3]: https://stackoverflow.com/questions/3672586/what-is-require-relative-in-ruby


In Ruby 2.x you can use [`Kernel#__dir__`](http://ruby-doc.org/core-2.5.0/Kernel.html#method-i-__dir__)

Unless you modify `$LOAD_PATH`, which would be a good idea if you keep loading from the same directory structure, you are stuck doing it that way.

The way I&#39;ve taken to doing it, to ensure things are as cross-platform as possible, is this:

    require File.expand_path(File.join(*%w[ ... ]), File.dirname(__FILE__))

It&#39;s a little verbose, but it results in the shortest possible path and the least amount of syntax fluff in most cases.

A more specific example would be:

    require File.expand_path(File.join(*%w[ .. lib example ]), File.dirname(__FILE__))

You can combine this with a modification to `$LOAD_PATH` to simplify things if you&#39;re loading a lot of files and do this:

    $LOAD_PATH &lt;&lt; File.expand_path(File.join(*%w[ .. lib ]), File.dirname(__FILE__))

    require &#39;example&#39;


In Ruby 1.8.x, where you don&#39;t have `require_relative` in core, `File.expand_path(...,__FILE__)` won&#39;t work.

Suppose `__FILE__ == &quot;/home/yourname/foo.rb&quot;`. `File.expand_path(&quot;bar.rb&quot;,__FILE__)` gives `&quot;/home/yourname/foo.rb/bar.rb`.

What you want is `File.expand_path(&quot;bar.rb&quot;,File.dirname(__FILE__))` which returns `&quot;/home/yourname/bar.rb&quot;`

You could also get `require_relative` from the [backports gem][1].


  [1]: http://github.com/marcandre/backports

Is there anywhere in the service runtime that would tell me if I&#39;m currently running on &#39;Staging&#39; or &#39;Production&#39;? Manually modifying the config to and from production seems a bit cumbersome.

Staging or Production Instance?

Is there a base-64 decoder and encoder for a String in Android?

Base64 encoder and decoder

Is `require File.expand_path(..., __FILE__)` the best way to require other files within a project?

Is require File.expand_path(..., __FILE__) the best practice?

<p>Is <code>require File.expand_path(..., __FILE__)</code> the best way to require other files within a project?</p>


What is the best practice if I want to `require` a relative file in Ruby *and* I want it to work in both 1.8.x and &gt;=1.9.2?

I see a few options:

  * just do `$LOAD_PATH &lt;&lt; &#39;.&#39;` and forget everything
  * do `$LOAD_PATH &lt;&lt; File.dirname(__FILE__)`
  * `require &#39;./path/to/file&#39;`
  * check if `RUBY_VERSION` &lt; 1.9.2, then define `require_relative` as `require`, use `require_relative` everywhere where it&#39;s needed afterwards
  * check if `require_relative` already exists, if it does, try to proceed as in previous case
  * use weird constructions such as &lt;code&gt;&lt;pre&gt;`require File.join(File.dirname(__FILE__), &#39;path/to/file&#39;)`&lt;/pre&gt;&lt;/code&gt; - alas they don&#39;t seem to work in Ruby 1.9 throughly, because, for example: &lt;pre&gt;&lt;code&gt;`$ cat caller.rb
require File.join(File.dirname(__FILE__), &#39;path/to/file&#39;)
$ cat path/to/file.rb
puts &#39;Some testing&#39;
$ ruby caller
Some testing
$ pwd
/tmp
$ ruby /tmp/caller
Some testing
$ ruby tmp/caller
tmp/caller.rb:1:in &#39;require&#39;: no such file to load -- tmp/path/to/file (LoadError)
        from tmp/caller.rb:1:in &#39;&lt;main&gt;&#39;`&lt;/code&gt;&lt;/pre&gt;
  * Even weirder construction: &lt;code&gt;&lt;pre&gt;`require File.join(File.expand_path(File.dirname(__FILE__)), &#39;path/to/file&#39;)`&lt;/pre&gt;&lt;/code&gt; seems to work, but it&#39;s weird and not quite good looking.
  * Use [backports][1] gem - it&#39;s kind of heavy, it requires rubygems infrastructure and includes tons of other workarounds, while I just want `require` to work with relative files.

There&#39;s a [closely related question at StackOverflow][2] that gives some more examples, but it doesn&#39;t give a clear answer - which is a best practice.

Is there are any decent, accepted-by-everyone universal solution to make my application run on both Ruby &lt;1.9.2 and &gt;=1.9.2?

&lt;h2&gt;UPDATE&lt;/h2&gt;

Clarification: I don&#39;t want just answers like &quot;you can do X&quot; - in fact, I&#39;ve already mentioned most of choices in question. I want *rationale*, i.e. *why* it is a best practice, what are its pros and cons and why it should be chosen among the others.

[1]: http://rubygems.org/gems/backports
[2]: https://stackoverflow.com/questions/4325759/is-require-file-expand-path-file-the-best-practice

Ruby: require vs require_relative - best practice to workaround running in both Ruby &lt;1.9.2 and &gt;=1.9.2

Would this be the best way to sort a hash and return Hash object (instead of Array):

    h = {&quot;a&quot;=&gt;1, &quot;c&quot;=&gt;3, &quot;b&quot;=&gt;2, &quot;d&quot;=&gt;4}
    # =&gt; {&quot;a&quot;=&gt;1, &quot;c&quot;=&gt;3, &quot;b&quot;=&gt;2, &quot;d&quot;=&gt;4}
    
    Hash[h.sort]
    # =&gt; {&quot;a&quot;=&gt;1, &quot;b&quot;=&gt;2, &quot;c&quot;=&gt;3, &quot;d&quot;=&gt;4}

Sort hash by key, return hash in Ruby

If i have a float of 49.967 and I do .to_i it will chop it down to 49 which for my use of disk space analysis .967 is over 900mb of space that wont be accounted for in the displays.

Is there a function to round numbers to the nearest integer or would i have to define it my self like this:

    class Float
      def to_nearest_i
        (self+0.5).to_i
      end
    end

so that i could then do:

    &gt;&gt; 5.44.to_nearest_i
    =&gt; 5
    &gt;&gt; 5.54.to_nearest_i
    =&gt; 6




Rounding a float to the nearest integer in ruby

So I&#39;m iterating over a range like so:

    (1..100).each do |n|
        # n = 1
        # n = 2
        # n = 3
        # n = 4
        # n = 5
    end

But what I&#39;d like to do is iterate by 10&#39;s.

So in stead of increasing `n` by 1, the next `n` would actually be 10, then 20, 30, etc etc.


Ruby: How to iterate over a range, but in set increments?

I&#39;ve got an array A. I&#39;d like to check if it contains duplicate values. How would I do so?

How do I check an array for duplicates?

How can I detect whether my Node.JS file was called using SH:`node path-to-file` or JS:`require(&#39;path-to-file&#39;)`?

This is the Node.JS equivalent to my previous question in Perl: https://stackoverflow.com/questions/4004466/how-can-i-run-my-perl-script-only-if-it-wasnt-loaded-with-require

Detect if called through require or directly by command line

Are there any libraries for in-browser javascript that provide the same flexibility/modularity/ease of use as Node&#39;s `require`?

To provide more detail: the reason `require` is so good is that it:

1.  Allows code to be dynamically loaded from other locations (which is stylistically better, in my opinion, than linking all your code in the HTML)
2.  It provides a consistent interface for building modules
3.  It is easy for modules to depend on other modules (so I could write, for instance, an API that requires jQuery so I can use `jQuery.ajax()`
4.  Loaded javascript is _scoped_, meaning I could load with `var dsp = require(&quot;dsp.js&quot;);` and I would be able to access `dsp.FFT`, which wouldn&#39;t interfere with my local `var FFT`

I have yet to find a library that does this effectively.  The workarounds I tend to use are:

-  [coffeescript-concat][1] -- it&#39;s easy enough to require other js, but you have to compile it, which means it is less great for fast development (e.g. building APIs in-test)

-  [RequireJS][2] -- It&#39;s popular, straightforward, and solves 1-3, but lack of scoping is a real deal-breaker (I believe [head.js][3] is similar in that it lacks scoping, though I&#39;ve never had any occasion to use it.  Similarly, [LABjs][4] can load and `.wait()` does mollify dependency issues, but it still doesn&#39;t do scoping)

As far as I can tell, there appear to be many solutions for dynamic and/or async loading of javascript, but they tend to have the same scoping issues as just loading the js from HTML.  More than anything else, I would like a way to load javascript that does not pollute the global namespace at all, but still allows me to load and use libraries (just as node&#39;s require does).

__2020 UPDATE:__ [Modules][7] are now standard in ES6, and as of mid-2020 are natively supported by [most browsers][8]. Modules support both synchronous and asynchronous (using Promise) loading. My current recommendation is that most new projects should use ES6 modules, and use a transpiler to fall back to a single JS file for legacy browsers.

As a general principle, bandwidth today is also typically much wider than when I originally asked this question. So in practice, you might reasonably chose to always use a transpiler with ES6 modules, and focus your effort on code efficiency rather than network.

__PREVIOUS EDIT (or if you don&#39;t like ES6 modules):__ Since writing this, I have extensively used [RequireJS][5] (which now has much clearer documentation). RequireJS really was the right choice in my opinion. I&#39;d like to clarify how the system works for people who are as confused as I was:

You can use `require` in everyday development. A module can be anything returned by a function (typically an object or a function) and is scoped as a parameter. You can also compile your project into a single file for deployment using `r.js` (in practice this is almost always faster, even though `require` can load scripts in parallel).

The primary difference between RequireJS and node-style require like browserify (a cool project suggested by tjameson) uses is the way modules are designed and required:

- RequireJS uses AMD (Async Module Definition). In AMD, `require` takes a list of modules (javascript files) to load and a callback function. When it has loaded each of the modules, it calls the callback with each module as a parameter to the callback. Thus it&#39;s truly asynchronous and therefore well-suited to the web.
- Node uses CommonJS. In CommonJS, `require` is a blocking call that loads a module and returns it as an object. This works fine for Node because files are read off the filesystem, which is fast enough, but works poorly on the web because loading files synchronously can take much longer.

In practice, many developers have used Node (and therefore CommonJS) before they ever see AMD. In addition, many libraries/modules are written for CommonJS (by adding things to an `exports` object) rather than for AMD (by returning the module from the `define` function). Therefore, lots of Node-turned-web developers want to use CommonJS libraries on the web. This is possible, since loading from a `&lt;script&gt;` tag is blocking. Solutions like browserify take CommonJS (Node) modules and wrap them up so you can include them with script tags.

Therefore, if you are developing your own multi-file project for the web, I strongly recommend RequireJS, since it is truly a module system for the web (though in fair disclosure, I find AMD much more natural than CommonJS). Recently, the distinction has become less important, since RequireJS now allows you to essentially use CommonJS syntax. Additionally, RequireJS can be used to load AMD modules in Node (though I prefer [node-amd-loader][6]).


  [1]: https://github.com/fairfieldt/coffeescript-concat
  [2]: http://requirejs.org/
  [3]: http://headjs.com/
  [4]: http://labjs.com/
  [5]: http://requirejs.org/
  [6]: https://github.com/ajaxorg/node-amd-loader
  [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
  [8]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules#Browser_support

Node-style require for in-browser javascript?

I would like to include a couple of JSON files in my JavaScript code that are in the same directory as my JavaScript source file.

If I wanted to include another JavaScript file I could simply use `require`.
Now I&#39;m using `readFileSync` and `__dirname` to get the JSON, which I think is an ugly way to do it.

Is there something similar for require that enables me to load a JSON file?


is there a require for json in node.js

When I do:

    lib = require(&#39;lib.js&#39;)(app)

is `app` actually geting passed in?

in lib.js:

    exports = module.exports = function(app){}

Seems like no, since when I try to do more than just `(app)` and instead do:

    lib = require(&#39;lib.js&#39;)(app, param2)

And:

    exports = module.exports = function(app, param2){}

I don&#39;t get `params2`.

I&#39;ve tried to debug by doing:

    params = {}
    params.app = app
    params.param2 = &quot;test&quot;
    
    lib = require(&quot;lib.js&quot;)(params)

but in lib.js when I try to `JSON.stringify` I get this error:

    &quot;DEBUG: TypeError: Converting circular structure to JSON&quot;








Node.js &quot;require&quot; function and parameters

In Ruby, I have been told that when doing

    require &quot;some_file&quot;

Ruby will look for the file in certain places.

I know that it looks for `some_file.rb`, but where does it look for it by default?
    

Content Type	Original Author	Original Content on Stackoverflow
Question	dan	View Question on Stackoverflow
Solution 1 - Ruby	the Tin Man	View Answer on Stackoverflow
Solution 2 - Ruby	Steve Benner	View Answer on Stackoverflow
Solution 3 - Ruby	tadman	View Answer on Stackoverflow
Solution 4 - Ruby	Ken Bloom	View Answer on Stackoverflow

Is require File.expand_path(..., FILE) the best practice?

Ruby Problem Overview

Ruby Solutions

Solution 1 - Ruby

Solution 2 - Ruby

Solution 3 - Ruby

Solution 4 - Ruby

Base64 encoder and decoder

Staging or Production Instance?

Attributions