Diferença entre require, include, require_once e include_once?


Respostas:


1426

Existem requiree include_oncetambém.

Portanto, sua pergunta deve ser ...

  1. Quando devo usar requirevs. include?
  2. Quando devo usar require_oncevs.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.


58
Lembre-se de que require () é executado mais rapidamente que require_once (), portanto, se você tiver certeza de que não há duplicado, inclua use require ().
Dia28

48
@DiAlex, require_once é mais lento, mas quase não é mensurável.
O contrato do Prof. Falken violou

77
@DiAlex ... e, se se verificar que o arquivo é, na verdade, já incluído, então require_once()será o mais rápido dos dois
Tom

11
@ Prof.Falken Em que circunstâncias é necessário um exigir o mesmo arquivo mais de uma vez? Não consigo pensar em um dentro da minha mentalidade atual.
Weishi Zeng 14/10

17
@WeishiZeng para páginas da web, pode haver trechos de HTML que você deseja incluir mais de uma vez.
James Beninger 07/07

406

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.


Eu tenho uma conexão DOP (ao banco de dados) . Devo usar qual? include? include_once? require? require_once?
Shafizadeh

6
Essa deve ser a resposta aceita, uma vez que responde à pergunta resumidamente e possui links para o manual oficial, em vez da outra resposta que apenas vincula o w3schools.
Daniel W.

9
explique-me por que você o incluiria se não for necessário?
Francisco Ochoa

1
Estou usando um modelo para um layout de página genérico que possui seções como cabeçalhos, colunas, rodapés etc. Isso permite que eu sirva esse modelo para todas as páginas do site e só preciso criar arquivos na estrutura de pastas da página, definindo o que deve entrar em cada uma dessas posições. Se eu decidir que uma página não precisa de uma barra lateral, apenas deixo esse arquivo na pasta da página e o modelo ainda funciona bem sem a existência desse arquivo.
James Coyle

301

Minha sugestão é usar apenas require_once99,9% do tempo.

O uso requireou includeimplica 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.


41
+1 Esta deve ser a resposta aceita. Os pontos principais são que a includefamília geralmente é uma péssima idéia (porque é muito raro incluir arquivos com possibilidade de não existirem) e que fora de require_oncee requirevocê deve usar require_onceao 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 requirepara incluir arquivos que fazem coisas imediatamente quando são incluídos. Em qualquer aplicativo Web grande, o último tipo de inclusão é incomum.
Mark Amery

7
+1 (tenha outro distintivo dourado;)) Concorde que o require_oncecandidato mais provável é o de ser usado quase o tempo todo. Dadas as pequenas diferenças de sobrecarga entre as opções, requiregarante 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 _onceprotege de problemas burros. Quem discorda provavelmente sabe o que está fazendo, pode escolher o que melhor se adequa ao aplicativo ou cenário.
James #

ei, eu tenho um arquivo que às vezes é incluído na página de índice e o tempo do homem é chamado diretamente (home.php) ........... agora eu já incluí o arquivo de configuração na página de índice com a função require agora posso usar require_once em home.php para evitar re inclui
Ravinder Payal

@RavinderPayal Bem, meu primeiro conselho é evitar uma dor de cabeça usando um controle frontal! Só porque um usuário chama example.com/home não significa que você deve ter um home.php totalmente separado! Em vez disso, o / home / deve apenas rotear pelo controlador frontal do index.php ou front.php. Somente o php realmente permite mais a abordagem "um script por página" da velha escola e, confie em mim, essa não é a melhor maneira. Mas se você DEVE ter um home.php e um index.php separados, qualquer coisa que PODE ENTRAR EM AMBOS deve estar em um arquivo ou modelo de biblioteca, ../templates/home.tpl ou ../view/home.view.php você sabe?
Kzqai 9/10

