ThinkPHP : le troisième des trois outils puissants pour les modèles (getter)

Définir le getter

La fonction du getter est de traiter automatiquement les données (brutes) du modèle objet . Un getter correspond à une méthode particulière du modèle (la méthode doit être de type public). La convention de dénomination de la méthode est :

getFieldNameAttr

FieldName est le cas camel). conversion du champ de la table de données Ou un champ qui n'existe pas dans votre table de données (faites attention à bien comprendre la phrase suivante. Voici une définition typique d'un getter :

<?php
namespace app\index\model;
use think\Model;
class User extends Model
{
    public function getUserTypeAttr($value, $data)
    {
        $type = [0 => &#39;普通&#39;, 1 => &#39;VIP&#39;, 2 => &#39;黄金&#39;, 3 => &#39;白金&#39;, 4 => &#39;钻石&#39;];
        return $type[$value];
    }
}

Vous devez définir un getter correspondant pour). chaque champ de données nécessitant un traitement de conversion de sortie. Mais le nom du champ du getter ne doit pas nécessairement être cohérent avec le nom du champ de la table de données. Par exemple, si je souhaite définir un getter nommé getTypeAttr pour le champ user_type. également autorisé, mais il convient de noter que le premier passé dans le getter à ce moment-là. Le paramètre ne doit avoir aucune valeur (car il n'y a pas de données de champ de table de données correspondantes), et vous ne pouvez obtenir les données dont vous avez besoin que via le deuxième paramètre .

<?php
namespace app\index\model;
use think\Model;
class User extends Model
{
    public function getTypeAttr($value, $data)
    {
        $type = [0 => &#39;普通&#39;, 1 => &#39;VIP&#39;, 2 => &#39;黄金&#39;, 3 => &#39;白金&#39;, 4 => &#39;钻石&#39;];
        return $type[$data[&#39;user_type&#39;]];
    }
}

Bien sûr, dans un cas plus rigoureux, vous devez également déterminer si $data['user_type'] existe, ce qui sera ignoré pour l'instant.

Notez que les données du deuxième paramètre peuvent avoir été traitées par le getter lui-même (si vous définissez le getter concerné).

Pourquoi devez-vous définir un getter qui est incohérent avec le champ du datagramme ? L’avantage le plus évident est la possibilité de différencier les différents domaines pour obtenir des données brutes et des données traitées. En fait, il existe de nombreuses raisons pour lesquelles vous devez définir des getters de champ qui n'existent pas dans la table de données. C'est précisément le charme des getters.

On peut voir que la définition du getter lui-même n'est pas difficile. La clé réside dans la logique d'acquisition de la méthode, qui est la chose la plus importante à laquelle il faut prêter attention dans les applications pratiques.

Appelez le getter

Après avoir défini le getter, celui-ci sera automatiquement déclenché dans les situations suivantes :

·L'opération de valeur d'objet de données du modèle (telle que $model->field_name) ;

·L'opération de sortie sérialisée du modèle ; (comme $model-> toArray() ou toJson());

·Appeler explicitement la méthode getAttr (comme $model->getAttr ('field_name'));

Les deux premiers sont en fait implémentés en appelant le dernier. Le plus important est de comprendre le premier. La valeur d'un objet modèle est généralement obtenue de la manière suivante :

$user = User::get(1);
echo $user->name;
echo $user->user_type;

Lorsque nous utilisons la méthode ci-dessus pour obtenir les données d'un objet modèle ou sortir le modèle, nous détecterons et obtiendrons en fait les données dans l'ordre suivant. .

·Étape 1 - Si le résultat de la requête contient les données du champ, récupérez les données d'origine, sinon passez à l'étape 2

·Étape 2 - Vérifiez si le getter (y compris le getter dynamique) de ce champ est défini. Si c'est le cas, appelez le getter pour renvoyer le résultat. Sinon, passez à l'étape 3 ; >

·Étape 3 - Vérifiez si la conversion du type de champ est définie, si c'est le cas, effectuez le traitement de conversion et renvoyez le résultat, sinon, passez à l'étape 4 ;

·Étape 4 - S'il s'agit d'un champ d'heure système, formatez automatiquement l'heure et renvoyez le résultat, sinon passez à l'étape 5 ; 🎜>·

Étape 5 - Si les données du champ ne sont pas incluses dans la vérification à l'étape 1, vérifiez s'il existe une définition d'attribut associée, et si oui, obtenez les données via la relation associée et Renvoie le résultat, sinon lève une exception de propriété non définie.

Pour le code détaillé des cinq étapes ci-dessus, si vous êtes intéressé, vous pouvez directement vous référer au code de la méthode getAttr de thinkmodelconcernAttribute.

Pour faire simple, lorsque vous obtiendrez $user->user_type, vous vérifierez si le getter pertinent est défini, que le champ user_type soit ou non un véritable champ de table de données.

Mais dans de nombreux cas, vous n'obtiendrez pas les données du modèle une par une, mais renverrez l'intégralité des données du modèle au client ou au modèle.

public function index()
{
    $user = User::get(1);
    return json($user);
}

Dans ce cas, le traitement toJson du modèle est en fait effectué lors de la réponse à la sortie.

Un point important est que si votre getter définit des champs qui ne sont pas des tables de données, ils ne seront pas automatiquement générés. Vous devez ajouter des attributs supplémentaires via la méthode append (et prendre en charge l'ajout des attributs de modèle associés).

Si nous définissons un getter pour l'attribut type (en supposant qu'il ne s'agit pas d'un véritable champ de table de données), alors vous devez utiliser la méthode suivante pour afficher normalement (sinon vous ne pouvez avoir que des données user_type) :

public function index()
{
    $user = User::get(1);
    return json($user->append(['type']));
}

Si vous utilisez toArray, la méthode de traitement est la même.

S'il s'agit d'une requête d'ensemble de données, vous pouvez également utiliser la méthode append pour ajouter des champs supplémentaires de manière uniforme.

public function index()
{
    $users = User::all();
    return json($users->append(['type']));
}

En plus de la méthode append, nous prenons également en charge la méthode cachée pour masquer temporairement certaines données.

Obtenir des données brutes

有些情况下，除了要获取处理过的数据外，还需要获取原始数据以便应对不同的需求。

如果你的获取器都是用的区分于实际数据表字段的额外属性字段，那么这个问题本身已经解决了。所以我们主要讨论的是当你的获取器属性和数据表字段一致的情况下，该如何获取原始数据。

一个最简单的办法是使用getData方法：

$user = User::get(1);
// 获取user_type获取器数据
echo $user->user_type;
// 获取原始的user_type数据
echo $user->getData('user_type');
// 获取全部原始数据
dump($user->getData());

动态获取器

前面我们提到过动态获取器的概念，动态获取器就是不需要在模型类里面定义获取器方法，而是在查询的时候使用闭包来定义一个字段的获取器对数据进行统一的处理。

User::withAttr('name', function($value, $data) {
return strtolower($value);
})->select();

如果你需要定义多个动态获取器，多次调用withAttr方法就行。

动态获取器的意义除了可以不用在模型里面定义获取器方法之外，还可以起到覆盖已经定义的获取器的作用，并且动态获取器可以支持Db类操作，弥补了Db操作不能使用获取器的缺憾，具体就看自己的需求来选择了。

Db::name('user')->withAttr('name', function($value, $data) {
return strtolower($value);
})->select();

总结

无论是获取器，还是之前提的修改器、搜索器，其作用无非是把你的模型工作细化和拆分，这样代码和逻辑也会更清晰，可维护性也大大增强，至于性能，从来不是模型首先考虑的。

PHP中文网，有大量免费的ThinkPHP入门教程，欢迎大家学习！

本文转自：https://blog.thinkphp.cn/825350

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!