The World of HarmonyOS Programming: Advantages of Asynchronous Programming and the Application of Promise

This article aims to deeply explore the technical details of the Huawei HarmonyOS Next system (up to API 12 as of now), and is summarized based on actual development practices. It mainly serves as a vehicle for technical sharing and communication. Mistakes and omissions are inevitable. Colleagues are welcome to put forward valuable opinions and questions so that we can make progress together. This article is original content, and any form of reprint must indicate the source and the original author.
Asynchronous programming refers to writing code that can execute multiple tasks simultaneously without blocking the main thread. Asynchronous programming can effectively improve the response speed and efficiency of an application and prevent time-consuming tasks from blocking the main thread, which may cause the application to freeze.
Promise is a common pattern used in JavaScript to handle asynchronous operations. It allows developers to write asynchronous code in a more concise manner.

Definition and Usage of Promise

Promise Definition:
A Promise is an object that represents the result of an asynchronous operation. A Promise has three states: pending (in progress), fulfilled (completed), and rejected (rejected).
Promise Usage:

• Creating a Promise:

const promise = new Promise((resolve, reject) => {
    // Code of the asynchronous operation
});

• Using the then Method:

promose.then((result) => {
    // Callback for handling success
}).catch((error) => {
    // Callback for handling failure
});

• Using async/await:

async function myAsyncFunction() {
    const result = await promise;
    // Handling the result
}

Asynchronous Processing with async/await in ArkTS

ArkTS supports using the async/await syntax for asynchronous processing. async/await is a more concise way of asynchronous programming, making asynchronous code look more like synchronous code.
Example:

async function myAsyncFunction() {
    const result = await new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Hello, world!');
        }, 3000);
    });
    console.log(result);
}

Precautions for async/await:

• An async function must return a Promise object.
• The await keyword can only be used inside an async function. ### Error Handling and Performance Optimization Error Handling:
• Use the catch method of Promise to capture errors.
• Use try/catch blocks to capture exceptions in asynchronous operations. Performance Optimization:
• Avoid performing time-consuming operations in asynchronous operations.
• Use the Promise.all method to execute multiple asynchronous operations in parallel. ### Code Example of Parallel Execution and Error Capture of Multiple Promises The following is a simple example demonstrating how to use Promise and async/await in HarmonyOS to execute multiple asynchronous operations in parallel and capture errors:

import { taskpool } from '@kit.ArkTS';
@Concurrent
function add(num1: number, num2: number): number {
    return num1 + num2;
}
@Concurrent
function subtract(num1: number, num2: number): number {
    return num1 - num2;
}
async function concurrentFunc() {
    try {
        const task1 = new taskpool.Task(add, 1, 2);
        const task2 = new taskpool.Task(subtract, 3, 4);
        const results = await Promise.all([taskpool.execute(task1), taskpool.execute(task2)]);
        console.log(results); // Print the result array
    } catch (e) {
        console.error("Error: " + e);
    }
}
@Entry
@Component
struct Index {
    @State message: string = 'Hello World';
    build() {
        Row() {
            Column() {
                Text(this.message)
                   .fontSize(50)
                   .fontWeight(FontWeight.Bold)
                   .onClick(() => {
                        concurrentFunc();
                    )
                   .width('100%');
            }
        }
       .height('100%');
    }
}

This code defines a component named Index and displays a text message "Hello World" in the component. Clicking the button will execute the concurrentFunc function, which creates two concurrent tasks and executes them in parallel. After the tasks are completed, the result array will be printed on the console. If an error occurs, the error will be captured and the error message will be printed.

Summary

Through the above introduction, you can understand the two ways of asynchronous programming in the HarmonyOS system: Promise and async/await. Using asynchronous programming can effectively improve the response speed and efficiency of an application and prevent time-consuming tasks from blocking the main thread. Hope this article can help you master the asynchronous programming techniques in the HarmonyOS system and develop better HarmonyOS applications.