相关疑难解决方法(0)

请帮助我理解这段代码.

var person = {
    'first-name': 'FirstName',
    'last-name': 'LastName',
    'gender': 'Male'
};

var anotherPerson = new Object(person);
anotherPerson.desig = 'Designation';

console.log('Another person designation: ' + anotherPerson['desig'] + ', person designation: ' + person['desig']);

我期待输出,Another person designation: Designation, person designation: undefined但令我惊讶的是我发现它`Another person designation: Designation, person designation: Designation.

根据我的说法,anotherPerson扩展person对象和属性设置anotherPerson为person对象不应该是可见的.我错了吗？或者这两个对象都指向同一个位置？

[编辑]

现在还有更多的惊喜.

我在上面添加了以下代码.

person.place = 'XYZ';
console.log(person['place'] + ', ' + anotherPerson['place']); // Expected: XYZ, undefined. Result: XYZ, XYZ.

基于上述结果和答案,我认为两个对象都指的是同一个位置.现在我添加了几行

person …

我有一些测试课

TestKlass = (function() {

    function TestKlass(value) {
      this.value = value != null ? value : 'hello world';
      console.log(this.value);
    }

    return TestKlass;

})();

x = new TestKlass;
x instanceof TestKlass; (gives true)

我有新的空物

y = {}
y instanceof Object

我能找到任何方法来为y设置任何属性,就像这样

y.__proto__ = x.__proto__
y.constructor.prototype = x.constructor.prototype

为了得到这个结果

y instanceof TestKlass => true

================================================== ==

UPD:

所以.我的主要目标 - 创建CLONE功能.现在我的解决方案适合我.请看这段代码:

JavaScript JS对象克隆

Object._clone = function(obj) {
  var clone, property, value;
  if (!obj || typeof obj !== 'object') {
    return obj; …

我一直在寻找这个,但到目前为止还没有找到重复,我可能使用错误的关键字...

我试图暂时更改存储在对象中的函数,但是无法将其设置回原来的状态.

考虑一下:

// Set the options object
var options = {
    success: function(){
        console.log('Original Function Called');
    }
}

// Save the options
$('#foo').data('bar',options);

然后在另一个功能:

// Get the options
var options = $('#foo').data('bar');

// Store the old options
var old_options = options;

// Temporarily change the success function
options.success = function(){
    console.log('Temporary Function Called');
}

// Save the options
// This allows the other functions to access the temporary function
$('#foo').data('bar',options);

// Do stuff here that uses the new options …

注意：我只是一个新手程序员，所以这个问题的核心可能是明显的错误或误解。

本质上，我需要将JavaScript中的“按值”多维数组深度复制到未知深度。我认为这将需要一些复杂的递归，但是似乎在JavaScript中，您只需要复制一个级别就可以按值复制整个数组。

举个例子，这是我的测试代码，它使用了一个故意卷积的数组。

function test() {
  var arr = [ ['ok1'],[],[ [],[],[ [], [ [ ['ok2'], [] ] ] ] ] ];
  var cloned = cloneArray(arr);
  arr = '';   // Delete the original
  alert ( cloned );
}


function cloneArray(arr) {  
  // Deep copy arrays. Going one level deep seems to be enough.
  var clone = [];
  for (i=0; i<arr.length; i++) {
    clone.push( arr[i].slice(0) )
  }
  return clone;
}

在我运行此测试（Ubuntu上最新稳定的Chrome和Firefox）的过程中，即使删除了原始数组，即使数组最深的部分也似乎已成功通过克隆中的值成功复制，即使slice_（）复制”仅深入了一层。这是JavaScript中的标准行为吗？我可以依靠它来运行较旧的浏览器吗？

当最初的目的是创建一个新数组时,为什么map方法会改变原始数组？

我有一个对象数组,我传递给一个纯函数,然后映射给定的数组并返回一个新的.然后我注意到原始数组也被改变了.我理解Js中的Object通过引用传递的概念,但是仍然无法抓住为什么实现map会改变原始数组,有点胜过IMO的目的.

var initialArray = [ { name: 'one' }, { name: 'two' }, { name: 'three'} ];

function doSomething(array) {

  // lodash
  // return _.map(array, (item) => _.assign(item, {isSelected: true}));  

  // vanilla
  return array.map(function(item) {
    item['isSelected'] = true;
    return item
  });

}

var changedArray = doSomething(initialArray);

console.log('initialArray', initialArray); // [{ name: 'one', isSelected: true }, ...]
console.log('changedArray', changedArray); // [{ name: 'one', isSelected: true }, ...]
console.log(initialArray === changedArray); // false

首先我想了解为什么会这样？

第二个我喜欢理解如何在不改变原始数组的情况下映射数组？(即._cloneDeep每次 …

情况就是这样:

user.username = body.username;
user.name = body.name;
user.surname = body.surname;
user.email = body.email;
user.password = body.password;
user.privilege = body.privilege;
user.pin = body.pin;
user.rfidTag = body.rfidTag;

我这样修改它,它按预期工作:

for (let propt in body) { 
    user[propt] = body[propt];
}

我想知道是否有更优雅的方式来写这个,也许有一些属性检查.

[更新]:有多种方法可以解决这个问题.

如果您不需要保留用户属性:

user = Object.assign( {}, body );

或者提案传播财产:

user = { ...body };

否则保留用户的属性:

Object.assign( user, body );

我有一个长度为 n 的对象数组，我想将其扩展到长度为 n+1。为了便于使用，我想复制最后一个元素，然后更改副本的属性。

let arr = [{id: 1, name: 'foo'}, {id: 2, name: 'bar'}];

arr.push(arr[1]);       // extend by copying the last
arr[2].id += 1;         // change the id of the new last
arr[2].name = 'foobar'; // change the name of the new last

console.log(arr);

在上面的代码片段中（使用浏览器控制台，因为代码片段控制台在这里的行为有点奇怪）是我尝试过的，但出于某种原因，对复制/新最后一个元素的任何更改也适用于原始/旧最后/新第二个元素-数组中的最后一个元素。

我怎样才能正确地做到这一点，为什么我的代码的行为方式如此？

我目前有一个像这样迭代的数组数据结构，调用foo每个唯一的元素对。

for(var i = 0; i < arr.length; i++) {
    for(var j = i + 1; j < arr.length; j++) {
        foo(arr[i], arr[j]);
    }
}

但是，我意识到我宁愿使用对象而不是数组，因为这样我就可以很轻松地按名称添加和删除元素。

但是，我看不到迭代此类对象的明显方法。我能得到的最接近的是：

for(i in obj) {
    for(j in obj) {
        foo(obj[i], obj[j]);
    }
}

显然，这将使每对执行两次，甚至产生一对相同的元素。是否有一种简单的方法可以像在第一个代码示例中的数组中那样迭代对象？

更新：

对jsperf上的解决方案进行性能测试。

在以下情况下，我发现 lodash 似乎没有复制源对象的 getter：

const _ = require("lodash");

let sourceObject = { };
Object.defineProperty(sourceObject, "abc", {
    get: () => 123
});

let cloneObject = _.cloneDeep(sourceObject);

console.log(sourceObject.abc); // 123
console.log(cloneObject.abc);  // undefined

有没有办法用lodash模块实现上述目的？

我正在使用 js 对象，可以说：

items: [{text: 'text1', active: true},
{text: 'text1', active: true},
{text: 'text1', active: true}]

我想制作对象的副本并在计算属性中对它们进行一些更改，如下所示：

computed: {
   copyAndChange() {
      var itemsCopy = []
      itemsCopy = this.items
      for (var i=0; i<itemsCopy.length; i++) {
         itemsCopy[i].text = "something"
         console.log('text from items: ' + this.item[i])
         console.log('text from itemsCopy: ' + itemsCopy[i])
      }
      return itemsCopy
   }
}

这段代码在控制台中给了我：

text from items: something
text from itemsCopy: something
text from items: something
text from itemsCopy: something
text from items: something
text from itemsCopy: something

（？） …