Em PHP:
- Quando devo usar
require
vs.include
? - Quando devo usar
require_once
vs.include_once
?
Em PHP:
require
vs. include
?require_once
vs. include_once
?Respostas:
Existem require
e include_once
também.
Portanto, sua pergunta deve ser ...
require
vs. include
?require_once
vs.require
A resposta para 1 é descrita aqui .
A função require () é idêntica a include (), exceto pelo fato de tratar erros de maneira diferente. Se ocorrer um erro, a função include () gera um aviso, mas o script continuará a execução. O require () gera um erro fatal e o script será interrompido.
A resposta para 2 pode ser encontrada aqui .
A instrução require_once () é idêntica a require (), exceto que o PHP verificará se o arquivo já foi incluído e, se for o caso, não o incluirá novamente.
require_once()
será o mais rápido dos dois
Usar
exigir
quando o arquivo é requerido pelo seu aplicativo, por exemplo, um modelo de mensagem importante ou um arquivo contendo variáveis de configuração sem as quais o aplicativo seria interrompido.
require_once
quando o arquivo contiver conteúdo que produziria um erro na inclusão subseqüente, por exemplo,
function important() { /* important code */}
é definitivamente necessário em seu aplicativo, mas como as funções não podem ser redeclaradas, não devem ser incluídas novamente.
incluir
quando o arquivo não for necessário e o fluxo do aplicativo continuar quando não for encontrado, por exemplo,
ótimo para modelos que fazem referência a variáveis do escopo atual ou algo assim
include_once
dependências opcionais que produziriam erros no carregamento subseqüente ou talvez inclusão remota de arquivo que você não deseja que ocorra duas vezes devido à sobrecarga de HTTP
Mas, basicamente, você decide quando usar qual.
include
? include_once
? require
? require_once
?
Minha sugestão é usar apenas require_once
99,9% do tempo.
O uso require
ou include
implica que seu código não pode ser reutilizado em outro lugar, ou seja, que os scripts que você está executando realmente executam código em vez de disponibilizar uma classe ou algumas bibliotecas de funções.
Se você precisa / inclui código que é executado no local, é um código processual e precisa conhecer um novo paradigma . Como programação orientada a objetos, programação baseada em funções ou programação funcional.
Se você já está fazendo OO ou programação funcional, usando include_once
é principalmente vai ser atrasar onde na pilha você encontrar bugs / erros. Deseja saber que a função do_cool_stuff()
não está disponível quando você solicita mais tarde ou no momento em que espera que esteja disponível solicitando a biblioteca? Geralmente, é melhor saber imediatamente se algo que você precisa e espera não está disponível, então use require_once
.
Como alternativa, no OOP moderno, basta carregar automaticamente suas classes após o uso.
include
família geralmente é uma péssima idéia (porque é muito raro incluir arquivos com possibilidade de não existirem) e que fora de require_once
e require
você deve usar require_once
ao incluir arquivos que definem funções ou classes a serem usado em outro lugar ou instancia singletons, como objetos de conexão com o banco de dados, e é usado require
para incluir arquivos que fazem coisas imediatamente quando são incluídos. Em qualquer aplicativo Web grande, o último tipo de inclusão é incomum.
require_once
candidato mais provável é o de ser usado quase o tempo todo. Dadas as pequenas diferenças de sobrecarga entre as opções, require
garante a interrupção do script, não consigo pensar em muitos cenários em que um aplicativo pode sobreviver sem que um arquivo seja incluído. E _once
protege de problemas burros. Quem discorda provavelmente sabe o que está fazendo, pode escolher o que melhor se adequa ao aplicativo ou cenário.
Diferença entre as funções _once e sem as funções _once: sem o código _once será incluído novamente, enquanto que com as funções _once o PHP controla os arquivos incluídos e o inclui apenas uma vez.
Diferença entre require e include: Se um arquivo necessário não for encontrado, o PHP emitirá um erro fatal, enquanto for include, apenas um aviso será emitido.
include()
emitirá um aviso se não puder incluir o arquivo, mas o restante do script será executado.
require()
lançará um E_COMPILE_ERROR
e interromperá o script se ele não puder incluir o arquivo.
As funções include_once()
e require_once()
não incluirão o arquivo uma segunda vez se ele já tiver sido incluído.
Consulte as seguintes páginas de documentação:
Sempre que você estiver usando, require_once()
pode ser usado em um arquivo para incluir outro arquivo quando você precisar do arquivo chamado apenas uma única vez no arquivo atual. Aqui no exemplo eu tenho um test1.php.
<?php
echo "today is:".date("Y-m-d");
?>
e em outro arquivo que chamei test2.php
<?php
require_once('test1.php');
require_once('test1.php');
?>
como você está observando o m exigindo o arquivo test1 duas vezes, mas o arquivo incluirá o test1 uma vez e, para chamar na segunda vez, isso será ignorado. E sem parar exibirá a saída uma única vez.
Sempre que você estiver usando 'include_once () `, pode ser usado em um arquivo para incluir outro arquivo quando você precisar do arquivo chamado mais de uma vez no arquivo atual. Aqui no exemplo, eu tenho um arquivo chamado test3.php.
<?php
echo "today is:".date("Y-m-d");
?>
E em outro arquivo que chamei test4.php
<?php
include_once('test3.php');
include_once('test3.php');
?>
enquanto você assiste ao m, incluindo o arquivo test3, o arquivo será incluído uma única vez, mas interromperá a execução.
Você deve manter as definições de classe e função organizadas em arquivos.
Use require_once()
para carregar dependências (classes, funções, constantes).
Use require()
para carregar arquivos semelhantes a modelos .
Use include_once()
para carregar dependências opcionais (classes, funções, constantes).
Use include()
para carregar arquivos opcionais do tipo modelo .
Esta pergunta foi feita sete anos atrás, e nenhuma das respostas fornece ajuda prática para a pergunta. Na programação PHP moderna, você usa principalmente required_once
apenas uma vez para incluir sua classe de carregador automático (carregador automático de compositor frequentemente) e carrega todas as suas classes e funções (os arquivos de funções precisam ser explicitamente adicionados ao composer.json
arquivo para estarem disponíveis em todos os outros arquivos). Se, por algum motivo, sua classe não for carregável a partir do carregador automático, você usarequire_once
-la.
Há algumas ocasiões que precisamos usar require
. Por exemplo, se você tem uma definição de matriz realmente grande e não deseja adicionar isso ao código-fonte de definição de classe, pode:
<?php
// arr.php
return ['x'=>'y'];
<?php
//main.php
$arr= require 'arry.php'
Se o arquivo que você pretende incluir contiver algo executável ou declarar algumas variáveis, você quase sempre precisará usar require
, porque se você usar require_once
além do primeiro lugar, seu código não será executado e / ou suas variáveis não serão iniciadas silenciosamente, causando erros que são absolutamente difíceis de identificar.
Não existe um caso de uso prático para include
e include_once
realmente.
include()
, envolvido em um buffer de saída para implementar seu mecanismo de modelo.
require()
para dividir arquivos grandes.
require_once
PHPMailer dentro de uma função, e meu carregador automático define a $mail
variável necessária posteriormente no código, para que o próximo require_once
seja ignorado, o que $mail
não foi inicializado! a solução era simplesmente usar require
após a chamada da função.
require
nesses casos?
A diferença está no erro gerado pelos comandos. Com require
, o arquivo que você deseja usar é realmente necessário e, portanto, gera um E_ERROR
se não for encontrado.
require()
é idêntico,include()
exceto se houver falha, também produzirá umE_ERROR
erro de nível fatal .
include
só gera um E_WARNING
erro se falhar, o que é mais ou menos silencioso.
Portanto, use-o se o arquivo for necessário para fazer o código restante funcionar e você desejar que o script falhe, o arquivo não está disponível.
Para *_once()
:
include_once()
pode ser usado nos casos em que o mesmo arquivo pode ser incluído e avaliado mais de uma vez durante uma execução específica de um script; portanto, nesse caso, ele pode ajudar a evitar problemas como redefinições de função, reatribuições de valores variáveis etc.
O mesmo se aplica a, é require_once()
claro.
Referência: require()
,include_once()
require
fornece E_COMPILE_ERROR, não E_ERROR.
Exija partes críticas, como autorização e inclua todas as outras.
Várias inclusões são apenas design muito ruim e devem ser evitadas. Então, * _once realmente não importa.
Incluir / Exigir que você também pode incluir o mesmo arquivo mais de uma vez:
require () é idêntico a include (), exceto que, em caso de falha, também produzirá um erro fatal no nível E_COMPILE_ERROR. Em outras palavras, ele interromperá o script, enquanto include () emite apenas um aviso (E_WARNING) que permite que o script continue.
é idêntico a incluir / exigir, exceto que o PHP verificará se o arquivo já foi incluído e, se for o caso, não o incluirá (exigirá) novamente.
include()
gera um aviso quando não encontra um arquivo, mas require_once()
gera um erro fatal.
Outra coisa é se o arquivo já foi incluído antes. Então require_once()
não o incluirá novamente.
Eu estava usando a função como abaixo:
function doSomething() {
require_once(xyz.php);
....
}
Havia valores constantes declarados em xyz.php.
Eu tenho que chamar essa função doSomething () de outro arquivo de script PHP.
Mas observei o comportamento ao chamar essa função em um loop, pois a primeira iteração doSomething () estava obtendo valores constantes xyz.php
, mas depois toda iteração doSomething()
não conseguiu obter os valores constantes declarados xyz.php
.
Resolvi meu problema alternando de require_once()
para include()
, o doSomething()
código atualizado é o seguinte:
function doSomething() {
include(xyz.php);
....
}
Agora, toda chamada de iteração doSomething()
obtém os valores constantes definidos em xyz.php
.
Do manual :
require()
é idêntico,include()
exceto se houver falha, também produzirá umE_COMPILE_ERROR
erro de nível fatal . Em outras palavras, ele interromperá o script, enquantoinclude()
apenas emite um aviso (E_WARNING
) que permite que o script continue.
O mesmo vale para as _once()
variantes.
Na era dos PSR-0 / PSR-4
carregadores automáticos, pode ser completamente desnecessário usar qualquer uma das instruções se tudo o que você precisa é disponibilizar algumas funções / classes para o seu código (é claro, você ainda precisa require_once
carregar o próprio carregador automaticamente em seu arquivo e include
modelos de inicialização, se ainda use o PHP como um mecanismo de modelo).
Quando alguém deve usar require
ouinclude
?
As funções require
e include
executam a mesma tarefa, ou seja, incluem e avalia o arquivo especificado, mas a diferença é require
que causará um erro fatal quando o local do arquivo especificado for inválido ou por qualquer erro.include
, gerará um aviso e continuará a execução do código.
Portanto, você pode usar a require
função no caso em que o arquivo que você está tentando incluir é o coração do sistema e pode causar um grande impacto no restante do código e pode usar oinclude
função quando o arquivo que você está tentando incluir for um arquivo simples contendo um código menos importante.
E minha recomendação pessoal (para código menos importante) é ir para a require
função em qualquer parte do código, enquanto ela está em fase de desenvolvimento, para que você possa depurar o código e, posteriormente, substitua todas as require
funções por include
função antes de movê-lo para a produção, caso você perca qualquer bug não afetará o usuário final e o restante do código será executado corretamente ...
Quando alguém deve usar require_once
ourequire
?
A diferença básica entre require
e require_once
é require_once
verificará se o arquivo já está incluído ou não, se já está incluído, mas não incluirá o arquivo, enquanto orequire
função incluirá o arquivo, independentemente de o arquivo já estar incluído ou não.
Portanto, nos casos em que você deseja incluir algumas partes do código repetidamente, use a require
função, enquanto que se você quiser incluir algum código apenas uma vez no código, use require_once
.
Use a função require quando precisar carregar qualquer classe, função ou dependência.
Use a função include quando desejar carregar o arquivo com estilo de modelo
Se você ainda estiver confuso, basta usar require_once para sempre.
São todas as formas de incluir arquivos.
Exigir significa que ele precisa. Require_once significa que será necessário, mas somente uma vez. Incluir significa que ele incluirá um arquivo, mas não precisa continuar.
Exemplos:
Require 'filename'
Require_once 'filename'
Include 'filename'
Há também uma função include_once que inclui um arquivo uma vez.
Include_once 'filename'
Não use letras maiúsculas onde tenho, pois estou digitando no meu telefone.
uma coisa que notei, ao usar o include, só posso acessar as funções dos arquivos incluídos no arquivo que o incluiu. Com require_once, eu posso executar essa função em um segundo arquivo required_once.
também: eu recomendo adicionar
if(file_exists($RequiredFile)){
require_once($RequiredFile);
}else{
die('Error: File Does Not Exist');
}
Como quando require_once mata a página, às vezes pode ecoar o diretório dos arquivos do seu site
Aqui está uma função personalizada que eu criei para exigir arquivos:
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;
}
}
exemplo de uso:
$success = addFile('functions/common');
if($success){
commonFunction();
}else{
fallbackFunction();
}
Basicamente, se você precisar de um caminho errado, o PHP lançará um erro fatal e a função de desligamento será chamada, mas quando você incluir um caminho errado, o PHP continuará a execução, mas exibirá apenas um aviso de que o arquivo não existe.
Da palavra em inglês exigir , é dito ao PHP que a execução da página ou arquivo depende do arquivo necessário.
Pela minha experiência, é norma exigir arquivos importantes, como arquivos de configuração, classes de banco de dados e outros utilitários importantes.
Geralmente, é uma questão de se você deseja carregar uma biblioteca de clientes condicionalmente ou seguir em frente e carregá-la, independentemente de usá-la ou não.
Aqui está um exemplo concreto; elaborando sobre o que pcj disse.
Digamos que você tenha um arquivo de configuração armazenando o nome de usuário e a senha do banco de dados (conf.php):
<?php
//my site configuration file
//For Database
$location='localhost';
$dbuser='yourname';
$userpw='yourpassword';
$database='nameofdatabase';
?>
E uma classe com uma função estática que usa o banco de dados:
<?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
}
}
?>
E essa função estática é usada dentro de outra função que está sendo chamada iterativamente dentro de um loop:
<?php
require_once('path/to/arbitraryObject.php'); //either will likely be OK at this level
$obj = new arbitraryObject();
foreach($array as $element){
$obj->myFunction();
}
?>
Você só pode exigir / incluir a classe uma vez. Se você precisar / incluí-lo em todas as iterações do seu loop, receberá um erro. No entanto, você deve incluir seu arquivo conf sempre que a função estática for chamada.
<?php
class arbitraryObject {
public function myFunction(){
require_once(/path/to/UsedInLoop.php); //This must be require_once. require() will not work
UsedInLoop::databaseQuery();
}
}
?>
Obviamente, movê-lo para fora da função pode ser uma solução para esse problema:
<?php
require(/path/to/UsedInLoop.php); //now require() is fine
class arbitraryObject {
public function myFunction(){
UsedInLoop::databaseQuery();
}
}
?>
A menos que você esteja preocupado com a sobrecarga de carregar uma classe que só pode ser usada em determinadas condições e não queira carregá-la quando não estiver.
require
tem maior sobrecarga do que include
, uma vez que precisa analisar o arquivo primeiro. Substituir requires
por includes
geralmente é uma boa técnica de otimização.
require
não analisa o arquivo mais do que include
faz. As _once
versões dessas funções têm um pouco de sobrecarga, mas, como outros disseram, é quase insignificante na maioria dos aplicativos.
Basta usar exigir e incluir.
Porque pense em como trabalhar com include_once ou require_once. Isso está procurando dados de log que salvam arquivos PHP incluídos ou necessários. Portanto, isso é mais lento que incluir e exigir.
if (!defined(php)) {
include 'php';
define(php, 1);
}
Apenas usando assim ...