'1.23e-7' Javascript parseFloat donne 1.23e-7 en cas de besoin 0,000000123

Question

parseFloat(1.51e-6);
// returns 0.00000151

parseFloat(1.23e-7);
// returns 1.23e-7
// required 0.000000123

Je Tri des colonnes de table contenant une large gamme de nombres à virgule flottante, certains représentés en notation scientifique.

J'utilise le plugin jQuery tablesorter2.0 qui utilise « parseFloat » pour les cellules qui commencent par un chiffre. Le problème est que parseFloat très petit nombre représentés comme 1.23e-7 comme une chaîne et ne se développe pas à ce 0,000000123. En tant que résultat tablesorter trie le contenu de la colonne sous forme de texte au lieu de valeurs numériques.

**Column To Sort**
2.34
1.01
13.56
1.23e-7

**After Sort Now**
1.01
1.23e-7
13.56
2.34

**Expect**
1.23e-7
1.01
2.34
13.56

Y at-il un moyen efficace de représenter un très petit nombre de notation scientifiques élargi des nombres à virgule flottante?

Solution:

tablesorter détermine comment trier une colonne en fonction de la première tablesorters parseurs automatique pour retourner vrai pour le contenu d'une cellule dans cette colonne. Si la cellule contenait 1.23e-7 qu'elle fait défaut pour trier par texte parce que l'analyseur de « chiffres » n'interprète pas comme un numéro.

Donc, pour contourner le problème, le code suivant représente le numéro de la notation scientifique comme une chaîne qui tablesorter peut interpréter / parse comme un chiffre et assure ainsi un tri numérique sur la colonne. @bitplitter -. Merci pour le conseil toFixed ()

var s = "1.23e-7";
// Handle exponential numbers.
if (s.match(/^[-+]?[1-9]\.[0-9]+e[-]?[1-9][0-9]*$/)) {
  s = (+s).toFixed(getPrecision(s));
}
//returns 0.000000123

// Get a nice decimal place precision for the scientific notation number.
// e.g. 1.23e-7 yields 7+2 places after the decimal point
// e.g. 4.5678e-11 yields 11+4 places after the decimal point
function getPrecision(scinum) {
  var arr = new Array();
  // Get the exponent after 'e', make it absolute.  
  arr = scinum.split('e');
  var exponent = Math.abs(arr[1]);

  // Add to it the number of digits between the '.' and the 'e'
  // to give our required precision.
  var precision = new Number(exponent);
  arr = arr[0].split('.');
  precision += arr[1].length;

  return precision;
}

Answer 1

Même si l'OP a affiché sa solution, je voudrais partager une solution assez simple, je suis tombé sur, qui est basé sur les parseurs dans le tablesorter code source et l'expression rationnelle donnée par Jasons sur une autre question .

// add parser through the tablesorter addParser method 
$.tablesorter.addParser({ 
// set a unique id
id: 'scinot', 
is: function(s) { 
    return /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/.test(s); 
}, 
format: function(s) { 
    return $.tablesorter.formatFloat(s);
}, 
type: 'numeric' 
});

Il fonctionne sur mes tables avec à peu près toutes les valeurs données en notation scientifique. Il détecte automatiquement (la partie is:) et trie correctement plusieurs champs. Il aide les autres à l'espoir qui pourraient tomber par hasard sur cette question.

Answer 2

Vous pouvez utiliser toFixed() au lieu de parseFloat() pour formater les numéros comme vous le souhaitez. Par exemple (1.23e-7).toFixed(9) sera rendu comme 0.000000123

Pour pouvoir trier ces sortes de comparaison de chaînes par défaut, assurez-vous de préfixe tous avec des zéros et faire tous la même taille de sorte que les points décimaux wil alignés.

Vous pouvez étendre l'objet de chaîne avec PadLeft comme ceci:

String.prototype.padLeft = function(len, char){
var prefix = '';
var length=this.length;
if(len>length)
 for(var i=0;i < len-length;i++) prefix += char;
return prefix + this;
}

Maintenant, vous pouvez appeler ((1.23e-7).toFixed(9)).padLeft(15,'0')

Answer 3

le problème n'est pas parseFloat, mais sorte que les utilisations comparaison de chaînes par défaut. Essayez l'application comparaison numérique:

a.sort(function(x, y) { return x - y })