The statement iterates over all enumerable properties of an object that are keyed by strings (ignoring ones keyed by Symbols), including inherited enumerable properties.

Try it


for (const variable in object) {

A different property name is assigned to variable on each iteration.


Object whose non-Symbol enumerable properties are iterated over.


The loop will iterate over all enumerable properties of the object itself and those the object inherits from its prototype chain (properties of nearer prototypes take precedence over those of prototypes further away from the object in its prototype chain).

A loop only iterates over enumerable, non-Symbol properties. Objects created from built–in constructors like Array and Object have inherited non–enumerable properties from Array.prototype and Object.prototype, such as Array's indexOf() method or Object's toString() method, which will not be visited in the loop.

The traversal order, as of modern ECMAScript specification, is well-defined and consistent across implementations. Within each component of the prototype chain, all non-negative integer keys (those that can be array indices) will be traversed first in ascending order by value, then other string keys in ascending chronological order of property creation.

Deleted, added, or modified properties

If a property is modified in one iteration and then visited at a later time, its value in the loop is its value at that later time. A property that is deleted before it has been visited will not be visited later. Properties added to the object over which iteration is occurring may either be visited or omitted from iteration.

In general, it is best not to add, modify, or remove properties from the object during iteration, other than the property currently being visited. There is no guarantee whether an added property will be visited, whether a modified property (other than the current one) will be visited before or after it is modified, or whether a deleted property will be visited before it is deleted.

Array iteration and

Array indexes are just enumerable properties with integer names and are otherwise identical to general object properties. The loop will traverse all integer keys before traversing other keys, and in strictly increasing order, making the behavior of close to normal array iteration. However, the loop will return all enumerable properties, including those with non–integer names and those that are inherited. Unlike for...of, uses property enumeration instead of the array's iterator. In sparse arrays, for...of will visit the empty slots, but will not.

It is better to use a for loop with a numeric index, Array.prototype.forEach(), or the for...of loop, because they will return the index as a number instead of a string, and also avoid non-index properties.

Iterating over own properties only

If you only want to consider properties attached to the object itself, and not its prototypes, you can use one of the following techniques:

Object.keys will return a list of enumerable own string properties, while Object.getOwnPropertyNames will also contain non-enumerable ones.

Why Use

Many JavaScript style guides and linters recommend against the use of, because it iterates over the entire prototype chain which is rarely what one wants, and may be a confusion with the more widely-used for...of loop. In what cases would be useful at all?

It may be most practically used for debugging purposes, being an easy way to check the properties of an object (by outputting to the console or otherwise). Although arrays are often more practical for storing data, in situations where a key-value pair is preferred for working with data (with properties acting as the "key"), there may be instances where you want to check if any of those keys hold a particular value.



The loop below iterates over all of the object's enumerable, non-Symbol properties and logs a string of the property names and their values.

const obj = {a: 1, b: 2, c: 3};

for (const prop in obj) {
  console.log(`obj.${prop} = ${obj[prop]}`);

// Output:
// "obj.a = 1"
// "obj.b = 2"
// "obj.c = 3"

Iterating own properties

The following function illustrates the use of Object.hasOwn(): the inherited properties are not displayed.

const triangle = {a: 1, b: 2, c: 3};

function ColoredTriangle() {
  this.color = 'red';

ColoredTriangle.prototype = triangle;

const obj = new ColoredTriangle();

for (const prop in obj) {
  if (Object.hasOwn(obj, prop)) {
    console.log(`obj.${prop} = ${obj[prop]}`);

// Output:
// "obj.color = red"


ECMAScript Language Specification
# sec-for-in-and-for-of-statements

Browser compatibility

BCD tables only load in the browser

Compatibility: Initializer expressions in strict mode

Prior to Firefox 40, it was possible to use an initializer expression (i=0) in a loop:

const obj = { a: 1, b: 2, c: 3 };
for (var i = 0 in obj) {
// 1
// 2
// 3

This nonstandard behavior is now ignored in version 40 and later, and will present a SyntaxError ("for-in loop head declarations may not have initializers") error in strict mode (bug 748550 and bug 1164741).

Other engines such as v8 (Chrome), Chakra (IE/Edge), and JSC (WebKit/Safari) are investigating whether to remove the nonstandard behavior as well.

See also