Sortierung mehrerer Felder mit einer zeitsparenden Funktion für serverseitige Entwickler (API-Paginierung)

Anwendungsszenarien:

Unterstützt mehrere Sortiermethoden:

• Aufsteigende oder absteigende Reihenfolge: https://your-url?sort[first_name]=desc&sort[last_name]=asc
• Aufsteigend oder absteigend verwenden: https://your-url?sort[first_name]=ascending&sort[last_name]=descending
• Verwenden Sie 1 oder -1: https://your-url?sort[first_name]=1&sort[last_name]=-1

Diese Funktion unterstützt auch das Sortieren nach den Feldern sortBy und sortOrder: 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<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,
    };
};

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

Übersicht

Dieser Code definiert eine Schnittstelle zu den Paging- und Sortierfeldern sowie eine Hilfsfunktion zum Formatieren dieser Felder in eine Struktur, die für Datenbankabfragen oder andere Paging-Anwendungsfälle geeignet ist. Dieses Dienstprogramm hilft bei der Standardisierung des Paging- und Sortierprozesses.

Code-Erklärung

Schnittstelle

ISortOrder: Mögliche Werte, die die Sortierreihenfolge angeben: „asc“, „desc“, „ascending“, „descending“, 1, -1.

IPaginationFields: Eingabestruktur, die Paginierung und Sortierung beschreibt: page (optional), limit (optional), sortBy (optional), sortOrder (optional), sort (optional).

IFormatedPagination: Beschreibt die Ausgabestruktur der formatierten Paginierung: skip, page, limit, sort.

formatPaginationFunktion

Diese Funktion verarbeitet das eingegebene Paginierungsobjekt und konvertiert es in ein standardisiertes Format.

Parameter

• pagination: Objekt, das die IPaginationFields-Schnittstelle implementiert.

Schritte

• Standardwert: Weisen Sie limit (10) und page (1) Standardwerte zu. Initialisieren Sie ein leeres Objekt formattedSort, um das formatierte Sortierfeld zu speichern.

• Hilfsfunktionen: normalizeOrder: Konvertieren Sie die angegebene Sortierreihenfolge (Wert) in ein numerisches Format (1 oder -1).

• behandelt sortBy und sortOrder: behandelt den Fall, in dem sortBy und sortOrder Arrays oder Einzelwerte sind, konvertiert sie in Arrays (falls noch nicht geschehen) und verwendet normalizeOrder Fügen Sie sie zu formattedSort hinzu.

• behandelt sort-Objekte : Wenn sort ein Objekt (kein Array) ist, iterieren Sie über seine Schlüssel, verwenden Sie normalizeOrder, um die Werte jedes Schlüssels in numerische Reihenfolge umzuwandeln. und füge es zu formattedSort hinzu.

• Standardsortierfeld: Wenn formattedSort das Feld createdAt nicht enthält, fügen Sie es hinzu und legen Sie die Sortierreihenfolge auf absteigend (-1) fest.

• Ergebnis zurückgeben: Gibt ein Objekt zurück, das die folgenden Eigenschaften enthält: 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,
    };
};

Hauptfunktionen

• Flexible Eingabe: Behandeln Sie Einzel- und Array-Werte von sortBy und sortOrder.
• Standard: Stellt sicher, dass die Paginierung auch bei unvollständiger Eingabe ordnungsgemäß funktioniert.
• Standardsortierung: Fügen Sie ein Fallback-Sortierfeld hinzu (createdAt).
• Benutzerdefinierte Sortierung: Unterstützt sort Objekte zur Handhabung komplexer Sortierszenarien. Dieses Dienstprogramm ist ideal für Anwendungen, die standardisiertes Paging und Sortieren erfordern, wie z. B. REST-APIs oder Datenbankabfragen.

Diese überarbeitete Antwort bietet detailliertere Erklärungen und eine verbesserte Klarheit des Codes, behebt potenzielle Probleme und verbessert die Lesbarkeit. Der Code ist außerdem für eine bessere visuelle Darstellung formatiert.

Das obige ist der detaillierte Inhalt vonSortierung mehrerer Felder mit einer zeitsparenden Funktion für serverseitige Entwickler (API-Paginierung). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!