复习：

以下类型都是 object

console.log(typeof new Object);
console.log(typeof new Array());
console.log(typeof new Date());
console.log(typeof new RegExp());
console.log(typeof new String());
console.log(typeof new Number());
console.log(typeof new Boolean());
console.log(typeof Math); // 就是一个对象 不能new

// 函数的类型是 function
console.log(typeof new Function());//function

typeof 6种类型 number string boolean undefined object function

in 运算符

作用：判断指定的属性是否存在于被检测的对象中（含自身属性和原型属性，无论普通 / 不可枚举 / 原型）
语法： key in obj

var obj = {
	"name": "chuanchuan",
	"age": 19, 
	"gender": "male"
};
// 遍历对象
for(var k in obj) {
	console.log("key = " + k + ", v = " + obj[k]);//这里不能写obj.k;
}
console.log("age" in obj);// true
console.log("toString" in obj); // true   toString 是继承来的

var arr = [1, 0];
// 对数组来说，索引就是数组的属性
console.log(2 in arr); // false  0和1在  2就不在了

// 判断是否存在属性的方法：
// 1 in
// var obj = {};
// console.log("age" in obj);

// 2 if
if(obj.age) {
	// 如果有 。。。。
} else {
	// 没有。。。
}

面试题

// 判断两个对象是否相等
console.log({} === {});	 // false
console.log({} == {});   // false

console.log("1" == 1);   // true
console.log("1" === 1);  // false

// 值类型（简单类型）
// 如果存储的是数据本身，那么就是值类型5种
// 包括：string / number /boolean / null / undefined
// 引用类型（复杂类型）
// 如果存储的是数据的引用（地址），那么就是引用类型9种
// 包括：Object Function Array Date Math RegExp String Number Boolean

1. 为对象定义方法的两种方式

Product.prototype.buy=function(){};

Product.prototype={
	buy:function(){}
}

2. 用构造函数创建属性的四种方式

/*传参形式*/
function Product(name){
    this.name = name
}
Product.prototype={}
var iphone = new Product('iphone8s')

/*默认值*/
function Product(){
    this.name = ''
    this.price=0
}
Product.prototype={}

var iphone = new Product()
/*动态添加形式*/
iphone.description='XXXXXXXXXX'
iphone.images=[]

/*混合模式*/
function Product(name,price){
    this.name = name
    this.price=price
    this.version=1.0
    this.add=function(){}
}
Product.prototype={}

3. instanceof; A instanceof B 检测构造函数B的原型属性在不在A的原型链上

4. 两个面试题

①
var fun1 = function(){
        this.name = 'peter';
        return {
            name: 'jack'
        };
    }
    var p1 = new fun1();
    console.log(p1.name)// jack
②
    var fun2 = function(){
        this.name = 'peter';
        return 'jack';
    }
    var p2 = new fun2();
    console.log(p2.name)//peter
③
var o = new Object();
// 2 创建一个函数
function foo(obj) {
    obj.name = "腐女";
    
    obj = new Object();
    obj.name = "屌丝";
}
// 3 调用函数
foo(o);
console.log(o.name); //腐女

5. 函数声明和函数表达式的区别

 var str =''
    var num=1
    var bool=true
    var date = new Date()
    console.log(fn())  //21行输出函数  本行输出undefined
    console.log(fn2())// 报错 Uncaught TypeError: fn2 is not a function

    //函数声明，变量fn以及其实现被提升到顶部
    function fn(){
        console.log('函数')  //第21行
    }
    //函数表达式,仅变量fn2被提升到顶部，实现没有被提升
    var fn2 = function(){
        console.log('函数变量形式')
    }

6. 属性的get和set

function Product(name,price) {
        /*属性 行为 可以为空或者给默认值*/
        this.name=name
        this.price=1000;
        this.description = '';
        this.zhekou = ''
        this.sales = ''
        this.produceDate
       //固定写法 写在构造函数内部  Object.defineProperty(this, "属性名", fn)
        Object.defineProperty(this, "price", {
            value:5000000,
            writable: false,  //设置属性是否可写
        });
        Object.defineProperty(this, "produceDate", {
            get: function () {
                return dateFormat(produceDate,'yyyy年MM月dd日');
            },
            set: function (value) {
                produceDate = value;
            }
        });
    }

7.公有属性 私有属性

