Impostare un valore di parametro predefinito per una funzione JavaScript

Vorrei che una funzione JavaScript avesse argomenti opzionali su cui ho impostato un valore predefinito, che vengono utilizzati se il valore non è definito (e ignorato se il valore viene passato). 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
}

Da ES6 / ES2015 , i parametri predefiniti sono nelle specifiche della lingua.

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

funziona e basta.

Riferimento: parametri predefiniti - MDN

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

Puoi anche simulare i parametri nominati predefiniti tramite la 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 permette di passare tutto quello che vuoi, incluso falso o nullo. ( typeof null == "object")

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

function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Questo assegna al delete_aftervalore di delete_afterse non è un valore falso , altrimenti assegna la stringa "my default here". Per maggiori dettagli, dai un'occhiata al sondaggio sulla lingua di Doug Crockford e dai un'occhiata alla sezione Operatori .

Questo approccio non funziona se si desidera passare a un Falsey valore vale a dire false, null, undefined, 0o "". Se richiedi il passaggio di valori di falsi, dovrai utilizzare il metodo nella risposta di Tom Ritter .

Quando si ha a che fare con una serie di parametri per una funzione, è spesso utile consentire al consumatore di passare gli argomenti dei parametri in un oggetto e quindi unire questi valori con un oggetto che contiene i valori predefiniti per la funzione

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

usare

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" }); 

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');
} 

In ECMAScript 6 sarai effettivamente in grado di scrivere esattamente quello che hai:

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

Questo verrà impostato delete_aftersu falsese non è presente o undefined. È possibile utilizzare le funzionalità ES6 come questa oggi con transpiler come Babel .

Vedi l'articolo MDN per ulteriori informazioni .

Valori dei parametri predefiniti

Con ES6, puoi fare forse uno dei modi di dire più comuni in JavaScriptrelazione all'impostazione di un valore predefinito per un parametro di funzione. Il modo in cui lo facciamo da 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 modello è più usato, ma è pericoloso quando passiamo valori come

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

Perché? Perché la0 is falsy , e quindi il x || 11 results in 11, non il passato direttamente in 0. Per correggere questo gotcha, alcune persone invece scriveranno il controllo più verbalmente in questo modo:

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

possiamo ora esaminare una sintassi utile utile aggiunta da a ES6per semplificare l'assegnazione di 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 = 11in una dichiarazione di funzione è più simile x !== undefined ? x : 11al linguaggio molto più comunex || 11

Espressioni di valori predefiniti

Functioni valori predefiniti possono essere più di semplici valori come 31; possono essere qualsiasi espressione valida, anche un 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 dei valori predefiniti vengono valutate pigramente, 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 predefinita può anche essere una chiamata di espressione di funzione incorporata, comunemente denominata Espressione di funzione immediatamente richiamata (IIFE):

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

quella soluzione è lavoro per me in js:

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

Basta usare un confronto esplicito con undefined.

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

Consiglio vivamente estrema cautela quando si utilizzano i valori dei parametri predefiniti in JavaScript. Si crea spesso bug se usato in combinazione con funzioni di ordine superiore come forEach, mape reduce. Ad esempio, considera questa riga di codice:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt ha un secondo parametro opzionale function parseInt(s, [radix=10]) ma mappa chiamate parseIntcon tre argomenti: ( elemento , indice e matrice ).

Ti suggerisco di separare i parametri richiesti dagli argomenti valutati facoltativi / predefiniti. Se la tua funzione accetta 1,2 o 3 parametri richiesti per i quali nessun valore predefinito ha senso, rendili parametri posizionali per la funzione, tutti i parametri opzionali devono seguire come attributi nominati di un singolo oggetto. Se la tua funzione richiede 4 o più, forse ha più senso fornire tutti gli argomenti tramite gli attributi di un singolo parametro oggetto.

Nel tuo caso ti suggerirei di scrivere la tua funzione deleteFile in questo modo: ( modificato per instead i commenti di ) ...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

L'esecuzione dello snippet sopra riportato illustra i pericoli in agguato dietro i valori degli argomenti predefiniti per i parametri non utilizzati.

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

essendo uno sviluppatore C ++ da molto tempo (Rookie allo sviluppo web :)), quando mi sono imbattuto per la prima volta in questa situazione, ho fatto l'assegnazione dei parametri nella definizione della funzione, come è menzionato nella domanda, come segue.

function myfunc(a,b=10)

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

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

L'intenzione per questa risposta non è quella 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.

