Erkennen, ob die Funktion native browser

Ich versuche zu iterieren über alle den globals definiert, in eine Webseite, aber damit bin ich auch immer die native browser-Funktionen.

var numf=0; var nump=0; var numo=0; 
for(var p in this) { 
    if(typeof(this[p]) === "function"){
        numf+=1;
        console.log(p+"()");
    } else if(typeof p != 'undefined'){
        nump+=1;
        console.log(p);
    } else { 
        numo+=1;
        console.log(p);
    }
}

Gibt es eine Möglichkeit zu bestimmen, ob eine Funktion ist nativ auf dem browser oder in einem Skript?

InformationsquelleAutor asawilliams | 2011-07-06

global-variables javascript

14

Können Sie rufen Sie die geerbt .toString() Funktion, die auf den Methoden und überprüfen Sie das Ergebnis. Native Methoden wird ein block wie [native code].
```
if( this[p].toString().indexOf('[native code]') > -1 ) {
    //yep, native in the browser
}
```
Update, da viele der Kommentatoren wollen einige Klarstellungen und die Leute haben wirklich eine Anforderung für eine solche Erkennung. Um diese Prüfung wirklich sparen, wir sollten wahrscheinlich verwenden Sie eine Zeile dieses:
```
if( /\{\s+\[native code\]/.test( Function.prototype.toString.call( this[ p ] ) ) ) {
    //yep, native
}
```
Nun sind wir mit den .toString Methode aus der prototype von Function das macht es sehr unwahrscheinlich, wenn nicht unmöglich einigen anderen script überschrieben toString Methode. Zweitens, wir sind der überprüfung mit einem regulären Ausdruck, so können wir nicht täuschen lassen durch Kommentare innerhalb der Funktion Körper.
- Dies würde nur funktionieren, wenn die toString wurde nicht überschrieben, nicht?
- Ist das narrensicher? Ich dachte toString funktioniert nicht in allen modernen Browsern oder so etwas.
- wenn toString überschrieben, Sie sollten in der Lage sein zu tun Function.prototype.toString.call(obj).indexOf('[native code]'); Auch wäre es wahrscheinlich eine bessere Idee, mit RegExp. Versuchen Sie den Aufruf der Funktion gegen sich selbst, und es kommen würde, wie native, denn es erscheint in der Zeichenfolge.
- Wenn bind binden Sie eine Methode, um bestimmten Kontext, die resultierende Methode ist zwar nicht heimisch, aber Ihre check würde sagen, seine Muttersprache. window.alert = function () {}; window.alert = window.alert.bind()
- Hinweis: dies ist nicht die perfekte Lösung. Checkout gist.github.com/jdalton/5e34d890105aca44399f
- Also, wenn ich eine Funktion erstellen checkNative mit jAndy-code, wird es wieder true auf sich selbst.
- Was ist, wenn function () { /* [native code] */ console.log("I'm not native."); }?
InformationsquelleAutor jAndy
10
```
function isFuncNative(f) {
       return !!f && (typeof f).toLowerCase() == 'function' 
       && (f === Function.prototype 
       || /^\s*function\s*(\b[a-z$_][a-z0-9$_]*\b)*\s*$(|([a-z$_][a-z0-9$_]*)(\s*,[a-z$_][a-z0-9$_]*)*)$\s*{\s*\[native code\]\s*}\s*$/i.test(String(f)));
}
```
diesem sollte gut genug sein. diese Funktion führt die folgenden tests durch:
1. null oder undefined;
2. der param ist eigentlich eine Funktion;
3. die param-Funktion.Prototyp selbst (dieses ist ein besonderer Fall, wo die Funktion.der Prototyp.toString gibt function Empty(){})
4. der Hauptteil der Funktion ist genau function <valid_function_name> (<valid_param_list>) { [native code] }
regex ist ein wenig kompliziert, aber eigentlich läuft ziemlich anständig schnell in chrome auf meinem 4GB lenovo laptop (core duo):
```
var n = (new Date).getTime(); 
for (var i = 0; i < 1000000; i++) {
    i%2 ? isFuncNative(isFuncNative) : 
          isFuncNative(document.getElementById);
}; 
(new Date).getTime() - n;
```
3023ms. also die Funktion übernimmt, irgendwo um 3 micro-sec zu laufen, wenn man alles JIT ' ed.

