Allgemeine Front-End-JavaScript-Methodenkapselung

Funktionstyp(Absatz) {
    gibt Object.prototype.toString.call(para) zurück
}

Funktion unique1(arr) {
    zurückgeben [...neues Set(arr)]
}

Funktion unique2(arr) {
    var obj = {};
    return arr.filter(ele => {
        wenn (!obj[ele]) {
            obj[ele] = true;
            gibt true zurück;
        }
    })
}

Funktion unique3(arr) {
    var Ergebnis = [];
    arr.fürEach(ele => {
        wenn (Ergebnis.indexOf(ele) == -1) {
            Ergebnis.push(Element)
        }
    })
    Ergebnis zurückgeben;
}

String.prototype.unique = Funktion () {
    var obj = {},
        str = '',
        len = diese.Länge;
    für (var i = 0; i < len; i++) {
        wenn (!obj[dies[i]]) {
            str += dies[i];
            obj[dies[i]] = wahr;
        }
    }
    gibt str zurück;
}

###### //Aufeinanderfolgende Zeichenfolgen entfernen function uniq(str) {
    return str.replace(/(\w)\1+/g, '$1')
}

//Deep Clone (Deep Clone berücksichtigt keine Funktion)
Funktion deepClone(Objekt, Ergebnis) {
    var Ergebnis = Ergebnis || {};
    für (var prop in obj) {
        wenn (obj.hasOwnProperty(prop)) {
            wenn (Typ von Objekt[Eigenschaft] == ​​'Objekt' und Objekt[Eigenschaft] !== null) {
                // Referenzwert (Objekt/Array) und nicht null
                wenn (Object.prototype.toString.call(obj[prop]) == '[Objekt Objekt]') {
                    // Objektergebnis[Eigenschaft] = {};
                } anders {
                    // Array-Ergebnis[Eigenschaft] = [];
                }
                deepClone(Objekt[Eigenschaft], Ergebnis[Eigenschaft])
    } anders {
        // Ursprünglicher Wert oder Funktion
        Ergebnis[Eigenschaft] = Objekt[Eigenschaft]
    }
  }
}
Ergebnis zurückgeben;
}

// Tiefes und flaches Klonen dient der Referenzwertfunktion deepClone(target) {
    wenn (Typ von (Ziel) !== 'Objekt') {
        Rücklaufziel;
    }
    var Ergebnis;
    wenn (Object.prototype.toString.call(target) == '[Objekt-Array]') {
        // Array-Ergebnis = []
    } anders {
        // Objektergebnis = {};
    }
    für (var prop in Ziel) {
        wenn (Ziel.hasOwnProperty(Eigenschaft)) {
            Ergebnis[Eigenschaft] = deepClone(Ziel[Eigenschaft])
        }
    }
    Ergebnis zurückgeben;
}
// Funktion kann nicht kopiert werden var o1 = jsON.parse(jsON.stringify(obj1));

// Ändere das ursprüngliche Array Array.prototype.myReverse = function () {
    var len = diese.Länge;
    für (var i = 0; i < len; i++) {
        var temp = dies[i];
        dies[i] = dies[Länge - 1 - i];
        dies[Länge - 1 - i] = temp;
    }
    gib dies zurück;
}

Funktion erben(Ziel, Ursprung) {
    Funktion F() {};
    F.Prototyp = Herkunft.Prototyp;
    Ziel.Prototyp = neues F();
    Ziel.prototype.constructor = Ziel;
    // Der endgültige Prototyp verweist auf Target.prop.uber = Origin.prototype;
}

String.prototype.firstAppear = Funktion () {
    var obj = {},
        len = diese.Länge;
    für (var i = 0; i < len; i++) {
        wenn (Objekt[dieses[i]]) {
            obj[dieses[i]]++;
        } anders {
            obj[dieses[i]] = 1;
        }
    }
    für (var prop in obj) {
       wenn (Objekt[Eigenschaft] == ​​1) {
         Rücklaufstütze;
       }
    }
}

