2、判断：
var b1 = {
b2: [1,'abc',console.log],
b3: function(){
console.log('b3');
return function(){
return 'xfzhang';
}
}
}
console.log(typeof b1.b2) // 'object'
console.log(b1 instanceof Object, b1 instanceof Array);3、相关问题：
function Person(name,age){ // 构造函数 类型
this.name = name;
this.age = age;
}
var p = new Person(); // 根据类型创建的实例对象
var a;
console.log(a); // undefined
a = null;
cosnole.log(a); // null
3）什么时候给变量赋值为null？
* 初始赋值，表明将要赋值为对象
* 结束前，让对象成为垃圾对象（被垃圾回收器回收）
// 起始
var b = null; // 初始赋值为null，表明将要赋值为对象
// 确定对象就赋值
b = ['abc', 12];
// 最后
b = null; // 将b指向的对象成为垃圾对象（被垃圾回收器回收）二、数据、变量、内存
1、什么是数据？
var a = 3;
var b = a;
var a = 3;
var b = a + 2;2、什么是内存？
3、什么是变量？
4、内存、数据、变量三者之间的关系
5、相关问题1
var obj1 = {name:'Tom'};
var obj2 = obj1; // 将obj1内存的内容保存到obj2
obj1.name = 'Jack';
console.log(obj2.name); //'Jack
var a = {age:12};
var b = a;
a = {name: 'BoB',age:13};
b.age = 14;
console.log(b.age,a.name,a.age); // 14 Bob 13
function fn(obj){
obj = {age:15}
}
fn(a);
console.log(a.age); // 136、相关问题2
① 在js调用函数时传递变量参数时，是值传递还引用传递？
* 理解1：都是值（基本/ 地址值）传递
* 理解2：可能是值传递，也可能是引用传递（地址值）
② JS引擎如何管理内存？
Ⅰ 内存生命周期
* 分配小内存空间，得到它的使用权
* 存储数据，可以反复进行操作
* 释放小内存空间
Ⅱ 释放内存
* 局部变量：函数执行完自动释放
* 全局变量：成为垃圾对象 ---> 垃圾回收器回收
function fn(){
var b = {}
}
fun(); // b是自动释放，b所指向的对象是在后面的某个时刻由垃圾回收器回收三、对象
1、什么是对象？
2、为什么要用对象？
3、对象的组成
4、如何访问对象内部数据？
var p = {
name: ' Tom ',
age: 12,
setName: function(name){
this.name = name;
},
setAge:function(age){
this.age = age;
}
}
p.setName('Bob');
p['setAge'](23);
console.log(p.name,p['age'])
var p = {}
1. 给p对象添加一个属性：content-type:text/json
p.content-type = 'text/json' //不能用
p['content-type'] = 'text/json'
2.属性名不确定
var propNmame = 'myAge';
var value = 18;
p.proName = value; //不能用
p[proName] = value四、函数
1、什么是函数？
2、为什么要用函数？
3、如何定义函数？
* 函数声明
function fn1(){
console.log('fn1()')
}
* 表达式
var fn2 = function(){
console.log('fn2()')
}
4、如何调用（执行）函数？
var obj = {}
function test2(){
this.xxx = 'guigu'
}
obj.test2(); // 错误
test2.call(obj); //js可以让一个函数成为指定任意对象的方法进行调用
console.log(obj.xxx);五、回调函数
1、什么函数才是回调函数？
2、常见的回调函数？
六、IIFE
1、理解
2、作用
(function(){
var a = 1;
function test(){
console.log(++a);
}
window.$ = function(){ // 向外暴露一个全局函数
return {
test:test;
}
}
})();
$().test(); // 1.$是一个函数 2.$执行后返回的是一个对象七、函数中的this
1、this是什么？
2、如何确定this的值？
* test( )：window
* p.test( )： p
* new test( )：新创建的对象
* p.call(obj)：obj
function Person(color) {
console.log(this)
this.color = color;
this.getColor = function () {
console.log(this)
return this.color;
};
this.setColor = function (color) {
console.log(this)
this.color = color;
};
}
Person("red"); //this是谁? window
var p = new Person("yello"); //this是谁? p
p.getColor(); //this是谁? p
var obj = {};
p.setColor.call(obj, "black"); //this是谁? obj
var test = p.setColor;
test(); //this是谁? window
function fun1() {
function fun2() {
console.log(this);
}
fun2(); //this是谁? window
}
fun1();八、关于语句分号问题
1、在下面两种情况下不加分号会有问题
2、解决方法：在行首加分号
九、复习
十、函数的prototype
1、函数的prototype属性
2、给原型对象添加属性（一般都是方法）
十一、显式原型与隐式原型
1、每个函数function都有一个prototype，即显式原型
2、每个实例对象都有一个__proto__，可称为隐式原型
3、对象的隐式原型的值为其对应构造函数的显式原型的值
4、内存结构
5、总结：
十二、原型链
1、原型链
2、构造函数 / 原型 / 实体对象的关系
3、构造函数 / 原型 / 实体对象的关系2
十二、原型链_属性问题
1、读取对象的属性值时：会自动到原型链中查找
2、设置对象的属性值时：不会查找原型链，如果当前对象中没有此属性，直接添加此属性并设置其值
3、方法一般定义在原型中，属性一般通过构造函数定义在对象本身上
十三、探索 instanceof
（判断左边的对象是否为右边类型的实例）
1、Function是通过new自己产生的实例
2、instanceof是如何判断的？
//案例1
function Foo() { }
var f1 = new Foo();
console.log(f1 instanceof Foo); // true
console.log(f1 instanceof Object); // true
//案例2
console.log(Object instanceof Function) // true
console.log(Object instanceof Object) // true
console.log(Function instanceof Object) // true
console.log(Function instanceof Function) // true
function Foo() {}
console.log(Object instanceof Foo); // false十四、面试题
/*
测试题1
*/
var A = function() { }
A.prototype.n = 1
var b = new A()
A.prototype = {
n: 2,
m: 3
}
var c = new A()
console.log(b.n, b.m, c.n, c.m) // 1 undefined 2 3
/*
测试题2
*/
var F = function(){};
Object.prototype.a = function(){
console.log('a()')
};
Function.prototype.b = function(){
console.log('b()')
};
var f = new F();
f.a() // true
f.b() // false
F.a() // true
F.b() // true
