Zusammenfassung von über 50 Hilfsfunktionen in JavaScript

Funktion ist statisch (Wert) {
    zurückkehren (
        Typ des Wertes === 'Zeichenfolge' ||
        Typ des Wertes === 'Zahl' ||
        Typ des Wertes === 'Boolesch' ||
        Typ des Wertes === 'undefiniert' ||
        Wert === null
    )
}

Funktion istPrimitiv(Wert) {
    returniere isStatic(Wert) || Typ des Wertes === 'Symbol'
}

Funktion istObjekt(Wert) {
    let Typ = Typ des Wertes;
    Rückgabewert != null && (Typ == ‚Objekt‘ || Typ == ‚Funktion‘);
}

Funktion istObjektähnlich(Wert) {
    Rückgabewert != null und Typ des Wertes == „Objekt“;
}

Funktion getRawType(Wert) {
    gibt Object.prototype.toString.call(Wert).slice(8, -1) zurück
}
// getoRawType([]) ⇒ Array

Funktion istEinfachesObjekt(Objekt) {
    returniere Object.prototype.toString.call(obj) === '[Objekt Objekt]'
}

Funktion istArray(arr) {
    gibt Object.prototype.toString.call(arr) === '[Objekt-Array]' zurück
}

//isArray auf ArrayArray einbinden.isArray = Array.isArray || isArray;

Funktion isRegExp(Wert) {
    gibt Object.prototype.toString.call(Wert) === '[Objekt RegExp]' zurück
}

Funktion istDatum(Wert) {
    returniere Object.prototype.toString.call(Wert) === '[Objekt Datum]'
}

Funktion isNative(Wert) {
    Rückgabetyp des Wertes === 'Funktion' && /nativer Code/.test(value.toString())
}

Funktion istFunktion(Wert) {
    gibt Object.prototype.toString.call(Wert) === '[Objektfunktion]' zurück
}

Funktion istLänge(Wert) {
    Rückgabetyp des Wertes == „Zahl“ und Wert > -1 und Wert % 1 == 0 und Wert <= Zahl.MAX_SAFE_INTEGER;
}

Funktion istArrayLike(Wert) {
    Rückgabewert != null && isLength(value.length) && !isFunction(value);
}

Funktion istLeer(Wert) {
    wenn (Wert == null) {
        gibt true zurück;
    }
    wenn (istArrayLike(Wert)) {
        return !Wert.Länge;
    } sonst wenn (isPlainObject(Wert)) {
        für (let Schlüsselwert) {
            if (hasOwnProperty.call(Wert, Schlüssel)) {
                gibt false zurück;
            }
        }
    }
    gibt false zurück;
}

Funktion zwischengespeichert(fn) {
    Lassen Sie den Cache = Objekt.erstellen(null);
    Rückgabefunktion cachedFn(str) {
        lass hit = cache[str];
        Treffer zurückgeben || (Cache[str] = fn(str))
    }
}

sei camelizeRE = /-(\w)/g;
Funktion Kamelize (str) {
    return str.replace(camelizeRE, Funktion(_, c) {
        gibt c zurück? c.toUpperCase(): '';
    })
}
//ab-cd-ef ==> abCdEf
//Verwende die Speicherfunktion let _camelize = cached(camelize)

sei hyphenateRE = /\B([AZ])/g;
Funktion Bindestrich(str){
    return str.replace(hyphenateRE, '-$1').toLowerCase()
}
//abCd ==> ab-cd
//Verwenden der gespeicherten Funktion let _hyphenate = cached(hyphenate);

Funktion Großschreibung(str) {
    return str.charAt(0).toUpperCase() + str.slice(1)
}
//abc ==> Abc
//Verwenden der Memoized-Funktion let _capitalize = cached(capitalize)

Funktion erweitern(auf, _form) {
    für (let-Schlüssel in _form) {
        zu[Schlüssel] = _form[Schlüssel];
    }
    zurück zu
}

Objekt.assign = Objekt.assign || Funktion() {
    if (arguments.length == 0) throw new TypeError('Undefined oder null kann nicht in Objekt konvertiert werden');
    let ziel = argumente[0],
        args = Array.prototype.slice.call(Argumente, 1),
        Schlüssel;
    args.forEach(Funktion(Element) {
        für (Element eingeben) {
            item.hasOwnProperty(Schlüssel) && (Ziel[Schlüssel] = Element[Schlüssel])
        }
    })
    Rücklaufziel
}