Funktion Eltern(ele, n) {
    während (Element && n) {
        ele = ele.übergeordnetesElement ? ele.übergeordnetesElement : ele.übergeordneterKnoten;
        N--;
    }
    Rückgabeelement;
}

Funktion retSibling(e, n) {
    während (e && n) {
        wenn (n > 0) {
            wenn (e.nächstesElementGeschwister) {
                e = e.nächstesElementGeschwister;
            } anders {
                für (e = e.nextSibling; e und e.nodeType !== 1; e = e.nextSibling);
            }
            N--;
        } anders {
            if (e.vorherigesElementGeschwister) {
                e = e.vorherigesElementGeschwister;
            } anders {
                für (e = e.vorherigesElementGeschwister; e und e.Knotentyp !== 1; e = e.vorherigesElementGeschwister);
            }
            n++;
        }
    }
    Rückkehr e;
}

Funktion meineKinder(e) {
    var Kinder = e.childNodes,
        arr = [],
        len = Kinder.Länge;
    für (var i = 0; i < len; i++) {
        wenn (Kinder[i].nodeType === 1) {
            arr.push(Kinder[i])
        }
    }
    Rückflug an;
}

Funktion hatKinder(e) {
    var Kinder = e.childNodes,
        len = Kinder.Länge;
    für (var i = 0; i < len; i++) {
        wenn (Kinder[i].nodeType === 1) {
            gibt true zurück;
        }
    }
    gibt false zurück;
}

Element.prototype.insertAfter = Funktion (Ziel, Elen) {
    var nextElen = elen.nextElenmentSibling;
    if (nextElen == null) {
        dies.appendChild(Ziel);
    } anders {
        dies.insertBefore(Ziel, nächstesElen);
    }
}

Funktion getDateTime() {
    var Datum = neues Datum(),
        Jahr = Datum.getFullYear(),
        Monat = Datum.getMonth() + 1,
        Tag = Datum.getDate(),
        Stunde = Datum.getHours() + 1,
        Minute = Datum.getMinutes(),
        Sekunde = Datum.getSeconds();
        Monat = Prüfzeit(Monat);
        Tag = Prüfzeit(Tag);
        Stunde = Prüfzeit(Stunde);
        Minute = Prüfzeit(Minute);
        Sekunde = Prüfzeit(Sekunde);
     Funktion checkTime(i) {
        wenn (i < 10) {
                i = "0" + i;
       }
      gebe ich zurück;
    }
    return "" + Jahr + "Jahr" + Monat + "Monat" + Tag + "Tag" + Stunde + "Stunde" + Minute + "Minute" + Sekunde + "Sekunde"
}

Funktion getScrollOffset() {
wenn (Fenster.SeiteXOffset) {
zurückkehren {
x: Fenster.SeitenXOffset,
y: Fenster.SeitenYOffset
}
} anders {
zurückkehren {
x: Dokument.Body.ScrollLeft + Dokument.DocumentElement.ScrollLeft,
y: Dokument.Body.ScrollTop + Dokument.DocumentElement.ScrollTop
}
}
}

Funktion getViewportOffset() {
    if (Fenster.innereBreite) {
        zurückkehren {
            w: Fenster.Innenbreite,
            h: Fenster.Innenhöhe
        }
    } anders {
        // IE8 und darunter if (document.compatMode === "BackCompat") {
            // Quirks-Modus return {
                w: Dokument.Body.Clientbreite,
                h: Dokument.Body.ClientHöhe
            }
        } anders {
            // Standardmodus return {
                w: Dokument.Dokumentelement.Clientbreite,
                h: Dokument.Dokumentelement.Clienthöhe
            }
        }
    }
}

Funktion getStyle(elem, prop) {
    window.getComputedStyle zurückgeben ? window.getComputedStyle(elem, null)[prop] : elem.currentStyle[prop]
}

Funktion addEvent(Element, Typ, Handle) {
    if (elem.addEventListener) { //nicht-IE und nicht-IE9
        elem.addEventListener(Typ, Handle, falsch);
    } sonst wenn (elem.attachEvent) { //ie6 nach ie8
        elem.attachEvent('on' + Typ, Funktion () {
            handle.call(Element);
        })
    } anders {
        Element['ein' + Typ] = Griff;
    }
}

