十六、数值与对象新方法

ES6 为数值和对象添加了一些新的方法，使操作更加方便和高效。

数值增强

Number.isFinite()

Number.isFinite() 方法判断一个值是否为有限数值，返回布尔值。

console.log(Number.isFinite(100)); // true
console.log(Number.isFinite(0.1)); // true
console.log(Number.isFinite(Infinity)); // false
console.log(Number.isFinite(-Infinity)); // false
console.log(Number.isFinite(NaN)); // false
console.log(Number.isFinite('100')); // false（与全局 isFinite 不同，不会强制转换）

Number.isNaN()

Number.isNaN() 方法判断一个值是否为 NaN，返回布尔值。

console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN(100)); // false
console.log(Number.isNaN('NaN')); // false（与全局 isNaN 不同，不会强制转换）
console.log(Number.isNaN(undefined)); // false

Number.isInteger()

Number.isInteger() 方法判断一个值是否为整数，返回布尔值。

console.log(Number.isInteger(100)); // true
console.log(Number.isInteger(100.0)); // true
console.log(Number.isInteger(100.1)); // false
console.log(Number.isInteger('100')); // false
console.log(Number.isInteger(NaN)); // false

Number.parseInt() 和 Number.parseFloat()

ES6 将全局的 parseInt() 和 parseFloat() 方法移植到了 Number 对象上，行为保持一致。

console.log(Number.parseInt('123')); // 123
console.log(Number.parseInt('123.45')); // 123
console.log(Number.parseFloat('123.45')); // 123.45
console.log(Number.parseFloat('123')); // 123

对象新方法

Object.keys()

Object.keys() 方法返回一个数组，包含对象自身的所有可枚举属性的键。

const person = {
  name: 'John',
  age: 30,
  city: 'New York'
};

console.log(Object.keys(person)); // ['name', 'age', 'city']

Object.values()

Object.values() 方法返回一个数组，包含对象自身的所有可枚举属性的值。

const person = {
  name: 'John',
  age: 30,
  city: 'New York'
};

console.log(Object.values(person)); // ['John', 30, 'New York']

Object.entries()

Object.entries() 方法返回一个数组，包含对象自身的所有可枚举属性的键值对数组。

const person = {
  name: 'John',
  age: 30,
  city: 'New York'
};

console.log(Object.entries(person)); // [['name', 'John'], ['age', 30], ['city', 'New York']]

Object.fromEntries()

Object.fromEntries() 方法将键值对数组转换为对象。

const entries = [
  ['name', 'John'],
  ['age', 30],
  ['city', 'New York']
];

const person = Object.fromEntries(entries);
console.log(person); // { name: 'John', age: 30, city: 'New York' }

Object.assign()

Object.assign() 方法用于将所有可枚举属性从一个或多个源对象复制到目标对象。

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3, a: 4 };

const result = Object.assign(target, source1, source2);
console.log(result); // { a: 4, b: 2, c: 3 }
console.log(target); // { a: 4, b: 2, c: 3 }（目标对象被修改）

Object.is()

Object.is() 方法判断两个值是否相等，与 === 类似，但处理了一些特殊情况。

console.log(Object.is(100, 100)); // true
console.log(Object.is('abc', 'abc')); // true
console.log(Object.is({}, {})); // false（不同对象引用）
console.log(Object.is(NaN, NaN)); // true（与 === 不同）
console.log(Object.is(+0, -0)); // false（与 === 不同）

实战：对象操作

1. 遍历对象属性

const person = {
  name: 'John',
  age: 30,
  city: 'New York'
};

// 使用 Object.keys()
console.log('Keys:');
Object.keys(person).forEach(key => {
  console.log(key);
});

// 使用 Object.values()
console.log('\nValues:');
Object.values(person).forEach(value => {
  console.log(value);
});

// 使用 Object.entries()
console.log('\nEntries:');
Object.entries(person).forEach(([key, value]) => {
  console.log(`${key}: ${value}`);
});

2. 对象合并

function mergeObjects(...objects) {
  return Object.assign({}, ...objects);
}

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const obj3 = { d: 5 };

const merged = mergeObjects(obj1, obj2, obj3);
console.log(merged); // { a: 1, b: 3, c: 4, d: 5 }

3. 数组转对象

const fruits = [
  ['apple', 'red'],
  ['banana', 'yellow'],
  ['grape', 'purple']
];

const fruitColors = Object.fromEntries(fruits);
console.log(fruitColors); // { apple: 'red', banana: 'yellow', grape: 'purple' }

数值与对象新方法的优势

1. 功能完善：提供了更多实用的操作方法
2. 性能优化：一些方法在性能上比传统方法更优
3. 语义清晰：方法名直观表达了其功能
4. 类型安全：一些方法对类型检查更加严格

通过本章节的学习，你已经掌握了 ES6 中数值和对象的新方法。这些方法可以使操作更加方便和高效，提高开发效率。