rewrote parse - 1000x improvement :)

Author: Scott Switzer

src/object-mapper.js

@@ -6,22 +6,24 @@ var _undefined
 function ObjectMapper(from_object, to_object, property_map)
 {
   global.elapsed['ObjectMapper'].n++ // performance monitoring
+  let timer = performance.now()
 
   // There are a few different constructors - move around properties if needed
   if (typeof property_map === 'undefined') {
-    property_map = to_object;
+    property_map = to_object
     to_object = _undefined
   }
 
-  for (const [from_key, to_key] of Object.entries(property_map)) {
+  // Loop through the map to process individual mapping instructions
+  for (const [from_key_str, to_key_str] of Object.entries(property_map)) {
 
-    // Traverse the 'from' object
-    var from_data = getKeyValue(from_object, from_key)
- 
-    // Insert into the 'to' object
-    to_object = setKeyValue(to_object, to_key, from_data)
+    global.elapsed['ObjectMapper'].ms += (performance.now() - timer)
+    const from_data = getKeyValue(from_object, from_key_str)
+    to_object = setKeyValue(to_object, to_key_str, from_data)
+    timer = performance.now()
   }
 
+  global.elapsed['ObjectMapper'].ms += (performance.now() - timer)
   return to_object
 }
 
@@ -30,11 +32,14 @@ function update(obj, data, key_arr)
 {
   global.elapsed['update'].n++ // performance monitoring
   let timer = performance.now()
+
   let x = 0 // index of the key array
 
   var o
   // Get the object key and index that needs to be parsed
-  var [key, ix] = process(key_arr.shift())
+  global.elapsed['update'].ms += (performance.now() - timer)
+  var [key, ix] = key_arr.shift()
+  timer = performance.now()
 
   // If there is a key, we need to traverse down to this part of the object
   if (key) {
@@ -59,8 +64,10 @@ function update_obj(obj, key, data, key_arr)
   let timer = performance.now()
 
   // If the object is undefined, we need to create a new object
-  if (obj == null) obj = {}
-  // Set the key of the object equal to the recursive, or if at the end, the data
+  if (obj == null)
+    obj = {}
+  
+    // Set the key of the object equal to the recursive, or if at the end, the data
   if (key_arr.length > 0) {
     global.elapsed['update_obj'].ms += (performance.now() - timer)
     obj[key] = update(obj[key], data, key_arr)
@@ -90,6 +97,7 @@ function update_arr(obj, key, ix, data, key_arr)
         return o
       }
     }, obj)
+    global.elapsed['update_arr'].ms += (performance.now() - timer)
     return obj
   }
   // If there is more work to be done, push an object onto the array
@@ -115,33 +123,23 @@ function select(obj, key_arr)
   global.elapsed['select'].n++ // performance monitoring
   let timer = performance.now()
 
-  // Check to see if key_arr is not an array.  If so, wrap it in an array.
-  // This is done for backwards compatibility from external functions that pass in a string
-  if (!Array.isArray(key_arr))
-    key_arr = parse(key_arr)
-
-  // If we are at the end of the key array x`stack, return the object
-  if (key_arr.length == 0) {
-    global.elapsed['update_arr'].ms += (performance.now() - timer)
-    return obj
-  }
-
   // Get the object key or index that needs to be parsed
-  global.elapsed['update_arr'].ms += (performance.now() - timer)
-  var [key, ix] = process(key_arr.shift())
+  global.elapsed['select'].ms += (performance.now() - timer)
+  var [key, ix] = key_arr.shift()
   timer = performance.now()
 
   // If there is an object key, grab the object property
   if (key) {
-    global.elapsed['update_arr'].ms += (performance.now() - timer)
+    global.elapsed['select'].ms += (performance.now() - timer)
     return select_obj(obj, key, key_arr)
   }
 
   // If we need to deal with an array, then loop through and return recursive select for each
   if (Array.isArray(obj)) {
-    global.elapsed['update_arr'].ms += (performance.now() - timer)
+    global.elapsed['select'].ms += (performance.now() - timer)
     return select_arr(obj, key, ix, key_arr)
   }
+  global.elapsed['select'].ms += (performance.now() - timer)
 }
 
 function select_obj(obj, key, key_arr)
@@ -172,8 +170,9 @@ function select_arr(obj, key, ix, key_arr)
   // Recursively loop through the array and grab the data
   obj = obj.map( function(o) {
     global.elapsed['select_arr'].ms += (performance.now() - timer)
-    return select(o, key_arr.slice())
+    let _o = select(o, key_arr.slice())
     timer = performance.now()
+    return _o
   })
   // obj = obj.map( function(o) {
   //   global.elapsed['select_arr'].ms += (performance.now() - timer)
@@ -191,78 +190,96 @@ function select_arr(obj, key, ix, key_arr)
 
 // Turns a key string (like key1.key2[].key3 into ['key1','key2','[]','key3']...)
 // 
