Simpify getting object type name

[Connormiha]

Summary

There is function for checking object type

function isA(typeName: string, value: any): boolean {
  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
}

But this function called many times for same object. (12 times for same ref)

isA('Number', ref) ||
isA('String', ref) ||
isA('Boolean', ref) ||
isA('Symbol', ref)
... 

My fix added caching object name to avoid needless Object.prototype.toString.apply(value) === '[object ' + typeName + ']'.

We just can get object name only once.

function getObjectType(value: any): string {
  return Object.prototype.toString.apply(value).slice(8, -1);
}


typeName === 'Number' ||
typeName === 'String' ||
typeName === 'Boolean' ||
typeName === 'Symbol'
...

Test plan

[codecov-io]

Codecov Report

Merging #7159 into master will increase coverage by <.01%.
The diff coverage is 92.85%.

@@            Coverage Diff             @@
##           master    #7159      +/-   ##
==========================================
+ Coverage   66.43%   66.44%   +<.01%     
==========================================
  Files         253      253              
  Lines       10658    10664       +6     
  Branches        4        4              
==========================================
+ Hits         7081     7086       +5     
- Misses       3576     3577       +1     
  Partials        1        1

Impacted Files	Coverage Δ
packages/jest-mock/src/index.js	88.18% <92.85%> (-0.09%)	⬇️

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 24880d9...e3f4643. Read the comment docs.

[thymikee]

Do you have any perf benchmarks showing that this slice is not slowing down the whole caching effort?

[Connormiha]

slice(8, -1) works 4x faster than concatanation '[object ' + typeName + ']'.

Source of my test.

const map1 = new Map();
const map2 = new Map();
let start;

function isA(typeName, value) {
  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
}

function getObjectType(value) {
  return Object.prototype.toString.apply(value).slice(8, -1);
}

console.log('isA');
console.log('=======================');

start = process.hrtime()[1];
const compare1 = isA('Map', map1);
console.log(process.hrtime()[1] - start, compare1);


console.log('');
console.log('getObjectType');
console.log('=======================');
start = process.hrtime()[1];
const compare2 = getObjectType(map1) === 'Map';
console.log(process.hrtime()[1] - start, compare2);

Result of my tests (nano seconds):

isA
=======================
208620 true

getObjectType
=======================
57268 true

Tested on Node v10.10.0, MacOs.

[thymikee]

This is single execution without a warmup, hard to tell if it's representative. Can your run it on jsperf? Something like here https://twitter.com/bmeurer/status/867277137564360704?s=21

[SimenB]

The gain in jest's case is probably from doing the toString once instead of up to 12 times.

I doubt slice or not makes much of a difference. I don't think this is super hot code anyways - it's only used when generating mocks

[Connormiha]

Ok. full test.
Test compares original getType(with many isA calls) and getType from this PR with chaching.

https://jsperf.com/object-prototype-tostring-caching

[rickhanlonii]

here's the result:

fwiw, performance aside, I think this code is easier to read and maintain so I'm +1

[thymikee]

missing changelog entry and we're good? :)

[Connormiha]

I updated changelog. @thymikee

[thymikee]

Thanks!

[github-actions]

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.
Please note this issue tracker is not a help forum. We recommend using StackOverflow or our discord channel for questions.