Javascript: cosa significa questa sintassi (0, functionName) (functionParemeter);

Question

Mi stavo chiedendo nel file javascript dalla sorgente di http://www.google.com effettivamente lo faccio spesso e cerco di capire cosa hanno fatto lì. oggi mi stavo chiedendo all'interno dei file e ho trovato alcune strane chiamate di funzione. Forse è una cosa sciocca, ma non ho davvero idea di cosa sia e quindi non ho potuto aiutare cercando.

un leggibile assomigliano del code-

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

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

Chiedo scusa per la mia mancanza di conoscenza.

EDIT:

Source-

sto usando Chrome. mentre nella pagina http://www.google.com aperta, ho aperto lo strumento di sviluppo. poi ho aperto la scheda delle fonti e ho aperto il file 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 nel visualizzatore. questo file è l'unico file js che ho visto lì. Ho attivato il "pretty print" e in linea 58 si trova la defination-

_.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 
     }; 

e in linea 83 vedrai la funzione viene chiamata.

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

Answer 1

(0, someFunction) 

restituisce semplicemente someFunction

quindi questo è solo equivale a

var someOtherThing = someFunction(oneParameter); 

Sei sicuro che è stata digitata esattamente come era? Se è così, e se non fosse una sorta di offuscamento, allora potrebbe essere lo sfortunato risultato di qualche minificazione. Se il codice reale fosse un po 'diverso, ad esempio (0, someObject.someFunction), potrebbe esserci qualche utilizzo di questo indirect function call.

EDIT:

si modifica conferma che l'obiettivo era probabilmente quello di garantire che this, all'interno della funzione, è l'oggetto globale (window in un browser) e non l'oggetto su cui era collegato Va (_) .