【JavaScript】内置对象及常用方法

JavaScript 内置对象及常用方法

一、Object

Object 构造函数创建一个对象包装器。

几乎所有的对象都是Object类型的实例，它们都会从Object.prototype继承属性和方法。Object构造函数，会根据给定的参数创建对象：

• 创建的对象是一个空对象，在该对象上没有继承 Object.prototype 原型链上的属性或者方法

  Object.create(null) // {}   No properties
  

• 如果给定值是 null 或 undefined，将会创建并返回一个空对象，该对象继承Object.prototype 原型链上的属性或者方法

  new Object(null) // {}   [[prototype]]: Object
  

• 如果传进去的是一个原始类型的值，则会构造其包装类型的对象

  new Object(2) // {2}
  

• 如果传进去的是引用类型的值，仍然会返回这个值，经他们复制的变量保有和源对象相同的引用地址

  new Object([1, 2]) // [1, 2]
  

具有Object类型的实例方法：

• toString()

  返回当前对象的字符串形式，返回值为String类型

  var a = [1,'2',true].toString();
  console.log('a: ', a); // '1,2,true'
  
  var b = (new Date()).toString();
  console.log('b: ', b); // 'Tue Oct 20 2020 13:35:05 GMT+0800 (China Standard Time)'
  
  var c = ({
       name: 'hai'}).toString();
  console.log('c: ', c); // '[object Object]'
  
  var fuc = function () {
       
      console.log('123')
  }
  var d = fuc.toString();
  console.log('d: ', d); // "function () {console.log('123')}"
  

• toLocaleString

  返回当前对象的"本地化"字符串形式，以便于当前环境的用户辨识和使用，返回值为String类型

  (1234567).toLocaleString(); // "1,234,567"
  (1.234567).toLocaleString(); // "1.235"
  (new Date()).toLocaleString(); // "2020/10/20 下午1:40:08"
  

• valueOf()

  返回指定对象的原始值

  Array：返回数组对象本身
  Date：返回时间戳

  new Date(2013, 7, 18, 23, 11, 59, 230).valueOf() // 1376838719230
  

  Number：返回数字值
  Boolean：返回布尔值true或false
  Function：返回函数本身
  Object：返回对象本身
  String：返回字符串值

Object 构造函数的方法：

• Object.assign(target, …sources)

  • 复制一个对象

    const obj = {
            a: 1 };
    const copy = Object.assign({
           }, obj);
    console.log(copy); // { a: 1 }
    

    对于深拷贝的问题：
    Object.assign()拷贝的是（可枚举）属性值。

    const v1 = "abc";
    const v2 = true;
    const v3 = 10;
    const v4 = Symbol("foo")
    
    const obj = Object.assign({
           }, v1, null, v2, undefined, v3, v4); 
    // 原始类型会被包装，null 和 undefined 会被忽略。
    // 注意，只有字符串的包装对象才可能有自身可枚举属性。
    console.log(obj); // { "0": "a", "1": "b", "2": "c" }
    

    如果属性值为简单类型（如string， number），得到的新对象为深拷贝。
    如果属性值为对象或其它引用类型，得到的新对象为浅拷贝。

    let obj1 = {
            a: 0 , b: {
            c: 0}};
    let obj2 = Object.assign({
           }, obj1);
    console.log('obj2: ', obj2); // obj2:  { a: 0, b: { c: 0 } }
    
    obj2.a = 1;
    console.log('obj1: ', obj1); // obj1:  { a: 0, b: { c: 0 } }
    console.log('obj2: ', obj2); // obj2:  { a: 1, b: { c: 0 } }
    
    obj2.b.c = 2;
    console.log('obj1: ', obj1); // obj1:  { a: 0, b: { c: 2 } }
    console.log('obj2: ', obj2); // obj2:  { a: 1, b: { c: 2 } }
    

    谈一谈你对深拷贝和浅拷贝的理解。

    数据分为基本数据类型和引用数据类型。深拷贝和浅拷贝只是针对引用数据类型的操作。

    • 浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。
    • 深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

    手写一个深拷贝：递归实现深拷贝

    // 标准深拷贝
    function deepClone(source) {
           
        // [] => Array {} => Object
        const targetObj = source.constructor === Array ? [] : {
           }
        for (let key in source) {
           
            if(Object.hasOwnProperty.call(source, key)) {
           
                if(source[key] && typeof source[key] === 'object') {
           
                    // 引用数据类型，递归
                    targetObj[key] = deepClone(source[key])
                } else {
           
                    // 基本数据类型，直接赋值
                    targetObj[key] = source[key]
                }
            }
        }
        return targetObj
    }
    

  • 合并对象
    目标对象自身也会改变；
    对象中的属性具有相同的键，后面的源对象的属性将类似地覆盖前面的源对象的属性。

    const o1 = {
            a: 1 };
    const o2 = {
            b: 2 };
    const o3 = {
            b: