有没有办法知道一个函数是否在一个 Promise 中被调用？

Question

假设我有这段代码，并且我在一个包中编写了一个名为handleSmell() 的函数，其他人可以使用：

const streamSomeUrl = (url='https://salmon.net/river') => {

  console.info('...connecting...');
  const { data, headers } = await axios({
    url,
    method: 'GET',
    responseType: 'stream',
  });
  return new Promise((resolve, reject) => {
    data.on('data', (chunk) => {
       if(smellsFunny(chunk)) {
         // promise aware function
         handleSmell(chunk) // <--- behaves differently inside a promise. 
         // E.g. prints  "Smell inside a promise" 
       }
    });
  })
}

有没有办法让函数handleSmell 判断它是否在承诺中？我的意思是，它的行为与这里不同：

readFile('/etc/fish', (err, data) => {
  if(smellsFunny(data)) {
     // promise aware function
     handleSmell(data) // <--- behaves differently inside a promise.
     // E.g. prints  "Smell *not* inside a promise" 
     ...
     }
});

我试图弄清楚是否可以在不接受拒绝/解决回调的情况下处理 handleSmell 函数（然后如果丢失，知道我没有承诺）。

据我所知，我不能使用传递不同数据的事实，chunk 和 data 都是字符串/缓冲区？

这有可能吗？我受到这个question 的激励，主要来自一个答案：

任何时候你在一个 promise 回调中，你都可以使用 throw。但是，如果您在任何其他异步回调中，则必须使用拒绝。

new Promise(function() {
  setTimeout(function() {
    throw 'or nah';
    // return Promise.reject('or nah'); also won't work
  }, 1000);
}).catch(function(e) {
  console.log(e); // doesn't happen
});

---

我的偏好是抛出，但我想知道如果我调用拒绝回调（即来自父拒绝）它会起作用：

function handleSmell(suspectData, reject=False) {
  const inPromise = //?????
  if (inPromise && reject) {
    return reject('SMELLY REJECT!')
  } else if (inPromise) {
    throw new Error('SMELLY THROWN!')
  } else { console.error('SMELLY NON-PROMISE!') }
}
// Both these should work
new Promise(function() {
  setTimeout(function() {
    handleSmell('cheese');
}).catch(function(e) {
  console.log(e); // doesn't try to throw
});

new Promise(function(resolve, reject) {
  setTimeout(function() {
    handleSmell('cheese', reject);
  }, 1000);
}).catch(function(e) {
  console.log(e); // this works
});

另一种选择是承诺不承诺（根据链接）。

但如果可能的话，我可以避免吗？

Answer 1

这可能吗？

不，你不能那样做，不，你不应该那样做。函数的作用应该取决于它的参数，而不是从哪里调用它。

我受到这个问题的启发，主要来自答案：

任何时候你在一个 promise 回调中，你都可以使用 throw。 但是，如果您在任何其他异步回调中，则必须使用拒绝。

嗯，handleSmell 没有在回调中定义，它是一个独立的同步函数，所以它应该简单地抛出一个异常。

调用此类函数的正确方法是从 try 块内或从承诺 (then) 回调内。

new Promise((resolve, reject) => {
  setTimeout(() => {
    try {
      resolve(handleSmell('cheese'));
    } catch(err) {
      reject(err);
    }
  });
}).then(console.log, console.error);

new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('cheese');
  }, 1000);
}).then(handleSmell).then(console.log, console.error);
//      ^^^^^^^^^^^
// or .then(res => handleSmell(res)) for verbosity