Question

好吧，长话短说，我有2个班级（功能），需要从第二个延伸一个..在艰难的一天结束时，我写了简单的解决方案，但后来我回家了，我认为这是错误的..但是..实际上它正在工作，只有我不明白为什么.. 所以例如我有两个功能：

function aa() {
  var r = "aaaa";
  this.method = function(){
    console.log(r);
  }
}

function bb() {
  var e = "bbbb";
  this.method2 = function(){
    console.log(e);
  }
}

var a = new aa();
var b = new bb();

使用此功能合并后：

var merge = function(one, two) {
  for(var method in two) {
    one[method] = two[method];
  }
  return one;
}
var c = merge(a, b);

这很好..所以问题是为什么？我猜在'merge'函数中，我只是添加到第二个的第一个对象方法，但是这个方法使用了私有变量，在第一个对象中没有定义，为什么他会看到它？

Answer 1

r和e值包含在method和method2函数的范围内。即使在移动这些函数之后，它们仍然保持对定义它们的范围中的变量的引用。这称为闭包。更多：How do JavaScript closures work?

Answer 2

请注意，您没有将method2函数从一个原型复制到另一个原型 - 您在method2中添加了对aa的引用。

只要bb存在，method2就能访问bb的变量e。特别是因为e是在method2可见的范围内声明的。

Answer 3

这基本上就是闭包的工作原理。您的代码可以简化为：

var bar;
(function foo () {
    var x = 10;
    bar = function () {
        alert(x);
    }
})();

// Now that we're outside of foo:
bar(); // bar can still see "x".

// Even if you do this:
var x = 0;
bar(); // bar still sees x=10

Answer 4

这是jQuery用于.extend（）api

的深层复制方法

function() {
var src, copyIsArray, copy, name, options, clone,
    target = arguments[0] || {},
    i = 1,
    length = arguments.length,
    deep = false;

// Handle a deep copy situation
if ( typeof target === "boolean" ) {
    deep = target;
    target = arguments[1] || {};
    // skip the boolean and the target
    i = 2;
}

// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
    target = {};
}

// extend jQuery itself if only one argument is passed
if ( length === i ) {
    target = this;
    --i;
}

for ( ; i < length; i++ ) {
    // Only deal with non-null/undefined values
    if ( (options = arguments[ i ]) != null ) {
        // Extend the base object
        for ( name in options ) {
            src = target[ name ];
            copy = options[ name ];

            // Prevent never-ending loop
            if ( target === copy ) {
                continue;
            }

            // Recurse if we're merging plain objects or arrays
            if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
                if ( copyIsArray ) {
                    copyIsArray = false;
                    clone = src && jQuery.isArray(src) ? src : [];

                } else {
                    clone = src && jQuery.isPlainObject(src) ? src : {};
                }

                // Never move original objects, clone them
                target[ name ] = jQuery.extend( deep, clone, copy );

            // Don't bring in undefined values
            } else if ( copy !== undefined ) {
                target[ name ] = copy;
            }
        }
    }
}

// Return the modified object
return target;
};

在JavaScript中扩展功能

4 个答案: