Node.js 开始使用承诺

我开始使用承诺，但我并不完全理解，你能帮我吗。我正在验证通过应用程序发送的所有数据，但仍在加载皮带扣，我不明白为什么

这是我的代码（现在我只是验证

POST

方法，但我只是用它进行测试）

var parse=require（'querystring'））
/*
检查最终值的正则表达式
（不接受特殊字符）
*/
var dev=函数（数据）{
var err=''；
如果（data==未定义的| | data==空的| | data.length'）{
//console.log（元素）
验证（元素）
新承诺（功能（解决、拒绝）{
验证（元素、功能（错误、元素）{
如果（错误）{
拒绝（错误）；
}否则{
决心（要素）；
}
});
})
});
}else if（数据类型）=“对象”）{
//转换数组上的对象以将其自身传递给check（递归）
console.log（'是一个对象'）
//console.log（数据）
newdata=Object.values（数据）
新承诺（功能（解决、拒绝）{
验证（newdata，函数（err，newdata）{
如果（错误）{
拒绝（错误）；
}否则{
解析（新数据）；
}
});
})
}else if（数据类型）=“函数”）{
console.log（'是一个函数'）
//验证（数据（））
新承诺（功能（解决、拒绝）{
验证（数据（），函数（错误，管道）{
如果（错误）{
拒绝（错误）；
}否则{
解决（管道）；
}
});
})
}否则{
//console.log（'最后一级数据'）
返回新承诺（功能（解决、拒绝）{
开发（数据、功能（错误、数据）{
如果（错误）{
拒绝（错误）；
}否则{
解析（数据）
}
})
})
//开发人员（数据）
}
//返回err<1？数据：err；
}
/*
检查请求的方法，并在此基础上通过req上的路径进行验证
（请求主体或请求参数请求查询）
*/
var controlencoder=功能（req、res、next）{
//控制台上的打印方法
控制台日志（请求方法）
//检查方法
if（req.method==“PUT”| | req.method==“POST”）{
让body=''；
让管道=''；
请求打开（'data'，chunk=>{
body+=chunk.toString（）；
});
请求开启（'end'，（）=>{
pipe=parse.parse（主体）
console.log（管道）
返回新承诺（功能（解决、拒绝）{
验证（管道、功能（错误）{
如果（错误）{
拒绝（错误）；
}否则{
解决（管道）；
}
});
}).then（next（））
});
}否则{
var管道=所需参数
返回新承诺（功能（解决、拒绝）{
验证（管道、功能（错误）{
如果（错误）{
拒绝（错误）；
}否则{
解决（管道）；
}
});
}).then（next（））
//console.log（管道）
}
//变量管道=[req.body，req.params]
}
module.exports=controlencoder；

我只想与您分享关于承诺的一般想法……在您的示例中，您混合了回调和承诺。因此，您无法看到承诺的所有优点。同时，请看下面的示例

function getCustomer() {
  return Promise((resolve, reject) => {
    // send async request here
    // on response execute resolve(res) or catch error with reject(err)
    // for example
    request
      .get('your_address_here')
      .on('response', (res) => {
        resolve(res)
      })
      .on('error', (err) => {
        reject(err)
      });
  })
}

function getCustomerOrders(customer) {
  return Promise((resolve, reject) => {
    // send async request here
    // on response execute resolve(res) or catch error with reject(err)
    // for example
    request
      .get('your_address_here')
      .on('response', (res) => {
        resolve(res)
      })
      .on('error', (err) => {
        reject(err)
      });
  })
}

//承诺的力量来自于你必须执行功能或解决所有问题（Promise.all）

或者，如果第二个承诺不依赖于第一个承诺的结果，就一起解决它们

Promise.all([getCustomer(), getCustomerOrders()]).then((values) => {
  console.log(values[0]); //is the result of getCustomer()
  console.log(values[1]); //is the result of getCustomerOrders()
});

承诺的主要缺点是

错误处理程序只是一个有人可能认为这是一个优势，但有时您需要不止一个错误处理程序

缺乏条件性。例如，有时你需要有条件性地解决承诺。然后代码就失去了它的美观和可读性

---

在所有调用

verify（）

和

dev（）

的地方，都使用两个参数调用它，但这两个函数都只接受一个参数。因此，它们将忽略传入的函数

现在，承诺的重点是摆脱这些回调，所以我想你已经完成了一半。所以让我们让所有承诺都返回承诺，只接受一个论点

让我们回顾一下代码：

开发人员（数据）

因为verify（）已经返回了一个承诺，所以我们不需要在这里创建任何额外的承诺对象。让我们放弃整个

