Intégrer les fonctionnalités de PHP5.X à PHP7.1.x

Recommandé (gratuit) : PHP7

Tant de bonnes fonctionnalités et de bonnes méthodes, pourquoi ne pas les utiliser, je j'espère également que PHP ira de mieux en mieux.
Toutes les nouvelles fonctionnalités de PHP 5.1, PHP5.2, PHP5.3, PHP5.4, PHP5.5, PHP5.6, PHP7, PHP7.1 sont organisées ici et sont prêtes à être apprises et utilisées par tout le monde

Le serveur Web intégré possède un simple serveur Web intégré

Pour utiliser le répertoire actuel comme document racine, vous n'avez besoin que de cette commande :

php -S localhost:3300

Vous pouvez également spécifier d'autres chemins

php -S localhost:3300 -t /path/to/root

Vous pouvez également spécifier des routes

php -S localhost:3300 router.php

Espace de noms (php5.3)

Le délimiteur de l'espace de noms est une barre oblique inverse

namespace fox\lanmps\Table;    
class Select {}

Obtenir le nom complet de la catégorie

Les fonctions des classes d'alias d'espace de noms et des versions courtes de l'espace de noms ont été introduites dans PHP5.3. Bien que cela ne fonctionne pas pour les noms de classe de chaîne

use Some\Deeply\Nested\Namespace\FooBar;    
// does not work, because this will try to use the global `FooBar` class    $reflection = new ReflectionClass('FooBar');   
echo FooBar::class;

Pour résoudre ce problème, adoptez la nouvelle syntaxe FooBar::class, qui renvoie le nom complet de la classe

opération d'utilisation de l'espace de noms Le début du symbole prend en charge l'importation de fonctions et de constantes

namespace Name\Space {  
    const FOO = 42;  
    function f() { echo __FUNCTION__."\n"; }  
}  
namespace {  
    use const Name\Space\FOO;  
    use function Name\Space\f;  

    echo FOO."\n";  
    f();  
}

sortie
42
NameSpacef

Déclarations d'utilisation de groupe

à partir du Les classes, fonctions et constantes importées du même espace de noms peuvent désormais être importées en même temps avec une seule instruction d'utilisation.

//PHP7之前use some\namespace\ClassA;use some\namespace\ClassB;use some\namespace\ClassC as C;use function some\namespace\fn_a;use function some\namespace\fn_b;use function some\namespace\fn_c;use const some\namespace\ConstA;use const some\namespace\ConstB;use const some\namespace\ConstC;// PHP7之后use some\namespace\{ClassA, ClassB, ClassC as C};use function some\namespace\{fn_a, fn_b, fn_c};use const some\namespace\{ConstA, ConstB, ConstC};

Prend en charge la liaison statique retardée

mot-clé statique pour faire référence à la classe actuelle, qui implémente la liaison statique retardée

class A {    
    public static function who() {    
        echo __CLASS__;    
    }    
    public static function test() {    
        static::who(); // 这里实现了延迟的静态绑定    
    }    
}    
class B extends A {    
    public static function who() {    
         echo __CLASS__;    
    }    
}
B::test();

Résultat de sortie :
B

Prend en charge l'instruction goto

La plupart des langages de programmation informatique prennent en charge l'instruction goto inconditionnelle goto Lorsque le programme exécute l'instruction goto, il se tourne vers l'instruction goto. L'exécution se poursuit à l'emplacement du programme indiqué par l'étiquette . Bien que l'instruction goto puisse conduire à un déroulement de programme flou et à une lisibilité réduite, elle présente sa propre commodité dans certaines situations, comme l'interruption de boucles profondément imbriquées et d'instructions if.

goto a;    
echo 'Foo';    
a:    
echo 'Bar';    
for($i=0,$j=50; $i<100; $i++) {    
  while($j--) {    
    if($j==17) goto end;    
  }     
}    
echo "i = $i";    
end:    
echo &#39;j hit 17&#39;;

Prend en charge les fermetures, les fonctions Lambda/Anonymes

Les concepts de fonctions de fermeture (Closure) et de fonctions Lambda proviennent du domaine de la programmation fonctionnelle. JavaScript, par exemple, est l'un des langages les plus courants prenant en charge les fermetures et les fonctions lambda.
En PHP, nous pouvons également créer des fonctions pendant que le code s'exécute via create_function(). Mais il y a un problème : la fonction créée n'est compilée qu'au moment de l'exécution et n'est pas compilée en code exécutable en même temps que les autres codes. Par conséquent, nous ne pouvons pas utiliser des caches de code exécutable comme APC pour améliorer l'efficacité de l'exécution du code.
En PHP5.3, nous pouvons utiliser des fonctions Lambda/anonymes pour définir certaines fonctions temporaires (jetables) comme fonctions de rappel pour array_map()/array_walk() et d'autres fonctions.

echo preg_replace_callback('~-([a-z])~', function ($match) {    
    return strtoupper($match[1]);    
}, 'hello-world');    
// 输出 helloWorld    $greet = function($name)    {    
    printf("Hello %s\r\n", $name);    
};    
$greet('World');    
$greet('PHP');    
//...在某个类中    $callback =      function ($quantity, $product) use ($tax, &$total)         {    
   $pricePerItem = constant(__CLASS__ . "::PRICE_" .  strtoupper($product));    
   $total += ($pricePerItem * $quantity) * ($tax + 1.0);    
 };

Méthodes magiques __callStatic() et __invoke()

