尝试for…in循环，并在第一次迭代后中断：

for (var prop in object) {
    // object[prop]
    break;
}

否。MDN定义的对象文本是：

一个对象的零对或多对属性名和相关值的列表，用大括号（{}）括起来。

因此，对象文字不是数组，您只能使用其显式名称或使用in关键字的for循环访问财产。

没有“第一”属性。对象键是无序的。

如果您使用for（var foo in bar）对它们进行循环，您将以某种顺序获取它们，但将来可能会发生变化（尤其是添加或删除其他键时）。

如果您需要访问“对象的第一个属性”，这可能意味着您的逻辑有问题。对象财产的顺序无关紧要。

这一点以前已经在这里讨论过了。

第一个概念不适用于对象财产，而for的顺序。。。在循环中并没有得到规范的保证，但实际上它是可靠的FIFO，除了chrome（错误报告）。据此做出决定。

正如其他人指出的那样，如果财产的顺序很重要，那么将它们存储在对象中并不是一个好主意。相反，您应该通过方括号使用数组。例如。，

var example = [ {/* stuff1 */}, { /* stuff2 */}, { /* stuff3 */}];
var first = example[0];

请注意，您会丢失“foo”标识符。但您可以向包含的对象添加名称属性：

var example = [ 
  {name: 'foo1', /* stuff1 */},
  {name: 'foo2', /* stuff2 */},
  {name: 'foo3', /* stuff3 */}
];
var whatWasFirst = example[0].name;

对于那些寻求类似问题答案的人，即：“我如何找到一个或多个匹配特定模式的财产？”，我建议使用Object.keys（）。要扩展benekastah的答案：

for (const propName of Object.keys(example)) {
  if (propName.startsWith('foo')) {
    console.log(`Found propName ${propName} with value ${example[propName]}`);
    break;
  }
}

使用Object.keys获取对象的财产数组。例子：

var example = {
    foo1: { /* stuff1 */},
    foo2: { /* stuff2 */},
    foo3: { /* stuff3 */}
};

var keys = Object.keys(example); // => ["foo1", "foo2", "foo3"] (Note: the order here is not reliable)

此处提供了文档和跨浏览器垫片。它的使用示例可以在我的另一个答案中找到。

编辑：为了清楚起见，我只想重复其他答案中正确的表述：JavaScript对象中的键顺序未定义。

var obj = { first: 'someVal' };
obj[Object.keys(obj)[0]]; //returns 'someVal'

Object.values(obj)[0]; // returns 'someVal'

使用它，您还可以通过索引访问其他财产。请注意！Object.keys或Object.values的返回顺序并不能根据ECMAScript得到保证，但所有主要浏览器实现都是非官方的，请阅读https://stackoverflow.com/a/23202095有关详细信息。

我不建议您使用Object.keys，因为旧IE版本不支持它。但如果你真的需要，你可以使用上面的代码来保证向后兼容性：

if (!Object.keys) {
Object.keys = (function () {
var hasOwnProperty = Object.prototype.hasOwnProperty,
    hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
    dontEnums = [
      'toString',
      'toLocaleString',
      'valueOf',
      'hasOwnProperty',
      'isPrototypeOf',
      'propertyIsEnumerable',
      'constructor'
    ],
    dontEnumsLength = dontEnums.length;

return function (obj) {
  if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');

  var result = [];

  for (var prop in obj) {
    if (hasOwnProperty.call(obj, prop)) result.push(prop);
  }

  if (hasDontEnumBug) {
    for (var i=0; i < dontEnumsLength; i++) {
      if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
    }
  }
  return result;
}})()};

功能Firefox（壁虎）4（2.0）Chrome 5 Internet Explorer 9 Opera 12 Safari 5

更多信息：https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys

但如果您只需要第一个，我们可以安排一个更短的解决方案，如：

var data = {"key1":"123","key2":"456"};
var first = {};
for(key in data){
    if(data.hasOwnProperty(key)){
        first.key = key;
        first.content =  data[key];
        break;
    }
}
console.log(first); // {key:"key",content:"123"}

