如何使用我的 Typescript 解析器对这个 Graphql 数组进行排序？

Question

我试图让我的过滤器在 sortPrice === true 时根据“价格”以降序返回我的对象数组。

我正在为解析器使用“type-graphql”，并使用 package“快速排序”对数据进行降序排序。

这是我的解析器代码 -请注意价格过滤器按预期工作。

 // Price filter if (minPrice) { filteredItems = filteredItems.filter((item: any) => item.price >= minPrice); } if (maxPrice) { filteredItems = filteredItems.filter((item: any) => item.price <= maxPrice); } // Sort price/rating if (sortPrice) { filteredItems = filteredItems.filter((item: any) => sort(items).desc()); }

这是我的 graphql 游乐场查询 - 您可以看到它没有按价格对数组进行排序。

Answer 1

就我而言，我正在使用这段代码对一组对象进行排序。 可以按 ASC/DESC 排序，也可以按一个或多个键排序。 几周后，我在 stackoverflow 中找到了这个 function，我已经稍微调整了一下。 还创建了一个枚举以使代码更安全。 这是在 typescript 但你可以摆脱类型和接口来转换 Javascript

export declare enum EOrderBy {
    ASC = "ASC",
    DESC = "DESC"
}

export interface ISortConfig<T> {
    column: keyof T;
    order?: keyof typeof EOrderBy;
    map?: itemMap;
}

export const sortByValues = <T extends object>(
    columns: (keyof T | ISortConfig<T>)[]
): ((a: T, b: T) => 0 | 1 | -1) => {
    return function (a: T, b: T) {
        const firstKey: keyof T | ISortConfig<T> = columns[0];
        const isSimple = typeof firstKey === "string";
        const key: keyof T = isSimple
            ? (firstKey as keyof T)
            : (firstKey as ISortConfig<T>).column;
        const reverse: boolean = isSimple
            ? false
            : (firstKey as ISortConfig<T>).order
            ? (firstKey as ISortConfig<T>).order?.toUpperCase() === "ASC"
                ? false
                : true
            : false;
        const map: itemMap | null = isSimple
            ? null
            : (firstKey as ISortConfig<T>).map || null;

        const valA = map ? map(a[key]) : a[key];
        const valB = map ? map(b[key]) : b[key];
        if (valA === valB) {
            if (columns.length === 1) {
                return 0;
            }
            return sortByValues<T>(columns.slice(1))(a, b);
        }
        if (reverse) {
            return valA > valB ? -1 : 1;
        }
        return valA > valB ? 1 : -1;
    };
};

export const sortArray = <T extends object>(
    array: T[],
    columns: (keyof T | ISortConfig<T>)[]
) => {
    return array.sort(sortByValues<T>(columns));
};

用法示例：

interface IObj {
    name: string;
    prenom: string;
    montant: number;
}

const arrobj: IObj[] = [
    {
        name: "al",
        prenom: "jero",
        montant: 10,
    },
    {
        name: "al",
        prenom: "ale",
        montant: 100,
    },
    {
        name: "zozo",
        prenom: "aa",
        montant: 10,
    },
];

//simple order 
console.log(sortArray(arrobj, [{ column: "prenom", order: "ASC" }]));
console.log(sortArray(arrobj, [{ column: "montant", order: "DESC" }]));


//order by several properties (montant DESC then name ASC)
console.log(
    sortArray(arrobj, [
        { column: "montant", order: "DESC" },
        { column: "name", order: "ASC" },
    ])
);

// preparing the orderBy parameter in a variable then send it to the function
const orderBy: IOrderBy<IObj>[] = [
    { column: "name", order: EOrderBy.DESC },
    { column: "prenom", order: EOrderBy.DESC },
];

console.log(sortArray(arrobj, orderBy));