如果有不对的地方还望指正
1:两个作用域:全局作用域和私有的函数作用域:
在运行代码之前,会做一些准备工作: 做饭之前先买菜,切菜:
全局中的准备工作: a:变量提升,b:函数声明 (在堆内存中存有函数的字符串代码 地址为 aaaFFF000, 在栈内存中会存有fn 存有aaaFFF000,完成对堆内存的引用)
变量提升:这个只在var 关键字下 会 提升
全局作用域和私有的函数作用域 两者独立存在.全局中有一个a ,私有的fn 的作用域中也有一个a
第一个console.log 这个时候a 已经声明 ,但是没有赋值, 所以是undefined
第二个调用fn 的时候因为在fn 本身的私有作用域中 也有a 但是也没有赋值 所以也是undefined ,fn运行之后销毁
第三个打印的是赋值之后的全局中的a 所以是12 .
至于这个准备工作 :
a: 在全局中是 两个变量提升和函数声明 , (如果有一个变量a 和一个函数a , 函数a 会干掉之前的变量a)
b: 在私有函数作用域中是 ,形参赋值,变量提升和函数声明 ,比上边多了一步.
至于什么时候是xxx undefined 什么时候是xxx = null 什么是xxx is not defined ?
undefined :可以理解为栈内存中 已经有 有x 存的是 key value 形式,key 为x 但是value 为空, 就是undefined. 比如var a , 在栈中有a 了 但是没有赋值,就是undefined
null:null 本身的类型是Object ,Object 是存在堆内存的, 如果 在堆内存没有 就是null
not: 如果在代码中直接 用 一个没声明的变量 比如 直接console.log(xxx) , 没有对xxx 进行过赋值 ,直接用, 也没有写var , 这时候栈内存里边也没有这个变量, 所以就是not defined .
in all,
栈内存没有这个key 就是not defined
如果有key 没有值 , 就是undefined
如果是引用类型 ,栈指向堆 ,堆里边没有就是null
2: 跟上边的区别在于fn 中用的a 没有var 修饰, 那么a用的就是fn 外边的 a, 也就是全局中的a,也就是fn也在操作全局的a ,
第一个log ,a 还没有赋值 但是已经声明 所以为undefined
第二个log ,打印全局中的a , 这时候已经为12
第三个log 打印全局中的a 这时候已经被修改为13
3: 这道题就是刚才说的 : 运行第一句的时候因为a 没有用var 修饰,进行变量提升, 所有在栈内存中还没有这个key , 直接调用 打印这个值就是 a 没有定义.
Uncaught ReferenceError: a is not defined
4:依旧是变量提升的问题:
那么问题是 if(){}里边的这个会不会提升? 可能是true 或者false , 跑到或者跑不到这个代码, 可能有也可能没有, JavaScript还没那么聪明能分别出来要不要, 所以都是要了.
bar()方法中有私有的foo变量 ,if(!foo) 这时候foo 还是undefined 所以 取反 为true ,var foo = 10; 这时候给foo 赋值为10 ,打印出来的foo 就是10 ;
5: 形成了 闭包. 函数b 作为返回值 传给了全局的c ,b 中依旧保留着对a 中的n的引用.
全局中的n 和a 中的n 是独立.
所以打印 11,12 ,0
6: 哪个变哪个不变?
这里用到了test 方法 私有作用域中的 形参赋值 ,test 中的a 和全局中的a 相对独立, var b 变量提升了b 也就是说test 中有自己的a 和b 操作起立,都是自己内部玩,对外边不会产生印象 ,但是c 是用的是全局的c 所以只会把c 改了
7:刚才shuole js编译器? 也不知道你的var 是不是true 或者false 满足的,所以都会进行声明, 这个声明其实就是在全局的window 下边创建了一个属性a 但是没有赋值 . 里边存的就是undefined ,("a" in window) 就是true ,取反为false ,var a = 1;不会执行
所以打印出来的a 就是 undefined,
8: 结果是3. 10 . undefined
看8.1 的介绍. 因为funcion b 没有return返回值,所以最后的a 肯定是undefined
至于b() 内部, 因为有映射机制, 所以第一个是3 ,第二个是10 .
8.1 第一个打印的是100 第二个打印的是undefined.
非Strict 模式下, 实参和形参有映射机制,
实参Arguments 的和形参的映射(是在函数运行时建立映射的机制 ) 是以 Arguments 的索引来实现的.Arguments中 有这个索引,浏览器会完成和形参的映射机制搭建.
如果形参比实参的数量多,那么多出来的形参无法跟Arguments 建立映射机制.
个人理解:
形参的英文 是parameter , 实参的英文是Arguments .可以想象一下, 有一架私人飞机上边有4个座, 这四个座就是parameter , 也就是说不管你飞机上拉多少人,就只有四个座, Arguments 是乘客,实际中坐飞机的人. 每个乘客手里都有自己的票,对应相应的座位, 那每个人怎么找到自己相应的座位? 就是按照票号 , 也就是映射机制中的按照索引来找座位.
如果飞机上四个座, 但是只有你和你老婆两个人坐飞机, 1号座和二号座, parameter 四个, 但是实际上飞机的Arguments 就是两个人, 函数运行可以理解为飞机起飞了, 这时候,一号座 和二号座的人已经固定了. 但是三号和四号这时候因为没有乘客所以他们是undefined,如果你儿子这时候想上来,可不可能? 飞机都已经起飞了,你儿子来晚了就赶不上了. 所以强行塞一个乘客到飞机上 ,实现不了,飞机起飞了.
8.2: 打印结果 undefined ,200 ,300 .
还是按照上边的 介绍. 飞机已经起飞了. 那么Arguments 或者parameter 这个时候改其他的空座 已经没有映射机制了,
8.3. 首先来 说~ .这个符号干嘛用的 ?简单理解 可以把他当成~function (){}
是这样 (function(){}) 一个匿名函数. 后跟着(), 函数立即执行.
结果是这样 因为覆盖,所以.结果是 2 ,20 ,和window . 自执行函数的this 就是window
8.4 . 2 ,20 ,undefined.
主要是严格模式和非严格模式的区别:
严格模式和非严格模式的区别:
1严格模式中 Arguments 的callee 不可用
2严格模式中 Arguments 的形参和 实参没有映射机制
3严格模式中给一个对象设置重复的属性 会在编译器中提示 duplicate declaration
4严格模式中,函数执行如果没有明确指定执行的主体(函数前面没有.),不再像非严格模式下统一返回window ,而是返回undefined,代表没有执行主体
9:结果是 三个hello 一个Arguments [0:null ....] ,最后的x 为null
考的知识点 . 第一个console.log(foo); 因为foo 作为形参已经声明过 并已经赋值 为hello ,这时候直接打印就是hello ,形参赋值在私有函数作用域中优先处理, 然后是 表达式|| .
左 && 右, 左 || 右 需要知道的概念
1: 返回的结果 ,第一个也是最简单的就是true 和false 的判断 .
if(condition){} . condition 中 什么时候返回true 什么时候返回 false
如果 为 0 ,undefined , null ,空字符串 都是返回 false
其中 undefined == null 返回 true
=== 和== 的区别 ?
=== 先比较的是左右两边的type 如果type 不一样 直接返回false
在JS 中type一共分为6 种 , object , number ,boolean ,string,function ,undefined
其中null 的type 是object.
2: console.log(12 && 13) 的返回值? 返回值为 13 ;
console.log( 0 || 13); 返回值是 13
那么 实际中有什么用 ?
第一种: 赋值默认值: str || "default" , 这样如果字符串为空 , 我们可以给他附一个默认值 为"default" ,
第二种: 非空判断:
判断确实存在 : function a(){}
if(a && a()) 这样就是判断 a 是否存在 ,存在了之后再执行后边的
还考了一个知识点 ES6 中 ,赋值为默认值.
function fn(x = 0){
console.log(arguments);// [o:null]
console.log(x);// null
}
x = 0 默认给x 赋值为0 . 那么什么时候这句话有效 ?
用babel 看一下
ES6 代码:
function fn(x = 0){
console.log(x);
}
fn(null);
转换之后的ES5代码:
"use strict";
function fn() {
var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
console.log(x);
}
fn(null);
重点在这里 arguments[0] !== undefined , 也就是说 只有在传进来的参数是undefined 才给x 赋值为默认值. 其他的null 0 "" 这些都不会走默认值这个分支.
10: 5,5,6 ,2 .这个就不解释了. fn 函数操作的都是全局的a .
11: 考的还是 参数里边形参.形参本身在fn 中有一个自己的复制.你可以理解为fn 里边的arr 不是arr .换个名字就叫 xxx , 但是这个xxx 和arr 都是指向同一个堆内存.aaaFFF000
然后在fn 中 也就是刚开始 xxx 和arr 都是指向堆内存aaaFFF000 ,先把 aaaFFF000里边的[0] 变成了 0 . 然后xxx 就指向新的堆内存 aaaFFF111, 这时候对aaaFFF000就不会产生影响了, 然后返回的是 aaaFFF111 给res .res 存的就是[100] .原来的修改为了[0,2,3,4]
- 30,60,80,41. 闭包了存了f 中的i .fn(20)(40) 和fn(30)(50); 运行完就销毁了.
13: 31,32,43,44 这个更简单 .都是操作全局的a
14: 这里开始考this 了 ,有一定难度:
22,23 ,65,30.
this 关键字
1.元素绑定事件,方法中的this 是当前操作的元素
2.方法名前面是否有点.有点.点前面是谁this 就是谁, 没有this 是window (严格模式是undefined)
3.构造函数执行,方法体重的this是当前类的一个实例
这个例子里主要用第二个.
自执行函数里边用this 都是window
fn(5); 中this 为window 取全局的num 来计算
obj.fn(10); this中为obj 里边的num
首先需要知道fn 是什么 ?
fn 是
this.num += n;
num++;
console.log(num);//22 23
而this.num = num * 3; num ++; 只在自执行函数执行时 运行了一次.
15: 51, 42 同上的道理.
区分 this 到底操作的是谁
fn 里边的代码只是 this.num += ++num;
16: 答案是
//false
//true
//true
//false
//false
//Fn
//Object
//100
//undefined
//200
//undefined
//
//
//true
prototype :
1 每个函数(类)都有一个prototype(原型)属性,属性值是一个对象,这个对象中存储了
当前类供实例调取使用的共有属性和方法
- 在浏览器默认给原型开辟的堆内存中有一个属性 constructor ,存储的是当前类本身.
3.每一个对象(实例)都有一个proto原型链属性,这个属性指向当前实例所属的类的原型
不确定所属的类 ,都指向Object.prototype
构造函数的使用和直接调用的共同点和区别
1: 参数赋值和变量提升 : 2 构造函数(创建实例,并用this 指向当前实例对象) this.xxx 全都在实例对象中 3构造函数会默认的返回创建的实例对象
在不需要传参数的时候 new Fn() 和 new Fn 是一样的
17: 答案直接写了
18: 返回结果 是 undefined 和 language
第一个结果 obj.prop.getFullName() 的函数是 getFullName()函数的运行主体 是obj.prop 然后看obj.prop 里边有没有 一个叫fullName的属性 ?
prop 里边只有一个getFullName的方法 没有这个属性 所以返回的是undefined
第二个结果是 language . 还是确认函数的运行主体 .
test()前边没有点,所以运行运行主体是window .打印出window 也就是全局的fullName .就是language
this 关键字
1.元素绑定事件,方法中的this 是当前操作的元素
2.方法名前面是否有点.有点.点前面是谁this 就是谁, 没有this 是window (严格模式是undefined)
3.构造函数执行,方法体重的this是当前类的一个实例
19: 答案是 window
还是确认函数的运行主体:
Tom.wait() 函数运行主体是Tom 这个Object 所以 wait 函数中的this 就是Tom.
fun 就是Tom 的Show 方法. fn 中代码就是 console.log(this.name);
然后fn 开始运行 . fn 前面没有点 所以运行主体就是window . 打印window 中也就是全局的 name ,结果就是"window"
20: 弹出框 0 和 30.
原型链和this 函数主体的确认:
my_fun.b(); 运行主体是my_fun 指向的是fun 的实例
实例中有a = 0 和b function ,b()打印的就是实例中的a .这时候是0
因为实例中已经有b 方法 所以不会运行原型链中的方法
然后运行my_fun.c(); 运行主体还是my_fun 这时候调用原型链中的c 方法修改了实例中a 的值,所以 弹出30
20.1 答案是 : 10 , 10 , 11,11
21: 答案是:
//Fn
//Object
//undefined
//20
//找不到方法
//20
//NaN
f2.bb(); 因为这时候 原型链重定向 所以f2 中没有bb 这个属性 这时候运行会报错的
至于最后一个f2.proto.aa(); 因为函数运行主体是 f2.proto 运行原型链中的方法console.log(this.m +10); 此时this 是 f2.proto ,而这里边没有m的这个属性 , 所以, this.m 就是undefined , 用undefined + 10 . 就是NaN . Not a number
22 略:
23: null 和 undefined . null 是因为已经到了最顶端没有上级了
undefined 是因为没有这个属性
24: 略:
25 原型链
26 保存和保护, 占内存
