profonde étendre (comme jQuery) pour nodeJS

Je suis aux prises avec de profondes copies d'objets en nodeJS. mon propre étendre l'est de la merde. trait de soulignement de l'étendre est plat. il y a plutôt simple d'étendre les variantes ici sur stackexchange, mais aucune n'est proche de jQuery.étendre(true, {}, obj obj obj) ..
(la plupart sont en réalité terrible et visser les avantages de asnyc code.)

donc, ma question: est-il une bonne copie en profondeur pour NodeJS? Personne n'a porté de jQuery ?

Éviter de le faire. Profonde des copies sont mauvaises. Faveur superficielle des copies.
pourriez-vous expliquer pourquoi? pour moi, le peu de copies sont un cauchemar lorsqu'ils se jettent dans une série de async rappels...
aussi - notre structure DB (mongoDB) a assez profonde des objets et j'ai vraiment pas envie de déconner et de convertir des structures... c'est très commode de simplement travailler avec les mêmes objets dans le code & db ...
Assurez-vous qu'il est. Il suffit de ne pas profondément les copier. Je travaille avec des objets de mongo et je n'ai jamais profond copier :\
itsatony je suis en désaccord avec Raynos ici, vous devez utiliser votre jugement quant à savoir si ce comportement est bon pour votre cas d'utilisation. Juste être conscient qu'il ya des pièges et utiliser votre tête. C'est un débat sur la copie en profondeur/étendre problème pour le trait de Soulignement projet: github.com/documentcloud/underscore/issues/162
Vous pouvez utiliser ce plugin github.com/maxmara/dextend

InformationsquelleAutor itsatony | 2012-02-22

Vous voulez de jQuery, il suffit donc de l'utiliser:

function extend() {
var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false,
toString = Object.prototype.toString,
hasOwn = Object.prototype.hasOwnProperty,
push = Array.prototype.push,
slice = Array.prototype.slice,
trim = String.prototype.trim,
indexOf = Array.prototype.indexOf,
class2type = {
"[object Boolean]": "boolean",
"[object Number]": "number",
"[object String]": "string",
"[object Function]": "function",
"[object Array]": "array",
"[object Date]": "date",
"[object RegExp]": "regexp",
"[object Object]": "object"
},
jQuery = {
isFunction: function (obj) {
return jQuery.type(obj) === "function"
},
isArray: Array.isArray ||
function (obj) {
return jQuery.type(obj) === "array"
},
isWindow: function (obj) {
return obj != null && obj == obj.window
},
isNumeric: function (obj) {
return !isNaN(parseFloat(obj)) && isFinite(obj)
},
type: function (obj) {
return obj == null ? String(obj) : class2type[toString.call(obj)] || "object"
},
isPlainObject: function (obj) {
if (!obj || jQuery.type(obj) !== "object" || obj.nodeType) {
return false
}
try {
if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
return false
}
} catch (e) {
return false
}
var key;
for (key in obj) {}
return key === undefined || hasOwn.call(obj, key)
}
};
if (typeof target === "boolean") {
deep = target;
target = arguments[1] || {};
i = 2;
}
if (typeof target !== "object" && !jQuery.isFunction(target)) {
target = {}
}
if (length === i) {
target = this;
--i;
}
for (i; i < length; i++) {
if ((options = arguments[i]) != null) {
for (name in options) {
src = target[name];
copy = options[name];
if (target === copy) {
continue
}
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 : {};
}
//WARNING: RECURSION
target[name] = extend(deep, clone, copy);
} else if (copy !== undefined) {
target[name] = copy;
}
}
}
}
return target;
}

et un petit test pour montrer qu'elle n'profonde des copies

extend(true, 
{
"name": "value"
}, 
{
"object": "value",
"other": "thing",
"inception": {
"deeper": "deeper",
"inception": {
"deeper": "deeper",
"inception": {
"deeper": "deeper"
}
}
}
}
)

