Résumé des instructions de code pour les méthodes magiques courantes en PHP orienté objet

Dans la programmation orientée objet, PHP fournit une série de méthodes magiques, qui offrent beaucoup de commodité pour la programmation. Les méthodes magiques en PHP commencent généralement par (deux traits de soulignement) et ne nécessitent pas d'appels explicites mais sont déclenchées par certaines conditions spécifiques.

Constructeur et Destructeur

Le Constructeur et le destructeur sont appelés lorsque l'objet est créé et détruit respectivement. Lorsqu'un objet est "détruit", cela signifie qu'il n'y a aucune référence à l'objet. Par exemple, si la variable qui fait référence à l'objet est supprimée (non définie), réaffectée ou si l'exécution du script se termine, le destructeur sera appelé.

construct()

construct() Le constructeur est de loin la fonction la plus couramment utilisée. Lorsque crée un objet, vous pouvez effectuer un travail d'initialisation dans le constructeur. Vous pouvez définir n'importe quel nombre de paramètres pour le constructeur, à condition que le nombre correspondant de paramètres soit transmis lors de l'instanciation. Toute exception qui se produit dans le constructeur empêche la création de l'objet.

class Device {
   public function  construct(Battery $battery, $name) {
       $this->battery = $battery;
       $this->name = $name;
       $this->connect();
    }
}

Dans l'exemple de code ci-dessus, le constructeur de la classe Device attribue des valeurs aux propriétés des membres et appelle la méthode connect().

Déclarer le constructeur comme méthode privée empêche la création d'objets en dehors de la classe, qui est souvent utilisée dans le modèle simplex.

destruct()

Le destructeur est généralement appelé lorsque l'objet est détruit. Le destructeur ne reçoit aucun paramètre. Certains travaux de nettoyage sont souvent effectués dans le destructeur, comme la fermeture de la connexion à la base de données, etc.

Surcharge de propriétés

Une chose à noter est que la "surcharge" en PHP n'est pas la même chose que la surcharge dans la plupart des autres langages, bien qu'ils implémentent tous la même fonction. .
Les deux méthodes magiques impliquées dans la surcharge de propriétés sont principalement utilisées pour gérer l'accès aux propriétés, définissant ce qui se passe lorsque nous essayons d'accéder à une propriété inexistante (ou inaccessible).

get()

La méthode magique get() sera appelée lorsque nous tenterons d'accéder à une propriété inexistante. Il reçoit un paramètre qui représente le nom de l'attribut accédé et renvoie la valeur de l'attribut. Dans la classe Device ci-dessus, il y a un attribut data, qui joue ici un rôle, comme le montre le code suivant :

class Device {
    public function  get($name) {
         if(array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }
        return null;
    }
}

L'endroit le plus couramment utilisé pour cette méthode magique est de créer un "read- uniquement l'attribut « » pour étendre le contrôle d'accès. Dans la classe Battery ci-dessus, il existe une propriété privée $charge, que nous pouvons étendre via la méthode magique get() pour qu'elle soit lisible mais non modifiable en dehors de la classe. Le code est le suivant :

class Battery {
    private $charge = 0;
 
    public function  get($name) {
        if(isset($this->$name)) {
            return $this->$name;
        }
        return null;
    }
}

set()

la méthode magique set() sera appelée lorsque nous tenterons de modifier une propriété inaccessible. Elle en reçoit deux. Paramètres, un nom représentant l'attribut et une valeur représentant l'attribut. L'exemple de code est le suivant :

class Device {
    public function  set($name, $value) {
        // use the property name as the array key
        $this->data[$name] = $value;
    }
}

isset()

La méthode magique isset() sera appelée lorsque la méthode isset() est appelée sur un accès inaccessible. propriété. Il reçoit un paramètre représentant le nom de l’attribut. Il doit renvoyer une valeur booléenne indiquant si la propriété existe. Le code est le suivant :

class Device {
    public function  isset($name) {
        return array_key_exists($name, $this->data);
    }
}

unset()

La méthode magique unset() sera appelée lorsque la fonction unset() est appelée pour détruire un objet inaccessible. propriété. Reçoit un paramètre exprimant le nom de l'attribut.

Convertir un objet en chaîne

Parfois, nous devons exprimer l'objet sous la forme d'une chaîne. Si nous imprimons un objet directement, le programme affichera un message d'erreur : Erreur fatale PHP Catchable : L'objet de classe Device n'a pas pu être converti en chaîne

toString()

toString() sera appelé lorsque nous utiliserons l'objet comme chaîne. Il ne reçoit aucun paramètre. Cette méthode permet de définir la représentation de l'objet. Le code est le suivant :