Funktion removeEvent(Element, Typ, Handle) {
    if (elem.removeEventListener) { //nicht-IE und nicht-IE9
        elem.removeEventListener(Typ, Handle, falsch);
    } sonst wenn (elem.detachEvent) { //ie6 nach ie8
        elem.detachEvent('on' + Typ, Handle);
    } anders {
        elem['on' + Typ] = null;
    }
}

Funktion stopBubble(e) {
    wenn (e && e.stopPropagation) {
        e.stopPropagation();
    } anders {
        Fenster.Ereignis.AbbrechenBubble = wahr;
    }
}

Funktion istPalina(str) {
    wenn (Object.prototype.toString.call(str) !== '[Objekt String]') {
        gibt false zurück;
    }
    var len = str.länge;
    für (var i = 0; i < len / 2; i++) {
        wenn (str[i] != str[len - 1 - i]) {
            gibt false zurück;
        }
    }
    gibt true zurück;
}

Funktion istPalindrom(str) {
    str = str.replace(/\W/g, '').toLowerCase();
    console.log(str)
    Rückgabewert (str == str.split('').reverse().join(''))
}

Element.prototype.getElementsByClassName = Document.prototype.getElementsByClassName = Funktion (_className) {
    var allDomArray = document.getElementsByTagName('*');
    var lastDomArray = [];
    Funktion trimSpace(strClass) {
        var reg = /\s+/g;
        returniere strClass.replace(reg, ' ').trim()
    }
    für (var i = 0; i < allDomArray.length; i++) {
        var classArray = trimSpace(allDomArray[i].className).split(' ');
        für (var j = 0; j < classArray.length; j++) {
            wenn (KlassenArray[j] == _KlassenName) {
                letztesDomArray.push(allesDomArray[i]);
                brechen;
            }
        }
    }
    gibt letztesDomArray zurück;
}

Funktion animieren(obj, json, Rückruf) {
    Intervall löschen(Objekt.Timer);
    var Geschwindigkeit,
        aktuell;
    obj.timer = setzeIntervall(Funktion () {
        var lock = true;
        für (var prop in json) {
            wenn (Eigenschaft == 'Deckkraft') {
                aktuell = parseFloat(window.getComputedStyle(obj, null)[prop]) * 100;
            } anders {
                aktuell = parseInt(window.getComputedStyle(obj, null)[prop]);
            }
            Geschwindigkeit = (json[prop] – aktuell) / 7;
            Geschwindigkeit = Geschwindigkeit > 0? Math.ceil(Geschwindigkeit) : Math.floor(Geschwindigkeit);

            wenn (Eigenschaft == 'Deckkraft') {
                obj.style[prop] = (aktuell + Geschwindigkeit) / 100;
            } anders {
                obj.style[prop] = aktuell + Geschwindigkeit + 'px';
            }
            wenn (aktuell != json[Eigenschaft]) {
                Sperre = falsch;
            }
        }
        if (sperren) {
            Intervall löschen(Objekt.Timer);
            Typ des Rückrufs == 'Funktion'? Rückruf(): '';
        }
    }, 30)
}

Funktion ElasticMovement(Objekt, Ziel) {
    Intervall löschen(Objekt.Timer);
    var iSpeed ​​= 40,
        a, u = 0,8;
    obj.timer = setzeIntervall(Funktion () {
        a = (Ziel – Objekt.OffsetLinks) / 8;
        iGeschwindigkeit = iGeschwindigkeit + a;
        iGeschwindigkeit = iGeschwindigkeit * u;
        wenn (Math.abs(iSpeed) <= 1 und Math.abs(a) <= 1) {
            console.log('über')
            Intervall löschen(Objekt.Timer);
            obj.style.left = Ziel + "px";
        } anders {
            obj.style.left = obj.offsetLeft + iSpeed ​​​​+ 'px';
        }
    }, 30);
}

