Division entière avec reste en JavaScript?

En JavaScript, comment puis-je obtenir:

  1. le nombre entier de fois un nombre entier donné va dans une autre?
  2. le reste?
InformationsquelleAutor Yarin | 2010-11-19
  1. 1079

    Pour un certain nombre y et certains diviseur x calculer le quotient (quotient) et le reste (remainder) comme:

    var quotient = Math.floor(y/x);
var remainder = y % x;
    • % fonctionne sur des flotteurs en JavaScript (ce qui diffère de beaucoup d'autres langues), ce qui est peut-être pas désiré: 3.5 % 2 évalue à 1,5. Assurez-vous de la poignée (parseInt, plancher, etc.) comme l'exige
    • La partie intégrante de -4.5 en mathématiques est -5, comme -5 est "la plus haute possible nombre entier qui est toujours inférieur à celui des -4.5".
    • Cependant, quelle que soit vous décidez de le faire sur les nombres négatifs, elle doit être cohérente à travers le quotient et le reste. À l'aide de floor et % ensemble n'est pas cohérent dans ce sens. Soit utiliser trunc au lieu de floor (ce qui permet de négatif restes) ou d'utiliser la soustraction pour obtenir le reste (rem = y - div * x).
    • l'utilisation de Math.floor() ici, c'est juste pour le cas que nombre donné sont positifs. regardez ce pour plus d'explication. Normalement parseInt() est mieux de choisir d'obtenir la partie entière d'un nombre ou une chaîne.
    • 1. Si vous allez calculer le reste rem de toute façon, vous pouvez obtenir le quotient div plus vite, sans plancher: (y - rem) / x. 2. Par la façon dont le modulo par Donald Knuth est recommandé définition (signe-correspond-diviseur, pas le reste, c'est à dire Euclidienne module, ni le JavaScript signe-correspond-dividende) est ce que l'on peut coder en JavaScript comme function mod (a, n) { return a % n + (Math.sign(a) !== Math.sign(n) ? n : 0); }.
    • Toughy: compte tenu de la description dans la question, je ne comprends pas comment 2 pourrait aller jusqu'à un total de -9 -5 fois. Pourriez-vous expliquer?
    • -9 / 2 = -4.5. Vous prenez alors le sol de -4.5, qui est de 5. Rappelez-vous que -5 est moins de -4.5, et le sol est définie comme le plus grand entier inférieur à une valeur donnée.
    • Notez qu'en général, ayant à 3 modulo 5 2 est au lieu de -3 est peut-être surprenant, mais c'est mathématiquement plus utile, car il permet d'éviter toute discontinuité autour de 0; tous les entiers modulo un nombre positif n est toujours dans la plage [0,n-1], si l'entier de départ est positif ou négatif. Mais pour aller avec ce que la définition et de garder l'identité quotient * divisor + remainder = dividend vrai, le quotient est à l'étage.
    • Voir Wikipédia pour plus de détails sur les trois types de modulo (et de la division entière).
    • Attention, cela ne fonctionne pas sur nombre négatif parce que -9 % 2 est -1 au lieu de 1.

    InformationsquelleAutor Mark Elliot
  2. 344

    Je ne suis pas expert dans les opérateurs au niveau du bit, mais voici une autre façon d'obtenir le nombre entier:

    var num = ~~(a / b);

    Cela fonctionne correctement pour les nombres négatifs, tandis que Math.floor() rond dans la mauvaise direction.

    Cela semble correct ainsi:

    var num = (a / b) >> 0;
    • Un autre, dont le but, j'ai juste passé les 20 dernières minutes à essayer de comprendre, est apparemment a/b | 0
    • Les opérations bit à bit n'a de sens que sur des entiers types et JS (bien sûr) le sait. ~~int, int | 0 et int >> 0 ne pas modifier argument initial, mais assurez-interprète pass partie intégrante de l'opérateur.
    • Juste au cas où quelqu'un me demandais ce qui était le plus rapide: jsperf.com/integer-division-math-floor-a-b-vs-a-b (Spoiler résultats semble pas concluant).
    • floor à peine tours dans la mauvaise direction, compte tenu de son nom tout simplement pas le sens que les gens veulent généralement bien!
    • C'est un buu buu. a = 12447132275286670000; b = 128 Math.floor(a/b) -> 97243220900677100 et ~~(a/b) -> -1231452688.
    • Soyez prudent avec la priorité. ~~(5/2) --> 2 comme (5/2)>>0 --> 2, mais ~~(5/2) + 1 --> 3, tandis que ~~(5/2)>>0 + 1 --> 1. ~~ est un bon choix parce que la priorité est plus approprié.
    • le comportement indésirable de >>0 est pourquoi emscripten et asm.js utilisation |0
    • juste pour clarifier - ce réellement le travail parce qu'ils sont non-ops et tous les js opérations bit à bit convertir à 32 bits ints
    • D'accord avec Jonny Leeds. En effet, alors que cette solution mérite d'être mentionné, je ne le rejette comme étant la meilleure pratique de codage. La réponse de Mark Elliot utilise une fonction qui est prévue à cet effet. Cette réponse repose sur un comportement qui n'est ni garanti par la mise en œuvre des opérations bit à bit.
    • Les réponses sont buubuus ~~( 2147483648/1) = -2147483648 (2147483648/1) >> 0 = -2147483648
    • grande dans un contexte où vous n'avez pas de bibliothèque de Mathématiques ( dans mon cas, dans les modèles )
    • Cette réponse œuvres pour les nombres qui correspondent à l'intérieur de la portée d'un entier signé, que le Javascript n'utilise le moins significatif de 32 bits pour les opérations bit à bit. Cependant, l'OP posées sur les opérations sur entiers et les services de renseignements sont en fait 32 bits des nombres signés dans la plupart des langues (JS n'a pas ints) donc je pense que c'est pas un problème. Oui ce sera un échec pour un très grand nombre, mais il en sera de Math.floor lorsque les numéros d'aller au-delà de 53 bits... C'est juste les limites inhérentes à présent partout dans l'endroit. Si vous voulez faire cela pour arbitrairement grand nombre, vous avez besoin de quelques bigint / bignumber de la bibliothèque.
    • Je ne dirais pas que Math.floor tours, le négatif quotient dans le mal, mais plutôt dans un différentes direction. Math.floor(-3 / 10) === -1 serait alors correspondent à parqueté division (tours "vers le bas"), alors que ~~(-3 / 10) === 0 correspond à tronquée de la division (tours "vers zéro"). Voir Wiki: Modulo.
    • Il s'agit essentiellement d'obfuscation du code. Ne fais pas ça pour faire le malin, l'utilisation la plus longue mais plus lisible Math.floor ou la nouvelle Math.trunc de ES6 Edge (12+)
    • La plupart des développeurs déjà acceptez l'utilisation de | 0 à tronquer, en particulier en raison de son utilisation dans asm.js, de sorte que vous ne pouvez pas vraiment dire qu'il code le code, parce que son sens est déjà largement connu.
    • Je commentais sur la réponse et qui ne fait pas mention de |0. Aussi, il est sans importance que asm.js utilise un style spécifique, car il n'est pas censé être écrit/lu par des humains, mais par transpilers et navigateurs
    • Idk. Ternaires l'air bizarre la première fois que vous les voyez eux. Null conditionnelles aussi l'air vraiment bizarre au premier abord. Personne ne dit de ne pas les utiliser parce qu'ils semblent intelligents; au lieu de cela, ils sont de nouveaux lang ajouts que les devs sont censés apprendre. Si ~~ ou | 0 n'a pas déjà utilement existe pas, quelqu'un pourrait avoir été tenté d'ajouter. Comme Joel a dit, "Ancien code ne rouille pas". N'employez pas utile conventions existantes, tout simplement parce qu'ils sont vieux. C'est Une Bonne idée.
    • Est-il un développeur contexte autour du terme buu buu que je ne suis pas au courant? Je suppose que nous ne parlons pas de la Dragonball Z de compétences ou de les enfants la ligne de vêtements?
    • Sérieusement ne pas le faire. C'est illisible hack.

    InformationsquelleAutor user113716
  3. 182

    J'ai fait quelques tests de vitesse sur Firefox.

    -100/3             //-33.33..., 0.3663 millisec
Math.floor(-100/3) //-34,       0.5016 millisec
~~(-100/3)         //-33,       0.3619 millisec
(-100/3>>0)        //-33,       0.3632 millisec
(-100/3|0)         //-33,       0.3856 millisec
(-100-(-100%3))/3  //-33,       0.3591 millisec

/* a=-100, b=3 */
a/b                //-33.33..., 0.4863 millisec
Math.floor(a/b)    //-34,       0.6019 millisec
~~(a/b)            //-33,       0.5148 millisec
(a/b>>0)           //-33,       0.5048 millisec
(a/b|0)            //-33,       0.5078 millisec
(a-(a%b))/b        //-33,       0.6649 millisec

    Ci-dessus est basé sur les 10 millions d'essais pour chaque.

    Conclusion: Utilisation (a/b>>0) (ou (~~(a/b)) ou (a/b|0)) pour atteindre environ 20% de gain d'efficacité. Aussi garder à l'esprit qu'ils sont tous incompatibles avec Math.floor, quand a/b<0 && a%b!=0.

    • Je trouve les Maths.floor() a des performances plus stables que d'autres. il est moins haut et en bas
    • Voici un joli ensemble de cas de test: jsperf.com/whole-integer-division
    • Notez que l'optimisation de la division entière de vitesse n'a de sens que si vous le faites à beaucoup. Dans tous les autres cas, je voudrais vous recommandons de choisir la plus simple (selon ce qui semble le plus simple pour vous et vos collègues de travail).
    • tout à fait d'accord - il y a bien trop d'accent sur des trucs comme ça en ligne
    • Mais ce qui est plus difficile: apprendre Math.floor et qui-sait-comment-et de nombreuses autres fonctions de l'API ou de l'apprentissage, ~ (au niveau du bit-non) de l'opérateur et de la façon dont les opérations bit à bit de travail en JS et ensuite comprendre l'effet de la double tilde?
    • Eh bien, si vos collègues ne sont pas de la programmation des puces dans l'assembleur, ils vont probablement comprendre Math.floor mieux. Et même si non, c'est googleable.
    • | 0: 2582.521 ms ~~: 2631.974 ms Mathématiques.étage: 2382.893 mme. Je voudrais vous encourager à exécuter les tests vous-même, plnkr.co/modifier/9g0IXjpavR2t2d2L1DC0
    • Je suis venu ici à la recherche pour la division entière en Javascript, ce qui n'est pas une nécessité particulière.
    • oui, mais juste envie de le faire ne pas dire que vous devriez écrire dans une étrange forme juste, car il arrive à être le plus rapide, sans une bonne raison - code de clarté en général, devraient normalement être votre première préoccupation. Aussi ces tests peuvent être complètement dénuée de sens après les changements de langue et à travers les différents navigateurs, il vous faudrait profil pour savoir ce qui est lent à votre demande, quel que soit. Il est peu probable d'être votre entier de la division de la méthode, sauf si vous avez déjà optimisé jamais seul autre chose!

    InformationsquelleAutor KalEl
  4. 118

    ES6 présente le nouveau Math.trunc méthode. Cela permet de fixer @MarkElliot réponse pour le faire fonctionner pour les nombres négatifs trop:

    var div = Math.trunc(y/x);
var rem = y % x;

    Noter que Math méthodes ont l'avantage sur les opérateurs au niveau du bit qu'ils travaillent avec les numéros de plus de 231.

    • var y =18014398509481984; var x= 5; div = ? - correction d'un bug ?
    • Ce n'est pas un bug. Votre numéro a trop de chiffres, vous ne pouvez pas avoir beaucoup de précision dans un fichier binaire 64 bits format IEEE 754 nombre. Par exemple, 18014398509481984 == 18014398509481985.
    • 18014398509481984 == 2**54, et j'ai surtout utilisé ce nombre, parce qu'il est représenté exactement en binary64 format. et la réponse est représentée exactement trop
    • Je n'explique pas très bien. Je voulais dire 18014398509481984 / 5 est 3602879701896396.8. Toutefois, ne peuvent pas être stockés, de sorte qu'il est converti 3602879701896397. Et puis Math.trunc(3602879701896397) est 3602879701896397.
    • OK, j'ai passé la journée entière à penser comment contourner ce arrondi trop. Semble, il est possible de déterminer qu'il y avait de l'arrondi et de corriger "tronquée quotinent": si (y / x === div && rem > x - rem) { div -= 1; }", mais je ne suis pas sûr de l'exactitude, de toute façon jamais l'esprit, votre solution est assez bon pour la plupart des cas.
    • Je pense que le choix est simple: Vous avez besoin de soutien pour les nombres jusqu'à 32 bits signé? Utilisation ~~(x/y). Besoin d'un soutien plus grand des nombres jusqu'à 54 bits signé? Utilisation Math.trunc si vous l'avez, ou Math.floor sinon (bon pour les nombres négatifs). Besoin d'un soutien encore plus grand nombre? L'utilisation de certains grand nombre de la bibliothèque.
    • pour rubyists ici de google dans la recherche de divmod, vous pouvez la mettre en œuvre en tant que telle: function divmod(x, y) { var div = Math.trunc(x/y); var rem = x % y; return [div, rem]; }

    InformationsquelleAutor Oriol
  5. 24
    var remainder = x % y;
return (x - remainder) / y;
    • Cette version échoue malheureusement à l'essai lorsque x = -100 parce qu'elle renvoie -34 au lieu de -33.
    • que dire de "var x = 0.3; var y = 0.01;" ? (merci à github.com/JuliaLang/julia/issues/4156#issuecomment-23324163)
    • En fait, @Samuel, avec des valeurs négatives, cette méthode renvoie des résultats corrects, ou au moins, elle retourne la même valeur que la méthode utilisant Math.trunc :). J'ai vérifié avec 100,3; -100,3; 100,-3 et -100,-3. Bien sûr, beaucoup de temps s'est écoulé depuis votre commentaire et les choses changent.
    InformationsquelleAutor gammax
  6. 13

    Vous pouvez utiliser la fonction parseInt pour obtenir un résultat tronqué.

    parseInt(a/b)

    À obtenir un reste, l'utilisation de mod de l'opérateur:

    a%b

    parseInt ont certains pièges avec des cordes, pour éviter d'utiliser un paramètre radix avec la base 10

    parseInt("09", 10)

    Dans certains cas, la représentation de chaîne de la valeur peut être une forme de notation scientifique, dans ce cas, parseInt va produire un résultat erroné.

    parseInt(100000000000000000000000000000000, 10) //1e+32

    Cet appel va produire 1 comme résultat.

    • parseInt devrait être évitée lorsque cela est possible. Voici Douglas Crockford de l'avertissement: "Si le premier caractère de la chaîne est 0, alors la chaîne est évaluée dans la base de 8 au lieu de la base 10. En base 8, 8 et 9 ne sont pas des chiffres, parseInt("08") et parseInt("09") produisent des 0 comme leur résultat. Cette erreur provoque des problèmes dans les programmes qui analysent les dates et les heures. Heureusement, parseInt peut prendre un paramètre radix, de sorte que parseInt("08", 10) produit 8. Je vous recommande de toujours fournir le paramètre radix." archive.oreilly.com/pub/a/javascript/excerpts/...
    • Dans une division, je m'attends à recevoir un nombre, pas une chaîne, mais c'est un bon point.
    • ajoutez la radix. Il ne dit pas parseInt doit être évité; juste qu'il y a quelques astuces à connaître. Vous devez être au courant de ces choses et être prêts à faire face.
    • Ne jamais appeler parseInt avec un argument nombre. parseInt est censé analyser partiellement des chaînes numériques, de ne pas tronquer des nombres.
    • Tout simplement parce que les choses ne sont pas à l'origine destiné à être utilisé d'une certaine façon, cela ne signifie pas que vous ne devriez pas. Cette réponse œuvres.
    InformationsquelleAutor Édipo Costa Rebouças
  7. 6

    JavaScript calcule la droite de la chaussée des nombres négatifs et le reste des nombres non-entiers, à la suite de la définition mathématique pour eux.

    SOL est définie comme "le plus grand nombre entier plus petit que le paramètre", donc:

    • nombres positifs: FLOOR(X)=partie entière de X;
    • les nombres négatifs: FLOOR(X)=partie entière de X moins 1 (parce qu'il doit être plus PETIT que le paramètre, c'est à dire, plus négative!)

    RESTE est définie comme la "gauche" de la division (Euclidienne de l'arithmétique). Lorsque le dividende n'est pas un entier, le quotient est généralement pas un nombre entier, c'est à dire, il n'y a pas de reste, mais si le quotient est forcé à être un nombre entier (et c'est ce qui arrive quand quelqu'un essaie de faire le reste ou le module d'un nombre à virgule flottante), il y aura un non-entier "de gauche " de plus", évidemment.

    JavaScript ne calcule tout comme prévu, le programmeur doit faire attention à poser les bonnes questions (et les gens devraient être attentif à répondre à ce qui est demandé!) Yarin est de la première question n'était PAS "qu'est-ce que la division entière de X par Y", mais, au contraire, "le nombre ENTIER de fois un nombre entier donné VA DANS une autre". Pour les nombres positifs, la réponse est la même pour les deux, mais pas pour les nombres négatifs, parce que la division entière (dividende par le diviseur) sera -1 plus petit que la fois d'un nombre (diviseur) "va dans" de l'autre (dividende). En d'autres termes, le PLANCHER sera de retour la réponse correcte pour une division entière d'un nombre négatif, mais Yarin n'ai pas demandé que!

    gammax répondu correctement, que le code fonctionne comme demandé par Yarin. D'autre part, Samuel est faux, il n'a pas les maths, je suppose, ou il aurait vu qu'il ne fonctionne pas (d'ailleurs, il n'a pas dit quel était le diviseur de son exemple, mais j'espère que ça a été 3):

    Reste = X % Y = -100 % 3 = -1

    GoesInto = (X - Reste) /Y = (-100 - -1) /3 = -99 /3 = -33

    En passant, j'ai testé le code sur Firefox 27.0.1, il a fonctionné comme prévu, avec des nombres positifs et négatifs et aussi avec les valeurs non entières, à la fois pour le dividende et le diviseur. Exemple:

    -100.34 /3.57: GoesInto = -28, Reste = -0.3800000000000079

    Oui, j'ai remarqué, il y a un problème de précision de là, mais je n'ai pas eu le temps de le vérifier (je ne sais pas si c'est un problème avec Firefox, Windows 7 ou avec mon CPU FPU). Pour Yarin la question, pourtant, qui n'implique que des nombres entiers, les gammax code fonctionne parfaitement.

    InformationsquelleAutor Cyberknight
  8. 5

    Math.floor(operation) retourne l'arrondi de la valeur de l'opération.

    Exemple de la 1st question:

    var x = 5;
var y = 10.4;
var z = Math.floor(x + y);

console.log(z);

    Console:

    15

    Exemple de la 2ème question:

    var x = 14;
var y = 5;
var z = Math.floor(x%y);

console.log(x);

    Console:

    4

    InformationsquelleAutor Aetricity
  9. 5

    Que j'utilise habituellement:

    const quotient =  (a - a % b) / b;
const remainder = a % b;

    C'est probablement pas le plus élégant, mais il fonctionne.

    • Belle solution, car elle permet d'éviter la laideur de l'analyse ou de la troncature d'un flotteur.
    • si vous avez besoin de quotient et le reste, calculer le reste d'abord et ensuite réutiliser cette valeur dans l'expression du quotient, c'est à dire le quotient = (un - reste) / b;
    InformationsquelleAutor Wolf Elkan
  10. 2

    Alex Moore-Niemis'commentaire comme une réponse:

    Pour Rubyists ici de Google dans la recherche de divmod, vous pouvez la mettre en œuvre en tant que telle: 

    function divmod(x, y) {
  var div = Math.trunc(x/y);
  var rem = x % y;
  return [div, rem];
}

    Résultat:

    //[2, 33]
    • Généralement, divmod utilise parqueté division (Math.floor), qui diffère de l'tronquée de la division (Math.trunc) lorsque les nombres négatifs sont impliqués. C'est le cas pour NPM divmod paquet, Ruby divmod, SWI-Prolog divmod et sans doute beaucoup d'autres implémentations, trop.
    • Tronquée de la division donne plus naturellement résultats de recherche qu'parqueté de la division, mais la compatibilité des atouts qui, de l'OMI. Peut-être, il y a des mathématiques ou des raisons de performances pour l'utilisation de terrassement de la division, trop. Notez qu'en général, divmod existe parce qu'il est effectue deux fois plus rapide que le calcul de ces deux opérations séparément. Fournir une telle fonction sans ce gain de performance peut être source de confusion.
    InformationsquelleAutor Alex
  11. 1

    Si vous êtes juste à partager avec les puissances de deux, vous pouvez utiliser les opérateurs sur les bits:

    export function divideBy2(num) {
  return [num >> 1, num & 1];
}

export function divideBy4(num) {
  return [num >> 2, num & 3];
}

export function divideBy8(num) {
  return [num >> 3, num & 7];
}

    (Le premier est le quotient, le deuxième le reste)

    • Généralement, function divideByPowerOf2(num, exponent) { return [num >> exponent, num & ((1 << exponent) - 1)]; }.
    InformationsquelleAutor Konstantin Möllers
  12. 1

    Calcul du nombre de pages peut être fait en une seule étape:
    Les mathématiques.ceil(x/y)

    • Je ne vois pas comment cela fournit le reste.
    InformationsquelleAutor user1920925
  13. 0

    Vous pouvez utiliser ternaire de décider comment gérer positifs et négatifs des valeurs entières ainsi.

    var myInt = (y > 0) ? Math.floor(y/x) : Math.floor(y/x) + 1

    Si le nombre est positif, tout est très bien. Si le nombre est négatif, il faudra ajouter 1 à cause de la façon dont les Mathématiques.étage poignées négatifs.

    InformationsquelleAutor John Galt
  14. 0

    Ce sera toujours tronquée vers zéro.
    Vous ne savez pas si il est trop tard, mais ici, il va:

    function intdiv(dividend, divisor) { 
    divisor = divisor - divisor % 1;
    if (divisor == 0) throw new Error("division by zero");
    dividend = dividend - dividend % 1;
    var rem = dividend % divisor;
    return { 
        remainder: rem, 
        quotient: (dividend - rem) / divisor
    };
}
    InformationsquelleAutor bzim
  15. 0

    Si vous avez besoin de calculer le reste pour les très grands nombres entiers, ce qui la JS exécution ne peut pas représenter en tant que tel (un entier plus grand que 2^32 est représenté comme un flotteur et donc il perd en précision), vous devez faire certains truc.

    Cela est particulièrement important de vérifier de nombreux cas, de vérifier les chiffres qui sont présents dans de nombreuses instances de notre vie quotidienne (numéros de compte en banque, cartes de crédit, ...)

    Tout d'abord vous avez besoin de votre numéro de chaîne (sinon, vous avez déjà perdu la précision et le reste n'a pas de sens).

    str = '123456789123456789123456789'

    A présent, vous devez diviser votre chaîne dans les petites pièces, assez petit donc la concaténation de tout le reste et un morceau de ficelle peut s'adapter à 9 chiffres.

    digits = 9 - String(divisor).length

    Préparer une expression régulière pour fractionner la chaîne

    splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g')

    Par exemple, si digits est de 7, la regexp est

    /.{1,7}(?=(.{7})+$)/g

    Elle correspond à une non vide de sous-chaîne de longueur maximale 7, qui est suivi ((?=...) est une anticipation positif) par un certain nombre de caractères qui est multiple de 7. Le " g " est de rendre l'expression de courir à travers toute la chaîne, de ne pas s'arrêter au premier match.

    Maintenant convertir chaque partie en entier, et de calculer les résidus par reduce (rajout du précédent reste - ou 0 - multiplié par la bonne puissance de 10):

    reducer = (rem, piece) => (rem * Math.pow(10, digits) + piece) % divisor

    Cela fonctionne en raison de la "soustraction" le reste de l'algorithme:

    n mod d = (n - kd) mod d

    qui permet de remplacer tout "première partie" de la représentation décimale d'un nombre avec son reste, sans affecter le reste final.

    La version finale du code ressemblerait à:

    function remainder(num, div) {
  const digits = 9 - String(div).length;
  const splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g');
  const mult = Math.pow(10, digits);
  const reducer = (rem, piece) => (rem * mult + piece) % div;

  return str.match(splitter).map(Number).reduce(reducer, 0);
}
    InformationsquelleAutor rewritten