Javascript: was bedeutet diese Syntax (0,functionName)(functionParemeter); ?

Question

Ich war im JavaScript-Datei des Quellcodes von http://www.google.com unterwegs, mach das eigentlich oft und versuche zu verstehen, was sie dort gemacht haben. Heute war ich in den Dateien unterwegs und habe einige seltsame Funktionsaufrufe gefunden. Vielleicht ist es eine dumme Sache, aber ich habe wirklich keine Ahnung, was es ist und konnte daher nicht damit helfen, danach zu suchen.

Ein lesbarer Code-Ausschnitt-

var someFunction = function(somaeParamenter){
    //do some stuffs;
    return something;
}

var someOtherThing = (0, someFunction)(oneParameter);

Bitte entschuldigen Sie mein Unwissen.

EDIT:

Quelle-

Ich benutze Chrome. Während die Seite http://www.google.com geöffnet ist, öffnete ich das Entwicklertool. Dann öffnete ich den Reiter "Quellen" und öffnete die Datei https://www.google.com.bd/xjs/_/js/s/c,sb,cr,cdos,vm,tbui,mb,wobnm,cfm,abd,bihu,kp,lu,m,tnv,amcl,erh,hv,lc,ob,r,rsn,sf,sfa,shb,srl,tbpr,hsm,j,p,pcc,csi/rt=j/ver=WUW4ydIf-wI.en_US./am=gA/d=1/sv=1/rs=AItRSTPu52CumknQsh0was81vrM4inla_w im Viewer. Diese Datei ist die einzige JS-Datei, die ich dort gesehen habe. Ich habe das "pretty print" aktiviert und in Zeile 58 finden Sie die Definition-

_.Va = function(a) {
            var b = typeof a;
            if ("object" == b)
                if (a) {
                    if (a instanceof window.Array)
                        return "array";
                    if (a instanceof window.Object)
                        return b;
                    var c = window.Object.prototype.toString.call(a);
                    if ("[object Window]" == c)
                        return "object";
                    if ("[object Array]" == c || "number" == typeof a.length && "undefined" != typeof a.splice && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("splice"))
                        return "array";
                    if ("[object Function]" == c || "undefined" != typeof a.call && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("call"))
                        return "function"
                } else
                    return "null";
            else if ("function" == b && "undefined" == typeof a.call)
                return "object";
            return b
        };

und in Zeile 83 sehen Sie den Funktionsaufruf.

_.Za = function(a) {
            return "array" == (0, _.Va)(a)
        };

Answer 1

(0, someFunction)

einfach gibt someFunction zurück

also ist dies einfach äquivalent zu

var someOtherThing = someFunction(oneParameter);

Bist du sicher, dass du es genau so eingegeben hast, wie es war? Wenn ja, und es war keine Art von Verschleierung, dann könnte es das unglückliche Ergebnis einer Minifizierung sein. Wenn der echte Code etwas anders wäre, zum Beispiel (0, someObject.someFunction), könnte es eine Verwendung dieses indirekten Funktionaufrufs geben.

EDIT:

Deine Bearbeitung bestätigt, dass das Ziel wahrscheinlich war, sicherzustellen, dass this, innerhalb der Funktion, das globale Objekt (window in einem Browser) ist und nicht das Objekt, an dem Va angehängt war (_).