Qu'est-ce que l'écriture de chaîne php ?

La méthode d'écriture de la chaîne php est "$tree->setAge()->setID()->setName();", où dans la classe php ce pointeur pointe vers la classe/l'objet lui-même , c'est comme une corde reliant la classe/l'objet aux attributs et fonctions de la classe.

L'environnement d'exploitation de cet article : système Windows 7, PHP version 7.1 , ordinateur DELL G3

La méthode d'écriture en chaîne existe dans de nombreux langages de programmation orientés objet. Personnellement, je la comprends simplement comme une liste chaînée, et elle est en effet très familière avec l'utilisation des listes chaînées. Le pointeur this est la base des opérations chaînées.
Les fonctions de ce pointeur dans différents langages de programmation sont similaires, mais les détails spécifiques sont différents. Mais il existe une base pour pointer vers l'objet/la fonction/la classe elle-même. Sur cette base, l’écriture en chaîne peut être mise en œuvre.
Prenons php comme exemple.
Dans la classe PHP, le pointeur this ($this) pointe vers la classe/objet lui-même. C'est comme une corde reliant la classe/l'objet aux attributs et fonctions de la classe. Et vous pouvez l'utiliser pour appeler les propriétés et fonctions (méthodes) correspondantes. Comme le montre la figure ci-dessous :

Démo du programme php :

<?php
/**
 * Created by PhpStorm.
 * User: dell
 * Date: 2017/3/31
 * Time: 21:42
 */
/*
*注释的规范写法：@param  [参数类型]  参数名   参数解释 
 * @return 返回值  [类型]   返回值名   返回值说明
*/



class Tree{
    private  $id ;
    private  $name;
    private  $age;
    /*
 *
 * @param  null
 * @return  null
 *
 */
    public function  _construct()
    {
        //构造函数
    }
    /*
 *
 * @param  [array] $arr 参数1
 * @return  null
 *
 */
    public function  init( $arr = array() )
    {
        //初始化函数
        $arrs = array();
        //设置默认参数
        $arrs = [
            &#39;id&#39;=> 1,
            &#39;name&#39;=> &#39;user&#39;,
            &#39;age&#39; => 18
        ];
        if( !(is_array($arr)) )
        {
        //如果传进来的数据不是数组则默认是id
            $this->id = intval( $arr );
        }
        $arrs = array_merge( $arrs , $arr );//合并数组
        //给类的属性赋值
        $this->id = $arrs[&#39;id&#39;];
        $this->name = $arrs[&#39;name&#39;];
        $this->age = $arrs[&#39;age&#39;];
    }
    /*
 *
 * @param  [int] $data 参数1
 * @return  $this
 *
 */
    public function  setID(  $data = 0 )
    {
        //判断是不是数字
        $this->id =is_numeric( $data )? $data : intval($data)  ;//判断是否是数字，是赋值，否则转为数字在赋值
        return $this;//返回this指针
    }
    /*
 *
 * @param  [string] $data 参数1
 * @return  $this
 *
 */
    public function  setName(  $data = &#39;user&#39; )
    {
        //判断是不是数字
        $this->name =is_string( $data )? $data : strval($data)  ;//判断是否是字符串，是赋值，否则转为字符串在赋值
        return $this;//返回this指针
    }
    /*
 *
 * @param  [int] data 参数1
 * @return  $this
 *
 */
    public function  setAge(  $data = 18 )
    {
        //判断是不是数字
        $this->age =is_numeric( $data )? $data : intval($data)  ;//判断是否是数字，是赋值，否则转为数字在赋值
        return $this;//返回this指针
    }
};

$tree = new Tree();
$array = array();
$array[&#39;id&#39;] = 10;
$array[&#39;name&#39;] = &#39;admin&#39;;
$array[&#39;age&#39;] = 20;
$tree->init($array);
var_dump($tree);//打印结果
$tree->setAge()->setID()->setName();//链式写法
var_dump($tree);//在打印看链式写法是否有效
?>

Résultat de sortie :

Ceci ci-dessus Dans la démo, un arbre est construit à l'aide de la classe PHP, avec l'ID, le nom et l'âge. Initialisez les propriétés via la fonction d'initialisation init. Attribuez ensuite des valeurs aux attributs via l'écriture en chaîne, et enfin imprimez le résultat pour vérifier s'il réussit.
Le principe selon lequel les fonctions/méthodes peuvent implémenter l'écriture en chaîne est que la valeur de retour est ce pointeur (renvoie $this en php, renvoie this en js, et similaire dans d'autres langages). Ce n'est qu'ainsi que le pointeur this peut être renvoyé après avoir appelé cette fonction. Logiquement, ce qui est renvoyé à ce moment-là est la classe elle-même, puis continue d'appeler la fonction et renvoie le pointeur this, et ainsi de suite.
Bien sûr, chaque langage de programmation a ses différences. Par exemple, c++ est ->, php->, et js ou jq est... ; la forme d'appel est différente mais le principe est le même.

Un point, il y a ce pointeur, renvoie ce pointeur, et ensuite vous pouvez réaliser l'écriture en chaîne et peut être utilisé de manière cyclique ->fun1(retourner ceci)->fun2(retourner ceci)- >fun3 (renvoyez ceci)…… .

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!