Qual è la differenza tra includere e richiedere in Ruby?

La mia domanda è simile a ” Qual è la differenza tra includere ed estendere in Ruby? “.

Qual è la differenza tra require e include in Ruby? Se voglio solo utilizzare i metodi di un modulo nella mia class, dovrei require o include ?

Qual è la differenza tra “include” e “richiedono” in Ruby?

Risposta:

I metodi include e require fanno cose molto diverse.

Il metodo require fa ciò che include nella maggior parte degli altri linguaggi di programmazione: esegue un altro file. Tiene traccia anche di ciò che hai richiesto in passato e non richiederà lo stesso file due volte. Per eseguire un altro file senza questa funzionalità aggiunta, è ansible utilizzare il metodo di caricamento.

Il metodo include prende tutti i metodi da un altro modulo e li include nel modulo corrente. Questa è una cosa a livello di linguaggio rispetto a una cosa a livello di file come con require. Il metodo include è il modo principale per “estendere” le classi con altri moduli (di solito indicati come mix-in). Ad esempio, se la tua class definisce il metodo “ciascuno”, puoi includere il modulo mixin Enumerable e può agire come una raccolta. Questo può essere fonte di confusione in quanto il verbo di inclusione viene usato in modo molto diverso in altre lingue.

fonte

Quindi, se vuoi semplicemente utilizzare un modulo, piuttosto che estenderlo o eseguire un mix-in, dovrai utilizzare require .

Stranamente, la require di Ruby è analoga a quella di C, mentre l’ include di Ruby è quasi nulla come l’ include di C.

Dal libro Rubir Metaprogramming,

Il metodo require() è abbastanza simile a load() , ma è pensato per uno scopo diverso. Si usa load() per eseguire il codice e si usa require() per importare le librerie.

Se stai usando un modulo, significa che stai portando tutti i metodi nella tua class. Se extend una class con un modulo, significa che stai “introducendo” i metodi del modulo come metodi di class . Se include una class con un modulo, significa che stai “introducendo” i metodi del modulo come metodi di istanza .

EX:

  module A def say puts "this is module A" end end class B include A end class C extend A end 

B.say => metodo non definito ‘say’ per B: Class

B.new.say => questo è il modulo A

C.say => questo è il modulo A

C.new.say => metodo non definito ‘say’ per C: Class

  • require Ruby è più come “includere” in altre lingue (come C). Racconta a Ruby che vuoi portare il contenuto di un altro file . Meccanismi simili in altre lingue sono:

    • using direttiva using in C # .
    • import in Java .
  • Ruby include è un meccanismo di ereditarietà orientato agli oggetti usato per i mixin .

C’è una buona spiegazione qui :

[La] risposta semplice è che richiedono e includono essenzialmente non correlati.

“require” è simile a C include, che può causare confusione newbie. (Una differenza notevole è che i locali all’interno del file richiesto “evaporano” quando viene effettuata la richiesta).

L’ inclusione di Ruby non ha nulla a che vedere con l’inclusione C. L’istruzione include “mescola” un modulo in una class. È una forma limitata di ereditarietà multipla . Un modulo incluso dà letteralmente una relazione “è-a” sulla cosa includendolo.

Enfasi aggiunta.

Hai mai provato a require un modulo? Quali sono stati i risultati? Prova:

 MyModule = Module.new require MyModule # see what happens 

I moduli non possono essere richiesti, solo inclusi!

Dalla programmazione Ruby 1.9

Faremo un paio di punti sulla dichiarazione di inclusione prima di andare avanti. Innanzitutto, non ha nulla a che fare con i file. I programmatori C usano una direttiva preprocessore chiamata #include per inserire il contenuto di un file in un altro durante la compilazione. L’istruzione include di Ruby fa semplicemente riferimento a un modulo. Se quel modulo si trova in un file separato, è necessario utilizzare require (o il suo cugino meno comunemente usato, caricare) per trascinare il file prima di usare include. In secondo luogo, un include di Ruby non copia semplicemente i metodi di istanza del modulo nella class. Invece, fa un riferimento dalla class al modulo incluso. Se più classi includono quel modulo, puntano tutti alla stessa cosa. Se cambi la definizione di un metodo all’interno di un modulo, anche mentre il tuo programma è in esecuzione, tutte le classi che includono quel modulo mostreranno il nuovo comportamento.

