javaScript复习！

变量的基本类型
			原始类型：number,string,boolean,null,undefined
			引用类型：Object,Array,Function
		typeof 返回的值(返回的是字符串)
			number,string,boolean,object,undefined,function
			{} [] null 返回的是object
			使用函数判断具体数据类型：

			function uniq(item){
				var itemType = Object.prototype.toString.call(item)
				if (typeof item == 'object') {
					if(item==null){
						console.log('null')
					}else if(itemType =="[object Array]"){
						console.log('Array')
					}else{
						console.log('Object')
					}
				}else{
					console.log(typeof item)
				}
			}
			var str = undefined
			uniq(str)
		instanceOf 判断变量是属于哪种类型，返回的值是boolean

		强制类型转换
			字符串拼接
			== 
			赋值语句
			逻辑运算
			if语句
		=== 
			== 如果判断值是否是 null和undefined 
			if(obj.a == null){}
			等价于
			if(obj.a === null||obj.a===undefined){}
			js中的内置函数
		Object,Array,Boolean,Number,String,Function,Date,RegExp,Error

		如何理解JSON
			JSON是JS的一个对象
		JSON.stringify({a:10,b:20})
		JSON.parse('{"a":10,"b":20}')

		原型和原型链:
			所有的引用类型都具有对象特点,即自由扩展属性
			所有的函数都有一个显示类型的属性，prototype指向构造器
			所有的引用类型都有一个_proto_属性，属性只是一个普通对象


		 new 一个函数的过程
			新建一个对象
			this指向这个对象
			给this赋值，
			返回this


			prototype 引用
			Father.prototype.lastName = 'xiaogeng'
			function Father(name,age){
				this.name = name;
				this.age = age;
			}
			var father = new Father('genggeng',25)

			Son.prototype = father
			Son.prototype.car = 'benz'
			function Son(grade){
				this.grade = grade
			}

			var item

			for(item in f){
				if(f.hasOwnProperty(item)){
					console.log('是本身属性')
				}
			}

			var son = new Son('3年级');
			console.log(son);
		继承
			原型链继承
				Grande.prototype.lastName = "benz" 
				function Grande(name,age){
					this.name = name;
					this.age = age
				}
				var grande = new Grande()
				Father.prototype = grande;
				function Father(grade){
					this.grade = grade
				}
				var father = new Father("xiaogeng",24,'大四')

				console.log(father)
			call/apply借用：该方法的缺点是不能继承原型上的东西
			 		Grande.prototype.lastName = "benz" 
				function Grande(name,age){
					this.name = name;
					this.age = age
				}
				function Father(name,age,grade){
					Grande.call(this,name,age)
					this.grade = grade;
				}	
				var father = new Father('xiaogeng',24,'大四')
				console.log(father)
			共享原型：不能修改原型
				Grande.prototype.lastName = "benz" 
				function Grande(){
				
				}
				function Father(){
				
				}
				function inhert(Tagert,Origin){
					Tagert.prototype = Origin.prototype
				}
				inhert(Father,Grande);

				var father = new Father()
			圣杯模式
				Grande.prototype.lastName = "benz" 
				function Grande(){
				
				}
				function Father(){
				
				}
				function inhert(Tagert,Origin){
					function F(){}
					F.prototype = Origin.prototype
					Tagert.prototype = new F()
					Tagert.prototype.constructor = Tagert //把Target的构造函数指向归位
					Tagert.prototype.uber = Origin.prototype //为了让我们知道Target真正继承自谁
				}
				inhert(Father,Grande);

				var father = new Father()

function test(){
			//函数声明
		}
		var text = function(){
			//函数表达式
		}
		//在后面添加执行符，函数表达式是可以执行的，但是函数声明不能被执行，因为函数声明会被先提升

		//执行期上下文：每个javascript函数都是一个对象，对象中有些属性我们可以访问，但有些不可以，这些属性仅供JavaScript引擎存取[[scope]]就是其中一个；[[scope]]就是我所说的作用域，其中存储了运行期上下文的集合;[[scope]]中存储的执行期上下文对象的集合，这个集合呈链式连接，我们把这种链式连接叫做作用域链
			//范围：一段script标签或者函数内，会产生一个执行期上下文
			//全局：函数定义，函数声明
			//函数：变量定义，函数声明、this、arguments

		this //指向在定义时无法确定，在执行时才能确认
		var a = {
			name:'a',
			fn:function(){
				console.log(this.name)
			}
		}
		a.fn()
		a.fn.call({name:'b'})
		var fn1 = a.fn
		fn1() //this指向window
		// 作为构造函数执行，this指向new出来的对象
		// 作为普通函数执行，this指向window
		// call和apply、bind，this指向被绑定的对象
		// 对象中的this,指向最近调用的一级

		//作用域:javascript没有块级作用域
			if(true){
				var a = 2; 
				//不推荐这种写法，因为这同样是定义在全局的，但是不易读
			}
			//js的作用域分为全局作用域和函数作用域，为了防止污染全局变量，函数当定义在函数作用域内部
		//作用域链:
			var a = 100;
			function fn(){
				var b = 50;
				function fn2(){
					var c = 300
					console.log(a) //a是自由变量
					console.log(b) //b是自由变量
					console.log(c)
				}
			} 

// 同步和异步
			//"同步模式"就是上一段的模式，后一个任务等待前一个任务结束，然后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的.是一种阻塞模式

			// "异步模式"则完全不同，每一个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行，所以程序的执行顺序与任务的排列顺序是不一致的、异步的。是非阻塞的

			//异步的使用场景： 需要等待就需要异步
				//定时任务： setTimeOut,setInterval
				//网络请求: ajax请求，动态加载
				//事件

var today = new Date();
		today.getTime() //获取毫秒数
		today.getFullYear() //年
		today.getMouth() // 月（0-11）
		today.getDate() // 日（0-31）
		today.getHours() //小时(0-23)
		today.getMinutes() //分钟（0-59）
		today.getSeconds() // 获取秒

 

转载于:https://my.oschina.net/u/4036426/blog/3024709