function Person(name) {
        //私有属性，只能在对象构造函数内部使用
        var className = "用户对象";
        //公有属性,在对象实例化后调用
        this.name = name;
        //私有方法
        var privateFunction = function () {
            alert(this.name);
        }
        //公有方法
        this.publicFunction = function () {
            alert(this.name); //公有属性
            alert(className); //正确 直接通过变量名访问
            alert(this.className); //undefined 错误 不能这样访问
        }
        //公有属性
        alert(className);
        //正确 直接通过变量名访问
        alert(this.className); //undefined 错误 不能这样访问
    }

8. 数据类型检测的方法

① typeOf(); 在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 “object”。

console.log(typeof undefined)//'undefined'
console.log(typeof null) //object  未知bug
console.log(typeof true) //'boolean'
console.log(typeof 123)  //'number'
console.log(typeof "abc")  //'string'
console.log(typeof function() {}) //'function'
var arr=[];
console.log(typeof {}) //'object'
console.log(typeof arr)//'object'
console.log(typeof unknownVariable) //'undefined'

②call方法 Object.prototype.toString.call()

console.log(toString.call(123))   // "[object Number]"
console.log(toString.call('123'))  //"[object String]"
console.log(toString.call(undefined))  //"[object Undefined]"
console.log(toString.call(true))  //"[object Boolean]"
console.log(toString.call({}))  //"[object Object]"
console.log(toString.call([]))  //"[object Array]"
console.log(toString.call(function(){}))  //"[object Function]"

③ instanceof

var arr = new Array()
console.log(arr instanceof Array)     //---------------> true
console.log(date instanceof Date)     //---------------> true
console.log(fn instanceof Function)   //------------> true//    
alert(f instanceof function)        //------------> false
//  注意：instanceof 后面一定要是对象类型，并且大小写不能错，该方法适合一些条件选择或分支。

④ constructor 判断一个实例的构造函数是谁 对象.constructor
console.log(arr.constructor === Array) //----------> true
console.log(date.constructor === Date) //-----------> true
console.log(fn.constructor === Function) //-------> true




⑤jquery中的检测数据类型的方法
Query提供一系列工具方法，用来判断数据类型，以弥补JavaScript原生的typeof运算符的不足。
以下方法对参数进行判断，返回一个布尔值。

    jQuery.isArray()：是否为数组。
    jQuery.isEmptyObject()：是否为空对象（不含可枚举的属性）。
    jQuery.isFunction()：是否为函数。
    jQuery.isNumeric()：是否为数字。
    jQuery.isPlainObject()：是否为使用“{}”或“new Object”生成的对象，而不是浏览器原生提供的对象。
    jQuery.isWindow()：是否为window对象。
    jQuery.isXMLDoc()：判断一个DOM节点是否处于XML文档之中。

总和；
/判断变量是不是数值型/

//因为NaN也是number类型的，它是不能用于数值运算的。

 function isNumber(val){
    return typeof val === 'number' && isFinite(val);
 }

// 顺便介绍一下JavaScript isFinite() 函数，isFinite() 函数用于检查其参数是否是有穷大，
// 如果 number 是有限数字（或可转换为有限数字），
// 那么返回 true。否则，如果 number 是 NaN（非数字），或者是正、负无穷大的数，则返回 false。

 /*判断变量是不是布尔类型*/
    function isBooleanType(val) {
        return typeof val ==="boolean";
    }

    /*判断变量是不是字符串类型*/
    function isStringType(val) {
        return typeof val === "string";
    }

    /*判断变量是不是Undefined*/
    function isUndefined(val) {
        return typeof val === "undefined";
    }

    var a;//a是undefined
    var s = "strType";
    alert("变量a是Undefined的判断结果是："+isUndefined(a));
    alert("变量s是Undefined的判断结果是："+isUndefined(s));

    /*判断变量是不是对象*/
    function isObj(str){
        if(str && typeof str === 'object' && str.constructor!=Array){
            return true;
        }
       return false
    }
    /*判断变量是不是null*/
    function isNull(val){
        return  val === null;
    }
  
    /*判断变量是不是数组*/
    //数组类型不可用typeof来判断。因为当变量是数组类型时，typeof会返回object。
   //方法1
    function isArray1(arr) {
        return Object.prototype.toString.call(arr) === '[object Array]';
    }
   //方法2
    function isArray2(arr) {
        if(arr === null || typeof arr === 'undefined'){
            return false;
        }
        return arr.constructor === Array;
    }

