Get rid of for-in loops

The for-in statement in JavaScript iterates also over inherited
properties. This is typically not desired and requires adding a
check using Object.prototype.hasOwnProperty inside the loop.

This commit replaces all for-in statements and related checks inside
them with iteration over Object.keys(...). The iteration is performed
using either Array.prototype.forEach of a plain for loop.

bin/pegjs

@@ -69,11 +69,9 @@ function addExtraOptions(options, json) {
     abort("The JSON with extra options has to represent an object.");
   }
 
-  for (let key in extraOptions) {
+  Object.keys(extraOptions).forEach(key => {
-    if (extraOptions.hasOwnProperty(key)) {
+    options[key] = extraOptions[key];
-      options[key] = extraOptions[key];
+  });
-    }
-  }
 }
 
 /*

lib/compiler/index.js

@@ -67,11 +67,9 @@ let compiler = {
       trace:             false
     });
 
-    for (let stage in passes) {
+    Object.keys(passes).forEach(stage => {
-      if (passes.hasOwnProperty(stage)) {
+      passes[stage].forEach(p => { p(ast, options); });
-        passes[stage].forEach(p => { p(ast, options); });
+    });
-      }
-    }
 
     switch (options.output) {
       case "parser": return eval(ast.code);

lib/peg.js

@@ -25,12 +25,10 @@ let peg = {
     function convertPasses(passes) {
       let converted = {};
 
-      for (let stage in passes) {
+      Object.keys(passes).forEach(stage => {
-        if (passes.hasOwnProperty(stage)) {
+        converted[stage] = Object.keys(passes[stage])
-          converted[stage] = Object.keys(passes[stage])
+          .map(name => passes[stage][name]);
-            .map(name => passes[stage][name]);
+      });
-        }
-      }
 
       return converted;
     }

spec/behavior/generated-parser-behavior.spec.js

@@ -10,11 +10,9 @@ describe("generated parser behavior", function() {
     function clone(object) {
       let result = {};
 
-      for (let key in object) {
+      Object.keys(object).forEach(key => {
-        if (object.hasOwnProperty(key)) {
+        result[key] = object[key];
-          result[key] = object[key];
+      });
-        }
-      }
 
       return result;
     }
@@ -89,19 +87,20 @@ describe("generated parser behavior", function() {
                 + jasmine.pp(e.message) + ".";
           } else {
             if (details) {
-              for (let key in details) {
+              let keys = Object.keys(details);
-                if (details.hasOwnProperty(key)) {
+              for (let i = 0; i < keys.length; i++) {
-                  if (!this.env.equals_(e[key], details[key])) {
+                let key = keys[i];
-                    this.message = () =>
+
-                      "Expected " + jasmine.pp(input) + " "
+                if (!this.env.equals_(e[key], details[key])) {
-                        + "with options " + jasmine.pp(options) + " "
+                  this.message = () =>
-                        + "to fail to parse"
+                    "Expected " + jasmine.pp(input) + " "
-                        + (details ? " with details " + jasmine.pp(details) : "") + ", "
+                      + "with options " + jasmine.pp(options) + " "
-                        + "but " + jasmine.pp(key) + " "
+                      + "to fail to parse"
-                        + "is " + jasmine.pp(e[key]) + ".";
+                      + (details ? " with details " + jasmine.pp(details) : "") + ", "
-
+                      + "but " + jasmine.pp(key) + " "
-                    return false;
+                      + "is " + jasmine.pp(e[key]) + ".";
-                  }
+
+                  return false;
                 }
               }
             }

spec/unit/compiler/passes/helpers.js

@@ -28,12 +28,13 @@ beforeEach(function() {
         } else if (isObject(details)) {
           if (!isObject(value)) { return false; }
 
-          for (let key in details) {
+          let keys = Object.keys(details);
-            if (details.hasOwnProperty(key)) {
+          for (let i = 0; i < keys.length; i++) {
-              if (!(key in value)) { return false; }
+            let key = keys[i];
 
-              if (!matchDetails(value[key], details[key])) { return false; }
+            if (!(key in value)) { return false; }
-            }
+
+            if (!matchDetails(value[key], details[key])) { return false; }
           }
 
           return true;
@@ -70,18 +71,19 @@ beforeEach(function() {
               + "but it did.";
         } else {
           if (details) {
-            for (let key in details) {
+            let keys = Object.keys(details);
-              if (details.hasOwnProperty(key)) {
+            for (let i = 0; i < keys.length; i++) {
-                if (!this.env.equals_(e[key], details[key])) {
+              let key = keys[i];
-                  this.message = () =>
+
-                    "Expected the pass to report an error "
+              if (!this.env.equals_(e[key], details[key])) {
-                      + "with details " + jasmine.pp(details) + " "
+                this.message = () =>
-                      + "for grammar " + jasmine.pp(grammar) + ", "
+                  "Expected the pass to report an error "
-                      + "but " + jasmine.pp(key) + " "
+                    + "with details " + jasmine.pp(details) + " "
-                      + "is " + jasmine.pp(e[key]) + ".";
+                    + "for grammar " + jasmine.pp(grammar) + ", "
-
+                    + "but " + jasmine.pp(key) + " "
-                  return false;
+                    + "is " + jasmine.pp(e[key]) + ".";
-                }
+
+                return false;
               }
             }
           }

spec/unit/parser.spec.js

@@ -204,17 +204,18 @@ describe("PEG.js grammar parser", function() {
                 + jasmine.pp(e.message) + ".";
           } else {
             if (details) {
-              for (let key in details) {
+              let keys = Object.keys(details);
-                if (details.hasOwnProperty(key)) {
+              for (let i = 0; i < keys.length; i++) {
-                  if (!this.env.equals_(e[key], details[key])) {
+                let key = keys[i];
-                    this.message = () =>
+
-                      "Expected " + jasmine.pp(this.actual) + " to fail to parse"
+                if (!this.env.equals_(e[key], details[key])) {
-                        + (details ? " with details " + jasmine.pp(details) : "") + ", "
+                  this.message = () =>
-                        + "but " + jasmine.pp(key) + " "
+                    "Expected " + jasmine.pp(this.actual) + " to fail to parse"
-                        + "is " + jasmine.pp(e[key]) + ".";
+                      + (details ? " with details " + jasmine.pp(details) : "") + ", "
-
+                      + "but " + jasmine.pp(key) + " "
-                    return false;
+                      + "is " + jasmine.pp(e[key]) + ".";
-                  }
+
+                  return false;
                 }
               }
             }