我理解的js中的构造函数，异步执行

构造函数

function Person(name,age,sex){
	        this.name=name;
	        this.age=age;
	        this.sex=sex;
	        this.getMoney = function(){
	        	console.log("获取10000美元");
	        }
	        console.log("执行Person构造函数-----",name);
	}
	Person.prototype.sayHi=function(){
	        console.log("你好")
	}
	Person.prototype.name = "原型链上的name"  

	function  Student(name,age,sex,score){
			//借用构造函数
			// Person.call(this,name,age,sex)
			this.score=score;
			console.log("执行Student构造函数----",name);
	}

	// 改变了原型指向
	Student.prototype = Person.prototype;
	//下面这句话执行的是Person这个构造函数
    Student.prototype.constructor();
    //打印值发现Student的原型对象的构造函数已经不再指向Student,而是指向了Person
	console.log("------",Student.prototype.constructor==Student,Student.prototype.constructor==Person);


	Student.prototype.eat=function(){
	console.log("吃东西");
	}
    
    //下面这句代码使我理解起来十分费解
    /*
	  var stu = {};
	  执行上面这句代码以后，确定了一个新对象
	  stu.__proto__ = Student.prototype
	  执行上面这句话以后,对于使用Student生成的子类对象，当这个子类对象寻找某个属性时，会首先在自己内部找，如果没有
	  就会去Student.prototype上去找
	  Student.call();
      执行这句代码以后，没有传递this的作用域,所以默认this的作用域就是Student这个对象，将Person中所有和this有关的属性和方法全部放入      Student中,
	*/
	var stu=new Student("小黑",20,"男","100分");
	
	console.log(stu.name,stu.age,stu.sex,stu.score);
	stu.sayHi()//你好
	stu.eat()//吃东西
	stu.getMoney();//父类中的函数

上面的代码我定义了一个Person函数和一个Student函数，我让Student的原型对象指向Person的原型对象
当我在给Student生成对象的时候，我发现它调的构造函数仍然是他自己，我上边没有给他的原型对象构造函数复位啊
！！！！！！！！！！！！
重新来理一下思路：
函数的构造函数到底是啥，我们在对一个函数AA进行new操作的时候，会进行三步操作，
第一步生成一个空对象aa，var aa = {};
第二步给这个空对象增加一组（proto，prototype),aa.key=AA.prototype
第三步就是执行构造函数了，我们发现这个构造函数就是我们new的那个函数AA本身,AA.call(aa);
在js中经常说函数原型对象的构造函数指向它本身，AA.prototype.construct ==AA;这句话没有毛病，但是在进行new的时候，真正调用的构造函数是函数本身AA,函数原型对象的构造函数在一些情况会发生改变的，比如我这里遇到的情况，其实我不修改指向，也不会影响new的时候正确构造函数的调用，但是考虑到不可预估的一致性，所以我们需要把它更正，因为以后我们可能会使用函数原型对象上的构造函数来做其他的一些事，我们需要得到正确的结果

异步执行

js是单线程的，分为同步任务和异步任务,同一个时刻只能去处理一个任务
有一个任务执行栈，同步任务都放到同步栈里面，异步任务执行有结果了，会放到异步栈
任务执行栈会从同步栈里取任务执行，当所有的同步栈任务执行结束，会从异步栈里取任务，
异步栈里也可以分的再细一点就是宏观异步栈和微观异步栈，在同一时刻，微观异步栈要先于宏观异步栈执行，
宏观异步栈指的是setTimeout(func,time);
微观异步栈指的是(new Promise()).then(func);

