mixin - ruby import class from another file

¿Cuál es la diferencia entre require_relative y require en Ruby? (7)

Resumen

Uso `require` para las gemas instaladas.

Utilice `require_relative` para archivos locales

require usa tu $LOAD_PATH para encontrar los archivos.
require_relative usa la ubicación actual del archivo usando la declaración

exigir

Require requiere que usted haya instalado (por ejemplo, gem install [package] ) un paquete en algún lugar de su sistema para esa funcionalidad.

Cuando use require , puede usar el formato " ./ " para un archivo en el directorio actual, por ejemplo, require "./my_file" pero eso no es una práctica común o recomendada y debería usar require_relative lugar.

require_relative

Esto simplemente significa incluir el archivo ''relativo a la ubicación del archivo con la declaración require_relative''. En general, recomiendo que los archivos estén "dentro" del árbol de directorios actual en lugar de "arriba", por ejemplo , no use

require_relative ''../../../filename''

(hasta 3 niveles de directorio) dentro del sistema de archivos porque eso tiende a crear dependencias innecesarias y quebradizas. Sin embargo, en algunos casos, si ya está ''profundo'' dentro de un árbol de directorios, entonces "subir y bajar" puede ser necesario otra rama de árbol de directorios. Quizá sea más simple, no use require_relative para archivos fuera de este repositorio (asumiendo que está usando git, que es un estándar de facto en este punto, finales de 2018).

Tenga en cuenta que require_relative utiliza el directorio actual del archivo con la declaración require_relative (por lo tanto, no necesariamente su directorio actual desde el que está usando el comando). Esto mantiene la ruta require_relative "estable" ya que siempre será relativa al archivo que lo requiere de la misma manera.

¿Cuál es la diferencia entre require_relative y require en Ruby?

Acabo de ver que el código de RSpec tiene algún comentario sobre require_relative siendo O (1) constante y require ser O (N) lineal. Así que probablemente la diferencia es que require_relative es la preferida que require .

Basta con mirar los docs :

require_relative complementa el método incorporado require al permitirle cargar un archivo que es relativo al archivo que contiene la declaración require_relative .
Por ejemplo, si tiene clases de prueba unitaria en el directorio "prueba", y datos para ellas en el directorio "prueba / datos" de prueba, entonces puede usar una línea como esta en un caso de prueba:
require_relative "data/customer_data_1"

Las mejores respuestas son correctas, pero profundamente técnicas. Para aquellos nuevos en el Ruby--

require_relative probablemente se usará para ingresar código de otro archivo que usted escribió.

por ejemplo, ¿qué ~/my-project/data.rb si tiene datos en ~/my-project/data.rb y desea incluirlos en ~/my-project/solution.rb ? en solution.rb usted agregaría require_relative ''data'' .

Es importante tener en cuenta que estos archivos no necesitan estar en el mismo directorio. require_relative ''../../folder1/folder2/data'' también es válido.

lo más probable es que se use require para traer código de una biblioteca que alguien más escribió.

por ejemplo, ¿qué active_support si desea utilizar una de las funciones de ayuda proporcionadas en la biblioteca active_support ? Tendrá que instalar la gema con gem install activesupport y luego en el archivo require ''active_support'' .

require ''active_support/all'' "FooBar".underscore

Dicho de otra manera--

require_relative requiere un archivo específicamente señalado en relación con el archivo que lo llama.
require requiere un archivo incluido en el $ LOAD_PATH.

Quiero agregar que cuando use Windows puede usar require ''./1.rb'' si el script se ejecuta localmente o desde una unidad de red asignada pero cuando se ejecuta desde una ruta UNC / servername / sharename / folder, debe usar require_relative ''./1.rb'' No me require_relative ''./1.rb'' en la discusión que usar por otras razones.

require_relative es un subconjunto conveniente de require

require_relative(''path'')

es igual a

require(File.expand_path(''path'', File.dirname(__FILE__)))

si __FILE__ está definido, o genera LoadError contrario.

Esto implica que:

require_relative ''a'' y require_relative ''./a'' requieren en relación con el archivo actual ( __FILE__ ).
Esto es lo que desea utilizar cuando lo requiera dentro de su biblioteca, ya que no desea que el resultado dependa del directorio actual de la persona que llama.
eval(''require_relative("a.rb")'') genera LoadError porque __FILE__ no está definido dentro de eval .
Esta es la razón por la que no puede usar require_relative en las pruebas de RSpec, que se eval .

Las siguientes operaciones solo son posibles si se require :

require ''./a.rb'' require relativo al directorio actual
require ''a.rb'' usa la ruta de búsqueda ( $LOAD_PATH ) para requerir. No encuentra archivos en relación con el directorio o ruta actual.
Esto no es posible con require_relative porque los documentos dicen que la búsqueda de ruta solo ocurre cuando "el nombre de archivo no se resuelve en una ruta absoluta" (es decir, comienza con / o ./ o ... ./ ), que es siempre el caso de File.expand_path .

La siguiente operación es posible con ambos, pero usted querrá usar require ya que es más corto y más eficiente:

require ''/a.rb'' y require_relative ''/a.rb'' requieren la ruta absoluta.

Leyendo la fuente

Cuando los documentos no están claros, te recomiendo que eches un vistazo a las fuentes (alternar fuente en los documentos). En algunos casos, ayuda entender lo que está sucediendo.

exigir:

VALUE rb_f_require(VALUE obj, VALUE fname) { return rb_require_safe(fname, rb_safe_level()); }

require_relative:

VALUE rb_f_require_relative(VALUE obj, VALUE fname) { VALUE base = rb_current_realfilepath(); if (NIL_P(base)) { rb_loaderror("cannot infer basepath"); } base = rb_file_dirname(base); return rb_require_safe(rb_file_absolute_path(fname, base), rb_safe_level()); }

Esto nos permite concluir que

require_relative(''path'')

es lo mismo que:

require(File.expand_path(''path'', File.dirname(__FILE__)))

porque:

rb_file_absolute_path =~ File.expand_path rb_file_dirname1 =~ File.dirname rb_current_realfilepath =~ __FILE__

De la API de Ruby :

require_relative complementa el método incorporado require al permitirle cargar un archivo que es relativo al archivo que contiene la declaración require_relative.
Cuando usa require para cargar un archivo, normalmente está accediendo a la funcionalidad que se ha instalado correctamente y se ha hecho accesible en su sistema. require no ofrece una buena solución para cargar archivos dentro del código del proyecto. Esto puede ser útil durante una fase de desarrollo, para acceder a datos de prueba, o incluso para acceder a archivos que están "bloqueados" dentro de un proyecto, no para uso externo.
Por ejemplo, si tiene clases de prueba unitaria en el directorio "prueba", y datos para ellas en el directorio "prueba / datos" de prueba, entonces puede usar una línea como esta en un caso de prueba:
require_relative "data/customer_data_1"
Dado que es probable que ni "prueba" ni "prueba / datos" estén en la ruta de la biblioteca de Ruby (y por una buena razón), un requisito normal no los encontrará. require_relative es una buena solución para este problema en particular.
Puede incluir u omitir la extensión (.rb o .so) del archivo que está cargando.
La ruta debe responder a to_str.

Puede encontrar la documentación en http://extensions.rubyforge.org/rdoc/classes/Kernel.html