Доступ до властивості JavaScript не враховує регістр?

Припустимо, у мене є об’єкт:

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

Мені потрібно отримати доступ до властивості цього об’єкта динамічно так:

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

Проблем тут немає, за винятком того, що це propмає бути чутливим до регістру, якщо ім'я властивості передається у функцію як, скажімо, Fooзамість foo.

То як я можу вказати на властивість об’єкта за назвою, не враховуючи регістр? Я хотів би уникати ітерації всього об’єкта, якщо це можливо.

Порівняйте всі властивості obj з prop.

var objSetter = function(prop,val){
  prop = (prop + "").toLowerCase();
  for(var p in obj){
     if(obj.hasOwnProperty(p) && prop == (p+ "").toLowerCase()){
           obj[p] = val;
           break;
      }
   }
}

Спробуйте це:

var myObject = { "mIxeDCaSEKeY": "value" };

var searchKey = 'mixedCaseKey';
myObject[Object.keys(myObject).find(key => key.toLowerCase() === searchKey.toLowerCase())];

В якості альтернативи ви вже можете вказати searchKey з малої літери.

Якщо ви хочете це як функцію:

/**
  * @param {Object} object
  * @param {string} key
  * @return {any} value
 */
function getParameterCaseInsensitive(object, key) {
  return object[Object.keys(object)
    .find(k => k.toLowerCase() === key.toLowerCase())
  ];
}

Якщо об'єкт не вдається знайти, він повернеться невизначеним, як звичайно.

Якщо вам потрібна підтримка старих браузерів, ви можете filterзамість них використовувати :

function getParameterCaseInsensitive(object, key) {
  return object[Object.keys(object).filter(function(k) {
    return k.toLowerCase() === key.toLowerCase();
  })[0]];
}

Я пропоную використовувати polyfills для Object.keys () та Array.filter (), якщо вам потрібна ще старша підтримка.

Для цього я віддаю перевагу використанню прототипу над окремою функцією лише для зручності використання та виразності. Я просто не люблю перетворювати об’єкти на функції, якщо цього не потрібно.

Крім того, хоча прийнята відповідь працює, я хотів отримати більш комплексне рішення як для отримання, так і для налаштування, яке б поводилось якомога більше, як нотація крапкових позначень або нотація дужок.

Маючи це на увазі, я створив кілька прототипів функцій для встановлення / отримання властивості об’єкта без урахування регістру. Ви повинні пам’ятати про ДУЖЕ відповідальність при додаванні до прототипу об’єкта. Особливо при використанні JQuery та інших бібліотек. Object.defineProperty () з переліченим значенням false було використано спеціально, щоб уникнути конфлікту з JQuery. Я також не турбувався називати функції тим, що вказує на те, що вони не враховують регістр, але ви, звичайно, могли б. Мені подобаються коротші імена.

Ось геттер:

Object.defineProperty(Object.prototype, "getProp", {
    value: function (prop) {
        var key,self = this;
        for (key in self) {
            if (key.toLowerCase() == prop.toLowerCase()) {
                return self[key];
            }
        }
    },
    //this keeps jquery happy
    enumerable: false
});

Ось сетер:

Object.defineProperty(Object.prototype, "setProp", {
    value: function (prop, val) {
        var key,self = this;
        var found = false;
        if (Object.keys(self).length > 0) {
            for (key in self) {
                if (key.toLowerCase() == prop.toLowerCase()) {
                    //set existing property
                    found = true;                        
                    self[key] = val;
                    break;
                }
            }
        }

        if (!found) {
            //if the property was not found, create it
            self[prop] = val;
        }  

        return val;
    },
    //this keeps jquery happy
    enumerable: false
});

Тепер, коли ми створили ці функції, наш код надзвичайно чистий і лаконічний і просто працює.

Отримання без урахування регістру:

var obj = {foo: 'bar', camelCase: 'humpy'}

obj.getProp("FOO");          //returns 'bar'
obj.getProp("fOO");          //returns 'bar'
obj.getProp("CAMELCASE");    //returns 'humpy' 
obj.getProp("CamelCase");    //returns 'humpy'

Налаштування без урахування регістру:

var obj = {foo: 'bar', camelCase: 'humpy'}

obj.setProp('CAmelCasE', 'super humpy');     //sets prop 'camelCase' to 'super humpy'
obj.setProp('newProp', 'newval');      //creates prop 'newProp' and sets val to 'newval'  
obj.setProp('NewProp', 'anotherval');  //sets prop 'newProp' to 'anotherval'

