Improve stringNumbers parsing performance by up to 100%

Author: Ruben Bridgewater

README.md

@@ -29,6 +29,7 @@ var myParser = new Parser(options);
 * `returnError`: *function*; mandatory
 * `returnFatalError`: *function*; optional, defaults to the returnError function
 * `returnBuffers`: *boolean*; optional, defaults to false
+* `stringNumbers`: *boolean*; optional, defaults to false
 
 ### Example
 
@@ -66,7 +67,7 @@ You do not have to use the returnFatalError function. Fatal errors will be retur
 
 And if you want to return buffers instead of strings, you can do this by adding the `returnBuffers` option.
 
-Big numbers that are too large for JS are automatically stringified.
+If you handle with big numbers that are to large for JS (Number.MAX_SAFE_INTEGER === 2^53 - 16) please use the `stringNumbers` option. That way all numbers are going to be returned as String and you can handle them safely.
 
 ```js
 // Same functions as in the first example
@@ -78,7 +79,8 @@ var parser = new Parser({
     returnError: function(err) {
         lib.returnError(err);
     },
-    returnBuffers: true // All strings are returned as buffer e.g. <Buffer 48 65 6c 6c 6f>
+    returnBuffers: true, // All strings are returned as Buffer e.g. <Buffer 48 65 6c 6c 6f>
+    stringNumbers: true // All numbers are returned as String
 });
 
 // The streamHandler as above

benchmark/index.js

@@ -34,7 +34,7 @@ var startBuffer = new Buffer('$100\r\nabcdefghij')
 var chunkBuffer = new Buffer('abcdefghijabcdefghijabcdefghij')
 var stringBuffer = new Buffer('+testing a simple string\r\n')
 var integerBuffer = new Buffer(':1237884\r\n')
-var bigIntegerBuffer = new Buffer(':18446744073709551617\r\n') // 2^64 + 1
+var bigIntegerBuffer = new Buffer(':184467440737095516171234567890\r\n') // 2^64 + 1
 var errorBuffer = new Buffer('-Error ohnoesitbroke\r\n')
 var arrayBuffer = new Buffer('*1\r\n*1\r\n$1\r\na\r\n')
 var endBuffer = new Buffer('\r\n')

changelog.md

@@ -1,3 +1,9 @@
+## v.2.2.0 - 31 Oct, 2016
+
+Features
+
+-  Improve `stringNumbers` parsing performance by up to 100%
+
 ## v.2.1.1 - 31 Oct, 2016
 
 Bugfixes

lib/parser.js

@@ -37,26 +37,40 @@ function parseSimpleNumbers (parser) {
 
 /**
  * Used for integer numbers in case of the returnNumbers option
+ *
+ * The maximimum possible integer to use is: Math.floor(Number.MAX_SAFE_INTEGER / 10) - 9
+ *
  * @param parser
  * @returns {*}
  */
 function parseStringNumbers (parser) {
   var offset = parser.offset
-  var length = parser.buffer.length
-  var number = ''
+  var length = parser.buffer.length - 1
+  var number = 0
+  var res = ''
 
   if (parser.buffer[offset] === 45) {
-    number += '-'
+    res += '-'
     offset++
   }
 
   while (offset < length) {
     var c1 = parser.buffer[offset++]
-    if (c1 === 13 && parser.buffer[offset] === 10) { // \r\n
+    if (c1 === 13) { // \r\n
       parser.offset = offset + 1
-      return number
+      if (number !== 0) {
+        res += number
+      }
+      return res
+    } else if (number > 900719925474090) {
+      res += number
+      res += c1 - 48
+      number = 0
+    } else if (c1 === 48 && number === 0) {
+      res += 0
+    } else {
+      number = (number * 10) + (c1 - 48)
     }
-    number += c1 - 48
   }
 }
 

test/parsers.spec.js

@@ -541,7 +541,7 @@ describe('parsers', function () {
           return this.skip()
         }
         var replyCount = 0
-        var entries = ['123', '590295810358705700002', '-99999999999999999']
+        var entries = ['123', '590295810358705700002', '-99999999999999999', '9007199254740992', '90071992547409920', '10000040000000000000000000000000000000020']
         function checkReply (reply) {
           assert.strictEqual(typeof reply, 'string')
           assert.strictEqual(reply, entries[replyCount])
@@ -551,8 +551,8 @@ describe('parsers', function () {
           returnReply: checkReply,
           stringNumbers: true
         })
-        parser.execute(new Buffer(':123\r\n:590295810358705700002\r\n:-99999999999999999\r\n'))
-        assert.strictEqual(replyCount, 3)
+        parser.execute(new Buffer(':123\r\n:590295810358705700002\r\n:-99999999999999999\r\n:9007199254740992\r\n:90071992547409920\r\n:10000040000000000000000000000000000000020\r\n'))
+        assert.strictEqual(replyCount, 6)
       })
 
       it('handle big numbers', function () {