Lassen Sie Klon = Objekt.assign({}, Ziel);

let clone = JSON.parse( JSON.stringify(Ziel) )

Funktion Klon(Wert, tief) {
    wenn (istPrimitiv(Wert)) {
        Rückgabewert
    }
    if (isArrayLike(value)) { // ist ein arrayähnlicher Wert = Array.prototype.slice.call(vall)
        Rückgabewert.map(Element => tief ? Klon(Element, tief) : Element)
    } sonst wenn (isPlainObject(value)) { //ist ein Objekt let target = {}, key;
        für (Wert eingeben) {
            value.hasOwnProperty(Schlüssel) && ( Ziel[Schlüssel] = tief ? Klon(Wert[Schlüssel], Wert[Schlüssel] ))
        }
    }
    let Typ = getRawType(Wert);
    Schalter(Typ) {
        Fall 'Datum':
        Fall 'RegExp':
        Fall „Fehler“: Wert = neues Fenster[Typ](Wert); Unterbrechung;
    }
    Rückgabewert
}

//Die Betriebsumgebung ist der Browser let inBrowser = typeof window !== 'undefined';
//Die Betriebsumgebung ist WeChat let inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
let weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
//Browser-UA-Beurteilung let UA = inBrowser && window.navigator.userAgent.toLowerCase();
let isIE = UA && /msie|trident/.test(UA);
let isIE9 = UA && UA.indexOf('msie 9.0') > 0;
let isEdge = UA && UA.indexOf('edge/') > 0;
let isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
let isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
let isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;

Funktion getExplorerInfo() {
    lass t = navigator.userAgent.toLowerCase();
    return 0 <= t.indexOf("msie") ? { //dh < 11
        Typ: "IE",
        Version: Nummer(t.match(/msie ([\d]+)/)[1])
    } : !!t.match(/trident\/.+?rv:(([\d.]+))/) ? { // zB 11
        Typ: "IE",
        Version: 11
    } : 0 <= t.indexOf("Kante") ? {
        Typ: "Kante",
        Version: Nummer(t.match(/edge\/([\d]+)/)[1])
    } : 0 <= t.indexOf("Firefox") ? {
        Typ: "Firefox",
        Version: Nummer(t.match(/firefox\/([\d]+)/)[1])
    } : 0 <= t.indexOf("chrome") ? {
        Typ: "Chrome",
        Version: Nummer(t.match(/chrome\/([\d]+)/)[1])
    } : 0 <= t.indexOf("opera") ? {
        Typ: "Opera",
        Version: Nummer(t.match(/opera.([\d]+)/)[1])
    } : 0 <= t.indexOf("Safari") ? {
        Typ: "Safari",
        Version: Nummer(t.match(/version\/([\d]+)/)[1])
    } : {
        Typ: t,
        Version: -1
    }
}

Funktion istPCBroswer() {
    lass e = navigator.userAgent.toLowerCase()
        , t = "ipad" == e.match(/ipad/i)
        , i = "iphone" == e.match(/iphone/i)
        , r = "midp" == e.match(/midp/i)
        , n = "rv:1.2.3.4" == e.match(/rv:1.2.3.4/i)
        , a = "ucweb" == e.match(/ucweb/i)
        , o = "Android" == e.match(/Android/i)
        , s = "Windows CE" == e.match(/Windows CE/i)
        , l = "Windows Mobile" == e.match(/Windows Mobile/i);
    Rückgabe !(t || i || r || n || a || o || s || l)
}

Funktion einzigartig(arr){
    if(!isArrayLink(arr)){ //kein array-ähnliches Objekt return arr
    }
    let ergebnis = []
    lass objarr = []
    let obj = Objekt.erstellen(null)

    arr.fürJeden(Element => {
        if(isStatic(item)){//Dies sind die Rohdaten, außer dem Symbol let key = item + '_' + getRawType(item);
            wenn(!obj[Schlüssel]){
                obj[Schlüssel] = true
                Ergebnis.push(Element)
            }
        }else{//Referenztyp und Symbol
            wenn (!objarr.includes(item)){
                objarr.push(Element)
                Ergebnis.push(Element)
            }
        }
    })

    Ergebnis zurückgeben
}

