JS高级（个人记录）

1.JS面向对象（掌握）

1.1 什么是js?

​ js它是一个基于对象和事件驱动的前端的编程语言，可以用来改进页面的设计，比如验证表单。

1.2 JS一切皆对象 (函数也是对象)

​ Java对象：某一个事物的具体的实例；

​ java基本类型： byte short int long char float double boolean

​ JS对象： 某一类事物也有具体的实例；

​ 比如： Person new Person();

​ JS里面一切皆对象；像JS里面的基本类型，引用类型和函数都可以看成一个对象；

变为对象就可以调用方法

1.3 true和false 注意事项：

0，"",undefined,NaN,null,flase 为false 其他都为true；

对象注意示例：
var flag = false;
	if(flag){
		console.log('这次进入不了 因为是布尔类型false')
	}

var flag1 = new Boolean（false）；
    if(falg1){
    	console.log('这次就能进入，因为现在是对象不是布尔类型')
    }

json的操作：
        eval()
        JSON.parse
        $.parseJSON

	var jsonStr = '{"name"："张三","age":18}';
	var jsonObj = eval("("+jsonStr+")");
		console.log(jsonObj);
json的字符串必须是标准的格式
jquery的转换方法   要使用$  必须引入jQuery文件 底层还是使用的JSON.parse方法进行转换
也就是字符串格式必须是标准的 
    var jsonObj2 = $.parseJSON(jsonStr); 
        console.log(jsonObj2);

JS类的操作：
	function Person(name,age){
        this.name=name;
        this.age = age;
    }
    var p1 = new Person("张三",18);
    var p2 = new Person("张4",22);
        console.log(p1);
        console.log(p2);

JS方法与属性的拷贝：
	var obj1 = {
        name:"gg",
        address:"yyy",
        age:"11",
        sex:"man"
    };
    var obj1 = {
            name:mm",
            sex:"woman"
        };
		console.log(obj1);
        console.log(obj2);
把对象1的address和age属性拷贝到obj2里面
	obj2.address = obj1.address；

	'对象2不存在的才添加   《.hasOwnProperty(判断是否有这个属性)》'
        for(var key in obj1){
            if(!obj2.hasOwnProperty(key)){
                obj2[key] = obj1[key]
                }
            }
            console.log(obj1);
            console.log(obj2);

函数对象的使用
	var func1 = new Function("a","b","return a+b");
		func1.age=11;
		func1.name='卢本伟';
		//函数里面Name这个属性，比较特殊，他是只读的属性不可修改
		console.log(func1);//这里打印就指挥出现age，不会出现name
		window.name='xxx';
		console.log(window.name);  //这里打印的是xxx
		//window里面默认的name属性是一个空字符串，并且可以进行修改
		var name = 'yyy';  //因为name默认是挂在window上面的
		console.log(window.name);  //这里打印的是yyy
		

2.JS里面THIS（掌握）

​ this 指的是当前对象，谁调用就是指向谁。

3.JS函数（掌握）

3.1回调函数: 就是一个通过函数(对象)引用调用的函数;

	//定时器就是一个回调函数   //ajax 回调 $.get(url,params,callback,type)都是回调函数
        setTimeoyt(doHandle,3000);
        function doHandle(){
            alert("3秒之后出现，这就是回调函数");
        }
	

​

