Unendlich viele Nachkommastellen anzeigen

Idee
Ich wollte eine Nachkommastelle prüfen und stellte fest, dass die meisten Rechner soweit nach dem Komma nicht mehr anzeigen. Verständlich, jedoch gibt es sehr seltene Fälle wo man dies braucht. Klar wieder eine der nice to have und nie genutzte Funktion, aber ich wollte es euch nicht vorenthalten, falls jemand schnell eine Funktion braucht und nur Copy&Paste machen will. Die Gesamtgroesse ansich ist auf 1000 Zeichen vorbelegt und kann mittels Parameter angepasst werden. Die errechnete Zahl ist ein Text, klar, sonst könnte man per Boardmittel das Ergebnis errechnen.

Umsetzung
Die Funktion ist in JavaScript geschrieben. Um den Code etwas zu erleichtern, habe ich die Formel für die Umwandlung der Zahl in eine Float als eigene Funktion ausgegliedert. Die Umwandlung in float ist hilfreich, wenn die Werte über ein Formular oder eine externe Datenquelle kommen und man nicht immer prüfen will, ob es im richtigen Format vorliegt. Also wird einfach alles konvertiert und wird immer eine float Zahl.
Angehängt ist auch eine rekursive Variante, aber die sollte man nicht nutzen, denn der Overhead kann den Rechner sehr belasten. Ich wollte die nicht weglassen, falls man einfach sehen will, dass Rekursion nicht immer die beste Wahl ist, vor allem nicht auf Performance ausgelegte Strukturen. Mit Sicherheit kann man den Code noch optimieren, aber so sieht man den Weg viel einfacher. Feel free to abuse it.

Code
// Hilfsfunktion floatval

function floatval(text, maxwert, minwert) {
    var zahl = parseFloat(text);
    if (isNaN(zahl))
        zahl = 0.0;
    if (typeof(maxwert) != "undefined" && maxwert < zahl)
        zahl = maxwert;
    if (typeof(minwert) != "undefined" && minwert > zahl)
        zahl = minwert;
    return zahl;
}

// Die eigentliche Funktion

function errechneZahl(zahla,zahlb,maxschritte) {
var t = "";
zahla = floatval(zahla);
zahlb = floatval(zahlb);
var ok = true;
var schonkomma = false;
var za = zahla;
var zb = zahlb;
var periode = new Array();
if (!maxschritte)
maxschritte = 1000;
for (var a=0;a<maxschritte;a++) {
if (za < zb){
if (t == "" || schonkomma)
t += '0';
if (!schonkomma) {
t += '.';
schonkomma = true;
} else
periode.push({"zahl":0,"wert":0});
za *= 10;
} else {
var d = Math.floor(za/zb);
t += d;
var dd = za - (d*zb);
if (dd == 0)
break;
if (schonkomma) {
var pwert = "";
for (var b=0;b<periode.length;b++){
if (periode[b].zahl == dd || pwert != "") {
pwert += ""+periode[b].wert;
}
}
if (pwert != "") {
t += " Periode "+pwert;
break;
}
periode.push({"zahl":dd,"wert":d});
}
za = dd;
if (schonkomma)
za *= 10;
}
}
return t;
}

// die rekursive, nicht empfohlene Version
/*
function errechneZahlRekursiv(zahla, zahlb, ergtext, schonkomma) {

var t = "";
zahla = floatval(zahla);
zahlb = floatval(zahlb);
if (ergtext)
t = ergtext;
if (zahla == zahlb) {
t += "1";
return t;
}
if (t.length > 1000)
return t;
if (zahla < zahlb) {
if (t == "" || schonkomma)
t += '0';
if (!schonkomma) {
t += '.';
schonkomma = true;
}
zahla *= 10;
t = errechneZahl(zahla, zahlb, t, schonkomma);
} else {
var d = Math.floor(zahla/zahlb);
t += d;
var dd = zahla - (d*zahlb);
if (dd == 0)
return t;
if (schonkomma)
dd *= 10;
t = errechneZahl(dd, zahlb, t, schonkomma);
}
return t;
}
*/

Fazit
Interessant um Werte schnell zu überprüfen. Rechnen kann man damit spontan nicht, aber man könnte auch Funktionen schaffen, welche beliebig große Zahlen addieren und dergleichen. Hier ist lediglich eine schnelle, einfache Funktion, welche viele Nachkommastellen anzeigen kann. Viel Spaß damit.

Saso Nikolov