Merge pull request #10813 from yfdyh000/for-of

Use for-of and Array.filter instead of general `for`

Author: Hainish

chromium/background.js

@@ -90,8 +90,8 @@ var wr = chrome.webRequest;
 var loadStoredUserRules = function() {
   var rules = getStoredUserRules();
   var i;
-  for (i = 0; i < rules.length; ++i) {
-    all_rules.addUserRule(rules[i]);
+  for (let rule of rules) {
+    all_rules.addUserRule(rule);
   }
   log('INFO', 'loaded ' + i + ' stored user rules');
 };
@@ -159,16 +159,13 @@ var addNewRule = function(params, cb) {
 var removeRule = function(ruleset) {
   if (all_rules.removeUserRule(ruleset)) {
     // If we successfully removed the user rule, remove it in local storage too
-    var oldUserRules = getStoredUserRules();
-    for (let x = 0; x < oldUserRules.length; x++) {
-      if (oldUserRules[x].host == ruleset.name &&
-          oldUserRules[x].redirectTo == ruleset.rules[0].to &&
-          String(RegExp(oldUserRules[x].urlMatcher)) == String(ruleset.rules[0].from_c)) {
-        oldUserRules.splice(x, 1);
-        break;
-      }
-    }
-    localStorage.setItem(USER_RULE_KEY, JSON.stringify(oldUserRules));
+    var userRules = getStoredUserRules();
+    userRules = userRules.filter(r =>
+      !(r.host == ruleset.name &&
+        r.redirectTo == ruleset.rules[0].to &&
+        String(RegExp(r.urlMatcher)) == String(ruleset.rules[0].from_c))
+    );
+    localStorage.setItem(USER_RULE_KEY, JSON.stringify(userRules));
   }
 }
 

chromium/popup.js

@@ -58,8 +58,8 @@ function appendRuleLineToListDiv(ruleset, list_div) {
   var favicon = document.createElement("img");
   favicon.className = "favicon";
   favicon.src = "chrome://favicon/";
-  for (var i=0; i < ruleset.rules.length; i++) {
-    var host = hostReg.exec(ruleset.rules[i].to);
+  for (let rule of ruleset.rules) {
+    var host = hostReg.exec(rule.to);
     if (host) {
       favicon.src += host[0];
       break;
@@ -176,8 +176,8 @@ document.addEventListener("DOMContentLoaded", function () {
 
   // auto-translate all elements with i18n attributes
   var elem = document.querySelectorAll("[i18n]");
-  for (var i=0; i < elem.length; i++) {
-    elem[i].innerHTML = chrome.i18n.getMessage(elem[i].getAttribute("i18n"));
+  for (let el of elem) {
+    el.innerHTML = chrome.i18n.getMessage(el.getAttribute("i18n"));
   }
 
   // other translations

chromium/rules.js

@@ -89,18 +89,18 @@ RuleSet.prototype = {
     var returl = null;
     // If we're covered by an exclusion, go home
     if (this.exclusions !== null) {
-      for (var i = 0; i < this.exclusions.length; ++i) {
-        if (this.exclusions[i].pattern_c.test(urispec)) {
+      for (let exclusion of this.exclusions) {
+        if (exclusion.pattern_c.test(urispec)) {
           log(DBUG, "excluded uri " + urispec);
           return null;
         }
       }
     }
 
     // Okay, now find the first rule that triggers
-    for(var i = 0; i < this.rules.length; ++i) {
-      returl = urispec.replace(this.rules[i].from_c,
-                               this.rules[i].to);
+    for (let rule of this.rules) {
+      returl = urispec.replace(rule.from_c,
+                               rule.to);
       if (returl != urispec) {
         return returl;
       }
@@ -194,9 +194,9 @@ RuleSets.prototype = {
    */
   addFromXml: function(ruleXml) {
     var sets = ruleXml.getElementsByTagName("ruleset");
-    for (var i = 0; i < sets.length; ++i) {
+    for (let s of sets) {
       try {
-        this.parseOneRuleset(sets[i]);
+        this.parseOneRuleset(s);
       } catch (e) {
         log(WARN, 'Error processing ruleset:' + e);
       }
@@ -234,11 +234,9 @@ RuleSets.prototype = {
   removeUserRule: function(ruleset) {
     log(INFO, 'removing user rule for ' + JSON.stringify(ruleset));
     this.ruleCache.delete(ruleset.name);
-    for(let x = 0; x < this.targets[ruleset.name].length; x++) {
-      if(this.targets[ruleset.name][x].isEquivalentTo(ruleset)) {
-        this.targets[ruleset.name].splice(x, 1);
-      }
-    }
+    this.targets[ruleset.name] = this.targets[ruleset.name].filter(r =>
+      !(r.isEquivalentTo(ruleset))
+    );
     if (this.targets[ruleset.name].length == 0) {
       delete this.targets[ruleset.name];
     }
@@ -280,33 +278,33 @@ RuleSets.prototype = {
     }
 
     var rules = ruletag.getElementsByTagName("rule");
-    for(var j = 0; j < rules.length; j++) {
-      rule_set.rules.push(new Rule(rules[j].getAttribute("from"),
-                                    rules[j].getAttribute("to")));
+    for (let rule of rules) {
+      rule_set.rules.push(new Rule(rule.getAttribute("from"),
+                                    rule.getAttribute("to")));
     }
 
     var exclusions = ruletag.getElementsByTagName("exclusion");
     if (exclusions.length > 0) {
       rule_set.exclusions = [];
-      for (var j = 0; j < exclusions.length; j++) {
+      for (let exclusion of exclusions) {
         rule_set.exclusions.push(
-            new Exclusion(exclusions[j].getAttribute("pattern")));
+          new Exclusion(exclusion.getAttribute("pattern")));
       }
     }
 
     var cookierules = ruletag.getElementsByTagName("securecookie");
     if (cookierules.length > 0) {
       rule_set.cookierules = [];
-      for(var j = 0; j < cookierules.length; j++) {
+      for (let cookierule of cookierules) {
         rule_set.cookierules.push(
-            new CookieRule(cookierules[j].getAttribute("host"),
-                cookierules[j].getAttribute("name")));
+          new CookieRule(cookierule.getAttribute("host"),
+            cookierule.getAttribute("name")));
       }
     }
 
     var targets = ruletag.getElementsByTagName("target");
-    for(var j = 0; j < targets.length; j++) {
-       var host = targets[j].getAttribute("host");
+    for (let target of targets) {
+       var host = target.getAttribute("host");
        if (!(host in this.targets)) {
          this.targets[host] = [];
        }
@@ -343,11 +341,11 @@ RuleSets.prototype = {
 
     // Replace each portion of the domain with a * in turn
     var segmented = host.split(".");
-    for (var i = 0; i < segmented.length; ++i) {
-      tmp = segmented[i];
-      segmented[i] = "*";
+    for (let s of segmented) {
+      tmp = s;
+      s = "*";
       results = results.concat(this.targets[segmented.join(".")]);
-      segmented[i] = tmp;
+      s = tmp;
     }
     // now eat away from the left, with *, so that for x.y.z.google.com we
     // check *.z.google.com and *.google.com (we did *.y.z.google.com above)
@@ -400,8 +398,8 @@ RuleSets.prototype = {
     var potentiallyApplicable = this.potentiallyApplicableRulesets(hostname);
     for (let ruleset of potentiallyApplicable) {
       if (ruleset.cookierules !== null && ruleset.active) {
-        for (var j = 0; j < ruleset.cookierules.length; j++) {
-          var cr = ruleset.cookierules[j];
+        for (let cookierules of ruleset.cookierules) {
+          var cr = cookierules;
           if (cr.host_c.test(cookie.domain) && cr.name_c.test(cookie.name)) {
             return ruleset;
           }