require(),include(),require_once()和include_once()区别
我把这两个语句放在一起介绍,读者可以比较学习。
1.require()语句
require()语句用于指定的文件代替语句本身,就象C语言中的include()语句一样。如果php配置文件php.ini中的URL fopen wrappers 是打开的(默认情况下是打开的),就可以使用URL来指定文件的位置从而实现远程文件的调用。
有一点就是使用require()和include()语句时要特别的注意。那就是在被包含的文件中,处理器是按照html模式来解释其中的内容的,处理完被包含的内容后又恢复到php模式。所以如果需要在被包含文件中使用php语法,就要使用正确的php开始和结束标记来把这些语句包含进去。
require()和include()知识php中的一种语言特性,而不是函数。它们和函数有许多不同的地方。
比如:require()所包含的文件中不能包含控制结构,而且不能使用return这样的语句。在require()所包含的文件中使用return语句会产生处理错误。
不象include()语句,require()语句会无条件地读取它所包含的文件的内容,而不管这些语句是否执行。所以如果你想按照不同的条件包含不同的文件,就必须使用include()语句。当然,如果require()所在位置的语句不被执行,require()所包含的文件中的语句也不会被执行。
require()不能在循环体中根据条件的不同而包含不同的文件。require()语句只会在第一次执行时调用它所包含的文件中的内容替换本身这条语句,当再次被执行时只能执行第一次所包含的语句。但是include()语句可以在循环体中来包含不同的文件。
require()语句中的变量继承require()语句所在位置的变量作用域。所有在require()语句的位置可以访问的变量,在require()语句所包含的文件中都可以访问。如果require()语句位于一个函数内部,那么被包含文件内的语句都相当于定义在函数内部。
require()语句在PHP程序执行前就会将使用require引用的文件读入,因此require通常放到程序的开始处。因此要特别注意一点,require语句有一点强,不管程序是否真的需要引用的文件,只要你使用require语句,它都会把他们包含进来!即使你是在条件控制语句中使用这个函数进行包含,那怕是那个条件不为真,引用文件也会被包含进来!形成了僵尸,在运行过程中这些僵尸是不起任何可见作用的,但是很明显它会加重负担,所以这一点要特别注意!如果使用require语句发生了包含错误,那么程序将输出出错信息并停止运行!!
如果require()语句通过声明文件的URL来包含远程文件,而且远程服务器按照php代码来解释该文件的话,本地php文件中所包含的内容是在远程服务器上处理以后的结果。例如:
复制代码 代码如下:
/*
这个例子假设some_server服务器可以解释.php文件,而不对.txt文件进行解释。在远程文件中
需要变量$varfirst和$varsecond
*/
/*不能正确执行,远程服务器不处理.txt文件*/
require("http://some_server/file.txt?varfirst=1&varsecond=2");
/*不正确,这样只能在本地机上寻找file.php文件*/
require("file.php?varfirst=1&varsecond=2");
/*正确的语句*/
require("http://some_server/file.php?varfirst=1&varsecond=2");
$varfirst=1;
$varsecond=2;
require("file.txt"); /*正确的语句*/
require("file.php"); /*正确的语句*/
本来在php3.0中,require()所包含的文件可以使用return语句,但条件是return语句不能出现在{}内部,而必须出现在被包含文件的全局范围内。在php4.0中已经取消了require()的这个功能,但是仍然可以使用include()来实现。
2.include()语句
include()语句和require()语句有许多相同的地方。凡是在上边require()语句中没有明确说明不能适用于include()的部分外,require()语句的功能完全适用于include()语句。下边介绍require()语句所没有的include()语句的功能和特点。
include语句只有在被执行时才会读入要包含的文件。在错误处理方便,使用include语句,如果发生包含错误,程序将跳过include语句,虽然会显示错误信息但是程序还是会继续执行!
php处理器会在每次遇到include()语句时,对它进行重新处理,所以可以根据不同情况的,在条件控制语句和循环语句中使用include()来包含不同的文件。
例如:
复制代码 代码如下:
$files=array('first.php','second.php','third.php');
for($i=0;$i
include $files[$i];
}
?>
在php3.0和php4.0中include()语句所包含的文件中都可以使用return语句来返回一个值,并停止执行被包含文件下面的内容。但php3.0和php4.0在处理这样的情况时有所不同。在php3.0中return语句不能包含在{}内,除非它在一个函数中,因为这时它表示函数的返回值而不是文件的返回值。而在php4.0中就没有了这样的限制,用户甚至可以在文件中返回一个数字,就象函数的返回值一样。这样的语句在
php3.0中通常会报告错误。以下举例说明:
假设被包含的文件为test.inc和主文件main.php位于一个目录中。test.inc的内容如下:
test.inc
复制代码 代码如下:
echo "Before the return
\n";
if(1)
{
return 27;
}
echo "After the return
\n";
?>
假设在main.php文件中包含下面的语句:
复制代码 代码如下:
$retval=include('test.inc');
echo "File returned:'$retval'
\n";
?>
php3.0解释器会在第二行报告错误,而不能得到include()语句的返回值。但在php4.0中会得到下面的结果:
Before the return
File returned: '27'
下边假设main.php改为:
复制代码 代码如下:
include('test.inc');
echo "Back in main.html
\n";
?>
在php4.0中的输出结果是:
Before the return
Back in main.html
在php5.0中的输出结果也是:
Before the return
Back in main.html
在php3.0中的输出结果是:
Before the return
27Back in main.html
Parse error:parse error in /apache/htdocs/phptest/main.html on line 5
出现上面的错误是因为return语句位于{}内部而且不是一个函数内部。如果把{}去掉,使它位于test.inc的最外层,输出结果是:
Before the return
27Back in main.html
之所以出现27,是因为在php3.0中不支持include()返回。
3.require_once()和include_once()语句
require_once()和include_once()语句分别对应于require()和include()语句。require_once()和include_once()语句主要用于需要包含多个文件时,可以有效地避免把同一段代码包含进去而出现函数或变量重复定义的错误。例如:如果创建两个文件util.inc和fool.inc,程序代码分别为:
util.inc:
复制代码 代码如下:
define(PHPVERSION,floor(phpversion()));
echo "GLOBALS ARE NICE
\n";
function goodTea()
{
return "Olong tea tasts good!";
}
?>
和fool.inc:
复制代码 代码如下:
require ("util.inc");
function showVar($var)
{
if(PHPVERSION==4)
{
print_r($var);
}
else
{
var_dump($var);
}
}
?>
然后在error_require.php中包含这两个文件:
复制代码 代码如下:
require("fool.inc");
require("util.inc");//此句会产生一个错误
$foo=array("1",array("complex","quaternion"));
echo "this is requiring util.inc again which is also
\n";
echo "required in fool.inc\n";
echo "Running goodTea:".goodTea()."
\n";
echo "Printing foo:
\n";
showVar($foo);
?>
当运行error_require.php时,输出结果如下:
GLOBALS ARE NICE
GLOBALS ARE NICE
Fatal error:Cannot redeclare goodTea() in util.inc on line 4
如果使用require_once()语句来代替 require()语句,就不会出现上面的错误。我们把error_require.php和fool.inc中的require()语句改为require_once()语句并重命名为error_require_once.php,这是显示结果如下:
GLOBALS ARE NICE
this is requiring util.inc again which is also
required in fool.inc Running goodTea:Olong tea tastes good!
Printing foo:
Array([0] => 1 [1] => Array ([0] => complex [1] = quaternion))
include_once()语句的语法和include()语句类似,主要区别也是避免多次包含一个文件而引起函数或变量的重复定义。
require_once语句有一个引用链,它可以保证文件加入你的程序仅仅只有一次,而且会避开变量值和函数名之间的冲突。
和require_once语句一样,include_once语句把include的功能扩展了。在程序执行期间,将指定的文件包含进来,如果从文件引用进来的程序先前已经包含过的时候,include_once()就不会把它再包含进来。也就是仅仅可以引用同一个文件一次!
include_once() 语句在脚本执行期间包含并运行指定文件。此行为和 include() 语句类似,唯一区别是如果该文件中的代码已经被包含了,则不会再次包含。如同此语句名字暗示的那样,只会包含一次。
include_once() 应该用于在脚本执行期间同一个文件有可能被包含超过一次的情况下,想确保它只被包含一次以避免函数重定义,变量重新赋值等问题。
使用 require_once() 和 include_once() 的更多例子见最新的 PHP 源程序发行包中的 PEAR 代码。
返回值和 include() 相同。如果文件已被包含,本函数返回 TRUE。
注: include_once() 是 PHP 4.0.1pl2 中新加入的。
注: 要注意 include_once() 和 require_once() 在大小写不敏感的操作系统中(例如 Windows)的行为
可能不是所期望的。
例子: include_once() 在 Windows 下不区分大小写
复制代码 代码如下:
include_once("a.php"); // this will include a.php
include_once("A.php"); // this will include a.php again on Windows! (PHP 4 only)
?>
此行为在 PHP 5 中改了,路径先被规格化,因此 C:\PROGRA~1\A.php 和 C:\Program Files\a.php 的实现一样,文件只会被包含一次。
如果要包含的文件不存在,include提示notice,然后继续执行下面的语句,require提示致命错误并且退出。
win32平台下它们都是先包含后执行,所以被包含文件里最好不要再有include或require语句,这样会造成目录混乱。或许Linux下情况不同,暂时还没测试。
如果一个文件不想被包含多次可以使用include_once或require_once## 读取,可以写入文档数据。
复制代码 代码如下:
function r($file_name) {
$filenum=@fopen($file_name,"r");
@flock($filenum,LOCK_SH);
$file_data=@fread($filenum,filesize($file_name));
@fclose($filenum);
return $file_data;
}
function w($file_name,$data,$method="w"){
$filenum=@fopen($file_name,$method);
flock($filenum,LOCK_EX);
$file_data=fwrite($filenum,$data);
fclose($filenum);
return $file_data;
}

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Dans le langage C, la principale différence entre Char et WCHAR_T est le codage des caractères: Char utilise ASCII ou étend ASCII, WCHAR_T utilise Unicode; Char prend 1 à 2 octets, WCHAR_T occupe 2-4 octets; Char convient au texte anglais, WCHAR_T convient au texte multilingue; Le char est largement pris en charge, WCHAR_T dépend de la prise en charge du compilateur et du système d'exploitation Unicode; Le char est limité dans la gamme de caractères, WCHAR_T a une gamme de caractères plus grande et des fonctions spéciales sont utilisées pour les opérations arithmétiques.

