js高级教程

js基础 (js 还有很多方法和属性,下面没有提及)
ec标准包括js和as es5 和 es6
js 核心语法
位置四个:属性上, a标签,独立,script内
变量
typeof 查看类型
var a=1;
运算符 + - / *
数据类型
布尔值
数字
undefined
字符串
null //释放资源
数组
函数
对象
数组
new Array() 或者 []
arr[0]=0
arr.push() 添加
arr.shift() 添加
arr.splice(索引,个数) //删除数组个数
arr=null;
for() //for循环
for of
for in 循环
arr.forEach //es5新增的
对象
一切皆对象
var obj =new Object 和 {}
obj.属性或方法=值或函数;
使用,obj.name 或者 obj[‘name’]使用

	函数
		function fn(){}
		var fn =function (){}
		匿名函数
	结构语句
		if else
		switch
		for
		while
		do while
dom 文档对象
	html5 提供了新的dom api 可以操作更多的dom文档
	事件有三种
		onclick= 'fn()'
		btn.onclick=function(){}
		btn.addEventListener('click',function(){});
bom 浏览器对象
	他就是window,函数是挂在window上面

高级变量
基本类型 数字 字符串 boolean undefined null
引用类型 数组 函数 对象

复制 基本是复制值, 引用类型是 复制地址

如果改变其中数据,是替换数据,只有改变其中的属性才有影响 ***
var name=18;
name.ls=3; //不可以这样使用,可以使用内置方法

instanceof  检查父亲是谁,属于谁 这个是判断是不是引用类型  (变量 instanceof 类型)
 typeof 检查自身类型

高级函数
实际参数可以比形式参数少 undefined
形式参数比实际参数多 没有反应 这个是重点
1.可以使用内置对象 arguments 可以接受所有参数,内置参数
2.可以打印函数本身 arguments.callee 打印函数本身,可以在node查看

面向对象(不是真的的面向对象)
1.内置类 Date Number Math等等函数都是
使用new 创建对象
2.自定义类
使用 Object函数 创建对象
3,工厂模式自定义类
function li(name,age){
var o = new Object();
o.name=name;
o.age=age;
return o;
}
var obj=new li(‘li’,18);
4, 构造函数 es5 //伪造的类方法
function Li(name,age){
this.name=name;
this.age =age;
}
var li = new Li(‘李志立’,18);
方法过载
实例化的对象是相互独立的(这个叫方法过载);(占用内存过多)
原型
所有函数和对象 都有一个 prototype 属性, 这个属性成为原型
1,解决方法过载
function Li(name,age){
this.name=name;
this.age =age;
}
Li.prototype.run=function(){} 方法挂载
2,扩展类,添加修改方法
console.dir(对象); 这个是查看对象的结构,数据
3,对象属性优先级
对象属性 > 构造函数 > 原型挂载 > 原型链(继承)
proto
和原型相等,就是引用地址相同
对象的叫__proto__(父级具有) 类上面叫 prototype(本身具有) (函数包含两个,即是 对象,也是 类)
constructor 这个是构造器声明,

json (js对象 标记)
转换 接受的是字符串格式 可以打印JSON 查看
字符串 转 对象 JSON.parsse(‘字符串’);
对象 转 字符串 JSON.stringify(数组或对象);
eval es3.1之前的版本
eval 是可以执行字符串 eval(‘var a=10’);

js 执行编译原理
编译型编程语言 先编译后执行 java c++ c
解释型编程语言 先执行后编译 php js
1,预编译 语法检查 ,变量提升 在变量环境中,先定义,后赋值. 函数作用域提升
2,执行 一句一句执行
作用域
函数外,全局作用域
查看 window 里面变量
函数内,局部作用域
let cost
块级作用域 (解决变量污染问题) iife 立即执行表达式函数
用函数内容执行
var sum = function (){
var sum =0;
for(var i= 0; i<100; i++){
sum+=i
}
return sum
}
匿名函数表达式(闭包)
(function(){
windows.a=3
})()
作用域链 气泡 (函数隐藏问题,把函数放到函数内部)(把函数和变量放进函数内部,就是闭包)

递归函数
阶乘
function fn(n){
if(n==1){
return 1;
}
return n+fn(n);
}
闭包(允许内部函数暴露在外部,访问函数内数据)
制作不重复,不修改的计数器
(function(){
var i=1;
window.show=function(){

	}
})()
var fn=(function(){
	var i=1;
	return function(){
		
	}
})()

回调函数
把函数当参数传进函数

this
严格模式 use strict
全局代表是window
函数中this 代表执行者的this
对象内this 代表的是对象本身,也是调用执行者
构造函数this 代表对象本身,就是谁new代表谁

函数 借给别的方法使用(修改了this的指向,可以让别的对象,调用本对象的方法)
var o={ phone:function(a){
console.log(222+a)
}};
o.phone(‘sss’)
var a={};
o.phone.call(a,‘www’)

call方法  主动指向 借用  调用一次,执行一次,执行完,注销掉

apply 方法 和call 一样,区别在于,传参的格式不一样,call是多个,apply是数组
bind 方法  被动式,调用时才改变this,一样,区别在于,不能直接执行,需要用 o.phone.bind(a,'www')()  (用定时器演示一下)

封装
就是把代码(函数) 封装到iife 函数中
目的是隐藏 属性和方法, 设置权限
1.(把变量,和函数,变成var 私有化)
2.可以使用特权方法() 自己设置
3,闭包方式(静态方法) 不需要实例 代码测试
原型的第二种方法

继承
原型链
1,对象伪造 子类拥有父类方法,但是不属于父类的子类
(让着父类原型等于子类原型) 指针赋值
(遍历父类原型,赋值给子类) 内存赋值
2,原型链继承
子类原型等于父类的实例
1,让子类实例化出来拥有所有属性
fu.call(this,name)
fu.apply(this,arguments) //子类的属性在最后

	2,让子类用于父类方法
		zi.prototye=Object.create(fu.prototype)
	3,找回丢失的构造器
		zi.prototye.constructor=zi

es6 继承
class fu{
constructor(name){
this.name=name
}
run(){

	}
}

class zi extends fu{
	constructor(age){
		super(name);
		this.age=age
	}
	xue(){
		
	}
}

多态 (这个了解一下就可以了,重载就是多态的表现)