题目
- 一. this的不同应用场景,如何取值?
// 作为普通函数调用 this是window对象
// 作为对象函数调用 this是对象本身
// 使用call,apply,bind时,this是这三个方法的第一个参数
// 在class方法中调用 this是实例
// 箭头函数中 this是箭头函数上级作用域的this
// 还有原型中的this,其实是属于第二种情况
- 二. 手写bind函数(bind是改变函数this指向的方法之一)
// bind()方法的使用
function fn1(a,b,c){
console.log('this',this) // this {x: 100}
console.log(a,b,c) // 10 20 30
return 'this is fn1' // this is fn1
}
const fn2 = fn1.bind({x:100},10,20,30)
const res = fn2()
console.log(res)
// 手写bind()
Function.prototype.bind1 = function(){
// arguments 是一个 传递给函数的参数的类数组对象,通过它可以拿到所有传递给函数的参数
// Array.prototype.slice.call 可以把一个类数组对象,变为数组
// bind() 方法创建一个新的函数,在 bind() 被调用时,这个新函数的 this 被指定为 bind() 的第一个参数,而其余参数将作为新函数的参数,供调用时使用。
// 第一步要做的,就是将参数拆解为数组
const args = Array.prototype.slice.call(arguments)
// 获取this (数组的第一项)
const t = args.shift()
// fn1.bind(...)中的 fn1
const self = this
return function (){
// apply()方法第一个参数是this对象,第二个参数是参数数组
// call()方法第一个参数跟apply一样,第二个参数是参数列表
return self.apply(t,args)
}
}
function fn1(a, b, c) {
console.log('this', this) // this {x: 100}
console.log(a, b, c) // 10 20 30
return 'this is fn1' // this is fn1
}
const fn2 = fn1.bind1({ x: 100 }, 10, 20, 30)
const res = fn2()
console.log(res)
- 三. 实际开发中闭包的应用场景,举例说明
// 隐藏数据,只提供API
// 如做一个简单的cache工具
function createCache(){
const data = {} //被隐藏数据
return {
set:function(key,val){
data[key] = val
},
get:function(key){
return data[key]
}
}
}
const c = createCache()
c.set('a',100)
c.get('a') // 100
//之所以说能隐藏数据,就是因为data是在createCache函数作用域内定义的
// 如果想要在createCache函数外部,直接通过 data.xx 访问值或修改值,是会报错的,说data未被定义
// 而set和get方法是在createCache作用域内定义的,是可以访问到data的,所以可以用来修改和访问被隐藏的data数据
- 四. 场景题:创建10个<a>标签,点击的时候,弹出对应的序号
let a,i
for( i=0; i < 10 ; i++){
a = document.createElement('a');
a.innerHTML = i + '<br>'
a.addEventListener('click',function(){
alert(i)
})
document.body.appendChild(a)
}
// 每个a标签被点击的时候,都会弹出10 ,
// 因为变量i是全局变量,生成10个a标签的循环会在很短时间内执行完。
// 当点击任意一个a标签的时候,全局变量i早就经过循环后变为了10。而每个for循环里弹出的i就是取的全局的i,所以是弹出10
// 如果想要输出每个a标签的数字,可以改为把i定义在for的块级作用域里,这么每次for循环执行的时候,都会形成不同的块,每个i就会不一样,循环到几,i就保存的是几,弹出的就是几
let a
for( let i=0; i < 10 ; i++){
a = document.createElement('a');
a.innerHTML = i + '<br>'
a.addEventListener('click',function(){
alert(i)
})
document.body.appendChild(a)
}
知识点
- 一. 作用域和自由变量
先看作用域
作用域可以简单的理解为变量的合法使用范围
,作用域分为以下几种:
1.全局作用域
直接编写在script标签之中的JS代码,或者是一个单独的JS文件中的,都是全局作用域
;
全局作用域在页面打开时创建,页面关闭时销毁
全局作用域中,有一个全局对象window(代表的是一个浏览器的窗口),可以直接使用,还有document对象
在全局作用域中,所创建的变量和函数,都会成为window对象的属性和方法
2.函数作用域
在函数内部就是函数作用域,变量只在函数的内部起作用
调用函数时,创建函数作用域,函数执行完毕之后,函数作用域销毁
每调用一次函数,就会创建一个新的函数作用域,它们之间相互独立
3.块级作用域(ES6新增)
在if,for,while之类的花括号范围内的,都是块级作用域
if (true) {
let b = 100
}
console.log(b) // b is not defined
再看自由变量
一个变量在当前的作用域,没有定义,但是被使用了
向上级作用域,一层通一层依次寻找,直到找到为止
如果到全局作用域都没有找到,则报错 xxx is not defined
- 二. 闭包(
闭包就是能够读取其他函数内部变量的函数
)
闭包其实就是作用域应用的特殊情况,它有两种表现
- 函数作为参数被传递
function print(fn){
let a = 100
fn()
}
let a = 200
function fn(){
console.log(a)
}
print(fn) //200
// 当执行print的时候,会把fn函数作为参数传入,而fn内部的输出自由变量a,a的查找不是在fn执行的作用域进行的,而是在fn定义的作用域进行的
- 函数作为返回值被返回
function create(){
let a = 100
return function(){
console.log(a)
}
}
let fn = create()
let a = 200
fn() // 100
闭包的影响:变量会常驻内存,得不到释放,闭包不要乱用;
- 注意,闭包不一定会造成内存泄漏,因为在闭包中的变量,我们无法判断未来是否会去用它,所以不去释放它。而内存泄漏一般是BUG造成的内存未释放或无法释放。
所有的自由变量的查找,都是在函数定义的地方
,向上级作用域查找,不是在函数执行的地方
- 三. this
记住:this取什么值,是在函数执行的时候确认的,不是在函数定义的时候确认的
- 作为普通函数调用
function fn1(){
console.log(this)
}
fn1() // window
- 使用call apply bind
fn1.call({x:100}) // {x:100} call apply 是一调用就直接执行了
const fn2 = fn1.bind({x:200}) // 注意bind会返回一个新的函数,然后再去执行这个新的函数
fn2() //{x:200}
- 作为对象方法被调用
const zhangsan = {
name:'张三',
sayHi(){
// 作为对象方法被调用 this就是当前对象
console.log(this)
},
wait(){
console.log(this) // 直接打印this,就跟上边一样,this就是当前对象
setTimeout(function(){
// this === window
console.log(this)
});
}
}
zhangsan.sayHi() // {name: "张三", sayHi: ƒ, wait: ƒ}
zhangsan.wait() // window
// 这里之所以为window,是因为function(){console.log(this)}的执行是setTimeout触发的
// 它是作为一个普通函数被执行的,而不是像上边zhangsan.sayHi()那样作为一个对象的方法被直接执行的
- 在class方法中调用
// class中this指向的就是实例
class People {
constructor(name){
this.name = name
}
sayHi(){
console.log(this)
}
}
const zhangsan = new People('zhangsan')
zhangsan.sayHi() // People {name: "zhangsan"}
- 箭头函数
// 换种方式
const zhangsan = {
name:'张三',
sayHi(){
console.log(this)
},
waitAgain(){
setTimeout(()=>{
console.log(this)
});
}
}
zhangsan.waitAgain() // {name: "张三", sayHi: ƒ, wait: ƒ}
// 这里原来的普通函数变为了箭头函数,this就变成了当前对象,具体原因是什么呢?
// 因为,箭头函数虽然是被setTimeout触发的,但是箭头函数里的this永远是取它上级作用域的this,箭头函数没有自己的this值
- 原型中的this
class People {
constructor(name,age){
this.name = name
this.age = age
}
sayHi(){
console.log(`hello ${this.name}`)
}
}
class Student extends People {
constructor(name,number){
super(name)
this.number = number
}
study(){
console.log(`${this.name} study hard`)
}
}
const xiaoming = new Student('xiaoming',100)
xiaoming.sayHi() // 此时this.name 就是小明,因为sayHi是作为对象的函数调用的,这个这个对象就是xiaoming
xiaoming.__proto__.sayHi() // 此时this.name 就是 undefined,因为sayHi是作为xiaoming.__proto__ 这个原型对象的函数执行的,而原型对象的name就是undefined