Différence entre require, include, require_once et include_once?

En PHP:

• Quand dois-je utiliser requirevs include?
• Quand dois-je utiliser require_oncevs include_once?

Il y en a requireet include_onceaussi.

Votre question devrait donc être ...

1. Quand dois-je utiliser requirevs include?
2. Quand dois-je utiliser require_oncevsrequire

La réponse à 1 est décrite ici .

La fonction require () est identique à include (), sauf qu'elle gère les erreurs différemment. Si une erreur se produit, la fonction include () génère un avertissement, mais le script continuera son exécution. Le require () génère une erreur fatale et le script s'arrête.

La réponse à 2 peut être trouvée ici .

L'instruction require_once () est identique à require () sauf que PHP vérifiera si le fichier a déjà été inclus, et si c'est le cas, ne l'inclut pas (require) à nouveau.

Utilisation

• exiger
  lorsque le fichier est requis par votre application, par exemple un modèle de message important ou un fichier contenant des variables de configuration sans lesquelles l'application se briserait.

• require_once
  lorsque le fichier contient du contenu qui produirait une erreur lors de l'inclusion ultérieure, par exemple function important() { /* important code */}est définitivement nécessaire dans votre application, mais comme les fonctions ne peuvent pas être redéclarées, elles ne devraient pas être incluses à nouveau.

• inclure lorsque le fichier n'est pas requis et le flux d'application doit continuer lorsqu'il n'est pas trouvé, par exemple
  idéal pour les modèles référençant des variables de la portée actuelle ou quelque chose

• 
  les dépendances optionnelles include_once qui produiraient des erreurs lors du chargement ultérieur ou peut-être l'inclusion de fichiers distants que vous ne voulez pas voir se produire deux fois en raison de la surcharge HTTP

Mais en gros, c'est à vous de décider quand l'utiliser.

Ma suggestion est de n'utiliser que require_once99,9% du temps.

Utiliser requireou includeimplique à la place que votre code n'est pas réutilisable ailleurs, c'est-à-dire que les scripts que vous tirez exécutent réellement du code au lieu de rendre disponible une classe ou certaines bibliothèques de fonctions.

Si vous avez besoin / y compris du code qui s'exécute sur place, c'est du code procédural, et vous devez apprendre à connaître un nouveau paradigme . Comme la programmation orientée objet, la programmation basée sur les fonctions ou la programmation fonctionnelle.

Si vous faites déjà de la programmation OO ou fonctionnelle, l'utilisation include_onceva principalement retarder où dans la pile vous trouvez des bugs / erreurs. Voulez-vous savoir que la fonction do_cool_stuff()n'est pas disponible lorsque vous allez l'appeler plus tard, ou au moment où vous vous attendez à ce qu'elle soit disponible en nécessitant la bibliothèque? En règle générale, il est préférable de savoir immédiatement si quelque chose dont vous avez besoin et auquel vous vous attendez n'est pas disponible, alors utilisez-le require_once.

Alternativement, dans la POO moderne, il suffit de charger automatiquement vos classes lors de leur utilisation.

Différence entre les fonctions _once et sans fonctions _once: sans le code _once sera à nouveau inclus alors qu'avec les fonctions _once, PHP garde une trace des fichiers inclus et ne l'inclura qu'une seule fois.

Différence entre require et include: si un fichier requis n'est pas trouvé, PHP émettra une erreur fatale alors que pour include, seul un avertissement sera émis.

include() lancera un avertissement s'il ne peut pas inclure le fichier, mais le reste du script s'exécutera.

require() jettera un E_COMPILE_ERROR et arrêter le script s'il ne peut pas inclure le fichier.

Le include_once()etrequire_once() fonctions n'incluront pas le fichier une deuxième fois s'il a déjà été inclus.

Consultez les pages de documentation suivantes:

• comprendre
• exiger
• include_once
• Demandez une fois

Chaque fois que vous utilisez require_once()peut être utilisé dans un fichier pour inclure un autre fichier lorsque vous avez besoin du fichier appelé une seule fois dans le fichier actuel. Ici, dans l'exemple, j'ai un test1.php.

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

et dans un autre fichier que j'ai nommé test2.php

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

car vous regardez le m nécessitant deux fois le fichier test1 mais le fichier inclura le test1 une fois et pour un deuxième appel, cela sera ignoré. Et sans s'arrêter affichera la sortie une seule fois.

Chaque fois que vous utilisez 'include_once () `peut être utilisé dans un fichier pour inclure un autre fichier lorsque vous avez besoin du fichier appelé plus d'une fois dans le fichier actuel. Ici, dans l'exemple, j'ai un fichier nommé test3.php.

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

Et dans un autre fichier que j'ai nommé test4.php

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

lorsque vous regardez le m, y compris le fichier test3, le fichier sera inclus une seule fois mais arrêtera l'exécution.

Utilisez "include" pour les modèles PHP réutilisables . Utilisez "require" pour les bibliothèques requises.

"* _once" est agréable, car il vérifie si le fichier est déjà chargé ou non, mais cela n'a de sens que pour moi dans "require_once".

