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

En PHP:

  • Quand devrais-je utiliser require vs include ?
  • Quand devrais-je utiliser require_once vs. include_once ?

    Il existe également des require et des include_once .

    Donc, votre question devrait être …

    1. Quand devrais-je utiliser require vs include ?
    2. Quand dois-je utiliser require_once vs require

    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 survient, 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’incluez pas à nouveau.

    Utilisation

    • exiger
      lorsque le fichier est requirejs 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.

    • Demandez une fois
      Lorsque le fichier contient un contenu qui produirait une erreur lors de l’inclusion ultérieure, par exemple, function important() { /* important code */} est absolument nécessaire dans votre application, mais les fonctions ne pouvant pas être redéclarées ne devraient plus être incluses.

    • inclure lorsque le fichier n’est pas requirejs et que le stream de l’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 scope actuelle ou quelque chose

    • include_once
      les dépendances facultatives qui produiraient des erreurs lors du chargement ultérieur ou peut-être l’inclusion de fichiers à distance 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 utiliser quoi.

    Ma suggestion est de simplement utiliser require_once 99,9% du temps.

    L’utilisation de require ou include implique plutôt que votre code ne soit pas réutilisable ailleurs, c’est-à-dire que les scripts que vous importez exécutent du code au lieu de rendre disponibles une bibliothèque de classes ou de fonctions.

    Si vous en avez besoin / y compris du code qui s’exécute sur-le-champ, c’est du code procédural, et vous devez apprendre à connaître un nouveau paradigme . Comme la programmation orientée object, la programmation basée sur les fonctions ou la functional programming.

    Si vous faites déjà de la programmation OO ou fonctionnelle, utiliser include_once retardera la plupart du temps où vous trouvez des bogues / erreurs dans la stack. 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 demandant 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 à quoi vous ne vous attendez pas est disponible, utilisez simplement require_once .

    Sinon, dans la POO moderne, il vous suffit de charger automatiquement vos cours lors de l’utilisation.

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

    Différence entre require et include: Si un fichier requirejs 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 rest du script s’exécutera.

    require() lancera un E_COMPILE_ERROR et arrêtera le script s’il ne peut pas inclure le fichier.

    Les fonctions include_once() et require_once() n’incluent pas le fichier une seconde fois s’il a déjà été inclus.

    Voir les pages de documentation suivantes:

    • comprendre
    • exiger
    • include_once
    • Demandez une fois

    Chaque fois que vous utilisez require_once() pouvez l’utiliser dans un fichier pour inclure un autre fichier lorsque vous avez besoin du fichier appelé une seule fois dans le fichier en cours. Ici, dans l’exemple, j’ai un test1.php.

      

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

      

    comme vous observez le m nécessitant le fichier test1 à deux resockets, mais le fichier inclura le test1 une fois et pour l’appel à la deuxième fois cela sera ignoré. Et sans arrêter affichera la sortie une seule fois.

    Chaque fois que vous utilisez «include_once ()», vous pouvez utiliser un fichier pour inclure un autre fichier lorsque vous avez besoin du fichier appelé plusieurs fois dans le fichier en cours. Ici, dans l’exemple, j’ai un fichier nommé test3.php.

      

    Et dans un autre fichier que j’ai appelé test4.php

      

    comme vous regardez le m incluant le fichier test3 inclura le fichier une seule fois mais arrêtera l’exécution ultérieure.

    Utilisez “include” pour les modèles PHP réutilisables. Utilisez “require” pour les bibliothèques requirejses.

    “* _once” est bien, car il vérifie si le fichier est déjà chargé ou non, mais cela n’a de sens que pour “require_once”.

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

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

    include génère uniquement une erreur E_WARNING si elle échoue, ce qui est plus ou moins silencieux.

    Donc, utilisez-le si le fichier est requirejs pour faire fonctionner le code restant et si vous voulez 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é plus d’une fois lors d’une exécution particulière d’un script. Dans ce cas, il peut éviter des problèmes tels que les redéfinitions de fonctions, les réaffectations de valeurs variables, etc.

    Même chose pour require_once() bien sûr.


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

    Avec obligatoire, le fichier doit exister, sinon, une erreur s’affichera; alors qu’avec include – si le fichier n’existe pas alors la page continuera à se charger.

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

    Les inclusions multiples ne sont que de très mauvaises conceptions et doivent être évitées. Donc, * _once ne compte pas vraiment.

    require produira une erreur fatale (E_COMPILE_ERROR) et arrêtera le script.

    include ne produira qu’un avertissement (E_WARNING) et le script continuera.

    L’instruction require_once peut être utilisée pour inclure un fichier PHP dans un autre lorsque vous devez inclure le fichier appelé plus d’une fois.

    Si a.php est un script PHP appelant b.php avec une instruction require_once () et ne trouve pas b.php, a.php arrête l’exécution, provoquant une erreur fatale.

    Inclure / Exiger vous pouvez inclure le même fichier plusieurs fois également:

    require () est identique à include () sauf 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 à include / require sauf que PHP vérifiera si le fichier a déjà été inclus, et si oui, ne l’inclut pas à nouveau.

    Vous devez conserver les définitions de classes et de fonctions organisées en fichiers.

    Utilisez require_once pour charger des dépendances (classes, fonctions, constantes).

    Utilisez obligatoire pour charger des fichiers de type template.

    comprendre()

    Il comprend un fichier spécifié. Il produira un avertissement s’il ne parvient pas à trouver le fichier et exécute les scripts restants

    exiger()

    Il comprend un fichier spécifié. Cela produira une erreur fatale si elle ne parvient pas à trouver le fichier et arrête l’exécution

    include_once ()

    Il comprend un fichier spécifié. un fichier a déjà été inclus, il ne sera plus inclus. Il produira un avertissement s’il ne parvient pas à trouver le fichier et à exécuter les scripts restants.

    Demandez une fois()

    Il comprend un fichier spécifié. un fichier a déjà été inclus, il ne sera plus inclus. Cela produira une erreur fatale si elle ne parvient pas à trouver le fichier et arrête l’exécution.

    A partir du manuel :

    require() est identique à include() sauf 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.

    La même chose est vraie pour les variantes _once() .

    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. Alors require_once() ne l’inclura plus.

    J’utilisais la fonction 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 () depuis un autre fichier de script PHP.

    Mais j’ai observé un comportement en appelant cette fonction dans une boucle, pour la première itération, doSomething () recevait des valeurs constantes dans xyz.php , mais plus tard, chaque itération doSomething() était incapable d’obtenir les valeurs constantes déclarées dans xyz.php .

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

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

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

    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 une aide pratique pour la question. Dans la programmation PHP moderne, vous utilisez principalement required_once une seule fois pour inclure votre classe d’autoloader (composeur automatique souvent), et cela chargera toutes vos classes et fonctions (les fichiers de fonctions doivent être explicitement ajoutés au fichier composer.json pour être disponibles dans tous les fichiers). autres fichiers). Si pour une raison quelconque, votre classe n’est pas chargeable depuis l’autoloader, vous utilisez require_once pour le charger.

    Ces jours-ci, vous utilisez uniquement pour diviser une grande partie d’un fichier PHP. C’est principalement une grande définition de tableau. Dans de tels cas, vous n’utilisez que require not require_once .

      'y'];  

    Si le fichier que vous avez l'intention d'utiliser contient quelque chose d'exécutable ou déclare des variables dont vous avez presque toujours besoin, car si vous utilisez require_once dans un autre endroit, votre code ne sera pas exécuté et / ou vos variables ne seront pas lancées en silence. qui sont absolument difficiles à cerner.

    Il n'y a pas de cas d'utilisation pratique pour include et include_once vraiment.

    À l’époque des chargeurs automatiques PSR-0 / PSR-4 il n’est peut-être pas nécessaire d’utiliser l’une des instructions si tout ce dont vous avez besoin est de rendre certaines fonctions / classes disponibles dans votre code (bien sûr, vous devez toujours fichier bootstrap et include modèles si vous utilisez toujours PHP comme moteur de template).

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

    2. Utilisez la fonction include lorsque vous souhaitez charger un fichier de style gabarit

    Si vous êtes encore confus, utilisez simplement require_once pour tout le temps.

    1. Quand faut-il utiliser ou include une utilisation?

      Les fonctions require et include effectuent la même tâche, c.-à-d. Incluent et évaluent le fichier spécifié, mais la différence require entraînera une erreur fatale lorsque l’emplacement de fichier spécifié est invalide ou pour toute erreur alors que include générera un avertissement et continuera l’exécution du code .

      Vous pouvez donc utiliser la fonction require 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 rest du code et vous pouvez utiliser la fonction include lorsque le fichier que vous essayez d’inclure est un fichier simple contenant du code moins important.

      Et ma recommandation personnelle (pour un code moins important) est d’utiliser la fonction de require partout dans votre code alors qu’il est en phase de développement, de sorte que vous puissiez déboguer le code et remplacer toutes require fonctions require par include fonction include Si vous manquez des bugs, cela n’affectera pas l’utilisateur final et le rest du code s’exécutera correctement …

    2. Quand faut-il utiliser require_once ou require_once ?

      La différence fondamentale entre require et require_once est que require_once vérifiera si le fichier est déjà inclus ou non s’il est déjà inclus, alors il n’inclura pas le fichier alors que la fonction require inclura le fichier, que le fichier soit déjà inclus ou non.

      Donc, dans les cas où vous souhaitez inclure à nouveau du code, utilisez la fonction require , alors que si vous souhaitez inclure du code une seule fois dans votre code, utilisez require_once .

    Ce sont tous des moyens d’inclure des fichiers:

    Exiger signifie qu’il en a besoin. Require_once signifie qu’il en aura besoin mais qu’il ne le nécessite qu’une fois. Include signifie qu’il va inclure un fichier mais qu’il n’en a pas besoin pour continuer.

    Exemples:

    Exiger ‘filename’ Require_once ‘filename’ Inclure ‘filename’

    Il y a aussi une fonction include_once qui inclut un fichier une fois.

    Include_once ‘filename’

    N’utilisez pas de lettres majuscules lorsque je tape depuis mon téléphone.

    Merci pour votre temps.

    Fondamentalement, si vous avez besoin d’un chemin incorrect, PHP génère une erreur fatale et la fonction d’arrêt est appelée, mais lorsque vous incluez un chemin incorrect, PHP continue son exécution, mais affiche simplement un avertissement indiquant que le fichier n’existe pas.

    D’après le mot anglais requirejs , PHP est informé que l’exécution de la page ou du fichier dépend du fichier requirejs.

    D’après mon expérience, il est normal d’avoir besoin de fichiers importants tels que des fichiers de configuration, des classes de firebase database et d’autres utilitaires importants.

    On m’a demandé l’autre jour quelle est la différence entre inclure et exiger en PHP. Ils semblent fonctionner de la même manière mais il y a une différence significative.

    Tout d’abord, ni inclure ni exiger sont des fonctions, ce sont des constructions. Il n’est donc pas nécessaire de les appeler en utilisant des parenthèses comme include (‘file.php’); au lieu de cela, il est préférable d’utiliser include ‘file.php’.

    La différence entre inclure et exiger se produit lorsque le fichier à inclure ne peut pas être trouvé: include émet un avertissement (E_WARNING) et le script continue, alors que require émet une erreur fatale (E_COMPILE_ERROR) et arrête le script. Si le fichier à inclure est essentiel au bon déroulement du script, vous devez utiliser obligatoirement.

    Vous devez prendre en compte toutes les erreurs fatales générées par le besoin au cours du processus de développement et pouvoir les résoudre avant de lancer votre script dans la nature. Cependant, vous pouvez envisager d’utiliser include pour mettre en place un plan B si ce n’est pas si simple: –

      

    Dans cet exemple, include est utilisé pour saisir 'fichier.php', mais si cela échoue, nous surpressons l'avertissement en utilisant @ et exécutons un code alternatif. include renverra false si le fichier est introuvable.

    include_once et require_once se comportent comme include et require respectivement, sauf qu'ils n'incluent que le fichier s'il n'a pas déjà été inclus. Sinon, ils jettent le même genre d'erreurs.

    require a plus de surcharge que include , car il doit d’abord parsingr le fichier. Remplacer les requires par des includes est souvent une bonne technique d’optimisation.

    Juste utiliser besoin et inclure.

    Parce que pensez comment travailler avec include_once ou require_once. Cela recherche des données de journal qui sauvegardent les fichiers PHP inclus ou requirejs. C’est donc plus lent que l’inclusion et l’exigence.

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

    Juste en utilisant comme ça …