fast-querystring - npm Package Compare versions

Comparing version 0.6.0 to 0.6.1

lib/parse.js

@@ -5,2 +5,4 @@ "use strict";
 
+const plusRegex = /\+/g;
+
 /**
@@ -37,6 +39,5 @@ * @callback parse
       keyEndingIndex = hasBothKeyValuePair ? equalityIndex : i;
-
       key = input.slice(startingIndex + 1, keyEndingIndex);
 
-      // Check if the current range consist of a single key
+      // Only update value if '=' exists in the current range
       if (hasBothKeyValuePair) {
@@ -50,3 +51,3 @@ value = input.slice(equalityIndex + 1, i);
         if (keyHasPlus) {
-          key = key.replaceAll("+", " ");
+          key = key.replace(plusRegex, " ");
         }
@@ -61,3 +62,3 @@
           if (valueHasPlus) {
-            value = value.replaceAll("+", " ");
+            value = value.replace(plusRegex, " ");
           }
@@ -75,2 +76,3 @@
 
+          // Optimization: value.pop is faster than Array.isArray(value)
           if (currentValue.pop) {
@@ -85,3 +87,2 @@ currentValue.push(value);
       // Reset reading key value pairs
-      key = "";
       value = "";
@@ -105,3 +106,3 @@ startingIndex = i;
     }
-    // Check '+', and replace it with empty space.
+    // Check '+', and remember to replace it with empty space.
     else if (c === 43) {
@@ -108,0 +109,0 @@ if (equalityIndex <= startingIndex) {

lib/stringify.js

@@ -37,2 +37,4 @@ "use strict";
   const keyLength = keys.length;
+  const separator = "&";
+  let valueLength = 0;
 
@@ -45,16 +47,20 @@ for (let i = 0; i < keyLength; i++) {
     if (i) {
-      result += "&";
+      result += separator;
     }
 
     if (Array.isArray(value)) {
-      const valueLength = value.length;
+      valueLength = value.length;
       for (let j = 0; j < valueLength; j++) {
         if (j) {
-          result += "&";
+          result += separator;
         }
 
-        result += encodedKey + getAsPrimitive(value[j]);
+        // Optimization: Dividing into multiple lines improves the performance.
+        // Since v8 does not need to care about the '+' character if it was one-liner.
+        result += encodedKey;
+        result += getAsPrimitive(value[j]);
       }
     } else {
-      result += encodedKey + getAsPrimitive(value);
+      result += encodedKey;
+      result += getAsPrimitive(value);
     }
@@ -61,0 +67,0 @@ }

package.json

 {
   "name": "fast-querystring",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "",
   "main": "lib/index.js",
   "type": "commonjs",
-  "engines": {
-    "node": ">= 15.0.0"
-  },
   "scripts": {
@@ -11,0 +8,0 @@ "format": "rome format . --write",

README.md

@@ -51,13 +51,13 @@ # fast-querystring
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ qs                                      │   10000 │  314822.82 op/sec │  ± 1.12 % ║
-║ query-string                            │    1000 │  330364.46 op/sec │  ± 0.89 % ║
-║ querystringify                          │   10000 │  442352.24 op/sec │  ± 1.31 % ║
-║ @aws-sdk/querystring-parser             │   10000 │  471561.65 op/sec │  ± 1.12 % ║
-║ URLSearchParams-with-Object.fromEntries │   10000 │  865453.19 op/sec │  ± 2.29 % ║
-║ URLSearchParams-with-construct          │   10000 │ 1234031.63 op/sec │  ± 3.12 % ║
-║ node:querystring                        │   10000 │ 1484397.94 op/sec │  ± 2.46 % ║
+║ qs                                      │   10000 │  317841.53 op/sec │  ± 1.18 % ║
+║ query-string                            │   10000 │  341009.91 op/sec │  ± 1.06 % ║
+║ querystringify                          │    1000 │  451609.79 op/sec │  ± 0.61 % ║
+║ @aws-sdk/querystring-parser             │    1000 │  477241.09 op/sec │  ± 0.69 % ║
+║ URLSearchParams-with-Object.fromEntries │   10000 │  870095.07 op/sec │  ± 3.29 % ║
+║ URLSearchParams-with-construct          │   10000 │ 1232650.60 op/sec │  ± 2.95 % ║
+║ node:querystring                        │   10000 │ 1462802.04 op/sec │  ± 3.69 % ║
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
 ║ Fastest test                            │ Samples │            Result │ Tolerance ║
 ╟─────────────────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ fast-querystring                        │   10000 │ 1798615.82 op/sec │  ± 2.65 % ║
+║ fast-querystring                        │   10000 │ 1809816.84 op/sec │  ± 3.19 % ║
 ╚═════════════════════════════════════════╧═════════╧═══════════════════╧═══════════╝
@@ -74,13 +74,13 @@ ```
 ╟────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ query-string               │   10000 │  290850.12 op/sec │  ± 1.52 % ║
-║ qs                         │   10000 │  324324.45 op/sec │  ± 2.05 % ║
-║ http-querystring-stringify │   10000 │  481327.85 op/sec │  ± 1.77 % ║
-║ URLSearchParams            │   10000 │  538867.84 op/sec │  ± 3.93 % ║
-║ querystringify             │   10000 │  774992.18 op/sec │  ± 2.51 % ║
-║ node:querystring           │   10000 │ 1827458.66 op/sec │  ± 5.41 % ║
+║ query-string               │   10000 │  284130.63 op/sec │  ± 1.62 % ║
+║ qs                         │   10000 │  334799.48 op/sec │  ± 1.93 % ║
+║ http-querystring-stringify │   10000 │  482642.49 op/sec │  ± 1.72 % ║
+║ URLSearchParams            │   10000 │  587274.65 op/sec │  ± 1.88 % ║
+║ querystringify             │   10000 │  753960.35 op/sec │  ± 2.20 % ║
+║ node:querystring           │   10000 │ 1796993.95 op/sec │  ± 5.34 % ║
 ╟────────────────────────────┼─────────┼───────────────────┼───────────╢
 ║ Fastest test               │ Samples │            Result │ Tolerance ║
 ╟────────────────────────────┼─────────┼───────────────────┼───────────╢
-║ fast-querystring           │   10000 │ 1881474.27 op/sec │  ± 4.78 % ║
+║ fast-querystring           │   10000 │ 2051022.89 op/sec │  ± 4.52 % ║
 ╚════════════════════════════╧═════════╧═══════════════════╧═══════════╝
 ```

No alert changes

Improved metrics

Total package byte prevSize

14817

increased by2.14%

Lines of code

253

increased by2.85%

No dependency changes