• PHP signifie PHP : Hypertext Preprocessor
  
• Les fichiers PHP peuvent contenir du texte, du code HTML, du code JavaScript et du code PHP
  
• Le code PHP est exécuté sur le serveur, et le résultat est renvoyé au navigateur sous forme de HTML brut
  
• L'extension de fichier par défaut des fichiers PHP est ".php"

Que peut faire PHP ?

• PHP peut générer du contenu de page dynamique
  
• PHP peut créer, ouvrir, lire, écrire et fermer des fichiers sur le serveur
  
• PHP peut collecter des données de formulaire
  
• PHP peut envoyer et recevoir des cookies
  
• PHP peut ajouter, supprimer et modifier des données dans votre base de données
  
• PHP peut restreindre l'accès des utilisateurs à certaines pages de votre site Web
  
• PHP peut chiffrer des données

Installation

Si votre serveur ne prend pas en charge PHP, vous devez :

1. Installer un serveur web
   
2. Installer PHP
   
3. Installer une base de données, telle que MySQL
   Le site officiel de PHP (PHP.net) contient les instructions d'installation de PHP :http://php.net/manual/en/install.php

Environnement de développement intégré recommandé : WAMPhttp://www.wampserver.com/

Syntaxe de base de PHP

Les scripts PHP peuvent être placés n'importe où dans un document.

Les scripts PHP commencent par <?php et se terminent par ?> :

<!DOCTYPE html>
<html>
<body>

<h1>我的第一个 PHP 页面</h1>

<?php
echo "Hello World!";

// 这是一行注释

/*
这是
多行
注释
*/

?>

</body>
</html>

Chaque ligne de code en PHP doit se terminer par un point-virgule

Deux instructions de base pour afficher du texte dans le navigateur : echo et print.

Variables PHP

Les variables commencent par le symbole $, suivi du nom de la variable

PHP n'a pas de commande pour déclarer des variables.

Une variable est créée lorsque vous lui affectez une valeur pour la première fois :

PHP est un langage faiblement typé
PHP convertit automatiquement la variable vers le type de données correct en fonction de sa valeur.

Dans les langages de programmation fortement typés, nous devons déclarer (définir) le type et le nom d'une variable avant de l'utiliser.

Portée des variables PHP

PHP possède quatre portées de variables différentes :

• local
  
• global
  
• static
  
• paramètre

Portée locale et globale

Les variables définies en dehors de toutes les fonctions ont une portée globale. Les variables globales peuvent être accessibles par n'importe quelle partie du script sauf les fonctions. Pour accéder à une variable globale à l'intérieur d'une fonction, vous devez utiliser le mot-clé global.

Les variables déclarées à l'intérieur d'une fonction PHP sont des variables locales et ne sont accessibles qu'à l'intérieur de la fonction :

<?php
$x=5; // 全局变量

function myTest()
{
    $y=10; // 局部变量
    echo "<p>测试变量在函数内部:<p>";
    echo "变量 x 为: $x";
    echo "<br>";
    echo "变量 y 为: $y";
} 

myTest();

echo "<p>测试变量在函数外部:<p>";
echo "变量 x 为: $x";
echo "<br>";
echo "变量 y 为: $y";
?>

Pour accéder à une variable globale définie en dehors d'une fonction depuis l'intérieur d'une fonction, nous devons placer le mot-clé global devant la variable à l'intérieur de la fonction :

<?php
$x=5;
$y=10;

function myTest()
{
    global $x,$y;
    $y=$x+$y;
}

myTest();
echo $y; // 输出 15
?>

PHP stocke toutes les variables globales dans un tableau nommé $GLOBALS[index]. L'index contient le nom de la variable. Ce tableau est accessible à l'intérieur des fonctions et peut également être utilisé directement pour mettre à jour les variables globales.

<?php
$x=5;
$y=10;

function myTest()
{
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
} 

myTest();
echo $y;
?>

Portée statique

Lorsqu'une fonction se termine, toutes ses variables sont généralement supprimées. Cependant, parfois, vous voulez qu'une variable locale ne soit pas supprimée ; vous pouvez utiliser le mot-cléstatickeyword

<?php

function myTest()
{
    static $x=0;
    echo $x;
    $x++;
}

