¿Diferencia entre require, include, require_once e include_once?

En PHP:

  • Cuando debo usar require vs include?
  • Cuando debo usar require_once vs include_once?

preguntado el 10 de marzo de 10 a las 13:03

PHP CodeSniffer dice, si el archivo se incluye condicionalmente, use include_once (en lugar de require_once). -

25 Respuestas

Existen require y include_once también.

Entonces tu pregunta debería ser ...

  1. Cuando debo usar require vs include?
  2. Cuando debo usar require_once vs 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 ocurre un error, la función include () genera una advertencia, pero el script continuará la ejecución. El 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 si es así, no lo incluirá (requerirá) nuevamente.

Respondido el 21 de junio de 19 a las 14:06

@WeishiZeng Por favor, vea mi respuesta para esto: PHPst

Utiliza

  • exigir
    cuando el archivo es son requeridos por su aplicación, por ejemplo, una plantilla de mensaje importante o un archivo que contiene variables de configuración sin las cuales la aplicación se rompería.

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

  • incluiyendo cuando el archivo no es necesario y el flujo de la aplicación debe continuar cuando no se encuentra, p. ej.
    ideal para plantillas que hacen referencia a variables del alcance actual o algo así

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

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

respondido 18 nov., 15:09

Mi sugerencia es usar require_once 99.9% del tiempo.

Usar require or include en su lugar, implica que su código no es reutilizable en otro lugar, es decir, que los scripts que está introduciendo en realidad ejecutar código en lugar de hacer Autos Disponibles una clase o algunas bibliotecas de funciones.

Si necesita / incluye código que se ejecuta en el lugar, ese es un código de procedimiento, y necesita conocer un nuevo paradigma. Como 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, use include_once mayormente va a ser demorando donde en la pila encuentras bugs / errors. ¿Quieres saber que la función do_cool_stuff() no está disponible cuando vaya a pedirlo más tarde, o en el momento en que esperas que esté disponible requiriendo la biblioteca? Por lo general, es mejor saber de inmediato si algo que necesita y espera no está disponible, así que use require_once.

Alternativamente, en la programación orientada a objetos moderna, simplemente carga automática sus clases sobre el uso.

contestado el 13 de mayo de 16 a las 04:05

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

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

respondido 10 mar '10, 16:03

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

require() lanzará un E_COMPILE_ERROR y detenga el script si no puede incluir el archivo.

La include_once() y require_once() Las funciones no incluirán el archivo por segunda vez si ya se ha incluido.

Consulte las siguientes páginas de documentación:

Respondido el 15 de enero de 13 a las 19:01

Siempre que estés usando require_once() se puede usar 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');  
?>

como está viendo el m que requiere el archivo test1 dos veces, pero el archivo incluirá el test1 una vez y para llamar por segunda vez, esto será ignorado. Y sin detenerse mostrará la salida una sola vez.

Siempre que esté usando 'include_once ()' se puede usar 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, el archivo m, incluido el test3, incluirá el archivo una sola vez, pero detendrá la ejecución posterior.

Respondido 02 Oct 12, 18:10

Debe mantener las definiciones de clases y funciones organizadas en archivos.

Utiliza require_once() cargar dependencias (clases, funciones, constantes).

Utiliza require() cargar archivos tipo plantilla.

Utiliza include_once() cargar dependencias opcionales (clases, funciones, constantes).

Utiliza include() cargar archivos opcionales similares a plantillas.

Respondido 13 Feb 19, 13:02

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 PHP moderna se utiliza principalmente required_once solo una vez para incluir su clase de autocargador (el autocargador del compositor a menudo), y cargará todas sus clases y funciones (los archivos de funciones deben agregarse explícitamente a composer.json archivo para estar disponible en todos los demás archivos). Si por alguna razón su clase no se puede cargar desde el cargador automático que usa require_once para cargarlo.

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

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

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

Si el archivo que desea incluir contiene algo ejecutable o declara algunas variables, casi siempre debe usar require, porque si usas require_once Aparte del primer lugar, su código no se ejecutará y / o sus variables no se iniciarán silenciosamente, lo que provocará errores que son absolutamente difíciles de identificar.

No existe un caso de uso práctico para include y include_once De Verdad.

Respondido el 20 de junio de 20 a las 10:06

Utilice "incluir" para reutilizable PHP plantillas. Utilice "require" para las bibliotecas necesarias.

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

Respondido el 02 de diciembre de 12 a las 11:12

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

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

include solo genera un E_WARNING error si falla que es más o menos silencioso.