class Device {
    public function  toString() {
       $connected = (isset($this->connection)) ? 'connected' : 'disconnected';
       $count = count($this->data);
       return $this->name . ' is ' . $connected . ' with ' . $count . ' items in memory' . PHP_EOL;
    }
    ...
}

set_state()(PHP 5.1)

Méthode magique statique set_state(), qui est appelée lorsque nous utilisons le var_export( ) fonction pour afficher un objet dans la méthode. La fonction var_export() est utilisée pour convertir les variables PHP en code PHP. Elle reçoit un tableau associatif contenant les valeurs des attributs d'objet en paramètre. L'exemple de code est le suivant :

class Battery {
    //...
    public static function  set_state(array $array) {
        $obj = new self();
        $obj->setCharge($array['charge']);
        return $obj;
    }
    //...
}

Cloner un objet

Par défaut, les objets sont passés par référence. Par conséquent, lorsque vous affectez un objet à une autre variable, vous créez uniquement une référence à l'objet et ne copiez pas l'objet. Afin de copier réellement un objet, nous devons utiliser le mot-clé clone.
Cette stratégie de "passage par référence" s'applique également aux objets contenus dans les objets. Même si nous clonons un objet, tous les objets à l'intérieur de l'objet ne seront pas clonés, le résultat final est donc que les deux objets partagent le même objet interne. L'exemple de code est le suivant :

$device = new Device(new Battery(), 'iMagic');
$device2 = clone $device;
 
$device->battery->setCharge(65);
echo $device2->battery->charge;
// 65

clone()

clone() La méthode magique clone() peut résoudre le problème ci-dessus. Cette méthode magique est appelée lorsque le mot-clé clone est utilisé sur un objet. Dans cette méthode magique, on peut cloner n'importe quel sous-objet. Le code est le suivant :

class Device {
    ...
    public function  clone() {
        // copy our Battery object
        $this->battery = clone $this->battery;
    }
    ...
}

对象序列化

序列化是讲任意数据转换为字符串格式的过程。序列化通常用来将整个对象存入数据库或写入文件中。当反序列化存储的数据时，我们可以得到序列化之前的对象。但是，并不是所有得数据都可以被序列化，比如数据库连接。幸运的是，有一个魔术方法可以帮我们解决这个问题。

sleep()

魔术方法sleep()在对一个对象序列化时(调用serialize())会被调用。它不接收任何参数，而且应该返回一个包含所有应该被序列化的属性的数组。在该魔术方法中，也可以执行一些其他操作。
有一点要注意的是，不要再该函数中进行任何的析构操作，因为这可能会影响正在运行的对象。

示例代码如下：

class Device {
    public $name;           
    public $battery;       
    public $data = array();
    public $connection;    
    //...
    public function  sleep() {
        return array('name', 'battery', 'data');
    }
    //...
}

wakeup()

魔术方法wakeup()在对存储的对象反序列化时会被调用。它不接收任何参数，也没有任何返回值。可以用它来处理在序列化时丢失的数据库连接或资源。代码如下：

class Device {
    //...
    public function  wakeup() {
        // reconnect to the network
        $this->connect();
    }
    //...
}

方法重载

PHP还有两个与成员方法相关的魔术方法call()和callStatic()，这两个魔术方法类似于属性重载方法。

call()

魔术方法call()在调用不存在或不可访问的方法时会被调用。它接收两个参数，一个是调用的方法的名字，一个是包含函数参数的数组。我们可以使用这种方法调用子对象中得同名函数。

在这个例子中，要注意函数call_user_func_array()，这个函数允许我们动态调用一个命名的函数。

示例代码如下:

class Device {
    //...
    public function  call($name, $arguments) {
        // make sure our child object has this method
        if(method_exists($this->connection, $name)) {
            // forward the call to our child object
            return call_user_func_array(array($this->connection, $name), $arguments);
        }
        return null;
    }
    //...
}

callStatic()

魔术方法callStatic()与call()的功能一样，唯一不同的是，该方法在尝试访问一个不存在或不可访问的静态方法时会被调用。示例代码如下：

class Device {
    //...
    public static function  callStatic($name, $arguments) {
        // make sure our class has this method
        if(method_exists('Connection', $name)) {
            // forward the static call to our class
            return call_user_func_array(array('Connection', $name), $arguments);
        }
        return null;
    }
    //...
}

其他:autoload()

autoload()方法并不是一个魔术方法，但是这个方法非常有用。但是，对着PHP版本的更新，该函数已经不建议使用，取而代之的是spl_auto_register()函数。

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!