seu SNS e eu escolhi um arquivo com uma abordagem de página inicialmente para facilitar o desenvolvimento e é uma grande pilha de arquivos que não consigo recriar e agora resolvi esse problema e a outra razão de fazer um arquivo em uma página é a velocidade e menos contato com o disco rígido. número decrescente de
inclusões

36

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.


1
Uau, curto e simples!
9743 Vlad

31

include() emitirá um aviso se não puder incluir o arquivo, mas o restante do script será executado.

require()lançará um E_COMPILE_ERRORe 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:


22

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.


'exemplo melhor que conselho'
Ramesh Kithsiri HettiArachchi 1/01/18

19

Use "include" para modelos PHP reutilizáveis . Use "require" para as bibliotecas necessárias.

"* _once" é legal, porque verifica se o arquivo já está carregado ou não, mas só faz sentido para mim em "require_once".


18

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 .


16

Uma resposta após 7 anos para 2018

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_onceapenas 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.jsonarquivo 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_oncealé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 includee include_oncerealmente.


+1 por mencionar o carregador automático. No entanto, essa última frase é discutível. Muitas vezes, você usará um include(), envolvido em um buffer de saída para implementar seu mecanismo de modelo.
25418 haz

Além disso, dados os editores de texto modernos e o PHP moderno, quase ninguém usa require()para dividir arquivos grandes.
haz

Eu enfrentei o mesmo problema ao usar o require_oncePHPMailer dentro de uma função, e meu carregador automático define a $mailvariável necessária posteriormente no código, para que o próximo require_onceseja ignorado, o que $mailnão foi inicializado! a solução era simplesmente usar requireapós a chamada da função.
Youssef

@haz Existe algum motivo para você não usar requirenesses casos?
PHPst 27/10/18

@ChristofferBubach LOL.
PHPst 9/11/19

15

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_ERRORse não for encontrado.

require()é idêntico, include() exceto se houver falha, também produzirá um E_ERROR erro de nível fatal .

includesó gera um E_WARNINGerro 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()


requirefornece E_COMPILE_ERROR, não E_ERROR.
Yousha Aleayoub

Parece que mudou nos últimos 7 anos.
Felix Kling #

9

Com require, o arquivo deve existir, se não existir, um erro será exibido; enquanto que com include - se o arquivo não existir, a página continuará carregando.


8

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.


7

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.

require_once / include_once

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


5

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.


5

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.


4

Do manual :

require()é idêntico, include()exceto se houver falha, também produzirá um E_COMPILE_ERRORerro de nível fatal . Em outras palavras, ele interromperá o script, enquanto include()apenas emite um aviso ( E_WARNING) que permite que o script continue.

O mesmo vale para as _once()variantes.


4

Na era dos PSR-0 / PSR-4carregadores 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_oncecarregar o próprio carregador automaticamente em seu arquivo e includemodelos de inicialização, se ainda use o PHP como um mecanismo de modelo).


3

 

  1. Quando alguém deve usar requireouinclude ?

    As funções requiree includeexecutam a mesma tarefa, ou seja, incluem e avalia o arquivo especificado, mas a diferença é requireque 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 requirefunçã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 requirefunçã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 requirefunções por includefunçã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 ...

  2. Quando alguém deve usar require_onceourequire ?

    A diferença básica entre requiree require_onceé require_onceverificará 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 requirefunção, enquanto que se você quiser incluir algum código apenas uma vez no código, use require_once.


2
  1. Use a função require quando precisar carregar qualquer classe, função ou dependência.

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


1

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.


1

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

0

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.


0

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.


-1

requiretem maior sobrecarga do que include, uma vez que precisa analisar o arquivo primeiro. Substituir requirespor includesgeralmente é uma boa técnica de otimização.


2
Eu sei que é um comentário tardio, mas isso não é verdade. requirenão analisa o arquivo mais do que includefaz. As _onceversões dessas funções têm um pouco de sobrecarga, mas, como outros disseram, é quase insignificante na maioria dos aplicativos.
ahouse101

-2

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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.