php - include_once - require_once__dir__




¿Diferencia entre require, include, require_once y include_once? (18)

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_once solo una vez para incluir su clase de autocargador (compositor autoloader a menudo), y cargará todas sus clases y funciones (los archivos de funciones deben agregarse explícitamente al archivo composer.json para que estén disponibles en todos otros archivos). Si por alguna razón su clase no se puede cargar desde el autocargador, use require_once para cargarla.

En estos días, el uso solo require dividir una gran parte de un archivo PHP. Esto es principalmente una gran definición de matriz. En tales casos, solo usas require no require_once .

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

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

Si el archivo que pretende usar contiene algo ejecutable o declara algunas variables que necesita usar casi todo el tiempo, porque si usa require_once en otro lugar, su código no se ejecutará y / o sus variables no se iniciarán de forma silenciosa, lo que provocará errores. que son absolutamente difíciles de identificar.

No hay un caso de uso práctico para include e include_once realmente.

En PHP:

  • ¿Cuándo debo usar require vs. include ?
  • ¿Cuándo debo usar require_once vs. include_once ?

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

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

Si aún estás confundido, solo usa require_once para siempre.


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


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

Utilice require_once para cargar dependencias (clases, funciones, constantes).

Utilice require para cargar archivos tipo plantilla.


Diferencia entre las funciones _once y sin las funciones _once: sin _once el código se incluirá nuevamente, 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.


En breve:

  • include: incluye un archivo y lo evalúa. PHP emitirá una advertencia si el archivo no se encuentra o no se puede leer.

  • include_once: si especifica include_once, PHP se asegurará de que incluya el archivo solo una vez.

  • Requerir: PHP incluirá un archivo y lo evaluará. Si el archivo no se encuentra o no se puede leer, se generará un error fatal.

  • require_once: En cuanto a include_once, pero se generará un error fatal en lugar de una advertencia.

La razón para no usar include_once () y require_once () todo el tiempo es un problema de rendimiento. PHP rastrea una lista de archivos que se ha incluido para admitir la funcionalidad de estas funciones. Esto requiere memoria, por lo que estas funciones se usan cuando son necesarias y no a favor de incluir o requerir.


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 mientras llamaba a esta función en un bucle, ya que la primera iteración doSomething () xyz.php valores constantes dentro de xyz.php , pero luego cada xyz.php doSomething() no podía obtener los valores constantes declarados en xyz.php .

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

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

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


Hay require y include_once también.

Entonces tu pregunta debería ser ...

  1. ¿Cuándo debo usar require vs. include ?
  2. ¿Cuándo debo usar require_once vs. require

La respuesta a 1 se describe here .

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 la secuencia de comandos continuará su ejecución. Require () genera un error fatal, y la secuencia de comandos se detendrá.

La respuesta a 2 se puede encontrar here .

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


Me preguntaron el otro día cuál es la diferencia entre incluir y requerir en PHP. Aparentemente funcionan igual pero hay una diferencia significativa.

En primer lugar, ni incluir ni requerir son funciones, son construcciones. Por lo tanto, no es necesario llamarlos usando paréntesis como include ('file.php'); en su lugar, se prefiere utilizar include 'file.php'.

La diferencia entre incluir y requerir surge cuando no se puede encontrar el archivo que se incluye: include emitirá una advertencia (E_WARNING) y la secuencia de comandos continuará, mientras que require emitirá un error fatal (E_COMPILE_ERROR) y detendrá la secuencia de comandos. Si el archivo que se incluye es crítico para el resto de la secuencia de comandos que se ejecuta correctamente, entonces necesita utilizar require.

Debe detectar cualquier error fatal que se produzca durante el proceso de desarrollo y ser capaz de resolverlo antes de liberar su script; sin embargo, es posible que desee considerar utilizar incluir para establecer un plan B si no es tan sencillo:

<?php
if (@include 'file.php') {
    // Plan A
} else {
    // Plan B - for when 'file.php' cannot be included
}

En este ejemplo, include se usa para capturar 'file.php', pero si esto falla, suprimimos la advertencia usando @ y ejecutamos algún código alternativo. include devolverá false si no se puede encontrar el archivo.

include_once y require_once se comportan como include y require respectivamente, excepto que solo incluirán el archivo si aún no se ha incluido. De lo contrario, lanzan el mismo tipo de errores.


Mi sugerencia es simplemente usar require_once 99.9% del tiempo.

El uso de require o include implica que su código no es reutilizable en otros lugares, es decir, que los scripts que está ejecutando en realidad ejecutan el código en lugar de poner a disposición una clase o algunas bibliotecas de funciones.

Si necesita / incluido el código que se ejecuta en el momento, 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, el uso de include_once general demorará dónde encontrar errores / errores en la pila. ¿Desea saber que la función do_cool_stuff() no está disponible cuando la llame 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 use require_once .

Alternativamente, en la POO moderna, simplemente autoload sus clases autoload al usarlas.


Sólo el uso requiere e incluye.

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

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

Sólo usando así ...


Siempre que esté utilizando require_once() se puede usar en un archivo para incluir otro archivo cuando necesite el archivo al que se llama 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 el m que requiere el archivo test1 dos veces, pero el archivo incluirá el test1 una vez y, por segunda vez, se ignorará. Y sin detenerse mostrará la salida una sola vez.

Siempre que esté utilizando 'include_once () `puede usarse en un archivo para incluir otro archivo cuando necesite el archivo al que se llama 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');  
?>

a medida que ve la m, incluido el archivo test3, se incluirá el archivo una sola vez, pero detendrá la ejecución.


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

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


Utilizar

  • require
    cuando el archivo es requerido 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.

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

  • include 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 de archivos remotos que no desea que ocurra dos veces debido a la sobrecarga de HTTP

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


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

require () es idéntico a include (), excepto en caso de error, 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.

require_once / include_once

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


include() emitirá una advertencia si no puede incluir el archivo, pero el resto de la secuencia de comandos se ejecutará.

require() lanzará un E_COMPILE_ERROR y detendrá la secuencia de comandos si no puede incluir el archivo.

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

Vea las siguientes páginas de documentación:


require tiene mayor sobrecarga que la include , ya que primero tiene que analizar el archivo. Reemplazar los requires con los includes es a menudo una buena técnica de optimización.


require producirá un error fatal (E_COMPILE_ERROR) y detendrá el script.

include solo producirá una advertencia (E_WARNING) y el script continuará.

La declaración require_once se puede usar para incluir un archivo PHP en otro, cuando es posible que necesite incluir el archivo llamado más de una vez.

Si a.php es un script PHP que llama a b.php con una declaración require_once () y no encuentra b.php, a.php detiene la ejecución, lo que provoca un error fatal.





require-once