Performance enhancements

Author: andersnm

lib/validator.js

@@ -72,21 +72,20 @@ Validator.prototype.compile = function(schema) {
 };
 
 Validator.prototype.compileSchemaObject = function(schemaObject) {
-	if (schemaObject == null || typeof schemaObject !== "object" || Array.isArray(schemaObject)) {
+	if (schemaObject === null || typeof schemaObject !== "object" || Array.isArray(schemaObject)) {
 		throw new Error("Invalid schema!");
 	}
 
 	const self = this;
-	const checks = {};
-	for (let name in schemaObject) {
-		checks[name] = this.compileSchemaType(schemaObject[name]);
-	}
+	const checks = Object.keys(schemaObject).map(name => ({name: name, fn: this.compileSchemaType(schemaObject[name])}));
 
 	return function(value, _, path, parent) {
 		const errors = [];
-		for (let name in checks) {
-			const propertyPath = (path ? path + "." : "") + name;
-			const res = checks[name](value[name], schemaObject[name], propertyPath, value);
+		const checksLength = checks.length;
+		for (let i = 0; i < checksLength; i++) {
+			const check = checks[i];
+			const propertyPath = (path !== undefined ? path + "." : "") + check.name;
+			const res = check.fn(value[check.name], undefined, propertyPath, value);
 
 			if (res !== true) {
 				self.handleResult(errors, propertyPath, res);
@@ -105,18 +104,19 @@ Validator.prototype.compileSchemaType = function(schemaType) {
 
 		return function(value, _, path, parent) {
 			const errors = [];
-			let validated = false;
-			for (let i = 0; i < checks.length; i++) {
-				const res = checks[i](value, schemaType[i], path, parent);
+			const checksLength = checks.length;
+			for (let i = 0; i < checksLength; i++) {
+				const res = checks[i](value, undefined, path, parent);
 
 				if (res !== true) {
 					self.handleResult(errors, path, res);
 				} else {
-					validated = true;
+					// Jump out after first success and clear previous errors
+					return true;
 				}
 			}
 
-			return validated ? true : errors;
+			return errors;
 		};
 	}
 
@@ -130,13 +130,14 @@ Validator.prototype.compileSchemaRule = function(schemaRule) {
 		};
 	}
 
-	if (!this.rules[schemaRule.type]) {
+	const checkRule = this.rules[schemaRule.type];
+	if (!checkRule) {
 		throw new Error("Invalid '" + schemaRule.type + "' type in validator schema!");
 	}
 
 	const self = this;
 	let checkContents = null;
-	
+
 	if (schemaRule.type === "object") {
 		if (schemaRule.props) {
 			checkContents = this.compileSchemaObject(schemaRule.props);
@@ -148,13 +149,26 @@ Validator.prototype.compileSchemaRule = function(schemaRule) {
 	}
 
 	return function(value, _, path, parent) {
-		const res = self.checkRule(value, schemaRule, path, parent);
+		const errors = [];
+		if (value === undefined || value === null) {
+			if (schemaRule.type === "forbidden")
+				return true;
+
+			if (schemaRule.optional === true)
+				return true;
+
+			self.handleResult(errors, path, self.makeError("required"));
+			return errors;
+		}
+
+		const res = checkRule.call(self, value, schemaRule, path, parent);
 		if (res !== true) {
-			return res;
+			self.handleResult(errors, path, res);
+			return errors;
 		}
 
-		if (checkContents) {
-			return checkContents(value, schemaRule, path, parent);
+		if (checkContents !== null) {
+			return checkContents(value, undefined, path, parent);
 		}
 
 		return true;
@@ -167,9 +181,10 @@ Validator.prototype.compileSchemaArray = function(schemaType) {
 
 	return function (value, _, path, parent) {
 		const errors = [];
-		for (let i = 0; i < value.length; i++) {
-			const arrayItemPath = (path ? path : "") + "[" + i + "]";
-			const res = checkArrayItem(value[i], schemaType, arrayItemPath, value);
+		const valueLength = value.length;
+		for (let i = 0; i < valueLength; i++) {
+			const arrayItemPath = (path !== undefined ? path : "") + "[" + i + "]";
+			const res = checkArrayItem(value[i], undefined, arrayItemPath, value);
 
 			if (res !== true) {
 				self.handleResult(errors, arrayItemPath, res);
@@ -180,20 +195,6 @@ Validator.prototype.compileSchemaArray = function(schemaType) {
 	}
 };
 
-Validator.prototype.checkRule = function(value, schemaRule, path, parent) {
-	if (value === undefined || value === null) {
-		if (schemaRule.type === "forbidden")
-			return true;
-
-		if (schemaRule.optional === true)
-			return true;
-
-		return this.makeError("required");
-	}
-
-	return this.rules[schemaRule.type].call(this, value, schemaRule, path, parent);
-};
-
 /**
  * Handle results from validator functions
  *