在JavaScript对象中将字符串与键进行比较

Question

如何将一个字符串与JavaScript对象的键进行比较？例如，这里有一个字符串和一个JavaScript对象。我想将该字符串（在本例中，myString的值为“Item1”）与JavaScript对象中的某个键（在本例中，键是Item1和Item2）进行比较：

var myString = "Item1";

var jsObject = 
{
    Item1:
    {
        "apples": "red",
        "oranges": "orange",
    },
    Item2:
    {
        "bananas": "yellow",
        "pears": "green"
    }
};

如果我创建一个'for'循环并通过循环运行对象的内容，我希望将该对象中的键与字符串进行比较。

for (var x = 0; x < Object.keys(jsObject).length; x++)
{
    if (myString == /* What do I put here to compare to grab Item1 or Item2? */)
    {
        // Do stuff
    }
}

- HuskyBlue

---

Object.keys(jsObject).x 可能会有所帮助。 - Mahi

抱歉，Object.keys(jsObject)[x]，我不知道为什么我们不能在此处使用.。 - Mahi

你根本不应该使用循环来做这件事。JavaScript对象通过名称直接访问每个属性。你不必通过比较名称循环遍历它们，只需直接引用属性即可。这样更容易且更快。 - Michael Geary

Answer 1

您不需要使用循环，也不应该使用循环。相反，直接引用对象属性。这样更简单和更快：

var myString = "Item1";

var jsObject = {
    Item1: {
        "apples": "red",
        "oranges": "orange",
    },
    Item2: {
        "bananas": "yellow",
        "pears": "green"
    }
};

var item;
if( jsObject.hasOwnProperty(myString) ) {
    item = jsObject[myString];
    console.log( item );
}

另外，如果您不介意，我有一个样式建议。您可能会注意到，在上面的代码段中，我将开放大括号移到了它们自己所在的行的末尾。

在大多数“花括号”语言中，这只是一种编码风格选择，不影响代码的编译和运行。但是，由于JavaScript的自动分号插入功能，将开放括号放在自己的一行可能会破坏您的代码。这里是一个例子：

function good() {
    return {
        foo: 'bar'
    }
}

console.log( 'good:', good() );

function bad()
{
    return
    {
        foo: 'bar'
    }
}

console.log( 'bad:', bad() );

good()和bad()函数看起来应该返回相同的结果，即{ foo: 'bar' }对象。这是因为自动分号插入将bad()函数更改为：

function bad()
{
    return;  // <-- semicolon added, so it returns undefined, not the object
    {
        foo: 'bar'
    }
}

因此，我建议将“开括号放在行末”的风格用于所有 JavaScript 代码。

- Michael Geary

Answer 2

var myString = "Item1";

var jsObject = 
{
    Item1:
    {
        "apples": "red",
        "oranges": "orange",
    },
    Item2:
    {
        "bananas": "yellow",
        "pears": "green"
    }
};

var keys = Object.keys(jsObject); //get keys from object as an array

keys.forEach(function(key) { //loop through keys array
  console.log(key, key == myString)
});

你可以使用 for 循环，但是你需要在某个地方存储键的数组。

var myString = "Item1";

var jsObject = 
{
    Item1:
    {
        "apples": "red",
        "oranges": "orange",
    },
    Item2:
    {
        "bananas": "yellow",
        "pears": "green"
    }
};

var keys = Object.keys(jsObject);

for (var i = 0; i < keys.length; i++) {
  if (myString == keys[i])
    console.log('match: ', keys[i])
}

可以选择使用for..in同时获取键。

var myString = "Item1";

var jsObject = 
{
    Item1:
    {
        "apples": "red",
        "oranges": "orange",
    },
    Item2:
    {
        "bananas": "yellow",
        "pears": "green"
    }
};

for (var key in jsObject) {
  console.log(key, key == myString)  
}

- Gavin

---

这个可行！我知道有方法，但在JavaScript方面我不如你熟练。谢谢！ - HuskyBlue

嗨，太好了，谢谢。当我获取键和获取对时，我应该如何返回匹配的对象 :) - vladanPro

Answer 3

使用.hasOwnProperty()直接测试字符串是否为对象的属性