3.2匿名函数: 没有名称的函数

	/**匿名函数有什么用？：
			1. 只想执行一次，解决作用域污染问题
			2. 作为一个参数来传递
		*/
	//匿名函数怎么写？  ↓  推荐写法
        (function(){
            alert(1);
        })(//'最后这个括号就是调用的意思');   
    //写法2：
        ~function(){
            alert(2);
        }(); 
 	//写法3：
        +function(){
            alert(3);
        }(); 

	//匿名函数有什么用？：
		var x=10;
		var y=20;
  		var z = x*y;
 		console.log(z);
		console.log(window); //这样就会造成作用域污染问题  所以就要使用匿名函数
	//匿名函数写法：
        (function(a,b){
			var result = a*b;
            console.log(result);
            window.result = result;//如果只想要算出来的结果的话 就挂到window上面
        })(10,50); //调用函数  把值分别传入a,b；
			console.log(window);//这样window作用域就不会被污染
			//挂到window上之后，在外面就可以使用结果值了

        (function(name)){
            console.log("说出名字："+name);
         }();  //这里没有传参数  所以打印出来 name就是undefined

/**
	小结：
		1. 匿名函数的写法: 
			(function(){
				
				})(参数1，参数2)；
		2. 解决作用域污染问题，有时候一些变量，只需要使用一次，用完之后就不需要他存在了，就可以
			通过匿名函数来实现 -- 屏蔽实现，只需要得到一个结果
		3. 匿名函数还可以作为一个参数来传递 比如 setTimeout
*/

JS原型Prototype（掌握）

prototype的使用：

prototype指原型的，每一个对象都有prototype的这个属性，我们可以通过该属性往对象上面添加属性方法。
	function User(name,age){
        this.name=name;
        this.age=age;
    }
	var user1 = new User('yyk',12);
	console.dir(user1);
    var user2 = new User('ygq',11);
	console.dir(user2);
	// ↓ 对象里面的原型属性  --  这个原型属性也是一个对象
	console.log(user1.__proto__ === uer2.__proto__);
	// 1. 同一个类的不同实例对象的原型是共享的；
	user1.__proto__.sex = 'man'; 
	console.log(user1);
	console.log(user2);  
	//因为是原型共享 所以user2这个原型也回有添加的这个数据
	console.log(user2.sex);//原型里面的对象的值可以打印出来

	//注意 ：  如果是以下↓例子
    this.sex=sex;
	var user2 = new User('xxx',12);
  	console.log(user2.sex); //打印出来的就是undefined
	//如果自身有就先找自身的值，如果没有再找原型里面的

	User.prototype.eat = function(){
        console.log('吃帮帮')；
    }
	user1.eat();
	user2.eat();
	//打印的就是吃帮帮  直接在原型上面进行添加的元素 user1 和user2都能使用
	/**
		小结：
			1.什么是原型？：
				prototype，他是类或者对象里面的属性，通过他可以给对象添加属性和方法
			2.每个对象的原型是共享的。
			3.属性的查找规则：
				先从自定义的属性上面找，没有找到再从原型上面去找。
	*/
	

​

JS闭包

函数内使用函数外的东西就是闭包

//最简单的闭包 函数内使用函数外的东西
        var name = 'xxx';
        function test(){
            console.log(name);
        }
        test();
//闭包： 实现只读的属性
<!--    var sum = 0;
        function add(){
            return sum++;
        }
        console.log(add()); //0   //0
        console.log(add()); //1	  //1
		sum = 3;
        console.log(add());	//2	  //3
        console.log(add());	//3	  //4
        console.log(add());	//4	  //5    -->

//闭包和匿名函数结合起来使用  实现只读的属性
	(function(){
        var a = 0;
        window.getSunm = function(){
            return a++;
        }
    })();
		 	console.log(getSum());  //0		//0
            console.log(getSum());	//1		//1
			a=10;//window.a         //这样就无法改变值  
            console.log(getSum());	//2		//2
            console.log(getSum());	//3		//3
            console.log(getSum());	//4		//4    

jQuery插件

JS继承—>Java继承

jQuery事件命名空间

jQuery事件委托（掌握）

什么是事件的委托？:

​ 基本的事件绑定，在功能有一个局限，必须是在绑定的时候 已知的，存在的，

<a href="javascript:void(0)">xxxx </a>   
 //可以避免锚点 比 href"#"好用

​

jQuery事件（掌握）

​

jQuery继承（jQuery写一个插件）

/*
	jquery想要实现继承：可以通过prototype    可以扩展功能	
	jQuery.fn == jQuery.prototype == $.fn
*/