同步、异步

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

同步，阻塞

for循环和setTimeout案例

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

promise

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

Promise.all()、Promise.race()

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

promise

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

Promise.all()、Promise.race()

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

promise

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

Promise.all()、Promise.race()

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

promise

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

Promise.all()、Promise.race()

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

promise

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

Promise.all()、Promise.race()

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

promise

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

Promise.all()、Promise.race()

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

同步、异步

同步，阻塞

异步（async），非阻塞

setTimeout()、setInterval()、ajax、for循环

for循环和setTimeout案例

如何输出0-4
    方法一：将setimeout写成函数，传入一个参数k（等于i的值），再输出k
    方法二：使用let定义变量，因为它有块级作用域

var i=0;
for( var i=0;i<5;i  ){
    setTimeout(function(){
        console.log(i);
    }，2000);
}
for循环是同步的，setTimeout()是异步的，最终输出5个5

promise

async fn(onoff) {
    return new Promise((resolve， reject) => {
        if(  onoff  ){
            resolve({  name：‘liu‘  });   // 成功return返回的值，对应then(res)中的res
        }
        else{
            reject(‘‘);  // 失败
        }
    });
}，
//async：定义异步函数      awaiting：同步执行

一个promise可能有三种状态：等待（pending）、已完成（fulfilled）、已拒绝（rejected）

Promise.all()、Promise.race()

Promise.race()意为赛跑的意思，也就是数组中的任务哪个获取的块，就返回哪个，不管结果本身是成功还是失败。
    一般用于和定时器绑定，比如将一个请求和三秒的定时器包装成Promise实例，加入到Promise队列中，请求三秒中还没有回应时，给用户一些提示或相应的操作。

Promise.all()可以将多个实例组装个成一个新实例，
    成功的时候返回一个成功的数组；失败的时候则返回最先被reject失败状态的值。
    适用场景：比如当一个页面需要在很多个模块的数据都返回回来时才正常显示，否则loading。
    promise.all中的子任务是并发执行的，适用于前后没有依赖关系的。

this指向总结

定义函数中this，this指向window。如果是调用函数，指向函数实例

对象（包括json）中的this指向对象实例

异步操作中，this指向最终值

for循环中，this指向最后一个循环值

() => {}本身并没有this，this为父级代码继承过来的，不同情况下调用同一个函数，this指向不同，不一定指向对象实例本身

setTimeout时，function(){}要用_this，不能直接使用this，因为this指向函数本身

this指向实例

var json1={
    fn1：function(){
        console.log(this);   //指向json
    }，
    fn2：function(){
        var i=3;
        function fn3(){
            console.log(this)   //指向window
        };
        return  fn3();
    }
}

json1.fn1();
json1.fn2();

vue中data、computed、methods的调用
    this.age;
    this.newOption
    this.getData();

    this.$parent可以访问父级vue实例（或者组件）
    this.$root可以访问根级vue实例（或者组件）
    this.$el
    this.$data
    this.$router  访问当前的路由

call()、apply()、bind()()三者的区别：改变this指向的三种方法

call()：第一个参数：this指向，如果要传参，后面依次是参数
apply：第一个参数：this指向，第二个参数接受的是一个数组，如果要传参，后面依次放入数组中
bind()：只改变this指向，不会调用函数。如果喜爱那个调用还需要加“()”，传参和跟call相似，只不过后面多了个 ()下面进入实体的案列

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.call(obj，1，2);

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.apply(obj，[1，2]);

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.bind(obj，1，2)();

this指向总结

定义函数中this，this指向window。如果是调用函数，指向函数实例

对象（包括json）中的this指向对象实例

异步操作中，this指向最终值

for循环中，this指向最后一个循环值

() => {}本身并没有this，this为父级代码继承过来的，不同情况下调用同一个函数，this指向不同，不一定指向对象实例本身

setTimeout时，function(){}要用_this，不能直接使用this，因为this指向函数本身

this指向实例

var json1={
    fn1：function(){
        console.log(this);   //指向json
    }，
    fn2：function(){
        var i=3;
        function fn3(){
            console.log(this)   //指向window
        };
        return  fn3();
    }
}

json1.fn1();
json1.fn2();

vue中data、computed、methods的调用
    this.age;
    this.newOption
    this.getData();

    this.$parent可以访问父级vue实例（或者组件）
    this.$root可以访问根级vue实例（或者组件）
    this.$el
    this.$data
    this.$router  访问当前的路由

call()、apply()、bind()()三者的区别：改变this指向的三种方法

call()：第一个参数：this指向，如果要传参，后面依次是参数
apply：第一个参数：this指向，第二个参数接受的是一个数组，如果要传参，后面依次放入数组中
bind()：只改变this指向，不会调用函数。如果喜爱那个调用还需要加“()”，传参和跟call相似，只不过后面多了个 ()下面进入实体的案列

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.bind(obj，1，2)();

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.call(obj，1，2);

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.apply(obj，[1，2]);

this指向总结

定义函数中this，this指向window。如果是调用函数，指向函数实例

对象（包括json）中的this指向对象实例

异步操作中，this指向最终值

for循环中，this指向最后一个循环值

() => {}本身并没有this，this为父级代码继承过来的，不同情况下调用同一个函数，this指向不同，不一定指向对象实例本身

setTimeout时，function(){}要用_this，不能直接使用this，因为this指向函数本身

this指向实例

vue中data、computed、methods的调用
    this.age;
    this.newOption
    this.getData();

    this.$parent可以访问父级vue实例（或者组件）
    this.$root可以访问根级vue实例（或者组件）
    this.$el
    this.$data
    this.$router  访问当前的路由

var json1={
    fn1：function(){
        console.log(this);   //指向json
    }，
    fn2：function(){
        var i=3;
        function fn3(){
            console.log(this)   //指向window
        };
        return  fn3();
    }
}

json1.fn1();
json1.fn2();

call()、apply()、bind()()三者的区别：改变this指向的三种方法

call()：第一个参数：this指向，如果要传参，后面依次是参数
apply：第一个参数：this指向，第二个参数接受的是一个数组，如果要传参，后面依次放入数组中
bind()：只改变this指向，不会调用函数。如果喜爱那个调用还需要加“()”，传参和跟call相似，只不过后面多了个 ()下面进入实体的案列

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.call(obj，1，2);

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.apply(obj，[1，2]);

function fn(x，y){
   console.log(this);
}
var obj = {
   name：“zs“
}
fn(1，2);
fn.bind(obj，1，2)();