简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
Heim
Artikel
Fragen und Antworten
Kurs
Thema
Herunterladen
Spiel
Wörterbuch
kürzliche Updates

Heim  >  Artikel  >  Web-Frontend  >  Quellcode-Recherche zum JS-Framework

Quellcode-Recherche zum JS-Framework

巴扎黑
巴扎黑Original
2017-08-10 13:21:301455Durchsuche

[Einführung] Underscore js-Quellcode Underscore js erweitert das native JavaScript-Objekt nicht, sondern kapselt es durch Aufrufen der _()-Methode. Sobald die Kapselung abgeschlossen ist, wird das native JavaScript-Objekt zu einem Underscore-Objekt. Bestimmen Sie, ob eine bestimmte Variable ein Objekt ist. Ist

underscore.js Quellcode

Underscore.js erweitert das native JavaScript-Objekt nicht, sondern kapselt es durch Aufrufen der _()-Methode. Sobald die Kapselung abgeschlossen ist, wird das native JavaScript-Objekt zu einem Underscore-Objekt.

Beurteilen Sie, ob die gegebene Variable ein Objekt ist

// Is a given variable an object?
    _.isObject = function(obj) {        var type = typeof obj;        return type === 'function' || type === 'object' && !!obj;
    };

Dies ist ein Quellcode für underscore.js, um zu beurteilen, ob die gegebene Variable object ist. Wir wissen, dass typeof die folgenden sechs Werte zurückgibt: 

1. 'undefined' --- 这个值未定义；2. 'boolean'    --- 这个值是布尔值；3. 'string'        --- 这个值是字符串；4. 'number'     --- 这个值是数值；5. 'object'       --- 这个值是对象或null；6. 'function'    --- 这个值是函数。

und && hat eine höhere Priorität als ||. !! verhält sich wie Boolean() und wandelt es in einen booleschen Wert um.

Bestimmen Sie, ob der angegebene Wert ein DOM-Element ist 

// Is a given value a DOM element?
    _.isElement = function(obj) {        return !!(obj && obj.nodeType === 1);
    };

In ähnlicher Weise entspricht !! der Rolle von Boolean(), nodeType === 1 gibt an, dass es sich um einen Elementknoten handelt. und das Attribut attr ist 2, Text text ist 3

