Was bedeutet "physisch gleich" in Haxe?

Question

Ich habe mit Neko Modulen herumgespielt, aber ich denke, dass ich ein inkonsistentes Verhalten bekomme.

var funcs = 0; 
var objs = 0; 
for (i in 0...m.globalsCount()) 
{ 
    var obj:Dynamic = m.getGlobal(i); 

    if (Reflect.compareMethods(obj, init)) 
     trace("matched"); 

    if (Reflect.isFunction(obj)) 
     funcs++; 
    else if (Reflect.isObject(obj)) 
     objs++; 
} 
trace('Functions: $funcs'); 
trace('Objects: $objs'); 

In dem obigen Code, wenn ich es das erste Mal ausführen, bekomme ich insgesamt 4487 Funktionen. Wenn ich eine Funktion entfernen, neu erstellen und ausführen, bekomme ich die erwarteten 4486.

ich den compareMethods Vergleich fügte die obj mit init zu vergleichen, wo init ist eine Funktion, die ich in der Hauptdatei deklarierte, aber die Spur nie ausgegeben .

Ich blickte auf den Code Hinweis für die compareMethods Funktion, und ich stolperte über die folgende Terminologie: if 'f1' and the 'f2' are **physically** equal.

Jetzt sind sie beide Funktionen, und nirgends im Haxe-Handbuch wird etwas über physikalische Funktionen erwähnt. Ich habe also wirklich eine zweiteilige Frage.

Was ist eine physikalische Funktion und wie erreiche ich das Tracergebnis, wie Sie es oben erwarten würden? Vielen Dank im Voraus.

Answer 1

Nach haxe Einheitentests (und js Quelle von Reflect) Reflect.compareMethods gibt true nur zurück, wenn Sie eine Methode des gleichen Objekts mit sich selbst vergleichen.

// https://github.com/HaxeFoundation/haxe/blob/ff3d7fe6911ab84c370b1334d537a768a55cca56/tests/unit/src/unit/TestReflect.hx 
// 
// t(expr) - expr should be true 
// f(expr) - expr should be false 

function testCompareMethods() { 
    var a = new MyClass(0); 
    var b = new MyClass(1); 
    t(Reflect.compareMethods(a.add,a.add)); 
    f(Reflect.compareMethods(a.add,b.add)); 
    f(Reflect.compareMethods(a.add,a.get)); 
    f(Reflect.compareMethods(a.add,null)); 
    f(Reflect.compareMethods(null, a.add)); 
    /* 
     Comparison between a method and a closure : 
     Not widely supported atm to justify officiel support 
     var fadd : Dynamic = Reflect.field(a, "add"); 
     var fget : Dynamic = Reflect.field(a, "get"); 
     t(Reflect.compareMethods(fadd, fadd)); 
     t(Reflect.compareMethods(a.add, fadd)); 
     t(Reflect.compareMethods(fadd, a.add)); 
     f(Reflect.compareMethods(fadd, fget)); 
     f(Reflect.compareMethods(fadd, a.get)); 
     f(Reflect.compareMethods(fadd, null)); 
    */ 
} 

Auch möglich Anwendungsfall

class Test { 
    static function main() { 
     var a = new A(); 
     var i:I = a; 
     trace(Reflect.compareMethods(a.test, i.test)); //returns true 
    } 
} 

interface I 
{ 
    function test():Void; 
} 

class A implements I 
{ 
    public function new() {} 
    public function test() {} 
}