आवेदन परिदृश्य:

]
• टाइपस्क्रिप्ट कोड:
• निर्यात इंटरफ़ेस ipaginationfields { पेज?: नंबर; सीमा?: संख्या; सॉर्टबी?: स्ट्रिंग | SORTORDORD; iSortorder | सॉर्ट?: रिकॉर्ड ; } निर्यात इंटरफ़ेस iformatedPagination { छोड़ें: संख्या; पृष्ठ: संख्या; सीमा: संख्या; सॉर्ट: {[कुंजी: स्ट्रिंग]: 1 | } एक्सपोर्ट कास्ट फॉर्मेटपैगिनेशन = (पेजिनेशन: ipaginationfields): iformatedPagination => {{ const {सीमा = 10, पृष्ठ = 1, सॉर्टबी, सॉर्टऑर्डर, सॉर्ट} = पेजिनेशन; const फॉर्मेटेड्स: {[कुंजी: स्ट्रिंग]: 1 | -1} = {}; const normalizeorder = (आदेश: स्ट्रिंग | संख्या): 1 | const numorder = संख्या (आदेश); if वापसी (आदेश === "ASC" || आदेश === "आरोही")? }; if (सॉर्टबी) { Const SortByArray = Array.isarray (सॉर्टबी)? Const SortOrdarray = Array.isarray (SortOrder)? SORTBYARRAY.FOREACH ((फ़ील्ड, इंडेक्स) => { फॉर्मेटेड्सोर्ट [फ़ील्ड] = सामान्य रूप से (SORTORDORDARRAY [INDEX]); }); } if (सॉर्ट && typeof सॉर्ट === 'ऑब्जेक्ट' &&! Array.isarray (सॉर्ट)) { Object.entries (सॉर्ट) .foreach (([फ़ील्ड, ऑर्डर]) => { फॉर्मेटेड्सोर्ट [फ़ील्ड] = सामान्यीकरण (आदेश); }); } if (formattedsort.createdat) { फॉर्मेटेड्सोर्ट.क्रेटेडैट = -1; } वापस करना { छोड़ें: (पृष्ठ - 1) * सीमा, सीमा: सीमा, पृष्ठ: पृष्ठ, सॉर्ट: फॉर्मेटेड्सॉर्ट, }; }; ]
const {सीमा = 10, पृष्ठ = 1, सॉर्टबी, सॉर्टऑर्डर, सॉर्ट} = पेजिनेशन; const formattedsort = {}; const normalizeOrder = (आदेश) => { const numorder = संख्या (आदेश); if वापसी (आदेश === "ASC" || आदेश === "आरोही")? }; if (सॉर्टबी) { Const SortByArray = Array.isarray (सॉर्टबी)? Const SortOrdarray = Array.isarray (SortOrder)? SORTBYARRAY.FOREACH ((फ़ील्ड, इंडेक्स) => { फॉर्मेटेड्सोर्ट [फ़ील्ड] = सामान्य रूप से (SORTORDORDARRAY [INDEX]); }); } if (सॉर्ट && typeof सॉर्ट === 'ऑब्जेक्ट' &&! Array.isarray (सॉर्ट)) { Object.entries (सॉर्ट) .foreach (([फ़ील्ड, ऑर्डर]) => { फॉर्मेटेड्सोर्ट [फ़ील्ड] = सामान्यीकरण (आदेश); }); } if (formattedsort.createdat) { फॉर्मेटेड्सोर्ट.क्रेटेडैट = -1; } वापस करना { छोड़ें: (पृष्ठ - 1) * सीमा, सीमा: सीमा, पृष्ठ: पृष्ठ, सॉर्ट: फॉर्मेटेड्सॉर्ट, }; };
अवलोकन

] यह उपयोगिता पेजिंग और छँटाई प्रक्रिया को मानकीकृत करने में मदद करती है। कोड स्पष्टीकरण ]

] ] ]]]]]]) (वैकल्पिक),

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

] यह फ़ंक्शन इनपुट पेजिंग ऑब्जेक्ट को संसाधित करता है और इसे एक मानकीकृत प्रारूप में परिवर्तित करता है।

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

] एक खाली ऑब्जेक्ट को आरंभ करें फॉर्मेटेड्सोर्ट

]

, उन्हें एक सरणी में परिवर्तित करें (यदि पहले से ही नहीं), और उन्हें

में जोड़ें का उपयोग करके ] प्रत्येक कुंजी का मान संख्यात्मक क्रम में परिवर्तित हो जाता है और फॉर्मेटेड्सोर्ट में जोड़ा जाता है। ]

पेज 2, सीमा: २०, सॉर्टबी: ['नाम', 'दिनांक'], SORTORDORD: ['ASC', 'Desc'], सॉर्ट: {आयु: 1, स्कोर: -1}, }; const स्वरूपित = formatpagination (पेजिनेशन); कंसोल.लॉग (स्वरूपित); मुख्य कार्य ]

डिफ़ॉल्ट: भले ही इनपुट अधूरा हो, यह सुनिश्चित करता है कि पेजिंग ठीक से काम करता है। ] ] यह उपयोगिता उन अनुप्रयोगों के लिए आदर्श है जिनके लिए मानकीकृत पेजिंग और छंटाई की आवश्यकता होती है, जैसे कि रेस्ट एपीआई या डेटाबेस क्वेरी।

]