新承诺（..{…}

东西，只需调用

verify（）

我们需要在此处验证所有元素并确保它们都正常。使用

.map（）

而不是

.forEach（）

可以收集

验证（）的返回值

调用，然后生成一个

Promise

对象数组。然后我们可以使用函数合并

Promise

对象数组。让我们将代码更新为：

现在，数组中的所有项都映射到所有

verify（）

调用的承诺结果数组，并且

Promise.all（）

将它们合并在一起，这样即使一个验证失败，返回的承诺也会失败

    } else if (typeof (data) == 'object') {
        //Convert the object on Array to pass this itself to check (recursively)
        console.log('is an object')
        // console.log(data)
        newdata = Object.values(data)
        new Promise(function (resolve, reject) {
            verify(newdata, function (err, newdata) {
                if (err) {
                    reject(err);
                } else {
                    resolve(newdata);
                }
            });
        })

此处有类似的更改。当verify已返回

承诺时，无需创建新的承诺对象。让我们更新到：

} else if (typeof (data) == 'object') {
    //Convert the object on Array to pass this itself to check (recursively)
    console.log('is an object');
    // console.log(data);
    newdata = Object.values(data);
    return verify(newdata);

此处的相同更改：

    } else if (typeof (data) == 'function') {
        console.log('is a function')
        // verify(data())
        new Promise(function (resolve, reject) {
            verify(data(), function (err, pipe) {
                if (err) {
                    reject(err);
                } else {
                    resolve(pipe);
                }
            });
        })

更改为：

    } else if (typeof (data) == 'function') {
        console.log('is a function');
        return verify(data());

最后：

    } else {
        // console.log('last level of data')
        return new Promise(function(resolve, reject){
            dev(data, function(err, data){
                if(err){
                    reject(err);
                } else {
                    resolve(data)
                }
            })
        })
        // dev(data)
    }
    // return err < 1 ? data : err;
}

控制编码器（req、res、next） 将此更改为：

var controlencoder = function (req, res, next) {

    //Print method on console 
    console.log(req.method)

    //check the method
    if (req.method == 'PUT' || req.method == 'POST') {
        let body = '';
        let pipe = '';
        req.on('data', chunk => {
            body += chunk.toString();
        });
        req.on('end', () => {
            pipe = parse.parse(body)
            console.log(pipe)
            return verify(pipe).then(next());
        });

这是：

    } else {
        var pipe = req.params
        return new Promise(function (resolve, reject) {
            verify(pipe, function (err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(pipe);
                }
            });
        }).then(next())
        // console.log(pipe)
    }
    // var pipe = [req.body, req.params]
}

……为此：

    } else {
        var pipe = req.params

        return verify(pipe).then(next());
        // console.log(pipe)
    }
    // var pipe = [req.body, req.params]
}

希望它能起作用：）

你有一个合作伙伴

    } else {
        // console.log('last level of data')
        return new Promise(function(resolve, reject){
            dev(data, function(err, data){
                if(err){
                    reject(err);
                } else {
                    resolve(data)
                }
            })
        })
        // dev(data)
    }
    // return err < 1 ? data : err;
}

    } else {
        // console.log('last level of data')
        return dev(data);
    }
    // return err < 1 ? data : err;
}

var controlencoder = function (req, res, next) {

    //Print method on console 
    console.log(req.method)

    //check the method
    if (req.method == 'PUT' || req.method == 'POST') {
        let body = '';
        let pipe = '';
        req.on('data', chunk => {
            body += chunk.toString();
        });
        req.on('end', () => {
            pipe = parse.parse(body)
            console.log(pipe)
            return new Promise(function (resolve, reject) {
                verify(pipe, function (err) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(pipe);
                    }
                });
            }).then(next())

        });

var controlencoder = function (req, res, next) {

    //Print method on console 
    console.log(req.method)

    //check the method
    if (req.method == 'PUT' || req.method == 'POST') {
        let body = '';
        let pipe = '';
        req.on('data', chunk => {
            body += chunk.toString();
        });
        req.on('end', () => {
            pipe = parse.parse(body)
            console.log(pipe)
            return verify(pipe).then(next());
        });

    } else {
        var pipe = req.params
        return new Promise(function (resolve, reject) {
            verify(pipe, function (err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(pipe);
                }
            });
        }).then(next())
        // console.log(pipe)
    }
    // var pipe = [req.body, req.params]
}

    } else {
        var pipe = req.params

        return verify(pipe).then(next());
        // console.log(pipe)
    }
    // var pipe = [req.body, req.params]
}