Array.prototype.myForEach = Funktion (Funktion, Objekt) {
    var len = diese.Länge;
    var _this = Argumente[1]? Argumente[1] : Fenster;
    // var _this=Argumente[1]||Fenster;
    für (var i = 0; i < len; i++) {
        func.call(_dies, dies[i], ich, dies)
    }
}

Array.prototype.myFilter = Funktion (Funktion, Objekt) {
    var len = diese.Länge;
    var arr = [];
    var _this = Argumente[1] || Fenster;
    für (var i = 0; i < len; i++) {
        func.call(_dies, dies[i], i, dies) und arr.push(dies[i]);
    }
    Rückflug an;
}

Array.prototype.myMap = Funktion (func) {
    var arr = [];
    var len = diese.Länge;
    var _this = Argumente[1] || Fenster;
    für (var i = 0; i < len; i++) {
        arr.push(func.call(_dies, dies[i], i, dies));
    }
    Rückflug an;
}

Array.prototype.myEvery = Funktion (func) {
    varflag = wahr;
    var len = diese.Länge;
    var _this = Argumente[1] || Fenster;
    für (var i = 0; i < len; i++) {
        wenn (func.apply(_this, [this[i], i, this]) == false) {
            Flagge = falsch;
            brechen;
        }
    }
    Flagge zurückgeben;
}

Array.prototype.myReduce = Funktion (Funktion, Anfangswert) {
    var len = diese.Länge,
        nächsterWert,
        ich;
    wenn (!initialValue) {
        // Kein zweiter Parameter übergeben nextValue = this[0];
        ich = 1;
    } anders {
        // Übergeben Sie den zweiten Parameter nextValue = initialValue;
        ich = 0;
    }
    für (; i < len; i++) {
        nächsterWert = func(nächsterWert, dieser[i], i, dieser);
    }
    gib den nächsten Wert zurück;
}

Funktion getWindonHref() {
    var sHref = Fenster.Standort.href;
    var args = sHref.split('?');
    wenn (args[0] === sHref) {
        zurückkehren '';
    }
    var hrefarr = args[1].split('#')[0].split('&');
    var obj = {};
    für (var i = 0; i < hrefarr.length; i++) {
        hrefarr[i] = hrefarr[i].split('=');
        obj[hrefarr[i][0]] = hrefarr[i][1];
    }
    gibt Objekt zurück;
}

// Schnelle Sortierung [links] + min + [rechts]
Funktion quickArr(arr) {
    wenn (arr.Länge <= 1) {
        Rückflug an;
    }
    var links = [],
        rechts = [];
    var pIndex = Math.floor(arr.length / 2);
    var p = arr.splice(pIndex, 1)[0];
    für (var i = 0; i < arr.length; i++) {
        wenn (arr[i] <= p) {
            links.drücken(arr[i]);
        } anders {
            rechts.drücken(arr[i]);
        }
    }
    // Rekursion return quickArr(links).concat([p], quickArr(rechts));
}

