Comment vérifier la pagination dans Golang

Cet article expliquera comment implémenter une requête de pagination dans Golang.

Lors de l'exécution de requêtes de pagination, nous devons connaître trois paramètres clés :

1. Le nombre d'enregistrements par page, c'est-à-dire le nombre maximum d'enregistrements affichés sur chaque page.
2. Le numéro de page actuel est utilisé pour spécifier quelle page de résultats de requête nous devons afficher.
3. Le nombre total d'enregistrements, qui correspond au nombre total d'enregistrements dans l'ensemble du résultat de la requête.

Dans Golang, vous pouvez utiliser différentes méthodes pour implémenter les requêtes de pagination. Cet article présentera deux méthodes d'implémentation.

Méthode 1 : Utiliser les clauses LIMIT et OFFSET de la base de données

Dans Golang, nous pouvons utiliser les clauses LIMIT et OFFSET dans l'instruction SQL pour interroger les données de la base de données en pages. Pour la base de données MySQL, on peut faire ceci :

func getPageData(pageSize int, pageNum int) ([]*Record, error) {
  offset := (pageNum - 1) * pageSize
  rows, err := db.Query("SELECT * FROM my_table LIMIT ? OFFSET ?", pageSize, offset)
  if err != nil {
    return nil, err
  }
  defer rows.Close()

  var records []*Record
  for rows.Next() {
    record := new(Record)
    if err := rows.Scan(&record.Field1, &record.Field2, &record.Field3); err != nil {
      return nil, err
    }
    records = append(records, record)
  }

  if err := rows.Err(); err != nil {
    return nil, err
  }
  return records, nil
}

Dans la fonction getPageData, on passe le nombre d'enregistrements par page pageSize et le nombre de pages à afficher pageNum. Ensuite, nous calculons le décalage en fonction de pageNum et pageSize, et utilisons les clauses LIMIT et OFFSET pour obtenir l'enregistrement de données correspondant au numéro de page de la base de données.

Il est à noter que nous devons fermer l'objet rows de la requête de base de données à la fin de la fonction et gérer l'erreur.

Méthode 2 : Utiliser les tranches et les tableaux intégrés de Golang pour la pagination

En plus d'utiliser les clauses LIMIT et OFFSET de la base de données, nous pouvons également utiliser les clauses intégrées de Golang tranches et tableaux. Nous devons d’abord obtenir tous les résultats de la requête, puis les paginer en fonction des paramètres transmis.

func getPageData(data []*Record, pageSize int, pageNum int) ([]*Record, error) {
  // 计算起始和结束下标
  start := (pageNum - 1) * pageSize
  end := start + pageSize

  // 处理边界情况，确保不越界
  if start > len(data)-1 {
    return nil, errors.New("Page not found")
  }
  if end > len(data) {
    end = len(data)
  }

  // 截取数据切片
  result := data[start:end]

  return result, nil
}

Dans la fonction getPageData, nous transmettons toutes les données du résultat de la requête, le nombre d'enregistrements par page pageSize et le nombre de pages à afficher pageNum. Ensuite, nous calculons les indices de début et de fin des données à intercepter en fonction de pageSize et pageNum, puis utilisons la tranche intégrée de Golang pour paginer les résultats de la requête.

Il est à noter que nous devons gérer les situations limites pour nous assurer de ne pas franchir la frontière.

Summary

Cet article présente deux méthodes pour implémenter les requêtes de pagination dans Golang : en utilisant les clauses LIMIT et OFFSET de la base de données et en utilisant la tranche et le tableau intégrés de Golang pour la pagination. Les deux méthodes ont leurs propres avantages et inconvénients. La méthode à utiliser dépend des besoins réels du projet.

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!