Comment implémenter la soumission de requêtes combinées multi-conditions frontales dans ThinkPHP5

Avec le développement rapide d'Internet, de plus en plus de sites Web et d'applications commencent à adopter une architecture de séparation front-end et back-end. Pour le backend, un bon framework peut nous aider à mieux mettre en œuvre la logique métier et à améliorer l’efficacité du développement et la qualité du code. Pour le front-end, l’affichage et la recherche des données constituent souvent aussi un lien crucial. Dans cet article, nous présenterons comment utiliser ThinkPHP5 pour implémenter la fonction de soumission de requêtes combinées multi-conditions frontales.

1. Analyse des exigences

Dans le développement réel, nous avons souvent besoin d'interroger certaines tables ou données. Ces données sont souvent très volumineuses et nous devons effectuer un filtrage multi-conditions pour trouver rapidement les données dont nous avons besoin. Par conséquent, nous devons développer une fonction de requête combinée multi-conditions.

Plus précisément, nous devons implémenter les fonctions suivantes :

1. Prise en charge des requêtes combinées avec plusieurs conditions : les utilisateurs peuvent sélectionner plusieurs conditions pour une requête combinée.

2. Requête de pagination prise en charge : s'il y a de nombreux résultats de requête, nous devrons peut-être les afficher en pagination.

3. Prise en charge du cache de requêtes : si la même condition de requête est exécutée plusieurs fois sur une courte période de temps, nous pouvons utiliser le cache de requêtes pour améliorer la vitesse des requêtes.

2. Sélection technologique

Afin d'atteindre les fonctions ci-dessus, nous devons choisir un framework puissant. Dans le contenu suivant, nous utiliserons le framework ThinkPHP5 pour implémenter cette fonction.

3. Étapes de mise en œuvre

1. Créer des tableaux et des données

Tout d'abord, nous devons créer un tableau et insérer des données de test. Dans cet exemple, nous allons créer une table appelée « utilisateurs » avec des champs tels que le nom, l'âge, le sexe, la ville et le statut.

2. Créer un formulaire de requête

Ensuite, nous devons créer un formulaire HTML pour recevoir les conditions de requête saisies par l'utilisateur. Dans cet exemple, nous prendrons en charge plusieurs conditions de requête telles que le nom, l'âge, le sexe, la ville et l'état. Nous pouvons y parvenir grâce à des contrôles de sélection ou de saisie dans le formulaire.

Comme vous pouvez le voir, nous utilisons des contrôles de sélection, de saisie et d'autres dans le formulaire pour recevoir les commentaires des utilisateurs, et utilisons le bouton Soumettre pour envoyer des demandes. Parmi eux, il convient de noter que pour les conditions de requête à sélection multiple, nous devons ajouter "[]" à l'attribut name de l'élément de formulaire pour indiquer qu'il s'agit d'un tableau.

3. Implémenter la logique de requête

Une fois que l'utilisateur a soumis la demande de requête, nous devons transmettre les conditions de requête saisies par l'utilisateur en arrière-plan pour la requête de données. Ici, nous utiliserons le générateur de requêtes fourni par le framework ThinkPHP5 pour y parvenir. Plus précisément, nous devons obtenir séparément les conditions de requête saisies par l'utilisateur, puis combiner ces conditions dans des instructions SQL et exécuter la requête. Les résultats de la requête peuvent être parcourus et affichés sous forme de pagination.

L'ensemble de la logique de requête est la suivante :

public function search(){
    $param = input('post.');//获取查询条件
    $page = input('page', 1);//获取当前页数，默认为第一页
    $limit = input('limit', 10);//获取每页显示条数，默认为10

    //开始拼凑查询条件
    $where = [];
    if(!empty($param['name'])){
        $where[] = ['name', 'like', '%'. $param['name'] . '%'];
    }
    if(!empty($param['gender'])){
        $where[] = ['gender', '=', $param['gender']];
    }
    if(!empty($param['age'])){
        $ageArr = explode('-', $param['age']);
        if(count($ageArr) == 2){
            $where[] = ['age', 'between', [$ageArr[0], $ageArr[1]]];
        }
    }
    if(!empty($param['city'])){
        $where[] = ['city', '=', $param['city']];
    }
    if(!empty($param['status'])){
        $where[] = ['status', '=', $param['status']];
    }

    //计算总记录数
    $count = Db::table('users')
        ->where($where)
        ->count();

    //执行分页查询
    $list = Db::table('users')
        ->where($where)
        ->page($page)
        ->limit($limit)
        ->select();

    //返回查询结果
    return json([
        'code' => 0,
        'msg' => '',
        'count' => $count,
        'data' => $list
    ]);
}

Dans ce code, nous obtenons d'abord les conditions de requête saisies par l'utilisateur, et utilisons la méthode Where pour combiner ces conditions dans une instruction SQL. Ensuite, nous utilisons la méthode count pour compter le nombre d'enregistrements qui remplissent les conditions, et utilisons les méthodes page et limit pour implémenter les requêtes de pagination. Enfin, nous renvoyons les résultats de la requête au front-end en JSON.

4. Implémenter la mise en cache des requêtes

Si nous interrogeons les mêmes conditions plusieurs fois sur une courte période de temps, la charge sur la base de données sera très importante. Par conséquent, nous pouvons améliorer l’efficacité des requêtes en activant la mise en cache des requêtes. Pour activer la mise en cache des requêtes, il suffit d'ajouter la méthode cache après l'instruction de requête. Plus précisément, nous pouvons modifier le code ci-dessus sous la forme suivante :

//执行分页查询
$list = Db::table('users')
    ->where($where)
    ->cache(true, 600)//开启缓存，缓存时间为600秒
    ->page($page)
    ->limit($limit)
    ->select();

Après avoir terminé les étapes ci-dessus, nous pouvons implémenter la fonction frontale de soumission de requêtes combinées multi-conditions. En utilisation réelle, si la quantité de données de requête est très importante, nous pouvons également envisager d'utiliser d'autres méthodes d'optimisation, telles que le chargement asynchrone, la requête distribuée, etc.

Résumé

Cet article présente la méthode d'utilisation du framework ThinkPHP5 pour implémenter la soumission de requêtes combinées multi-conditions frontales. De cette manière, nous pouvons implémenter rapidement et facilement des fonctions de requête complexes et améliorer l’efficacité du développement et la qualité du code. Dans le même temps, nous avons également présenté comment activer la mise en cache des requêtes afin de réduire la charge sur la base de données et d'améliorer encore l'efficacité des requêtes.

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!