Remove remaining for of loops

Author: lukechilds

assert.js

@@ -381,14 +381,16 @@ function expectedException(actual, expected, msg, fn) {
                                       expected, 'may not be an empty object');
     }
     if (isDeepEqual === undefined) lazyLoadComparison();
-    for (const key of keys) {
-      if (typeof actual[key] === 'string' &&
-          isRegExp(expected[key]) &&
-          expected[key].test(actual[key])) {
-        continue;
+    keys.forEach(key => {
+      if (
+        typeof actual[key] === 'string' &&
+        isRegExp(expected[key]) &&
+        expected[key].test(actual[key])
+      ) {
+        return;
       }
       compareExceptionKey(actual, expected, key, msg, keys, fn);
-    }
+    });
     return true;
   }
   // Guard instanceof against arrow functions as they don't have a prototype.

internal/assert/assertion_error.js

@@ -81,9 +81,9 @@ const kMaxShortLength = 10;
 function copyError(source) {
   const keys = Object.keys(source);
   const target = Object.create(Object.getPrototypeOf(source));
-  for (const key of keys) {
+  keys.forEach(key => {
     target[key] = source[key];
-  }
+  });
   Object.defineProperty(target, 'message', { value: source.message });
   return target;
 }

internal/util/comparisons.js

@@ -5,6 +5,8 @@
 
 const regexFlagsSupported = /a/g.flags !== undefined;
 
+const arrayFrom = require('array-from');
+
 const objectIs = Object.is ? Object.is : require('object-is');
 const objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : () => [];
 
@@ -344,7 +346,9 @@ function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
 
 function setHasEqualElement(set, val1, strict, memo) {
   // Go looking.
-  for (const val2 of set) {
+  const setValues = arrayFrom(set.values());
+  for (let i = 0; i < setValues.length; i++) {
+    const val2 = setValues[i];
     if (innerDeepEqual(val1, val2, strict, memo)) {
       // Remove the matching element to make sure we do not check that again.
       set.delete(val2);
@@ -405,7 +409,9 @@ function setEquiv(a, b, strict, memo) {
   // This is a lazily initiated Set of entries which have to be compared
   // pairwise.
   let set = null;
-  for (const val of a) {
+  const aValues = arrayFrom(a.values());
+  for (let i = 0; i < aValues.length; i++) {
+    const val = aValues[i];
     // Note: Checking for the objects first improves the performance for object
     // heavy sets but it is a minor slow down for primitives. As they are fast
     // to check this improves the worst case scenario instead.
@@ -435,7 +441,9 @@ function setEquiv(a, b, strict, memo) {
   }
 
   if (set !== null) {
-    for (const val of b) {
+    const bValues = arrayFrom(b.values());
+    for (let i = 0; i < bValues.length; i++) {
+      const val = bValues[i];
       // We have to check if a primitive value is already
       // matching and only if it's not, go hunting for it.
       if (typeof val === 'object' && val !== null) {
@@ -457,7 +465,9 @@ function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
   // To be able to handle cases like:
   //   Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
   // ... we need to consider *all* matching keys, not just the first we find.
-  for (const key2 of set) {
+  const setValues = arrayFrom(set.values());
+  for (let i = 0; i < setValues.length; i++) {
+    const key2 = setValues[i];
     if (innerDeepEqual(key1, key2, strict, memo) &&
       innerDeepEqual(item1, map.get(key2), strict, memo)) {
       set.delete(key2);
@@ -471,7 +481,9 @@ function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
 function mapEquiv(a, b, strict, memo) {
   let set = null;
 
-  for (const [key, item1] of a) {
+  const aEntries = arrayFrom(a.entries());
+  for (let i = 0; i < aEntries.length; i++) {
+    const [key, item1] = aEntries[i];
     if (typeof key === 'object' && key !== null) {
       if (set === null) {
         set = new Set();
@@ -498,7 +510,9 @@ function mapEquiv(a, b, strict, memo) {
   }
 
   if (set !== null) {
-    for (const [key, item] of b) {
+    const bEntries = arrayFrom(b.entries());
+    for (let i = 0; i < bEntries.length; i++) {
+      const [key, item] = bEntries[i];
       if (typeof key === 'object' && key !== null) {
         if (!mapHasEqualEntry(set, a, key, item, strict, memo))
           return false;

package.json

@@ -24,13 +24,13 @@
     "@babel/core": "^7.4.4",
     "@babel/preset-env": "^7.4.4",
     "airtap": "^2.0.2",
-    "array-from": "^2.1.1",
     "core-js": "^3.0.1",
     "cross-env": "^5.2.0",
     "object.getownpropertydescriptors": "^2.0.3",
     "tape": "^4.10.1"
   },
   "dependencies": {
+    "array-from": "^2.1.1",
     "buffer": "^5.2.1",
     "es6-object-assign": "^1.1.0",
     "object-is": "^1.0.1",

test/common/index.js

@@ -247,7 +247,7 @@ function expectsError(fn, settings, exact) {
 
     // Check all error properties.
     const keys = Object.keys(settings);
-    for (const key of keys) {
+    keys.forEach(key => {
       if (!isDeepStrictEqual(error[key], innerSettings[key])) {
         // Create placeholder objects to create a nice output.
         const a = new Comparison(error, keys);
@@ -271,7 +271,7 @@ function expectsError(fn, settings, exact) {
         });
       }
 
-    }
+    });
     return true;
   }
   if (fn) {

test/parallel/test-assert-checktag.js

@@ -45,9 +45,9 @@ if (process.stdout && process.stdout.isTTY)
 if (!isBrowser) {  // At the moment global has its own type tag
   const fakeGlobal = {};
   Object.setPrototypeOf(fakeGlobal, Object.getPrototypeOf(global));
-  for (const prop of Object.keys(global)) {
+  Object.keys(global).forEach(prop => {
     fakeGlobal[prop] = global[prop];
-  }
+  });
   assert.notDeepEqual(fakeGlobal, global);
   // Message will be truncated anyway, don't validate
   assert.throws(() => assert.deepStrictEqual(fakeGlobal, global),
@@ -58,9 +58,9 @@ if (!isBrowser) {  // At the moment global has its own type tag
 if (!isBrowser) { // At the moment process has its own type tag
   const fakeProcess = {};
   Object.setPrototypeOf(fakeProcess, Object.getPrototypeOf(process));
-  for (const prop of Object.keys(process)) {
+  Object.keys(process).forEach(prop => {
     fakeProcess[prop] = process[prop];
-  }
+  });
   assert.notDeepEqual(fakeProcess, process);
   // Message will be truncated anyway, don't validate
   assert.throws(() => assert.deepStrictEqual(fakeProcess, process),