Modulo en JavaScript - grand nombre

J'ai essayer de calculer avec JS' modulo fonction, mais ne pas obtenir le bon résultat (qui devrait être de 1). Voici une codé en dur morceau de code.

var checkSum = 210501700012345678131468;
alert(checkSum % 97);

Result: 66

Quel est le problème ici?

Ce qui concerne,
Benedikt

source d'informationauteur Benedikt

9

Un tas d'améliorations à Benedikt la version: "crête +=" + cDivident;" est une correction de bug; parseInt(diviseur) permet de faire passer les deux arguments comme des chaînes de caractères; vérifier la chaîne vide à la fin, il est toujours en revenir à des valeurs numériques; ajout var états il n'est donc pas l'utilisation de variables globales; converti foreach vieux style de sorte qu'il fonctionne dans les navigateurs avec les anciens Javascript; fixe la crête == 0; bug (merci @Dan.StackOverflow).
```
fonction modulo (divident, diviseur) { 
var cDivident = "; 
var crête = "; 

for (var i dans divident ) { 
var cChar = divident[i]; 
var cOperator = crête + "+ cDivident + " + cChar; 

si ( cOperator < parseInt(diviseur) ) { 
cDivident += " + cChar; 
} else { 
crête = cOperator % diviseur; 
si ( crête == 0 ) { 
crête = "; 
} 
cDivident = "; 
} 

} 
la crête += " + cDivident; 
si (crête == ") { 
crête = 0; 
} 
de retour de la crête; 
} 
```
13

Pour un IBAN calcul de la forme normale de numéro de compte bancaire, je me retrouve avec un très grand nombre contenu dans un type de données chaîne. De ce grand nombre je dois trouver le repos lorsqu'il est divisé par 97 -> grand nombre % 97.

Dès que j'ai de convertir le type de données à un nombre entier-je obtenir un dépassement de capacité résultant en un nombre entier négatif et finalement un mal de repos de la valeur. Comme je l'ai vu certains détaillé des morceaux de code (qui a également donné de mauvais résultats), je ne pouvais pas résister à partager ma propre. Les crédits vont à Trouver le Module d'un Très Grand Nombre avec un Nombre Normal
```
modulo: function(divident, divisor) {
    var partLength = 10;

    while (divident.length > partLength) {
        var part = divident.substring(0, partLength);
        divident = (part % divisor) +  divident.substring(partLength);          
    }

    return divident % divisor;
}
```
N. B.
J'utilise 10 postes ici car c'est plus petit que le 15 (et) les positions de max entier en JavaScript, il en résulte un nombre plus grand que 97 et c'est un beau chiffre rond. Les deux premiers arguments de la matière.
5

on dirait que vous avez été victime de cette: Qu'est-ce que JavaScript est plus haute valeur entière d'un Nombre peut aller sans perdre de précision?

juste pour rappeler que ce qui est dans l'autre thread:

ils sont 64 bits des valeurs à virgule flottante, la plus exacte de l'intégrale est égale à 2^53. cependant, à partir de la spécification de la section [8.5: Numéro de Type]:

Certains ECMAScript opérateurs de ne traiter qu'avec des nombres entiers dans l'intervalle -2^31 par 2^31-1, inclusivement, ou dans la gamme de 0 à 2^32-1, inclusivement. Ces opérateurs accepter n'importe quelle valeur du type de Numéro, mais d'abord convertir chaque valeur à l'un des 2^32 valeurs entières. Voir les descriptions de la ToInt32 et ToUint32 opérateurs dans les sections 0 et 0, respectivement

Mais de crédit lorsque le crédit est dû. Jimmy a obtenu la accepté de répondre plus là pour faire le travail sur le terrain (bien, googler).

Enfin, ma solution:

function modulo (divident, divisor) {
    cDivident = '';
    cRest = '';

    for each ( var cChar in divident ) {
        cOperator = cRest + '' + cDivident + '' + cChar;

        if ( cOperator < divisor ) {
            cDivident += '' + cChar;
        } else {
            cRest = cOperator % divisor;
            if ( cRest == 0 ) cRest = '';
            cDivident = '';
        }

    }

    return cRest;
}

3

Silencieux Matt a développé un Javascript bibliothèque pour les Grands Entiers. Il pourrait résoudre ce problème.

Pour ceux qui veulent simplement copier&pâte de travail (fonctionnelle) de la solution dans l'ES6 pour vérifier les codes iban:

function isIBAN(s){
    const rearranged = s.substring(4,s.length) + s.substring(0,4);
    const numeric   = Array.from(rearranged).map(c =>(isNaN(parseInt(c)) ? (c.charCodeAt(0)-55).toString() : c)).join('');
    const remainder = Array.from(numeric).map(c => parseInt(c)).reduce((remainder, value) => (remainder * 10 + value) % 97,0);

    return  remainder === 1;}

Vous pouvez même écrire comme un one-liner.

Le modulo opération est effectuée sur le tableau d'entiers de stocker le nombre réel (dividentappliqué comme une chaîne de caractères à la fonction):

function modulo(divident, divisor){
   return Array.from(divident).map(c => parseInt(c)).reduce((remainder, value) => (remainder * 10 + value) % divisor,0);
};

Cela fonctionne parce que le Modulo est distributive sur l'addition, de la soustraction et de la multiplication:

(a+b)%m = ((a%m)+(b%m))%m
(a-b)%m = ((a%m)-(b%m))%m
(unb)%m = ((a%m)(b%m))%m

L'IBAN fonction transpiled à ES5 ressemble:

function (s) {
    var rearranged = s.substring(4, s.length) + s.substring(0, 4);
    var numeric = Array.from(rearranged).map(function (c) { return (isNaN(parseInt(c)) ? (c.charCodeAt(0) - 55).toString() : c); }).join('');
    var remainder = Array.from(numeric).map(function (c) { return parseInt(c); }).reduce(function (remainder, value) { return (remainder * 10 + value) % 97; }, 0);
    return remainder === 1;
};

Vous devez vous connecter pour publier un commentaire.