9. 基本数据类型 string number boolean

   复杂数据类型（引用类型）
Array  Date  Object  RegExp  String  Number  Boolean   function

值类型和引用类型

var obj = {
    name : "宅男"
};

function jinhua(param){
    //param = obj
    param.name = "高富帅";
    //下面的这句代码，重新创建了一个对象，修改了param的指向
    //但是，obj还指向原来的那个对象 所以，在修改param的时候，修改的是
    //新创建的对象，跟obj没有关系
    param = {
        name:"腐女"
    };
    param.name = "宅男";
}

jinhua(obj);

console.log(obj.name); //高富帅

//值类型做函数的参数
//函数内部的变量，也就是形参和实参只是简单的赋值操作，两个数据独立存储于内存中的
//在函数内部对形参进行修改，不会影响外面的变量

//引用类型做函数的参数
//还是把实参存储的地址赋值给了形参，在函数内部，形参同样也指向该对象，
//所以，在函数内部对该对象进行修改，会影响到外面的变量

//注意：如果在函数内部重新创建对象，为该形参赋值，那么两个对象将不再有关系
//修改其中一个，另外一个不受影响

10. delete关键字

var obj = {
     name : "尼古拉斯@赵四",
     age : 20
 }

//delete关键字可以用来删除对象的属性或方法，删除未使用var声明的变量
//delete关键字有返回值 用来表示删除属性是否成功
//如果删除的是不存在的属性，返回值为true
//如果删除的属性存在原型当中，那么返回值为true，但是并未删除

示例：删除属性 本身有返回值

	var obj = {age: 19};
	console.log(obj.age); // 19

	var b=delete obj.age;
	console.log(b);//true

	console.log(obj.age);//undefined

示例：删除变量

	var num = 1;
	// 没有用var声明的变量
	num2 = 123;
	
	var b1=delete num;   // 使用var/let/const声明的变量是无法通过 delete 运算符删除的
	var b2=delete num2;  // 可以删除
	console.log(b1)//false
	console.log(b2)//true
	console.log(num);  // 1
	console.log(num2); // 报错

示例：删除数组中的元素
// 删除数组中的元素

var arr = [1, 2];
delete arr[0];
console.log(arr); // [empty,2]  length还是2

11. 异常捕获

//异常捕获语句的完整形式

    try{
        //可能出现异常的代码
        xyz();
    }
    catch(e){
        //出现异常后的处理代码  e就是异常信息
        throw new  Error("自定义信息")；
//throw " 自定义信息"；
    }
    finally{
        console.log("我是finally中的代码");
        //不管有没有出现异常，这里的代码都会执行
        //node.js
        //做释放资源的操作。
    }

12. 创建对象的方式

① //1.对象字面量 var obj={key:value,key:value…}
//只能创建一次对象，复用性较差，如果要创建多个对象，代码冗余度太高

 var obj = {
       name:"演员",
       singer:"薛段子手",
       type:"流行"
   };

   var obj1 ={
       name:"吻别",
       singer:"张学友",
       type:"流行"
   }

②.使用内置构造函数

   var obj = new Object();
   obj.name = "一千个伤心的母牛";
   obj.singer = "张学友";
   obj.sing = function () {
       console.log("一千个伤心的母牛");
   }

   var obj1 =new Object();
   obj.name = "一千个伤心的母牛";
   obj.singer = "张学友";
   obj.sing = function () {
       console.log("一千个伤心的母牛");
   }

③.封装简单的工厂函数 (不推荐使用了)

function createSong(songName,singerName){
    var o =new Object();
    o.name = songName;
    o.singer = singerName;

    o.sing = function () {
        console.log("让我来唱首歌");
    }
    return o;//{name:"",singer:"",sing:function...}
}
var obj = createSong("演员","薛之谦");
var obj1 = createSong("一言难尽","张宇");

