In my development work, I often encounter situations where I need to determine whether a function is a JavaScript native function. Sometimes this is a very necessary task. You need to know whether this function is provided by the browser itself, or is encapsulated and disguised as a native function by a third party. Of course, the best way is to examine the return value of the toString method that executes this function.
The JavaScript
The way to accomplish this task is very simple:
The code copy is as follows:
function isNative(fn) {
return (//{/s*/[native code/]/s*/}/).test('' + fn);
}
The toString method will return the string form of this method, and then use a regular expression to determine the characters contained in it.
A stronger method
John-David Dalton, the founder of Lodash, found a better solution:
The code copy is as follows:
;(function() {
// Used to resolve the internal `[[Class]]` of values
var toString = Object.prototype.toString;
// Used to resolve the decompiled source of functions
var fnToString = Function.prototype.toString;
// Used to detect host constructors (Safari > 4; really typed array specific)
var reHostCtor = /^/[object .+?Constructor/]$/;
// Compile a regexp using a common native method as a template.
// We choose `Object#toString` because there's a good chance it is not being mucked with.
var reNative = RegExp('^' +
// Coerce `Object#toString` to a string
String(toString)
// Escape any special regexp characters
.replace(/[.*+?^${}()|[/]////]/g, '//$&')
// Replace mentions of `toString` with `.*?` to keep the template generic.
// Replace thing like `for ...` to support environments like Rhino which add extra info
// such as method arity.
.replace(/toString|(function).*?(?=///()| for .+?(?=///])/g, '$1.*?') + '$'
);
function isNative(value) {
var type = typeof value;
return type == 'function'
// Use `Function#toString` to bypass the value's own `toString` method
// and avoid being faked out.
? reNative.test(fnToString.call(value))
// Fallback to a host object check because some environments will represent
// things like typed arrays as DOM methods which may not conform to the
// normal native pattern.
: (value && type == 'object' && reHostCtor.test(toString.call(value))) || false;
}
// export however you want
module.exports = isNative;
}());
Now you see it too, it's very complex, but more powerful. Of course, this is not for security protection, it just provides you with relevant information on whether it is a native function.