Mais n'oubliez pas de mentionner la source: https://github.com/jquery/jquery/blob/master/src/core.js

Veuillez noter que je n'ai pas apporté plus de "isPlainObject", "isArray" ou tout autres fichiers jQuery, parce que je tenais à préciser que vous pouvez capturer directement leur source et de n'utiliser que.
cool, merci une tonne! J'avais essayé de faire par moi-même, mais j'ai tout gâché. le vôtre fonctionne, mine de ne pas 🙁

InformationsquelleAutor jcolebrand

27

Il a déjà été porté. nœud-étendre

Note le projet n'a pas de tests et n'a pas beaucoup de popularité, donc à utiliser à vos propres risques.

Comme mentionné, vous n'aurez probablement pas besoin profond d'exemplaires. Essayez de changer vos structures de données si vous avez seulement besoin peu profondes des copies.

Quelques mois plus tard

J'ai écrit un petit module au lieu de cela, vous recommandons l'utilisation de xtend. Il ne s'agit pas d'une mise en œuvre contenant jQuery bagages ni de bugs, comme le node-mesure.
- Désolé, comment pouvez-vous dire que juste parce que vous n'ont jamais utilisé une copie en profondeur qu'ils sont mauvais et doit être évitée dans tous les cas?
- Je ne dis pas qu'ils sont mauvais, j'ai juste dit de les éviter. Ils sont gourmand en ressources et ont un tas de gênant bord des cas, vous devez être conscient de. Profonde copies sont la complexité inutile, qui est facile à éviter
- Nœud-étendre 1.0.0 ne fonctionne pas pour la profondeur des copies. J'ai corrigé ma copie locale et envoyé les changements de l'auteur: a) renommer appel sur la ligne 16 de hasOwn pour hasOwnProperty b) donner la fonction principale d'un nom sur la ligne 19: la fonction extend () { var options, name, ... si l'appel récursif de travail et alors juste module.exports = extend; après que la fonction, sur la dernière ligne du fichier source (ligne 83).
- merci pour xtend ! nous testons aujourd'hui. en général, nous avons eu de la difficulté avec l'ensemble s'étend (y compris jquery et sugarJS versions) lorsque nous avons essayé de profonde étendre les tableaux. comportement dans cette affaire était toujours étrange et certainement inattendu. nous publierons un violon/gist sur le problème dès que possible.
- xtend seulement peu profonde extension par la conception
- après avoir essayé quelques modules-je choisir pour node.étendre parce que c'clones objets à l'aide de prototypes correctement. xtend et noeud-mesure (avec un ' -'), les deux ne parviennent pas à le faire.
- vous devriez dire que vous êtes l'auteur de la bibliothèque vous promouvoir.
- importe-t-il, c'est une bibliothèque qui ne fait qu'une chose bien.
- Même si vous êtes 100% impartial, vous devez divulguer votre affiliation", comme indiqué ici
- Vous ne devez divulguer votre implication dans le projet, vous lien ici. Merci de résoudre ce problème ou votre réponse pourrait être supprimée si elle est plus marqué.
- J'ai ajouté de la divulgation dans la demande.
- Pourriez-vous nous expliquer comment vous l'appui de votre demande de, "ni bugs"? Bogues-vous allusion?
InformationsquelleAutor Raynos
11

Un rapide et sale réponse à la profondeur des copies est juste de tricher avec un peu de JSON. C'est pas le plus performant, mais il fait le travail très bien.
```
function clone(a) {
return JSON.parse(JSON.stringify(a));
}
```
- C'est super si c'est juste un de données orientée objet, mais vous ne voulez pas le faire que si votre objet est venu à partir d'un constructeur avec ses propres méthodes et de l'héritage qu'il aurait tout perdu.
- c'est absolument vrai; il est seulement utile pour la copie de simples objets de valeurs; il ne parvient pas pour les dates, fonctions, et, dans certains cas, des objets construits.
- malheureusement, les fonctions sont perdus. Cela fonctionne perfecty pour tout, mais les fonctions
- Non, cela ne fonctionne pas parfaitement pour tout, mais des fonctions. Pour citer directement le commentaire avant le vôtre: it's only useful for copying simple objects of values; it fails for dates, functions, and in some instances constructed objects.
- Le clonage n'est pas nécessairement l'extension. L'extension nécessite une cible.
InformationsquelleAutor Kato
11

