Anwendungsszenario:

Unterstützen Sie mehrere Sortiermethoden:

• asc https: // your-url? Sort [first_name] = desc & sort [last_name] = asc
]
• Verwenden Sie aufsteigend oder absteigend: https: // your-url? Sort [first_name] = aufsteigend & sort [last_name] = dachsing
• Verwenden Sie 1 oder -1: https: // your-url? Sort [first_name] = 1 & sort [last_name] = -1

Diese Funktion unterstützt auch die Sortierung der Sortby und sortOrder Felder: https: // your-url? SortOrder = desc & sortby = last_name

TypeScript -Code:

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

Überblick

Dieser Code definiert die Schnittstelle für Paging- und Sortierfelder und eine praktische Funktion, um diese Felder in Strukturen zu formatieren, die für Datenbankabfragen oder andere Paging -Anwendungsfälle geeignet sind. Dieses Dienstprogramm hilft, den Paging- und Sortierprozess zu standardisieren.

code Erklärung

Schnittstelle

isortorder : Mögliche Werte, die die Sortierordnung darstellen: "ASC", "Desc", "Ascending", "Abstieg", 1, -1.

ipaginationFields : Beschreiben Sie die Eingabestruktur von Pagination und Sortierung: page (optional), limit (optional), sortby ] ]]]]]]]]) (Optional), sortOrder (optional), sort (optional).

iFormatedPagination : Beschreiben Sie die Ausgabestruktur der formatierten Pagination: überspringen , page , limit , sort ]]].

formatpagination function

Diese Funktion verarbeitet das Eingabe -Paging -Objekt und konvertiert es in ein standardisiertes Format.

Parameter

• pagination : objekt, das die ipaginationFields interface implementiert.

Schritt

• default value : Default -Werte an limit (10) und page (1). Initialisieren Sie ein leeres Objekt formattedSort wird verwendet, um formatierte Sortierfelder zu speichern.

• helfer function: normalizeorder : konvertiert die angegebene Sortierreihenfolge (Wert) in numerisches Format (1 oder -1).

• handle sortby und sortOrder : verhandelt den Fall, in dem sortby und sortorder Arrays oder einzelne Werte sind Konvertieren Sie sie in ein Array (wenn auch nicht noch) und fügen Sie sie zu formattedSort hinzu Normalizeorder .

• handle sort object : if sort ist ein Objekt (kein Array), iteriert über seinen Schlüssel und verwendet Normalizeorder zu zu Der Wert jedes Schlüssels wird in numerische Reihenfolge konvertiert und zu formattedSort hinzugefügt.

• default sortieren field : if formattedSort enthält das Feld erstellt , fügen Sie es nicht hinzu und setzen Sie seine Sortierreihenfolge auf absteigend (-1).

• return result : Rückgabe eines Objekts mit den folgenden Attributen: überspringen , 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);

Hauptfunktionen

• Flexible Eingabe: Verarbeitet einzelne und Array -Werte von sortby und sortOrder .
• Standard: Auch wenn die Eingabe unvollständig ist, stellt sie sicher, dass das Paging ordnungsgemäß funktioniert.
• default sortieren: fügen Sie ein fallback -sortierfeld hin ( createdat ).
• benutzerdefinierte sortieren: unterstützt sort Objekte, um komplexe Sortierszenarien zu verarbeiten. Dieses Dienstprogramm ist ideal für Anwendungen, die standardisierte Paging und Sortierung erfordern, z. B. REST -APIs oder Datenbankabfragen.

Diese überarbeitete Antwort enthält detailliertere Erklärungen und verbesserte Code -Klarheit, die potenzielle Probleme und die Verbesserung der Lesbarkeit für eine bessere visuelle Präsentation formatiert.