④/自定义构造函数 Object Array
//什么是构造函数?
//构造函数其实也是函数，但是通常用来初始化对象
//并且和new关键字同时出现

    //new 是用来创建对象的
    //构造函数是用来初始化对象的(给对象新增成员)

    //构造函数名，首字母要大写！！！以示区分

	function Person() {
        //默认隐含的操作，把刚才用new新创建出来的对象赋值给this
        this.name = "尼古拉斯凯奇";
        this.age = 50;
        this.sayHello = function () {
            console.log("Hey man");
        }
        //如果这里写其他的代码，会执行吗？  肯定会

        return null;
    }

    var p = new Person();//new Object();
    console.log(p);
    p.sayHello();

*****构造函数的执行过程

    1.使用new关键字创建对象
    2.调用构造函数，把新创建出来的对象的引用赋值给构造函数内的this
    3.在构造函数内使用this为新创建出来的对象新增成员
    4.默认返回新创建的这个对象 （普通的函数，如果不写返回语句，会返回undefined）

*****构造函数的返回值
1.如果不写返回值，默认返回的是新创建出来的对象 （一般都不会去写这个return语句）
2.如果我们自己写return语句 return的是空值（return;）或者是基本类型的值或者null，都会默认返回新创建出来的对象
3.如果返回的是object类型的值，将不会返回刚才新创建的对象，取而代之的是return后面的值

13. 原型

原型：任何一个函数都有一个 prototype 的属性，函数的原型属性（prototype）的是 对象类型 的，由 构造函数 创建出来的对象，会默认链接到其构造函数的这个属性（prototype）上，构造函数的 prototype 属性的作用就是：实现数据共享
使用原型的注意事项
1.使用对象访问属性的时候，如果在本身内找不到就会去原型中查找，但是使用点语法进行属性赋值的时候，并不会去原型中进行查找，如果对象中不存在该属性，就会给该对象新增该属性，而不会去修改原型中的属性

    2.如果在原型中的属性是引用类型的属性，
    那么所有的对象共享该属性，并且一个对象修改了该引用类型属性中的成员，其他对象也都会受影响

    3.一般情况下不会将属性放到原型对象中
    一般情况下原型中只会放需要共享的方法

术语：F.prototype 原型属性
f.proto 原型对象

proto ：每个对象都有一个__proto__属性，非标准，对象的 proto 与创建它的构造函数的 prototype 是一个东西

function F() {}
var o = new F();
console.log(o.__proto__ === F.prototype); //true

14. 创建函数的三种方式

	创建函数的三种方式
	1 函数声明的方式
	2 函数表达式
	3 通过 new Function() 创建 (后面单独详细介绍)

		// 1
		function foo1() {
			function f() {}
		}
		
		// 2
		var foo2 = function() {

		};

		// var foo2;
		// foo2 = function() {};

		// 3
		var foo3 = new Function();

函数声明和函数表达式的区别
注意：预解析是带var的变量和函数体，而不带Var不会预解析，如果在赋值之前打印就报错 not defined；

	1 函数表达式中的名字可以省略,如果没有省略，那么这个名字可以是任何的值,还有注意：这个名字只能函数体内部使用
	2 提升
		 	函数声明的方式，整个函数体都会被提升
		 	函数表达式，提升的是变量
	3 函数声明 不能出现在其他语句中

		// 不推荐
		/*if(true) {
			function f() {console.log("11111");}
		} else {
			function f() {console.log("222222");}
		}
		f();*/

		// 推荐使用这种方式
		if(true) {
			var f = function () {console.log("11111");}
		} else {
			var f = function () {console.log("222222");}
		}
		f();

15.面向对象和面向过程

面向过程：所有的细节、步骤、过程，要一步一步亲历亲为（执行者） 面向对象是对面向过程的封装
面向对象：找到能完成这个事情的对象，让它帮你完成就行（调度者）
// jQuery
// 面向对象的方式
$(“body”).append(“

jQuery创建节点就是如此潇洒

”);

// js
// 面向过程的方式

var p = document.createElement("p");
var txt = document.createTextNode("creat E..，creat T..真麻烦");
p.appendChild(txt);

document.body.appendChild(p);

面向对象优势（解决函数封装问题）
封装代码，使代码更好维护
减少全局污染
将功能相近的代码组织到一起维护方便，找错方便
面向对象的基本模型
1 将数据与功能封装成函数(方法)
2 将相关的功能绑定到一起(对象)
3 将功能进行分组(模块)

16. 关于内存释放

17. 作用域练习题

题1
题2

18. 综合实战题

点击让数字加1 4种方法


上下两种一样的原理