Ottieni il valore predefinito della funzione?

Question

C'è un modo per recuperare il valore di argomento predefinito di una funzione in JavaScript?

function foo(x = 5) { 
    // things I do not control 
} 

C'è un modo per ottenere il valore di default di x qui? In modo ottimale, qualcosa come:

getDefaultValues(foo); // {"x": 5} 

Nota che toString ing la funzione non avrebbe funzionato come si spezzerebbe il default che non sono costanti.

Answer 1

mi piacerebbe affrontare il problema estraendo i parametri da una versione stringa della funzione: metodo di estrazione

// making x=3 into {x: 3} 
function serialize(args) { 
    var obj = {}; 
    var noWhiteSpace = new RegExp(" ", "g"); 
    args = args.split(","); 
    args.forEach(function(arg) { 
    arg = arg.split("="); 
    var key = arg[0].replace(noWhiteSpace, ""); 
    obj[key] = arg[1]; 
    }); 
    return obj; 
    } 

function foo(x=5, y=7, z='foo') {} 

// converting the function into a string 
var fn = foo.toString(); 

// magic regex to extract the arguments 
var args = /\(\s*([^)]+?)\s*\)/.exec(fn); 

//getting the object 
var argMap = serialize(args[1]); // {x: "5", y: "7", z: "'foo'"} 

argomento è stato preso da qui: Regular Expression to get parameter list from function definition

applausi!

PS. come puoi vedere, trasforma gli interi in stringhe, che a volte possono essere fastidiosi. assicurati di conoscere in anticipo il tipo di input o assicurati che non sia importante.

Answer 2

Dal momento che non abbiamo riflessione classica in JS, come si può trovare su C#, Ruby, ecc, dobbiamo fare affidamento su uno dei miei strumenti preferiti, le espressioni regolari, per fare questo lavoro per noi:

let b = "foo"; 
function fn (x = 10, /* woah */ y = 20, z, a = b) { /* ... */ } 

fn.toString() 
    .match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1] // Get the parameters declaration between the parenthesis 
    .replace(/(\/\*[\s\S]*?\*\/)/mg,'')    // Get rid of comments 
    .split(',') 
    .reduce(function (parameters, param) {   // Convert it into an object 
    param = param.match(/([_$a-zA-Z][^=]*)(?:=([^=]+))?/); // Split parameter name from value 
    parameters[param[1].trim()] = eval(param[2]); // Eval each default value, to get strings, variable refs, etc. 

    return parameters; 
    }, {}); 

// Object { x: 10, y: 20, z: undefined, a: "foo" } 

Se si intende utilizzare questo, è sufficiente assicurarsi di memorizzare le regex per le prestazioni.

Grazie a bubersson per suggerimenti sui primi due regexs

Answer 3

Come afferma trattasi utilizzando toString è una soluzione limitata. Produrrà un risultato che potrebbe essere qualsiasi cosa, da un valore letterale a una chiamata di metodo. Tuttavia, questo è il caso del linguaggio stesso: consente tali dichiarazioni. Convertire tutto ciò che non è un valore letterale in un valore è un'ipotesi euristica nel migliore dei casi. Considerare i seguenti 2 frammenti di codice:

let def; 
function withDef(v = def) { 
    console.log(v); 
} 

getDefaultValues(withDef); // undefined, or unknown? 

def = prompt('Default value'); 
withDef(); 

function wrap() { 
    return (new Function(prompt('Function body')))(); 
    // mutate some other value(s) --> side effects 
} 

function withDef(v = wrap()) { 
    console.log(v); 
} 
withDef(); 
getDefaultValues(withDef); // unknown? 

Mentre il primo esempio potrebbe essere valutato (ricorsivamente se necessario) per estrarre undefined e successivamente su qualsiasi altro valore, la seconda è veramente definito come valore predefinito è non deterministico. Ovviamente è possibile sostituire prompt() con qualsiasi altro ingresso/generatore casuale.

Quindi la risposta migliore è quella che hai già. Utilizzare toString e, se lo si desidera, eval() ciò che si estrae, ma avrà effetti collaterali.

Answer 4

C'è un modo per ottenere il valore predefinito di x qui?

No, non v'è alcuna funzione di riflessione incorporata per fare queste cose, ed è del tutto impossibile in ogni caso dato come parametri di default sono stati progettati in JavaScript.

Si noti che la funzione toString() non funzionerebbe in quanto si interromperà su valori predefiniti che non sono costanti.

Infatti. L'unico modo per scoprirlo è chiamare la funzione, poiché i valori predefiniti possono dipendere dalla chiamata. Basti pensare

function(x, y=x) { … } 

e cercare di ottenere la rappresentazione ragionevole per y s valore predefinito.

In altre lingue che si è in grado di accedere ai valori di default o perché sono costante (valutati in sede di definizione), o la loro riflessione consente di abbattere le espressioni e valutare nel contesto sono stati definiti in.

In Contrasto, JS valuta le espressioni di inizializzazione dei parametri su ogni chiamata della funzione (se necessario) - dai un'occhiata a How does this work in default parameters? per i dettagli. E queste espressioni sono, come se fossero parte del corpo delle funzioni, non accessibili a livello di programmazione, così come tutti i valori a cui si riferiscono sono nascosti nell'ambito della chiusura privata della funzione.
Se si dispone di un'API di riflessione che consente l'accesso ai valori di chiusura (come l'API di debug del motore), è possibile accedere ai valori predefiniti.

È impossibile distinguere function(x, y=x) {…} da function(x) { var y=x; …} dalle loro proprietà pubbliche o dal loro comportamento, l'unico modo è .toString(). E tu non vuoi fare affidamento su quello di solito.