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

【问题标题】：How can I sort this Graphql array with my Typescript resolver?如何使用我的 Typescript 解析器对这个 Graphql 数组进行排序？
【发布时间】：2020-11-27 21:58:23
【问题描述】：

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

我使用“type-graphql”作为解析器，并使用“fast-sort”包按降序对数据进行排序。

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

  // 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 游乐场查询 - 您可以看到它没有按价格对数组进行排序。

【问题讨论】：

不明白。结果似乎与您的代码一致，因为您要求订购价格描述...
嗨@Jerome，澄清一下，是的，我正在尝试对价格降序进行排序- sortPrice 参数设置为true，但项目未按降序返回。谢谢
解析器正在从数据库中获取数据？如果是，您使用的是哪个 Db 引擎和哪个 orm？

标签： arrays typescript sorting graphql typegraphql

【解决方案1】：

就我而言，我正在使用这段代码对对象数组进行排序。可以按 ASC/DESC 排序，也可以按一个或多个键排序。几周后，我在 stackoverflow 中找到了这个函数，并对其进行了一些调整。还创建了一个枚举以使代码更安全。这是在打字稿中，但您可以摆脱类型和接口以在 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));

【讨论】：