JavaScript, % (modulo) donne un résultat négatif pour les nombres négatifs

Selon Google Calculatrice (-13) % 64 est 51.

Selon Javascript (voir ce JSBin) il est -13.

Comment puis-je résoudre ce problème?

Cela peut juste être une question de priorité. Voulez-vous dire (-13) % 64 ou -(13 % 64)? Personnellement, je l'avais mis dans les parens de toute façon, juste pour plus de clarté.
édité, merci.
essentiellement une copie de Comment java module de calculs avec des nombres négatifs? même si c'est un javascript question.
Javascript se sent parfois comme une plaisanterie cruelle
google ne peut pas être mauvais
Le problème fondamental est en JS % n'est pas l'opérateur modulo. C'est le reste de l'opérateur. Il n'y a pas d'opérateur modulo en JavaScript. Si l'on a accepté la réponse est le chemin à parcourir.
Lequel avez-vous l'intention de corriger, Google ou JS?

InformationsquelleAutor Alec Gorge | 2010-12-17

227
```
Number.prototype.mod = function(n) {
    return ((this%n)+n)%n;
};
```
Prises à partir de cet article: Le JavaScript Modulo Bug
- Je ne sais pas si je dirais que c'est un "bug". Le modulo n'est pas très bien définies sur les nombres négatifs, et les différents environnements informatiques de gérer la situation différemment. L'article de Wikipedia sur la modulo couvre assez bien.
- Il peut sembler idiot, car il est souvent appelé "modulo", suggérant qu'il aurait le même comportement que ses mathématiques définition (voir ℤ/nℤ algèbre), ce qui n'est pas.
- Pourquoi prendre le modulo avant l'ajout de n? Pourquoi ne pas simplement ajouter n et ensuite prendre le modulo?
- si vous n'utilisez pas cette%n il ne pourrait pas pour x < -n - par exemple (-7 + 5) % 5 === -2 mais ((-7 % 5) + 5) % 5 == 3.
- Théorie intéressante, mais Number.prototype.mod n'a pas d'effet dans les navigateurs modernes - au moins Firefox 28, Chrome 32.
- Il fonctionne parfaitement pour moi dans Firefox 28 et Chrome 34. (Pourquoi pas?)
- Il n'est jamais défini par défaut, Firefox ou Chrome, pour moi la seule façon de l'utiliser, si vous définir le Nombre.le prototype.mod, et l'appeler comme Nombre.le prototype.mod. Voir: i.imgur.com/nU4kUIX.png
- Personne n'a dit qu'il a été défini par défaut. Le code de cette réponse, c'est ce qui la définit. L'exécution de ce code, vous pouvez alors dire (-13).mod(64) et obtenir 51. jsfiddle.net/63KyC
- Je vois, à partir de cet affichage, je implicite que .mod a remplacé l' % mod comportement - si oui, la fonction serait originaire d'abord la méthode. Donc, cette méthode serait pas différent que de le faire Number.prototype.myfunction = ...
- Je recommande d'ajouter à la réponse que pour accéder à cette fonction, il faut utiliser le format (-13).mod(10) au lieu de -13 % 10. Il serait plus clair.
- JavaScript calcule le reste qui est différent de modulo
- Cette volonté de dépassement pour un très grand n (désolé, trop de temps de travail avec l'Ethereum)
- Dans §20.3.1.13 MakeDay les modulo opération spécifiée se comporte comme pour les mathématiques sens, par exemple, -1 modulo 12 est de 11, mais -1 % 12 est -1. Elle est tout à fait explicite dans ce §5.2 Algorithme de Conventions où il est dit: "La notation “x modulo y” (y doit être finie et différente de zéro) calcule une valeur k de même signe que y (ou zéro) tels que abs(k) < abs(y) et x-k = q × y pour certaines entier q.", ce qui n'est pas la façon dont le % opérateur fonctionne.
- Notez également que % est maintenant appelé un MultiplicativeOperator et à l'est par rapport au C et C++ reste de l'opérateur.
- Le lien que vous avez fourni semble être mort
- est incorrect. En mathématiques, il est certainement vrai que, par exemple -1 % 12 = -1. C'est parce que dans le mod 12 algèbre, -1 = 11. Ils sont distincts des symboles se référant à la même classe d'équivalence.
InformationsquelleAutor Enrique
130

À l'aide de Number.prototype est LENT, parce que chaque fois que vous utilisez la méthode de prototype de votre numéro est enveloppé dans un Object. Au lieu de cela:
```
Number.prototype.mod = function(n) {
  return ((this % n) + n) % n;
}
```
Utilisation:
```
function mod(n, m) {
  return ((n % m) + m) % m;
}
```
Voir: http://jsperf.com/negative-modulo/2

~97% plus rapide que l'utilisation d'un prototype. Si la performance est importante pour vous, bien sûr..
- Bon conseil. J'ai pris votre jsperf et comparé avec le reste de la solutions à cette question (mais il semble que c'est le meilleur de toute façon): jsperf.com/negative-modulo/3
- Micro-optimisation. Vous auriez à faire un massif quantité de mod calculs de ce fait aucune différence que ce soit. Code ce qui est plus clair et plus facile à gérer, alors d'optimiser suite à l'analyse des performances.
- Je pense que vous avez votre ns et ms dans le mauvais sens dans votre deuxième exemple @StuR . Il devrait être return ((n % m) + m) % m;.
- Cela devrait être un commentaire pour la accepté de réponse, pas de réponse pour lui-même.
- La motivation est indiqué dans cette réponse, c'est une micro-optimisation, oui, mais de modifier le prototype est problématique. Préférez l'approche, avec le moins d'effets secondaires, qui est celui-ci.
InformationsquelleAutor StuR
25