myTest();
myTest();
myTest();

?>

Portée des paramètres

Les paramètres sont des variables locales qui reçoivent les valeurs transmises à la fonction par le code appelant.

Les paramètres sont déclarés dans la liste des paramètres, dans le cadre de la déclaration de la fonction :

<?php

function myTest($x)
{
    echo $x;
}

myTest(5);

?>

Instructions echo et print en PHP

• echo - peut afficher une ou plusieurs chaînes
  
• print - permet uniquement d'afficher une chaîne, et sa valeur de retour est toujours 1

Astuce : echo affiche plus rapidement que print, echo n'a pas de valeur de retour, et print a une valeur de retour de 1.
echo et print sont tous deux des constructions du langage. Lorsque vous les utilisez, vous pouvez omettre les parenthèses ou ajouter des parenthèses : echo ou echo(), print ou print().

<?php
echo "<h2>PHP is fun!</h2>";
echo "Hello world!<br>";
echo "I'm about to learn PHP!<br>";
echo "This", " string", " was", " made", " with multiple parameters.";

print "<h2>PHP is fun!</h2>";
print "Hello world!<br>";
print "I'm about to learn PHP!";

?>

L'exemple suivant montre comment utiliser la commande echo pour afficher des variables et des chaînes :

<?php
$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

echo $txt1;
echo "<br>";
echo "Study PHP at $txt2"; //php 双引号内部可包含变量
echo "My car is a {$cars[0]}"; //用大括号 显式的指定这是变量

$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

print $txt1;
print "<br>";
print "Study PHP at $txt2";
print "My car is a {$cars[0]}";

?>

Types de données PHP5

Chaîne, entier, flottant, booléen, tableau, objet, NULL (valeur null).

String
Vous pouvez placer n'importe quel texte entre guillemets simples et guillemets doubles :

<?php 
$x = "Hello world!";
echo $x;
echo "<br>"; 
$x = 'Hello world!'; //单引号 包括字符串字面量 双引号包含的字符串 可包含变量
echo $x;
?>

Integer
Dans l'exemple suivant, nous allons tester différents nombres. PHPvar_dump()La fonction renvoie le type de données et la valeur d'une variable :

?php 
$x = 5985;
var_dump($x);
echo "<br>"; 
$x = -345; // 负数 
var_dump($x);
echo "<br>"; 
$x = 0x8C; // 十六进制数
var_dump($x);
echo "<br>";
$x = 047; // 八进制数
var_dump($x);
?>

Float

<?php 
$x = 10.365;
var_dump($x);
echo "<br>"; 
$x = 2.4e3;
var_dump($x);
echo "<br>"; 
$x = 8E-5;
var_dump($x);
?>

Boolean

Un booléen peut être TRUE ou FALSE.

Tableau

Un tableau peut stocker plusieurs valeurs dans une seule variable

<?php 
$cars=array("Volvo","BMW","Toyota");
var_dump($cars);
?>

Object

En PHP, les objets doivent être déclarés.

Tout d'abord, vous devez déclarer un objet de classe à l'aide du mot-clé class. Une classe est une structure qui peut contenir des propriétés et des méthodes.
Ensuite, nous définissons les types de données dans la classe, puis nous utilisons les types de données dans la classe instanciée :

<?php
class Car
{
    var $color;
    function Car($color="green") {
      $this->color = $color;
    }
    function what_color() {
      return $this->color;
    }
}

function print_vars($obj) {
   foreach (get_object_vars($obj) as $prop => $val) {
     echo "\t$prop = $val\n";
   }
}

// instantiate one object
$herbie = new Car("white");

// show herbie properties
echo "\herbie: Properties\n";
print_vars($herbie);

?>  

Valeur NULL
La valeur NULL indique qu'une variable n'a pas de valeur. NULL est une valeur de type de données NULL.

<?php
$x="Hello world!";
$x=null;
var_dump($x);
?>

Constantes

Une constante est un identifiant pour une valeur simple. Cette valeur ne peut pas être modifiée pendant l'exécution du script. (Un nom de constante n'a pas besoin du modificateur $.)

Remarque : Les constantes peuvent être utilisées dans tout le script.

