De la fonction anonyme (fonctionnalité de fermeture) au modèle de conteneur de modèle de conception PHP

Fonction anonyme (fonction de fermeture)

La fonction anonyme, également appelée fonction de fermeture, permet la création temporaire d'une fonction sans nom spécifié, couramment utilisée La valeur du paramètre de la fonction de rappel peut également être utilisé comme valeur d'une variable. Pour une utilisation spécifique, voir l'exemple de code suivant :

/* 示例一：声明一个简单匿名函数，并赋值给一个变量，通过变量名调用这个匿名函数 */
$anonFunc = function($param){    
    echo $param;
}; 
$anonFunc('这里是一个匿名函数');　　// 通过变量名调用匿名函数，和普通函数没什么区别

/* 示例二：通过在函数内部使用匿名函数动态创建函数 */
function operate($operator){
    if($operator == '+'){
        return function($a, $b){
            return $a + $b;
        }
    }
    if($operator == '-'){
        return function($a, $b){
            return $a - $b;
        }
    }
}
$add = operate('+');
echo $add(4, 3);    // 7
$sub = operate('-');
echo $sub(4, 3);    // 1
/* 示例三：匿名函数作为回调函数参数传入 */
function callback($callback){
    $callback();
}
function callback(){
    // 闭包测试函数
    echo '这里是闭包测试函数体';
}

Dans les trois exemples de code ci-dessus, la fonction anonyme ne transmet pas de paramètres. Nous savons que les fonctions anonymes sont fréquemment utilisées en JavaScript et dans le langage JavaScript. fonction parent Les variables paramètres peuvent être utilisées directement dans la sous-fonction, mais le langage PHP ne le permet pas. Vous devez utiliser le mot-clé use ($var) (notez l'utilisation dans le code) pour atteindre le même objectif. Apportez les modifications suivantes à l'exemple 3 dans le code ci-dessus :

/* 示例三修改：匿名函数作为参数传入，并且携带参数 */
function callback($callback) use ($content){
    $callback($content);
}
$content = '这里是闭包函数的输出内容';
function callback($content){
    // 闭包函数
    echo $content;
}

Dans l'exemple 2 du code ci-dessus, vous pouvez également utiliser le mot-clé use pour implémenter la référence de la fonction anonyme à la variable externe de la fonction parent. . L'utilisation de fonctions anonymes et de fonctionnalités de fermeture dans ces exemples de codes sert uniquement à comprendre les concepts et n'a pas beaucoup de signification pratique. Les fermetures ont de nombreuses utilisations et elles sont le plus souvent utilisées dans l'injection de dépendances (DI) du mode conteneur dans PHP. cadre.

Mode conteneur orienté objet PHP

Comme son nom l'indique, un conteneur sert à stocker des choses. En fait, il s'agit de déclarer une classe spécifiquement pour accéder à un objet. instances Dans ce cas, il doit y avoir au moins deux méthodes principales dans le conteneur pour lier les dépendances au conteneur et obtenir les dépendances du conteneur. Un conteneur peut être considéré comme un outil de gestion des dépendances, parfois également appelé conteneur de services.

/* 声明一个简单的容器类 */
class Container{
    private $_diList = array();    // 用于存放依赖

    /* 核心方法之一，用于绑定服务
    * @param string $className 类名称
    * @param mixed $concrete 依赖在容器中的存储方式，可以是类名字符串，数组，一个实例化对象，或者是一个匿名函数
    */
    puclic function set($className, $concrete){

            $this->_diList[$className] = $concrete;   
    }

    /* 
    * 核心方法之二，用于获取服务对象 
    * @param string $className 将要获取的依赖的名称
    * @return object 返回一个依赖的实例化对象
    */
    public function get($className){
        if(isset($this->_diList[$className])){
            return $this->diList[$className];
        }    
        return null;
    }
}

Le code ci-dessus est un modèle de conteneur simple, dans lequel la méthode set est utilisée pour enregistrer les dépendances et la méthode get est utilisée pour obtenir les dépendances. Il existe de nombreuses façons pour les conteneurs de stocker les dépendances. L'exemple de code suivant utilise des fonctions anonymes à titre d'illustration.

/* 数据库连接类 */
class Connection{
    public function __construct($dbParams){
        // connect the database...    
    }
    public someDbTask(){
        // code...
    }
}
/* 会话控制类 */
class Session{
    public function openSession(){
        session_start();
    }
    // code...
}
$container->set('session', function(){
    return new Session();
});

$container = new Container();
// 使用容器注册数据库连接服务
$container->set('db', function(){
    return new Connetion(array(  
        "host" => "localhost",  
        "username" => "root",  
        "password" => "root",  
        "dbname" => "dbname"  
    ));
});
// 使用容器注册会话控制服务
$container->set('session', function(){
    return new Session();
});
// 获取之前注册到容器中的服务，并进行业务的处理
$container->get('db')->someDbTask();
$container->get('session')->openSession();

Le code ci-dessus explique comment utiliser le conteneur, dans lequel deux services, db et session, sont enregistrés. Ici, les fonctions anonymes sont utilisées comme méthodes de stockage dépendantes, et l'ensemble $container-> () est appelée. Lors de l'enregistrement du service, elle n'est pas réellement instanciée, mais la fonction anonyme est exécutée lorsque la méthode $container->get() est appelée pour obtenir la dépendance, et l'objet instancié est renvoyé. permet une instanciation à la demande. Aucune instanciation n'améliore l'efficacité de l'exécution du programme.

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!