Senario aplikasi:

Menyokong pelbagai kaedah pengisihan:

• Tertib menaik atau menurun: https://your-url?sort[first_name]=desc&sort[last_name]=asc
• Gunakan menaik atau menurun: https://your-url?sort[first_name]=ascending&sort[last_name]=descending
• Gunakan 1 atau -1: https://your-url?sort[first_name]=1&sort[last_name]=-1

Fungsi ini juga menyokong pengisihan menggunakan medan sortBy dan sortOrder: https://your-url?sortOrder=desc&sortBy=last_name

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

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

Ikhtisar

Kod ini mentakrifkan antara muka ke medan pengisihan dan halaman, serta fungsi utiliti untuk memformat medan ini ke dalam struktur yang sesuai untuk pertanyaan pangkalan data atau kes penggunaan halaman lain. Utiliti ini membantu menyeragamkan proses pengisihan dan halaman.

Penjelasan kod

Antara Muka

ISortOrder: Nilai yang mungkin menunjukkan susunan isihan: "asc", "desc", "naik", "menurun", 1, -1.

IPaginationFields: Struktur input yang menerangkan halaman dan pengisihan: page (pilihan), limit (pilihan), sortBy (pilihan), sortOrder (pilihan), sort (pilihan).

IFormatedPagination: Menerangkan struktur output penomboran berformat: skip, page, limit, sort.

formatPagination Fungsi

Fungsi ini memproses objek penomboran input dan menukarnya kepada format piawai.

Parameter

• pagination: Objek yang melaksanakan antara muka IPaginationFields.

Langkah

• Nilai lalai: Berikan nilai lalai kepada limit (10) dan page (1). Mulakan objek kosong formattedSort untuk menyimpan medan isihan terformat.

• Fungsi pembantu: normalizeOrder: Tukar susunan isihan (nilai) yang diberikan kepada format angka (1 atau -1).

• mengendalikan sortBy dan sortOrder: mengendalikan kes di mana sortBy dan sortOrder ialah tatasusunan atau nilai tunggal, tukarkannya kepada tatasusunan (jika belum), dan gunakan normalizeOrder Tambahkan mereka pada formattedSort.

• mengendalikan sort objek : jika sort ialah objek (bukan tatasusunan), ulangi kekuncinya, gunakan normalizeOrder untuk menukar nilai setiap kunci kepada susunan berangka, dan Tambahkan pada formattedSort.

• Medan isihan lalai: Jika formattedSort tidak mengandungi medan createdAt, tambahkannya dan tetapkan tertib isihannya kepada menurun (-1).

• Kembali hasil: Mengembalikan objek yang mengandungi sifat berikut: 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,
    };
};

Fungsi utama

• Input fleksibel: mengendalikan nilai tunggal dan tatasusunan sortBy dan sortOrder.
• Lalai: Memastikan penomboran berfungsi dengan betul walaupun dengan input yang tidak lengkap.
• Isih lalai: Tambah medan isihan sandaran (createdAt).
• Isih tersuai: Menyokong sort objek untuk mengendalikan senario isihan yang kompleks. Utiliti ini sesuai untuk aplikasi yang memerlukan halaman dan pengisihan piawai, seperti REST API atau pertanyaan pangkalan data.

Respons yang disemak ini memberikan penjelasan yang lebih terperinci dan kejelasan kod yang dipertingkatkan, menangani isu yang berpotensi dan meningkatkan kebolehbacaan Kod ini juga diformatkan untuk persembahan visual yang lebih baik.

Atas ialah kandungan terperinci Pengisihan berbilang medan dengan fungsi penjimatan masa untuk pembangun sisi pelayan (penomboran api). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!