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

Em PHP:

• Quando devo usar requirevs. include?
• Quando devo usar require_oncevs. include_once?

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.

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.

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.

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_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:

• incluir
• exigir
• include_once
• requer uma vez

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.

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

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 .

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.

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

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.

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.

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.

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

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

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.

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.

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.

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

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