typeValidator.js

function isValidType( type, value ) {

  function getType( item ) {
    return Object.prototype.toString.call( item ).slice( 8, -1 );
  }

  function checkPrimitiveType( type, value ) {
    return type == getType( value );
  }

  function checkObjectType( type, value ) {
    if ( getType( value ) != 'Object' ) return false;
    return Object.keys( type )
      .every( function ( tKey ) {
        return checkType( type[ tKey ], value[ tKey ] )
      } );
  }

  function checkArrayType( type, value ) {
    if ( getType( value ) != 'Array' ) return false;
    return value.every( function ( item ) {
      return checkType( type[ 0 ], item )
    } );
  }

  function checkType( type, value ) {
    switch ( getType( type ) ) {
      case 'Object': return checkObjectType( type, value );
      case 'Array': return checkArrayType( type, value );
      default: return checkPrimitiveType( type, value );
    }
  }

  return checkType( type, value );
}



// **************** Unit Tests **************** //

var type = {
  name: 'String',
  id: 'Number',
  active: 'Boolean',
  projects: [{
    name: 'String',
    id: 'Number',
    titles: [ 'String' ]
  }]
}

var trueValue = {
  name: 'Sandeep',
  id: 1,
  active: true,
  projects: [{
    name: 'String',
    id: 1,
    titles: [ 'JS', 'Core' ]
  }]
}

var falseValue = {
  name: 'Sandeep',
  id: 1,
  active: true
}

// Complete check
console.log('\nisValidType tests: \n');
console.log('True: ', isValidType( type, trueValue ) );
console.log('False: ', isValidType( type, falseValue ) );
console.log('False: ', isValidType( { a: 'String' }, { b: 12 } ) );
// console.log('True: ', isValidType( complexType, complexValue ) );

// checkArrayType
console.log('\ncheckArrayType tests: \n');
console.log('True: ', isValidType( ['String'], ['a', 'b', 'c'] ) );
console.log('False: ', isValidType( ['Number'], [1, 'a', 3] ) );

// checkObjectType
console.log('\ncheckObjectType tests: \n');
console.log('True: ', isValidType(
  { a: 'String', b: 'Number', c: 'Boolean' },
  { a: 'Sandeep', b: 123, c: true }
));
console.log('False: ', isValidType(
  { a: 'String', b: 'Number', c: 'Boolean' },
  { a: 'Sandeep', b: 123, c: 1 }
));

// checkPrimitiveType
console.log('\ncheckPrimitiveType tests: \n');
console.log('True: ', isValidType( 'String', 'Sandeep' ) );
console.log('True: ', isValidType( 'Number', 1.23 ) );
console.log('True: ', isValidType( 'Boolean', true ) );
console.log('False: ', isValidType( 'String', 1.12 ) );
console.log('False: ', isValidType( 'Number', 'Sandeep' ) );
console.log('False: ', isValidType( 'Boolean', 0.1 ) );

ES6 Version:

function isValidType( type, value ) {
    const getType = item => Object.prototype.toString.call(item).slice(8, -1);

    const checkPrimitiveType = (type, value) => type === getType(value);

    const checkObjectType = (type, value) => getType(value) != 'Object'
        ? false 
        : Object.keys(type).every(tKey => checkType(type[tKey], value[tKey]));

    const checkArrayType = (type, value) => getType(value) != 'Array'
        ? false
        : value.every(item => checkType(type[0], item));

    const checkType = (type, value) => {
        switch(getType(type)) {
            case 'Object': return checkObjectType(type, value);
            case 'Array': return checkArrayType(type, value);
            default: return checkPrimitiveType(type, value);
        }
    }

    return checkType( type, value );
}