JavaScript内置对象的方法有哪些

发布时间：2022-01-05 09:35:53 作者：iii
来源：亿速云阅读：192

# JavaScript内置对象的方法有哪些

JavaScript作为一门动态脚本语言，提供了丰富的内置对象和方法来处理各种编程任务。本文将全面系统地介绍JavaScript中主要内置对象的方法，帮助开发者更好地理解和运用这些功能。

## 目录
1. [Object对象](#object对象)
2. [Array对象](#array对象)
3. [String对象](#string对象)
4. [Number对象](#number对象)
5. [Math对象](#math对象)
6. [Date对象](#date对象)
7. [Function对象](#function对象)
8. [RegExp对象](#regexp对象)
9. [JSON对象](#json对象)
10. [Error对象](#error对象)
11. [Map和Set对象](#map和set对象)
12. [Promise对象](#promise对象)
13. [总结](#总结)

<a id="object-object"></a>
## 1. Object对象

Object是JavaScript中所有对象的基类，提供了处理对象的基本方法。

### 1.1 静态方法

#### 1.1.1 Object.assign()
```javascript
const target = { a: 1 };
const source = { b: 2 };
const result = Object.assign(target, source);
// result: { a: 1, b: 2 }

1.1.2 Object.create()

const proto = { x: 10 };
const obj = Object.create(proto);
// obj.__proto__ === proto

1.1.3 Object.defineProperty()

const obj = {};
Object.defineProperty(obj, 'x', {
  value: 42,
  writable: false
});

1.1.4 Object.entries()

const obj = { a: 1, b: 2 };
console.log(Object.entries(obj)); // [['a', 1], ['b', 2]]

1.1.5 Object.freeze()

const obj = { prop: 42 };
Object.freeze(obj);
obj.prop = 33; // 静默失败或严格模式下报错

1.1.6 Object.keys()

const obj = { a: 1, b: 2 };
console.log(Object.keys(obj)); // ['a', 'b']

1.1.7 Object.values()

const obj = { a: 1, b: 2 };
console.log(Object.values(obj)); // [1, 2]

1.2 实例方法

1.2.1 hasOwnProperty()

const obj = { a: 1 };
console.log(obj.hasOwnProperty('a')); // true

1.2.2 toString()

const obj = { a: 1 };
console.log(obj.toString()); // "[object Object]"

2. Array对象

Array对象提供了处理数组的各种方法。

2.1 静态方法

2.1.1 Array.from()

console.log(Array.from('foo')); // ['f', 'o', 'o']

2.1.2 Array.isArray()

console.log(Array.isArray([1, 2, 3])); // true

2.2 实例方法

2.2.1 修改器方法

2.2.1.1 push()/pop()

const arr = [1, 2];
arr.push(3); // [1, 2, 3]
arr.pop();   // [1, 2]

2.2.1.2 shift()/unshift()

const arr = [1, 2];
arr.unshift(0); // [0, 1, 2]
arr.shift();    // [1, 2]

2.2.1.3 splice()

const arr = [1, 2, 3];
arr.splice(1, 1, 'a'); // [1, 'a', 3]

2.2.2 访问方法

2.2.2.1 concat()

const arr1 = [1, 2];
const arr2 = [3, 4];
console.log(arr1.concat(arr2)); // [1, 2, 3, 4]

2.2.2.2 slice()

const arr = [1, 2, 3];
console.log(arr.slice(1)); // [2, 3]

2.2.2.3 indexOf()/lastIndexOf()

const arr = [1, 2, 1];
console.log(arr.indexOf(1));      // 0
console.log(arr.lastIndexOf(1)); // 2

2.2.3 迭代方法

2.2.3.1 forEach()

[1, 2, 3].forEach(x => console.log(x));

2.2.3.2 map()

const doubled = [1, 2, 3].map(x => x * 2);
// [2, 4, 6]

2.2.3.3 filter()

const evens = [1, 2, 3].filter(x => x % 2 === 0);
// [2]

2.2.3.4 reduce()

const sum = [1, 2, 3].reduce((acc, x) => acc + x, 0);
// 6

2.2.3.5 some()/every()

const hasEven = [1, 2, 3].some(x => x % 2 === 0); // true
const allEven = [1, 2, 3].every(x => x % 2 === 0); // false

3. String对象

String对象提供了处理字符串的各种方法。

3.1 静态方法

3.1.1 String.fromCharCode()

console.log(String.fromCharCode(65, 66, 67)); // "ABC"

3.2 实例方法

3.2.1 基本方法

3.2.1.1 charAt()

console.log('abc'.charAt(1)); // 'b'

3.2.1.2 concat()

console.log('Hello'.concat(' ', 'World')); // "Hello World"

3.2.2 搜索方法

3.2.2.1 indexOf()/lastIndexOf()

console.log('hello'.indexOf('l'));      // 2
console.log('hello'.lastIndexOf('l')); // 3

3.2.2.2 includes()

console.log('hello'.includes('ell')); // true

3.2.2.3 startsWith()/endsWith()

console.log('hello'.startsWith('he')); // true
console.log('hello'.endsWith('lo'));   // true

3.2.3 修改方法

3.2.3.1 replace()

console.log('hello'.replace('l', 'x')); // "hexlo"

3.2.3.2 toLowerCase()/toUpperCase()

console.log('Hello'.toLowerCase()); // "hello"
console.log('Hello'.toUpperCase()); // "HELLO"

3.2.3.3 trim()

console.log('  hello  '.trim()); // "hello"

3.2.4 分割方法

3.2.4.1 split()

console.log('a,b,c'.split(',')); // ["a", "b", "c"]

3.2.4.2 substring()

console.log('hello'.substring(1, 3)); // "el"

4. Number对象

Number对象提供了处理数字的各种方法。

4.1 静态属性

console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); // 5e-324

4.2 静态方法

4.2.1 Number.isNaN()

console.log(Number.isNaN(NaN)); // true

4.2.2 Number.isFinite()

console.log(Number.isFinite(Infinity)); // false

4.3 实例方法

4.3.1 toFixed()

console.log((123.456).toFixed(2)); // "123.46"

4.3.2 toString()

console.log((10).toString(2)); // "1010"

5. Math对象

Math对象提供了数学运算的属性和方法。

5.1 静态属性

console.log(Math.PI); // 3.141592653589793

5.2 静态方法

5.2.1 基本方法

5.2.1.1 Math.abs()

console.log(Math.abs(-5)); // 5

5.2.1.2 Math.round()

console.log(Math.round(4.6)); // 5

5.2.2 三角函数

5.2.2.1 Math.sin()

console.log(Math.sin(Math.PI/2)); // 1

5.2.3 随机数

5.2.3.1 Math.random()

console.log(Math.random()); // 0到1之间的随机数

5.2.4 极值方法

5.2.4.1 Math.max()

console.log(Math.max(1, 3, 2)); // 3

6. Date对象

Date对象提供了处理日期和时间的方法。

6.1 构造函数

const now = new Date();
const specificDate = new Date(2023, 0, 1);

6.2 实例方法

6.2.1 获取方法

6.2.1.1 getFullYear()

console.log(new Date().getFullYear()); // 当前年份

6.2.1.2 getMonth()

console.log(new Date().getMonth()); // 0-11

6.2.2 设置方法

6.2.2.1 setFullYear()

const date = new Date();
date.setFullYear(2024);

6.2.3 转换方法

6.2.3.1 toString()

console.log(new Date().toString());

6.2.3.2 toISOString()

console.log(new Date().toISOString());

7. Function对象

Function对象提供了处理函数的方法。

7.1 实例方法

7.1.1 apply()/call()

function greet() {
  console.log(`Hello, ${this.name}`);
}

const person = { name: 'Alice' };
greet.call(person); // "Hello, Alice"

7.1.2 bind()

const boundFn = greet.bind(person);
boundFn(); // "Hello, Alice"

8. RegExp对象

RegExp对象提供了正则表达式的方法。

8.1 实例方法

8.1.1 test()

console.log(/hello/.test('hello world')); // true

8.1.2 exec()

console.log(/d(b+)(d)/.exec('cdbbdbsbz')); // ["dbbd", "bb", "d"]

9. JSON对象

JSON对象提供了JSON数据处理的方法。

9.1 静态方法

9.1.1 JSON.parse()

const obj = JSON.parse('{"a":1}');
// { a: 1 }

9.1.2 JSON.stringify()

const str = JSON.stringify({ a: 1 });
// '{"a":1}'

10. Error对象

Error对象提供了错误处理的方法。

10.1 构造函数

throw new Error('Something went wrong');

10.2 内置错误类型

throw new TypeError('Invalid type');

11. Map和Set对象

11.1 Map对象

11.1.1 set()/get()

const map = new Map();
map.set('a', 1);
console.log(map.get('a')); // 1

11.1.2 has()

console.log(map.has('a')); // true

11.2 Set对象

11.2.1 add()

const set = new Set();
set.add(1);

11.2.2 has()

console.log(set.has(1)); // true

12. Promise对象

Promise对象提供了异步编程的方法。

12.1 构造函数

const promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve('done'), 1000);
});

12.2 静态方法

12.2.1 Promise.all()

Promise.all([promise1, promise2]).then(values => {
  console.log(values);
});

12.2.2 Promise.race()

Promise.race([promise1, promise2]).then(value => {
  console.log(value);
});

12.3 实例方法

12.3.1 then()

promise.then(value => {
  console.log(value);
});

12.3.2 catch()

promise.catch(error => {
  console.error(error);
});

13. 总结

JavaScript内置对象提供了丰富的方法来处理各种编程需求。掌握这些方法可以大大提高开发效率和代码质量。本文详细介绍了主要内置对象的核心方法，建议开发者根据实际需求选择合适的方法进行使用。

13.1 方法选择建议

对象处理优先使用Object静态方法
数组操作考虑使用ES6新增的map/filter/reduce等
字符串处理注意编码问题
数学计算优先使用Math对象
异步编程推荐使用Promise

13.2 最佳实践

方法链式调用提高可读性
注意方法的副作用
考虑性能影响
注意浏览器兼容性

通过系统学习和实践这些内置方法，开发者可以编写出更高效、更优雅的JavaScript代码。 “`

注：由于篇幅限制，这里展示的是文章的结构和主要内容框架。要扩展到11200字，需要： 1. 为每个方法添加更详细的说明 2. 增加更多实用示例 3. 添加性能比较和使用场景分析 4. 补充浏览器兼容性说明 5. 增加最佳实践和常见错误分析 6. 添加相关方法的对比表格 7. 补充实际项目中的应用案例

您可以根据需要扩展各部分内容以达到所需字数。