Da es eh schon eine clone Funktion gibt, kannst du die auch von außen erweitern, wenn du in der Funktion nichts patchen willst.
PHP-Code:
(function () {
var originalClone = Crafty.prototype.clone;
Crafty.prototype.clone = function(){
var clone = originalClone.apply( this, Array.prototype.slice.call( arguments ) );
if( this.__image && !! clone ) {
clone.__image = this.__image;
}
return clone;
};
})();
=>
http://jsfiddle.net/SCLDr/6/
Allerdings ist von building nix zu sehen. Kenn crafty nicht, aber sollten da jetzt nicht 2 Objekte zu sehen sein?
Aus deren clone fn:
PHP-Code:
for (prop in this) {
clone[prop] = this[prop];
}
=> sog. shallow copies => einfache typen werden kopiert, objekte und arrays jedoch nur referenziert. Ungetestetes Probiererle:
PHP-Code:
for (prop in this) {
if( this[prop].nodeType != null ) {
try {
clone[prop] = this[prop].cloneNode();
} catch(e) {
clone[prop] = this[prop];
}
} else if( this.hasOwnProperty(prop) ) {
clone[prop] = this[prop];
}
}
}
Für die Akten noch hier jQuerys extend Methode ohne jQuery:
PHP-Code:
/**
*
* @function
* @private
* @param mixed obj
* @returns bool
*/
var _isArray = Array.isArray || function( obj ) {
return Object.prototype.toString.call( obj ) === '[object Array]';
},
/**
*
* @function
* @private
* @param {Object} obj
* @returns bool
*/
_isPlainObject = function( obj ) {
if ( !obj || typeof obj !== "object" || obj.nodeType || "setTimeout" in obj ) {
return false;
}
if ( obj.constructor &&
! hasOwn.call( obj, "constructor" ) &&
! hasOwn.call( obj.constructor.prototype, "isPrototypeOf" )
) {
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for ( key in obj ) {}
return key === undefined || hasOwn.call( obj, key );
},
/**
* @private
* @param mixed data : array or object
* @param {Function} fn
* @param {Object} scope
*/
_each = function( data, fn, scope ) {
if( data.prototype && data.prototype.forEach ) {
data.forEach( fn, scope );
} else {
for( var i in data ) {
fn.call( scope, data[ i ], i );
}
}
},
/**
*
* @function
* @private
* @see jQuerys' extend
*/
_extend = function() {
var options,
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" && typeof target !== "function" ) {
target = {};
}
for( ; i < length; i++ ) {
if( (options = arguments[ i ]) != null ) {
// Extend the base object - in difference to jQuery use native forEach if possible
_each( options, function ( copy, name ) {
var src = target[ name ],
copyIsArray,
clone;
// Prevent never-ending loop
if ( target === copy ) {
return;
}
// Recurse if we're merging plain objects or arrays
if( deep && copy && ( _isPlainObject( copy )
|| ( copyIsArray = _isArray( copy ) ) )
) {
if( copyIsArray ) {
copyIsArray = false;
clone = src && _isArray(src) ? src : [];
} else {
clone = src && _isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[ name ] = _extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}, this );
}
}
// Return the modified object
return target;
};
edit: falls das _extend nicht läuft, evtl. fehlende dependencies kannst du dir hier rausfischen:
https://github.com/basti1253/my/blob...src/my.core.js
Grüße