Fenster.Set = Fenster.Set || (Funktion () {
    Funktion Set(arr) {
        diese.Artikel = arr? einzigartig(arr) : [];
        this.size = this.items.length; // Array-Größe}
    Prototyp = {
        hinzufügen: Funktion (Wert) {
            // Ein Element hinzufügen. Wenn das Element bereits vorhanden ist, überspringen Sie es und geben Sie die Set-Struktur selbst zurück.
            wenn (!dieser.hat(Wert)) {
                this.items.push(Wert);
                diese.Größe++;
            }
            gib dies zurück;
        },
        löschen: Funktion () {
            // Alle Mitglieder löschen, kein Rückgabewert.
            diese.items = []
            diese.Größe = 0
        },
        löschen: Funktion (Wert) {
            //Löschen Sie einen Wert und geben Sie einen booleschen Wert zurück, um anzuzeigen, ob das Löschen erfolgreich war.
            gib dies zurück.items.some((v, i) => {
                wenn(v === Wert){
                    diese.items.splice(i,1)
                    returniere wahr
                }
                return false
            })
        },
        hat: Funktion (Wert) {
            //Gibt einen Booleschen Wert zurück, der angibt, ob der Wert ein Mitglied des Sets ist.
            gib this.items.some(v => v === Wert) zurück
        },
        Werte: Funktion () {
            gib diese.Artikel zurück
        },
    }

    Set zurückgeben;
}());

Funktion wiederholen(str, n) {
    lass res = '';
    während(n) {
        wenn(n % 2 === 1) {
            res += str;
        }
        wenn(n > 1) {
            str += str;
        }
        n >>= 1;
    }
    Rückgabewert
};
//wiederholen('123',3) ==> 123123123

Funktion dateFormater(formater, t){
    lass Datum = t? neues Datum(t) : neues Datum(),
        Y = date.getFullYear() + '',
        M = date.getMonth() + 1,
        D = datum.getDate(),
        H = date.getHours(),
        m = date.getMinutes(),
        s = date.getSeconds();
    Rückgabeformatierer.Ersetzen(/JJJJ|jjjj/g,J)
        .ersetzen(/YY|yy/g,Y.substr(2,2))
        .replace(/MM/g,(M<10?'0':'') + M)
        .ersetzen(/DD/g,(D<10?'0':'') + D)
        .replace(/HH|hh/g,(H<10?'0':'') + H)
        .replace(/mm/g,(m<10?'0':'') + m)
        .replace(/ss/g,(s<10?'0':'') + s)
}
// dateFormater('JJJJ-MM-TT HH:mm', t) ==> 2019-06-26 18:30
// dateFormater('JJJJMMTTHHmm', t) ==> 201906261830

Funktion dateStrForma(str, von, bis){
    //'20190626' 'JJJJMMTT' 'JJJJ Jahr MM Monat TT Tag'
    str += ''
    sei Y = ''
    wenn(~(Y = von.indexOf('YYYY'))){
        Y = str.substr(Y, 4)
        zu = zu.ersetzen(/JJJJ|jjjj/g,J)
    }sonst wenn(~(Y = from.indexOf('YY'))){
        Y = str.substr(Y, 2)
        zu = zu.ersetzen(/YY|yy/g,Y)
    }

    sei k,i
    ['M','D','H','h','m','s'].fürEach(s => {
        i = von.indexOf(s+s)
        k = ~i ? str.substr(i, 2) : ''
        zu = zu.ersetzen(s+s, k)
    })
    zurück zu
}
// dateStrForma('20190626', 'JJJJMMTT', 'JJJJ Jahr MM Monat TT Tag') ==> 26. Juni 2019 // dateStrForma('121220190626', '----JJJJMMTT', 'JJJJ Jahr MM Monat TT Tag') ==> 26. Juni 2019 // dateStrForma('20190626', 'JJJJ Jahr MM Monat TT Tag', 'JJJJMMTT') ==> 20190626

// Sie können hierfür auch reguläre Ausdrücke verwenden //'2019-06-26'.replace(/(\d{4})year(\d{2})month(\d{2})day/, '$1-$2-$3') ==> 2019-06-26

Funktion getPropByPath(Objekt, Pfad, strikt) {
      lass tempObj = obj;
      Pfad = Pfad.Ersetzen(/\[(\w+)\]/g, '.$1'); //Konvertiere [0] in .0
      Pfad = Pfad.replace(/^\./, ''); //Entfernen Sie das führende .

      let keyArr = path.split('.'); // Schneiden gemäß . let i = 0;
      für (let len ​​= keyArr.length; i < len - 1; ++i) {
        wenn (!tempObj && !strict) abbrechen;
        sei Schlüssel = SchlüsselArr[i];
        if (Schlüssel in tempObj) {
            tempObj = tempObj[Schlüssel];
        } anders {
            if (strict) {//Strict-Modus einschalten, kein entsprechender Schlüsselwert gefunden, einen Fehler ausgeben throw new Error('bitte übertrage dem Formularelement einen gültigen Prop-Pfad!');
            }
            brechen;
        }
      }
      zurückkehren {
        o: tempObj, //Originaldaten k: keyArr[i], //Schlüsselwert v: tempObj ? tempObj[keyArr[i]] : null //Wert, der dem Schlüsselwert entspricht};
};

Funktion GetUrlParam(){
    Lassen Sie URL = document.location.toString();
    Lassen Sie arrObj = url.split("?");
    let params = Objekt.erstellen(null)
    wenn (arrObj.length > 1){
        arrObj = arrObj[1].split("&");
        arrObj.fürJeden(item=>{
            Artikel = Artikel.split("=");
            Parameter[Element[0]] = Element[1]
        })
    }
    Rückgabeparameter;
}
// ?a=1&b=2&c=3 ==> {a: "1", b: "2", c: "3"}

Funktion downloadFile(Dateiname, Daten) {
    let DownloadLink = document.createElement('a');
    wenn (DownloadLink) {
        Dokument.body.appendChild(DownloadLink);
        DownloadLink.style = 'Anzeige: keine';
        DownloadLink.download = Dateiname;
        DownloadLink.href = Daten;
        wenn (Dokument.Ereignis erstellen) {
            let DownloadEvt = document.createEvent('Mausereignisse');
            DownloadEvt.initEvent('klicken', wahr, falsch);
            DownloadLink.dispatchEvent(DownloadEvt);
        } sonst wenn (Dokument.createEventObject) {
            DownloadLink.fireEvent('beimKlick');
        } sonst wenn (Typ von DownloadLink.onclick == 'Funktion') {
            DownloadLink.onclick();
        }
        Dokument.body.removeChild(DownloadLink);
    }
}

Funktion toFullScreen() {
    lass elem = Dokument.Body;
    elem.webkitRequestFullScreen
    ? elem.webkitRequestFullScreen()
    : elem.mozRequestFullScreen
    ? elem.mozRequestFullScreen()
    : elem.msRequestFullscreen
    ? elem.msRequestFullscreen()
    : elem.requestFullScreen
    ? elem.requestFullScreen()
    : alert("Der Browser unterstützt keinen Vollbildmodus");
}

Funktion exitFullscreen() {
    let elem = übergeordnetes Dokument;
    elem.webkitAbbrechenVollbild
    ? elem.webkitCancelFullScreen()
    : elem.mozAbbrechenVollbild
    ? elem.mozCancelFullScreen()
    : elem.cancelFullScreen
    ? elem.cancelFullScreen()
    :elem.msExitFullscreen
    ? elem.msExitFullscreen()
    : elem.exitFullscreen
    ? elem.exitFullscreen()
    : alert("Wechseln ist fehlgeschlagen. Versuchen Sie, durch Drücken von Esc zu beenden");
}

Fenster.RequestAnimationFrame = Fenster.RequestAnimationFrame ||
    Fenster.webkitRequestAnimationFrame ||
    window.mozRequestAnimationFrame ||
    fenster.msRequestAnimationFrame ||
    Fenster.oRequestAnimationFrame ||
    Funktion (Rückruf) {
        //Um setTimeout so nah wie möglich an 60 Bilder pro Sekunde zu bringen, window.setTimeout(callback, 1000 / 60);
    }
window.cancelAnimationFrame = window.cancelAnimationFrame ||
    window.webkitAnimationFrame abbrechen ||
    window.mozAnimationFrame abbrechen ||
    Fenster.msCancelAnimationFrame ||
    window.oAnimationFrame abbrechen ||
    Funktion (ID) {
        //Um setTimeout so nah wie möglich an 60 Bilder pro Sekunde zu bringen window.clearTimeout(id);
    }

Funktion _isNaN(v){
    zurückgeben !(Typ von v === 'Zeichenfolge' || Typ von v === 'Zahl') || istNaN(v)
}

Funktion max(arr){
    arr = arr.filter(Element => !_isNaN(Element))
    gibt arr.length zurück? Math.max.apply(null, arr) : undefiniert
}
//max([1, 2, '11', null, 'fdf', []]) ==> 11

Funktion min(arr){
    arr = arr.filter(Element => !_isNaN(Element))
    gibt arr.length zurück? Math.min.apply(null, arr) : undefiniert
}
//min([1, 2, '11', null, 'fdf', []]) ==> 1

Funktion random(unterer, oberer) {
    niedriger = +niedriger || 0
    oben = +oben || 0
    return Math.random() * (oberer - unterer) + unterer;
}
//zufällig(0, 0,5) ==> 0,3567039135734613
//zufällig(2, 1) ===> 1,6718418553475423
//zufällig(-2, -1) ==> -1,4474325452361945

Objekt.Tasten = Objekt.Tasten || Funktionstasten(Objekt) {
    wenn (Objekt === null || Objekt === undefiniert) {
        throw new TypeError('Undefined oder null kann nicht in Objekt konvertiert werden');
    }
    lass Ergebnis = [];
    wenn (istArrayLike(Objekt) || istPlainObject(Objekt)) {
        für (let-Schlüssel im Objekt) {
            Objekt.hasOwnProperty(Schlüssel) && (Ergebnis.push(Schlüssel))
        }
    }
    Ergebnis zurückgeben;
}

Objekt.Werte = Objekt.Werte || Funktion Werte(Objekt) {
    wenn (Objekt === null || Objekt === undefiniert) {
        throw new TypeError('Undefined oder null kann nicht in Objekt konvertiert werden');
    }
    lass Ergebnis = [];
    wenn (istArrayLike(Objekt) || istPlainObject(Objekt)) {
        für (let-Schlüssel im Objekt) {
            Objekt.hasOwnProperty(Schlüssel) && (Ergebnis.push(Objekt[Schlüssel]))
        }
    }
    Ergebnis zurückgeben;
}

Array.prototype.fill = Array.prototype.fill || Funktion füllen(Wert, Start, Ende) {
    lass ctx = dies
    lass Länge = ctx.Länge;

    start = parseInt(start)
    wenn (isNaN(start)) {
        Start = 0
    }sonst wenn (Start < 0) {
        Start = -Start > Länge? 0: (Länge + Start);
      }

      Ende = parseInt(Ende)
      wenn(isNaN(Ende) || Ende > Länge){
          Ende = Länge
      }sonst wenn (Ende < 0) {
        Ende += Länge;
    }

    während (Start < Ende) {
        ctx[start++] = Wert;
    }
    ctx zurückgeben;
}
//Array(3).fill(2) ===> [2, 2, 2]

Array.prototype.includes = Array.prototype.includes || Funktion umfasst(Wert, Start) {
    lass ctx = dies;
    lass Länge = ctx.Länge;
    start = parseInt(start)
    wenn(istNaN(Start)) {
        Start = 0
    } sonst wenn (Start < 0) {
        Start = -Start > Länge? 0: (Länge + Start);
    }
    let index = ctx.indexOf(Wert);
    Rückgabeindex >= Start;
}

Array.prototype.find = Array.prototype.find || Funktion find(fn, ctx) {
    ctx = ctx || dies;
    lass resultieren;
    ctx.some((Wert, Index, arr), dieserWert) => {
        returniere fn(Wert, Index, arr) ? (Ergebnis = Wert, wahr) : falsch
    })
    Ergebnis zurückgeben
}

Array.prototype.findIndex = Array.prototype.findIndex || Funktion findIndex(fn, ctx){
    ctx = ctx || dies

    lass resultieren;
    ctx.some((Wert, Index, arr), dieserWert) => {
        returniere fn(Wert, Index, arr) ? (Ergebnis = Index, wahr) : falsch
    })

    Ergebnis zurückgeben
}

