비동기/대기 구문에서 거부하려면 어떻게 해야 합니까?

비동기/대기 구문에서 거부하려면 어떻게 해야 합니까?

async/await능하하??? ???

예: 원래:

foo(id: string): Promise<A> {
  return new Promise((resolve, reject) => {
    someAsyncPromise().then((value)=>resolve(200)).catch((err)=>reject(400))
  });
}

하면 ★★★★★★★★★★★★★★★★.async/await:

async foo(id: string): Promise<A> {
  try{
    await someAsyncPromise();
    return 200;
  } catch(error) {//here goes if someAsyncPromise() rejected}
    return 400; //this will result in a resolved promise.
  });
}

그렇다면, 어떻게 이 약속을 제대로 거절할 수 있을까요?

것이 throw한 사람Error가 with wrapping wrapping wrapping wrapping wrapping wrapping wrapping wrapping with with wrapping wrapping치 with with with with with wrapping wrapping wrapping wrapping 。Error값을 래핑합니다.

} catch (error) {
    throw new Error(400);
}

'하다'라고 해도 요.throw스택 트레이스 정보는 없습니다.

} catch (error) {
    throw 400;
}

""를 반환합니다.Error가치를 포장하지만, 관용적이지는 않습니다.

} catch (error) {
    return Promise.reject(new Error(400));
}

그냥 (혹은그))return Promise.reject(400);하지만 컨텍스트 정보는 없습니다.)

같은 경우에는 TypeScript ★★★★★★★★★★★★★★★★★」foo은 의음음 음음 음음 음 ' ' ' ' 。Promise<A> 쓸 수 , 하다, 하다, 하다, 하다.

return Promise.reject<A>(400 /*or Error*/ );

①의 async/await마지막은 의미상 불일치일 수도 있지만 효과가 있습니다.

Error 하면 '어느 에도 잘 어울린다', ' 것에도 잘 ', '어느 것에도 잘 어울린다', '어느 것에도 잘 어울린다', '어느 것에도 잘 어울린다', '어느 것에도 잘 어울린다', '어느 것에도 잘 어울린다foo의 결과( 과 ' ' await★★★★

try {
    await foo();
} catch (error) {
    // Here, `error` would be an `Error` (with stack trace, etc.).
    // Whereas if you used `throw 400`, it would just be `400`.
}

''로 묶을 수 해야 할 입니다.catch()이치이는 후드 아래에서 약속이 반환되기 때문입니다.

await foo().catch(error => console.log(error));

''를 수 요.try/catch구문을 사용할 수 있습니다.

약속을 받아 오류가 없으면 데이터 배열을 반환하고 오류가 있으면 오류를 반환하는 래퍼 함수를 만들 수 있습니다.

function safePromise(promise) {
  return promise.then(data => [ data ]).catch(error => [ null, error ]);
}

ES7 및 비동기 기능에서는 다음과 같이 사용합니다.

async function checkItem() {
  const [ item, error ] = await safePromise(getItem(id));
  if (error) { return null; } // handle error and return
  return item; // no error so safe to use item
}

비동기 함수를 쓰는 보다 좋은 방법은 보류 중인 Promise를 처음부터 반환한 후 약속 콜백 내에서 거부와 해결을 모두 처리하는 것입니다.오류 발생 시 거부된 약속을 그냥 뱉는 것이 아닙니다.예:

async foo(id: string): Promise<A> {
    return new Promise(function(resolve, reject) {
        // execute some code here
        if (success) { // let's say this is a boolean value from line above
            return resolve(success);
        } else {
            return reject(error); // this can be anything, preferably an Error object to catch the stacktrace from this function
        }
    });
}

그리고 돌아온 약속에 따라 방법을 연결하기만 하면 됩니다.

async function bar () {
    try {
        var result = await foo("someID")
        // use the result here
    } catch (error) {
        // handle error here
    }
}

bar()

출처 - 이 튜토리얼:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise

이건 @T.J. Crowder의 답변에 대한 답이 아닙니다.코멘트에 대한 답변일 뿐입니다.실제로 예외가 거부로 변환될 경우, 에러인지 아닌지는 잘 모르겠습니다.에러만 던지는 이유는 해당되지 않을 것입니다.

가 「」를 사용하고 .async/awaitError400:

try {
  await foo('a');
}
catch (e) {
  // you would still want `e` to be an `Error` instead of `400`
}

여러 번 시도 캐치 블록을 사용하지 않고 새로운 접근 방식으로 적절히 거부물을 처리할 것을 제안합니다.

import to from './to';

async foo(id: string): Promise<A> {
    let err, result;
    [err, result] = await to(someAsyncPromise()); // notice the to() here
    if (err) {
        return 400;
    }
    return 200;
}

to.ts 함수를 Import해야 하는 위치:

export default function to(promise: Promise<any>): Promise<any> {
    return promise.then(data => {
        return [null, data];
    }).catch(err => [err]);
}

크레딧은 다음 링크에서 Dima Grossman으로 이동합니다.

이것은 오래된 질문인 것은 알지만, 우연히 알게 된 것입니다.또, 예상되는 케이스에 대처하기 위해서 예외 처리를 사용하지 말라는, 자주 반복되고 있는 조언(적어도 많은 경우)에 어긋나는 에러와 거부 사이에 혼재하고 있는 것 같습니다.설명: 비동기 방식이 사용자 인증을 시도하고 있는데 인증이 실패했을 경우, 이는 거부(예상되는2가지 케이스 중 하나)이지 오류(인증 API를 사용할 수 없는 경우 등)가 아닙니다.

단순히 헤어스타일을 분할하는 것이 아님을 확인하기 위해 다음 코드를 사용하여 세 가지 접근법에 대한 성능 테스트를 수행했습니다.

const iterations = 100000;

function getSwitch() {
  return Math.round(Math.random()) === 1;
}

function doSomething(value) {
  return 'something done to ' + value.toString();
}

let processWithThrow = function () {
  if (getSwitch()) {
    throw new Error('foo');
  }
};

let processWithReturn = function () {
  if (getSwitch()) {
    return new Error('bar');
  } else {
    return {}
  }
};

let processWithCustomObject = function () {
  if (getSwitch()) {
    return {type: 'rejection', message: 'quux'};
  } else {
    return {type: 'usable response', value: 'fnord'};
  }
};

function testTryCatch(limit) {
  for (let i = 0; i < limit; i++) {
    try {
      processWithThrow();
    } catch (e) {
      const dummyValue = doSomething(e);
    }
  }
}

function testReturnError(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithReturn();
    if (returnValue instanceof Error) {
      const dummyValue = doSomething(returnValue);
    }
  }
}

function testCustomObject(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithCustomObject();
    if (returnValue.type === 'rejection') {
      const dummyValue = doSomething(returnValue);
    }
  }
}

let start, end;
start = new Date();
testTryCatch(iterations);
end = new Date();
const interval_1 = end - start;
start = new Date();
testReturnError(iterations);
end = new Date();
const interval_2 = end - start;
start = new Date();
testCustomObject(iterations);
end = new Date();
const interval_3 = end - start;

console.log(`with try/catch: ${interval_1}ms; with returned Error: ${interval_2}ms; with custom object: ${interval_3}ms`);

Javascript 인터프리터에 대한 나의 불확실성 때문에 그 안에 있는 것들 중 일부는 포함되어 있다. 예를 들어, 나는 한 번에 한 마리씩 토끼굴에 들어가는 것을 좋아한다.doSomething기능 및 그 반환을 할당하다dummyValue조건부 블록이 최적화되지 않도록 해야 합니다.

결과는 다음과 같습니다.

with try/catch: 507ms; with returned Error: 260ms; with custom object: 5ms

작은 최적화를 찾아내는 데 애쓸 가치가 없는 경우가 많다는 것을 알지만, 대규모 시스템에서는 이러한 것들이 누적적으로 큰 차이를 만들 수 있습니다. 이는 매우 엄연한 비교입니다.

즉, 비동기 함수 내에서 예측 불가능한 오류를 처리해야 하는 경우 허용되는 답변의 접근법은 타당하다고 생각합니다만, 거절이 단순히 "플랜 B(또는 C, 또는 D…)"를 의미하는 경우라면, 저는 커스텀 응답 개체를 사용하여 거절하는 것이 좋다고 생각합니다.

언급URL : https://stackoverflow.com/questions/42453683/how-to-reject-in-async-await-syntax