La % opérateur en JavaScript est le reste de l'opérateur, et non pas l'opérateur modulo (la principale différence est dans la façon dont les nombres négatifs sont traités):

-1 % 8 // -1, not 7
- doit être appelé le reste de l'opérateur, mais il est, appelé opérateur de modulo: developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/...
- MDN n'est pas une langue officielle de référence, c'est une communauté édité par site qui, parfois, s'il se trompe. Le spec ne pas appeler ça un opérateur modulo, et aussi loin que je peux dire il n'a jamais (je suis retourné à l'ES3). Il dit explicitement que l'opérateur donne le reste de l'implicite de la division, et juste il appelle "l'opérateur%."
InformationsquelleAutor Rob Sobers
14

Un "mod" de la fonction pour retourner un résultat positif.
```
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
```
Et bien sûr
```
mod(-13,64) //51
```
- MDN n'est pas une langue officielle de référence, c'est une communauté édité par site qui, parfois, s'il se trompe. Le spec ne pas appeler ça un opérateur modulo, et aussi loin que je peux dire il n'a jamais (je suis retourné à l'ES3). Il dit explicitement que l'opérateur donne le reste de l'implicite de la division, et juste il appelle "l'opérateur%."
- Oups, le lien que vous avez spécifié en fait des références #sec-applying-the-mod-operator dans l'url 🙂 bref, merci pour la remarque, j'ai pris les peluches de ma réponse, ce n'est pas vraiment important de toute façon.
- Shanimal: LOL! Il n'. Une erreur de l'éditeur HTML. La spécification de texte ne fonctionne pas.
InformationsquelleAutor Shanimal
9

Accepté la réponse me rend un peu nerveux, parce qu'il ré-utilise l'opérateur%. Si Javascript modifie le comportement dans le futur?

Voici une solution de contournement qui n'a pas ré-utiliser %:
```
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
```
- Si javascript changé l'opérateur modulo pour correspondre à la définition mathématique, de la accepté de répondre fonctionne encore.
- "Ce que si Javascript modifie le comportement dans le futur?" - Pourquoi serait-il? Changer le comportement d'un tel fondamentaux de l'opérateur n'est pas probable.
- +1 pour le partage de cette préoccupation-de & alternative à la réponse #réponse-4467559 &pour 4 raisons: (1) Pourquoi les états,& oui“Changer le comportement d'un tel fondamentaux de l'op n'est pas probable”, mais tout de même plus prudent de considérer encore à trouver, il n'est pas nécessaire. (2) la définition de travail de l'op en termes de rupture de l'un, tout en impressionnant, est worrysome au moins le 1er look, à l'est doit être til pas (3) quoique je hvnt bien vérifié que cette alternative, je trouve easer pour suivre sur quick look. (4)minuscule: il utilise 1 div+1 mul au lieu de 2 (mod) divs& j'ai entendu BEAUCOUP plus tôt matériel w/o une bonne FPU,la multiplication a été plus rapide.
- il n'est pas prudent, il ne sert à rien. Si ils étaient à modifier le comportement du reste de l'opérateur, elle allait se briser une bonne gamme de programmes l'utilisant. Qui ne va jamais arriver.
- Que faire si le comportement de -, *, /, ;, ., (, ), ,, Math.floor, function ou return changements? Ensuite, votre code est horriblement cassé.
- que faire si le comportement du moins les changements d'opérateur? 🙂
InformationsquelleAutor wisbucky
8

JavaScript Modulo

Mise en œuvre réussie d'un calcul scientifique ou de l'algorithme est possible non seulement de comprendre les caractéristiques d'un langage ou d'un cadre, mais propose également de comprendre les limites.

Ordinateurs sont précis instruments scientifiques, mais ils travaillent-ils par la manipulation d'entités dans de petits espaces (vous avez un nombre limité de pixels sur l'écran, il y a un nombre limité de bits qui sont derrière chaque numéro, etc.)

Essayer d'ignorer les limites ou le cadre des spécifications et bientôt vous verrez que vous avez une différence d'impédance entre votre formule mathématique et le code que vous essayez d'écrire.

Opérateur Modulo

Parfois, les situations sont compliquées par faussement annoncé ou entendu cadre des fonctions ou opérateurs. Cet article se concentre sur l'opérateur modulo.

Demandez à n'importe quel C# ou JavaScript programmeur quel est l'opérateur modulo dans leur langue et il ya une grande chance qu'ils vont allé réponse: % (par exemple, le signe de pourcentage). L'abondance de la documentation, reportez-vous à la % à l'inscription en tant que opérateur modulo.

Wow! C'est une subtile, mais très dangereuse erreur. En C# et JavaScript opérateur % est actuellement utilisé pour calculer le reste (avec signe) qui reste lorsque l'un des opérandes est divisé par le deuxième opérande. Par conséquent, l'opérande doit être correctement appelé signé le reste de l'opérateur.

À première vue, l'signé le reste de l'opérateur fonctionne de manière similaire à l'opérateur modulo. Nous allons faire quelques tests en comparant les résultats retournés par JavaScript avec ceux retournés par Google.

Dans Chrome, ouvrez la console (appuyez sur la touche F12 et sélectionnez l'onglet de la Console). Type de il y, un par un, les calculs à partir de la colonne de gauche. Tapez ensuite les mêmes expressions dans la barre de recherche de Google. Notez les résultats. Ils devraient être les mêmes.
```
                JavaScript  Google
    5 % 3       2           2
    26 % 26     0           0
    15 % 12     3           3
```
Nous allons maintenant essayer d'utiliser une valeur négative comme le premier opérande:

Surprise!

-5 % 3 = 1 (selon Google)
-5 % 3 = -2 (selon JavaScript)

Bien ... cela ne devrait pas réellement une surprise si l'on regarde la définition de l'opérateur % en JavaScript (... ou encore C# ou de nombreuses autres langues). Google calcule le vrai modulo, bien que ces langages de calculer un signé de rappel.

Cependant, pas tous les langages de programmation /cadres ont la même mise en œuvre de %. En Python, par exemple, l'opérateur % calcule le vrai modulo de la même manière que Google.

Cette différence de comportement entre les langues peuvent introduire un subtil des erreurs dans votre calcul, surtout si vous essayez de port d'un algorithme à partir d'une langue à l'autre!

Un problème compris, c'est un problème à moitié résolu

Supposons que nous avons besoin pour mettre en œuvre une (scientifique) de calcul en JavaScript en utilisant l'arithmétique modulo.

Puisque nous comprenons maintenant que JavaScript n'est pas un vrai opérateur modulo, nous pouvons facilement mettre en œuvre notre modulo comme une fonction.

Il y a de multiples façons de mettre en œuvre modulo en JavaScript. Je vais vous montrer 3 façons de le faire.
```
//Implement modulo by replacing the negative operand 
//with an equivalent positive operand that has the same wrap-around effect
function mod(n, p)
{
    if ( n < 0 )
        n = p - Math.abs(n) % p;

    return n % p;
}

//Implement modulo by relying on the fact that the negative remainder
//is always p numbers away from a positive reminder
//Ex: -5 % 3 | -5 = -2 * 3 + 1 and -5 = -1 * 3 + (-2) | -2 + 3 = 1  
function mod(n, p)
{
    var r = n % p;

    return r < 0 ? r + p : r;
}

//Implement modulo by solving n = v * p + r equation  
function mod(n, p) 
{
    return n - p * Math.floor( n / p );
}
```
Plus précis sur les outils à notre disposition, nous sommes maintenant prêts à s'attaquer à ce (scientifique) de calcul et de s'attendre à obtenir de bons résultats à chaque fois.

Remarque: Il y a beaucoup de calculs qui font usage de l'arithmétique modulo... Si vous voulez voir comment utiliser ces nouvelles modulo les fonctions dans la mise en œuvre d'un César de Chiffrement /ROT13 code, vous pouvez vérifier ce l'article.

InformationsquelleAutor Marian Veteanu
3

Si elle n'est pas se comporter comme prévu, cela ne signifie pas que le JavaScript n'est pas 'comportement'. C'est un choix JavaScript pour son calcul modulo. Parce que, par définition, soit de répondre de sens.

Voir cette à partir de Wikipedia. Vous pouvez voir sur la droite comment les différentes langues ont choisi le résultat du signe.

InformationsquelleAutor dheerosaur
3

Si x est un entier et n est une puissance de 2, vous pouvez utiliser x & (n - 1) au lieu de x % n.
```
> -13 & (64 - 1)
51 
```
InformationsquelleAutor quasimodo
2

Il semble donc que si vous essayez de mod autour de degrés (de sorte que si vous avez -50 degrés - 200 degrés), vous voulez utiliser quelque chose comme:
```
function modrad(m) {
    return ((((180+m) % 360) + 360) % 360)-180;
}
```
InformationsquelleAutor JayCrossler

Je traite avec un négatif et négatif n trop

 //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); 
    }

InformationsquelleAutor bormat

1

Ce n'est pas un bug, il y a 3 fonctions pour calculer modulo, vous pouvez utiliser l'une qui conviennent à vos besoins (je vous recommande d'utiliser Euclidienne de fonction)

Tronquant la partie décimale de la fonction
```
console.log(  41 %  7 ); // 6
console.log( -41 %  7 ); //-6
console.log( -41 % -7 ); //-6
console.log(  41 % -7 ); // 6
```
Partie entière de la fonction
```
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
```
Euclidienne fonction
```
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
```
- Dans la fonction de vérification de la m < 0 est inutile parce que ((ce%n)+n)%n est toujours positif
- Oui, il est, mais en Javascript % peut retourner des résultats négatifs (ce qui est le but de ces fonctions, régler le problème)
- vous avez écrit ceci [code] Nombre.le prototype.mod = function(n) { var m = ((ce%n)+n)%n; return m < 0 ? m + Mathématiques.abs(n) : m; }; [/code] donne-moi une valeur de n où m est négative. ils sont pas de la valeur de n, où m est négative, car vous ajoutez de n après la première % .
- Sans cette vérification, parseInt(-41).mod(-7) serait de retour -6 au lieu de 1 (et c'est exactement le but de la partie entière de la fonction que j'ai écrit)
- ha ok, tu as raison, toutes mes excuses, j'ai oublié négatif modulo, je ne faisais que penser à la "ce" négatif. Puis-je suggérer à déplacer les Mathématiques.abs Nombre.le prototype.mod = function(n) { return ((ce%n)+ Math.abs(n))%n; }; (-41).mod(-7) == 1 //pas besoin parseInt
- Vous pouvez simplifier votre fonction en supprimant la deuxième modulo Nombre.le prototype.mod = function(n) { var m = ce%n; return (m < 0) ? m + Mathématiques.abs(n) : m; };
InformationsquelleAutor zessx

Il y a un MNP paquet qui va faire le travail pour vous. Vous pouvez l'installer avec la commande suivante.

npm install just-modulo --save

Utilisation copié à partir du fichier README

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

GitHub peut être trouvé via le lien suivant:

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

InformationsquelleAutor maartenpaauw

Vous devez vous connecter pour publier un commentaire.

JavaScript Modulo

Opérateur Modulo

Un problème compris, c'est un problème à moitié résolu

Tronquant la partie décimale de la fonction

Partie entière de la fonction

Euclidienne fonction