javascript 标签

严格模式限制

By hiluluke on

js严格模式限制

  • 变量必须声明后再使用
  • 函数的参数不能有同名属性,否则报错
  • 不能使用with语句
  • 不能对只读属性赋值,否则报错
  • 不能使用前缀0表示八进制数,否则报错
  • 不能删除不可删除的属性,否则报错

$.extend

  • 用途
    扩展对象属性。
    第一个参数如果是true就递归的将source给target。

    1
    2
    $.extend(target, [source, [source2, ...]]) ⇒ target
    $.extend(true, target, [source, ...]) ⇒ target v1.0+
  • 相关代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    function extend(target, source, deep) {
    for (key in source)
    if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {
    if (isPlainObject(source[key]) && !isPlainObject(target[key]))
    target[key] = {}
    if (isArray(source[key]) && !isArray(target[key]))
    target[key] = []
    extend(target[key], source[key], deep)
    }
    else if (source[key] !== undefined) target[key] = source[key]
    }
    // Copy all but undefined properties from one or more
    // objects to the `target` object.
    $.extend = function(target){
    var deep, args = slice.call(arguments, 1)
    if (typeof target == 'boolean') {
    deep = target
    target = args.shift()
    }
    args.forEach(function(arg){ extend(target, arg, deep) })
    return target
    }

今年重新找工作的时候面试官问了个问题,jQuery的链式函数调用的原理。当时一脸懵逼,因为完全没有去了解过。(事实证明面试能够很好的提高自己)

然后感觉直接去看jq的源码,要仔细看好感觉得花很长时间,还是先看看zepto,反正组织代码的原理都差不多。

构造

在立即调用函数中声明了3个东东:

1
2
3
4
5
6
7
8
9
10
zepto = {};
function Z(dom, selector) {
var i, len = dom ? dom.length : 0
for (i = 0; i < len; i++) this[i] = dom[i]
this.length = len
this.selector = selector || ''
}
$ = function(selector, context){
return zepto.init(selector, context)
}

当然声明的位置各有不同,Z函数很显然是构造函数,zepto是构造中间的一些方法的保留吧,然后$上挂上所有对外的方法。构造调用的基本流程是,$调用zepto的init,然后init函数做一些处理,再返回一个Z的`return zepto.Z(dom, selector)`,其中zepto.Z返回的就是一个构造函数Z。这样做的处理是要在$上吧zepto挂上,可以在插件里面改写。

因子

在看Zepto源码的时候发现它做类型判断的时候用的下面的方法:

1
2
3
4
5
6
7
var a = {},
toString = a.toString;
toString.call(function(){}); // [object Function]
toString.call({}); // [object Object]
toString.call(123); // [object Number]
toString.call("sasa"); // [object String]

上面这个判断类型的方法好像在js高程中好像看见过,不过忘了。然后让我对toString这个方法产生了好奇心,于是去多了解了下。

在Zepto里面有一些没有暴露出来的私有方法,有一些值得借鉴的地方,比如里面用来判断类型的type函数。大概纪录如下:

一些类型判断方法

判断数组:

1
2
isArray = Array.isArray ||
function(object){ return object instanceof Array }

类型判断函数

1
2
3
4
5
6
7
8
9
10
11
var class2type = {},
toString = class2type.toString;
// class2type map
$.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
class2type[ "[object " + name + "]" ] = name.toLowerCase()
});
function type(obj) {
return obj == null ? String(obj) :
class2type[toString.call(obj)] || "object"
}

上面的类型判断,基本上可以判断所有的类型。主要是改变toString的this指向来实现的。