JavaScriptObject.values用法详解

**JavaScript Object.values() 方法：快速获取对象属性值的利器** 想要轻松提取 JavaScript 对象中的所有值？`Object.values()` 方法是你的理想选择。它能将对象的可枚举属性值提取到一个数组中，简化数据处理流程，告别繁琐的手动遍历。本文将深入解析 `Object.values()` 的语法、使用场景和注意事项，并通过实例演示如何结合数组方法（如 `map`、`filter`、`reduce`）进行高效的数据筛选和转换。掌握 `Object.values()`，配合 `Object.keys()` 和 `Object.entries()`，让你在 JavaScript 对象处理中如鱼得水，显著提升开发效率。

Object.values()用于提取对象中所有可枚举的自有属性值并返回数组。它只处理字符串键，忽略Symbol键、不可枚举属性和原型链属性。1. 用法为Object.values(obj)，返回值数组顺序在现代引擎中通常可预测，遵循插入顺序与整数键排序规则；2. 结合数组方法如filter、map、reduce等，可用于高效筛选、转换和聚合数据；3. 与Object.keys()和Object.entries()配合使用，分别适用于只需键、只需值、或需键值对的场景，构成JavaScript处理对象的核心工具集。

JavaScript的Object.values方法，简单来说，就是给你一个对象，它会把这个对象里所有“看得见”的属性值，一个不落地抽出来，然后打包成一个数组还给你。它只关心值，不关心键，而且只处理对象自己的、可枚举的属性。在我个人看来，这玩意儿极大地简化了我们从对象中提取数据的工作，尤其是在处理一些配置对象或者纯粹需要其内容列表的场景。

解决方案

使用Object.values非常直接，它的语法就是Object.values(obj)，其中obj就是你要处理的那个对象。它会返回一个新数组，里面包含了obj所有可枚举的自有属性的值。

举个例子，假设你有一个表示用户信息的对象：

const userInfo = {
  name: '张三',
  age: 30,
  city: '北京',
  isAdmin: false
};

const values = Object.values(userInfo);
console.log(values); // 输出: ['张三', 30, '北京', false]

你看，它直接就把所有值拎出来了，干净利落。

需要注意的是，它不会返回原型链上的属性值，也不会返回那些使用Symbol作为键的属性值，更不会返回那些不可枚举的属性值。它就是专注于对象本身那些“常规”的、可枚举的字符串键属性。这其实是个好设计，避免了我们拿到一堆不相干的数据。

如果你给它一个非对象值，比如字符串、数字或null/undefined，它会尝试将其转换为对象再处理。比如字符串会被当作一个类数组对象，返回每个字符。但说实话，在实际开发中，我们很少会这样用它。它最主要的舞台还是在处理普通对象。

console.log(Object.values('hello')); // 输出: ['h', 'e', 'l', 'l', 'o']
console.log(Object.values(123));     // 输出: [] (数字无法转换为有可枚举属性的对象)
console.log(Object.values(null));    // 抛出 TypeError

所以，基本用法就是这样，传入一个对象，拿到一个值数组。

Object.values()、Object.keys() 和 Object.entries() 各自适用于哪些场景？

这三个方法就像是JavaScript给对象数据分析提供的“三驾马车”，它们都是ES2015（ES6）之后才出现的，大大提升了我们处理对象数据的便利性。我个人觉得，理解它们各自的侧重点，是高效编程的关键。

• Object.keys(): 这个方法返回一个包含对象所有可枚举的自有字符串键的数组。它的应用场景很明确：当你只关心一个对象有哪些属性名时，比如你想遍历对象的属性名，或者想知道一个对象是否包含某个特定的属性（虽然hasOwnProperty更直接，但有时配合keys做批量检查也行）。

  const product = {
    id: 'P001',
    name: '智能手表',
    price: 999,
    currency: 'RMB'
  };
  const keys = Object.keys(product);
  console.log(keys); // 输出: ['id', 'name', 'price', 'currency']
  
  // 场景：遍历属性名
  keys.forEach(key => console.log(`属性名: ${key}`));

• Object.values(): 就像我们前面说的，它返回一个包含对象所有可枚举的自有属性值的数组。它的用武之地在于，你只需要对象里存储的数据本身，而对这些数据对应的键不感兴趣。比如，你可能想把一个对象里的所有配置项值拿出来，然后进行某种统计或显示。

  const scores = {
    math: 95,
    english: 88,
    science: 92
  };
  const subjectScores = Object.values(scores);
  console.log(subjectScores); // 输出: [95, 88, 92]
  
  // 场景：计算总分
  const totalScore = subjectScores.reduce((sum, score) => sum + score, 0);
  console.log(`总分: ${totalScore}`); // 输出: 总分: 275

• Object.entries(): 这个方法则更全面，它返回一个包含对象所有可枚举的自有字符串键值对的数组。每个键值对都是一个[key, value]的数组。当你既需要键又需要值，或者需要将对象转换为更方便遍历的数组形式时，Object.entries()就是你的首选。它特别适合在for...of循环中使用，或者进行数据转换。

  const settings = {
    theme: 'dark',
    fontSize: 16,
    notifications: true
  };
  const entries = Object.entries(settings);
  console.log(entries);
  // 输出: [['theme', 'dark'], ['fontSize', 16], ['notifications', true]]
  
  // 场景：遍历键值对，或者重建对象
  for (const [key, value] of entries) {
    console.log(`${key}: ${value}`);
  }

