ES6中的Object、apply、call

// 将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
      const target = {a: 1, b: 2}
      const source = {b: 4, c: 5}
      const returnedTarget = Object.assign(target, source)
      // output: Object { a: 1, b: 4, c: 5 }
      console.log(target)
      // output: Object { a: 1, b: 4, c: 5 }
      console.log(returnedTarget)

      // 浅拷贝复制对象 Object.assign()拷贝的是属性值。假如源对象的属性值是一个对象的引用,那么它也只指向那个引用
      const obj = {a: 1}
      const copy = Object.assign({}, obj)
      // { a: 1 }
      console.log(copy)

      // 合并对象
      const o1 = {a: 1}
      const o2 = {b: 2}
      const o3 = {c: 3}
      const obj1 = Object.assign(o1, o2, o3)
      console.log(obj1) // { a: 1, b: 2, c: 3 }
      console.log(o1)  // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变。

      // 合并具有相同属性的对象
      const o11 = {a: 1, b: 1, c: 1}
      const o22 = {b: 2, c: 2}
      const o33 = {c: 3}

      const obj2 = Object.assign({}, o11, o22, o33)
      console.log(obj2) // { a: 1, b: 2, c: 3 }

      // 创建一个新对象
      const person = {
        isHuman: false,
        printIntroduction: function () {
          console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`)
        }
      }
      const me = Object.create(person)
      me.name = 'Matthew' // "name" is a property set on "me", but not on "person"
      me.isHuman = true // inherited properties can be overwritten
      me.printIntroduction()

      // entries返回一个给定对象自身可枚举属性的键值对数组
      const obj = {
        a: 'somestring',
        b: 42
      }
      for (let [key, value] of Object.entries(obj)) {
        console.log(`${key}: ${value}`)
      }
      console.log(obj)

      // 可以将 Map 转化为 Object
      const map = new Map([['foo', 'bar'], ['baz', 42]])
      const obj = Object.fromEntries(map)
      // { foo: "bar", baz: 42 }
      console.log(obj)

      // 可以将 Array 转化为 Object
      const arr = [['0', 'a'], ['1', 'b'], ['2', 'c']]
      const obj2 = Object.fromEntries(arr)
      // { 0: "a", 1: "b", 2: "c" }
      console.log(obj2)

      const obj = {
        prop: 42
      }
      // 被冻结的对象再也不能被修改 不能向这个对象添加新的属性,不能删除已有属性,
      // 不能修改该对象已有属性的可枚举性、可配置性、可写性,以及不能修改已有属性的值。
      // 此外,冻结一个对象后该对象的原型也不能被修改 freeze() 返回和传入的参数相同的对象
      Object.freeze(obj)
      obj.prop = 33
      console.log(obj.prop)

      // 判断两个值是否是相同的值
      let l = Object.is('foo', 'foo')
      console.log(l)

      // simple array
      var arr = ['a', 'b', 'c']
      console.log(Object.keys(arr)) // console: ['0', '1', '2']

      // array like object
      var obj = {0: 'a', 1: 'b', 2: 'c'}
      console.log(Object.keys(obj)) // console: ['0', '1', '2']

      // array like object with random key ordering
      var anObj = {100: 'a', 2: 'b', 7: 'c'}
      console.log(Object.keys(anObj)) // console: ['2', '7', '100']

      var obj = {foo: 'bar', baz: 42}
      console.log(Object.values(obj)) // ['bar', 42]

      // array like object
      var obj = {0: 'a', 1: 'b', 2: 'c'}
      console.log(Object.values(obj)) // ['a', 'b', 'c']

      // array like object with random key ordering
      // when we use numeric keys, the value returned in a numerical order according to the keys
      var an_obj = {100: 'a', 2: 'b', 7: 'c'}
      console.log(Object.values(an_obj)) // ['b', 'c', 'a']

      // valueOf() 方法返回指定对象的原始值
      // Array:返回数组对象本身
      let array = ['ABC', true, 12, -5]
      // true
      console.log(array.valueOf() === array)

      // Date:当前时间距1970年1月1日午夜的毫秒数
      let date = new Date(2013, 7, 18, 23, 11, 59, 230)
      // 1376838719230
      console.log(date.valueOf())

      // Number:返回数字值
      let num = 15.26540
      // 15.2654
      console.log(num.valueOf())

      // 布尔:返回布尔值true或false
      let bool = true
      // true
      console.log(bool.valueOf() === bool)

      // new一个Boolean对象
      let newBool = new Boolean(true)
      // valueOf()返回的是true,两者的值相等
      // true
      console.log(newBool.valueOf() == newBool)
      // 但是不全等,两者类型不相等,前者是boolean类型,后者是object类型
      // false
      console.log(newBool.valueOf() === newBool)

      /**
       * apply() 方法调用一个具有给定this值的函数,以及作为一个数组(或类似数组对象)提供的参数。
       * call()方法的作用和 apply() 方法类似,区别就是call()方法接受的是参数列表,而apply()方法接受的是一个参数数组
       **/
      var numbers = [5, 6, 2, 3, 7]
      var max = Math.max.apply(null, numbers)
      console.log(max)
      var min = Math.min.apply(null, numbers)
      console.log(min)

      // 用 apply 将数组添加到另一个数组
      var array = ['a', 'b']
      var elements = [0, 1, 2]
      array.push.apply(array, elements)
      console.info(array) // ["a", "b", 0, 1, 2]

      /**
       * 使用 call 方法调用父构造函数
       * */
      function Product(name, price) {
        this.name = name
        this.price = price
      }

      function Food(name, price) {
        Product.call(this, name, price)
        this.category = 'food'
      }

      function Toy(name, price) {
        Product.call(this, name, price)
        this.category = 'toy'
      }

      var cheese = new Food('feta', 5)
      var fun = new Toy('robot', 40)
      console.log(cheese)
      console.log(fun)

<think>好的,用户想了解ES6call方法的用法,并希望有使用教程和示例。首先,我需要确认call方法是否属于ES6的新特性。其实,call方法是JavaScript中函数对象原生就有的方法,属于ES5甚至更早版本的内容,并不是ES6新增的。但用户可能在ES6的上下文中提到,所以需要解释清楚这一点,避免误解。 接下来,我需要回顾call方法的基本功能。call方法的主要作用是改变函数执行时的this指向,并立即调用该函数。它的语法是function.call(thisArg, arg1, arg2, ...),其中thisArg是函数运行时指定的this值,后面的参数是函数调用时传入的参数列表。 然后,我应该考虑用户可能的实际应用场景。比如,借用其他对象的方法,实现继承,或者在回调函数中绑定特定的上下文。需要准备几个典型的示例,展示不同情况下call的使用方法。 同时,用户提供的引用内容中提到了Proxy、Set结构、模板字符串等ES6特性,但和call方法没有直接关联。需要确保回答不混淆这些概念,但如果有必要,可以适当提及其他相关方法如apply和bind的区别,尤其是ES6中箭头函数的this绑定问题,这可能影响call的使用。 还要注意用户提到的引用[2]中ES6的变量声明如let和const,这些可能影响this的指向,特别是在块级作用域中。例如,使用let声明的变量不会成为全局对象的属性,这可能在某些情况下影响call方法的效果,但需要具体分析。 用户可能需要明确的步骤说明和代码示例。比如,如何用call来改变this指向,如何传递参数,以及实际应用中的例子。需要确保示例简洁明了,并涵盖常见的使用场景。 此外,用户可能混淆了callapply的区别,因此需要简要说明两者的区别,即参数传递方式的不同(call接受参数列表,apply接受数组)。同时,可以提到ES6的扩展运算符如何简化apply的使用,例如func.apply(null, args)可以用func(...args)替代,这可能更符合ES6的语法习惯。 最后,生成相关问题时要围绕call方法的应用、与其他方法的比较、以及实际开发中的注意事项,确保问题有助于用户深入理解。</think>### ES6call方法的使用教程 在JavaScript中,`call()`是函数对象的内置方法,用于显式绑定函数的`this`指向并立即执行[^2]。虽然`call()`并非ES6新增,但在ES6中仍广泛使用。以下是其核心用法: --- #### **1. 基本语法** ```javascript function.call(thisArg, arg1, arg2, ...) ``` - `thisArg`:函数运行时指定的`this`值 - `arg1, arg2...`:传递给函数的参数列表 --- #### **2. 核心功能** - **改变`this`指向** 示例:借用对象方法 ```javascript const obj1 = { name: 'Alice', showName() { console.log(this.name) } }; const obj2 = { name: 'Bob' }; obj1.showName.call(obj2); // 输出:Bob ``` - **传递参数** 示例:计算最大值 ```javascript Math.max.call(null, 1, 3, 5); // 返回5 ``` --- #### **3. ES6中的增强用法** - **结合箭头函数** 箭头函数自身无`this`,`call()`无法改变其`this`指向: ```javascript const func = () => console.log(this); func.call({ value: 10 }); // 输出全局对象(非严格模式) ``` - **类继承中的应用** 通过`call`实现构造函数继承: ```javascript class Parent { constructor(name) { this.name = name; } } class Child extends Parent { constructor(name, age) { super(name); Parent.call(this, name); // 显式调用父类构造函数 this.age = age; } } ``` --- #### **4. 与`apply()`的区别** - `call()`接收**参数列表**,`apply()`接收**参数数组** ```javascript // 使用call Math.max.call(null, 1, 3, 5); // 使用applyES5方式) Math.max.apply(null, [1, 3, 5]); // ES6扩展运算符替代apply Math.max(...[1, 3, 5]); ``` --- #### **5. 实际应用场景** 1. **类数组转为数组** ```javascript const nodeList = document.querySelectorAll('div'); const arr = Array.prototype.slice.call(nodeList); ``` 2. **调用原生方法** ```javascript Object.prototype.toString.call([]); // 输出:[object Array] ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值