How to determine that a JavaScript function is native (without testing '[native code]')

Question

I would like to know if there is a way to differentiate a JavaScript script function (function(){}) from a JavaScript native function (like Math.cos).
I already know the func.toString().indexOf('[native code]') != -1 trick but I was wondering if there is another way to detect it.

context:
I need to create a No-op forwarding ES6 Proxy that can handle native functions on an object but it fails with TypeError: Illegal invocation (see Illegal invocation error using ES6 Proxy and node.js).

To workaround this I .bind() all my functions in the get handler of my Proxy but if I could detect native function effectively, I will only need to .bind() these native functions.

more details: https://github.com/FranckFreiburger/module-invalidate/blob/master/index.js#L106

note:

(function() {}).toString() -> "function () {}"
(function() {}).prototype  -> {}

(require('os').cpus).toString() -> "function getCPUs() { [native code] }"
(require('os').cpus).prototype  -> getCPUs {}

(Math.cos).toString() -> "function cos() { [native code] }"
(Math.cos).prototype  -> undefined

(Promise.resolve().then).toString() -> "function then() { [native code] }"
(Promise.resolve().then).prototype  -> undefined

edit:
For the moment, the best solution is to test !('prototype' in fun) but it will not work with require('os').cpus ...

did you check this https://davidwalsh.name/detect-native-function ? — Tareq, Mar 04 '17 at 10:09
@Tareq, detect-native-function uses fnToString and regexp that is similar to `func.toString().indexOf('[native code]') != -1` — Franck Freiburger, Mar 04 '17 at 10:18
@jonrsharpe, I need to create a No-op forwarding ES6 Proxy that can handle native functions on an object but this fails (see http://stackoverflow.com/questions/42496414/illegal-invocation-error-using-es6-proxy-and-node-js). — Franck Freiburger, Mar 04 '17 at 10:26
It would be helpful to include that context in the question, so people don't suggest other methods with similar limitations. — jonrsharpe, Mar 04 '17 at 10:27
Your "trick" does not work at all: `function f() {return "[native code]";}` will result as if it were a built-in instead of a plain js function. — Bakuriu, Mar 04 '17 at 15:55
Prototype checking in es6 is not stable `func = () => {}; func.hasOwnProperty ('prototype') === false; ` — AlexeyP0708, Dec 31 '20 at 13:28

Nina Scholz · Answer 1 · 2017-03-04T12:24:25.233

16

You could try to use a Function constructor with the toString value of the function. If it does not throw an error, then you get a custom function, otherwise you have a native function.

function isNativeFn(fn) {
    try {
        void new Function(fn.toString());    
    } catch (e) {
        return true;
    }
    return false;
}

function customFn() { var foo; }

console.log(isNativeFn(Math.cos));          // true
console.log(isNativeFn(customFn));          // false
console.log(isNativeFn(customFn.bind({}))); // true, because bind

edited Mar 04 '17 at 12:24

answered Mar 04 '17 at 10:23

Nina Scholz

376,160
25
347
392

it's the nature of a `try ... catch` block, but without `indexOf` or an regex, i see no different way, acutally. – Nina Scholz Mar 04 '17 at 10:32
check out `console.log(isNativeFn( customFn.bind( {/*whatever*/} ));` – Thomas Mar 04 '17 at 12:05
*"The **`bind()`** method creates a new function"* and is obviously native. – Nina Scholz Mar 04 '17 at 12:08
1

True, but it does not throw `TypeError: Illegal invocation` when accessed through a ES6 Proxy – Franck Freiburger Mar 04 '17 at 12:18
1

Your isNativeFn can be bypassed. I forge a function: `var a=(function(){}).bind(null); isNativeFn(a); //true` – Sugar May 03 '17 at 07:14
@NinaScholz the `toString` also can be overriden, resulting an exception if you try to construct a function with that returned string from the overriden `toString` – Koushik Chatterjee Oct 16 '19 at 14:00
@KoushikChatterjee right, but then you can not trust the language anymore. – Nina Scholz Oct 16 '19 at 14:04

Thomas · Answer 2 · 2017-03-04T10:50:29.257

My summary on this topic: don't use it, it doesn't work. You can not certainly detect wether a function is native, because Function#bind() also creates "native" functions.

function isSupposedlyNative(fn){
    return (/\{\s*\[native code\]\s*\}/).test(fn);
}

function foo(){ }
var whatever = {};

console.log("Math.cos():", isSupposedlyNative( Math.cos ));
console.log("foo():", isSupposedlyNative( foo ));
console.log("foo.bind():", isSupposedlyNative( foo.bind(whatever) ));

And since the Version by John-David Dalton, which Tareq linked to in this comment, does basically the same that code doesn't work either. I've checked it.

And the approach from Nina works on a similar principle, because again it is the [native code] part in the function body wich throws the error when trying to parse it into a new function.

The only secure way to determine wether the function you're dealing with is the native function, is to hold a reference to the native function and compare your function against that reference, but I guess this is no option for your use case.

I agree. Additionally, nowadays we have the Proxy API that makes it even harder to detect whether a function is monkey patched. The only "safe" way to do this check is to hold a reference of the “clean” native function and, later on, compare your potentially monkey patched function with it (which can be impractical). I added some more context here: https://stackoverflow.com/a/73204287/4836602 — Matteo Mazzarolo, Aug 02 '22 at 08:32

How to determine that a JavaScript function is native (without testing '[native code]')

2 Answers2

Linked

Related