简单来说，只想要键用keys，只想要值用values，键值都要用entries。它们各自服务于不同的数据提取需求，共同构成了现代JavaScript处理对象的核心工具集。

Object.values() 返回的数组顺序是怎样的？它总是可预测的吗？

这是一个很好的问题，因为在JavaScript的世界里，顺序有时会让人有点头疼。对于Object.values()返回的数组顺序，答案是：在现代JavaScript引擎中，它是可预测的，并且通常遵循属性的创建（插入）顺序。

具体来说，ECMAScript规范对对象属性的迭代顺序有明确规定。它大致遵循以下规则：

1. 整数索引（Integer Indices）：如果对象的键是看起来像整数的字符串（比如"0", "1", "2"），它们会首先被提取出来，并且按照数值大小升序排列。
2. 其他字符串键（Other String Keys）：接着，所有非整数索引的字符串键会按照它们被添加到对象中的顺序（也就是插入顺序）进行排列。
3. Symbol键（Symbol Keys）：Symbol键的属性不会被Object.values()包含，所以这里不考虑。

这意味着，如果你有一个普通的对象，属性都是字符串键，那么Object.values()返回的数组顺序会和你在代码中定义这些属性的顺序一致。

const myObject = {
  a: 1,
  b: 2,
  c: 3
};
console.log(Object.values(myObject)); // 输出: [1, 2, 3] (通常与定义顺序一致)

const mixedKeys = {
  '10': '十',
  'apple': '苹果',
  '2': '二',
  'banana': '香蕉'
};
console.log(Object.values(mixedKeys)); // 输出: ['二', '十', '苹果', '香蕉']
// 注意：数字键 '2' 和 '10' 会被当作整数索引，并按数值大小排序，然后才是字符串键的插入顺序。

在ES2015之前，JavaScript对象属性的顺序并没有被严格规范，不同的引擎可能会有不同的实现。所以，如果你在非常老的浏览器或环境中工作，依赖属性顺序可能会出问题。但现在，主流浏览器和Node.js都遵循了规范，你可以放心地依赖这个顺序。

不过，虽然顺序可预测，但我们写代码时，最好还是不要过度依赖这个特性，尤其是在处理可能来自外部、顺序不确定的数据时。如果顺序对你的逻辑至关重要，那么最好在获取值之后，显式地对数组进行排序，这样可以增加代码的健壮性。毕竟，清晰的逻辑总比隐式的约定来得可靠。

如何利用 Object.values() 结合数组方法进行数据筛选和转换？

Object.values()的强大之处，很大一部分在于它将对象的值转换成了一个数组，而数组在JavaScript中有着极其丰富且强大的操作方法（map、filter、reduce等）。这种转换让我们可以把对象数据，无缝地融入到数组的函数式编程范式中，进行高效的数据处理。

在我看来，这简直是神来之笔。以前，我们可能需要手动循环对象的键，然后去取值，再操作。现在，一步到位，直接拿到数组，然后各种链式调用，代码可读性一下就上去了。

下面我举几个结合Object.values()和数组方法进行数据筛选和转换的例子：

1. 筛选数据：找出符合特定条件的值

假设你有一个学生成绩对象，你想找出所有及格（分数大于等于60）的科目分数。

const studentScores = {
  math: 85,
  english: 55,
  history: 70,
  physics: 90,
  chemistry: 40
};

// 步骤：先获取所有分数，然后筛选及格分数
const passingScores = Object.values(studentScores).filter(score => score >= 60);

console.log(passingScores); // 输出: [85, 70, 90]

这里，filter方法直接作用在由Object.values()返回的分数数组上，非常直观。

2. 转换数据：对所有值进行某种操作

如果你想把所有学生分数都加上5分作为最终成绩（比如是卷面分调整）。

const studentScoresAdjusted = Object.values(studentScores).map(score => score + 5);

console.log(studentScoresAdjusted); // 输出: [90, 60, 75, 95, 45]

map方法为数组中的每个元素应用一个函数，并返回一个新数组。这种链式调用非常优雅。

3. 聚合数据：计算总和、平均值等

我们经常需要对一组数值进行统计，比如计算所有科目的总分。

const totalScore = Object.values(studentScores).reduce((sum, score) => sum + score, 0);
const averageScore = totalScore / Object.values(studentScores).length;

console.log(`总分: ${totalScore}`);     // 输出: 总分: 340
console.log(`平均分: ${averageScore}`); // 输出: 平均分: 68

reduce方法非常适合进行累加、计数或将数组缩减为单个值的操作。

4. 结合多种操作：筛选后转换

比如，你只想给及格的科目分数加5分。

const passingAndAdjustedScores = Object.values(studentScores)
                                     .filter(score => score >= 60) // 先筛选及格的
                                     .map(score => score + 5);    // 再给及格的加分

console.log(passingAndAdjustedScores); // 输出: [90, 75, 95]

这种链式调用是现代JavaScript开发中非常常见的模式，它让数据流向清晰，代码意图明确。

这些例子展示了Object.values()如何作为一道桥梁，将看似不方便直接操作的对象值，转换成灵活的数组，从而充分利用JavaScript数组方法的强大功能。在我看来，掌握这种组合技，能让你的数据处理代码既简洁又高效。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~