javascript: obtenir tous les paramètres de l'objet

J'ai un objet JS avec un nombre variable de paramètres. Est-il possible de voir quels sont les paramètres qui ont été transmis à ce moment précis?

L'exemple:

function getElement() {
    var scope = document;

    this.by = function(data){
        if (data.id)    scope = scope.getElementById(data.id);
        if (data.tag)   scope = scope.getElementsByTagName(data.tag);       
        return scope;
    }
}

Et je le lance comme

var x = new getElement(); 
vad div = x.by({id : "chosenID"});

obtient le div avec l'id chosenID

ou

var x = new getElement(); 
vad inputs = x.by({id : "chosenID", tag : "input"});

obtient tous les inputs dans le div avec l'id chosenID;

Je veux savoir si j'ai passé un ou deux paramètres, et ceux qui.

Merci!

ps: je vous remercie de votre temps pour m'aider, mais s'il vous plaît ne pas sugget jQuery ou autres JS cadre que ce soit pour des fins de formation seulement. Bien obligé, Sorin.

OriginalL'auteur Sorin Buturugeanu | 2011-01-31

  1. 5

    Utiliser un ... boucle d'itération sur le passé de l'objet paramètres, comme:

    var prop;

for (prop in data) {
    if (data.hasOwnProperty(prop)) {
        //do something with data[prop]
    }
}

    N'oubliez pas de vérifier la propriété avec hasOwnProperty.

    Cela devrait-il être for (var prop in data)?
    Non, prop est déjà déclaré avec une portée locale à l'aide de var.
    Ah, est-il une différence entre les deux façons de faire?
    Non, for (var prop in data) est un raccourci pour var prop; for (prop in data).
    Pour vérifier si une propriété est détenue par data ou si elle est héritée. À partir de SOCIÉTÉ: “Cette méthode peut être utilisée pour déterminer si un objet a la propriété spécifiée comme une propriété de l'objet; à la différence de la in opérateur, cette méthode ne permet pas de vérifier en bas de l'objet prototype de la chaîne.”

    OriginalL'auteur Marcel Korpel

  2. 1

    À l'aide de l'objet de l'itération (key in data) et de la matrice de combinaison... vous pouvez retourner un certain nombre d'éléments... bien que l'objet de l'itération est rendu assez inutile par l'instruction switch.

    function getElement() {
    var scope = document;
    this.by = function(data){
        var key;
        var ret=[];
        for (key in data) {
          if(data.hasOwnProperty(key)) {
            switch(key) {
              case "id":
                ret=ret.concat(scope.getElementById(data[key]));
                break;
              case "tag":
                ret=ret.concat(scope.getElementsByTagName(data[key]));
                break;
              default:
                throw new Error("Unknown property "+key);
            }
          }
        }
        return ret;
    };
}

    OriginalL'auteur Rudu

  3. 1

    Il ya beaucoup de bons général réponses, cependant pensez à ceci:

    Donc, au lieu de cela, je vais couvrir certains cas spécifiques.
    Tout d'abord, généralement, je commence avec:

    function f (x) {
  x = x || {} //so f() will be accepted as per f({})
  ...
}

    Cela définit aussi le cadre pour le suivant.

    Mon approche normale, c'est juste pour vérifier la vérité-y la valeur. Une valeur true signifie "fourni". Cependant, cela a l'inconvénient de ne pas traiter de 0 ou " "fourni".

    if (x.id) {
   //x.id is any truth-y
}

    Si 0 est acceptée en entrée puis-je élargir la case pour que les non-undefined les valeurs sont considérées comme "livré". Un unset propriété par défaut toujours undefined. (Cette méthode accepte tous les de la vérité, les valeurs de y et de faux-y des valeurs telles que 0, "", et null).

    if (x.id !== undefined) {
   //x.id is all truth-y and all-but-undefined false-y
}

    Si undefined est reconnu d'entrée (qui, je l'affirme avec force contre), puis la vérification peut être basé sur hasOwnProperty. Cela a la dis-l'avantage de ne pas avoir vérifié la [[prototype]] de la chaîne.

    if (x.hasOwnProperty("id")) {
   //x.id set to something, including undefined
}

    La for(..in..) construction peut également être utilisé pour itérer sur les propriétés d'un objet (y compris les propriétés dans le [[prototype]], sauf s'ils sont spécialement caché). Cependant, pour le cas général, de traiter d'entrée (par exemple, ne pas créer une librairie JSON), je trouve que c'est simple et propre pour traiter les propriétés de l'objet entrée(s) dans l'une des méthodes décrites ci-dessus.

    wow, merci pour la réponse détaillée, il m'a vraiment aidé!

    OriginalL'auteur