单行版本：

var val = example[function() { for (var k in example) return k }()];

也可以执行Object.values（示例）[0]。

使用lodash库的解决方案：

_.find(example) // => {name: "foo1"}

但无法保证对象财产的内部存储顺序，因为它依赖于javascript VM实现。

有什么理由不这样做吗？

> example.map(x => x.name);

(3) ["foo1", "foo2", "foo3"]

要获取对象中的第一个关键字名称，可以使用：

var obj = { first: 'someVal' };
Object.keys(obj)[0]; //returns 'first'

返回字符串，因此如果存在嵌套对象，则无法访问该对象，例如：

var obj＝｛first:｛someVal:｛id:1｝｝；使用该解决方案，您无法访问id。

如果您想获得实际对象，最好的解决方案是使用lodash，如：

obj[_.first(_.keys(obj))].id

要返回第一个键的值，（如果您不知道确切的第一个键名称）：

var obj = { first: 'someVal' };
obj[Object.keys(obj)[0]]; //returns 'someVal'

如果您知道密钥名称，请使用：

obj.first

or

obj['first']

顶部答案可以生成整个数组，然后从列表中捕获。这是另一个有效的捷径

var obj = { first: 'someVal' };
Object.entries(obj)[0][1] // someVal

我们也可以采用这种方法。

var example = {
  foo1: { /* stuff1 */},
  foo2: { /* stuff2 */},
  foo3: { /* stuff3 */}
}; 
Object.entries(example)[0][1];

下面是获取第一个密钥的更简单的方法：var对象={foo1:'第一个属性“foo1”的值'，foo2:{/*stuff2*/}，foo3:{/*stuff3*/}};let[firstKey]=对象.keys（对象）console.log（firstKey）console.log（对象[firstKey]）

如果有人喜欢数组销毁

const [firstKey] = Object.keys(object);

您可以使用Object.values（）访问对象的值：

var obj = { first: 'someVal' };
Object.values(obj)[0]; // someVal

优雅地遍历键值的基本语法

const object1 = {
  a: 'somestring',
  b: 42
};

for (const [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`);
}

// expected output:
// "a: somestring"
// "b: 42"

这是一种更有效的方法，无需调用返回数组的Object.keys（）或Object.values（）：

Object.prototype.firstKey = function () {
  for (const k in this) {
    if (Object.prototype.hasOwnProperty.call(this, k)) return k;
  }
  return null;
};

然后你可以像这样使用它：

const obj = {a: 1, b: 2, c: 3}
console.log(obj.firstKey()) //=> 'a'

这不一定会返回第一个键，请参见“for（…in…）”循环中的元素顺序

这是一个老问题，但大多数解决方案都假设我们知道属性的名称，但事实并非如此。例如，如果您试图从用户可以上传的文件或类似案例中可视化数据，则情况并非如此。

这是我使用的一个简单函数，在两种情况下都可以使用，即您知道变量，如果不知道，它将返回对象的第一个属性（按字母顺序排序）

label函数接收对象d，如果存在则提取键，否则返回对象的第一个属性。

常量数据=[{label:“A”，值：10}，{标签：“B”，值：15}，{label:“C”，值：20}，{label:“D”，值：25}，｛label:“E”，值：30｝]const keys=['label'，0，''，null，undefined]常量标签=（d，k）=>k？d[k]：对象.值（d）[0]data.forEach（d=>{console.log（`first:${label（d）}，label:${label（d，keys[0]）}`）})keys.forEach（k=>{console.log（`$｛k｝的标签：$｛label（data[0]，k）｝`）})

对于0、“”、null和undefined等值，将返回数组的第一个元素。

这是我的解决方案

  const dataToSend = {email:'king@gmail.com',password:'12345'};
   const formData = new FormData();
      for (let i = 0; i < Object.keys(dataToSend).length; i++) {
     formData.append(Object.keys(dataToSend)[i], 
         Object.values(dataToSend)[i]);
      }

  console.log(formData);