Other ways to loop through a JavaScript object?

Question

this code below works well but the ESLint plugin show the warning:"Using 'ForinStatement' is not allowed" so i want to change it to other ways to prevent the warning message:

    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;
        }
      }
    }

Why `const key`? Why not `let` or `var`. Also `{}.hasOwnProperty.call(groups[key], 'users')` can be `groups[key].hasOwnProperty( 'users')` — Rajesh, Nov 01 '16 at 09:27
@Rajesh Because the `key` doesn't change inside of the body of the loop. That's the recommended practice. — Madara's Ghost, Nov 01 '16 at 09:27
@MadaraUchiha I didn't know this. But will second iteration not try to override it as `const key` will be hoisted? — Rajesh, Nov 01 '16 at 09:29
Possible duplicate of [Iterate through object properties](http://stackoverflow.com/questions/8312459/iterate-through-object-properties) — evolutionxbox, Nov 01 '16 at 09:30
Possible duplicate of [map function for objects (instead of arrays)](http://stackoverflow.com/questions/14810506/map-function-for-objects-instead-of-arrays) — roberrrt-s, Nov 01 '16 at 09:55
This question is a little vague. There are a number of ways you can iterate an object without `for..in`: `Object.values`, `Object.entries` or `Object.keys` with `for..of` or `forEach` or `reduce`. The real question is do you understand why `for..in` is *semantically different* than those options and do you need `for..in` for your logic to function correctly? — CodingIntrigue, Nov 01 '16 at 10:06
@evolutionxbox Very correct! But all the answers in your duplicate notification state the `for...in` solution. — roberrrt-s, Nov 01 '16 at 15:59
@Roberrrt that they do! The answer I specifically meant was http://stackoverflow.com/a/18202926/989920 — evolutionxbox, Nov 01 '16 at 16:08

score 14 · Accepted Answer · answered Nov 01 '16 at 16:10

14

If your goal alone is to avoid errors in your ESLint, i'd suggest using Object.keys(obj).forEach() I usually go with this approach in my own projects.

Pseudo-example:

Object.keys(groups).forEach(key => {
    if (Object.prototype.toString.call(groups[key]) === '[object Object]') {
        if ({}.hasOwnProperty.call(groups[key], 'users')) {
            count += groups[key].users.length;
        }
    }
});

answered Nov 01 '16 at 16:10

roberrrt-s

7,249
2
41
53

2

thank, it work perfectly. However to prevent ESLint, you should change "Object.keys(groups).forEach(key => {" to "Object.keys(groups).forEach((key) => {" – methis Nov 02 '16 at 03:18
Arrow scoped parameters do not require parenthesis when single: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions It's neater to do it your way though, ++! – roberrrt-s Nov 02 '16 at 07:34

score 1 · Answer 2 · edited Sep 13 '18 at 16:39

Here are three possible ways of solving this depending on what part of the map you need, the keys, the values or both the key/value pairs.

If you need not only the key, but the value in the map you might choose:

for (const [key, value] of Object.entries(object)) {
  // ...
}

If you only need the keys:

for (const key of Object.keys(object)) {
  // ...
}

Finally, if you only need the values, but not the keys you can use:

for (const value of Object.values(object)) {
  // ...
}

Nina Scholz · Answer 3 · 2016-11-01T09:51:38.540

0

You use a single line for checking and counting.

let count = Object.keys(groups).reduce((r, key) =>
    r + (('users' in groups[key]) && groups[key].users.length || 0), 0);

edited Nov 01 '16 at 09:51

answered Nov 01 '16 at 09:31

Nina Scholz

323,592
20
270
324

Btw, you better use `'users' in groups[key]` (instead of `groups[key].hasOwnProperty('users')`) since otherwise semantics of the code is different. – zerkms Nov 01 '16 at 09:50

score 0 · Answer 4 · answered Nov 01 '16 at 09:32

I like to implement an it helper function to iterate objects:

function* it(obj) {
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      yield [key, obj[key]];
    }
  }
}

Then you can iterate like so:

for (const [key, value] of it(obj)) {
  if ({}.toString.call(value) === '[object Object]' &&
      value.hasOwnProperty('users')) {
      count += connections[key].users.length;
    }
}

While this method still uses for..in, it's now contained in one function, and you can make a single exception in your ESLint file for it. Then you don't need to use it ever again.

Other ways to loop through a JavaScript object?

4 Answers4