更好的方法是使用Object.prototype.hasOwnProperty()直接测试字符串是否为对象的属性。 .hasOwnProperty()方法返回一个布尔值，指示对象是否将字符串作为对象的直接属性。它不会在对象的原型中查找属性。这等同于测试该字符串是否是Object.keys()中的条目，因为该方法只返回可枚举的对象自有属性。如果您担心属性是否可枚举，则还可以使用Object.prototype.propertyIsEnumerable()来测试该属性是否也是可枚举的。

使用这种方法将比创建键数组并搜索该数组要快。

var myString = "Item1";

var jsObject = {
    Item1: {
        "apples": "red",
        "oranges": "orange",
    },
    Item2: {
        "bananas": "yellow",
        "pears": "green"
    }
};

if(jsObject.hasOwnProperty(myString)) {
    //myString is a key on the Object, but not its prototype.
    console.log(myString + ' is a property of jsObject');
}

如果真想搜索键，则使用.indexOf()

对于您的方法，Array.prototype.indexOf() 方法更为适用。 .indexOf() 方法会搜索数组并返回第一个匹配项的索引。您可以测试返回值是否> -1，以指示数组中存在匹配项。

var myString = "Item1";

var jsObject = {
    Item1: {
        "apples": "red",
        "oranges": "orange",
    },
    Item2: {
        "bananas": "yellow",
        "pears": "green"
    }
};

if(Object.keys(jsObject).indexOf(myString)>-1) {
    //myString is a property.
    console.log(myString + ' is a property of jsObject');
}

- Makyen

Answer 4

你可以用以下几种方式实现这个功能：

for (var key in jsObject) {
  if (myString == key) {
  }
}

或者

Object.keys(jsObject).forEach(function(key) { //loop through keys array
  if (myString == key) {
  }
});

或者

for (var x = 0; x < Object.keys(jsObject).length; x++)
{
  if (myString == Object.keys(jsObject)[x])
  {
    // Do stuff
  }
}

鉴于原始对象的使用，您可以直接跳过循环...

if (typeof jsObject[myString] !== "undefined") {
}

- rfornal

Answer 5

var myString = "Item1";

var jsObject = 
{
    Item1:
    {
        "apples": "red",
        "oranges": "orange",
    },
    Item2:
    {
        "bananas": "yellow",
        "pears": "green"
    }
};
for (var x = 0; x < Object.keys(jsObject).length; x++)
{
    if (myString ==(Object.keys(jsObject)[x]) )
    {
       console.log(Object.keys(jsObject)[x]+" is in object");
    }
   
}

- Mahi

Answer 6

我们可以轻松地使用以下步骤比较并找到我们要查找的对象： 步骤：

1. 使用Object.keys()方法获取对象键数组
2. 使用Array.find()方法比较对象键和字符串
3. 在获取到键之后，我们可以引用对象以接收值

Example:

const string = 'en'
const shortDatePatterns = {
    'af-ZA': 'yyyy/MM/dd',
    'am-ET': 'd/M/yyyy',
    'ar-EN': 'dd/MM/yyyy',
    'ar-BH': 'dd/MM/yyyy',
    'ar-DZ': 'dd-MM-yyyy',
    'ar-EG': 'dd/MM/yyyy',
    'ar-IQ': 'dd/MM/yyyy',
    'ar-JO': 'dd/MM/yyyy',
    'ar-KW': 'dd/MM/yyyy',
    'ar-LB': 'dd/MM/yyyy'
}
const comparedString = shortDatePatterns[Object.keys(shortDatePatterns).find(key => key.includes(string.toUpperCase())?shortDatePatterns[key]:'')]

console.log(comparedString)

- KARTHIKEYAN.A

Answer 7

在 ES2020 的世界中，回应了一些问题：

由于对象键是唯一的，所以字符串只能匹配一次。因此，不需要循环。

为了在引用值之前“向前查看”（如果您愿意，可以称之为“可能值”），我想到了两种简洁的方法，迄今为止还没有提到。

在您对字符串值和对象都有所了解以避免原型陷阱的情况下，`in` 运算符可以很好地传达代码的意图。

// perform some side-effect
if (myString in jsObject) { /* do stuff to the world */ }

最后，ES2020的可选链与空值合并运算符结合在一起，可以很好地改变返回值的“类型”maybe value -> value：

// only requires jsObject be defined (which is the case here)
return jsObject?.[myString] ?? defaultValue;

- E

- Edmund's Echo