Run results for: schema vs manual f

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36

Browser: Chrome 96

Operating system: Windows

Device Platform: Desktop

Date tested: 2 years ago

Test name	Executions per second
hp	1186694.5 Ops/sec
hps	926378.7 Ops/sec
ref	1981807.5 Ops/sec

Script Preparation code:

function hasProp(obj, prop, type) {
  return (prop in obj && typeof obj[prop] === type);
}

function hasProps(obj, schema) {
  for (const [prop, type] of Object.entries(schema)) {
    if (!(prop in obj && typeof obj[prop] === type)) {
      return false;
    }
  }
  return true;
}

function hasProps2(obj, schema) {
    const entries = Object.entries(schema);
    for (let i = 0, length = entries.length; i < length; ++i) {
        if (!(entries[i][0] in obj && (entries[i][1] === 'array' ? Array.isArray(obj[entries[i][0]]) : typeof obj[entries[i][0]] === entries[i][1]))) {
            return false;
        }
    }
    return true;
}

const testTypes = ['undefined', 'object', 'boolean', 'number', 'bigint', 'string', 'symbol', 'function', 'array'];

const o = {
  a: undefined,
  b: {},
  c: true,
  c2: false,
  d: -34,
  e: BigInt(56),
  f: 'yass',
  f2: '',
  g: Symbol('queen'),
  h: (a, b) => a + b.length,
  i: [1, 32],
};

function cartesianProduct(...allEntries) {
  return allEntries.reduce((results, entries) => results
    .map((result) => entries.map((entry) => [...result, entry]))
    .reduce((subResults, result) => [...subResults, ...result], []), [[]]);
}
const testParams = cartesianProduct(Object.keys(o), testTypes);

const schema = {
  a: 'undefined',
  f: 'string',
  g: 'symbol',
  i: 'object'
}

function hp() {
  if (Math.round(Math.random())) {
    return hasProp(o, "a", 'undefined') && hasProp(o, "f", 'string') && hasProp(o, "g", 'symbol') && hasProp(o, "i", 'object');
  } else {
    return true
  }
}



function hps() {
  if (Math.round(Math.random())) {
    return hasProps(o, schema);
  } else {
    return true
  }
}

function ref() {
  if (Math.round(Math.random())) {
    return "a" in o && typeof o.a === 'undefined' && "f" in o && typeof o.f === 'string' && "g" in o && typeof o.g === 'symbol' && "i" in o && typeof o.i === 'object';
  } else {
    return true
  }
}

Tests:

hp
let r1 = false; r1 = hp(); const r = `${r1} + 4`;
hps
let r2 = false; r2 = hps(); const r = `${r2} + 4`;
ref
let r3 = false; r3 = ref(); const r = `${r3} + 4`;