前端学习(三十六)promise(笔记)

一个页面:  头部、用户信息、新闻列表

jquery ajax:  
1、
$.ajax({
    url:'',
    dataType:'json',

}).then(res=>{
    //res :  成功后的返回
},err=>{
    //err: 失败的对象
});

2、
let url = '';
$.ajax({
    url,
    data:
    dataType:
    ...
    success:function(res){
        //res 成功后的数据
    },
    error(err){
        //err 失败的对象信息
    }
});

实现 :  头部,用户,新闻  三块功能
方法一:
    $.ajax({url:'头部数据接口地址',success(res){用res来渲染头部页面}});
    $.ajax({url:'用户数据接口地址',success(res){用res来渲染用户部分页面}});
    $.ajax({url:'新闻数据接口地址',success(res){用res来渲染新闻部分页面}});
要求:等三部分数据都返回后,做点事情,打印三次请求的结果。
    $.ajax({
        url:'头部',
        success(res){
            //res
            $.ajax({
                url:'用户',
                success(res){
                    //头部和用户都成功
                    $.ajax({
                        url:'新闻'
                        success(){
                            //三次都成功

                        }
                    });
                }
            });
        }
    });

==========================
以上,程序员 回调函数  —— 恶梦

直到 2015 年,ES6 出来了 —— Promise

Promise: —— 承诺、保证
    多个异步请求全部完成后,要做的事情 —— 通过 Promise 来解决。

一、基本用法
    let p1 = new Promise(function(resolve,reject){
        $.ajax({
            url:'',
            data:
            dataType:
            ...
            success(res){
                以前在这里直接处理res
                现在不直接处理,要如下
                resolve(res);
            },
            error(err){
                reject(err);
            }
        });
    });

    p1.then(res=>{
        //在这里处理成功的结果
    },err=>{});

二、真正用法
    Promise.all([Promise对象1,Promise对象2,...]).then(function(arr){
        //说明,所有的请求都成功了

        //arr[0] ——> 请求1的结果
        //arr[1] ——> 请求2的结果
        ...
    },function(err){
        //只要有一个失败
    });
三、封装
    function creactPromise(url){
        return new Promise(function(resolve,reject){
            $.ajax....
        });
    }
四、jquery 的 ajax

        let r =$.ajax({
        .....
    });
    // r ——> 就是一个 Promise对象

    $.ajax({}).then(res=>{},err=>{});

    Promse.all([
        $.ajax({}),
        $.ajax({}),
        $.ajax({})
        ...
    ]).then(arr=>{
        //arr  对应多个请求的结果
    },err=>{});

五、Promise.race
    Promise.race([p1,p2....]).then(res=>{
        //成功
        res —— >  最先返回结果的那个请求
    },err=>{});

    //应用,对于同一个数据,多个数据接口提供请求,可以多个接口同时访问,哪个快就用哪个结果—— 保证用户能使用最快的数据

==========================

要求:当头部请求完成后,做点事,再去请求用户,用户请求完成后,做点事,再去请求新闻 ....
    
Generator: 生成器 —— 函数
    1. 把一个函数切分成若干个小函数
    2. 把异步请求同步化
    3. 可以暂停的函数

语法:
    function* show(){
        alert(1);
        alert(2);
    }

    let ge = show(); // ge --  Generator 对象
    ge.next(); //下一个 , 触发 Generator 函数的执行
    
暂停:  在函数里面 , 使用   
    yield —— 只用于 Generator 函数里。

generator:
    1) function*
    2) 返回 Generator 对象
    3) 可以暂停
        yield
    4) obj.next()
yield:
    1)暂停函数
    2)可以返回中间结果
    3)可以接收中间参数

* yield 相当于把函数切分为若干段 ,yield 属于下半段
==========================
返回值:
    
    obj.next(); —— 返回值:
        {
            done: false
            value:  yield 返回结果
        }

* yield 返回值 属于上一部分
* 每一个next 对应的是切分后的一部分(不是对应一个 yield)

* 中间过程返回值 通过  yield ,最后的结果返回,通过 return

中间过程:  done : false
整体结束:  done: true

==========================
回顾:
    function* show(){
        alert('a');
        yield x;
        alert('b');
        yield y;

        return z;
    }
    //以上函数被分为3块,
        第一块:  alert('a');   x
        第二块:  yield     alert('b');  y
        第三块:  yield  return z;
    //以下的next 对应的是每一块
    let obj = show();
    let r1 = obj.next(); //r1:{value:x,done:false}
    let r2 = obj.next(); //r2:{value:y,done:false}
    let r3 = obj.next(); //r3:{value:z,done:true}