fenster.onload = funktion() {
    setzeTimeout(Funktion() {
        sei t = Leistung.Timing;
        console.log('DNS-Abfragezeit:' + (t.domainLookupEnd - t.domainLookupStart).toFixed(0))
        console.log('TCP-Verbindungszeit:' + (t.connectEnd - t.connectStart).toFixed(0))
        console.log('Anforderungsanforderungszeit:' + (t.responseEnd - t.responseStart).toFixed(0))
        console.log('Zeitaufwand für das Parsen des DOM-Baums:' + (t.domComplete - t.domInteractive).toFixed(0))
        console.log('Zeit des weißen Bildschirms:' + (t.responseStart - t.navigationStart).toFixed(0))
        console.log('domready-Zeit: ' + (t.domContentLoadedEventEnd - t.navigationStart).toFixed(0))
        console.log('Ladezeit: ' + (t.loadEventEnd - t.navigationStart).toFixed(0))
        wenn (t = Leistung.Speicher) {
            console.log('Prozentsatz der js-Speichernutzung:' + (t.usedJSHeapSize / t.totalJSHeapSize * 100).toFixed(2) + '%')
        }
    })
}

document.addEventListener('Taste gedrückt', Funktion(Ereignis) {
    zurückkehren !(
        112 == event.keyCode || //F1 deaktivieren
        123 == event.keyCode || //F12 deaktivieren
        event.ctrlKey && 82 == event.keyCode || //Strg+R deaktivieren
        event.ctrlKey && 18 == event.keyCode || //Strg+N deaktivieren
        event.shiftKey && 121 == event.keyCode || //Umschalt+F10 deaktivieren
        event.altKey && 115 == event.keyCode || //Alt+F4 deaktivieren
        "A" == event.srcElement.tagName && event.shiftKey //Umschalt+Klick auf Tag a deaktivieren || (event.returnValue = false)
});

['Kontextmenü', 'SelectStart', 'Kopieren'].forEach(Funktion(ev) {
    document.addEventListener(ev, Funktion(Ereignis) {
        Rückgabeereignis. Rückgabewert = false;
    })
});

Funktion numAdd(num1, num2) {
    sei Basisnummer, Basisnummer1, Basisnummer2;
    versuchen {
        baseNum1 = num1.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer1 = 0;
    }
    versuchen {
        baseNum2 = num2.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer2 = 0;
    }
    Basiszahl = Math.pow(10, Math.max(Basiszahl1, Basiszahl2));
    return (Zahl1 * Basiszahl + Zahl2 * Basiszahl) / Basiszahl;
};

Funktion numSub(num1, num2) {
    sei Basisnummer, Basisnummer1, Basisnummer2;
    let precision; // Präzision try {
        baseNum1 = num1.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer1 = 0;
    }
    versuchen {
        baseNum2 = num2.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer2 = 0;
    }
    Basiszahl = Math.pow(10, Math.max(Basiszahl1, Basiszahl2));
    Präzision = (Basiszahl1 >= Basiszahl2) ? Basiszahl1 : Basiszahl2;
    return ((Zahl1 * Basiszahl - Zahl2 * Basiszahl) / Basiszahl).toFixed(Präzision);
};

Funktion numMulti(num1, num2) {
    sei Basisnummer = 0;
    versuchen {
        Basisnummer += Nummer1.toString().split(".")[1].Länge;
    } fangen (e) {
    }
    versuchen {
        Basisnummer += Nummer2.toString().split(".")[1].Länge;
    } fangen (e) {
    }
    returniere Zahl(Zahl1.toString().replace(".", "")) * Zahl(Zahl2.toString().replace(".", "")) / Math.pow(10, Basiszahl);
};

Funktion numDiv(num1, num2) {
    sei baseNum1 = 0, baseNum2 = 0;
    sei Basisnummer3, Basisnummer4;
    versuchen {
        baseNum1 = num1.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer1 = 0;
    }
    versuchen {
        baseNum2 = num2.toString().split(".")[1].Länge;
    } fangen (e) {
        Basisnummer2 = 0;
    }
    mit (Mathe) {
        baseNum3 = Zahl(num1.toString().replace(".", ""));
        baseNum4 = Zahl(num2.toString().replace(".", ""));
        return (Basiszahl3 / Basiszahl4) * pow(10, Basiszahl2 - Basiszahl1);
    }
};