Number.sign () w javascript

Ciekawe, czy są jakieś nietrywialne sposoby znalezienia znaku liczby ( funkcja signum )?
Mogą być krótsze / szybsze / bardziej eleganckie rozwiązania niż oczywiste

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

Krótka odpowiedź!

Użyj tego, a będziesz bezpieczny i szybki (źródło: moz )

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

Możesz przyjrzeć się skrzypcom porównawczym wydajności i wymuszania typu

Minęło dużo czasu. Dalej jest głównie ze względów historycznych.

Wyniki

Na razie mamy takie rozwiązania:

1. Oczywiste i szybkie

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

1.1. Modyfikacja z kbec - jeden typ rzadziej rzucany, wydajniejszy , krótszy [najszybszy]

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

Uwaga: sign("0") -> 1

2. Eleganckie, krótkie, nie tak szybkie [najwolniejsze]

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

Ostrzeżenie: sign(+-Infinity) -> NaN ,sign("0") -> NaN

Jak Infinityna numer prawny w JS, to rozwiązanie nie wydaje się w pełni poprawne.

3. Sztuka ... ale bardzo wolno [najwolniej]

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

4. Używając szybkiego przesunięcia bitowego
, alesign(-Infinity) -> 0

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

5. Bezpieczne dla typów [megafast]

! Wygląda na to, że przeglądarki (zwłaszcza Chrome v8) dokonują magicznych optymalizacji i to rozwiązanie okazuje się znacznie wydajniejsze niż inne, nawet niż (1.1), mimo że zawiera 2 dodatkowe operacje i logicznie rzecz biorąc, nigdy nie może być szybsze.

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

Przybory

• testy wydajności jsperf ;
• skrzypce - testy typu cast;

Ulepszenia są mile widziane!

[Offtopic] Zaakceptowana odpowiedź

• Andrey Tarantsov - +100 za sztukę, ale niestety jest to około 5 razy wolniejsze niż oczywiste podejście

• Frédéric Hamidi - jakoś najbardziej chwalona odpowiedź (jak na razie piszę) i jest całkiem fajna, ale zdecydowanie nie tak należy to robić, imho. Ponadto nie obsługuje poprawnie liczb nieskończoności, które są również liczbami, wiesz.

• kbec - to ulepszenie oczywistego rozwiązania. Nie tak rewolucyjne, ale biorąc wszystko razem uważam to podejście za najlepsze. Zagłosuj na niego :)

Bardziej elegancka wersja szybkiego rozwiązania:

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

Dzielenie liczby przez jej wartość bezwzględną również daje jej znak. Korzystanie ze zwierającego operatora logicznego AND pozwala nam na specjalne wielkości, 0więc nie kończymy na dzieleniu przez to:

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

Funkcja, której szukasz, nazywa się signum , a najlepszym sposobem jej wdrożenia jest:

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

Czy to nie powinno obsługiwać zer podpisanych w JavaScript (ECMAScript)? Wydaje się, że działa przy zwracaniu x zamiast 0 w funkcji „megafast”:

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

To sprawia, że ​​jest kompatybilny z wersją roboczą Math.sign ( MDN ) ECMAScript :

Zwraca znak x, wskazując, czy x jest dodatnie, ujemne czy zerowe.

• Jeśli x jest NaN, wynikiem jest NaN.
• Jeśli x wynosi −0, wynikiem jest −0.
• Jeśli x wynosi +0, wynikiem jest +0.
• Jeśli x jest ujemne, a nie −0, wynikiem jest −1.
• Jeśli x jest dodatnie, a nie +0, wynikiem jest +1.

Dla osób, które są zainteresowane tym, co się dzieje z najnowszymi przeglądarkami, w wersji ES6 dostępna jest natywna metoda Math.sign . Wsparcie możesz sprawdzić tutaj .

W zasadzie to wraca -1, 1, 0lubNaN

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;

Superszybki, jeśli nie potrzebujesz Infinity i wiesz, że liczba jest liczbą całkowitą, znalezioną w źródle openjdk-7: java.lang.Integer.signum()

Pomyślałem, że dodam to dla zabawy:

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

