Differenza tra require, include, require_once e include_once?

In PHP:

• Quando dovrei usare requirevs. include?
• Quando dovrei usare require_oncevs. include_once?

Ci sono requiree include_oncepure.

Quindi la tua domanda dovrebbe essere ...

1. Quando dovrei usare requirevs. include?
2. Quando dovrei usare require_oncevs.require

La risposta a 1 è descritta qui .

La funzione request () è identica a include (), tranne per il fatto che gestisce gli errori in modo diverso. Se si verifica un errore, la funzione include () genera un avviso, ma lo script continuerà l'esecuzione. Requisito () genera un errore irreversibile e lo script si arresterà.

La risposta a 2 può essere trovata qui .

L'istruzione request_once () è identica a require () tranne PHP verificherà se il file è già stato incluso e, in tal caso, non includerlo (richiederlo) di nuovo.

Uso

• richiede
  quando il file è richiesto dall'applicazione, ad esempio un modello di messaggio importante o un file contenente variabili di configurazione senza le quali l'app si spezzerebbe.

• require_once
  quando il file contiene contenuto che produrrebbe un errore alla successiva inclusione, ad esempio function important() { /* important code */}è sicuramente necessario nella tua applicazione, ma poiché le funzioni non possono essere rideterminate non dovrebbero essere incluse di nuovo.

• includere quando il file non è richiesto e il flusso dell'applicazione dovrebbe continuare quando non viene trovato, ad es.
  ottimo per i modelli che fanno riferimento a variabili dall'ambito corrente o qualcosa del genere

• include_once
  dipendenze opzionali che potrebbero produrre errori al successivo caricamento o forse inclusione remota di file che non si desidera che si verifichino due volte a causa dell'overhead HTTP

Ma fondamentalmente, dipende da te quando usare quale.

Il mio consiglio è di usare solo il require_once99,9% delle volte.

L'uso requireo includeinvece implica che il tuo codice non è riutilizzabile altrove, ovvero che gli script che stai inserendo eseguono effettivamente il codice invece di rendere disponibili una classe o alcune librerie di funzioni.

Se hai bisogno / incluso il codice che viene eseguito sul posto, questo è un codice procedurale e devi conoscere un nuovo paradigma . Come la programmazione orientata agli oggetti, la programmazione basata sulle funzioni o la programmazione funzionale.

Se si sta già facendo OO o programmazione funzionale, utilizzando include_onceè in gran parte sta per essere ritardare dove nella pila a trovare bug / errori. Vuoi sapere che la funzione do_cool_stuff()non è disponibile quando vai a chiamarla in un secondo momento o nel momento in cui ti aspetti che sia disponibile richiedendo la libreria? In generale, è meglio sapere immediatamente se qualcosa di cui hai bisogno e che ti aspetti non sia disponibile, quindi usa solo require_once.

In alternativa, nella moderna OOP, carica automaticamente le tue classi dopo l'uso.

Differenza tra le funzioni _once e senza le funzioni _once: senza il codice _once verrà nuovamente incluso mentre con le funzioni _once PHP tiene traccia dei file inclusi e lo includerà solo una volta.

Differenza tra richiedi e includi: se non viene trovato un file richiesto, PHP emetterà un errore fatale mentre per includere verrà emesso solo un avviso.

include() genererà un avviso se non può includere il file, ma verrà eseguito il resto dello script.

require()lancerà un E_COMPILE_ERRORe fermerà lo script se non può includere il file.

Le funzioni include_once()e require_once()non includeranno il file una seconda volta se è già stato incluso.

Vedere le seguenti pagine di documentazione:

• includere
• richiedere
• include_once
• require_once

Ogni volta che si utilizza require_once()può essere utilizzato in un file per includere un altro file quando è necessario il file chiamato solo una volta nel file corrente. Qui nell'esempio ho un test1.php.

<?php  
echo "today is:".date("Y-m-d");  
?>  

e in un altro file che ho chiamato test2.php

<?php  
require_once('test1.php');  
require_once('test1.php');  
?>

mentre stai guardando la m che richiede il file test1 due volte, ma il file includerà il test1 una volta e per la chiamata alla seconda volta questo verrà ignorato. E senza fermarsi visualizzerà l'output una sola volta.

