Tri de plusieurs champs avec une fonction permettant de gagner du temps pour le développeur côté serveur (pagination API)

Scénarios d'application :

Prend en charge plusieurs méthodes de tri :

• Ordre croissant ou décroissant : https://your-url?sort[first_name]=desc&sort[last_name]=asc
• Utiliser ascendant ou décroissant : https://your-url?sort[first_name]=ascending&sort[last_name]=descending
• Utilisez 1 ou -1 : https://your-url?sort[first_name]=1&sort[last_name]=-1

Cette fonction prend également en charge le tri à l'aide des champs sortBy et sortOrder : https://your-url?sortOrder=desc&sortBy=last_name

Code TypeScript :

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

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

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,
    };
};

Code JavaScript :

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 une interface pour les champs de pagination et de tri, ainsi qu'une fonction utilitaire pour formater ces champs dans une structure adaptée aux requêtes de base de données ou à d'autres cas d'utilisation de pagination. Cet utilitaire permet de standardiser le processus de pagination et de tri.

Explication du code

Interface

ISortOrder : Valeurs possibles indiquant l'ordre de tri : "asc", "desc", "ascending", "descending", 1, -1.

IPaginationFields : Structure de saisie décrivant la pagination et le tri : page (facultatif), limit (facultatif), sortBy (facultatif), sortOrder (facultatif), sort (facultatif).

IFormatedPagination : Décrit la structure de sortie de la pagination formatée : skip, page, limit, sort.

formatPaginationFonction

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

Paramètres

• pagination : Objet qui implémente l'interface IPaginationFields.

Étapes

• Valeur par défaut : Attribuez des valeurs par défaut à limit (10) et page (1). Initialisez un objet vide formattedSort pour stocker le champ de tri formaté.

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

• gère sortBy et sortOrder : gère le cas où sortBy et sortOrder sont des tableaux ou des valeurs uniques, convertissez-les en tableaux (s'ils ne le sont pas déjà) et utilisez normalizeOrder Ajoutez-les à formattedSort.

• gère sort objets  : si sort est un objet (pas un tableau), parcourez ses clés, utilisez normalizeOrder pour convertir les valeurs de chaque clé dans l'ordre numérique, et ajoutez-le à formattedSort.

• Champ de tri par défaut : Si formattedSort ne contient pas le champ createdAt, ajoutez-le et définissez son ordre de tri sur décroissant (-1).

• Résultat de retour : Renvoie un objet contenant les propriétés suivantes : skip, limit, page, sort.

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

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

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,
    };
};

Fonctions principales

• Saisie flexible : gérez les valeurs simples et matricielles de sortBy et sortOrder.
• Par défaut : garantit que la pagination fonctionne correctement même en cas de saisie incomplète.
• Tri par défaut : ajoutez un champ de tri de secours (createdAt).
• Tri personnalisé : prend en charge les objets sort pour gérer des scénarios de tri complexes. Cet utilitaire est idéal pour les applications qui nécessitent une pagination et un tri standardisés, telles 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é améliorée du code, résolvant les problèmes potentiels et améliorant la lisibilité. Le code est également formaté pour une meilleure présentation visuelle.

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!