Pour définir une constante, utilisez la fonction define(), dont la syntaxe est la suivante :

define(string constant_name, mixed value, case_sensitive = true)
Cette fonction a trois paramètres :

• constant_name : Paramètre obligatoire, le nom de la constante, c’est-à-dire l’identifiant.
  
• value : Paramètre obligatoire, la valeur de la constante.
  
• case_sensitive : Paramètre facultatif, indique s’il est sensible à la casse ; définissez-le sur true pour indiquer qu’il est insensible à la casse.

L’exemple suivant crée une constante sensible à la casse avec la valeur "Welcome to example.com!" :

<?php
define("GREETING", "Welcome to example.com!");
echo GREETING;
?>

Fonctions de chaîne et concaténation de chaînes

<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2; // 字符串连接运算符 .

echo strlen("Hello world!"); //获取字符串长度
echo strpos("Hello world!","world"); //获取子串位置
//字符串中第一个字符的位置是 0
?>

Opérateurs

<?php
//其他运算符略..
//逻辑运算符 ! && || and or xor
//数组运算符 合并: + 比较：== != === !==
$x = array("a" => "red", "b" => "green"); 
$y = array("c" => "blue", "d" => "yellow"); 
$z = $x + $y; // $x 和 $y 数组合并
var_dump($z);
var_dump($x == $y);
var_dump($x === $y);
var_dump($x != $y);
var_dump($x <> $y);
var_dump($x !== $y);
?>

Instructions de contrôle de flux, comme en JS

<?php

$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}



$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$t=date("H");
if ($t<"10")
{
    echo "Have a good morning!";
}
else if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$favcolor="red";
switch ($favcolor)
{
    case "red":
    echo "Your favorite color is red!";
    break;
    case "blue":
    echo "Your favorite color is blue!";
    break;
    case "green":
    echo "Your favorite color is green!";
    break;
    default:
    echo "Your favorite color is neither red, blue, or green!";
}

//循环
$i=1;
while($i<=5)
{
    echo "The number is " . $i . "<br>";
    $i++;
}


$i=1;
do
{
    $i++;
    echo "The number is " . $i . "<br>";
}
while ($i<=5);

for ($i=1; $i<=5; $i++)
{
    echo "The number is " . $i . "<br>";
}


$x=array("one","two","three");
foreach ($x as $value)
{
    echo $value . "<br>";
}

?>

Tableaux

<?php
$cars=array("Volvo","BMW","Toyota"); //数组定义 数值数组
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . "."; //访问数组元素

//数组长度count()
$cars=array("Volvo","BMW","Toyota");
echo count($cars); //count() 函数用于返回数组的长度

//遍历数值数组
$cars=array("Volvo","BMW","Toyota");
$arrlength=count($cars);