Ogni volta che stai usando 'include_once () `può essere usato in un file per includere un altro file quando hai bisogno del file chiamato più di una volta nel file corrente. Qui nell'esempio ho un file chiamato test3.php.

<?php  
echo "today is:".date("Y-m-d");  
?> 

E in un altro file che ho chiamato test4.php

<?php  
include_once('test3.php');  
include_once('test3.php');  
?>

mentre stai guardando la m incluso il file test3 includerà il file una sola volta ma interromperà l'ulteriore esecuzione.

Usa "include" per i template riutilizzabili di PHP . Utilizzare "richiedi" per le librerie richieste.

"* _once" è carino, perché controlla se il file è già caricato o meno, ma ha senso per me solo in "require_once".

È necessario mantenere le definizioni di classe e funzione organizzate in file.

Utilizzare require_once()per caricare dipendenze (classi, funzioni, costanti).

Utilizzare require()per caricare file simili a modelli .

Utilizzare include_once()per caricare dipendenze opzionali (classi, funzioni, costanti).

Utilizzare include()per caricare file facoltativi simili a modelli .

Una risposta dopo 7 anni per il 2018

Questa domanda è stata posta sette anni fa e nessuna delle risposte fornisce un aiuto pratico per la domanda. Nella moderna programmazione PHP usi principalmente required_onceuna sola volta per includere la tua classe di caricatore automatico (caricatore automatico del compositore spesso) e caricherà tutte le tue classi e funzioni (i file di funzioni devono essere aggiunti esplicitamente al composer.jsonfile per essere disponibili in tutti gli altri file). Se per qualsiasi motivo la tua classe non è caricabile dal caricatore automatico, la usi require_onceper caricarla.

Ci sono alcune occasioni che dobbiamo usare require. Ad esempio, se si dispone di una definizione di array molto grande e non si desidera aggiungerla al codice sorgente della definizione di classe, è possibile:

 <?php
// arr.php
return ['x'=>'y'];

 <?php
//main.php
$arr= require 'arry.php'

Se il file che intendi includere contiene qualcosa di eseguibile o dichiara alcune variabili che devi quasi sempre usare require, perché se usi a require_onceparte il primo posto il tuo codice non verrà eseguito e / o le tue variabili non verranno avviate silenziosamente, causando bug che sono assolutamente difficili da individuare.

Non v'è alcun caso d'uso pratico per includee include_oncedavvero.

La differenza sta nell'errore generato dai comandi. Con require, il file che si desidera utilizzare è veramente richiesto e quindi genera un E_ERRORse non viene trovato.

require()è identico a include() meno che in caso di fallimento produrrà anche un E_ERROR errore di livello fatale .

includegenera un E_WARNINGerrore solo se fallisce, che è più o meno silenzioso.

Quindi usalo se il file è richiesto per far funzionare il codice rimanente e vuoi che lo script fallisca il file non è disponibile.

Per *_once():

include_once() può essere utilizzato nei casi in cui lo stesso file può essere incluso e valutato più di una volta durante una particolare esecuzione di uno script, quindi in questo caso può aiutare a evitare problemi come ridefinizioni delle funzioni, riassegnazioni di valori variabili, ecc.

Lo stesso vale require_once()ovviamente.

Riferimento: require(),include_once()

Con request il file deve esistere, in caso contrario verrà visualizzato un errore; mentre con include - se il file non esiste, la pagina continuerà a caricarsi.

Richiedono parti critiche, come l'autorizzazione e includi tutte le altre.

Le inclusioni multiple sono solo un pessimo design e devono essere assolutamente evitate. Quindi, * _once non ha molta importanza.

Includi / Richiedi puoi includere lo stesso file più di una volta anche:

require () è identico a include () tranne che in caso di errore produrrà anche un errore di livello E_COMPILE_ERROR fatale. In altre parole, interromperà lo script mentre include () emette solo un avviso (E_WARNING) che consente allo script di continuare.

Require_once / include_once

è identico per includere / richiedere tranne PHP verificherà se il file è già stato incluso e, in tal caso, non includerlo (richiederlo) di nuovo.

include()genererà un avviso quando non trova un file, ma require_once()genererà un errore irreversibile.