var example_asyn = function()
{
var test0 = function(){
	console.log("同步任务的第一个任务");
	setTimeout(()=>{
	          console.log("宏观任务1 当所有同步任务和微观任务执行完以后，则开始执行");
	})
	/*
	Promise是实现异步任务中微观任务的一个方法，通过传入一个callBack(resolve,reject)函数，一个是完成信号函数resolve
	一个是拒绝信号函数reject，这两个函数会触发Promoise对象上的then函数，这个then函数也有两个参数，一个是成功的回调，一个是拒绝的回调
	当然这个callback本身是同步任务，只是我们可以在这个callback的内部通过信号来选择时机触发then函数，从而实现了异步
	误区：不是说执行了resolve和reject这两个信号，就会立即出发它的then函数，then函数是微观异步栈，需要等所有的同步栈执行结束才可以执行
    
    下面这种方式的then函数的传参方式：
    then(success(data),fail(data))
    第一个then函数的参数可以拿到从信号槽传来的参数data
    后面的then函数必须依靠前一个then函数传来data,如果前一个then函数没有return，则下一个then函数的参数为undefined

	*/
	function promise(){
		return new Promise(function(resolve,reject){
		    console.log("同步任务 准备执行for循环了");
		    for(let i=0;i<100;i++){
		    	//必须执行reject这个函数才会去执行then函数的失败回调和catch函数
		        //i==20&&reject("then函数失败回调");
		        //必须执行resove()这个函数才会去执行then的成功回调
		        i==21&&resolve("我是信号槽传来的参数,传给第一个then函数成功回调");
		        console.log("number-----",i);
		    }

		    setTimeout(()=>{
		    	console.log("promise delay 1 sec end ");
		    	// resolve();
		    },1)
		})
	}
	promise()
			.then(function(res){console.log("执行then succes函数-----1",res);
			      //throw new Error('then中出现异常,会走下一个then的失败回调,\r\n由于下一个then没有失败回调，就会继续往下找,\r\n如果都没有，就会被catch捕获到');
			      return "此处的return可以传递给第二个then的成功回调";},function(err){console.log("执行then fail函数-----1",err)})
			.then(function(res){console.log("执行then succes函数-----2",res);return "此处的return可以传递给第三个then的成功回调"},(err)=>{console.log("执行then fail函数-----2",err)})
			.then(function(res){console.log("执行then succes函数-----3",res);return "此处的return可以传递给第四个个then的成功回调"},(err)=>{console.log("执行then fail函数-----3",err)})
			.catch(function(err) {console.log('出错啦',err)});
	console.log("同步任务,代码执行完毕");
}


var test1 = function(){
	// 下面看一下直接用函数返回值来引用then函数
	//发现这样使用了以后，第一如果抛出new Error,则程序直接报错，真的就没法往下执行了
	//第二then函数的return值不能传递给下一个then函数，所有then函数都只能使用信号槽传来的参数
	let fs = require('fs')
	function read(url) {
	    return new Promise((resolve, reject) => {
	    fs.readFile(url, 'utf8', (err, data) => {
	      if (err) reject("error--ajja----",err)
	      resolve("信号槽的参数")
	    })
	  })
	}
	let testp = read('./name.txt')
	 testp.then(function(data) {
	  	console.log(data);
	    //throw new Error('then中出现异常,会走下一个then的失败回调,\r\n由于下一个then没有失败回调，就会继续往下找,\r\n如果都没有，就会被catch捕获到') //
	    return "传递给第二个then函数的回调";
	  }) //
	  testp.then(function(data) {
	    console.log(data);
	    return "传递给第三个then函数的回调";
	  },null)
	 testp.then(function(data) {
	    console.log(data)
	  },null)
	 testp.then(null,null)
	 testp.then(null, function(err) {
	    console.log('出错----', err)// then error
	  })
	  testp.catch(function(err) {
	    console.log('error')
	  })
}
test1();
var test2 = function(){
	//下面是使用构造器的方式实现非阻塞功能
	// 用 co 模块自动执行
	let fs = require('fs')
	function read(file) {
	  return new Promise(function(resolve, reject) {
	    fs.readFile(file, 'utf8', function(err, data) {
	      if (err) reject(err)
	      resolve(data)
	    })
	  })
	}

	function* r() {
			  let r1 = yield read('./1.txt');
			  let r2 = yield read(r1);
			  let r3 = yield read(r2);
			  console.log(r1);
			  console.log(r2);
			  console.log(r3);
			  return "我要传递给then函数";
	}
	let co = require('co')
	co(r()).then(function(data) {
	  console.log(data)
	})
	// 2.txt=>3.txt=>4.txt=>我要传递给then函数
}
test2();

var test3 = function(){
	//下面的函数主要实现的是串联的任务
	//一个函数如果加上 async ，那么该函数就会返回一个 Promise
    async function async1() {
	  return "1"
	}
	console.log(async1()) // -> Promise {<resolved>: "1"}


	let fs = require('fs')
	function read(file) {
		  return new Promise(function(resolve, reject) {
		    fs.readFile(file, 'utf8', function(err, data) {
		      if (err) reject(err)
		      resolve(data)
		    })
		  })
	}
	console.log("同步任务中间一句话");
	async function readResult(params) {
	  try {
	    console.log("进入到函数里面了啊");
	    //读出的内容为下一个文件的名字
	    let p1 = await read(params, 'utf8')//await后面跟的是一个Promise实例
	    let p2 = await read(p1, 'utf8')
	    let p3 = await read(p2, 'utf8')
	    console.log('p1', p1)
	    console.log('p2', p2)
	    console.log('p3', p3)
	    return p3
	  } catch (error) {
	    console.log(error)
	  }
	}
	readResult('1.txt').then( // async函数返回的也是个promise
	  data => {
	    console.log(data)
	  },
	  err => console.log(err)
	)
	console.log("同步任务最后一句话");
	// p1 2.txt
	// p2 3.txt
	// p3 4.txt
	// 4.txt

}

var test4 = function(){
	//下面实现并发的任务
	let fs = require('fs')
	function read(file) {
	  return new Promise(function(resolve, reject) {
	    fs.readFile(file, 'utf8', function(err, data) {
	      if (err) reject(err)
	      resolve(data)
	    })
	  })
	}
	function readAll() {
	  read1()
	  read2()//这个函数同步执行
	}
	async function read1() {
	  let r = await read('1.txt','utf8')
	  console.log(r)
	}
	async function read2() {
	  let r = await read('2.txt','utf8')
	  console.log(r)
	}
    readAll() // 2.txt 3.txt
}
var test5 = function(){
	//下面这个是解决地狱回调问题
	var sayhello = function (name) {
				  return new Promise(function (resolve, reject) {
				    setTimeout(function () {
				      console.log(name);
				      resolve();　　//在异步操作执行完后执行 resolve() 函数
				    }, 1000);
				  });
    }
	sayhello("first").then(function () {
	  return sayhello("second");　　//仍然返回一个 Promise 对象
	}).then(function () {
	  return sayhello("third");
	}).then(function () {
	  console.log('end');
	}).catch(function (err) {
	  console.log(err);
	})
	//输出：first  second  third end
}
test5();




}
example_asyn();