学习日志

复杂查询

聚合查询/分组查询

聚合函数

1.获取数量 SELECT COUNT(*) from emp;

2.求总和 SELECT sum(sal) from emp;

3.求平均数 SELECT AVG(sal) from emp;

4.求最大、最小值 SELECT max(sal) as 最高工资,min(sal) as 最低工资 from emp where deptno=10;

5.获取当前数据中的年份数值 SELECT year(hirdate) from emp where deptno=10;

6.获取当前数据中的月份数值 SELECT DISTINCT month(hirdate) from emp where deptno=10;

分组查询

group by

子查询

子查询就是把一个sql语句的查询结果作为另一个sql语句的查询条件

多表查询(跨表查询)

内连接

inner join...on...

左外连接

left outer join .....on.... 查询左侧表中的所有数据

右外连接

right outer join...on 查询右侧表中的所有数据

全连接

union 合并相同的项

union all 不合并相同的项

promise

Promise是一个构造函数，它跟JS中的Date、Array等构造函数类似，都是使用new操作符实例化之后就可以通过传参和调用方法的形式来完成某些特定的功能。Promise是专门用来实现多个异步函数，必须先后顺序执行的技术

使用promise

避免callback hell（回调地狱）

什么时候使用Promise？

当有要求，下一个函数必须在前一个函数执行后，才能开始执行时，就使用promise

使用Promise

第一步：将异步函数使用new Promise包裹，并返回该new Promise，同时与下一项任务相连

return new Promise((resolve, reject)=>{
// 如果正确，就继续调用resolve()
// 否则，就调用reject("错误提示")
})

第二步：在new Promise() 内的异步任务内部，设置前一项任务需要决定何时调用的函数，只要前一项任务内部调用了这个函数，就会通知下一项任务开始执行

Promise 实例具有then方法，then方法的第一个参数是resolve（成功）的回调，第二个参数（可选）是reject（失败）的回调

        var promise=new Promise(function(resolve,reject){
            setTimeout(function(){
                if(false){
                    resolve("我是对的！")
                }else{
                    reject("我是错的！")
                }
            },1000)
        })
        promise.then(function(data){
            console.log("ok!")
            console.log(data)
        },function(err){
            console.log("No ok!")
            console.log(err)
        })

第三步：调用前一项任务，然后调用 .then() 连接下一项任务

多个函数需要连续调用，每个函数，都要返回Promise对象，才能连续用then调用

实例：

        function one(){
            return new Promise( 
            function(next){
                console.log("开始比赛")
                console.log("one start!")
                setTimeout(function(){
                    next()
                },2000)
            }
            )
        }
        function two(){
            return new Promise(
            function(next){
                console.log("one end")
                console.log("two start!")
                setTimeout(function(){
                    next()
               },2000)
            }   
            )
        }
        function three(){
            return new Promise(
                function three(){
                console.log("two end")
                console.log("three start!")
                setTimeout(function(){
                     console.log("结束比赛")
                },2000)
            }   
            )
        }
        one().then(two).then(three);

前后两个异步任务之间传参

        var one= new Promise((resolve,reject)=>{
            resolve()
        })
        one.then(function(){
            fn()
        })
        function fn(){
            console.log("hello,xiaoming")
        }

如果需要等待多个函数执行完，才执行

语法：

Promise.all

Promise.all([
函数1(),
函数2(),
... ... ,
]).then(end)

        var p1=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口1")
            },1000)
        })
        var p2=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口2")
            },2000)
        })
        var p3=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口3")
            },3000)
        })
        Promise.all([p1,p2,p3]).then((data)=>{
            console.log(data)//返回等待最慢的全部
        })

Promise.race方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。使用race方法时如果有一个率先成功，那么就立即返回

        var p1=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口1")
            },1000)
        })
        var p2=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口2")
            },2000)
        })
        var p3=new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve("接口3")
            },3000)
        })
        Promise.race([p1,p2,p3]).then((data)=>{
            console.log(data)//返回最快的一个
        })

promise语法

Promise的参数中是一个函数

1、函数封装了原函数正常的逻辑

2、函数由两个回调函数参数

resolve 在正常执行后，调用 .then()

reject 在出错时，调用 .catch()

Promise的三个状态

三个状态: pending(挂起/等待)、fulfilled(成功)、rejected(失败)

学习心得

今天的promise有点绕，又是半懂不懂的状态。需要慢慢理解。