0 i NaN zwróci -1
działa dobrze na +/- Nieskończoność

Rozwiązanie, które działa na wszystkich liczbach, a także 0i -0, a także Infinityi -Infinity, to:

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

Zobacz pytanie „ Czy +0 i -0 to to samo? ”, Aby uzyskać więcej informacji.

Ostrzeżenie: Żadna z tych odpowiedzi, w tym obecnie standardowym Math.signpraca będzie na razie 0vs -0. Może to nie stanowić problemu dla Ciebie, ale w niektórych implementacjach fizyki może to mieć znaczenie.

Możesz przesunąć nieco liczbę i sprawdzić najbardziej znaczący bit (MSB). Jeśli MSB jest 1, to liczba jest ujemna. Jeśli jest 0, to liczba jest dodatnia (lub 0).

Właśnie miałem zadać to samo pytanie, ale znalazłem rozwiązanie, zanim skończyłem pisać, zobaczyłem, że to pytanie już istnieje, ale nie widziałem tego rozwiązania.

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

wydaje się być szybszy po dodaniu trójskładnika (n >> 31) + (n>0?1:0)

Bardzo podobne do odpowiedzi Martijna

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

Uważam to za bardziej czytelne. Ponadto (lub, w zależności od twojego punktu widzenia, jednakże), określa również rzeczy, które można zinterpretować jako liczbę; np. wraca -1po wyświetleniu '-5'.

Nie widzę praktycznego sensu zwracania -0 i 0 z, Math.signwięc moja wersja to:

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

Metody, które znam, są następujące:

Math.sign (n)

var s = Math.sign(n)

Jest to funkcja natywna, ale jest najwolniejsza ze wszystkich ze względu na narzut wywołania funkcji. Obsługuje jednak „NaN”, gdzie pozostałe poniżej mogą po prostu przyjąć 0 (tj. Math.sign („abc”) to NaN).

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

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

W tym przypadku tylko lewa lub prawa strona może być 1 na podstawie znaku. Powoduje to 1-0(1), 0-1(-1) lub 0-0(0).

Szybkość tego wydaje się łeb w łeb z następną poniżej w Chrome.

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

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

Używa "przesunięcia w prawo propagującego znak". Zasadniczo przesunięcie o 31 zrzuca wszystkie bity z wyjątkiem znaku. Jeśli znak został ustawiony, daje to -1, w przeciwnym razie 0. Po prawej stronie |testuje wartość dodatnią, konwertując wartość na wartość logiczną (0 lub 1 [BTW: łańcuchy nienumeryczne, np.!!'abc' , stają się w tym przypadku 0 i not NaN]) następnie używa bitowej operacji OR do łączenia bitów.

Wydaje się, że jest to najlepsza średnia wydajność we wszystkich przeglądarkach (najlepsza przynajmniej w Chrome i Firefox), ale nie najszybsza we WSZYSTKICH z nich. Z jakiegoś powodu operator trójskładnikowy jest szybszy w IE.

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

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

Z jakiegoś powodu najszybsza w IE.

jsPerf

Wykonane testy: https://jsperf.com/get-sign-from-value

Moje dwa centy, z funkcją, która zwraca te same wyniki co Math.sign, tj. Sign (-0) -> -0, sign (-Infinity) -> -Infinity, sign (null) -> 0 , znak (nieokreślony) -> NaN itp.

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

Jsperf nie pozwala mi stworzyć testu ani wersji, przepraszam, że nie mogę dostarczyć Ci testów (wypróbowałem jsbench.github.io, ale wyniki wydają się być znacznie bliżej siebie niż w przypadku Jsperf ...)

Gdyby ktoś mógł dodać to do wersji Jsperf, byłbym ciekawy, jak wypada na tle wszystkich podanych wcześniej rozwiązań ...

Dziękuję Ci!

Jim.

EDYCJA :

Powinienem był napisać:

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

( (+x && -1)zamiast (x && -1)) w celu sign('abc')poprawnej obsługi (-> NaN)

Math.sign nie jest obsługiwany w IE 11. Łączę najlepszą odpowiedź z odpowiedzią Math.sign:

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

Teraz można bezpośrednio korzystać z Math.sign.