Il existe à l'origine une méthode magique __call() en PHP Lorsque le code appelle un objet qui n'est pas The. La méthode magique sera automatiquement appelée lorsque la méthode existe. La nouvelle méthode __callStatic() n'est utilisée que pour les méthodes de classe statique. Lorsque vous essayez d'appeler une méthode statique qui n'existe pas dans la classe, la méthode magique __callStatic() sera automatiquement appelée.

class MethodTest {    
    public function __call($name, $arguments) {    
        // 参数 $name 大小写敏感    
        echo "调用对象方法 '$name' "    
             . implode(' -- ', $arguments). "\n";    
    }    
    /**  PHP 5.3.0 以上版本中本类方法有效  */    
    public static function __callStatic($name, $arguments) {    
        // 参数 $name 大小写敏感    
        echo "调用静态方法 '$name' "    
             . implode(' -- ', $arguments). "\n";    
    }    
}    

$obj = new MethodTest;    
$obj->runTest('通过对象调用');    
MethodTest::runTest('静态调用');  // As of PHP 5.3.0

Le résultat après l'exécution du code ci-dessus est le suivant :
Appelez la méthode objet 'runTest' - - Appelez la méthode statique 'runTest' via l'appel d'objet - - Appel statique
Quand en appelant l'objet sous la forme d'une fonction, la méthode __invoke() sera appelée automatiquement.

class MethodTest {    
    public function __call($name, $arguments) {    
        // 参数 $name 大小写敏感    
        echo "Calling object method '$name' "    
             . implode(', ', $arguments). "\n";    
    }    

    /**  PHP 5.3.0 以上版本中本类方法有效  */    
    public static function __callStatic($name, $arguments) {    
        // 参数 $name 大小写敏感    
        echo "Calling static method '$name' "    
             . implode(', ', $arguments). "\n";    
    }    
}    
$obj = new MethodTest;    
$obj->runTest('in object context');    
MethodTest::runTest('in static context');  // As of PHP 5.3.0

Syntaxe Nowdoc

L'utilisation est similaire à Heredoc, mais utilise des guillemets simples. Heredoc doit être déclaré à l'aide de guillemets doubles.
Nowdoc n'effectue aucune analyse de variables, ce qui est très approprié pour transmettre un morceau de code PHP.

// Nowdoc 单引号 PHP 5.3之后支持    $name = 'MyName';    
echo <<<&#39;EOT&#39;    My name is "$name".    
EOT;    
//上面代码输出 My name is "$name". ((其中变量不被解析)    // Heredoc不加引号    echo <<<FOOBAR    
Hello World!    
FOOBAR;    
//或者 双引号 PHP 5.3之后支持    echo <<<"FOOBAR"    Hello World!    
FOOBAR;

Prend en charge l'initialisation des variables statiques, des membres de classe et des constantes de classe via Heredoc.

// 静态变量    function foo()    {    
    static $bar = <<<LABEL    
Nothing in here...    
LABEL;    
}    
// 类成员、常量    class foo    {    
    const BAR = <<<FOOBAR    
Constant example    
FOOBAR;    

    public $baz = <<<FOOBAR    
Property example    
FOOBAR;    
}

Const peut également être utilisé pour définir des constantes en dehors de la classe

//PHP中定义常量通常是用这种方式  define("CONSTANT", "Hello world.");  

//并且新增了一种常量定义方式  const CONSTANT = 'Hello World';

L'opérateur ternaire ajoute une méthode d'écriture raccourcie

Le format d'origine est (expr1) ? (expr2) : (expr3)
Si le résultat de expr1 est True, le résultat de expr2 est renvoyé.
Ajout d'une nouvelle façon d'écrire, vous pouvez omettre la partie centrale et l'écrire comme expr1 ?: expr3
Si le résultat de expr1 est vrai, le résultat de expr1 est renvoyé

$expr1=1;$expr2=2;//原格式  $expr=$expr1?$expr1:$expr2  //新格式  $expr=$expr1?:$expr2

Résultat de sortie :
1
1

Opérateur de coalescence nul (??)

Jugement simplifié

$param = $_GET['param'] ?? 1;

est équivalent à :

$param = isset($_GET['param']) ? $_GET['param'] : 1;

Json comprend mieux le chinois (JSON_UNESCAPED_UNICODE)

echo json_encode("中文", JSON_UNESCAPED_UNICODE);  
//输出："中文"

Binaire

$bin  = 0b1101;  
echo $bin;  
//13

Syntaxe de traduction de point de code Unicode

Ceci est accepté. Un point de code Unicode sous forme hexadécimale et imprime une chaîne codée en UTF-8 entourée de guillemets doubles ou d'hérédoc. Tout point de code valide est accepté et le premier 0 peut être omis.

 echo "\u{9876}"

Sortie de l'ancienne version : u{9876}
Entrée de la nouvelle version : top

Utiliser ** pour le fonctionnement électrique

Ajouter une jointure à droite opérateur * pour effectuer des opérations d'exponentiation. Il prend également en charge l'opérateur abrégé *=, ce qui signifie effectuer une exponentiation et attribuer des valeurs.

printf("2 ** 3 ==      %d\n", 2 ** 3);printf("2 ** 3 ** 2 == %d\n", 2 ** 3 ** 2);$a = 2;$a **= 3;printf("a ==           %d\n", $a);

sortie
2 ** 3 == 8
2 * 3 * 2 == 512
a == 8

Opérateur de vaisseau spatial (opérateur de comparaison combinée)

L'opérateur du vaisseau spatial est utilisé pour comparer deux expressions. Quand ​ unGrand dans, etc. ou Petit dans $a 大于、等于或小于$

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!