JavaScript 中的 Number.sign()

Question

想知道是否有任何重要的方法可以找到数字的符号（符号函数）？
可能比显而易见的

var sign = number > 0 ? 1 : number < 0 ? -1 : 0;

---

简短答案更短/更快/更优雅的解决方案！

使用这个，你会安全又快速（来源：moz）

if (!Math.sign) Math.sign = function(x) { return ((x > 0) - (x < 0)) || +x; };

您可能想查看性能和类型强制比较fiddle

已经过去很长时间了。进一步主要是历史原因。

---

结果

目前我们有以下解决方案：

---

1. 明显且快速

function sign(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }

---

1.1. 修改自 kbec -一种类型转换更少，性能更高，更短[最快]

function sign(x) { return x ? x < 0 ? -1 : 1 : 0; }

注意： sign("0") -> 1

---

2. 优雅，简短，不太快[最慢]

function sign(x) { return x && x / Math.abs(x); }

注意： sign(+-Infinity) - > NaN, sign("0") ->; NaN

由于 Infinity 是 JS 中的合法数字，因此该解决方案似乎并不完全正确。

---

3. 艺术......但非常慢[最慢]

function sign(x) { return (x > 0) - (x < 0); }

---

4. 使用位移位
快，但是sign(-Infinity) -> 0

function sign(x) { return (x >> 31) + (x > 0 ? 1 : 0); }

---

5. 类型安全 [megafast]

! 看起来浏览器（尤其是 chrome 的 v8）发挥了一些作用优化，并且该解决方案比其他解决方案性能更高，甚至比 (1.1) 更高，尽管它包含 2 个额外的操作，并且从逻辑上讲永远不会更快。

function sign(x) {
    return typeof x === 'number' ? x ? x < 0 ? -1 : 1 : x === x ? 0 : NaN : NaN;
}

---

工具

• jsperf 性能测试；
• fiddle - 类型转换测试；

欢迎改进！

---

[Offtopic] 接受的答案

• Andrey Tarantsov - +100 的艺术，但遗憾的是它比明显的方法慢了大约 5 倍

• Frédéric Hamidi - 不知怎的，得到最多支持的答案（在撰写本文时），这有点酷，但这绝对不是事情应该如何完成，恕我直言。此外，它不能正确处理无穷大数字，这也是数字，你知道。

• kbec - 是对显而易见的解决方案的改进。虽然不是那么革命性，但综合考虑，我认为这种方法是最好的。投票给他:)

Answer 1

更优雅的快速解决方案版本：

var sign = number?number<0?-1:1:0

Answer 2

将数字除以其绝对值也可以得出其符号。使用短路逻辑 AND 运算符允许我们使用特殊情况 0，这样我们就不会最终除以它：

var sign = number && number / Math.abs(number);

Answer 3

您正在寻找的函数称为 signum，实现它的最佳方法是：

function sgn(x) {
  return (x > 0) - (x < 0);
}

Answer 4

这应该不支持 JavaScript (ECMAScript) 的签名零吗？当在“megafast”函数中返回 x 而不是 0 时，它似乎可以工作：

function sign(x) {
    return typeof x === 'number' ? x ? x < 0 ? -1 : 1 : x === x ? x : NaN : NaN;
}

这使得它与 ECMAScript 的 Math.sign (MDN）：

返回 x 的符号，指示 x 是正数、负数还是零。

• 如果 x 为 NaN，则结果为 NaN。
• 如果 x 为 -0，则结果为 -0。
• 如果 x 为 +0，则结果为 +0。
• 如果 x 为负且不为 −0，则结果为 −1。
• 如果 x 为正数且不是 +0，则结果为 +1。

Answer 5

对于对最新浏览器的情况感兴趣的人，在 ES6 版本中，有一个原生的 Math.sign 方法。您可以在此处查看支持。

基本上它返回 -1、1、0 或 NaN

Math.sign(3);     //  1
Math.sign(-3);    // -1
Math.sign('-3');  // -1
Math.sign(0);     //  0
Math.sign(-0);    // -0
Math.sign(NaN);   // NaN
Math.sign('foo'); // NaN
Math.sign();      // NaN

Answer 6

var sign = number >> 31 | -number >>> 31;

如果您不需要 Infinity 并且知道该数字是整数，则超级快，可在 openjdk-7 源代码中找到：java.lang.Integer.signum()

Answer 7

我想我添加这个只是为了好玩：

function sgn(x){
  return 2*(x>0)-1;
}

0 和 NaN 将返回 -1
在 +/-Infinity 上工作正常

Answer 8

适用于所有数字、0 和 -0、以及 Infinity 和 -Infinity 的解决方案>，是：

function sign( number ) {
    return 1 / number > 0 ? 1 : -1;
}

参见问题“+0 和 -0 相同吗？”了解更多信息。

---

警告：这些答案都不是，包括现在标准的Math.sign 将适用于 0 与 -0 的情况。这对您来说可能不是问题，但在某些物理实现中可能很重要。

Answer 9

您可以对数字进行位移位并检查最高有效位 (MSB)。如果 MSB 为 1，则该数字为负数。如果为 0，则该数字为正数（或 0）。

Answer 10

我正要问同样的问题，但在我写完之前就找到了解决方案，看到这个问题已经存在，但没有看到这个解决方案。

(n >> 31) + (n > 0)

通过添加三元似乎更快 (n >> 31) + (n> 0) 0?1:0)