Veuillez utiliser le haut-util module:
```
var extend = require('util')._extend;
var merged = extend(obj1, obj2);
```
- Ce n'est pas une méthode documentée, et est précédé d'un trait de soulignement qui signifie généralement qu'il n'est pas destiné à la consommation publique.
- Aussi util._extend n'est pas profonde.
- C'est pourquoi la confidentialité des conventions de ne pas travailler dans le monde réel 😉
InformationsquelleAutor ScriptMaster
8

Je sais que c'est une vieille question, mais je voudrais juste jeter lodash de la fusion dans le mélange comme une bonne solution. Je le recommande lodash pour les fonctions de l'utilitaire en général 🙂
- J'aime lodash, mais lodash de extend mutation de l'objet et ce suce le gros temps.
- Lodash de mutation peuvent être facilement évitée avec un objet vide comme premier paramètre pour les deux merge et extend. var obj3 = lodash.extend(obj1, obj2) va muter obj1 var obj3 = lodash.extend({}, obj1, obj2) ne mutera pas obj1.
InformationsquelleAutor thataustin

Cela fonctionne pour la profondeur de l'objet de l'extension... être averti qu'il remplace des tableaux plutôt que leurs valeurs, mais qui peut évidemment être mis à jour comme vous le souhaitez. Il doit maintenir l'énumération des capacités et toutes les autres choses que vous voudrez probablement qu'elle ne

function extend(dest, from) {
var props = Object.getOwnPropertyNames(from), destination;
props.forEach(function (name) {
if (typeof from[name] === 'object') {
if (typeof dest[name] !== 'object') {
dest[name] = {}
}
extend(dest[name],from[name]);
} else {
destination = Object.getOwnPropertyDescriptor(from, name);
Object.defineProperty(dest, name, destination);
}
});
}

InformationsquelleAutor marksyzm

1

Dans Node.js, Vous pouvez utiliser Extendify pour créer un _.étendre la fonction qui prend en charge les objets imbriqués extension (deep étendre) et est également immuable à la params (d'où profond clone).
```
_.extend = extendify({
inPlace: false,
isDeep: true
});
```
InformationsquelleAutor user1928072
1

nœud.étendre n'profonde et est familier jQuery syntaxe

InformationsquelleAutor Stanislav
1

il suffit d'installer l'extension.
docs:
nœud étendre paquet
installer:
```
npm install extend
```
ensuite en profiter:
```
extend ( [deep], target, object1, [objectN] )
```
profonde est facultatif. valeur par défaut est false. si l'interrupteur à true, de manière récursive fusionner vos objets.
- Cette réponse est correcte...
InformationsquelleAutor Amin
0

Tranchant version appelée aiguiser.étendre.

Je ré-écrire nœud-étendre avec CoffeeScript et ajouter travis-ci de la suite de tests, parce que j'ai besoin profond d'adaptation dans Nœud pour moi, donc maintenant, c'est ici.

Et oui, je pense que dans certains cas il est absolument à utiliser correctement profond de fusion, par exemple je l'utilise au config fonctionne, quand on a besoin de fusionner par défaut et l'utilisateur branches ensemble.

InformationsquelleAutor Meettya
0

Vous pouvez également utiliser ma version de prolonger plugin
https://github.com/maxmara/dextend

InformationsquelleAutor Vlad Miller

Vous devez vous connecter pour publier un commentaire.

Quelques mois plus tard