perf: improve parsing performance by pruning

Author: anonrig

README.md

@@ -48,17 +48,17 @@ console.log(qs.stringify({ foo: ['bar', 'baz'] }))
 ╔═════════════════════════════════════════╤═════════╤═══════════════════╤═══════════╗
 ║ Slower tests                            │ Samples │            Result │ Tolerance ║
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ qs                                      │    9000 │  320475.01 op/sec │  ± 1.00 % ║
-║ query-string                            │   10000 │  329524.10 op/sec │  ± 1.33 % ║
-║ querystringify                          │    1000 │  447654.63 op/sec │  ± 0.64 % ║
-║ @aws-sdk/querystring-parser             │    1000 │  467889.89 op/sec │  ± 0.75 % ║
-║ URLSearchParams-with-Object.fromEntries │   10000 │  836523.77 op/sec │  ± 3.43 % ║
-║ URLSearchParams-with-construct          │   10000 │ 1239361.94 op/sec │  ± 2.88 % ║
-║ node:querystring                        │   10000 │ 1399756.44 op/sec │  ± 4.07 % ║
+║ qs                                      │   10000 │  310498.16 op/sec │  ± 1.40 % ║
+║ query-string                            │   10000 │  335094.41 op/sec │  ± 1.06 % ║
+║ querystringify                          │   10000 │  444913.68 op/sec │  ± 1.32 % ║
+║ @aws-sdk/querystring-parser             │    1000 │  462867.39 op/sec │  ± 0.75 % ║
+║ URLSearchParams-with-Object.fromEntries │   10000 │  830585.13 op/sec │  ± 3.19 % ║
+║ URLSearchParams-with-construct          │   10000 │ 1216221.57 op/sec │  ± 3.46 % ║
+║ node:querystring                        │    3500 │ 1407749.94 op/sec │  ± 0.91 % ║
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
 ║ Fastest test                            │ Samples │            Result │ Tolerance ║
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ fast-querystring                        │    5500 │ 1496630.81 op/sec │  ± 0.98 % ║
+║ fast-querystring                        │   10000 │ 1575870.52 op/sec │  ± 2.80 % ║
 ╚═════════════════════════════════════════╧═════════╧═══════════════════╧═══════════╝
 ```
 

lib/parse.js

@@ -18,8 +18,10 @@ function parse(input) {
   let value = "";
   let startingIndex = -1;
   let equalityIndex = -1;
-  let shouldDecode = false;
-  let hasPlus = false;
+  let shouldDecodeKey = false;
+  let shouldDecodeValue = false;
+  let keyHasPlus = false;
+  let valueHasPlus = false;
 
   // Have a boundary of input.length + 1 to access last pair inside the loop.
   for (let i = 0; i < inputLength + 1; i++) {
@@ -41,14 +43,20 @@ function parse(input) {
       // Add key/value pair only if the range size is greater than 1; a.k.a. contains at least "="
       if (i - startingIndex > 1) {
         // Optimization: Replace '+' with space
-        if (hasPlus) {
+        if (keyHasPlus) {
           key = key.replaceAll("+", " ");
+        }
+
+        if (valueHasPlus) {
           value = value.replaceAll("+", " ");
         }
 
         // Optimization: Do not decode if it's not necessary.
-        if (shouldDecode) {
+        if (shouldDecodeKey) {
           key = fastDecode(key) || key;
+        }
+
+        if (shouldDecodeValue) {
           value = fastDecode(value) || value;
         }
 
@@ -70,25 +78,35 @@ function parse(input) {
       value = "";
       startingIndex = i;
       equalityIndex = i;
-      shouldDecode = false;
-      hasPlus = false;
+      shouldDecodeKey = false;
+      shouldDecodeValue = false;
+      keyHasPlus = false;
+      valueHasPlus = false;
     }
     // Check '='
     else if (c === 61) {
       // If '=' character occurs again, we should decode the input.
       if (equalityIndex > startingIndex) {
-        shouldDecode = true;
+        shouldDecodeValue = true;
       } else {
         equalityIndex = i;
       }
     }
     // Check '+', and replace it with empty space.
     else if (c === 43) {
-      hasPlus = true;
+      if (equalityIndex <= startingIndex) {
+        keyHasPlus = true;
+      } else {
+        valueHasPlus = true;
+      }
     }
     // Check '%' character for encoding
     else if (c === 37) {
-      shouldDecode = true;
+      if (equalityIndex <= startingIndex) {
+        shouldDecodeKey = true;
+      } else {
+        shouldDecodeValue = true;
+      }
     }
   }