Answer 11

与 Martijn 的答案非常相似的是

function sgn(x) {
    isNaN(x) ? NaN : (x === 0 ? x : (x < 0 ? -1 : 1));
}

我发现它更具可读性。此外（或者，取决于您的观点），它还可以理解可以解释为数字的事物；例如，当出现 '-5' 时，它会返回 -1。

Answer 12

我没有看到从 Math.sign 返回 -0 和 0 的任何实际意义，所以我的版本是：

function sign(x) {
    x = Number(x);
    if (isNaN(x)) {
        return NaN;
    }
    if (x === -Infinity || 1 / x < 0) {
        return -1;
    }
    return 1;
};

sign(100);   //  1
sign(-100);  // -1
sign(0);     //  1
sign(-0);    // -1

Answer 13

我知道的方法如下：

Math.sign(n)

var s = Math.sign(n)

这是本机函数，但速度最慢，因为函数调用的开销。然而，它确实处理“NaN”，而下面的其他内容可能只是假设 0（即 Math.sign('abc') 是 NaN）。

((n>0) - (n<0))

var s = ((n>0) - (n<0));

在这种情况下，只有左边或者根据符号右侧可以是 1。这会导致 1-0 (1)、0-1 (-1) 或 0-0 (0)。

这个速度似乎与 Chrome 中的下一个速度并驾齐驱。

(n>>31)|(!!n)

var s = (n>>31)|(!!n);

使用“符号传播右移”。基本上移位 31 会丢弃除符号之外的所有位。如果设置了符号，则结果为 -1，否则为 0。 | 的右侧通过将值转换为布尔值（0 或 1 [顺便说一句：非数字字符串，例如!!'abc'，在本例中变为 0，而不是 NaN]），然后使用按位 OR 运算来组合这些位。

这似乎是所有浏览器中最好的平均性能（至少在 Chrome 和 Firefox 中是最好的），但并不是所有浏览器中最快的。由于某种原因，三元运算符在 IE 中速度更快。

n?n<0?-1:1:0

var s = n?n<0?-1:1:0;

由于某种原因，在 IE 中最快。

jsPerf

执行的测试：https://jsperf.com/get-sign -来自值

Answer 14

我的两分钱，有一个返回与 Math.sign 相同结果的函数，即 sign(-0) --> -0, 符号(-无穷大) --> -无穷大，符号(null) --> 0, 符号(未定义) --> NaN 等。Jsperf

function sign(x) {
    return +(x > -x) || (x && -1) || +x;
}

不允许我创建测试或修订，很抱歉无法为您提供测试（我已经尝试过 jsbench.github.io，但结果似乎比 Jsperf 更接近） ...）

如果有人可以将其添加到 Jsperf 修订版中，我很好奇它与之前给出的所有解决方案相比如何...

谢谢！

吉姆.

编辑：

我应该写：(

function sign(x) {
    return +(x > -x) || (+x && -1) || +x;
}

(+x && -1) 而不是 (x && -1) ) 以便正确处理 sign('abc') (--> NaN)

Answer 15

IE 11 不支持 Math.sign。我将最佳答案与 Math.sign 答案相结合：

Math.sign = Math.sign || function(number){
    var sign = number ? ( (number <0) ? -1 : 1) : 0;
    return sign;
};

现在，可以直接使用 Math.sign。

Answer 16

这是一个紧凑版本：

let sign=x=>2*(x>=0)-1
//Tests
console.log(sign(0)); //1
console.log(sign(6)); //1
console.log(sign(Infinity)); //1
console.log(sign(-6)); //-1
console.log(sign(-Infinity)); //-1
console.log(sign("foo")); //-1

如果您想处理 NaN 和其他边缘情况，请使用这个（虽然它更长）：

let sign=x=>isNaN(x)?NaN:2*(x>=0)-1
//Tests
console.log(sign(0)); //1
console.log(sign(6)); //1
console.log(sign(Infinity)); //1
console.log(sign(-6)); //-1
console.log(sign(-Infinity)); //-1
console.log(sign("foo")); //NaN

如果您希望 sign(0) 返回0 以及：

let sign=x=>isNaN(x)?NaN:(x?2*(x>=0)-1:0)
//Tests
console.log(sign(0)); //0
console.log(sign(6)); //1
console.log(sign(Infinity)); //1
console.log(sign(-6)); //-1
console.log(sign(-Infinity)); //-1
console.log(sign("foo")); //NaN