==========================
接收中间参数:
    obj.next(传入的参数);

使用 Generator 的意义:
    1、什么时候停止,停止多久,什么时候再开始,  是可以通过程序控制;
    2、在函数每次停止和下一次开始之间,可以做一些其它的操作;

==========================
题:
    function* show(){
        let a = 12;
        let b = yield 5;
        let c = 99;
        let d = yield;
        alert(a+b-c*d);
    }
    要求:把 5 接出来,乘以2,再传回去,程序如何写,结果是什么?

==========================
回顾场景:
    三次请求:  头,用户,新闻 
    要求:  头
            用户
                新闻
    实现:
        一:回调嵌套
        二:Generator
            function* show(){
                yield $.ajax({请求头部});

                yield $.ajax({请求用户信息});
                yield $.ajax({请求新闻信息});
            }
            let obj = show();
            let r1 = obj.next(); //r1 : 头部的返回结果
            ....
            obj.next();
            ....
            obj.next();
            ..
            obj.next();
            

==========================
ES6总结:
    let
    const
    块作用域
    ()=>
        1、 this 指向父级作用域
        2、arguments 不能用
        3、简写
            如果 参数只有一个,可以省略小括号
            如果 函数体只有一句话,并且是 return, 可以省略 大括号 和 return
    ...
        应用:
            1、扩展函数参数
                function show(a,b,...args){}
            2、复制数组
                let arr2 = [...arr1];
                方法:
                    a) 循环复制
                    b) ...
                    c) let arr2 = Array.from(arr1)

    Map
        let map = new Map();
        map.set('key',value);
        map.get('key');
        map.delete('key');
    for..of:
        for(let item of map)
        for(let item of map.entries())
        for(let key of map.keys())
        for(let val of map.values())
    模块化:
        定义/导出:
            let a = 12;
            let b = '';
            export default {
                a,b
            }
        使用:
            import modA from 'a.js'
    JSON简写:
        1、 变量
            let a= 12;
            {
                //a:a
                a
            }
        2、函数:
            {
                show:function(){},
                show2(){
                    
                }
            }
    解构赋值:
        左边和右边结构一致;
    数组方法:
        let arr2 = arr.map(item=>{
            return item + 1;
        });

        arr.forEach((val,index)=>{
            
        });

        let arr2 = arr.filter(item=>{
            return item>10;
        });

        arr.reduce((pre,cur,index,self)=>{
            return x; // x 做为下一次的前一个
        });
        arr.reduce((pre,cur,index,self)=>{},pre2);
        应用:
            1)数组求和
            2)二维数组扁平化
    面向对象:
        class Person{
            constructor(x){
                this.x = x;
            }
            show(){}
            show2(){}
        }
        class Worker extends Person{
            construnctor(){
                super();
                this.x = x;
                ....
            }
            show(){}
        }
    
    ``    字符串板
        `fdsafd${x}safdas`
    
    startsWith
    endsWith

    Promise:
    Generator:
==========================
Bootstrap:
    前端布局的框架。主要应用于响应式的页面。
    官网:http://www.bootcss.com/

组成:
    基本样式
    组件
    Javascript 插件

* 强依赖于 jquery

原则:
1.引入库文件
    bootstrap.css

    jquery.js
    bootstrap.js

下载:
    npm:
        npm i bootstrap
            不会下载 jquery
        npm i jquery
    bower:(安装 git )
        bower i bootstrap

2.基本结构
    div.container   —— 容器
        div.row —— 行
            div.col-
            内容
        
3.栅格
    整个页面分成12列
        
4. 列偏移
    col-sm-offset-4
5.列排序
    col-sm-push-*
    col-sm-pull-*
6.响应式工具
    .visible-sm
    .hidden-sm

------------------------------
基本样式:
    浮动:
        pull-left
        pull-right
    清除浮动:
        .clearfix
    文本居中:
        text-center
    文本颜色:
        text-primary
        text-danger
    按钮:
        基本样式:  btn
        不同样式:
            btn-primary
            btn-danger
            ...
------------------------------

转载于:https://www.cnblogs.com/wxiaoyu/p/9579514.html

你可能感兴趣的:(前端学习(三十六)promise(笔记))