¿Diferencia entre require, include, require_once e include_once?


Respuestas:


1427

Hay requirey include_oncetambién.

Entonces tu pregunta debería ser ...

  1. ¿Cuándo debo usar requirevs. include?
  2. ¿Cuándo debo usar require_oncevs.require

La respuesta a 1 se describe aquí .

La función require () es idéntica a include (), excepto que maneja los errores de manera diferente. Si se produce un error, la función include () genera una advertencia, pero el script continuará ejecutándose. Require () genera un error fatal y el script se detendrá.

La respuesta a 2 se puede encontrar aquí .

La instrucción require_once () es idéntica a require (), excepto que PHP verificará si el archivo ya ha sido incluido y, de ser así, no lo incluirá (require) nuevamente.


58
Tenga en cuenta que require () se ejecuta más rápido que require_once (), por lo que si está seguro de que no hay duplicados incluye use require ().
dialex

48
@DiAlex, require_once es más lento, pero casi no se puede medir.
contrato del Prof. Falken incumplió el

77
@DiAlex ... y, si resulta que el archivo, de hecho, ya está incluido, entonces require_once()será el más rápido de los dos
Tom

11
@ Prof.Falken ¿En qué circunstancias necesita uno requerir el mismo archivo más de una vez? No puedo pensar en uno dentro de mi mentalidad actual.
Weishi Zeng

17
@WeishiZeng para páginas web, puede haber fragmentos de HTML que desee incluir más de una vez.
James Beninger

406

Utilizar

  • requerirá
    cuando el archivo se requiere por su aplicación, por ejemplo, una plantilla de mensaje importante o un archivo que contiene las variables de configuración sin la cual la aplicación podría romper.

  • require_once
    cuando el archivo contiene contenido que produciría un error en la inclusión posterior, por ejemplo, function important() { /* important code */}definitivamente es necesario en su aplicación, pero dado que las funciones no se pueden volver a declarar, no se deben volver a incluir.

  • incluir cuando no se requiere el archivo y el flujo de la aplicación debe continuar cuando no se encuentra, por ejemplo,
    ideal para plantillas que hacen referencia a variables del alcance actual o algo así

  • include_once
    dependencias opcionales que producirían errores en la carga posterior o tal vez la inclusión remota de archivos que no desea que ocurra dos veces debido a la sobrecarga de HTTP

Pero básicamente, depende de ti cuándo usar cuál.


Tengo una conexión PDO (a la base de datos) . ¿Debo usar cuál? include? include_once? require? require_once?
Shafizadeh

66
Esta debería ser la respuesta aceptada, ya que responde la pregunta en breve y enlaza con el manual oficial, en lugar de que la otra respuesta solo vincule w3schools.
Daniel W.

99
dame una razón por la que lo incluirías si no es necesario?
Francisco Ochoa

1
Estoy usando una plantilla para un diseño de página genérico que tiene secciones como encabezados, columnas, pies de página, etc. Esto me permite servir esa plantilla para cada página en el sitio y solo necesito crear archivos en la estructura de carpetas de la página definiendo qué debe ir a cada una de esas posiciones. Si decido que una página no necesita una barra lateral, simplemente dejo ese archivo en la carpeta de esa página y la plantilla aún funciona bien sin que ese archivo exista.
James Coyle el

301

Mi sugerencia es usar el require_once99.9% del tiempo.

Usar requireo includeen su lugar implica que su código no es reutilizable en otro lugar, es decir, que los scripts que está ejecutando realmente ejecutan código en lugar de poner a disposición una clase o algunas bibliotecas de funciones.

Si necesita / incluye código que se ejecute en el acto, ese es un código de procedimiento, y necesita conocer un nuevo paradigma . Al igual que la programación orientada a objetos, la programación basada en funciones o la programación funcional.

Si ya está haciendo OO o programación funcional, el uso en include_oncesu mayoría va a retrasar en qué parte de la pila encuentra errores / errores. ¿Desea saber que la función do_cool_stuff()no está disponible cuando vaya a llamarla más tarde, o en el momento en que espera que esté disponible al requerir la biblioteca? En general, es mejor saber de inmediato si algo que necesita y espera no está disponible, así que solo úselo require_once.

Alternativamente, en la OOP moderna, solo carga automáticamente tus clases al usarlas.


41
+1 Esta debería ser la respuesta aceptada. Los puntos clave son que la includefamilia es por lo general una absoluta mala idea (porque es bastante raro para ser incluidos archivos que tienen alguna posibilidad de no existir), y que de require_oncey require, se debe utilizar require_oncesi se incluyen los archivos que definen las funciones o clases para ser se usa en otros lugares, o crea instancias de singletons como objetos de conexión de base de datos, y se usa requirepara incluir archivos que hacen cosas inmediatamente cuando se incluyen. En cualquier aplicación web grande, este último tipo de inclusión es inusual.
Mark Amery