Un'altra cosa è se il file è incluso prima. Quindi require_once()non lo includerà di nuovo.

Stavo usando la funzione come di seguito:

function doSomething() {
    require_once(xyz.php);
    ....
}

Ci sono stati valori costanti dichiarati in xyz.php.

Devo chiamare questa funzione doSomething () da un altro file di script PHP.

Ma ho osservato il comportamento mentre chiamavo questa funzione in un ciclo, per la prima iterazione doSomething () stava ottenendo valori costanti all'interno xyz.php, ma in seguito ogni iterazione doSomething()non era in grado di ottenere i valori costanti dichiarati xyz.php.

Ho risolto il mio problema passando da require_once()a include(), il doSomething()codice aggiornato è il seguente:

function doSomething() {
    include(xyz.php);
    ....
}

Ora ogni chiamata di iterazione doSomething()ottiene i valori costanti definiti in xyz.php.

Dal manuale :

require()è identico a include()meno che in caso di fallimento produrrà anche un E_COMPILE_ERRORerrore di livello fatale . In altre parole, interromperà lo script mentre include()emette solo un avviso ( E_WARNING) che consente allo script di continuare.

Lo stesso vale per le _once()varianti.

PSR-0 / PSR-4Nell'era dei caricatori automatici, potrebbe essere completamente inutile utilizzare una qualsiasi delle istruzioni se tutto ciò che serve è rendere alcune funzioni / classi disponibili per il proprio codice (ovviamente, è comunque necessario require_oncecaricarsi automaticamente nel file di bootstrap e nei includemodelli se si uso ancora PHP come motore di template).

1. Quando si dovrebbe usare requireo include?

   Le funzioni requiree includesvolgono la stessa attività, ovvero includono e valutano il file specificato, ma la differenza è requirecauserà un errore irreversibile quando il percorso del file specificato non è valido o per qualsiasi errore, mentre includegenererà un avviso e continuerà l'esecuzione del codice.

   Quindi è possibile utilizzare la requirefunzione nel caso in cui il file che si sta tentando di includere sia il cuore del sistema e possa avere un impatto enorme sul resto del codice e si può usare la includefunzione quando il file che si sta tentando di includere è un file semplice contenente un codice meno importante.

   E la mia raccomandazione personale (per il codice meno importante) è quella di cercare la requirefunzione ovunque nel tuo codice mentre è in fase di sviluppo in modo che tu possa eseguire il debug del codice e in seguito sostituire tutte le requirefunzioni con la includefunzione prima di spostarla in produzione in modo tale che se manchi eventuali bug non influiranno sull'utente finale e il resto del codice verrà eseguito correttamente ...

2. Quando si dovrebbe usare require_onceo require?

   La differenza di base tra requiree require_onceis require_oncecontrollerà se il file è già incluso o meno se è già incluso, quindi non includerà il file mentre la requirefunzione includerà il file indipendentemente dal fatto che il file sia già incluso o meno.

   Quindi, nei casi in cui si desidera includere ancora e ancora una parte del codice, utilizzare la requirefunzione, mentre se si desidera includere un codice una sola volta nel codice, utilizzare require_once.

1. Utilizzare la funzione di richiesta quando è necessario caricare qualsiasi classe, funzione o dipendenza.

2. Utilizzare la funzione include quando si desidera caricare file in stile modello

Se sei ancora confuso, usa solo use_once per sempre.

Sono tutti modi per includere file.

Richiedi significa che ne ha bisogno. Require_once significa che ne avrà bisogno ma lo richiede solo una volta. Includi significa che includerà un file ma non è necessario per continuare.

Esempi:

Require 'filename'
Require_once 'filename'
Include 'filename'

C'è anche una funzione include_once che include un file una volta.

Include_once 'filename'

Non usare maiuscole dove ho mentre sto scrivendo dal mio telefono.

una cosa che ho notato, quando uso include posso accedere solo alle funzioni dei file inclusi dal file che lo ha incluso. Con Require_once, posso eseguire quella funzione in un secondo file required_once.

anche: consiglio di aggiungere

if(file_exists($RequiredFile)){
    require_once($RequiredFile);
}else{
  die('Error: File Does Not Exist');
}

Perché quando request_once uccide la pagina, a volte può fare eco alla directory dei file del tuo sito web