Ще одна варіація на вже представлених, яка підштовхує ітерацію до функції Підкреслення / Лодаша findKey:

var _ = require('underscore');
var getProp = function (obj, name) {
    var realName = _.findKey(obj, function (value, key) {
        return key.toLowerCase() === name.toLowerCase();
    });
    return obj[realName];
};

Наприклад:

var obj = { aa: 1, bB: 2, Cc: 3, DD: 4 };
getProp(obj, 'aa'); // 1
getProp(obj, 'AA'); // 1
getProp(obj, 'bb'); // 2
getProp(obj, 'BB'); // 2
getProp(obj, 'cc'); // 3
getProp(obj, 'CC'); // 3
getProp(obj, 'dd'); // 4
getProp(obj, 'DD'); // 4
getProp(obj, 'EE'); // undefined

Ви можете зробити це для того, щоб "нормалізувати" prop

 var normalizedProp = prop.toLowerCase();
 obj[normalizedProp] = val;

Немає потреби в будь-якій ітерації. Оскільки це propможе бути не рядок, його слід спочатку примусити до рядка, де це доречно, оскільки це те, що об’єкти роблять спочатку. Проста функція отримання:

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

Якщо є вимога обмежити доступ до власних властивостей:

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

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

та сетер:

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

чому ми робимо це так складно, коли ми просто можемо зробити все це малими літерами:

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

назвати це: your_object.GetName(your_var.toLowerCase());

Мені здається хорошим кандидатом на проксі з пастками для перетворення рядкових ключів у верхній або нижній регістр та поведінку як звичайний об'єкт. Це працює або з позначеннями: крапками або брекетами

Ось код:

'use strict';

function noCasePropObj(obj)
{
	var handler =
	{
		get: function(target, key)
			{
				//console.log("key: " + key.toString());
				if (typeof key == "string")
				{
					var uKey = key.toUpperCase();

					if ((key != uKey) && (key in target))
						return target[key];
					return target[uKey];
				}
				return target[key];
			},
		set: function(target, key, value)
			{
				if (typeof key == "string")
				{
					var uKey = key.toUpperCase();

					if ((key != uKey) && (key in target))
						target[key] = value;
					target[uKey] = value;
				}
				else
					target[key] = value;
			},
		deleteProperty: function(target, key)
			{
				if (typeof key == "string")
				{
					var uKey = key.toUpperCase();

					if ((key != uKey) && (key in target))
						delete target[key];
					if (uKey in target)
						delete target[uKey];
				}
				else
					delete target[key];
			},
	};
	function checkAtomic(value)
	{
		if (typeof value == "object")
			return new noCasePropObj(value); // recursive call only for Objects
		return value;
	}

	var newObj;

	if (typeof obj == "object")
	{
		newObj = new Proxy({}, handler);
        // traverse the Original object converting string keys to upper case
		for (var key in obj)
		{
			if (typeof key == "string")
			{
				var objKey = key.toUpperCase();

				if (!(key in newObj))
					newObj[objKey] = checkAtomic(obj[key]);
			}
		}
	}
	else if (Array.isArray(obj))
	{
        // in an array of objects convert to upper case string keys within each row
		newObj = new Array();
		for (var i = 0; i < obj.length; i++)
			newObj[i] = checkAtomic(obj[i]);
	}
	return newObj; // object with upper cased keys
}

// Use Sample:
var b = {Name: "Enrique", last: "Alamo", AdDrEsS: {Street: "1233 Main Street", CITY: "Somewhere", zip: 33333}};
console.log("Original: " + JSON.stringify(b));  // Original: {"Name":"Enrique","last":"Alamo","AdDrEsS":{"Street":"1233 Main Street","CITY":"Somewhere","zip":33333}}
var t = noCasePropObj(b);
console.log(JSON.stringify(t)); // {"NAME":"Enrique","LAST":"Alamo","ADDRESS":{"STREET":"1233 Main Street","CITY":"Somewhere","ZIP":33333}}
console.log('.NaMe:' + t.NaMe); // .NaMe:Enrique
console.log('["naME"]:' + t["naME"]); // ["naME"]:Enrique
console.log('.ADDreSS["CitY"]:' + t.ADDreSS["CitY"]); // .ADDreSS["CitY"]:Somewhere
console.log('check:' + JSON.stringify(Object.getOwnPropertyNames(t))); // check:["NAME","LAST","ADDRESS"]
console.log('check2:' + JSON.stringify(Object.getOwnPropertyNames(t['AddresS']))); // check2:["STREET","CITY","ZIP"]