Vous devez conserver les définitions de classe et de fonction organisées dans des fichiers.

Permet require_once()de charger des dépendances (classes, fonctions, constantes).

Utilisez require()pour charger des fichiers de type modèle .

Permet include_once()de charger des dépendances optionnelles (classes, fonctions, constantes).

Utilisez include()pour charger des fichiers de type modèle en option .

Une réponse après 7 ans pour 2018

Cette question a été posée il y a sept ans, et aucune des réponses ne fournit d'aide pratique à la question. Dans la programmation PHP moderne, vous n'utilisez principalement required_oncequ'une seule fois pour inclure votre classe d'autochargeur (autochargeur de compositeur souvent), et il chargera toutes vos classes et fonctions (les fichiers de fonctions doivent être explicitement ajoutés au composer.jsonfichier pour être disponibles dans tous les autres fichiers). Si, pour une raison quelconque, votre classe ne peut pas être require_oncechargée à partir du chargeur automatique, vous l'utilisez pour la charger.

Il y a des occasions que nous devons utiliser require. Par exemple, si vous avez une très grande définition de tableau et que vous ne voulez pas l'ajouter à votre code source de définition de classe, vous pouvez:

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

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

Si le fichier que vous avez l'intention d'inclure contient quelque chose d'exécutable ou déclare certaines variables que vous devez presque toujours utiliser require, car si vous utilisez en require_oncedehors du premier endroit, votre code ne sera pas exécuté et / ou vos variables ne se lanceront pas silencieusement, provoquant des bogues qui sont absolument difficiles à cerner.

Il n'y a pas de cas d'utilisation pratique pour includeet include_oncevraiment.

La différence réside dans l'erreur générée par les commandes. Avec require, le fichier que vous souhaitez utiliser est vraiment nécessaire et génère donc un E_ERRORs'il n'est pas trouvé.

require()est identique, include() sauf en cas d'échec, il produira également une E_ERROR erreur de niveau fatale .

includene génère une E_WARNINGerreur qu'en cas d'échec plus ou moins silencieuse.

Utilisez-le donc si le fichier est requis pour faire fonctionner le code restant et que vous souhaitez que le script échoue, le fichier n'est pas disponible.

Pour *_once():

include_once() peut être utilisé dans les cas où le même fichier peut être inclus et évalué plusieurs fois au cours d'une exécution particulière d'un script, dans ce cas, cela peut aider à éviter des problèmes tels que les redéfinitions de fonctions, les réaffectations de valeurs variables, etc.

Il en va require_once()de même bien sûr.

Référence: require(),include_once()

Avec require, le fichier doit exister, sinon, une erreur s'affichera; alors qu'avec include - si le fichier n'existe pas alors la page continuera son chargement.

Exiger des pièces critiques, comme l'autorisation et inclure toutes les autres.

Les inclusions multiples sont simplement de très mauvaise conception et doivent être évitées du tout. Donc, * _once n'a pas vraiment d'importance.

Inclure / exiger que vous puissiez également inclure plusieurs fois le même fichier:

require () est identique à include () sauf qu'en cas d'échec, il produira également une erreur fatale de niveau E_COMPILE_ERROR. En d'autres termes, il arrêtera le script alors que include () n'émet qu'un avertissement (E_WARNING) qui permet au script de continuer.

require_once / include_once

est identique à inclure / exiger, sauf que PHP vérifiera si le fichier a déjà été inclus, et si c'est le cas, ne l'inclut pas (à nouveau).

include()générera un avertissement lorsqu'il ne trouvera pas de fichier, mais require_once()générera une erreur fatale.

Une autre chose est si le fichier est inclus avant. Ensuite , require_once()ne comprendra pas encore.

J'utilisais la fonction comme ci-dessous:

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

Il y avait des valeurs constantes déclarées dans xyz.php.

Je dois appeler cette fonction doSomething () à partir d'un autre fichier de script PHP.

Mais j'ai observé un comportement lors de l'appel de cette fonction dans une boucle, pour la première itération, doSomething () obtenait des valeurs constantes à l'intérieur xyz.php, mais plus tard chaque itération doSomething()n'a pas pu obtenir les valeurs constantes déclarées dansxyz.php .

J'ai résolu mon problème en passant de require_once()à include(), le doSomething()code mis à jour est le suivant:

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

Maintenant, chaque itération appelle doSomething() obtient les valeurs constantes définies dans xyz.php.

Du manuel :

require()est identique, include()sauf en cas d'échec, il produira également une E_COMPILE_ERRORerreur de niveau fatale . En d'autres termes, il arrêtera le script alors qu'il include()n'émettra qu'un avertissement ( E_WARNING) qui permettra au script de continuer.

Il en va de même pour les _once()variantes.

À l'ère des PSR-0 / PSR-4chargeurs automatiques, il peut être complètement inutile d'utiliser l'une des instructions si tout ce dont vous avez besoin est de rendre certaines fonctions / classes disponibles pour votre code (bien sûr, vous devez toujours se require_oncecharger automatiquement dans votre fichier de démarrage et vos includemodèles si vous toujours utiliser PHP comme moteur de modèle).