A chiunque sia interessato a far funzionare il codice in Microsoft Edge, non utilizzare i valori predefiniti nei parametri della funzione.

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

Secondo la sintassi

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

puoi definire il valore predefinito dei parametri formali. e controlla anche il valore indefinito usando la funzione typeof .

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!!!

Utilizzare questo se si desidera utilizzare la ECMA6sintassi più recente :

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. Consente 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 identico comportamento di ciascuno di questi esempi, basandosi sul fatto che la variabile del parametro sarà undefinedse nessun valore di parametro è stato passato quando si chiama quella funzione.

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

ES5: La maggior parte delle risposte fornite non è abbastanza buona per me perché ci sono occasioni in cui potrei dover passare valori falsi come 0, nulle undefinedad una funzione. Per determinare se un parametro non è definito perché questo è il valore che ho passato anziché indefinito a causa del fatto che non sono stato definito affatto, faccio questo:

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

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

Qui foo () è una funzione che ha un parametro chiamato argValue. Se non passiamo nulla nella chiamata della funzione qui, verrà chiamata la funzione throwIfNoValue () e il risultato restituito verrà assegnato all'unico argomento argValue. Ecco come una chiamata di funzione può essere utilizzata come parametro predefinito. Il che rende il codice più semplice e leggibile.

Questo esempio è stato preso da qui

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

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

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

Se hai bisogno della ES5sintassi 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 precedente ORviene utilizzato l' operatore. L' ORoperatore restituisce sempre il primo valore se questo può essere convertito in truecaso contrario restituisce il valore sul lato destro. Quando la funzione viene chiamata senza argomento corrispondente, la variabile del parametro ( barnel nostro esempio) viene impostata undefineddal motore JS. undefinedViene quindi convertito in falso e quindi l' ORoperatore restituisce il valore 0.

Sì, l'utilizzo dei parametri predefiniti è pienamente supportato in ES6 :

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

o

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

ma prima in ES5 potresti facilmente farlo:

function read_file(file, delete_after) {
  var df = delete_after || false;
  // Code
}

Ciò significa che se il valore è presente, utilizzare il valore, altrimenti utilizzare il secondo valore dopo l' ||operazione che fa la stessa cosa ...

Nota: c'è anche una grande differenza tra quelli se si passa un valore a ES6 uno anche se il valore è falso, che verrà sostituito con un nuovo valore, qualcosa di simile nullo ""... ma ES5 verrà sostituito solo se solo il valore passato è vero, è perché il modo in cui ||funziona ...

Se per qualche motivo non siete non sul ES6 e si utilizza lodash: ecco un modo conciso per i parametri di funzione di default tramite _.defaultToil metodo:

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>

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

Suoni del futuro

In futuro, sarai in grado di "diffondere" un oggetto su un altro (attualmente dal 2019 NON supportato da Edge !) - dimostrazione di come utilizzarlo per opzioni predefinite piacevoli indipendentemente dall'ordine:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

Riferimento MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... nel frattempo ciò che Edge DOES supporta è Object.assign () (IE no, ma spero davvero che potremo lasciare IE alle spalle :))

Allo stesso modo potresti fare

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

EDIT: A causa di commenti constopzioni - il problema con l'utilizzo di opzioni costanti nel resto della funzione è in realtà non è che non si può fare, è solo che non è possibile utilizzare la variabile costante nella propria dichiarazione - si avrebbe per adattare il nome dell'input a qualcosa di simile

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}

Giusto per mostrare anche le mie capacità (lol), la funzione sopra può essere scritta anche senza aver chiamato argomenti come di seguito:

ES5 e versioni successive

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 e versioni successive

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

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

Il codice seguente 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');

poiché il valore predefinito nelle lingue funziona quando il valore del parametro della funzione viene ignorato durante la chiamata, in JavaScript viene assegnato a indefinito . Questo approccio non ha un aspetto attraente a livello di programmazione ma ha retrocompatibilità .

Sì, questo è indicato come parametro predefinito

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

Sintassi:

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

Descrizione:

Parametri delle funzioni predefiniti su indefiniti Tuttavia, in situazioni potrebbe essere utile impostare un valore predefinito diverso. È qui che possono aiutare i parametri predefiniti.

In passato, la strategia generale per impostare i valori predefiniti era testare i valori dei parametri nel corpo della funzione e assegnare un valore se non definito. Se nella chiamata non viene fornito alcun valore, il suo valore sarebbe indefinito. Dovresti impostare un controllo condizionale per assicurarti che il parametro non sia indefinito

