php - ejemplo - ¿Diferencia entre require, include, require_once y include_once?

require_once php ejemplo (27)

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 ?

Utilice la función require cuando necesite cargar cualquier clase, función o dependencia.
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.

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

De la palabra inglesa 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 base de datos y otras utilidades importantes.

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.

Del manual :

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.

Lo mismo es cierto para las variantes _once() .

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.

En la era de los autocargadores PSR-0 / PSR-4 puede ser completamente innecesario usar cualquiera de las afirmaciones si todo lo que necesita es hacer que algunas funciones / clases estén disponibles para su código (por supuesto, todavía necesita requerir el autocargador require_once en su bootstrap e include plantillas si aún usa PHP como motor de plantillas).

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

¿Cuándo debo usar require vs. include ?
¿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.

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 error, también producirá un error de nivel E_ERROR fatal.

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

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

Para *_once() :

include_once() se puede usar en casos donde 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 la redefinición de funciones, la reasignación de valores de variables, etc.

Lo mismo se aplica a require_once() por supuesto.

Referencia: require , php.net/manual/en/function.include-once.php

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.

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

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

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.

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:

Requerir ''nombre de archivo'' Require_once ''nombre de archivo'' Incluir ''nombre de archivo''

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

Include_once ''nombre de archivo''

No use letras mayúsculas donde tengo ya que estoy escribiendo desde mi teléfono.

Gracias por tu tiempo.

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.

incluir()

Incluye un archivo especificado. Se producirá una advertencia si no encuentra el archivo y ejecuta los scripts restantes

exigir()

Incluye un archivo especificado. Producirá un error fatal si no encuentra el archivo y detiene la ejecución

include_once ()

Incluye un archivo especificado. ya se ha incluido un archivo, no se volverá a incluir. Producirá una advertencia si no encuentra el archivo y ejecuta los scripts restantes.

requerir una vez()

Incluye un archivo especificado. ya se ha incluido un archivo, no se volverá a incluir. Producirá un error fatal si no encuentra el archivo y detiene la ejecución.

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:

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

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

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.

¿Cuándo debería un uso require o include ?
Las funciones de require e include realizan la misma tarea, es decir, incluye y evalúa el archivo especificado, pero la diferencia es que require un error fatal cuando la ubicación del archivo especificado no sea válida o si se produce algún error, mientras que include generará una advertencia y continuará la ejecución del código .
Por lo tanto, puede usar la función require en el caso en el 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 función de include cuando el archivo que está tratando de incluir Es un archivo simple que contiene algún código menos importante.
Y mi recomendación personal (para el código menos importante) es buscar la función require 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 funciones require por la función de include antes de pasar a producción de tal manera que Si omite algún error, no afectará al usuario final y el resto del código se ejecutará correctamente ...
¿Cuándo se debe usar require_once o require ?
La diferencia básica entre require y require_once es require_once comprobará si el archivo ya está incluido o no, si ya está incluido, entonces no incluirá el archivo, mientras que la función require incluirá el archivo independientemente de si el archivo ya está incluido o no.
Por lo tanto, en los casos en los que desee incluir una parte del código una y otra vez, use la función require , mientras que si desea incluir algún código solo una vez en su código, use require_once .