Number.sign () em javascript

Gostaria de saber se existem maneiras não triviais de encontrar o sinal de número ( função signum )?
Podem ser soluções mais curtas / rápidas / mais elegantes do que a óbvia

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

Resposta curta!

Use isso e você estará seguro e rápido (fonte: moz )

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

Você pode querer observar o desempenho e o violino de comparação de coerção de tipo

Muito tempo se passou. Além disso, é principalmente por razões históricas.

Resultados

Por enquanto, temos estas soluções:

1. Óbvio e rápido

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

1.1. Modificação de kbec - um tipo de elenco a menos, mais desempenho, mais curto [mais rápido]

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

Cuidado: sign("0") -> 1

2. Elegante, curto, não tão rápido [mais lento]

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

CUIDADO: sign(+-Infinity) -> NaN ,sign("0") -> NaN

Como Infinityé um número legal em JS, essa solução não parece totalmente correta.

3. A arte ... mas muito lenta [mais lenta]

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

4. Usando bit-shift
rápido, massign(-Infinity) -> 0

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

5. Tipo seguro [megafast]

! Parece que os navegadores (especialmente o Chrome v8) fazem algumas otimizações mágicas e esta solução acaba tendo muito mais desempenho do que outras, até mesmo do que (1.1), apesar de conter 2 operações extras e logicamente nunca pode ser mais rápida.

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

Ferramentas

• testes de desempenho jsperf ;
• violino - testes de tipo fundido;

Melhorias são bem-vindas!

[Offtopic] Resposta aceita

• Andrey Tarantsov - +100 para a arte, mas infelizmente é cerca de 5 vezes mais lento do que a abordagem óbvia

• Frédéric Hamidi - de alguma forma a resposta mais votada (por enquanto) e é bem legal, mas definitivamente não é como as coisas deveriam ser feitas, imho. Além disso, ele não lida corretamente com números do Infinity, que também são números, você sabe.

• kbec - é uma melhoria da solução óbvia. Não tão revolucionário, mas no conjunto considero esta abordagem a melhor. Vote nele :)

Versão mais elegante de solução rápida:

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

Dividir o número por seu valor absoluto também fornece seu sinal. Usar o operador AND lógico de curto-circuito nos permite criar casos especiais 0para não acabarmos nos dividindo por ele:

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

A função que você está procurando é chamada signum , e a melhor maneira de implementá-la é:

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

Isso não deveria suportar zeros assinados de JavaScript (ECMAScript)? Parece funcionar ao retornar x em vez de 0 na função “megafast”:

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

Isso o torna compatível com um rascunho do Math.sign ( MDN ) do ECMAScript :

Retorna o sinal de x, indicando se x é positivo, negativo ou zero.

• Se x for NaN, o resultado será NaN.
• Se x for −0, o resultado será −0.
• Se x for +0, o resultado será +0.
• Se x for negativo e não −0, o resultado será −1.
• Se x for positivo e não +0, o resultado será +1.

Para quem está interessado no que está acontecendo com os navegadores mais recentes, na versão ES6 existe um método nativo Math.sign . Você pode verificar o suporte aqui .

Basicamente ele retorna -1, 1, 0ouNaN

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

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

Super rápido se você não precisa do Infinity e sabe que o número é um inteiro, encontrado na fonte openjdk-7: java.lang.Integer.signum()

Pensei em adicionar isto apenas por diversão:

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

0 e NaN retornará -1
funciona bem em +/- Infinity

Uma solução que funciona em todos os números, bem como 0e -0, bem como Infinitye -Infinity, é:

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

Consulte a pergunta " +0 e -0 são iguais? " Para obter mais informações.

Aviso: Nenhuma dessas respostas, incluindo o agora padrão Math.signtrabalho vontade sobre o caso 0vs -0. Isso pode não ser um problema para você, mas em certas implementações de física pode ser importante.

Você pode alterar o número de bits e verificar o bit mais significativo (MSB). Se o MSB for 1, o número é negativo. Se for 0, o número é positivo (ou 0).

Eu estava prestes a fazer a mesma pergunta, mas cheguei a uma solução antes de terminar de escrever, vi que essa pergunta já existia, mas não vi essa solução.

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

parece ser mais rápido adicionando um embora ternário (n >> 31) + (n>0?1:0)

Muito semelhante à resposta de Martijn é

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

Acho mais legível. Além disso (ou, dependendo do seu ponto de vista, no entanto), também groca coisas que podem ser interpretadas como um número; por exemplo, ele retorna -1quando apresentado com '-5'.

Não vejo nenhum sentido prático de retornar -0 e 0, Math.signentão minha versão é:

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

Os métodos que conheço são os seguintes:

Math.sign (n)

var s = Math.sign(n)

Esta é a função nativa, mas é a mais lenta de todas devido à sobrecarga de uma chamada de função. No entanto, ele lida com 'NaN', onde os outros abaixo podem apenas assumir 0 (ou seja, Math.sign ('abc') é NaN).

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

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

Neste caso, apenas o lado esquerdo ou direito pode ser 1 com base no sinal. Isso resulta em 1-0(1), 0-1(-1) ou0-0 (0).

A velocidade deste parece pescoço a pescoço com o próximo abaixo no Chrome.

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

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

Usa o "deslocamento para a direita de propagação de sinal". Basicamente, deslocar em 31 elimina todos os bits, exceto o sinal. Se o sinal foi definido, isso resulta em -1, caso contrário, é 0. À direita |dele testa positivo ao converter o valor em booleano (0 ou 1 [BTW: strings não numéricas, como!!'abc' , tornam-se 0 neste caso, e not NaN]) então usa uma operação OR bit a bit para combinar os bits.

Este parece ser o melhor desempenho médio entre os navegadores (melhor no Chrome e Firefox, pelo menos), mas não o mais rápido em TODOS eles. Por algum motivo, o operador ternário é mais rápido no IE.

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

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

Mais rápido no IE por algum motivo.

jsPerf

Testes realizados: https://jsperf.com/get-sign-from-value

Meus dois centavos, com uma função que retorna os mesmos resultados que Math.sign faria, ou seja, sinal (-0) -> -0, sinal (-Infinito) -> -Infinito, sinal (nulo) -> 0 , sinal (indefinido) -> NaN, etc.

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

Jsperf não me deixa criar um teste ou revisão, desculpe por não ser capaz de fornecer testes (eu tentei jsbench.github.io, mas os resultados parecem muito mais próximos uns dos outros do que com Jsperf ...)

Se alguém pudesse adicioná-lo a uma revisão Jsperf, eu ficaria curioso para ver como ele se compara a todas as soluções fornecidas anteriormente ...

Obrigado!

Jim.

EDITAR :

Eu deveria ter escrito:

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

(em (+x && -1)vez de (x && -1)) a fim de lidar sign('abc')corretamente (-> NaN)

Math.sign não é compatível com o IE 11. Estou combinando a melhor resposta com Math.sign:

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

Agora, pode-se usar o Math.sign diretamente.