Con i parametri predefiniti in ES2015, il controllo nel corpo della funzione non è più necessario. Ora puoi semplicemente inserire un valore predefinito nell'intestazione della funzione.

Esempio delle differenze:

// OLD METHOD
function multiply(a, b) {
  b = (typeof b !== 'undefined') ?  b : 1;
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5


// NEW METHOD
function multiply(a, b = 1) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

Diversi esempi di sintassi:

Riempimento non definito rispetto ad altri valori di falsità:

Anche se il valore viene impostato esplicitamente durante la chiamata, il valore dell'argomento num è quello predefinito.

function test(num = 1) {
  console.log(typeof num);
}

test();          // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)

// test with other falsy values:
test('');        // 'string' (num is set to '')
test(null);      // 'object' (num is set to null)

Valutato al momento della chiamata:

L'argomento predefinito viene valutato al momento della chiamata, quindi a differenza di altre lingue, un nuovo oggetto viene creato ogni volta che viene chiamata la funzione.

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); //[1]
append(2); //[2], not [1, 2]


// This even applies to functions and variables
function callSomething(thing = something()) {
 return thing;
}

function something() {
  return 'sth';
}

callSomething();  //sth

I parametri predefiniti sono disponibili per i parametri predefiniti successivi:

I parametri già rilevati sono disponibili per i parametri predefiniti successivi

function singularAutoPlural(singular, plural = singular + 's',
                        rallyingCry = plural + ' ATTACK!!!') {
  return [singular, plural, rallyingCry];
}

//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');

//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');

//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')

Funzioni definite all'interno del corpo della funzione:

Introdotto in Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Le funzioni dichiarate nel corpo della funzione non possono essere riferite all'interno dei parametri predefiniti e generare un ReferenceError (attualmente un TypeError in SpiderMonkey, vedere il bug 1022967). I parametri predefiniti vengono sempre eseguiti per primi, le dichiarazioni di funzione all'interno del corpo della funzione vengono valutate in seguito.

// Doesn't work! Throws ReferenceError.
function f(a = go()) {
  function go() { return ':P'; }
}

Parametri senza valori predefiniti dopo i parametri predefiniti:

Prima di Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), il codice seguente generava un SyntaxError. Questo problema è stato risolto nel bug 777060 e funziona come previsto nelle versioni successive. I parametri vengono comunque impostati da sinistra a destra, sovrascrivendo i parametri predefiniti anche se ci sono parametri successivi senza valori predefiniti.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

Parametro destrutturato con assegnazione di valore predefinita:

È possibile utilizzare l'assegnazione di valori predefiniti con la notazione di assegnazione destrutturante

function f([x, y] = [1, 2], {z: z} = {z: 3}) {
  return x + y + z;
}

f(); // 6

Solo un approccio diverso per impostare i parametri predefiniti consiste nell'utilizzare la mappa degli oggetti degli argomenti, anziché gli argomenti direttamente. Per esempio,

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

In questo modo, è facile estendere gli argomenti e non preoccuparsi della mancata corrispondenza della lunghezza degli argomenti.

La risposta è si. In effetti, ci sono molte lingue che supportano i parametri predefiniti. Python è uno di questi:

def(a, enter="Hello"):
   print(a+enter)

Anche se questo è il codice Python 3 a causa delle parentesi, i parametri predefiniti nelle funzioni funzionano anche in JS.

Ad esempio, e nel tuo caso:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Ma a volte non hai davvero bisogno di parametri predefiniti.

Puoi semplicemente definire la variabile subito dopo l'inizio della funzione, in questo modo:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

In entrambi i miei esempi, restituisce la stessa cosa. Ma a volte potrebbero effettivamente essere utili, come in progetti molto avanzati.

Quindi, in conclusione, i valori dei parametri predefiniti possono essere utilizzati in JS. Ma è quasi la stessa cosa che definire una variabile subito dopo l'inizio della funzione. Tuttavia, a volte sono ancora molto utili. Come avrai notato, i valori dei parametri predefiniti accettano 1 riga di codice in meno rispetto al modo standard che definisce il parametro subito dopo l'avvio della funzione.

EDIT: E questo è molto importante! Questo non funzionerà in IE. Vedere la documentazione . Quindi con IE devi usare il metodo "Definisci variabile al massimo della funzione". I parametri predefiniti non funzioneranno in IE.

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