77
+1 (tener otra insignia de oro;)) De acuerdo en que require_oncees probable que el candidato sea usado casi todo el tiempo. Dadas las pequeñas diferencias generales entre las opciones, requiregarantiza que el script se detenga, no puedo pensar en muchos escenarios en los que una aplicación puede sobrevivir sin incluir un archivo. Y _onceprotege de problemas de engaño. Cualquiera que no esté de acuerdo probablemente sepa lo que está haciendo, por lo que puede elegir el que mejor se adapte a la aplicación o al escenario.
James

oye, tengo un archivo que a veces se incluye en la página de índice y el tiempo del hombre llamado directamente (home.php) ... ahora ya incluí el archivo de configuración en la página de índice con la función require ahora ¿puedo usar require_once? en home.php para evitar que se vuelvan a incluir
Ravinder Payal

@RavinderPayal Bueno, mi primer consejo es que te ahorres un dolor de cabeza usando un controlador frontal. El hecho de que un usuario llame a example.com/home no significa que deba tener un home.php totalmente separado. En cambio, / home / debería enrutarse a través del controlador frontal de index.php o front.php. Solo php realmente permite el enfoque de "un script por página" de la vieja escuela, y créeme, no es la mejor manera. Pero si DEBE tener un home.php e index.php separados, todo lo que PUEDE ENTRAR EN AMBOS debe estar en un archivo o plantilla de biblioteca, ../templates/home.tpl o ../view/home.view.php ¿ya sabes?
Kzqai

Su SNS y yo elegimos un enfoque de un archivo de una página inicialmente para un desarrollo fácil y es una gran pila de archivos que no puedo recrear y ahora resolví ese problema y la otra razón de hacer un archivo de una página es la velocidad y menos contacto con el disco duro. número decreciente de incluye
Ravinder Payal

36

Diferencia entre _once funciones y sin _once funciones: sin _once código se incluirá nuevamente mientras que con _once funciones PHP realiza un seguimiento de los archivos incluidos y lo incluirá solo una vez.

Diferencia entre require e include: si no se encuentra un archivo requerido, PHP emitirá un error fatal mientras que para incluir solo se emitirá una advertencia.


1
¡Guau, corto y simple!
Vlad

31

include() lanzará una advertencia si no puede incluir el archivo, pero se ejecutará el resto del script.

require()lanzará E_COMPILE_ERRORy detendrá el script si no puede incluir el archivo.

Los include_once()y require_once()las funciones que no se incluyen en el archivo una segunda vez si ya se ha incluido.

Consulte las siguientes páginas de documentación:


22

Siempre que lo esté usando, require_once()puede usarlo en un archivo para incluir otro archivo cuando necesite el archivo llamado solo una vez en el archivo actual. Aquí en el ejemplo tengo un test1.php.

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

y en otro archivo que he llamado test2.php

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

ya que está viendo los m que requieren el archivo test1 dos veces, pero el archivo incluirá el test1 una vez y para llamar por segunda vez esto se ignorará. Y sin detenerse mostrará la salida una sola vez.

Siempre que esté usando 'include_once ()' puede usarse en un archivo para incluir otro archivo cuando necesite el archivo llamado más de una vez en el archivo actual. Aquí en el ejemplo tengo un archivo llamado test3.php.

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

Y en otro archivo que he llamado test4.php

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

mientras mira la m, incluido el archivo test3, incluirá el archivo una sola vez, pero detendrá la ejecución posterior.


'ejemplo mejor que consejo'
Ramesh Kithsiri HettiArachchi

19

Use "incluir" para plantillas PHP reutilizables . Use "require" para las bibliotecas requeridas.

"* _once" es bueno, porque comprueba si el archivo ya está cargado o no, pero solo tiene sentido para mí en "require_once".


18

Debe mantener las definiciones de clase y función organizadas en archivos.

Se usa require_once()para cargar dependencias (clases, funciones, constantes).

Úselo require()para cargar archivos tipo plantilla .

Se usa include_once()para cargar dependencias opcionales (clases, funciones, constantes).

Úselo include()para cargar archivos opcionales tipo plantilla .


16

Una respuesta después de 7 años para 2018

Esta pregunta se hizo hace siete años, y ninguna de las respuestas proporciona ayuda práctica para la pregunta. En la programación moderna de PHP, usted usa principalmente required_oncesolo una vez para incluir su clase de autocargador (el autocargador de compositor a menudo), y cargará todas sus clases y funciones (los archivos de funciones deben agregarse explícitamente al composer.jsonarchivo para estar disponibles en todos los demás archivos). Si por alguna razón su clase no se puede cargar desde el autocargador, use require_oncepara cargarla.