for($x=0;$x<$arrlength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");//定义关联数组
echo "Peter is " . $age['Peter'] . " years old.";

//遍历关联数组
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
foreach($age as $x=>$x_value)
{
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
}
?>

Tri de tableau

PHP - Fonctions de tri des tableaux

• sort() - trie un tableau par ordre croissant
  
• rsort() - trie un tableau par ordre décroissant
  
• asort() - trie un tableau associatif par ordre croissant selon la valeur
  
• ksort() - trie un tableau associatif par ordre croissant selon la clé
  
• arsort() - trie un tableau associatif par ordre décroissant selon la valeur
  
• krsort() - trie un tableau associatif par ordre décroissant selon la clé

//sort()
$cars=array("Volvo","BMW","Toyota");
sort($cars);

$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

//rsort()   
$cars=array("Volvo","BMW","Toyota");
rsort($cars);   

//asort() arsort() 关联数组排序 value
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
asort($age);
arsort($age);

//ksort() krsort() 关联数组排序 key
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
ksort($age);
krsort($age);
?>

Variables superglobales

PHP prédéfinit plusieurs variables superglobales, ce qui signifie qu'elles sont disponibles dans toutes les portées tout au long d'un script.

• $GLOBALS
  
• $_SERVER
  
• $_REQUEST
  
• $_POST
  
• $_GET
  
• $_COOKIE
  
• $_FILES
  
• $_ENV
  
• $_SESSION

$GLOBAL est un tableau combiné global qui contient toutes les variables. Les noms des variables sont les clés du tableau.

<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

$_SERVER est un tableau contenant des informations telles que les en-têtes, les chemins et les emplacements de script. Les éléments de ce tableau sont créés par le serveur web. Il n'y a aucune garantie que chaque serveur fournisse tous les éléments;

<?php 
echo $_SERVER['PHP_SELF']; // /try/demo_source/demo_global_server.php
echo "<br>";
echo $_SERVER['SERVER_NAME']; // example.com
echo "<br>";
echo $_SERVER['HTTP_HOST']; // www.example.com
echo "<br>";
echo $_SERVER['HTTP_REFERER']; //来由
echo "<br>";
echo $_SERVER['HTTP_USER_AGENT']; //浏览器
echo "<br>";
echo $_SERVER['SCRIPT_NAME']; // /try/demo_source/demo_global_server.php

//另外$_SERVER对象还包括 SERVER_ADDR, SERVER_PROTOCOL ,REQUEST_METHOD..等属性

?>

$_REQUEST est utilisé pour collecter les données soumises par les formulaires HTML.

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_REQUEST['fname']; 
echo $name; 
?>

</body>
</html>

$_POST est largement utilisé pour collecter les données de formulaire. Spécifiez cet attribut dans la balise de formulaire HTML : "method="post"

<html>
<body>
<!--页面post给自己-->
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_POST['fname']; 
echo $name; 
?>

</body>
</html>

$_GET est également largement utilisé pour collecter les données de formulaire. Spécifiez cet attribut dans la balise de formulaire HTML : "method="get".

$_GET peut également collecter les données envoyées dans l'URL.

<html>
<body>

<a href="test_get.php.html">Test $GET</a>

</body>
</html>

//test_get.php

<html>
<body>

<?php 
echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
?>

</body>
</html>

Fonctions PHP

La véritable puissance de PHP vient de ses fonctions.

En PHP, plus de 1000 fonctions intégrées sont fournies.

<html>
<body>

<?php
function writeName()
{
    echo "Kai Jim Refsnes";
}

echo "My name is ";
writeName();

//函数传参
function writeName($fname,$punctuation)
{
    echo $fname . " Refsnes" . $punctuation . "<br>";
}

echo "My name is ";
writeName("Kai Jim",".");
echo "My sister's name is ";

//函数返回值
function add($x,$y)
{
    $total=$x+$y;
    return $total;
}

echo "1 + 16 = " . add(1,16);

?>

</body>
</html>

Variables magiques

Il existe huit constantes magiques dont les valeurs changent selon leur position dans le code.

• _LINE__
  Le numéro de ligne actuel dans le fichier.
  
• FILE
  Le chemin complet et le nom du fichier. Si cette constante est utilisée dans un fichier inclus, le nom du fichier inclus est renvoyé.
  
• DIR
  Le répertoire du fichier. Si cette constante est utilisée dans un fichier inclus, le répertoire du fichier inclus est renvoyé.
  
• FUNCTION
  Le nom de la fonction (nouveau dans PHP 4.3.0). À partir de PHP 5, cette constante renvoie le nom de la fonction tel qu’il a été défini (sensible à la casse). Dans PHP 4, la valeur est toujours en minuscules.

<?php
function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test();
?>

• CLASSLe nom de la classe (nouveau dans PHP 4.3.0). À partir de PHP 5, cette constante renvoie le nom de la classe tel qu’il a été défini (sensible à la casse).

Dans PHP 4, la valeur est toujours en minuscules. Le nom de la classe inclut sa portée déclarée (par ex. Foo\Bar). Notez qu’à partir de PHP 5.4,CLASSfonctionne aussi avec les traits. Lorsqu’elle est utilisée dans une méthode de trait,CLASScorrespond au nom de la classe qui utilise la méthode du trait.

<?php
class test {
    function _print() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new test();
$t->_print();
?>

• TRAITLe nom du trait (nouveau dans PHP 5.4.0). À partir de PHP 5.4.0, PHP implémente une méthode de réutilisation de code appelée traits.

Le nom du trait inclut sa portée déclarée (par ex. Foo\Bar).

Le membre hérité de la classe de base est remplacé par la méthode MyHelloWorld insérée dans le trait SayWorld. Son comportement est identique à celui de la méthode définie dans la classe MyHelloWorld. L’ordre de priorité est le suivant : les méthodes de la classe courante remplacent les méthodes de trait, et les méthodes de trait remplacent à leur tour les méthodes de la classe de base.

<?php
class Base {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'World!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>

• METHODLe nom de la méthode de classe (nouveau dans PHP 5.0.0). Renvoie le nom de la méthode tel qu’il a été défini (sensible à la casse).

<?php
function test() {
    echo  '函数名为：' . __METHOD__ ;
}
test();
?>

• NAMESPACELe nom de l’espace de noms courant (sensible à la casse). Cette constante est définie au moment de la compilation (nouveau dans PHP 5.3.0).

<?php
namespace MyProject;

echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

Espaces de noms

Les espaces de noms PHP ont été ajoutés dans PHP 5.3. Si vous avez appris C# et Java, les espaces de noms ne sont pas une nouveauté. Cependant, ils ont encore une importance considérable en PHP.

Les espaces de noms PHP peuvent résoudre les deux types de problèmes suivants :

• Les collisions de noms entre le code utilisateur et les classes/fonctions/constantes internes de PHP.
  
• Créer des alias (ou des noms raccourcis), améliorant la lisibilité du code source.

Par défaut, toutes les constantes, classes et noms de fonctions sont placés dans l’espace global, exactement comme avant que PHP ne prenne en charge les espaces de noms.
Si un fichier contient des espaces de noms, la déclaration d'espace de noms doit précéder tout autre code.

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...  

//也可以在同一个文件中定义不同的命名空间代码
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  

?>

Le seul code autorisé avant de déclarer un espace de noms est une instruction declare utilisée pour définir l'encodage du fichier source. Tout code non-PHP, y compris les espaces blancs, ne peut pas apparaître avant la déclaration d'espace de noms.

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace { // 全局代码
    session_start();
    $a = MyProject\connect();
    echo MyProject\Connection::start();
}
?>

Le code suivant provoquera une erreur de syntaxe :

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

Sous-espaces de noms

<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间
//创建了常量 MyProject\Sub\Level\CONNECT_OK，
//类 MyProject\Sub\Level\Connection 
//和函数 MyProject\Sub\Level\Connect.

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

Utilisation des espaces de noms
Les noms de classes dans les espaces de noms PHP peuvent être référencés de trois manières :

1. Noms non qualifiés, ou noms de classe sans préfixe, par ex. $a=new foo(); ou foo::staticmethod();. Si l'espace de noms courant est currentnamespace, foo sera résolu en currentnamespace\foo. Si le code qui utilise foo est global, c'est-à-dire du code non contenu dans un espace de noms, foo sera résolu en foo. Avertissement : si une fonction ou une constante dans un espace de noms n'est pas définie, le nom de fonction ou de constante non qualifié sera résolu en le nom global de fonction ou de constante.~~Référence sans préfixe d'espace de noms : par défaut, recherche dans l'espace de noms courant, puis dans l'espace de noms global.

2. Noms qualifiés, ou noms contenant un préfixe, par ex. $a = new subnamespace\foo(); ou subnamespace\foo::staticmethod();. Si l'espace de noms courant est currentnamespace, foo sera résolu en currentnamespace\subnamespace\foo. Si le code qui utilise foo est global, c'est-à-dire du code non contenu dans un espace de noms, foo sera résolu en subnamespace\foo.~~Référence avec un préfixe d'espace de noms relatif (semblable à un chemin relatif) ; ajoute automatiquement en préfixe l'espace de noms du code appelant.

3. Noms pleinement qualifiés, ou noms contenant l'opérateur de préfixe global, par ex. $a = new \currentnamespace\foo(); ou \currentnamespace\foo::staticmethod();. Dans ce cas, foo est toujours résolu en le nom littéral dans le code, currentnamespace\foo.~~Référence avec un préfixe d'espace de noms absolu (semblable à un chemin absolu). Le chemin de référence est explicite et aucune recherche n'est nécessaire.

file1.php

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

file2.php

<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为函数 Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod.
echo FOO; // resolves to constant Foo\Bar\FOO

/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
                                  // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
                                  
/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

Accéder aux classes, fonctions et constantes globales depuis un espace de noms :

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>

Espaces de noms et fonctionnalités dynamiques du langage

L'implémentation des espaces de noms en PHP est affectée par les fonctionnalités dynamiques du langage lui-même. Par conséquent, si vous voulez convertir le code suivant en espaces de noms, accédez aux éléments dynamiquement.

//example.php

<?php
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global
?>

<?php
namespace namespacename;
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "namespaced";

include 'example1.php';//全局命名空间和某个命名空间有相同类 函数 和 常量 分别区别访问

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global

/* note that if using double quotes, "\\namespacename\\classname" must be used */
$a = '\namespacename\classname';
$obj = new $a; // prints namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // also prints namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // prints namespacename\funcname
$b = '\namespacename\funcname';
$b(); // also prints namespacename\funcname
echo constant('\namespacename\constname'), "\n"; // prints namespaced
echo constant('namespacename\constname'), "\n"; // also prints namespaced
?>

Mot-clé namespace et constante __NAMESPACE__

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

Création dynamique de noms avec __NAMESPACE__

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\\' . $classname;
    return new $a;
}
?>

Le mot-clé namespace peut être utilisé pour accéder explicitement aux éléments de l'espace de noms courant ou d'un sous-espace de noms. Il est équivalent à l'opérateur self dans les classes.

<?php
namespace MyProject;

use blah\blah as mine; // see "Using namespaces: importing/aliasing"

blah\mine(); // calls function blah\blah\mine()
namespace\blah\mine(); // calls function MyProject\blah\mine()

namespace\func(); // calls function MyProject\func()
namespace\sub\func(); // calls function MyProject\sub\func()
namespace\cname::method(); // calls static method "method" of class MyProject\cname
$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname
$b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b
?>

En PHP, les alias sont implémentés avec l'opérateur use. Voici un exemple utilisant les trois manières possibles d'importer :

1. Importer/utiliser des alias avec l'opérateur use

<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>

1. Plusieurs instructions use sur une seule ligne

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>
<p>导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。</p>
<ol>
<li>导入和动态名称</li>
</ol>
<pre>
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

1. Importation et noms dynamiques

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

De plus, l'opération d'importation n'affecte que les noms non qualifiés et qualifiés. Comme les noms pleinement qualifiés sont définitifs, ils ne sont pas affectés par l'importation.

1. Importation et noms pleinement qualifiés

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // instantiates object of class My\Full\Classname
$obj = new \Another; // instantiates object of class Another
$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing
$obj = new \Another\thing; // instantiates object of class Another\thing
?>

Utilisation des espaces de noms : repli vers les fonctions/constantes globales

Dans un espace de noms, lorsque PHP rencontre un nom de classe, de fonction ou de constante non qualifié, il utilise différentes stratégies de priorité pour résoudre ce nom.

• Les noms de classes sont toujours résolus vers des noms de l'espace de noms courant (une erreur est levée s'ils sont introuvables).Par conséquent, lors de l'accès à des classes système internes ou à des noms de classes non contenus dans un espace de noms, vous devez utiliser des noms pleinement qualifiés.
  
• Pour les fonctions et les constantes, si la fonction ou la constante n'existe pas dans l'espace de noms courant, PHP se replie sur l'utilisation de la fonction ou de la constante dans l'espace global.

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

Espace global
Si aucun espace de noms n'est défini, toutes les définitions de classes et de fonctions se trouvent dans l'espace global, exactement comme avant que PHP n'introduise le concept d'espaces de noms. Préfixer un nom avec \ indique que ce nom est un nom de l'espace global, même lorsque ce nom se trouve dans un autre espace de noms.

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

Ordre des espaces de noms (omis..)

Gestion des fichiers PHP

Ouverture de fichiers

$file = fopen($fname, mode) // nom du fichier, mode d'ouverture

• r Lecture seule. Commence au début du fichier.
  
• r+ Lecture/Écriture. Commence au début du fichier.
  
• w Écriture seule. Ouvre et efface le contenu du fichier ; si le fichier n'existe pas, crée un nouveau fichier.
  
• w+ Lecture/Écriture. Ouvre et efface le contenu du fichier ; si le fichier n'existe pas, crée un nouveau fichier.
  
• a Ajout. Ouvre et écrit à la fin du fichier ; si le fichier n'existe pas, crée un nouveau fichier.
  
• a+ Lecture/Ajout. Ouvre et écrit à la fin du fichier pour préserver le contenu du fichier.
  
• x Écriture seule. Crée un nouveau fichier. Retourne FALSE et une erreur si le fichier existe déjà.
  
• x+ Lecture/Écriture. Crée un nouveau fichier. Retourne FALSE et une erreur si le fichier existe déjà.

Remarque : si la fonction fopen() ne peut pas ouvrir le fichier spécifié, elle retourne 0 (false).

<?php
//打开文件
$file = fopen("welcome.txt", "r") or exit("Unable to open file!");
//Output a line of the file until the end is reached

//是否到达文件末尾 
while(!feof($file))
{
    echo fgets($file). "<br>"; //逐行读取文件
    //echo fgetc($file); //逐字符读取

}
//关闭文件
fclose($file);
?>

Fonctions du système de fichiers

• basename() Retourne la partie nom de fichier d'un chemin.
  
• chgrp() Modifie le groupe du fichier.
  
• chmod() Modifie le mode du fichier.
  
• chown() Modifie le propriétaire du fichier.
  
• clearstatcache() Efface le cache des statistiques de fichier.
  
• copy() Copie un fichier.
  
• delete() Voir unlink() ou unset()
  
• dirname() Retourne la partie nom de répertoire d'un chemin.
  
• disk_free_space() Retourne l'espace disponible dans un répertoire.
  
• disk_total_space() Retourne la capacité totale du disque d'un répertoire.
  
• diskfreespace() Alias de disk_free_space().
  
• fclose() Ferme un fichier ouvert.
  
• feof() Teste si le pointeur de fichier est à la fin du fichier.
  
• fflush() Vide la sortie mise en tampon vers un fichier ouvert.
  
• fgetc() Retourne un caractère depuis un fichier ouvert.
  
• fgetcsv() Analyse une ligne depuis un fichier ouvert, en vérifiant les champs CSV.
  
• fgets() Retourne une ligne d'un fichier ouvert.
  
• fgetss() Retourne une ligne d'un fichier ouvert et filtre les balises HTML et PHP.
  
• file() Lit un fichier dans un tableau.
  
• file_exists() Vérifie si un fichier ou un répertoire existe.
  
• file_get_contents() Lit un fichier dans une chaîne. ~~Obtenir le contenu du fichier
  
• file_put_contents() Écrit une chaîne dans un fichier. ~~Écrire le contenu du fichier
  
• fileatime() Retourne l'heure du dernier accès à un fichier.
  
• filectime() Retourne l'heure de la dernière modification d'un fichier.
  
• filegroup() Retourne l'ID du groupe d'un fichier.
  
• fileinode() Retourne le numéro d'inode d'un fichier.
  
• filemtime() Retourne l'heure de la dernière modification du contenu d'un fichier.
  
• fileowner() Retourne l'ID utilisateur (propriétaire) d'un fichier.
  
• fileperms() Retourne les permissions du fichier.
  
• filesize() Retourne la taille du fichier.
  
• filetype() Retourne le type de fichier.
  
• flock() Verrouille ou libère un fichier.
  
• fnmatch() Vérifie si un nom de fichier ou une chaîne correspond à un modèle spécifié.
  
• fopen() Ouvre un fichier ou une URL.
  
• fpassthru() Lit les données d'un fichier ouvert jusqu'à la fin du fichier (EOF) et écrit le résultat dans le tampon de sortie.
  
• fputcsv() Formate une ligne en CSV et l'écrit dans un fichier ouvert.
  
• fputs() Alias de fwrite().
  
• fread() Lit un fichier ouvert.
  
• fscanf() Analyse l'entrée selon un format spécifié.
  
• fseek() Positionne le pointeur dans un fichier ouvert.
  
• fstat() Retourne des informations sur un fichier ouvert.
  
• ftell() Retourne la position actuelle dans un fichier ouvert.
  
• ftruncate() Tronque un fichier ouvert à une longueur spécifiée.
  
• fwrite() Écrit dans un fichier ouvert.
  
• glob() Retourne un tableau contenant les noms de fichiers/répertoires qui correspondent à un motif spécifié.
  
• is_dir() Vérifie si un fichier est un répertoire.
  
• is_executable() Vérifie si un fichier est exécutable.
  
• is_file() Vérifie si un fichier est un fichier régulier.
  
• is_link() Vérifie si un fichier est un lien.
  
• is_readable() Vérifie si un fichier est lisible.
  
• is_uploaded_file() Vérifie si un fichier a été téléversé via HTTP POST.
  
• is_writable() Vérifie si un fichier est accessible en écriture.
  
• is_writeable() Alias de is_writable().
  
• lchgrp() Modifie le propriétaire de groupe d’un lien symbolique.
  
• lchown() Modifie le propriétaire utilisateur d’un lien symbolique.
  
• link() Crée un lien matériel.
  
• linkinfo() Retourne des informations sur un lien matériel.
  
• lstat() Retourne des informations sur un fichier ou un lien symbolique.
  
• mkdir() Crée un répertoire.
  
• move_uploaded_file() Déplace un fichier téléchargé vers un nouvel emplacement.
  
• parse_ini_file() Analyse un fichier de configuration.
  
• parse_ini_string() Analyse une chaîne de configuration.
  
• pathinfo() Retourne des informations sur un chemin d’accès.
  
• pclose() Ferme un processus ouvert par popen().
  
• popen() Ouvre un processus.
  
• readfile() Lit un fichier et l'écrit dans le tampon de sortie.
  
• readlink() Renvoie la cible d'un lien symbolique.
  
• realpath() Renvoie le chemin absolu.
  
• realpath_cache_get() Renvoie les entrées du cache.
  
• realpath_cache_size() Renvoie la taille du cache.
  
• rename() Renomme un fichier ou un répertoire.
  
• rewind() Rembobine la position d'un pointeur de fichier.
  
• rmdir() Supprime un répertoire vide.
  
• set_file_buffer() Définit la taille du tampon d'un fichier ouvert.
  
• stat() Renvoie des informations sur un fichier.
  
• symlink() Crée un lien symbolique.
  
• tempnam() Crée un fichier temporaire unique.
  
• tmpfile() Crée un fichier temporaire unique.
  
• touch() Définit l'heure d'accès et de modification d'un fichier.
  
• umask() Modifie les permissions des fichiers.
  
• unlink() Supprime un fichier.

PHP JSON

• json_encode Encode une variable au format JSON.
  
• json_decode Décode une chaîne au format JSON et la convertit en variable PHP.
  
• json_last_error Retourne la dernière erreur survenue.

string json_encode ( $value [, $options = 0 ] )
Parameters

value : La valeur à encoder. Cette fonction ne fonctionne qu'avec des données encodées en UTF-8.
options : Un masque de bits constitué des constantes suivantes : JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT.

<?php
   $arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);
   echo json_encode($arr);


    class Emp {
       public $name = "";
       public $hobbies  = "";
       public $birthdate = "";
   }
   $e = new Emp();
   $e->name = "sachin";
   $e->hobbies  = "sports";
   $e->birthdate = date('m/d/Y h:i:s a', "8/5/1974 12:20:03 p");
   $e->birthdate = date('m/d/Y h:i:s a', strtotime("8/5/1974 12:20:03"));

   echo json_encode($e);
?>

mixed json_decode ($json [,$assoc = false [, $depth = 512 [, $options = 0 ]]])
Parameters

json_string : La chaîne JSON à décoder. Il doit s'agir de données encodées en UTF-8.

assoc : Lorsque ce paramètre vaut TRUE, un tableau est renvoyé ; lorsqu'il vaut FALSE, un objet est renvoyé.

depth : Un paramètre entier qui spécifie la profondeur de récursion.

options : Un masque de bits. Actuellement, seul JSON_BIGINT_AS_STRING est pris en charge.

<?php
   $json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

   var_dump(json_decode($json));
   var_dump(json_decode($json, true));
?>

Plus de tutoriels

Pour des tutoriels plus détaillés, voir :Tutoriel PHP