-function parse(key, delimiter = '.')
+function parse(key_str, delimiter = '.')
 {
   global.elapsed['parse'].n++ // performance monitoring
   let timer = performance.now()
-
-  if (typeof(key) == 'string') {
-    var key_array = key.split(delimiter)  
-    var keys = key_array.reduce(function(keys,current_key) {
-      var [k,ix] = process(current_key)
-      if (k) keys.push(k)
-      if (ix !== null) keys.push('[' + ix + ']')
-      return keys
-    }, [])
-    global.elapsed['parse'].ms += (performance.now() - timer)
-    return keys
+  let _default = null
+  let _transpose = null
+
+  // If the value was passed in object notation, grab the default and transpose values, then rewrite as a string
+  if (typeof(key) == 'object') {
+    _default = key_str.default
+    _transpose = key_str.transpose
+    key_str = key_str.key
   }
-  global.elapsed['parse'].ms += (performance.now() - timer)
-} 
-
-function process(k)
-{
-  global.elapsed['process'].n++ // performance monitoring
-  let timer = performance.now()
 
-  var arr
-  try {
-    var [_,key,ix] = k.match(/(.*?)\[(.*?)\]/)
-    arr = [key,ix]
-  } catch (e) {
-    arr = [k,null]
+  const key_arr = key_str.split(delimiter)
+  let keys = []
+  let n = 0
+  for (let i=0, len1=key_arr.length; i<len1; i++) {
+    // Build a object which is either an object key or an array
+    //  Note that this is not the most readable, but it is fastest way to parse the string (at this point in time)
+    let begin=-1, end=-1, key=key_arr[i]
+    for (let j=0, len2=key.length; j<len2; j++) {
+      if (key[j] == '[') begin = j
+      if (key[j] == ']' && begin > -1) {
+        end = j
+        break
+      }
+    }
+    // No array - just add object key
+    if (begin == -1) {
+      keys[n++] = [key_arr[i] || null, null]
+    }
+    // No key - just add array index
+    else if (begin == 0 && end > 0) {
+      keys[n++] = [null, key_arr[i].substring(begin+1,end)]
+    }
+    // Both object and array key
+    else if (begin > 0 && end > 0) {
+      keys[n++] = [key.substring(0,begin), null]
+      keys[n++] = [null, key.substring(begin+1,end)]
+    }
   }
   global.elapsed['parse'].ms += (performance.now() - timer)
-  return arr
-}
+  return keys
+} 
 
 // A string of how to navigate through the incoming array is sent.
 // This is translated into an array of instructions for the recursive object
 function getKeyValue(obj, key_str)
 {
   global.elapsed['getKeyValue'].n++ // performance monitoring
+  let timer = performance.now()
 
-  // String
-  if (typeof(key_str) == 'string') return select(obj,parse(key_str))
-  // Nothing else is valid
+  // Convert the mapping string into an array of instructions
+  //  e.g. 'foo.bar[].baz => foo, bar, [], baz
+  global.elapsed['getKeyValue'].ms += (performance.now() - timer)
+  let key_arr = parse(key_str)
+  timer = performance.now()
+
+  // Return the selected object
+  global.elapsed['getKeyValue'].ms += (performance.now() - timer)
+  return select(obj, key_arr)
 }
 
-function setKeyValue(obj,key_str,data)
+function setKeyValue(obj, key_str, data)
 {
   global.elapsed['setKeyValue'].n++ // performance monitoring
-
-  // Key_str is written as a simple string
-  if (typeof(key_str) == 'string')
-    return update(obj, data, parse(key_str))
+  let timer = performance.now()
 
   // Key_str is an array of values
   if (Array.isArray(key_str)) {
-    for (var i=0, len = key_str.length; i < len; i++) {
-      obj = update(obj, data, parse(key_str[i]))
+    for (let i=0, len=key_str.length; i<len; i++) {
+      global.elapsed['setKeyValue'].ms += (performance.now() - timer)
+      let key_arr = parse(to_key_str[i])
+      obj = update(obj, data, key_arr)
+      timer = performance.now()
     }
-    return obj
+  } else {
+    global.elapsed['setKeyValue'].ms += (performance.now() - timer)
+    let key_arr = parse(key_str)
+    obj = update(obj, data, key_arr)
+    timer = performance.now()
   }
-
-  // Key_str is written in object notation form
-  if (typeof(key_str) == 'object')
-    return update(obj, data, parse(key_str.key))
-
+  global.elapsed['setKeyValue'].ms += (performance.now() - timer)
+  return obj
   // Nothing else is valid
 }
 
 module.exports = ObjectMapper
 module.exports.getKeyValue = getKeyValue
 module.exports.setKeyValue = setKeyValue
-module.exports.process = process
 module.exports.parse = parse
 // module.exports.merge = ObjectMapper;