Location>code7788 >text

What's the deal with developing declarative UI for * NEXT?

Popularity：134 ℃/2024-10-15 10:58:54

Hello, I'm V. ArkTS is HarmonyOS' preferred workhorse application development language, which extends TypeScript to provide declarative UI descriptions, custom components, and the ability to dynamically extend UI elements. These capabilities, together with the system components in the ArkUI development framework and their associated event methods, property methods, etc., form the main body of UI development. ArkTS also provides a multi-dimensional state management mechanism, allowing data to be used within a component, but also can be passed between different component levels to realize the linkage of data and UI. In addition, ArkTS also provides rendering control capabilities, including conditional rendering, cyclic rendering and lazy loading of data, to adapt to different application development needs.

In declarative UI description, ArkTS allows developers to combine and extend components declaratively to describe an application's UI.This includes basic property configuration, event handling, and subcomponent configuration methods. For example, styles and other properties of system components can be configured by chaining calls to theText('hello').fontSize(20).fontColor(). It is also possible to set up the component's event response logic, such as theButton('Click me').onClick(() => { = 'ArkUI'; }). In addition, if the component supports subcomponent configurations, you can add a UI description of the subcomponent to the closure, such asColumn() { Text('Hello').fontSize(100) } 。

ArkTS' declarative UI development paradigm provides an efficient and intuitive way to build an application's user interface. With a declarative syntax, developers can focus more on the logic and structure of the application rather than on specific implementation details, resulting in increased development efficiency and code maintainability. As HarmonyOS continues to evolve, ArkTS will also continue to evolve, providing additional features and capabilities to meet the needs of developers in application development and operation.

In HarmonyOS, the ArkTS language provides a declarative way of describing the UI, allowing developers to build and manipulate user interfaces in a declarative way. Here are some key points and code examples, and an analysis of them:

1. Basic syntax and component creation

ArkTS defines declarative UI descriptions, custom components and the ability to dynamically extend UI elements. Components can be created with or without parameters:

  • parameter-free component: If the component's interface definition does not contain mandatory constructor parameters, nothing needs to be configured after the component's "()". For example, the Divider component does not contain constructor parameters:
  Column() {
    Text('item 1')
    Divider()
    Text('item 2')
  }
  • parameterized component: If the interface definition of the component contains constructor parameters, the "()" after the component configures the corresponding parameters. For example, the mandatory parameter src for the Image component:
  Image('https://weige/')

or the non-required parameter content of the Text component:

  Text('weige')

2. Configuration properties

The property methods are called in a "." chained calls to configure styles and other properties of system components. For example, configure the font size of the Text component:

Text('weige').fontSize(15)

Multiple properties of a component can also be configured:

Image('').alt('').width(100).height(100)

3. Configuration events

The event methods are organized as "." Chain calls to configure events supported by system components. For example, use a lambda expression to configure the component's event methods:

Button('Click me').onClick(() => {
   = 'ArkUI';
})

4. Configuration subcomponents

If the component supports subcomponent configuration, you need to add the UI description of the subcomponent to the component in the trailing closure "{...}". For example, the Column component configures the subcomponent example:

Column() {
  Text('Hello').fontSize(100)
  Divider()
  Text().fontSize(100).fontColor()
}

5. Status management

ArkTS provides a multi-dimensional state management mechanism. State variable changes trigger UI refreshes. Example:

@Entry
@Component
struct Index {
  @State message: string = 'Hello World'
  build() {
    Column() {
      Text('Hello').fontSize(30)
      Text().fontSize(30)
      Button() {
        Text('Click Me').fontSize(30)
      }.onClick(() => {
        ='ArkUI'
      }).width(200).height(50)
    }
  }
}

6. Rendering control

ArkTS provides capabilities for rendering control, including conditional rendering, cyclic rendering, and lazy loading of data. These capabilities allow developers to render the UI content in the corresponding state based on the different states of the application.

With this basic syntax and examples, developers can build feature-rich interfaces for HarmonyOS applications.ArkTS' declarative UI descriptions provide an efficient and intuitive way to build an application's user interface.

<Previous Next>