Javascript是通过引用传递还是通过值传递？以下是Javascript:Good Parts的示例.我my对矩形函数的参数非常困惑.它实际上是undefined在函数内部重新定义的.没有原始参考.如果我从函数参数中删除它,则内部区域功能无法访问它.

是关闭吗？但是没有返回任何函数.

var shape = function (config) {
    var that = {};
    that.name = config.name || "";
    that.area = function () {
        return 0;
    };
    return that;
};
var rectangle = function (config, my) {
    my = my || {};
    my.l = config.length || 1;
    my.w = config.width || 1;
    var that = shape(config);
    that.area = function () {
        return my.l * my.w;
    };
    return that;
};
myShape = shape({
    name: "Unhnown"
}); …

有没有办法更新对象中的值？

{
  _id: 1,
  name: 'John Smith',
  items: [{
     id: 1,
     name: 'item 1',
     value: 'one'
  },{
     id: 2,
     name: 'item 2',
     value: 'two'
  }]
}

假设我想更新id = 2的项目的名称和值项目;

我尝试了以下w/mongoose:

var update = {name: 'updated item2', value: 'two updated'};
Person.update({'items.id': 2}, {'$set':  {'items.$': update}}, function(err) { ...

这种方法的问题在于它更新/设置整个对象,因此在这种情况下我丢失了id字段.

有没有更好的方法在mongoose中设置数组中的某些值但是只留下其他值？

我也只是询问了这个人:

Person.find({...}, function(err, person) {
  person.items ..... // I might be able to search through all the items here and find item with id 2 then update the values I want …

为什么默认情况下对象不可迭代？

我一直看到与迭代对象有关的问题,常见的解决方案是迭代对象的属性并以这种方式访问​​对象中的值.这似乎很常见,它让我想知道为什么对象本身不可迭代.

for...of默认情况下,像ES6 这样的语句很适合用于对象.因为这些功能仅适用于不包含{}对象的特殊"可迭代对象" ,所以我们必须通过箍来使这个对我们想要使用它的对象起作用.

for ... of语句创建一个循环迭代可迭代对象 (包括Array,Map,Set,arguments对象等)......

例如,使用ES6 生成器功能:

var example = {a: {e: 'one', f: 'two'}, b: {g: 'three'}, c: {h: 'four', i: 'five'}};

function* entries(obj) {
   for (let key of Object.keys(obj)) {
     yield [key, obj[key]];
   }
}

for (let [key, value] of entries(example)) {
  console.log(key);
  console.log(value);
  for (let [key, value] of entries(value)) {
    console.log(key);
    console.log(value);
  }
}

当我在Firefox(支持ES6)中运行代码时,上面按照我期望的顺序正确记录数据:

默认情况下,{}对象不可迭代,但为什么？缺点是否超过了可迭代对象的潜在好处？与此相关的问题是什么？

此外,由于{}对象是从"阵列状"集合和"可迭代的对象",如不同NodeList,HtmlCollection以及arguments …

ES6是否为对象属性引入了明确定义的枚举顺序？

var o = {
  '1': 1,
  'a': 2,
  'b': 3
}

Object.keys(o); // ["1", "a", "b"] - is this ordering guaranteed by ES6?

for(let k in o) {
  console.log(k);
} // 1 2 3 - is this ordering guaranteed by ES6?

我有一个对象数组.我想映射这个对象数组.我知道如何映射数组,但无法弄清楚如何映射对象数组.这是我到目前为止所做的:

我要映射的对象数组:

const theData = [
    {
        name: 'Sam',
        email: 'somewhere@gmail.com'
    },

    {
        name: 'Ash',
        email: 'something@gmail.com'
    }
]

我的组件:

class ContactData extends Component {
    render() {
        //works for array
        const renData = this.props.dataA.map((data, idx) => {
            return <p key={idx}>{data}</p>
        });

        //doesn't work for array of objects
        const renObjData = this.props.data.map(function(data, idx) {
            return <p key={idx}>{data}</p>
        });

        return (
            <div>
                //works
                {rennData}
                <p>object</p>
                //doesn't work
                {renObjData}
            </div>
        )
    }
}


ContactData.PropTypes = {
    data: PropTypes.arrayOf(
        PropTypes.obj
    ),
    dataA: PropTypes.array
} …

下面的代码运行良好,但ESLint插件显示警告:"不允许使用'ForinStatement'"所以我想将其更改为其他方法来阻止警告消息:

    let count = 0;
    for (const key in groups) {
      if (Object.prototype.toString.call(groups[key]) === '[object Object]') {
        if ({}.hasOwnProperty.call(groups[key], 'users')) {
          count += groups[key].users.length;
        }
      }
    }

有没有办法修剪对象的所有属性？换句话说，我可以更改一下：

{a: ' a', b: 'b ', c: ' c '}

对此：

{a: 'a', b: 'b', c: 'c'}

看来我无法映射对象，那么如何将函数应用于所有属性并获取对象呢？

当我有:

const foo = 1;

我可以设置对象属性名称的简写

const bar = {foo}

就像那样

const bar = {foo: foo} // bar will be {foo: 1}

当我有一个带箭头功能的const时,有没有简写？

const foo = () => 1

我必须像这样设置它,但它不酷

const bar = {foo: foo()}

我想这样或者更短的东西

const bar = {foo()}  //bar should be {foo: 1} but this will fail

我需要映射这样的对象

let obj = { 
    a : { value : 5, meta: "sss" },
    b : { value : 1, meta: "rrr" },
    a : { value : 6, meta: "nnn" },
}`

像这样获得并反对

{ a: 5, b: 1, c:6}

我无法获取字符串形式的“密钥”。

我试过了：

let yyy = Object.keys(obj).map(function (key) {
    return { key: obj[key].value };
});

但它会生成一个“数组”（虽然我需要一个对象），其中包含{key : 5}... 字符串“key”而不是键的名称。

我正在尝试编写一个函数,它将遍历我的对象并返回对象的级别深度.

例如,如果我在此对象上运行该函数:

var test = {
  name: 'item 1',
  children: [{
    name: 'level 1 item',
    children: [{
      name: 'level 2 item'
    },
    {
      name: 'second level 2 item',
      children: [{
        name: 'level 3 item'
      }]
    }]
  }]
}

var depth = myFunction(test); // Would return 2 (0 index based) as the collection goes 3 levels deep

我一直在尝试编写一个确定最大深度的递归函数,但到目前为止我无法做到正确.这是我到目前为止:https://jsfiddle.net/6cc6kdaw/2/

似乎返回的值是每个节点命中的计数,而不是唯一级别.我明白我哪里出错了(从某种意义上说我没有过滤掉它)但是我已经盯着代码这么久以至于没有任何意义了!

有谁能够指出我哪里出错了？谢谢

所以我有一些状态是一个看起来像这样的对象

object:{
  foo: Array[3]
  bar: Array[6]
}

并且对象内部的条目数量可能会发生变化,它可能有3个数组,它可能有10个.它需要是动态的我必须显示那些作为计数(在饼图中)接受数据看起来像这样,数据是JSX标记内的prop

data:{[
  {x:foo, y:foo.length},
  {x:bar, y:bar.length}
]}

x输出作为名称,y输出作为数字(不是百分比,lib为我工作)

我试过在这里使用一些例子,例如这个帖子,但我只是没有得到它

ES6语法的首选项如果你感兴趣的话,我正在使用Victory for my graphing lib

如果 Redux 操作实际上并不对数据进行操作而只是返回一个有效负载，为什么它们被称为操作？

除了被分派之外，动作还有其他用途吗，为什么在调用时不分派动作？

这只是未来证明可与多个商店一起使用的应用程序的一种方式吗？

这也产生了对 mapDispatchToProps 的需求，它通常是完全样板代码，用于用调度调用包装动作

通常可以用这个函数来概括，它接受一个动作对象并返回一个 mapDispatchToProps 函数

// mapActionsToDispatchProps.js
const mapActionsToDispatchProps = actions => {
  return dispatch => (
    actions.mapEntries(action => (
      (...args) => dispatch(action(...args))
    )
  )
)
export default mapActionsToDispatchProps

Object.mapEntries示例。

编辑

我看到最后一个关于 mapDispachToProps 主要是样板的问题可以通过直接传递一个动作对象来避免，并且 connect 将为我映射它们。

我有 2 个数组：

var keys = Object.keys(item); // [first, second, third, forth]
var values = Object.values(item); // [fifth, sixth, seventh, eighth]
let newArray = [];

输出应该是：

[first, fifth, second, sixth, third, seventh, forth, eighth]

是否可以不使用任何 while 循环，例如for i in item或for i = 0；i <= item.length; i++ ..
只需使用地图、拼接等。