1# Asynchronous Concurrency Overview (Promise and Async/Await) 2 3 4Promise and async/await are standard JavaScript syntax that provides asynchronous concurrency. Asynchronous code ensures that actions initiated now finish later. It allows the execution of only one segment of code at a time and is therefore applicable to the development of a [single I/O task](single-io-development.md), for example, a network request or a file read/write operation. 5 6 7Promise and async/await allow an application to perform other operations without waiting for the completion of certain actions. 8 9 10## Promise 11 12Promise is an object used to process asynchronous operations. It converts asynchronous operations into a style similar to synchronous operations for easier code writing and maintenance. Promise provides a state mechanism to manage different phases of asynchronous operations. It also provides methods to register callback functions to handle the success or failure of these operations. 13 14Promise has three states: pending, fulfilled, and rejected. A Promise object is in the pending state after being created and changes to the fulfilled or rejected state when the asynchronous operation is complete. 15 16The most common usage for Promise is to instantiate a Promise object through a constructor and pass in a function (usually named **executor**) with two parameters. The two parameters are **resolve** and **reject**, which represent the callback functions that should be called when the asynchronous operation succeeds and fails, respectively. The code snippet below creates a Promise object and simulates an asynchronous operation: 17 18 19```ts 20const promise: Promise<number> = new Promise((resolve: Function, reject: Function) => { 21setTimeout(() => { 22 const randomNumber: number = Math.random(); 23 if (randomNumber > 0.5) { 24 resolve(randomNumber); 25 } else { 26 reject(new Error('Random number is too small')); 27 } 28}, 1000); 29}) 30``` 31 32In the preceding code, the **setTimeout** function simulates an asynchronous operation that generates a random number one second later. If the random number is greater than 0.5, the **resolve** callback function is executed and the random number is passed in as a parameter. Otherwise, the **reject** callback function is executed and an error object is passed in. 33 34After the Promise object is created, you can use the **then** and **catch** methods to register the callback functions for the fulfilled and rejected states. The **then** method can receive two parameters: one for processing the fulfilled state and the other for processing the rejected state. If only one parameter is passed in, the callback function is executed as long as the state changes. The **catch** method receives a callback function to process the failure result, that is, capture the exception thrown when the Promise state changes to **rejected** or the operation fails. The code snippet below shows the use of the **then** and **catch** methods: 35 36 37```ts 38import { BusinessError } from '@ohos.base'; 39 40promise.then((result: number) => { 41 console.info(`Random number is ${result}`); 42}).catch((error: BusinessError) => { 43 console.error(error.message); 44}); 45``` 46 47In the preceding code, the callback function of the **then** method receives the success result of the Promise object as a parameter and outputs it to the console. If the Promise object enters the rejected state, the callback function of the **catch** method receives the error object as a parameter and outputs it to the console. 48 49 50## Async/Await 51 52Async/Await is a Promise syntax sugar used to process asynchronous operations, making it easier to read and write asynchronous code. The async keyword is used to declare an asynchronous function, and the await keyword is used to wait for Promise parsing (fulfilled or rejected). In this way, the asynchronous operation logic is coded as a synchronous operation. 53 54The **async** function returns a Promise object to represent an asynchronous operation. Inside the **async** function, you can use the await keyword to wait for the parsing of the Promise object and return its parsed value. If an **async** function throws an exception, the Promise object returned by the function is rejected, and the exception information is passed in to the **onRejected()** method of the Promise object. 55 56The code snippet below uses async/await to simulate an asynchronous operation that returns a string three seconds later. 57 58 59```ts 60async function myAsyncFunction(): Promise<void> { 61 const result: string = await new Promise((resolve: Function) => { 62 setTimeout(() => { 63 resolve('Hello, world!'); 64 }, 3000); 65 }); 66 console.info(result); // Output: Hello, world! 67} 68 69myAsyncFunction(); 70``` 71 72In the preceding code, the await keyword is used to wait for the parsing of the Promise object and store its parsed value in the **result** variable. 73 74Note that the entire operation must be packaged in the **async** function because the code needs to wait for the asynchronous operation to complete. In addition to **await**, you can use the try/catch block to capture exceptions in asynchronous operations. 75 76 77```ts 78async function myAsyncFunction(): Promise<void> { 79 try { 80 const result: string = await new Promise((resolve: Function) => { 81 resolve('Hello, world!'); 82 }); 83 } catch (e) { 84 console.error(`Get exception: ${e}`); 85 } 86} 87 88myAsyncFunction(); 89``` 90