La différence entre le multithreading et l'asynchrone est que le multithreading exécute plusieurs threads en même temps, tandis que les opérations effectuent de manière asynchrone sans bloquer le thread actuel. Le multithreading est utilisé pour les tâches à forte intensité de calcul, tandis que de manière asynchrone est utilisée pour l'interaction utilisateur. L'avantage du multi-threading est d'améliorer les performances informatiques, tandis que l'avantage des asynchrones est de ne pas bloquer les threads d'interface utilisateur. Le choix du multithreading ou asynchrone dépend de la nature de la tâche: les tâches à forte intensité de calcul utilisent le multithreading, les tâches qui interagissent avec les ressources externes et doivent maintenir la réactivité de l'interface utilisateur à utiliser asynchrone.

Il n'y a pas de fonction de somme intégrée dans le langage C, il doit donc être écrit par vous-même. La somme peut être obtenue en traversant le tableau et en accumulant des éléments: Version de boucle: la somme est calculée à l'aide de la longueur de boucle et du tableau. Version du pointeur: Utilisez des pointeurs pour pointer des éléments de tableau, et un résumé efficace est réalisé grâce à des pointeurs d'auto-incitation. Allouer dynamiquement la version du tableau: allouer dynamiquement les tableaux et gérer la mémoire vous-même, en veillant à ce que la mémoire allouée soit libérée pour empêcher les fuites de mémoire.