// Blasenfunktion bubbleSort(arr) {
    für (var i = 0; i < arr.length - 1; i++) {
        für (var j = i + 1; j < arr.length; j++) {
            wenn (arr[i] > arr[j]) {
                var temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    Rückflug an;
}

Funktion bubbleSort(arr) {
    var len = arr.Länge;
    für (var i = 0; i < len - 1; i++) {
        für (var j = 0; j < len - 1 - i; j++) {
            wenn (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    Rückflug an;
}

Funktion traverse(Element, Rückruf) {
    Rückruf(Element);
    var Liste = Element.Kinder;
    für (var i = 0; i < Liste.Länge; i++) {
        durchqueren(Liste[i], Rückruf);
    }
}

Funktion Ajax (Methode, URL, Rückruf, Daten, Flag) {
    var xhr;
    flag = Flagge || wahr;
    Methode = Methode.toUpperCase();
    wenn (Fenster.XMLHttpRequest) {
        xhr = neue XMLHttpRequest();
    } anders {
        xhr = neues ActiveXObject('Microsoft.XMLHttp');
    }
    xhr.onreadystatechange = Funktion () {
        wenn (xhr.readyState == 4 und xhr.status == 200) {
            console.log(2)
            Rückruf(xhr.responseText);
        }
    }

    wenn (Methode == 'GET') {
        var Datum = neues Datum(),
        Timer = Datum.getTime();
        xhr.open('GET', URL + '?' + Daten + '&Timer' + Timer, Flagge);
        xhr.senden()
        } sonst wenn (Methode == 'POST') {
        xhr.open('POST', URL, Flagge);
        xhr.setRequestHeader('Inhaltstyp', 'Anwendung/x-www-form-urlencoded');
        xhr.senden(Daten);
    }
}

Funktion loadScript(URL, Rückruf) {
    var oscript = document.createElement('Skript');
    if (oscript.readyState) { // IE8 und darunter oscript.onreadystatechange = function () {
            if (oscript.readyState === 'abgeschlossen' || oscript.readyState === 'geladen') {
                Rückruf();
            }
        }
    } anders {
        oscript.onload = Funktion () {
            Rückruf()
        };
    }
    oscript.src = URL;
    Dokument.body.appendChild(oscript);
}

var cookie = {
    set: Funktion (Name, Wert, Zeit) {
        document.cookie = Name + '=' + Wert + '; max-age=' + Zeit;
        gib dies zurück;
    },
    entfernen: Funktion (Name) {
        gib dies zurück.setCookie(name, '', -1);
    },
    get: Funktion (Name, Rückruf) {
        var allCookieArr = document.cookie.split('; ');
        für (var i = 0; i < allCookieArr.length; i++) {
            var itemCookieArr = allCookieArr[i].split('=');
            wenn (itemCookieArr[0] === Name) {
                Rückgabewert itemCookieArr[1]
            }
        }
        Rückgabe undefiniert;
    }
}

Function.prototype.myBind = Funktion (Ziel) {
    var Ziel = Ziel || Fenster;
    var _args1 = [].slice.call(arguments, 1);
    var selbst = dies;
    var temp = Funktion () {};
    var F = Funktion () {
        var _args2 = [].slice.call(arguments, 0);
        var parasArr = _args1.concat(_args2);
        returniere self.apply(diese Instanz von temp? dies: Ziel, parasArr)
    }
    temp.prototyp = selbst.prototyp;
    F.prototype = neues Temp();
    Rückgabe F;
}

Funktion.prototype.myCall = Funktion () {
    var ctx = Argumente[0] || Fenster;
    ctx.fn = dies;
    var args = [];
    für (var i = 1; i < Argumente.Länge; i++) {
        args.push(Argumente[i])
    }
    var Ergebnis = ctx.fn(...args);
    ctx.fn löschen;
    Ergebnis zurückgeben;
}

Funktion.prototype.myApply = Funktion () {
    var ctx = Argumente[0] || Fenster;
    ctx.fn = dies;
    wenn (!Argumente[1]) {
        var Ergebnis = ctx.fn();
        ctx.fn löschen;
        Ergebnis zurückgeben;
    }
    var Ergebnis = ctx.fn(...Argumente[1]);
    ctx.fn löschen;
    Ergebnis zurückgeben;
}

Funktion Entprellung(Handle, Verzögerung) {
    var Timer = null;
    Rückgabefunktion () {
        var _self = dies,
            _args = Argumente;
        Zeitüberschreitung löschen(Timer);
        Timer = setzeTimeout(Funktion () {
            handle.anwenden(_self, _args)
        }, Verzögerung)
    }
}

Funktion Drosselklappe(Handler, warten) {
    var letzteZeit = 0;
    Rückgabefunktion (e) {
        var jetztTime = neues Date().getTime();
        if (jetztZeit - letzteZeit > warte) {
            handler.apply(diese, Argumente);
            letzteZeit = aktuelleZeit;
        }
    }
}

fenster.requestAnimFrame = (funktion () {
    gibt window.requestAnimationFrame zurück ||
        Fenster.webkitRequestAnimationFrame ||
        window.mozRequestAnimationFrame ||
        Funktion (Rückruf) {
            window.setTimeout(Rückruf, 1000 / 60);
        };
})();

fenster.cancelAnimFrame = (funktion () {
    Fenster zurückgeben.AnimationsFrame abbrechen ||
        window.webkitAnimationFrame abbrechen ||
        window.mozAnimationFrame abbrechen ||
        Funktion (ID) {
            Fenster.ClearTimeout(id);
        };
})();

Funktion jsonp(URL, Rückruf) {
    var oscript = document.createElement('Skript');
    if (oscript.readyState) { // IE8 und darunter oscript.onreadystatechange = function () {
            if (oscript.readyState === 'abgeschlossen' || oscript.readyState === 'geladen') {
                Rückruf();
            }
        }
    } anders {
        oscript.onload = Funktion () {
            Rückruf()
        };
    }
    oscript.src = URL;
    Dokument.body.appendChild(oscript);
}

Funktion getUrlParam(sUrl, sKey) {
    var Ergebnis = {};
    sUrl.replace(/(\w+)=(\w+)(?=[&|#])/g, Funktion (Element, Schlüssel, Wert) {
        wenn (!Ergebnis[Schlüssel]) {
            Ergebnis[Schlüssel] = Wert;
        } anders {
            var temp = Ergebnis[Schlüssel];
            Ergebnis[Schlüssel] = [].concat(temp, val);
        }
    })
    wenn (!sSchlüssel) {
        Ergebnis zurückgeben;
    } anders {
        Ergebnis zurückgeben[sKey] || '';
    }
}

Funktion formatDate(t, str) {
    var obj = {
        yyyy: t.getFullYear(),
        yy: ("" + t.getFullYear()).slice(-2),
        M: t.getMonth() + 1,
        MM: ("0" + (t.getMonth() + 1)).slice(-2),
        d: t.getDate(),
        dd: ("0" + t.getDate()).slice(-2),
        H: t.getHours(),
        HH: ("0" + t.getHours()).slice(-2),
        h: t.getHours() % 12,
        hh: ("0" + t.getHours() % 12).slice(-2),
        m: t.getMinutes(),
        mm: ("0" + t.getMinutes()).slice(-2),
        s: t.getSeconds(),
        ss: ("0" + t.getSeconds()).slice(-2),
        w: ['日', 'MON', 'TU', 'MI', 'DO', 'FR', 'SA'][t.getDay()]
    };
    return str.replace(/([az]+)/ig, Funktion ($1) {
        Rückgabeobjekt [$1]
    });
}

Funktion istVerfügbareE-Mail(sE-Mail) {
    var reg = /^([\w+\.])+@\w+([.]\w+)+$/
    returniere reg.test(sEmail)
}

Funktion curryIt(fn) {
    var Länge = fn.Länge,
        Argumente = [];
    var Ergebnis = Funktion (Argument) {
        args.push(arg);
        Länge--;
        wenn (Länge <= 0) {
            gibt fn.apply(diese, args) zurück;
        } anders {
            Ergebnis zurückgeben;
        }
    }
    Ergebnis zurückgeben;
}

Funktion SummeGroßeZahl(a, b) {
    var res = '', // Ergebnis temp = 0; // Ergebnis der bitweisen Addition und Übertrag a = a.split('');
    b = b.split('');
    während (a.Länge || b.Länge || temp) {
        //~~Bitweises NICHT 1. Typkonvertierung, konvertiert in Zahl 2.~~undefined==0 
        temp += ~~a.pop() + ~~b.pop();
        res = (Temp % 10) + res;
        Temperatur = Temperatur > 9;
    }
    gibt res.replace(/^0+/, '') zurück;
}

Funktion getSingle(Funktion) {
    var Ergebnis;
    Rückgabefunktion () {
        wenn (!Ergebnis) {
            Ergebnis = neue Funktion (Argumente);
        }
        Ergebnis zurückgeben;
    }
}