tra - php require_once




Differenza tra require, include, require_once e include_once? (18)

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_once una sola volta per includere la tua classe autoloader (autoloader del compositore spesso) e carica tutte le tue classi e funzioni (i file di funzioni devono essere esplicitamente aggiunti al file composer.json per essere disponibili in tutte altri file). Se per qualsiasi motivo la tua classe non è caricabile dal caricatore automatico, devi utilizzare require_once per caricarla.

In questi giorni si utilizza solo per dividere una grande porzione di un file PHP. Questa è principalmente una grande definizione di array. In questi casi, usi solo non require require_once .

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

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

Se il file che intendi utilizzare contiene qualcosa di eseguibile o dichiara alcune variabili che hai bisogno di usare quasi sempre, perché se usi require_once in un altro posto il tuo codice non verrà eseguito e / o le tue variabili non inizieranno in silenzio, causando bug che sono assolutamente difficili da individuare.

Non vi è alcun caso pratico di utilizzo per include e include_once realtà.

In PHP:

  • Quando dovrei usare require vs. include ?
  • Quando dovrei usare require_once vs. include_once ?

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

  2. Usa la funzione include quando vuoi caricare un file in stile template

Se sei ancora confuso, usa solo require_once per tutto il tempo.


Basta usare richiedono e includi.

Perché pensa come lavorare con include_once o require_once. Questo sta cercando dati di log che salvano inclusi o richiedono file PHP. Quindi è più lento di includere e richiedere.

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

Usando solo così ...


Ci sono anche require e include_once .

Quindi la tua domanda dovrebbe essere ...

  1. Quando dovrei usare require vs. include ?
  2. Quando dovrei usare require_once vs. require

La risposta a 1 è descritta here .

La funzione require () è 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. Require () genera un errore irreversibile e lo script si interrompe.

La risposta a 2 può essere trovata here .

L'istruzione require_once () è identica a require (), eccetto PHP controlla se il file è già stato incluso e, in caso affermativo, non lo include (richiede) di nuovo.


Dal manual :

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

Lo stesso vale per le varianti _once() .


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

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


Il mio suggerimento è di usare require_once 99,9% delle volte.

L'uso di require o include implica che il tuo codice non è riutilizzabile altrove, cioè che gli script che stai inserendo effettivamente eseguono il codice invece di rendere disponibile una classe o alcune librerie di funzioni.

Se è necessario / incluso il codice che viene eseguito sul posto, si tratta di codice procedurale e occorre conoscere un nuovo paradigma . Come la programmazione orientata agli oggetti, la programmazione basata sulle funzioni o la programmazione funzionale.

Se stai già facendo OO o la programmazione funzionale, l'uso di include_once sta per ritardare il punto in cui nello stack trovi bug / errori. Vuoi sapere che la funzione do_cool_stuff() non è disponibile quando vai a chiamarla in seguito, o nel momento in cui ti aspetti che sia disponibile richiedendo la libreria? In genere, è meglio sapere immediatamente se qualcosa di cui hai bisogno e aspettarti non è disponibile, quindi usa solo require_once .

In alternativa, nel moderno OOP, basta autoload le classi in uso.


In breve:

  • include: include un file e lo valuta. PHP emetterà un avviso se il file non viene trovato o non può essere letto.

  • include_once: se si specifica include_once, PHP si accerterà che includa il file solo una volta.

  • richiede: PHP includerà un file e lo valuterà. Se il file non viene trovato o non può essere letto, verrà generato un errore irreversibile.

  • require_once: come per include_once, ma verrà generato un errore fatale invece di un avviso.

Il motivo per non utilizzare include_once () e require_once () per tutto il tempo è un problema di prestazioni. PHP tiene traccia di un elenco di file che sono stati inclusi per supportare la funzionalità di queste funzioni. Ciò richiede memoria, quindi queste funzioni sono piuttosto utilizzate quando sono necessarie e non a favore di includere o richiedere.


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

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

include solo genera un errore E_WARNING se fallisce che è più o meno silenzioso.

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

Per *_once() :

include_once() può essere usato nei casi in cui lo stesso file potrebbe 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 di funzioni, riassegnazioni di valori variabili, ecc.

Lo stesso vale per require_once() ovviamente.

Riferimento: require , php.net/manual/en/function.include-once.php


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 il m che richiede il file test1 due volte ma il file includerà il test1 una volta e per la seconda volta questo verrà ignorato. E senza fermarsi visualizzerà l'output una volta sola.

Ogni volta che usi '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 il m incluso il file test3 includerà il file una volta sola ma interromperà l'ulteriore esecuzione.


Sono tutti modi di includere i file:

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

Esempi:

Richiedi 'nome file' Require_once 'nome file' Include 'nome file'

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

Include_once 'nomefile'

Non usare le lettere maiuscole dove ho mentre sto digitando dal mio telefono.

Grazie per il tuo tempo.


Stavo usando la funzione come di seguito:

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

C'erano 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 di xyz.php , ma in seguito ogni iterazione doSomething() non era in grado di ottenere i valori costanti dichiarati in xyz.php .

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

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

Ora ogni chiamata iterativa a doSomething() ottiene i valori costanti definiti in xyz.php .


Uso

  • require
    quando il file è richiesto dall'applicazione, ad esempio un modello di messaggio importante o un file contenente variabili di configurazione senza il quale l'app si interrompe.

  • here
    quando il file contiene un contenuto che produce un errore nell'inclusione successiva, ad esempio la function important() { /* important code */} è sicuramente necessaria nell'applicazione, ma poiché le funzioni non possono essere ridichiarate non dovrebbero essere incluse di nuovo.

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

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

Ma in fondo, spetta a te quando usare quale.


includere()

Include un file specificato. Produrrà un avvertimento se non riesce a trovare il file ed esegue gli script rimanenti

richiedere()

Include un file specificato. Produrrà un errore fatale se non riesce a trovare il file e interrompe l'esecuzione

include_once ()

Include un file specificato. un file è già stato incluso, non sarà incluso di nuovo. Produrrà un avvertimento se non riesce a trovare il file ed esegue gli script rimanenti.

require_once ()

Include un file specificato. un file è già stato incluso, non sarà incluso di nuovo. Produrrà un errore fatale se non riesce a trovare il file e interrompe l'esecuzione.


PSR-0 / PSR-4 caricatori automatici PSR-0 / PSR-4 può essere completamente inutile utilizzare una qualsiasi delle istruzioni se tutto ciò di cui hai bisogno è di rendere alcune funzioni / classi disponibili per il tuo codice (ovviamente hai ancora bisogno di require_once caricatore automatico nel tuo file di bootstrap e include modelli se usi ancora PHP come motore di template).


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

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


require ha un overhead maggiore rispetto a include , dal momento che deve prima analizzare il file. Sostituire requires con includes è spesso una buona tecnica di ottimizzazione.


require produrrà un errore fatale (E_COMPILE_ERROR) e interromperà lo script.

include produrrà solo un avvertimento (E_WARNING) e lo script continuerà.

L'istruzione require_once può essere utilizzata per includere un file PHP in un altro, quando potrebbe essere necessario includere il file chiamato più di una volta.

Se a.php è uno script PHP che chiama b.php con un'istruzione require_once (), e non trova b.php, a.php interrompe l'esecuzione, causando un errore fatale.





require-once