Includi Quando includi un modulo nella tua class come mostrato di seguito, è come se avessi preso il codice definito all’interno del modulo e inserito nella class, dove lo “includi”. Permette il comportamento “mixin”. È usato per ASCIUGARE il codice per evitare la duplicazione, ad esempio, se ci fossero più classi che avrebbero bisogno dello stesso codice all’interno del modulo.

Caricare Il metodo load è quasi come il metodo require, tranne che non tiene traccia del fatto che la libreria sia stata caricata o meno. Quindi è ansible caricare una libreria più volte e anche quando si utilizza il metodo di caricamento è necessario specificare l’estensione “.rb” del nome del file della libreria.

Richiedi Il metodo require consente di caricare una libreria e impedirne il caricamento più di una volta. Il metodo require restituirà ‘false’ se si tenta di caricare la stessa libreria dopo la prima volta. Il metodo di richiesta deve essere utilizzato solo se la libreria che si sta caricando è definita in un file separato, che di solito è il caso.

Puoi preferire questo http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/

 require(name) 

Restituirà bolean vero / falso

Il nome che viene passato come parametro al require, ruby ​​cercherà di trovare il file sorgente con quel nome nel tuo percorso di caricamento. Il metodo require restituirà ‘false’ se si tenta di caricare la stessa libreria dopo la prima volta. Il metodo di richiesta deve essere utilizzato solo se la libreria che stai caricando è definita in un file separato. Quindi tiene traccia di se quella libreria è già stata caricata o meno.

 include module_name 

Supponiamo che tu abbia alcuni metodi che devi avere in due classi diverse. Quindi non è necessario scriverli in entrambe le classi. Invece quello che puoi fare è definirlo nel modulo. E quindi includere questo modulo in altre classi. È fornito da Ruby solo per garantire il principio ASCIUTTO. È utilizzato per ASCIUGARE il codice per evitare la duplicazione

Includere

Quando include un modulo nella tua class, è come se avessi preso il codice definito all’interno del modulo e inserito nella class, dove lo “includi”. Permette il comportamento “mixin”. È usato per ASCIUGARE il codice per evitare la duplicazione, ad esempio, se ci fossero più classi che avrebbero bisogno dello stesso codice all’interno del modulo.

 module Log def class_type "This class is of type: #{self.class}" end end class TestClass include Log # ... end tc = TestClass.new.class_type # -> success tc = TestClass.class_type # -> error 

richiedere

Il metodo require consente di caricare una libreria e impedirne il caricamento più di una volta. Il metodo require restituirà ‘false’ se si tenta di caricare la stessa libreria dopo la prima volta. Il metodo di richiesta deve essere utilizzato solo se la libreria che si sta caricando è definita in un file separato, che di solito è il caso.

Quindi tiene traccia di se quella libreria è già stata caricata o meno. Inoltre, non è necessario specificare l’estensione “.rb” del nome del file della libreria. Ecco un esempio di come usare require. Inserisci il metodo require nella parte superiore del tuo file “.rb”:

Caricare

Il metodo load è quasi come il metodo require, tranne per il fatto che non tiene traccia del fatto che la libreria sia stata caricata o meno. Quindi è ansible caricare una libreria più volte e anche quando si utilizza il metodo di caricamento è necessario specificare l’estensione “.rb” del nome del file della libreria.

Estendere

Quando si utilizza il metodo est anziché l’inclusione, si aggiungono i metodi del modulo come metodi di class anziché come metodi di istanza.

 module Log def class_type "This class is of type: #{self.class}" end end class TestClass extend Log # ... end tc = TestClass.class_type 

Di seguito sono riportate alcune differenze di base tra richiedere e includere:

richiede:

  1. Require legge il file dal file system, lo analizza, lo salva nella memoria e lo esegue in un determinato punto, il che significa che se cambierai qualcosa mentre lo script è in esecuzione, quel cambiamento non si rifletterà.
  2. Richiediamo file per nome, non per nome del modulo.
  3. Viene in genere utilizzato per le librerie e le estensioni.

Includere:

  1. Quando includi un modulo nella tua class si comporta come se avessi preso il codice definito nel tuo modulo e inserito nella tua class.
  2. Includiamo il nome del modulo, non il nome del file.
  3. Viene in genere utilizzato per asciugare il codice e rimuovere la duplicazione nel codice.