Es funktioniert in allen Browsern. Zuvor, ich benutzte Funktion.der Prototyp.toString.Anruf, dieses stürzt ab, DH, da im IE der DOM-element-Methoden und-Fenster Methoden sind NICHT Funktionen, sondern Objekte, und Sie haben keine toString-Methode. String-Konstruktor löst das problem elegant.

InformationsquelleAutor Yong
0

Function.prototype.toString manipuliert werden können, etwas, das ein bisschen wie diese:
```
Function.prototype.toString = (function(_toString){
  return function() {
    if (shouldSpoof) return 'function() { [native code] }'
    return _toString.apply(this, arguments)
  }
})(Function.prototype.toString)
```
Können Sie erkennen, ob Function.prototype.toString ist verwüstet durch überfüllung .apply(), .call(), .bind() (und andere).

Und wenn es war, können Sie sich eine "saubere" version von Function.prototype.toString von einem neu gespritzt IFRAME.

InformationsquelleAutor cvazac
-1

Habe ich versucht einen anderen Ansatz. Dies ist nur getestet für firefox und chrome.
```
function isNative(obj){
    //Is there a function?
    //You may throw an exception instead if you want only functions to get in here.

    if(typeof obj === 'function'){
        //Check does this prototype appear as an object?
        //Most natives will not have a prototype of [object Object]
        //If not an [object Object] just skip to true.
        if(Object.prototype.toString.call(obj.prototype) === '[object Object]'){
            //Prototype was an object, but is the function Object?
            //If it's not Object it is not native.
            //This only fails if the Object function is assigned to prototype.constructor, or
            //Object function is assigned to the prototype, but
            //why you wanna do that?
            if(String(obj.prototype.constructor) !== String(Object.prototype.constructor)){
                return false;
            }
        }
    }
    return true;
}

function bla(){}

isNative(bla); //false
isNative(Number); //true
isNative(Object); //true
isNative(Function); //true
isNative(RegExp); //true
```
- Zurück false für Promise obwohl mein browser unterstützt das verspricht nativ.
- Ja, ich weiß nicht, warum das so ist. Versprechen.der Prototyp.Konstruktor ist nicht gleich Objekt.der Prototyp.Konstruktor. Ich in der Regel nicht testen, ob es natives sowieso, und suchen Sie nach der then Methode, die wie native verspricht beheben Bibliothek verspricht keiner Weise. Wenn alle Stricke reißen, dann benutze ich Promise.resolve(nonNative) zu normalisieren, alle verspricht.
- Meistens funktioniert in Chrome. Gibt false zurück, für RegExp.
- Interessant. In Firefox Object.prototype.toString.call(RegExp.prototype) zurück [Objekt RegExp]. Ich weiß nicht, über IE oder Opera.
- Ich downvoted, da war ich in der Lage, leicht machen es true zurück, auf eine nicht-native Funktion: let f = function() {}; f.prototype = Object.prototype; isNative(f) // true.
- Würden Sie das nicht nur tun, wenn man einen Konstruktor? Wenn Sie das eine machen, dann würden Sie nicht wissen, was es ist? Es gibt wirklich keine perfekte Lösungen für dieses spezielle problem. Ich habe darüber bekannt, die " [native code]' überprüfen Sie für eine lange Zeit, aber es gibt Situationen, in denen das funktioniert nicht so gut. Ich habe nicht gehört, dass in meiner Antwort, weil schon jemand anderes gepostet hat.
- Dem Konstruktor werden könnten, importiert von irgendwo und nicht von mir gemacht. Ich glaube, dass es nicht wirklich eine narrensichere Antwort. Ich wünschte, es war!
- Wenn es ein Konstruktor ist es nicht eine Funktion. Obwohl es ist. 😉 Du weißt Polymorphismus zerstört Identifizierbarkeit, oder so ähnlich. Aber noch, sind Sie wirklich gehend zu überprüfen, ob eine Funktion ist die native, wenn Sie wissen, es ist ein Konstruktor?
InformationsquelleAutor Quentin Engles

-1

fast alle scheitern, weil:

JS:

function notNative(){}
notNative.toString = String.bind(0, "function notNative() { [native code] }");
console.log( notNative.toString() );

statt:

JS:

Function.prototype.isNative = function(){
return Function.prototype.toString.call(this).slice(-14, -3) === "native code";
};

console.log(alert.isNative());
console.log(String.isNative());
function foo(){}
console.log(foo.isNative());

können Sie erläutern, warum Ihre Lösung besser ist und wie das funktioniert?

InformationsquelleAutor adddff

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.