TypeScript 对数组进行排序

Posted 2023-02-22

【中文标题】TypeScript 对数组进行排序

【英文标题】：TypeScript sorting an array

【发布时间】：2014-03-08 09:58:54

【问题描述】：

我一直试图找出我在使用 typescript 时遇到的一个非常奇怪的问题。它将内联布尔表达式视为第一个值的类型，而不是完整的表达式。

因此，如果您尝试以下简单的操作：

var numericArray:Array<number> = [2,3,4,1,5,8,11];

var sorrtedArray:Array<number> = numericArray.sort((n1,n2)=> n1 > n2);

TryIt

您将在排序方法上收到错误消息，指出参数与调用目标的任何签名都不匹配，因为您的结果是数字而不是布尔值。我想我错过了一些东西，因为我很确定 n1>n2 是一个布尔语句。

【参考方案1】：

数字

在对数字进行排序时，可以使用紧凑比较：

var numericArray: number[] = [2, 3, 4, 1, 5, 8, 11];

var sortedArray: number[] = numericArray.sort((n1,n2) => n1 - n2);

即- 而不是 <。

其他类型

如果您要比较其他任何内容，则需要将比较结果转换为数字。

var stringArray: string[] = ['AB', 'Z', 'A', 'AC'];

var sortedArray: string[] = stringArray.sort((n1,n2) => 
    if (n1 > n2) 
        return 1;
    

    if (n1 < n2) 
        return -1;
    

    return 0;
);

对象

对于对象，您可以根据属性进行排序，请记住以上关于能够简写数字类型的信息。以下示例适用于任何类型。

var objectArray:  age: number; [] = [ age: 10,  age: 1 , age: 5];

var sortedArray:  age: number; [] = objectArray.sort((n1,n2) => 
    if (n1.age > n2.age) 
        return 1;
    

    if (n1.age < n2.age) 
        return -1;
    

    return 0;
);

【讨论】：

有人能解释一下为什么对于小于测试，'[e-mail]' 在小于'[e-mail]' 的情况下返回真吗？例如：让 myTest = ('[e-mail]'

第二种情况可以使用localeCompare()比较当前locale中的字符串，返回一个数字

请解释一下，(n1,n2)=>n1-n2 表达式将如何执行或工作..??

@RahulChaudhari 在数字示例中，它是一个接受数字 n1 和 n2 的函数，在函数内它返回 n1-n2，它可以是正数、零或一个负数。这告诉排序操作是否需要切换项目，从而启用排序。

它可以是不同属性的过滤器

【参考方案2】：

错误完全正确。

正如它试图告诉你的那样，.sort() 采用一个返回数字而非布尔值的函数。

如果第一项较小，则需要返回负数；如果大于则为正，如果相等则为零。

【讨论】：

这就是我们使用 TypeScript 的原因！ :-)

【参考方案3】：

很好的答案Sohnee。 想补充一点，如果您有一个对象数组并且您希望按键排序，那么它几乎相同，这是一个可以按日期（数字）或标题（字符串）排序的示例：

    if (sortBy === 'date') 
        return n1.date - n2.date
     else 
        if (n1.title > n2.title) 
           return 1;
        
        if (n1.title < n2.title) 
            return -1;
        
        return 0;
    

如果它更动态，也可以将里面的值作为变量 n1[field] vs n2[field]，只要保持字符串和数字之间的差异。

【讨论】：

应使用 cmets 函数对答案进行评论。

@Nicktar 这可能是作为格式化的答案发布的。但无论如何它不会造成任何伤害

【参考方案4】：

let numericArray: number[] = [2, 3, 4, 1, 5, 8, 11];

let sortFn = (n1 , n2) => number  return n1 - n2; 

const sortedArray: number[] = numericArray.sort(sortFn);

按某个字段排序：

let arr:key:number[] = [key : 2, key : 3, key : 4, key : 1, key : 5, key : 8, key : 11];

let sortFn2 = (obj1 , obj2) => key:number  return obj1.key - obj2.key; 

const sortedArray2:key:number[] = arr.sort(sortFn2);

【讨论】：

n1 - 当 n1 n2 时为正，当 n1 == n2 时为 0

谢谢！我为此更改了它： myArray.sort((a, b): number => return a.NumberProp - b.NumberProp; );

key:number 排序功能在我的打字稿文件中不起作用...删除它...现在可以工作，我有 key:Date 数据类型

【参考方案5】：

排序混合数组（字母和数字）

function naturalCompare(a, b) 
   var ax = [], bx = [];

   a.replace(/(\d+)|(\D+)/g, function (_, $1, $2)  ax.push([$1 || Infinity, $2 || ""]) );
   b.replace(/(\d+)|(\D+)/g, function (_, $1, $2)  bx.push([$1 || Infinity, $2 || ""]) );

   while (ax.length && bx.length) 
     var an = ax.shift();
     var bn = bx.shift();
     var nn = (an[0] - bn[0]) || an[1].localeCompare(bn[1]);
     if (nn) return nn;
   

   return ax.length - bx.length;


let builds = [ 
     id: 1, name: 'Build 91', 
     id: 2, name: 'Build 32' , 
     id: 3, name: 'Build 13' , 
     id: 4, name: 'Build 24' ,
     id: 5, name: 'Build 5' ,
     id: 6, name: 'Build 56' 
]

let sortedBuilds = builds.sort((n1, n2) => 
  return naturalCompare(n1.name, n2.name)
)

console.log('Sorted by name property')
console.log(sortedBuilds)

【参考方案6】：

最简单的方法似乎是从第一个数字中减去第二个数字：

var numericArray:Array<number> = [2,3,4,1,5,8,11];

var sorrtedArray:Array<number> = numericArray.sort((n1,n2) => n1 - n2);

https://alligator.io/js/array-sort-numbers/

【参考方案7】：

我用这个

type SortArrayType = <T>(arr: T[]) => T[];

const sortArray: SortArrayType = (arr) => 
  return arr.sort((a, b) => 
    const strA = JSON.stringify(a);
    const strB = JSON.stringify(b);
    if (strA < strB) 
      return -1;
    
    if (strA > strB) 
      return 1;
    
    return 0;
  );
;

【参考方案8】：

我今天写这篇文章是在尝试用 TypeScript 重新创建 _.sortBy 时写的，我想我会把它留给有需要的人。

// ** Credits for getKeyValue at the bottom **
export const getKeyValue = <T extends , U extends keyof T>(key: U) => (obj: T) => obj[key] 

export const sortBy = <T extends >(index: string, list: T[]): T[] => 
    return list.sort((a, b): number => 
        const _a = getKeyValue<keyof T, T>(index)(a)
        const _b = getKeyValue<keyof T, T>(index)(b)
        if (_a < _b) return -1
        if (_a > _b) return 1
        return 0
    )

用法：

它需要一个泛型类型 T 的数组，因此转换为 <T extends >，以及使用 T[] 键入参数和函数返回类型

const x = [ label: 'anything' ,  label: 'goes']
const sorted = sortBy('label', x)

** getByKey fn 找到 here