Ecco una funzione personalizzata che ho creato per richiedere i file:

function addFile($file, $type = 'php', $important=false){
    //site-content is a directory where I store all the files that I plan to require_once
    //the site-content directory has "deny from all" in its .htaccess file to block direct connections
    if($type && file_exists('site-content/'.$file.'.'.$type) && !is_dir('site-content/'.$file.'.'.$type)){
        //!is_dir checks that the file is not a folder
        require_once('site-content/'.$file.'.'.$type);
        return 'site-content/'.$file.'.'.$type;
    }else if(!$type && file_exists('site-content/'.$file) && !is_dir('site-content/'.$file)){
        //if you set "$type=false" you can add the file type (.php, .ect) to the end of the "$file" (useful for requiring files named after changing vars)
        require_once('site-content/'.$file);
        return 'site-content/'.$file;
    }else if($important){
        //if you set $important to true, the function will kill the page (which also prevents accidentally echoing the main directory path of the server)
        die('Server Error: Files Missing');
        return false;
    }else{
        //the function returns false if the file does not exist, so you can check if your functions were successfully added
        return false;
    }
}

esempio di utilizzo:

$success = addFile('functions/common');

if($success){
    commonFunction();
}else{
    fallbackFunction();
}

Fondamentalmente, se hai bisogno di un percorso sbagliato, PHP genera un errore fatale e viene chiamata la funzione di spegnimento, ma quando includi un percorso sbagliato, PHP continuerà l'esecuzione, ma mostrerà solo un avviso che il file non esiste.

Dalla parola inglese richiede , a PHP viene detto che l'esecuzione della pagina o del file dipende dal file richiesto.

Dalla mia esperienza, è normale richiedere file importanti come file di configurazione, classi di database e altre utilità importanti.

Spesso si tratta di caricare una libreria client in modo condizionale, oppure procedere e caricarlo indipendentemente dal fatto che lo si utilizzi o meno.

Ecco un esempio concreto; elaborando ciò che diceva pcj.

Supponi di avere un file di configurazione che memorizza il nome utente e la password del tuo database (conf.php):

<?php
//my site configuration file

//For Database
$location='localhost';
$dbuser='yourname';
$userpw='yourpassword';
$database='nameofdatabase';
?>

E una classe con una funzione statica che utilizza il database:

<?php
class UsedInLoop {
    public static function databaseQuery(){
        require(/path/to/conf.php);                //require_once will not work here
        $db = new mysqli($location, $dbuser, $userpw, $database);
        //yada yada yada
    }
}
?>

E quella funzione statica viene utilizzata all'interno di un'altra funzione che viene chiamata iterativamente all'interno di un ciclo:

<?php
require_once('path/to/arbitraryObject.php');  //either will likely be OK at this level
$obj = new arbitraryObject();
foreach($array as $element){
    $obj->myFunction();
}
?>

Puoi richiedere / includere la classe solo una volta. Se lo richiedi / includilo in ogni iterazione del tuo ciclo, otterrai un errore. Tuttavia, è necessario includere il file conf ogni volta che viene chiamata la funzione statica.

<?php
class arbitraryObject {
    public function myFunction(){
        require_once(/path/to/UsedInLoop.php);   //This must be require_once. require() will not work
        UsedInLoop::databaseQuery();
    }
}
?>

Naturalmente, spostarlo al di fuori della funzione potrebbe essere una soluzione a questo problema:

<?php
require(/path/to/UsedInLoop.php);   //now require() is fine   
class arbitraryObject {
    public function myFunction(){
        UsedInLoop::databaseQuery();
    }
}
?>

A meno che non ti preoccupi del sovraccarico di caricare una classe che potrebbe essere utilizzata solo in determinate condizioni e non vuoi caricarla quando non lo è.

requireha un sovraccarico maggiore di include, poiché deve prima analizzare il file. La sostituzione requirescon includesè spesso una buona tecnica di ottimizzazione.

Basta usare richiedi e includi.

Perché pensare a come lavorare con include_once o request_once. Questo è alla ricerca di dati di registro che salvano i file PHP inclusi o richiesti. Quindi è più lento di includere e richiedere.

if (!defined(php)) {
    include 'php';
    define(php, 1);
}

Basta usare così ...