Por lo tanto, utilícelo 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 donde el mismo archivo puede ser incluido y evaluado 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 de variables, etc.

Lo mismo se aplica a require_once() por supuesto.


Referencia: require(), include_once()

respondido 10 mar '10, 16:03

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

respondido 10 mar '10, 16:03

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

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

Respondido el 02 de diciembre de 12 a las 11:12

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

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

requerir una vez / incluir_una vez

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

respondido 03 nov., 11:11

Estaba usando la función de la siguiente manera:

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

Se declararon valores constantes 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 () obtenía 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(), actualizado doSomething() el código es el siguiente:

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

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

Respondido el 08 de enero de 18 a las 02:01

 

  1. Cuando se debe usar require or include?

    La require y include Las funciones hacen la misma tarea, es decir, incluye y evalúa el archivo especificado, pero la diferencia es require causará un error fatal cuando la ubicación del archivo especificada no sea válida o por cualquier error, mientras que include generará una advertencia y continuará la ejecución del código.

    Entonces puedes usar el require función en el caso de que el archivo que está intentando incluir es el corazón del sistema y puede causar un gran impacto en el resto del código y puede usar el include función cuando el archivo que está intentando incluir es un archivo simple que contiene un código menos importante.

    Y mi recomendación personal (para un código menos importante) es optar por el require funcionar en todas partes en su código mientras está en la fase de desarrollo, de modo que pueda depurar el código y luego reemplazar todo require funciona por include funciona antes de moverlo a producción, de modo que si omite algún error, no afectará al usuario final y el resto del código se ejecutará correctamente ...

  2. Cuando se debe usar require_once or require?

    La diferencia básica entre require y require_once is require_once Verificará si el archivo ya está incluido o no, si ya está incluido, entonces no incluirá el archivo mientras que el require La función incluirá el archivo independientemente de si el archivo ya está incluido o no.

    Entonces, en los casos en los que desee incluir algún fragmento de código una y otra vez, use el require función mientras que si desea incluir algún código solo una vez en su código, use require_once.

Respondido el 08 de enero de 18 a las 02:01

Desde el manual:

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

Lo mismo es cierto para el _once() variantes.

respondido 03 nov., 11:11

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. Luego require_once() no lo volveré a incluir.

Respondido el 02 de diciembre de 12 a las 11:12

En la época de PSR-0 / PSR-4 cargadores 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_once autocargador en su archivo de arranque y include plantillas si todavía usa PHP como motor de plantillas).

Respondido el 18 de diciembre de 18 a las 03:12

  1. Utiliza exigir función cuando necesite cargar cualquier clase, función o dependencia.

  2. Utiliza incluiyendo función cuando desee cargar un archivo con estilo de plantilla

Si todavía está confundido, simplemente use requerir una vez para todo el tiempo.

Respondido 07 Jul 15, 05:07

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.

De la palabra inglesa exigir, Se le dice a PHP que la ejecución de la página o el archivo depende del archivo requerido.

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

Respondido el 08 de enero de 18 a las 02:01

Todas son 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 tengo mientras escribo desde mi teléfono.

Respondido el 18 de diciembre de 18 a las 03:12

Una cosa que noté, cuando uso include, solo puedo acceder a las funciones de archivos incluidos desde el archivo que lo incluía. 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 del directorio de 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();
}

Respondido 15 Jul 19, 19:07

A menudo se trata de si desea cargar una biblioteca cliente de forma condicional o continuar y cargarla, ya sea que la vaya a utilizar 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 solicitar / incluir la clase una vez. Si lo requiere / incluye en cada iteración de su ciclo, obtendrá un error. Sin embargo, debe incluir su archivo conf cada vez que se llame 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 le preocupe la sobrecarga de cargar una clase que solo se puede usar en ciertas condiciones y no quiere cargarla cuando no lo está.

contestado el 13 de mayo de 20 a las 07:05

require tiene una sobrecarga mayor que include, ya que primero tiene que analizar el archivo. Reemplazo requires con includes suele ser una buena técnica de optimización.

Respondido el 08 de enero de 18 a las 02:01

Sé que es un comentario tardío, pero en realidad no es cierto. require no analiza el archivo más de include hace. los _once Cada una de las versiones de esas funciones tiene un poco de sobrecarga, pero como han dicho otros, es casi insignificante en la mayoría de las aplicaciones. - unacasa101

Solo use require e incluya.

Porque piensa cómo trabajar con include_once o require_once. Eso es buscar datos de registro que guarden 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í ...

Respondido el 08 de enero de 18 a las 02:01

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.