valore - visibilità funzioni javascript




Imposta un valore di parametro predefinito per una funzione JavaScript (14)

Basta usare un confronto esplicito con undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

Vorrei che una funzione JavaScript avesse argomenti opzionali su cui imposto un valore predefinito, che viene utilizzato se il valore non è definito. In Ruby puoi farlo in questo modo:

def read_file(file, delete_after = false)
  # code
end

Funziona in JavaScript?

function read_file(file, delete_after = false) {
  // Code
}

Come aggiornamento ... con ECMAScript 6 puoi FINALMENTE impostare valori predefiniti nelle dichiarazioni dei parametri di funzione in questo modo:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

Come riferito da - http://es6-features.org/#DefaultParameterValues


Da ES6 / ES2015, i parametri predefiniti sono specificati nella lingua.

function read_file(file, delete_after = false) {
  // Code
}

funziona

Riferimento: parametri di default - MDN

I parametri di funzione predefiniti consentono di inizializzare i parametri formali con i valori predefiniti se non viene passato alcun valore o non definito .

Puoi anche simulare i parametri con nome predefinito tramite destrutturazione :

// the `= {}` below lets you call the function without any parameters
function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)
    // Use the variables `start`, `end` and `step` here
    ···
}

Pre ES2015 ,

Ci sono molti modi, ma questo è il mio metodo preferito: ti lascia passare tutto ciò che vuoi, incluso falso o nulla. ( typeof null == "object" )

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}

Essendo uno sviluppatore C ++ di lunga data (Rookie to web development :)), quando ho incontrato per la prima volta questa situazione, ho eseguito l'assegnazione dei parametri nella definizione della funzione, come indicato nella domanda, come segue.

function myfunc(a,b=10)

Ma attenzione che non funziona in modo coerente attraverso i browser. Per me ha funzionato su Chrome sul mio desktop, ma non ha funzionato su Chrome su Android. Opzione più sicura, come molti hanno menzionato sopra è -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

L'intenzione di questa risposta non è di ripetere le stesse soluzioni, ciò che altri hanno già menzionato, ma di informare che l'assegnazione dei parametri nella definizione della funzione può funzionare su alcuni browser, ma non fare affidamento su di essa.


Per chiunque sia interessato a far funzionare il codice in Microsoft Edge, non utilizzare i parametri di default.

function read_file(file, delete_after = false) {
    #code
}

In quell'esempio Edge genererà un errore "Expecting") ""

Per aggirare questo uso

function read_file(file, delete_after) {
  if(delete_after == undefined)
  {
    delete_after = false;
  }
  #code
}

A partire dall'8 agosto 2016 questo è ancora un problema


Sì, funzionerà in Javascript. Puoi anche farlo:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25

Se per qualche motivo non sei su ES6 e stai usando lodash ecco un modo conciso per i parametri di funzione predefiniti tramite il metodo _.defaultTo :

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Quale imposterà il valore predefinito se il valore corrente è NaN , null o non definito


Se si utilizza ES6+ è possibile impostare i parametri predefiniti nel seguente modo:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Se hai bisogno della sintassi ES5 puoi farlo nel modo seguente:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Nella sintassi sopra riportata viene utilizzato l'operatore OR . L'operatore OR restituisce sempre il primo valore se questo può essere convertito in true se non restituisce il valore di destra. Quando la funzione viene chiamata senza argomenti corrispondenti, la variabile parametro ( bar nel nostro esempio) viene impostata su undefined dal motore JS. undefined Viene quindi convertito in false e quindi l'operatore OR restituisce il valore 0.


Trovo che qualcosa di semplice come questo sia molto più conciso e leggibile personalmente.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

Usalo se vuoi usare la più ECMA6 sintassi ECMA6 :

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Si chiama default function parameters . Permette di inizializzare i parametri formali con valori predefiniti se non viene passato alcun valore o non definito. NOTA : non funzionerà con Internet Explorer o browser meno recenti.

Per la massima compatibilità possibile utilizzare questo:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Entrambe le funzioni hanno lo stesso comportamento di ciascuno di questi esempi dipendono dal fatto che la variabile parametro sarà undefined se non è stato passato alcun valore di parametro durante la chiamata a tale funzione.


ES6: Come già accennato nella maggior parte delle risposte, in ES6, puoi semplicemente inizializzare un parametro insieme a un valore.

ES5: La maggior parte delle risposte fornite non sono abbastanza buone per me perché ci sono occasioni in cui potrei dover passare valori falsi come 0 , null e undefined in una funzione. Per determinare se un parametro non è definito perché quello è il valore che ho passato invece di undefined perché non è stato definito affatto lo faccio:

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

Valori dei parametri predefiniti

Con ES6, è possibile fare uno degli idiomi più comuni in JavaScript relativo all'impostazione di un valore predefinito per un parametro di funzione. Il modo in cui lo abbiamo fatto per anni dovrebbe sembrare abbastanza familiare:

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

Questo schema è più utilizzato, ma è pericoloso quando passiamo valori come

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

Perché? Perché lo 0 is falsy , e quindi x || 11 results in 11 x || 11 results in 11 , non quelli passati direttamente in 0. Per risolvere questo problema, alcune persone scriveranno invece il controllo in modo più verosimile come questo:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

ora possiamo esaminare una bella sintassi utile aggiunta a ES6 per semplificare l'assegnazione dei valori predefiniti agli argomenti mancanti:

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11 in una dichiarazione di funzione è più simile a x !== undefined ? x : 11 x !== undefined ? x : 11 rispetto all'idioma molto più comune x || 11 x || 11

Espressioni valore predefinito

Function valori predefiniti delle Function possono essere più di semplici valori come 31; possono essere qualsiasi espressione valida, anche una function call :

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

Come puoi vedere, le espressioni di valore di default vengono ponderate, il che significa che vengono eseguite solo se e quando sono necessarie, ovvero quando l'argomento di un parametro viene omesso o non è definito.

Un'espressione di valore di default può anche essere una chiamata di espressioni di funzione inline, comunemente denominata espressione di una funzione (IIFE) Invoked Function (IIFE) :

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

def read_file(file, delete_after = false)
  # code
end

Il seguente codice può funzionare in questa situazione incluso ECMAScript 6 (ES6) e versioni precedenti.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

come valore di default nelle lingue funziona quando il valore del parametro della funzione viene saltato durante la chiamata, in JavaScript viene assegnato a undefined . Questo approccio non sembra attraente a livello di codice, ma ha una compatibilità a ritroso .


function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!




default-parameters