Scénario d'application:

prend en charge plusieurs méthodes de tri:

• asc https: // your-url? Soi [premier_name] = desc & tri [last_name] = asc
]
• Utilisez ascendant ou descendant: https: // your-url? Sort [first_name] = ascendant et tri [last_name] = descendant
• Utilisez 1 ou -1: https: // your-url? Sort [first_name] = 1 & tri [last_name] = -1

Cette fonction prend également en charge le tri à l'aide du sortby et sortOrder fields: https: // your-url? SortOrder = desc & sortby = last_name

]

Code de type:

type ISortOrder = "asc" | "desc" | "ascending" | "descending" | 1 | -1;

export interface IPaginationFields {
    page?: number;
    limit?: number;
    sortBy?: string | string[];
    sortOrder?: ISortOrder | ISortOrder[];
    sort?: Record;
}

export interface IFormatedPagination {
    skip: number;
    page: number;
    limit: number;
    sort: { [key: string]: 1 | -1 };
}

export const formatPagination = (pagination: IPaginationFields): IFormatedPagination => {
    const { limit = 10, page = 1, sortBy, sortOrder, sort } = pagination;

    const formattedSort: { [key: string]: 1 | -1 } = {};

    const normalizeOrder = (order: string | number): 1 | -1 => {
        const numOrder = Number(order);
        if (!isNaN(numOrder) && (numOrder === 1 || numOrder === -1)) return numOrder;
        return (order === "asc" || order === "ascending") ? 1 : -1;
    };

    if (sortBy) {
        const sortByArray = Array.isArray(sortBy) ? sortBy : [sortBy];
        const sortOrderArray = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
        sortByArray.forEach((field, index) => {
            formattedSort[field] = normalizeOrder(sortOrderArray[index]);
        });
    }

    if (sort && typeof sort === 'object' && !Array.isArray(sort)) {
        Object.entries(sort).forEach(([field, order]) => {
            formattedSort[field] = normalizeOrder(order);
        });
    }

    if (!formattedSort.createdAt) {
        formattedSort.createdAt = -1;
    }

    return {
        skip: (page - 1) * limit,
        limit: limit,
        page: page,
        sort: formattedSort,
    };
};

JavaScript Code:

const formatPagination = (pagination) => {
    const { limit = 10, page = 1, sortBy, sortOrder, sort } = pagination;

    const formattedSort = {};

    const normalizeOrder = (order) => {
        const numOrder = Number(order);
        if (!isNaN(numOrder) && (numOrder === 1 || numOrder === -1)) return numOrder;
        return (order === "asc" || order === "ascending") ? 1 : -1;
    };

    if (sortBy) {
        const sortByArray = Array.isArray(sortBy) ? sortBy : [sortBy];
        const sortOrderArray = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
        sortByArray.forEach((field, index) => {
            formattedSort[field] = normalizeOrder(sortOrderArray[index]);
        });
    }

    if (sort && typeof sort === 'object' && !Array.isArray(sort)) {
        Object.entries(sort).forEach(([field, order]) => {
            formattedSort[field] = normalizeOrder(order);
        });
    }

    if (!formattedSort.createdAt) {
        formattedSort.createdAt = -1;
    }

    return {
        skip: (page - 1) * limit,
        limit: limit,
        page: page,
        sort: formattedSort,
    };
};

Aperçu

Ce code définit l'interface pour les champs de pagination et de tri, et une fonction pratique pour formater ces champs en structures adaptées aux requêtes de base de données ou à d'autres cas d'utilisation de pagination. Cet utilitaire aide à standardiser le processus de pagination et de tri.

explication du code ]

interface

IsortOrder : valeurs possibles représentant l'ordre de tri: "asc", "desc", "ascendant", "descendant", 1, -1.

iPaginationFields : Décrivez la structure d'entrée de la pagination et du tri: page (facultatif), limite (facultatif), sortby ] ]]]]]]]]) (Facultatif), sortOrder (facultatif), tri (facultatif).

iforMatedPagination : Décrivez la structure de sortie de la pagination formatée: skip , page , limite , tri ]]]].

formatpagination fonction

Cette fonction traite l'objet de pagination d'entrée et le convertit en un format standardisé.

paramètre

• pagination : objet qui implémente l'interface iPaginationFields .

étape

• valeur par défaut : attribuez des valeurs par défaut à limite (10) et page (1). Initialiser un objet vide FormattedSort est utilisé pour stocker des champs de tri formatés.

• Fonction d'assistance: normalizeOrder : convertit l'ordre de tri donné (valeur) au format numérique (1 ou -1).

• manche sortby et sortOrder : gère le cas où sortby et sortOrder sont des objets ou des valeurs uniques , Convertissez-les en un tableau (sinon déjà), et ajoutez-les à formatedSort en utilisant normalizeOrder .

• manche tri objet : si srie est un objet (pas un tableau), itère sur sa clé et utilise normalizeOrder to to to to to to to to to La valeur de chaque touche est convertie en ordre numérique et ajoutée à formattedSort .

• champ de tri par défaut : if formattedSort ne contient pas le champ CreateDat , ajoutez-le et définissez son ordre de tri pour descendant (-1).

• Return result: Return an object with the following attributes: skip, limit, page, sort].

const pagination = {
  page: 2,
  limit: 20,
  sortBy: ['name', 'date'],
  sortOrder: ['asc', 'desc'],
  sort: { age: 1, score: -1 },
};

const formatted = formatPagination(pagination);

console.log(formatted);

fonctions principales

Entrée flexible: traite les valeurs uniques et de tableau de
• sortby et sortOrder .
par défaut: même si l'entrée est incomplète, il garantit que la pagination fonctionne correctement.
Triement par défaut: Ajoutez un champ de tri de secours (
• créé ).
personnalisé Sort: prend en charge
• tri objets pour gérer les scénarios de tri complexes. Cet utilitaire est idéal pour les applications qui nécessitent une pagination et un tri standardisés, tels que les API REST ou les requêtes de base de données.

Cette réponse révisée fournit des explications plus détaillées et une clarté de code améliorée, aborder les problèmes potentiels et améliorer la lisibilité.