const getPropertyNoCase = (obj, prop) => obj[Object.keys(obj).find(key => key.toLowerCase() === prop.toLowerCase() )];

або

const getPropertyNoCase = (obj, prop) => {
    const lowerProp = prop.toLowerCase(obj[Object.keys(obj).find(key => key.toLowerCase() === prop.toLowerCase() )];
}

Ось дуже простий код для цього Припускаючи, що дані - це масив подібних об’єктів

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;
}, [])

Вихід буде

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

Можливо, вам доведеться лише збігати регістр (як правило, дорого через ітерацію об’єкта), якщо збіг, чутливий до регістру (дешевий і швидкий), не вдається.

Скажімо, у вас є:

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

І ви з будь-якої причини маєте значення_ 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 ;
          } ;
      } 
  } ;

Ще один простий спосіб:

function getVal(obj, prop){
var val;
  prop = (prop + "").toLowerCase();
  for(var p in obj){
     if(obj.hasOwnProperty(p) && prop == (p+ "").toLowerCase()){
           val = obj[p]
           break;
      }
   }
   return val;
}

Використовуйте його так:

var obj = {
  foo:"bar",
  fizz:"buzz"
};
    getVal(obj,"FoO") -> returns "bar"

Ось приємна рекурсивна функція, яка дозволяє здійснити обхід об’єкта javascript без урахування регістру:

let testObject = {'a': {'B': {'cC': [1,2,3]}}}
let testSeq = ['a','b','cc']

function keySequence(o, kseq) {
  if(kseq.length==0){ return o; }
  let validKeys = Object.keys(o).filter(k=>k.toLowerCase()==kseq[0].toLowerCase());
  if(validKeys.length==0) { return `Incorrect Key: ${kseq[0]}` }
  return keySequence(o[validKeys[0]], kseq.slice(1))
}

keySequence(testObject, testSeq); //returns [1,2,3]

Приклад ES6, опублікований @nilloc, є неправильним і не працює.

Ось робочий приклад:

const x = {'first':5,'X-Total-Count':10,'third':20};
console.log(x[Object.keys(x).reduce((result,key)=>{
   if (!result) {
      return key.match(/x-total-count/i)
   } else {
      return result;
   }
 },null)]);

або ще краще, він повинен повернутися невизначеним, якщо ключ не існує:

const x = {'first':5,'X-Total-Count':10,'third':20};
console.log(x[Object.keys(x).reduce((result,key)=>{
   if (!result) {
     return key.match(/x-total-count/i) || undefined
   } else {
     return result;
   }
  },undefined)]);

Однією з міркувань є те, що наведений вище приклад поверне останній відповідний ключ в об’єкті, якщо є кілька відповідних ключів.

Ось приклад з кодом, перетвореним у функцію:

/**
  * @param {Object} object
  * @param {string} key
  * @return {string||undefined} value || undefined
 */
function getKeyCase(obj,key) {
  const re = new RegExp(key,"i");
  return Object.keys(obj).reduce((result,key)=>{
   if (!result) {
     return key.match(re) || undefined
   } else {
     return result;
   }
  },undefined);

const x = {'first':5,'X-Total-Count':10,'third':20};

console.log(x[getKeyCase(x,"x-total-count")]);

Ця відповідь вимагає ES6.

const x = { 'aB': 1, 'X-Total-Count': 10, y3: 2 }
console.log(x[Object.keys(x).find(key=>{return key.match(/ab/i)})])
console.log(x[Object.keys(x).find(key=>{return key.match(/x-total-count/i)})])
console.log(x[Object.keys(x).find(key=>{return key.match(/y3/i)})])

Це дуже сумно, що ітерацію не можна пропустити, як здається. Для мене те, що є прийнятним, але може бути не для всіх, - це сформувати об’єкт один раз за допомогою ітерації, а потім використовувати його звичайним способом хеш-карти.

const hashmap = {
  'FOO': 'foo as in function programming',
  'bar': 'bar is in baz',
};

const shapedmap = Object.entries(hashmap).reduce(
  (acc, [key, val]) => (acc[key.toUpperCase()] = val, acc), {}
);

for (const term of ['foo', 'bar', 'baz']) {
  const match = shapedmap[term.toUpperCase()]
  match && console.log('awesome, we got the term.', match);
};

Навіть якщо потрібно виконати лише одноразовий пошук, він не повинен бути менш продуктивним, як будь-яке інше рішення ітерації, оскільки після 1 проходу швидкість пошуку постійна. (Я вважаю).