Le char et le char non signé sont deux types de données qui stockent les données des caractères. La principale différence est le moyen de gérer les nombres négatifs et positifs: plage de valeur: char signé (-128 à 127), et Char non signé Unsigned (0 à 255). Traitement du nombre négatif: le char peut stocker des nombres négatifs, le char non signé ne peut pas. Mode bit: Char le bit le plus élevé représente le symbole, un bit non signé non signé. Opérations arithmétiques: le char et le char non signé sont signés et non signés, et leurs opérations arithmétiques sont différentes. Compatibilité: char et char non signé

Les fonctions de langue C sont la base de la modularisation du code et de la construction de programmes. Ils se composent de déclarations (en-têtes de fonction) et de définitions (corps de fonction). Le langage C utilise des valeurs pour transmettre les paramètres par défaut, mais les variables externes peuvent également être modifiées à l'aide d'adresse Pass. Les fonctions peuvent avoir ou ne pas avoir de valeur de retour et le type de valeur de retour doit être cohérent avec la déclaration. La dénomination de la fonction doit être claire et facile à comprendre, en utilisant un chameau ou une nomenclature de soulignement. Suivez le principe de responsabilité unique et gardez la simplicité de la fonction pour améliorer la maintenabilité et la lisibilité.

Les fonctions de langue C sont des blocs de code réutilisables. Ils reçoivent des entrées, effectuent des opérations et renvoient les résultats, ce qui améliore modulairement la réutilisabilité et réduit la complexité. Le mécanisme interne de la fonction comprend le passage des paramètres, l'exécution de la fonction et les valeurs de retour. L'ensemble du processus implique une optimisation telle que la fonction en ligne. Une bonne fonction est écrite en suivant le principe de responsabilité unique, un petit nombre de paramètres, des spécifications de dénomination et une gestion des erreurs. Les pointeurs combinés avec des fonctions peuvent atteindre des fonctions plus puissantes, telles que la modification des valeurs de variables externes. Les pointeurs de fonctions passent les fonctions comme des paramètres ou des adresses de magasin, et sont utilisées pour implémenter les appels dynamiques aux fonctions. Comprendre les fonctionnalités et les techniques des fonctions est la clé pour écrire des programmes C efficaces, maintenables et faciles à comprendre.

Le multithreading est une technologie importante dans la programmation informatique et est utilisée pour améliorer l'efficacité de l'exécution du programme. Dans le langage C, il existe de nombreuses façons d'implémenter le multithreading, y compris les bibliothèques de threads, les threads POSIX et l'API Windows.

H5. La principale différence entre les mini programmes et l'application est: Architecture technique: H5 est basé sur la technologie Web, et les mini-programmes et l'application sont des applications indépendantes. Expérience et fonctions: H5 est légère et facile à utiliser, avec des fonctions limitées; Les mini-programmes sont légers et ont une bonne interactivité; Les applications sont puissantes et ont une expérience fluide. Compatibilité: H5 est compatible multiplateforme, les applets et les applications sont limités par la plate-forme. Coût de développement: H5 a un faible coût de développement, des mini-programmes moyens et une application la plus élevée. Scénarios applicables: H5 convient à l'affichage d'informations, les applets conviennent aux applications légères et les applications conviennent aux fonctions complexes.
