/*js运行机制题目*/
/*知识点:
1.所有的等号赋值,第一步是先创建值
函数创建的时候就声明了她的作用域
*/
/*
全局代码执行作用域EC(G)
*/
var i =0;
function A(){
var i =10;
function x(){
console.log(i)
}
// console.log(x)
return x //此时返回的是函数x的函数体
}
// console.log(A()+'111')
var y=A()
console.log(y)
// y()
// var y =A();
y();
function B(){
var i =20;
y()
}
B()
/*一般函数执行完毕之后就出栈释放了 函数堆释放
闭包:函数执行时产生一个不被释放的私有上下文(也就是被占用的时候 ),保护里面私有变量不受污染而且还可以把这些信息保存下来,
供她的下级上下文使用
* heap 堆函数释放:空指针 比如:
let obj ={a:'111'}
obj=null 空指针,此时obj之前指向的堆被释放
* stack 栈内存释放:
1. 全局上下文中,页面关闭即释放
2. 私有上下文中:
(1)函数执行完,私有上下文都会出栈释放
(2)当前上下文中的某些内容(比如一个堆),被除了当前上下文之外的内容占用了,就不能出栈.
GC浏览器垃圾回收机制:
(1)引用标记法_谷歌浏览器:当堆内存被占用时做标记(这个要自己查 TODO:)
(2)引用计数_IE低版本浏览器 容易内存泄漏 TODO: 查一下内存泄漏的原因以及情况
总结:当前内存如果被占用就不能被释放,没被占用的时候,浏览器会在空闲时间将他们释放出去
*/
/* let const var 的区别
* let: 创建一个变量,这个变量可以在下面被修改 比如:
let a =10;
a =12
console.log(a)-->12
* const: 创建一个变量,关联一个值,这个值不可被修改(不能需修改此变量的关联指向) 比如:
const b =10;
b=12 --> 报错
但是,如果 const 是一个对象,可以通过成员访问的方式进行修改
比如:
const b ={
name:'qqq'
}
b.name='aaa'
console.log(b)--> {name:'aaa'}
* 再相同的上下文中
(1) var 允许重复声明,但只识别一次
(2) let 不允许重复声明
*/
// console.log不会被执行,而是直接报错,是因为在词法解析阶段,如果有报错,所有代码都不会执行
//code.html:103 Uncaught SyntaxError: Identifier 'b' has already been declared
// console.log('ok')
// const b =10;
// const b =30;
/*
var 和function 中声明的变量,除了在全局变量对象VO(G)中储存,也会在GO(window)中设置相应的属性.(新版处理机制:在全局上下文中
基于bar 和function声明的变量,会直接存储到GO也就是window中,不会在 VO(G)中存储了)
let 和const 中声明的变量,只会在全局上下文VO(G)中存储,不会在GO(window )中存储
*/
/* js 中的暂时性死区:用typeof检测一个未声明的变量,不会报错,会显示 'undefined'
例如: console.log(typeof n ) -->此时n未被声明,typeof n 形成暂时性死区 但是
如果 let n =10 上面输出结果就会报错:不得在未声明之前使用n 所以
可以用 在下面let创建变量抵消上面的暂时性死区 即 let的机制可以抵消暂时性死区
*/
console.log(typeof n)
// var n =10 -->不会抵消暂时性死区
//let n=10
//-->Uncaught ReferenceError: Cannot access 'n' before initialization 抵消暂时性死区
{
var k=20
let m=90;// -->此时的m只是块级私有的 在下面无法被调用
console.log(m)
}
console.log(m)
/*
匿名函数:把函数作为值赋给xxx
例如: xxx.onclick=function(){....}
*/
/*
this 的指向
1-全局上下文中的this指向的是window
2-块级作用域指向的是他所继承的this，箭头函数也是
函数执行
* 正常的普通函数执行：看函数执行前是否有“点”，有，“点”前面是谁this就是谁，没有“点”，this是window「严格模式下是undefined」,
跟他在哪里调用 哪里执行的都没关系
* 匿名函数:
* + 函数表达式：等同于普通函数或者事件绑定等机制
* + 自执行函数：this一般都是window/undefined
* + 回调函数：一般都是window/undefined，但是如果另外函数执行中，对回调函数的执行做了特殊处理，以自己处理的为主
* 括号表达式:小括号中包含“多项”，这样也只取最后一项，但是this受到影响（一般是window/undefined），比如：（10，obj.fn）（），
* 指向的是window，如果开启严格模式，会显示undefind
* function fn() {
// console.log(this);
// }
// let obj = {
// name: 'zhufeng',
// fn
// // fn: fn
// };
// fn(); //this->window/undefined
// obj.fn(); //this->obj
自执行函数的this是window 或者undefeated（在严格模式下
自执行函数举例：
(function(){
console.log(this)==>输出window
})(10)
回调函数：把一个函数A作为实参，传递给另外一个执行的函数B「在B函数执行中，可以把A执行」
/* function fn(callback) {
// callback -> 匿名函数
callback();
}
fn(function () {
console.log(this);
}); */
/* let arr = [10, 20, 30];
// arr.forEach(function (item, index) {
// console.log(this); //->window
// });
arr.forEach(function (item, index) {
console.log(this); //->forEach第二个参数「对象」 forEach内部做处理了
},{xxx:'xxx'});
数组的foreach方法，传的第二个参数会改变this的指向
*/
//一道题来了!!
var x = 3,
obj = {
x: 5
};
/**在全局上下文中创建了变量
* x-------3
* 对象obj-------指向堆地址 0x001
* 作用域
**/
obj.fn = (function () {
this.x *= ++x;
return function (y) {
this.x *= (++x) + y;
console.log(x);
}
})();
/*
自执行函数,在创建的时候会自己调用一次,指向堆地址0x002
作用域:全局 EC(G)
内容:
'this.x *= ++x;
return function (y) {
this.x *= (++x) + y;
console.log(x);'
执行: this.x=this.x*(++x),前面的this.x,是window.x,也就是3,后面的x也是全局的x,也是3 所以
此时里面的x都是3 全局x经过运算之后
this.x=this.x*(++x)
=3*4
=12
执行完毕,返回一个匿名函数,存储在0x003 同时在0x001堆内存中创建 fn-------0x003,被占用,形成不被释放的闭包
注意:自执行函数,创建时自调用一次之后,返回的值 赋给等号前面的东西
此时:
全局变量中:
x-----3 变为 x------4(因为++x),再变为x-----12
0x003的内容:
'this.x *= (++x) + y;
console.log(x)'
形成作用域EC(003)
执行完毕后,没有被占用,释放0x002内存
此时0x001中的变量
x-------5
fn------0x003
*/
var fn = obj.fn;
/*在全局中创建一个变量fn-------0x003
此时全局变量中存在的有:
x-------------12
obj--------0x001
fn------------0x003
*/
obj.fn(6);
/*
执行0x003中的代码段
this.x *= (++x) + y;
console.log(x)
形成私有上下文,私有作用域EC(1),私有变量
y--------传参6
this的指向为obj,根据点语法,obj.fn调用,this就是obj
this.x=this.x*((++x)+y)
=5*((全局x--12自增=13)+6)
=5*(13+6)
=95
此时obj中的x发生改变
obj中:
x-----5 变为x----95
全局变量中
x----12 因为自增,变成了x----13
*/
fn(4);
/*
函数调用:相当于0x003中传参4
因为没有被点,所以匿名函数的this 没有严格模式下为window
此时:
this.x *= (++x) + y;
console.log(x)
this.x是window中的x,为13,++x的x 也是全局的x 为13,y是此匿名函数执行时形成的新的私有上下文EC(2)中的私有变量
y------4
所以执行函数:
this.x=this.x*((++x)+y)
=13*((x--13自增为14)+4)
=13*18
=234
----也就是 此时全局的x变成了234
因为没被占用,执行完毕后释放
*/
console.log(obj.x, x,);
/*最终这道题的答案是:
obj.x为95
x为234
*/