1. Quand faut-il utiliser requireou include?

   Les fonctions requireet includeeffectuent la même tâche, c'est-à-dire incluent et évaluent le fichier spécifié, mais la différence est requireprovoquera une erreur fatale lorsque l'emplacement du fichier spécifié n'est pas valide ou pour toute erreur alors que includegénérera un avertissement et continuera l'exécution du code.

   Vous pouvez donc utiliser la requirefonction dans le cas où le fichier que vous essayez d'inclure est le cœur du système et peut avoir un impact énorme sur le reste du code et vous pouvez utiliser la includefonction lorsque le fichier que vous essayez d'inclure est un fichier simple contenant du code moins important.

   Et ma recommandation personnelle (pour le code moins important) est d'aller chercher la requirefonction partout dans votre code pendant qu'il est en phase de développement de sorte que vous puissiez déboguer le code et ensuite remplacer toutes les requirefonctions par includefonction avant de le déplacer en production de sorte que si vous manquez tout bogue n'affectera pas l'utilisateur final et le reste du code s'exécute correctement ...

2. Quand faut-il utiliser require_onceourequire?

   La différence de base entre requireet require_onceest de require_oncevérifier si le fichier est déjà inclus ou non s'il l'est déjà alors il n'inclura pas le fichier alors que lerequire fonction inclura le fichier indépendamment du fait que le fichier soit déjà inclus ou non.

   Donc, dans les cas où vous souhaitez inclure encore et encore du code, utilisez la requirefonction alors que si vous souhaitez inclure du code une seule fois dans votre code, utilisez require_once.

1. Utilisez la fonction require lorsque vous devez charger une classe, une fonction ou une dépendance.

2. Utilisez la fonction d' inclusion lorsque vous souhaitez charger un fichier de style modèle

Si vous êtes toujours confus, utilisez simplement require_once pour toujours.

Ce sont toutes des façons d'inclure des fichiers.

Exiger signifie qu'il en a besoin. Require_once signifie qu'il en aura besoin mais ne l'exige qu'une seule fois. Inclure signifie qu'il inclura un fichier mais qu'il n'en a pas besoin pour continuer.

Exemples:

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

Il existe également une fonction include_once qui inclut une fois un fichier.

Include_once 'filename'

N'utilisez pas de majuscules là où je les ai car je tape à partir de mon téléphone.

une chose que j'ai remarquée, lorsque j'utilise include, je ne peux accéder aux fonctions des fichiers inclus qu'à partir du fichier qui l'a inclus. Avec require_once, je peux exécuter cette fonction dans un deuxième fichier required_once.

aussi: je recommande d'ajouter

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

Parce que lorsque require_once tue la page, il peut parfois faire écho au répertoire des fichiers de votre site Web

Voici une fonction personnalisée que j'ai créée pour exiger des fichiers:

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;
    }
}

exemple d'utilisation:

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

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

Fondamentalement, si vous avez besoin d'un mauvais chemin, PHP génère une erreur fatale et la fonction d'arrêt est appelée, mais lorsque vous incluez un mauvais chemin, PHP continuera l'exécution, mais il affichera simplement un avertissement indiquant que le fichier n'existe pas.

Du mot anglais require , PHP est informé que l'exécution de la page ou du fichier dépend du fichier requis.

D'après mon expérience, il est normal d'exiger des fichiers importants tels que des fichiers de configuration, des classes de base de données et d'autres utilitaires importants.

Il s'agit souvent de savoir si vous souhaitez charger une bibliothèque cliente de manière conditionnelle, ou continuer et la charger, que vous l'utilisiez ou non.

Voici un exemple concret; élaborer sur ce que PCJ a dit.

Supposons que vous ayez un fichier de configuration stockant votre nom d'utilisateur et votre mot de passe de base de données (conf.php):

<?php
//my site configuration file

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

Et une classe avec une fonction statique qui utilise la base de données:

<?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
    }
}
?>

Et cette fonction statique est utilisée à l'intérieur d'une autre fonction qui est appelée itérativement à l'intérieur d'une boucle:

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

Vous ne pouvez exiger / inclure la classe qu'une seule fois. Si vous l'exigez / l'incluez à chaque itération de votre boucle, vous obtiendrez une erreur. Cependant, vous devez inclure votre fichier conf à chaque appel de la fonction statique.

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

Bien sûr, le déplacer en dehors de la fonction pourrait être une solution à ce problème:

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

À moins que vous ne soyez préoccupé par la surcharge de chargement d'une classe qui ne peut être utilisée que dans certaines conditions et que vous ne souhaitez pas la charger lorsqu'elle ne l'est pas.

requirea un temps système supérieur à include, car il doit d'abord analyser le fichier. Le remplacement requirespar includesest souvent une bonne technique d'optimisation.

Utilisez simplement require et include.

Parce que pensez à travailler avec include_once ou require_once. Cela recherche des données de journal qui enregistrent les fichiers PHP inclus ou requis. C'est donc plus lent que d'inclure et d'exiger.

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

J'utilise juste comme ça ...