Access JavaScript property case-insensitively ?

Question

Supposons que j'ai un objet :

var obj = {
  foo:"bar",
  fizz:"buzz"
};

J'ai besoin d'accéder à une propriété de cet objet de manière dynamique, comme suit :

var objSetter = function(prop,val){
  obj[prop] = val;
}

Aucun problème, sauf que prop ne doit pas tenir compte des majuscules et des minuscules au cas où le nom de la propriété serait transmis à la fonction sous la forme de, disons, Foo au lieu de foo .

Alors comment puis-je pointer vers la propriété d'un objet par son nom sans tenir compte de la casse ? Je voudrais éviter d'itérer l'objet entier si possible.

Answer 1

C'est une vieille question, mais c'est la première que j'ai trouvée. Comme le dit @ZachSmith, vous pouvez utiliser un Proxy. Voici un exemple de code :

function lowercase(oldKey) {
    // Check that it's a string.
    return typeof oldKey === 'string' ? oldKey.toLowerCase() : oldKey;
}
const propertiesMap = new Map(
    Object.keys(obj).map(propKey => [lowercase(propKey), obj[propKey]])
);
const caseInsensitiveGetHandler = {
    get: function(target, property, receiver) {
        return propertiesMap.get(lowercase(property));
    }
};
obj = new Proxy(obj, caseInsensitiveGetHandler);

Pour mon cas d'utilisation, je n'ai eu besoin que d'un proxy pour le getter de l'objet, mais vous pouvez avoir besoin d'implémenter plus d'éléments de l'architecture de l'objet. Méthodes de proxy .

Answer 2

Il n'y a pas besoin d'itération. Puisque prop peut ne pas être une chaîne de caractères, elle doit être convertie en chaîne de caractères le cas échéant, puisque c'est ce que font les objets nativement. Une fonction getter simple est :

function objGetter(prop) {
  return obj[String(prop).toLowerCase()];
}

S'il y a une exigence, c'est de restreindre l'accès à ses propres propriétés :

function objGetter(prop) {
  prop = String(prop).toLowerCase();

  if (obj.hasOwnProperty(prop)) {
    return obj.prop;
  }
}

et un passeur :

function objSetter(prop, val) {
  obj[String(prop).toLowerCase()] = val;
}

Answer 3

Voici un code très simple pour faire cela En supposant que les données sont un tableau d'objets comme

data=[{"A":"bc","B":"nn"}]

var data=data.reduce(function(prev, curr) {
    var cc = curr; // current value
    var K = Object.keys(cc); // get all keys
    var n = {};
    for (var i = 0; i < K.length; i++) {
        var key = K[i];//get hte key

        n[key.toLowerCase()] = cc[key] // convert to lowercase and assign 
    }
    prev.push(n) // push to array
    return prev;
}, [])

La sortie sera

data=[{"a":"bc","b":"nn"}]

Answer 4

Il se peut que vous n'ayez besoin de faire une correspondance insensible à la casse (généralement coûteuse en raison de l'itération des objets) QUE SI une correspondance sensible à la casse (bon marché et rapide) échoue.

Disons que vous l'avez :

var your_object = { "Chicago" : 'hi' , "deTroiT" : 'word' , "atlanta" : 'get r dun' } ;

Et vous avez, pour une raison quelconque, la_valeur, Detroit :

if( your_object.hasOwnProperty( the_value ) ) 
  { 
    // do what you need to do here
  } 
else  
  { // since the case-sensitive match did not succeed, 
    //   ... Now try a the more-expensive case-insensitive matching

    for( let lvs_prop in your_object ) 
      { if( the_value.toLowerCase()  == lvs_prop.toLowerCase() ) 
          { 

            // do what you need to do here

            break ;
          } ;
      } 
  } ;

Answer 5

Pourquoi le faire de manière aussi compliquée alors qu'il suffit de le faire en minuscules :

    var your_object = { 
"chickago" : 'hi' ,
 "detroit" : 'word', 
 "atlanta" : 'get r dun',     
GetName: function (status) {
        return this[status].name;
    } };

pour l'appeler : your_object.GetName(your_var.toLowerCase());