<body>
    <p id="test">测试</p><script>
    var t = document.getElementById(&#39;test&#39;);
    alert(t.nodeType);//1
    alert(t.nodeName);//p
    alert(t.nodeValue);//null</script></body>

firstChild Attribut 

var t = document.getElementById(&#39;test&#39;).firstChild;
alert(t.nodeType);//3alert(t.nodeName);//#testalert(t.nodeValue);//测试

Der Textknoten wird ebenfalls als Knoten betrachtet, also als untergeordneter Knoten von p ist ein Textknoten, daher werden 3 zurückgegeben Array, gib

zurück, wenn nicht, gib

zurück.

wird verwendet, um zu bestimmen, ob eine Variable eine Instanz eines Objekts ist, wie z. B. 
isArray = Array.isArray ||            function(object){ return object instanceof Array }

Array.isArray() und true gibt auch false

zurück instanceof Gibt einen booleschen Wert zurück. Wenn 

var a= [];
alert(a instanceof Array);//返回 true
ist, wird

zurückgegeben, andernfalls wird das Ergebnis von alert(a instanceof Object) zurückgegeben. true

Datentypbeurteilung

isArrayArray.isArraytrue ist ein leeres Objekt. Tatsächlich wird auf diese Weise ein leeres Objekt ohne Nichts erstellt trueobject instanceof Array

Wir können verwenden die

-Methode zum Bestimmen des Datentyps, zum Beispiel: 

class2type = {},function type(obj) {        return obj == null ? String(obj) :
        class2type[toString.call(obj)] || "object"
    }    function isFunction(value) { return type(value) == "function" }    function isWindow(obj)     { return obj != null && obj == obj.window }    function isDocument(obj)   { return obj != null && obj.nodeType == obj.DOCUMENT_NODE }    function isObject(obj)     { return type(obj) == "object" }

Wenn der Parameter class2type zunächst Object.create(null); oder

ist, dann verwenden Sie

, um ihn in den umzuwandeln entsprechende Originalzeichenfolge „Object.prototype.toString.call()“ oder „

“. 
console.log(Object.prototype.toString.call(123)) //[object Number]  console.log(Object.prototype.toString.call(&#39;123&#39;)) //[object String]    console.log(Object.prototype.toString.call(undefined)) //[object Undefined]                         console.log(Object.prototype.toString.call(true)) //[object Boolean]                                      console.log(Object.prototype.toString.call({})) //[object Object]                                      console.log(Object.prototype.toString.call([])) //[object Array]             console.log(Object.prototype.toString.call(function(){})) //[object Function]

Dann leiht sich obj zunächst die Prototypmethode undefined von null aus, um die Zeichenfolgendarstellung von String(obj) zu erhalten. Der Rückgabewert hat die Form undefined, wobei null der ist interne Objektklasse.

ruft dann die Kleinbuchstabenzeichenfolge ab, die class2type[toString.call(obj)] entspricht, aus dem Objekt Object und gibt sie zurück. Wenn sie nicht abgerufen wird, wird immer „toString() zurückgegeben. obj[object class]get-Methode class

Ermitteln Sie den Wert, der dem angegebenen Index im Satz entspricht. Wenn class2type kleiner als 0 ist, ist [object class] gleich object und

ist die Länge des Satzes .

Vielleicht haben Sie gerade 
get: function(idx){            return idx === undefined ? slice.call(this) : this[idx >= 0 ? idx : idx + this.length]
        },
gesehen. Sie werden sich sehr verwirrt fühlen. Tatsächlich sind nicht nur der Quellcode von

, sondern auch der Quellcode von idx und idx so geschrieben , aber sie haben am Anfang eine Aussage gemacht: idx+lengthlength

Also

ist eigentlich immer noch slice.call(this)zepto.jsjQueryprototype.js Quellcode backbone

var push = array.push;var slice = array.slice;var splice = array.splice;
Weil

hängt von slice.call(this) ab, daher analysieren wir zuerst Letzteres, und Array.slce.call(this) ist das erste. Elemente werden in

-Objekte gekapselt. Die Bedeutung von 

  //为对象添加 class 属性值

   addClassName: function(element, className) {
        element = $(element);
        Element.removeClassName(element, className);
        element.className += &#39; &#39; + className;
    },   //为对象移除 class 属性值

    removeClassName: function(element, className) {
        element = $(element);        if (!element)            return;        var newClassName = &#39;&#39;;        var a = element.className.split(&#39; &#39;);        for (var i = 0; i < a.length; i++) {            if (a[i] != className) {                if (i > 0)
                    newClassName += &#39; &#39;;
                newClassName += a[i];
            }
        }
        element.className = newClassName;
    },
ist, dass das Elementobjekt ist Existiert es nicht, wird es ignoriert und die Ausführung wird nicht fortgesetzt. 🎜>Wenn die leere Zeichenfolge (

) als Trennzeichen verwendet wird, wird jedes Zeichen im Objekt durch addClassName um festzustellen, ob es den Klassenattributwert removeClassName()$()prototypeKompatibel mit älteren Browserversionen hat, fügen Sie die Array-Push-Methode hinzu 

if(!element)  return

Wenn es 
split() 方法用于把一个字符串分割成字符串数组。
ist Dies bedeutet, dass der Browser diese Methode nicht unterstützt und die übergebenen Parameter nacheinander in das Array eingefügt werden und schließlich die Länge des Arrays zurückgegeben werden Auf Objekte kann mit der

-Notation oder "" zugegriffen werden. Ebenso ist der Zugriff auf Array-Elemente

Der jQuery-Quellcode 

//是否拥有 class 属性值hasClassName: function(element, className) {
    element = $(element);    if (!element)        return;    var a = element.className.split(&#39; &#39;);    for (var i = 0; i < a.length; i++) {        if (a[i] == className)            return true;//返回正确的处理结果
    }    return false;//返回错误的处理结果},