Hay algunas ocasiones que necesitamos usar require. Por ejemplo, si tiene una definición de matriz realmente grande y no desea agregarla a su código fuente de definición de clase, puede:

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

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

Si el archivo que tiene la intención de incluir contiene algo ejecutable o declara algunas variables que casi siempre necesita usar require, porque si lo usa require_onceaparte del primer lugar, su código no se ejecutará y / o sus variables no se iniciarán en silencio, causando errores que son absolutamente difíciles de identificar.

No hay un caso de uso práctico para includey include_oncerealmente.


+1 por mencionar el autocargador. Sin embargo, esa última oración es discutible. Muy a menudo usará un include(), envuelto en un búfer de salida para implementar su motor de plantillas.
Haz

Además, dados los editores de texto modernos y el PHP moderno, casi nadie usa require()para dividir archivos grandes.
Haz

require_onceEnfrenté el mismo problema al usar para PHPMailer dentro de una función, y mi autocargador define la $mailvariable necesaria más adelante en el código, por lo que require_oncese ignora el siguiente , que $mailno se inicializó. la solución fue simplemente usar requiredespués de la llamada a la función.
Youssef

@haz ¿Hay alguna razón por la que no uses requireen esos casos?
PHPst

@ChristofferBubach LOL.
PHPst

15

La diferencia está en el error que generan los comandos. Con require, el archivo que desea usar es realmente obligatorio y, por lo tanto, genera un archivo E_ERRORsi no se encuentra.

require()es idéntico a, include() excepto en caso de falla, también producirá un E_ERROR error de nivel fatal .

includesolo genera un E_WARNINGerror si falla que es más o menos silencioso.

Por lo tanto, úselo si el archivo es necesario para que el código restante funcione y desea que el script falle, el archivo no está disponible.


Para *_once():

include_once() puede usarse en casos en los que el mismo archivo puede incluirse y evaluarse más de una vez durante una ejecución particular de un script, por lo que en este caso puede ayudar a evitar problemas como redefiniciones de funciones, reasignaciones de valores variables, etc.

Lo mismo se aplica, por require_once()supuesto.


Referencia: require(),include_once()


requireda E_COMPILE_ERROR, no E_ERROR.
Yousha Aleayoub

Parece que ha cambiado en los últimos 7 años.
Felix Kling

9

Con require, el archivo debe existir, si no es así, aparecerá un error; mientras que con include: si el archivo no existe, la página continuará cargándose.


8

Requerir partes críticas, como autorización e incluir todas las demás.

Las inclusiones múltiples son simplemente un diseño muy malo y deben evitarse en absoluto. Entonces, * _una vez realmente no importa.


7

Incluir / Requerir puede incluir el mismo archivo más de una vez también:

require () es idéntico a include () excepto que en caso de falla también producirá un error fatal de nivel E_COMPILE_ERROR. En otras palabras, detendrá el script mientras que include () solo emite una advertencia (E_WARNING) que permite que el script continúe.

require_once / include_once

es idéntico a include / require excepto que PHP verificará si el archivo ya ha sido incluido, y si es así, no lo incluirá (require) nuevamente.


5

include()generará una advertencia cuando no encuentre un archivo, pero require_once()generará un error fatal.

Otra cosa es si el archivo se incluye antes. Entonces require_once()no lo incluirá de nuevo.


5

Estaba usando la función de la siguiente manera:

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

Hubo valores constantes declarados en xyz.php.

Tengo que llamar a esta función doSomething () desde otro archivo de script PHP.

Pero observé el comportamiento al llamar a esta función en un bucle, para la primera iteración doSomething () estaba obteniendo valores constantes dentro xyz.php, pero luego cada iteración doSomething()no pudo obtener los valores constantes declarados en xyz.php.

Resolví mi problema cambiando de require_once()a include(), el doSomething()código actualizado es el siguiente:

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

Ahora, cada llamada a la iteración doSomething()obtiene los valores constantes definidos en xyz.php.


4

Del manual :

require()es idéntico a, include()excepto en caso de falla, también producirá un E_COMPILE_ERRORerror de nivel fatal . En otras palabras, detendrá el script mientras que include()solo emite una advertencia ( E_WARNING) que permite que el script continúe.

Lo mismo es cierto para las _once()variantes.


4

En la era de los PSR-0 / PSR-4cargadores automáticos, puede ser completamente innecesario usar cualquiera de las declaraciones si todo lo que necesita es hacer que algunas funciones / clases estén disponibles para su código (por supuesto, aún necesita require_oncecargarse automáticamente en su archivo de arranque y includeplantillas si todavía uso PHP como motor de plantillas).


