A few optimizations

Author: Marsup

lib/array.js

@@ -38,6 +38,17 @@ internals.Array = function () {
 Hoek.inherits(internals.Array, Any);
 
 
+internals.safeParse = function (value, result) {
+
+    try {
+        const converted = JSON.parse(value);
+        if (Array.isArray(converted)) {
+            result.value = converted;
+        }
+    }
+    catch (e) { }
+};
+
 internals.Array.prototype._base = function (value, state, options) {
 
     const result = {
@@ -47,13 +58,7 @@ internals.Array.prototype._base = function (value, state, options) {
     if (typeof value === 'string' &&
         options.convert) {
 
-        try {
-            const converted = JSON.parse(value);
-            if (Array.isArray(converted)) {
-                result.value = converted;
-            }
-        }
-        catch (e) { }
+        internals.safeParse(value, result);
     }
 
     let isArray = Array.isArray(result.value);

lib/object.js

@@ -25,6 +25,15 @@ internals.Object = function () {
 
 Hoek.inherits(internals.Object, Any);
 
+internals.safeParse = function (value) {
+
+    try {
+        return JSON.parse(value);
+    }
+    catch (parseErr) {}
+
+    return value;
+};
 
 internals.Object.prototype._base = function (value, state, options) {
 
@@ -41,10 +50,7 @@ internals.Object.prototype._base = function (value, state, options) {
     if (typeof value === 'string' &&
         options.convert) {
 
-        try {
-            value = JSON.parse(value);
-        }
-        catch (parseErr) { }
+        value = internals.safeParse(value);
     }
 
     const type = this._flags.func ? 'function' : 'object';
@@ -95,42 +101,42 @@ internals.Object.prototype._base = function (value, state, options) {
 
     const renamed = {};
     for (let i = 0; i < this._inner.renames.length; ++i) {
-        const item = this._inner.renames[i];
+        const rename = this._inner.renames[i];
 
-        if (item.options.ignoreUndefined && target[item.from] === undefined) {
+        if (rename.options.ignoreUndefined && target[rename.from] === undefined) {
             continue;
         }
 
-        if (!item.options.multiple &&
-            renamed[item.to]) {
+        if (!rename.options.multiple &&
+            renamed[rename.to]) {
 
-            errors.push(this.createError('object.rename.multiple', { from: item.from, to: item.to }, state, options));
+            errors.push(this.createError('object.rename.multiple', { from: rename.from, to: rename.to }, state, options));
             if (options.abortEarly) {
                 return finish();
             }
         }
 
-        if (Object.prototype.hasOwnProperty.call(target, item.to) &&
-            !item.options.override &&
-            !renamed[item.to]) {
+        if (Object.prototype.hasOwnProperty.call(target, rename.to) &&
+            !rename.options.override &&
+            !renamed[rename.to]) {
 
-            errors.push(this.createError('object.rename.override', { from: item.from, to: item.to }, state, options));
+            errors.push(this.createError('object.rename.override', { from: rename.from, to: rename.to }, state, options));
             if (options.abortEarly) {
                 return finish();
             }
         }
 
-        if (target[item.from] === undefined) {
-            delete target[item.to];
+        if (target[rename.from] === undefined) {
+            delete target[rename.to];
         }
         else {
-            target[item.to] = target[item.from];
+            target[rename.to] = target[rename.from];
         }
 
-        renamed[item.to] = true;
+        renamed[rename.to] = true;
 
-        if (!item.options.alias) {
-            delete target[item.from];
+        if (!rename.options.alias) {
+            delete target[rename.from];
         }
     }
 
@@ -185,15 +191,15 @@ internals.Object.prototype._base = function (value, state, options) {
 
         for (let i = 0; i < unprocessedKeys.length; ++i) {
             const key = unprocessedKeys[i];
+            const localState = { key, path: (state.path ? state.path + '.' : '') + key, parent: target, reference: state.reference };
+            const item = target[key];
 
             for (let j = 0; j < this._inner.patterns.length; ++j) {
                 const pattern = this._inner.patterns[j];
 
                 if (pattern.regex.test(key)) {
                     delete unprocessed[key];
 
-                    const item = target[key];
-                    const localState = { key, path: (state.path ? state.path + '.' : '') + key, parent: target, reference: state.reference };
                     const result = pattern.rule._validate(item, localState, options);
                     if (result.errors) {
                         errors.push(this.createError('object.child', { key, reason: result.errors }, localState, options));