JavaScript% (Modulo) liefert ein negatives Ergebnis für negative Zahlen

Laut Google Calculator (-13) % 64 ist 51.

Laut Javascript (siehe diese JSBin ) ist es -13.

Wie behebe ich das?

Number.prototype.mod = function(n) {
    return ((this%n)+n)%n;
};

Entnommen aus diesem Artikel: Der JavaScript Modulo Bug

Die Verwendung Number.prototypeist LANGSAM, da Ihre Nummer jedes Mal, wenn Sie die Prototypmethode verwenden, in eine eingeschlossen wird Object. An Stelle von:

Number.prototype.mod = function(n) {
  return ((this % n) + n) % n;
}

Verwenden:

function mod(n, m) {
  return ((n % m) + m) % m;
}

Siehe: http://jsperf.com/negative-modulo/2

~ 97% schneller als bei Verwendung eines Prototyps. Wenn Leistung für Sie natürlich wichtig ist ..

Der %Operator in JavaScript ist der Restoperator, nicht der Modulo-Operator (der Hauptunterschied besteht darin, wie negative Zahlen behandelt werden):

-1 % 8 // -1, not 7

Eine "Mod" -Funktion, um ein positives Ergebnis zurückzugeben.

var mod = function (n, m) {
    var remain = n % m;
    return Math.floor(remain >= 0 ? remain : remain + m);
};
mod(5,22)   // 5
mod(25,22)  // 3
mod(-1,22)  // 21
mod(-2,22)  // 20
mod(0,22)   // 0
mod(-1,22)  // 21
mod(-21,22) // 1

Und natürlich

mod(-13,64) // 51

Die akzeptierte Antwort macht mich etwas nervös, weil sie den% -Operator wiederverwendet. Was ist, wenn Javascript das Verhalten in Zukunft ändert?

Hier ist eine Problemumgehung, bei der% nicht wiederverwendet wird:

function mod(a, n) {
    return a - (n * Math.floor(a/n));
}

mod(1,64); // 1
mod(63,64); // 63
mod(64,64); // 0
mod(65,64); // 1
mod(0,64); // 0
mod(-1,64); // 63
mod(-13,64); // 51
mod(-63,64); // 1
mod(-64,64); // 0
mod(-65,64); // 63

Obwohl es sich nicht wie erwartet verhält, bedeutet dies nicht, dass sich JavaScript nicht "verhält". Es ist ein JavaScript, das für die Modulo-Berechnung ausgewählt wurde. Denn per Definition macht jede Antwort Sinn.

Siehe dies aus Wikipedia. Sie können rechts sehen, wie verschiedene Sprachen das Vorzeichen des Ergebnisses ausgewählt haben.

Wenn xes sich um eine Ganzzahl und eine Zweierpotenz nhandelt, können Sie x & (n - 1)anstelle von verwenden x % n.

> -13 & (64 - 1)
51 

Wenn Sie also versuchen, um Grad zu modifizieren (wenn Sie also -50 Grad - 200 Grad haben), möchten Sie Folgendes verwenden:

function modrad(m) {
    return ((((180+m) % 360) + 360) % 360)-180;
}

Ich beschäftige mich auch mit negativem a und negativem n

 //best perf, hard to read
   function modul3(a,n){
        r = a/n | 0 ;
        if(a < 0){ 
            r += n < 0 ? 1 : -1
        }
        return a - n * r 
    }
    // shorter code
    function modul(a,n){
        return  a%n + (a < 0 && Math.abs(n)); 
    }

    //beetween perf and small code
    function modul(a,n){
        return a - n * Math[n > 0 ? 'floor' : 'ceil'](a/n); 
    }

Dies ist kein Fehler, es gibt 3 Funktionen zur Berechnung von Modulo. Sie können diejenige verwenden, die Ihren Anforderungen entspricht (ich würde empfehlen, die euklidische Funktion zu verwenden).

Abschneiden der Dezimalteilfunktion

console.log(  41 %  7 ); //  6
console.log( -41 %  7 ); // -6
console.log( -41 % -7 ); // -6
console.log(  41 % -7 ); //  6

Ganzzahlige Teilfunktion

Number.prototype.mod = function(n) {
    return ((this%n)+n)%n;
};

console.log( parseInt( 41).mod( 7) ); //  6
console.log( parseInt(-41).mod( 7) ); //  1
console.log( parseInt(-41).mod(-7) ); // -6
console.log( parseInt( 41).mod(-7) ); // -1

Euklidische Funktion

Number.prototype.mod = function(n) {
    var m = ((this%n)+n)%n;
    return m < 0 ? m + Math.abs(n) : m;
};

console.log( parseInt( 41).mod( 7) ); // 6
console.log( parseInt(-41).mod( 7) ); // 1
console.log( parseInt(-41).mod(-7) ); // 1
console.log( parseInt( 41).mod(-7) ); // 6

Es gibt ein NPM-Paket, das die Arbeit für Sie erledigt. Sie können es mit dem folgenden Befehl installieren.

npm install just-modulo --save

Verwendung aus der README-Datei kopiert

import modulo from 'just-modulo';

modulo(7, 5); // 2
modulo(17, 23); // 17
modulo(16.2, 3.8); // 17
modulo(5.8, 3.4); //2.4
modulo(4, 0); // 4
modulo(-7, 5); // 3
modulo(-2, 15); // 13
modulo(-5.8, 3.4); // 1
modulo(12, -1); // NaN
modulo(-3, -8); // NaN
modulo(12, 'apple'); // NaN
modulo('bee', 9); // NaN
modulo(null, undefined); // NaN

Das GitHub-Repository finden Sie über den folgenden Link:

https://github.com/angus-c/just/tree/master/packages/number-modulo