¿Diferencia entre require, include, require_once e include_once?

En PHP:

• ¿Cuándo debo usar requirevs. include?
• ¿Cuándo debo usar require_oncevs. include_once?

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.

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.

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.

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.

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:

• incluir
• exigir
• incluir_una vez
• requerir una vez

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.

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".

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 .

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.

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()

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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

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.

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á.

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

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í ...