Javascript - elegant way to check object has required properties

If you want "elegant", what you're looking for is called a schema:

var schema = { name: function (value) { return /^([A-Z][a-z\-]* )+[A-Z][a-z\-]*( \w+\.?)?$/.test(value); }, age: function (value) { return !isNaN(value) && parseInt(value) == value && value >= 18; }, phone: function (value) { return /^(\+?\d{1,2}-)?\d{3}-\d{3}-\d{4}$/.test(value); } }; var info = { name: "John Doe", age: "", phone: "123-456-7890" }; function validate(object, schema) { var errors = Object.keys(schema).filter(function (key) { return !schema[key](object[key]); }).map(function (key) { return new Error(key + " is invalid."); }); if (errors.length > 0) { errors.forEach(function (error) { console.log(error.message); }); } else { console.log("info is valid"); } } validate(info, schema);

To address @AndreFigueiredo's pedantry, you can also check if the object contains the property at all:

var schema = { name: function (value) { return /^([A-Z][a-z\-]* )+[A-Z][a-z\-]*( \w+\.?)?$/.test(value); }, age: function (value) { return !isNaN(value) && parseInt(value) == value && value >= 18; }, phone: function (value) { return /^(\+?\d{1,2}-)?\d{3}-\d{3}-\d{4}$/.test(value); } }; schema.name.required = true; schema.age.required = true; var info = { // name: "John Doe", age: "", phone: "123-456-7890" }; function validate(object, schema) { var errors = Object.keys(schema).map(function (property) { var validator = schema[property]; return [property, !validator.required || (property in object), validator(object[property])]; }).filter(function (entry) { return !entry[1] || !entry[2]; }).map(function (entry) { if (!entry[1]) return new Error(entry[0] + " is required."); else return new Error(entry[0] + " is invalid."); }); if (errors.length > 0) { errors.forEach(function (error) { console.log(error.message); }); } else { console.log("info is valid"); } } validate(info, schema);

Update

Here's a modernized solution using features from ECMAScript 6 edition including destructuring, arrow functions, Object.entries(), template literals, and for...of:

const schema = { name: value => /^([A-Z][a-z\-]* )+[A-Z][a-z\-]*( \w+\.?)?$/.test(value), age: value => parseInt(value) === Number(value) && value >= 18, phone: value => /^(\+?\d{1,2}-)?\d{3}-\d{3}-\d{4}$/.test(value) }; let info = { name: 'John Doe', age: '', phone: '123-456-7890' }; const validate = (object, schema) => Object .keys(schema) .filter(key => !schema[key](object[key])) .map(key => new Error(`${key} is invalid.`)); const errors = validate(info, schema); if (errors.length > 0) { for (const { message } of errors) { console.log(message); } } else { console.log('info is valid'); }

And the version that performs required and validate checks separately:

const schema = { name: value => /^([A-Z][a-z\-]* )+[A-Z][a-z\-]*( \w+\.?)?$/.test(value), age: value => parseInt(value) === Number(value) && value >= 18, phone: value => /^(\+?\d{1,2}-)?\d{3}-\d{3}-\d{4}$/.test(value) }; schema.name.required = true; schema.age.required = true; let info = { // name: 'John Doe', age: '', phone: '123-456-7890' }; const validate = (object, schema) => Object .entries(schema) .map(([key, validate]) => [ key, !validate.required || (key in object), validate(object[key]) ]) .filter(([_, ...tests]) => !tests.every(Boolean)) .map(([key, invalid]) => new Error(`${key} is ${invalid ? 'invalid' : 'required'}.`)); const errors = validate(info, schema); if (errors.length > 0) { for (const { message } of errors) { console.log(message); } } else { console.log('info is valid'); }

You can use https://github.com/jquense/yup to solve your problem.

import * as yup from 'yup'; let schema = yup.object().shape({ name: yup.string().required(), age: yup.number().required().positive().integer(), address: yup.string().required(), }); var info = { name: "John Doe", age: "", phone: "123-456-7890" } // check validity schema .isValid(info) .then(function (valid) { valid; // => false }); 

This is doing a bit more than just checking for the existence of fields, it's also ensuring that the data type is correct e.g. that age is a non-negative number.

I think that you should be more concerned about what's the proper way of checking for it, rather than the most elegant. I'll drop a link to a very good post from Todd Moto regarding this: Please, take a look

In short your code should look like this:

 var validateFields = function(o, required_fields) { required_fields.forEach(function(field){ if(field in o){ if((typeof o[field] != 'undefined')){ console.log(field + ": " + o[field]); }else{ console.log(field + " exists but is undefined"); } }else{ console.log(field + " doesn't exist in object"); } }); } 

Note: Take care when checking it has value, many expressions in javasscript are falsy (eg. 0, false, etc.) but are valid values.

I would do for a real check for empty strings, because 0 is falsy, but a value and not empty.

function validateFields(object, keys) { keys.forEach(function (k) { if (k in object) { console.log(k + ": " + object[k]); if (object[k] === '') { console.log(k + " exists but is empty"); } return; } console.log(k + " doesn't exist in object"); }); } var fields = ['name', 'age', 'address', 'zeroString', 'zeroNumber'], info = { name: "John Doe", age: "", phone: "123-456-7890", zeroString: '0', zeroNumber: 0 }; validateFields(info, fields);

Here's a function that will check that an Object contains every required key by comparing its keys to an array of strings. Since it validates by comparing lengths, it won't matter if the order is different or if the object contains additional information.

const hasRequiredKeys = (object, requiredKeys) => { return Object.keys(object).filter(key => requiredKeys.includes(key)).length === requiredKeys.length } 

Usage

exempleUsage(username: string, password: string) { checkRequiredProperties({username, password}) return this.apiService.post(`/.../...`) } 

Helpers

const isEmpty = (v) => (!v && v !== false && v !== 0); const handleErrorForCB = (error, errorCB) => { if (!errorCB) throw error; errorCB(error); }; export function hasProperty(o, p) { return !isEmpty(_.get(o, p)); } export function checkRequiredProperties(o, properties = Object.keys(o), errorCB) { const errors = properties.filter(p => !hasProperty(o, p)); if (errors.length > 0) handleErrorForCB(new Error("Missing properties: " + errors), errorCB); } export function checkFoundProperties(o, properties = Object.keys(o), errorCB) { const errors = properties.filter(p => !hasProperty(o, p)); if (errors.length > 0) handleErrorForCB(new Error("Not found: " + errors), errorCB); } 

!You can do the following

const checkObj = (obj, fields) => { if ('object' !== typeof obj || null == obj) { console.log('Object is not valid'); return false; } const hasOnlyTheKeys = JSON.stringify(Object.keys(obj).sort()) === JSON.stringify(fields.sort()); if (false === hasOnlyTheKeys) { console.log('Keys do not match'); return false; } for (let prop in Obj) { switch (obj[prop]) { case null: case undefined: console.log(prop + ' is undefined'); break; case '': console.log(prop + ' is empty string'); break; case 0: console.log(prop + ' is 0'); break; default: } } }; 

You can validate the fields array if you please Array.isArray(fields)