gelesen hab ich schon viel, aber ich möchte wissen, was der "Goldstandard" wäre, um Strings, die numerische Werte enthalten (sollten), umzuwandeln. Bisher habe ich:

        function round_i(v) {
            let num = parseInt(v, 10);
            return isNaN(num) ? 0 : num;
        }

        function round_f(v, d = -1) {
            if (d <= 0) {
                return Number(v);
            }
            return Number(v).toFixed(d);
            // Oder: return Number(Math.round(v + 'e' + d) + 'e-' + d); ?
        }

        /**
         * Nachbau der Rundungsmethode.
         * @param {number|string} value - Der zu rundende Wert
         * @param {number} decimals - Anzahl der Nachkommastellen
         * @param {boolean} halfUp - true für ROUND_HALF_UP (kaufmännisch), false für ROUND_DOWN (Abschneiden)
         * @return {string} Der gerundete Wert als formtierter String ohne abschließende Nullen
         */
        function round_s(value, decimals, halfUp) {
            // Falls der Wert als String kommt, in eine Zahl wandeln
            let num = Number(value);

            // Verhindert JavaScript-Fließkommafehler durch Skalierung (z.B. 10^2 = 100)
            let factor = Math.pow(10, decimals);
            let tempResult;

            if (halfUp) {
                // Kaufmännisches runden:
                // Math.round() rundet in JS standardmäßig kaufmännisch
                tempResult = Math.round(num * factor) / factor;
            } else {
                // Striktes Abschneiden (Gegen Null runden):
                // Math.trunc() schneidet die Nachkommastellen einfach ab (funktioniert für positiv wie negativ)
                tempResult = Math.trunc(num * factor) / factor;
            }

            return tempResult.toFixed(decimals);
        }

Jede Funktion soll sowohl mit Zeichenketten als auch mit schon umgewandelten Werten funktionieren (da ich in Vanilla-JS ja keine Typsicherheit habe). Optional soll die Anzahl der Nachkommastellen angegeben werden dürfen.

round_i braucht logischerweise keinen Nachkommastellenparamter... Aber ist parseInt richtig, oder sollte eher Math.round an dieser Stelle verwendet werden? Sind die Default-Paramter so richtig? Und habe ich noch bestimmte Edge-Cases übersehen?