The World of HarmonyOS Programming: Behavioral Differences between ArkTS Containers and Native Containers

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进步 together. This article is original content, and any form of reprint must indicate the source and the original author.
ArkTS provides a set of container types, including Array, Map, and Set, etc., which are used to store and manage data. There are some differences in behavior between ArkTS containers and JavaScript native containers, which developers need to pay attention to.

ArkTS Container Types such as Array, Map, and Set

• Array: The Array type in ArkTS is similar to the Array type in JavaScript, but there are some differences. For example, it is not allowed to add, delete, or modify elements during traversal or access.
• Map: The Map type in ArkTS is similar to the Map type in JavaScript, but there are some differences. For example, the constructor must be provided with a constructor of an initial value, and the use of computed property names is not supported.
• Set: The Set type in ArkTS is similar to the Set type in JavaScript, but there are some differences. For example, it is not allowed to add, delete, or modify elements during traversal or access, and the use of computed property names is not allowed in Sendable classes and interfaces. ### Differences between Native APIs and ArkTS APIs | Native API | ArkTS API | |---|---| | Array.from | collections.Array.from | | Array.slice | collections.Array.slice | | Map.entries | collections.Map.entries | | Map.keys | collections.Map.keys | | Map.values | collections.Map.values | | Set.add | collections.Set.add | | Set.delete | collections.Set.delete | | Set.has | collections.Set.has | ### Application of ArkTS Containers in Concurrency ArkTS containers can be safely passed between concurrent instances, avoiding data race problems. However, ArkTS containers are not thread-safe and use a fail-fast mechanism internally. Therefore, when using ArkTS containers in a concurrent environment, an asynchronous lock mechanism needs to be used to ensure the safe access of the containers. ### Examples of Creating and Operating ArkTS Containers The following is a simple example demonstrating how to create and operate ArkTS containers:

import { collections } from '@kit.ArkTS';
@Entry
@Component
struct Index {
    @State message: string = 'Hello World';
    build() {
        Column() {
            Text(this.message)
             .fontSize(50)
             .fontWeight(FontWeight.Bold)
             .onClick(async () => {
                    // Create an Array
                    const arr = new collections.Array<number>();
                    arr.push(1);
                    arr.push(2);
                    arr.push(3);
                    console.log(arr); // Output: [1, 2, 3]
                    // Create a Map
                    const map = new collections.Map<number, string>();
                    map.set(1, 'one');
                    map.set(2, 'two');
                    map.set(3, 'three');
                    console.log(map); // Output: {1: "one", 2: "two", 3: "three"}
                    // Create a Set
                    const set = new collections.Set<string>();
                    set.add('one');
                    set.add('oneself');
                    set.add('two');
                    set.add('three');
                    console.log(set); // Output: Set { "one", "two", "three" }
                })
             .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 create Array, Map, and Set containers and output the contents of the containers.

Comparison Table between ArkTS Containers and Native APIs

Summary

Through the above introduction, you can understand the differences between ArkTS containers and native containers in the HarmonyOS system, as well as the application of ArkTS containers in concurrency. Hope this article can help you master the concurrent programming techniques in the HarmonyOS system and develop better HarmonyOS applications.