web-dev-qa-db-fra.com

Comment passer la valeur 'undefined' à une fonction avec plusieurs paramètres?

Je veux passer la valeur de 'undefined' sur une fonction de paramètre multiple mais sans omettre le paramètre.

Que veux-je dire par "sans omettre le paramètre". Je veux dire que nous ne devrions pas simplement omettre le parm2 comme ceci:

function myFunction (parm1, parm2) {}
myFunction("abc");

Cela fera effectivement parm2 undefined, mais je ne suis pas autorisé à le faire de cette façon car je devrai spécifier d'autres paramètres APRÈS le paramètre omis, de sorte que la méthode précédente ne fonctionnera pas dans le cas où je veux rendre parm1 undefined avoir d'autres paramètres après celui-ci pour contenir une valeur.

J'ai essayé de résoudre le problème avec:

myFunction( ,"abc"); //doesn't seem to work

Mettre à jour:

et myFunction(undefined, "abc"); </ s> «cela fonctionne de manière fiable maintenant.

Cependant, il convient de mentionner que:

Définir une variable sur undefined est considéré comme une mauvaise pratique, nous devrait utiliser null à la place.

javascriptfunctionparameter-passingundefined
40
ajax333221

myFunction(undefined,"abc"); de cette façon devrait fonctionner, quel est le problème?

voir ici

Voici la documentation non définie de mozilla, supportée par tous les navigateurs

52
xdazz

L'opérateur void semble être le moyen le plus courant d'obtenir explicitement undefined.

Vous l'utiliseriez comme ceci dans votre exemple:

myFunction(void 0, "abc");

C'est également une méthode fiable de comparaison avec undefined qui est protégée contre le remplacement de undefined dans des environnements JavaScript plus anciens:

var x;
if (x === void 0) {
    // this will execute
}
12
bkbooth

Une meilleure approche pourrait être de passer Object avec des attributs nommés, puis de rechercher ces valeurs d'attributs spécifiques. De cette façon, vous ne devez pas être dépendant du nombre d'arguments.
Exemple: Object.dummy

10
dbrin

Je viens d'avoir une idée et cela semble fonctionner:

var undf;

myFunction(undf, "abc");

Je suis sûr qu'il y a de meilleures façons, mais je poste ceci

5
ajax333221

Vous pouvez utiliser apply et un tableau de paramètres pour passer "indéfini" en tant que paramètre. Par exemple, vous vouliez passer Parm1 en tant que "non défini":

function myFunction (parm1, parm2) {

    if(typeof (parm1) === "undefined"){
        alert("parm1 is undefined")
    }

    if(typeof (parm2) === "undefined"){
        alert("parm2 is undefined")
    }

}

var myParameters = [undefined, "abc"];

myFunction.apply(valueForThis, myParameters );
1
Edward Olamisan

Vous devez gérer l'appel de fonction avec une variable non définie dans le code de fonction lui-même de l'une des manières suivantes: - 

 function myFunction (parm1, parm2) {

         if (parm1 !== undefined) {
             // execute code if 1st param is undefined
        }

         if (parm2 !== undefined) {
             // execute code if 2 param is undefined
        }

        // execute other part of code

    }

Vous pouvez maintenant appeler la fonction ci-dessus de différentes manières: - 

myFunction(undefined,"abc"); // with 1st param value not known

myFunction("cde",undefined); // with 2nd param value not known

myFunction("cde","abc");  // with both param value known
1
Nipun Madan

Essayez d’utiliser cette méthode si vous envisagez d’ajouter une quantité indéterminée de paramètres:

function myFunc(params) {
    // Define default values
    var name = 'John';
    var age = '40';
    // You can loop through them
    for (var p in params) {
        alert(p + ':' + params[p]);
    }
    // And read them in like this
    if (typeof params.name != 'undefined') {
        name = params.name;
    }
    if (typeof params.age != 'undefined') {
        age = params.age;
    }
    alert(name + ' ' + age);
}

alert('test1');
myFunc({name:'Bob', age:'30'});
alert('test2');
myFunc({name:'Bob'});
1
Aram Kocharyan

Je pense que le mieux que vous aurez à faire est de passer null en tant que paramètre. Ce n'est pas undefined, mais dans la plupart des cas, c'est assez proche.

1
Niet the Dark Absol

Si c'est possible, pourriez-vous réorganiser la fonction en tant que myFunction (parm2, parm1) 

c'est à dire. essayez de vous assurer que les paramètres non définis sont les derniers dans la fonction, cela pourrait ne pas fonctionner si davantage de paramètres sont introduits.

0
Tomy Varghese

Juste pour donner des exemples sur ce que @dbrin expliquait, et @alphapilgrim aurait peut-être voulu vérifier. 

simpleFunction({params1:12, params2:"abc"}); //use expected arguments
simpleFunction({params2:"abc"}); //use only one
simpleFunction({params2:"abc", params1:12, iDoNotExist:"I will not be included"}); //use expected arguments in any order
simpleFunction(); //ignore arguments and uses defaults
simpleFunction(2123); //ignores non object arguments 

function simpleFunction(someParams){
  var myParams = {
    params1:null,
    params2:"cde" //default value for second parameter
  };
  simpleExtend(myParams, someParams);
  
  console.log(myParams);

}


//to include in your utilities
function simpleExtend(currentParams, newParams){
  
  if(typeof currentParams !== "undefined" && typeof newParams !== "undefined"){
    Object.keys(newParams).forEach(function(key){
   
      if(typeof currentParams[key] !== "undefined"){
        currentParams[key] = newParams[key];    
      }

    });
 
  
  }
  
 

}

0
MFAL

Un moyen facile de le faire, le cas échéant, consiste à passer non défini. Mais mieux encore comme suit par W3C

Arguments manquants en Javascript

function myFunction(x, y) {
if (y === undefined) {
      y = 0;
    } 
}
0
alphapilgrim

myFunction(undefined,"abc") devrait absolument fonctionner, sauf si une personne cruelle a redéfini undefined! Si vous voulez être en sécurité, il existe des dizaines de façons d’obtenir la valeur indéfinie en évitant de supposer que la chose appelée "indéfini" a bien la valeur indéfinie spéciale:

void 0
var undef; undef
[][0]
{}.foo
// `undef` is guaranteed to have the undefined value within this closure
(function(undef){ undef }())
// this expression evaluates as undefined
(function(){}())

void 0 est le plus largement utilisé (CoffeeScript compilé l’inclut chaque fois que la valeur indéfinie est requise).

0
davidchambers