jQuery.extend

[Аркадий Укупник]

Это высер резига:

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

	// Handle a deep copy situation
	if ( typeof target === "boolean" ) {
		deep = target;

		// skip the boolean and the target
		target = arguments[ i ] || {};
		i++;
	}

	// 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 ( i === length ) {
		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;
};

А эта функция делает тоже самое:

function extend() {
  var target = arguments[0]
    , i = 1;
  for (; i < arguments.length; ++i) {
    var options = arguments[i];
    for (var name in options) {
      if (options.hasOwnProperty(name)) {
        target[name] = options[name];
      }
    }
  }
  return target;
}

Я не пойму зачем у резига там рекурсия? Я думал он что-то клонирует, но такой пример показывает что это не так

a={foo: null},b={foo:[1,2,3]}
Object {foo: Array[3]}
$.extend(a,b)
Object {foo: Array[3]}
a.foo[0]='bar'
"bar"
JSON.stringify(b,0,2)
"{
  "foo": [
    "bar",
    2,
    3
  ]
}"

[Аркадий Укупник]

Если же необходимо что-то клонировать, то функцию можно переписать так:

function extend() {
  var target = arguments[0]
    , i = 1;
  for (; i < arguments.length; ++i) {
    var options = arguments[i];
    for (var name in options) {
      if (options.hasOwnProperty(name)) {
        var src = options[name];
        if (src == target) { // избегаем ухода в вечную рекурсию
          continue;
        }
        if (isObject(src)) { // src != null && typeof src == 'object'
          var dst = new src.constructor();
          src = arguments.callee(dst, src);
        }
        target[name] = src;
      }
    }
  }
  return target;
}

[Аркадий Укупник]

function extend() {
  var target = arguments[0]
    , i = 1
    , deep = false;
  if (typeof target == 'boolean') {
    deep = target;
    target = arguments[1];
    i = 2;
  }
  for (; i < arguments.length; ++i) {
    var options = arguments[i];
    for (var name in options) {
      if (options.hasOwnProperty(name)) {
        var copy = options[name];
        if (copy === undefined || copy == target) {
          continue;
        }
        // if (deep && copy != null && typeof copy == 'object') {
        if (deep && isObject(copy)) {f
          var dst = new copy.constructor();
          copy = arguments.callee(deep, dst, copy);
        }
        target[name] = copy;
      }
    }
  }
  return target;
}