HarmonyOS Next Iterator Mode: for-in and interval traversal tips

[Lomanu4]

In the development of Cangjie language in HarmonyOS Next, the iterator mode is an important means to implement data traversal. For-in expression, as its key implementation method, provides developers with concise and powerful traversal functions.As a technician who has accumulated rich practical experience in this field, I will analyze the core points of for-in expressions and interval traversal in depth, and share the skills and principles.

1. Iterable interface specifications

(I) Custom type implementation iterator case


In Cangjie language, the for-in expression can traverse those type instances that extend the iterator interface Iterable.This feature not only applies to built-in types, but also provides a unified traversal method for custom types.Take a custom linked list type as an example:


class Node<T> {
var value: T
var next: Node<T>?

init(_ value: T) {
this.value = value
this.next = null
}
}

class LinkedList<T>: Iterable<T> {
var head: Node<T>?
var tail: Node<T>?

init() {
this.head = null
this.tail = null
}

func add(_ value: T) {
let newNode = Node(value)
if (this.tail == null) {
this.head = newNode
this.tail = newNode
} else {
this.tail!.next = newNode
this.tail = newNode
}
}

func iterator(): Iterator<T> {
return LinkedListIterator(this.head)
}
}

class LinkedListIterator<T>: Iterator<T> {
var current: Node<T>?

init(_ node: Node<T>?) {
this.current = node
}

func hasNext(): Bool {
return this.current!= null
}

func next(): T {
let value = this.current!.value
this.current = this.current!.next
return value
}
}

In the above code, the LinkedList class implements the Iterable<T> interface, and returns an iterator object LinkedListIterator that implements the Iterator<T> interface through the iterator method.This way, you can use the for-in expression to traverse LinkedList:


main() {
let list = LinkedList<Int>()
list.add(1)
list.add(2)
list.add(3)
for (num in list) {
println(num)
}
}

Implementing the iterator interface through custom types can not only reuse the for-in expressions, but also encapsulate complex data structure traversal logic to improve the readability and maintainability of the code.

2. Tuple deconstruction techniques

(I) Tuple unpacking example of coordinate array traversal


When using the for-in expression to traverse a sequence of elements as tuple types, the tuple deconstruction technique allows us to easily obtain each element in the tuple.For example, when processing coordinate arrays:


main() {
let coordinates = [(1, 2), (3, 4), (5, 6)]
for ((x, y) in coordinates) {
println("Coordinates: (\(x), \(y))")
}
}

In this example, (x, y) is the writing of tuple deconstruction. It splits each tuple element in the coordinates array into two variables, x and y, for easy use in the loop body.This method avoids the tedious operation of manually accessing tuple elements, making the code more concise and intuitive.In actual development, when processing similar structured data, tuple deconstruction can greatly improve development efficiency and reduce the probability of errors.

3. Where conditional filtering

(I) Compiler optimization principle of odd filters


The for-in expression of Cangjie language supports adding filter conditions using the where keyword when traversing sequences.Take filtering odd numbers as an example:


main() {
for (i in 0..8 where i % 2 == 1) {
println(i)
}
}

In this example, where i % 2 == 1 means only odd numbers between 0 and 8 are traversed.From the perspective of compiler optimization, this method can optimize the traversal logic during the compilation stage.The compiler can directly skip elements that do not meet the conditions when generating code, without making conditional judgments every time the loop, thereby improving traversal efficiency.Compared with using if statements for filtering inside the loop body, the where condition filtering reduces unnecessary branch jumps and condition judgment overhead, making code execution more efficient.In scenarios where large-scale data traversal is processed and conditional filtering is required, the rational use of the where condition can significantly improve program performance.

Mastering these key points of for-in expressions and interval traversal can enable developers to process data traversal tasks more efficiently in the development of Cangjie language in HarmonyOS Next.Whether it is traversal of custom types or processing of complex data structures, these techniques can provide strong support for code writing and optimization.

Пожалуйста Авторизируйтесь или Зарегистрируйтесь для просмотра скрытого текста.