hat zu viele Verbindungen und ist daher schwierig Um es separat zu analysieren, geben wir ein oder zwei einfache Beispiele: Die 

/**
 * 为兼容旧版本的浏览器增加 Array 的 push 方法。
 */if (!Array.prototype.push) {    Array.prototype.push = function() {        var startLength = this.length;//this指代Array
        for (var i = 0; i < arguments.length; i++)            this[startLength + i] = arguments[i];//this依旧指代Array
        return this.length;
    }
}
toArray-Methode

!Array.prototype.push truethis[startLength + i] = arguments[i] kann Objekte mit

-Attributen in Arrays konvertieren, das heißt, es ist Der Zweck besteht darin, das Array von

-Objekten zu extrahieren und in Arrays umzuwandeln. Zum Beispiel: (.)[]

Dies ist der gewünschte Basisobjektname

jQueryDies kann man sich als Namensraum für die Instanzmethoden eines Arrays vorstellen

slice
这提取数组的一部分并返回新的数组，并没有开始和结束索引，它只是返回一个数组的拷贝

call
这是一个非常有用的功能，它允许你从一个对象调用一个函数并且使用它在另一个上下文环境

下面的写法是等效的：

Array.prototype.slice.call == [].slice.call

看这个例子：

object1 = {
    name:&#39;frank&#39;,
    greet:function(){
        alert(&#39;hello &#39;+this.name)
    }
};

object2 = {
    name:&#39;trigkit4&#39;};// object2没有greet方法// 但我们可以从object1中借来

 object1.greet.call(object2);//弹出hello trigkit4

分解一下就是object1.greet运行弹出hello + 'this.name'，然后object2对象冒充，this就指代object2

var t = function(){    console.log(this);// String [ "t", "r", "i", "g", "k", "i", "t", "4" ]    console.log(typeof this);  //  Object    console.log(this instanceof String);  // true};
t.call(&#39;trigkit4&#39;);

call(this)指向了所传进去的对象。

在Object.prototype中已经包含了一些方法：

    1.toString ( )

    2.toLocaleString ( )

    3.valueOf ( )

    4.hasOwnProperty (V)

    5.isPrototypeOf (V)

    6.propertyIsEnumerable (V)

on方法

jQuery.fn.extend({
    on: function( types, selector, data, fn, /*INTERNAL*/ one ) {        var type, origFn;        // Types can be a map of types/handlers
        if ( typeof types === "object" ) {            // ( types-Object, selector, data )
            if ( typeof selector !== "string" ) {                // ( types-Object, data )
                data = data || selector;
                selector = undefined;

            }
        }
})


jQuery.extend(object) ：为扩展jQuery类本身.为类添加新的方法。

jQuery.fn.extend(object) ：给jQuery对象添加方法。

!= 在表达式两边的数据类型不一致时,会隐式转换为相同数据类型,然后对值进行比较.
!== 不会进行类型转换,在比较时除了对值进行比较以外，还比较两边的数据类型, 它是恒等运算符===的非形式。

on : function(){} 是js对象字面量的写法

{键:值,键:值}语法中的“健/值”会成为对象的静态成员。如果给某个“健”指定的值是一个匿名函数，那么该函数就会变成对象的静态方法；否则就是对象的一个静态属性。
Quellcode-Recherche zum JS-Framework

jQuery类型判断

type: function( obj ) {            if ( obj == null ) {                return obj + "";
            }            return typeof obj === "object" || typeof obj === "function" ?
            class2type[ toString.call(obj) ] || "object" :                typeof obj;
        },

前面已经分析了，class2type = {};所以class2type[ toString.call(obj) ] =
{}.toString.call(obj)。它的作用是改变toString的this指向为object的实例。

Das obige ist der detaillierte Inhalt vonQuellcode-Recherche zum JS-Framework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel：Ausführliche Erläuterung grundlegender Datentypen und Werttypreferenzen in JavaScriptNächster Artikel：Ausführliche Erläuterung grundlegender Datentypen und Werttypreferenzen in JavaScript

In Verbindung stehende Artikel

Mehr sehen