3

 

  1. ¿Cuándo se debe usar requireo include?

    Las funciones requirey includerealizan la misma tarea, es decir, incluyen y evalúan el archivo especificado, pero la diferencia es requireque causará un error grave cuando la ubicación del archivo especificado no sea válida o por cualquier error, mientras includeque generará una advertencia y continuará la ejecución del código.

    Por lo tanto, puede usar la requirefunción en el caso en que el archivo que está tratando de incluir es el corazón del sistema y puede causar un gran impacto en el resto del código y puede usar la includefunción cuando el archivo que está tratando de incluir es un archivo simple que contiene un código menos importante.

    Y mi recomendación personal (para un código menos importante) es ir a la requirefunción en todas partes de su código mientras está en la fase de desarrollo, de modo que pueda depurar el código y luego reemplazar todas las requirefunciones por includefunción antes de pasarlo a producción, de modo que si se pierde cualquier error no afectará al usuario final y el resto del código se ejecuta correctamente ...

  2. ¿Cuándo se debe usar require_onceo require?

    La diferencia básica entre requirey require_oncese require_oncecomprobará si el archivo ya está incluido o no, si ya se incluye a continuación, no incluirá el archivo, mientras que la requirefunción incluirá el archivo independientemente de si el archivo ya está incluido o no.

    Por lo tanto, en los casos en que desee incluir algún fragmento de código una y otra vez, use la requirefunción, mientras que si desea incluir algún código solo una vez en su código, úselo require_once.


2
  1. Use la función require cuando necesite cargar cualquier clase, función o dependencia.

  2. Use la función de inclusión cuando desee cargar un archivo con estilo de plantilla

Si todavía está confundido, simplemente use require_once todo el tiempo.


1

Son todas formas de incluir archivos.

Requerir significa que lo necesita. Require_once significa que lo necesitará, pero solo lo requiere una vez. Incluir significa que incluirá un archivo pero no lo necesita para continuar.

Ejemplos:

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

También hay una función include_once que incluye un archivo una vez.

Include_once 'filename'

No use letras mayúsculas donde las tengo mientras escribo desde mi teléfono.


1

Una cosa que noté, cuando uso include solo puedo acceder a las funciones de los archivos incluidos desde el archivo que lo incluye. Con require_once, puedo ejecutar esa función en un segundo archivo required_once.

también: recomiendo agregar

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

Porque cuando require_once mata la página, a veces puede hacer eco en el directorio de los archivos de su sitio web

Aquí hay una función personalizada que hice para requerir archivos:

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

ejemplo de uso:

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

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

0

Básicamente, si necesita una ruta incorrecta, PHP arroja un error fatal y se llama a la función de apagado, pero cuando incluye una ruta incorrecta, PHP continuará la ejecución, pero solo mostrará una advertencia de que el archivo no existe.

A partir de la palabra en inglés require , se le dice a PHP que la ejecución de la página o el archivo depende del archivo requerido.

Desde mi experiencia, es normal requerir archivos importantes como archivos de configuración, clases de bases de datos y otras utilidades importantes.


0

A menudo se trata de si desea cargar una biblioteca de cliente condicionalmente, o cargarla si la va a usar o no.

Aquí hay un ejemplo concreto; elaborando sobre lo que dijo pcj.

Supongamos que tiene un archivo de configuración que almacena el nombre de usuario y la contraseña de su base de datos (conf.php):

<?php
//my site configuration file

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

Y una clase con una función estática que usa la base de datos:

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

Y esa función estática se usa dentro de otra función que se llama iterativamente dentro de un bucle:

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

Solo puede requerir / incluir la clase una vez. Si lo requiere / lo incluye en cada iteración de su ciclo, obtendrá un error. Sin embargo, debe incluir su archivo conf cada vez que se llama a la función estática.

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

Por supuesto, moverlo fuera de la función podría ser una solución a ese problema:

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

A menos que esté preocupado por la sobrecarga de cargar una clase que solo se puede usar en ciertas condiciones y no desea cargarla cuando no lo está.


-1

requiretiene una sobrecarga mayor que include, ya que primero debe analizar el archivo. Reemplazar requirescon includesfrecuencia es una buena técnica de optimización.


2
Sé que es un comentario tardío, pero en realidad esto no es cierto. requireno analiza el archivo más de includelo que lo hace. Las _onceversiones de esas funciones tienen un poco de sobrecarga, pero como otros han dicho, es casi insignificante en la mayoría de las aplicaciones.
ahouse101

-2

Solo use require e include.

Porque piense cómo trabajar con include_once o require_once. Eso está buscando datos de registro que guarden los archivos PHP incluidos o requeridos. Entonces eso es más lento que incluir y requerir.

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

Solo usando así ...

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.