@buaa_smat/hometrans 0.1.0 → 0.1.2

package/skills/hmos-ui-align/references/MVVM/345/274/200/345/217/221/346/226/207/346/241/243/@Track/350/243/205/351/245/260/345/231/250/357/274/232class/345/257/271/350/261/241/345/261/236/346/200/247/347/272/247/346/233/264/346/226/260.md

@@ -0,0 +1,297 @@
+# @Track装饰器：class对象属性级更新
+
+@Track应用于class对象的属性级更新。@Track装饰的属性变化时，只会触发该属性关联的UI更新。
+
+在阅读本文档之前，建议开发者对状态管理基本观察能力有基本的了解。建议提前阅读：[@State](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-state)。
+
+> **说明：**
+>
+> 从API version 11开始，该装饰器支持在ArkTS卡片中使用。
+>
+> 从API version 12开始，该装饰器支持在元服务中使用。
+
+## 概述
+
+@Track是class对象的属性装饰器。当一个class对象是状态变量时，@Track装饰的属性发生变化，只会触发该属性关联的UI更新；如果class类中使用了@Track装饰器，则未被@Track装饰器装饰的属性不能在UI中使用，如果使用，会发生运行时报错。
+
+## class属性级更新说明
+
+状态管理V1中@State等装饰器默认支持观察第一层属性的变化，第一层属性的变化虽然可以触发更新，但无法做到类属性级的观察，下面的例子就展示了这一限制：
+
+```TypeScript
+import { hilog } from '@kit.PerformanceAnalysisKit';
+const DOMAIN_NUMBER: number = 0XFF00;
+const TAG: string = '[Sample_StateTrack]';
+class Info {
+  public name: string = 'Jack';
+  public age: number = 12;
+}
+
+@Entry
+@Component
+struct Index {
+  @State info: Info = new Info();
+
+  // 借助getFontSize的日志打印，可以分辨哪个组件触发了渲染
+  getFontSize(id: number): number {
+    hilog.info(DOMAIN_NUMBER, TAG, `Component ${id} render`);
+    return 30;
+  }
+
+  build() {
+    Column() {
+      Text(`name: ${this.info.name}`)
+        .fontSize(this.getFontSize(1))
+      Text(`age: ${this.info.age}`)
+        .fontSize(this.getFontSize(2))
+
+      // 点击当前Button，可以发现当前虽然仅改变了name属性
+      // 但是依旧会触发两个Text的刷新
+      // Text(`age: ${this.info.age}`)是冗余刷新
+      Button('change name').onClick(() => {
+        this.info.name = 'Jane';
+      })
+
+      // 点击当前Button，可以发现当前虽然仅改变了age属性
+      // 但是依旧会触发两个Text的刷新
+      // Text(`name: ${this.info.name}`)是冗余刷新
+      Button('change age').onClick(() => {
+        this.info.age++;
+      })
+    }
+    .height('100%')
+    .width('100%')
+  }
+}
+```
+
+> **说明：**
+>
+> 当UI刷新时，会执行组件的属性设置方法，利用这一机制可以通过观察getFontSize方法是否被调用来判断当前组件是否刷新。
+
+- UI首次渲染完成，观察到输出如下日志：
+
+```text
+Component 1 render
+Component 2 render
+```
+
+- 当点击Button('change name')时，即使只修改了info.name，观察日志发现两个Text组件仍会重新渲染。组件Text(`age: ${this.info.age}`)并未使用name属性，但仍因为info.name的改变而刷新，因此这次刷新是冗余的。日志输出如下：
+
+```text
+Component 1 render
+Component 2 render
+```
+
+- 同理，点击Button('change age')，也会触发Text(`name: ${this.info.name}`)的刷新。日志输出如下：
+
+```text
+Component 1 render
+Component 2 render
+```
+
+造成上述冗余刷新的根本原因是：状态管理V1中@State等装饰器无法精准观察类属性的访问与变更。为了实现类对象属性的精准观察，引入@Track装饰器。
+
+## 装饰器说明
+
+| @Track变量装饰器 | 说明 |
+| --- | --- |
+| 装饰器参数 | 无 |
+| 可装饰的变量 | class对象的非静态成员属性。 |
+
+## 观察变化和行为表现
+
+当一个class对象是状态变量时，@Track装饰的属性发生变化，该属性关联的UI触发更新。
+
+> **说明：**
+>
+> 当class对象中没有一个属性被标记@Track，行为与原先保持不变。@Track没有深度观测的功能。
+
+使用@Track装饰器可以避免冗余刷新。
+
+```TypeScript
+import { hilog } from '@kit.PerformanceAnalysisKit';
+const DOMAIN_NUMBER: number = 0XFF00;
+const TAG: string = '[Sample_StateTrack]';
+
+class LogTrack {
+  @Track public str1: string;
+  @Track public str2: string;
+
+  constructor(str1: string) {
+    this.str1 = str1;
+    this.str2 = 'World';
+  }
+}
+
+class LogNotTrack {
+  public str1: string;
+  public str2: string;
+
+  constructor(str1: string) {
+    this.str1 = str1;
+    this.str2 = 'World';
+  }
+}
+
+@Entry
+@Component
+struct AddLog {
+  @State logTrack: LogTrack = new LogTrack('Hello');
+  @State logNotTrack: LogNotTrack = new LogNotTrack('Hello');
+
+  isRender(index: number) {
+    hilog.info(DOMAIN_NUMBER, TAG, `Text ${index} is rendered`);
+    return 50;
+  }
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.logTrack.str1) // Text1
+          .id('str1')
+          .fontSize(this.isRender(1))
+          .fontWeight(FontWeight.Bold)
+        Text(this.logTrack.str2) // Text2
+          .fontSize(this.isRender(2))
+          .fontWeight(FontWeight.Bold)
+        Button('change logTrack.str1')
+          .id('str2')
+          .onClick(() => {
+            this.logTrack.str1 = 'Bye';
+          })
+        Text(this.logNotTrack.str1) // Text3
+          .fontSize(this.isRender(3))
+          .fontWeight(FontWeight.Bold)
+        Text(this.logNotTrack.str2) // Text4
+          .fontSize(this.isRender(4))
+          .fontWeight(FontWeight.Bold)
+        Button('change logNotTrack.str1')
+          .onClick(() => {
+            this.logNotTrack.str1 = 'Bye';
+          })
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
+```
+
+在上面的示例中：
+
+1. 类LogTrack中的属性均被@Track装饰器装饰，点击按钮"change logTrack.str1"，此时Text1刷新，Text2不刷新，只有一条日志输出，避免了冗余刷新。
+
+```ts
+Text 1 is rendered
+```
+
+2. 类logNotTrack中的属性均未被@Track装饰器装饰，点击按钮"change logNotTrack.str1"，此时Text3、Text4均会刷新，有两条日志输出，存在冗余刷新。
+
+```ts
+Text 3 is rendered
+Text 4 is rendered
+```
+
+## 限制条件
+
+- 如果class类中使用了@Track装饰器，那么该class类中非@Track装饰的属性不能在@Component UI中使用，包括不能绑定在组件上、不能用于初始化子组件，错误的使用将导致运行时报错，详见[在UI中使用非@Track装饰的属性发生运行时报错](#在ui中使用非track装饰的属性发生运行时报错)；可以在非UI中使用非@Track装饰的属性，如事件回调函数中、生命周期函数中等。
+
+- API version 19及以后，@Track使用在[@ComponentV2](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-create-custom-components#componentv2)的UI中，不会引起运行时报错，但依旧不会刷新，详见[@Observed+@Track装饰的class（V1->V2）](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-v1-v2-mixusage#传递class类型v1-v2)、[@Observed+@Track装饰的class（V2->V1）](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-v1-v2-mixusage#传递class类型v2-v1)。
+
+- 建议开发者不要混用包含@Track的class对象和不包含@Track的class对象，如联合类型中、类继承中等，容易在UI中误用非@Track装饰的属性，导致运行时报错。
+
+## 使用场景
+
+### @Track和自定义组件更新
+
+以下示例展示组件更新和@Track的处理步骤。对象log是@State装饰的状态变量，logInfo是@Track装饰的成员属性，其余成员属性都是非@Track装饰的，而且也不准备在UI中更新它们的值。
+
+```TypeScript
+import { hilog } from '@kit.PerformanceAnalysisKit';
+const DOMAIN_NUMBER: number = 0XFF00;
+const TAG: string = '[Sample_StateTrack]';
+class Log {
+  @Track public logInfo: string;
+  public owner: string;
+  public id: number;
+  public time: Date;
+  public location: string;
+  public reason: string;
+
+  constructor(logInfo: string) {
+    this.logInfo = logInfo;
+    this.owner = 'OH';
+    this.id = 0;
+    this.time = new Date();
+    this.location = 'CN';
+    this.reason = 'NULL';
+  }
+}
+
+@Entry
+@Component
+struct AddLog {
+  @State log: Log = new Log('origin info.');
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.log.logInfo)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+          .onClick(() => {
+            // 没有被@Track装饰的属性可以在点击事件中使用。
+            hilog.info(DOMAIN_NUMBER, TAG, 'owner: ' + this.log.owner +
+              ' id: ' + this.log.id +
+              ' time: ' + this.log.time +
+              ' location: ' + this.log.location +
+              ' reason: ' + this.log.reason);
+            this.log.time = new Date();
+            this.log.id++;
+            this.log.logInfo += ' info.';
+          })
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}
+```
+
+处理步骤：
+
+1. AddLog自定义组件的Text.onClick点击事件自增字符串' info.'。
+
+2. 由于@State log变量的@Track属性logInfo更改，Text重新渲染。
+
+## 常见问题
+
+### 在UI中使用非@Track装饰的属性发生运行时报错
+
+在UI中使用非@Track装饰的属性，运行时会报错。
+
+```ts
+class Person {
+  // id被@Track装饰
+  @Track id: number;
+  // age未被@Track装饰
+  age: number;
+
+  constructor(id: number, age: number) {
+    this.id = id;
+    this.age = age;
+  }
+}
+
+@Entry
+@Component
+struct Parent {
+  @State parent: Person = new Person(2, 30);
+
+  build() {
+    // 没有被@Track装饰的属性不可以在UI中使用，运行时会报错
+    Text(`Parent id is: ${this.parent.id} and Parent age is: ${this.parent.age}`)
+  }
+}
+```

package/skills/hmos-ui-align/references/MVVM/345/274/200/345/217/221/346/226/207/346/241/243/@Watch/350/243/205/351/245/260/345/231/250/357/274/232/347/212/266/346/200/201/345/217/230/351/207/217/346/233/264/346/224/271/351/200/232/347/237/245.md

@@ -0,0 +1,395 @@
+# @Watch装饰器：状态变量更改通知
+
+@Watch应用于对状态变量的监听。如果开发者需要关注某个状态变量的值是否改变，可以使用@Watch为状态变量设置回调函数。
+
+@Watch提供了状态变量的监听能力，@Watch仅能监听到可以观察到的变化。
+
+在阅读本文档前，建议开发者对状态管理基本观察能力有基本的了解。建议提前阅读：[@State](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-state)。
+
+> **说明：**
+>
+> 从API version 9开始，该装饰器支持在ArkTS卡片中使用。
+>
+> 从API version 11开始，该装饰器支持在元服务中使用。
+
+## 概述
+
+@Watch用于监听状态变量的变化，当状态变量变化时，@Watch的回调方法将被调用。@Watch在ArkUI框架内部判断数值有无更新使用的是严格相等（===），遵循严格相等规范。当严格相等判断的结果是false（即不相等）的情况下，就会触发@Watch的回调。
+
+## 装饰器说明
+
+| @Watch补充变量装饰器 | 说明 |
+| --- | --- |
+| 装饰器参数 | 必填。常量字符串，字符串需要有引号。是(string) => void自定义成员函数的方法的引用。 |
+| 可装饰的自定义组件变量 | 可监听所有装饰器装饰的状态变量。不允许监听常规变量。 |
+| 装饰器的顺序 | 装饰器顺序不影响实际功能，开发者可以根据自己的需要决定装饰器顺序的先后。建议[@State](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-state)、[@Prop](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-prop)、[@Link](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-link)等装饰器在@Watch装饰器之前，以保持整体风格的一致。 |
+| @Watch触发时机 | 使用@Watch来监听状态变量变化时，回调触发时间是变量真正变化、被赋值的时间。详细示例请参考使用场景中的[@Watch的触发时机](#watch的触发时机)。 |
+
+## 语法说明
+
+| 类型 | 说明 |
+| --- | --- |
+| (changedPropertyName? : string) => void | 该函数是自定义组件的成员函数，changedPropertyName是被watch的属性名。在多个状态变量绑定同一个@Watch的回调方法的时候，可以通过changedPropertyName进行不同的逻辑处理。将属性名作为字符串输入参数，不返回任何内容。 |
+
+## 观察变化和行为表现
+
+1. 当观察到状态变量的变化（包括双向绑定的[AppStorage](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-appstorage)和[LocalStorage](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-localstorage)中对应的key发生的变化）的时候，对应的@Watch的回调方法将被触发；
+
+2. @Watch方法在自定义组件的属性变更之后同步执行；
+
+3. 如果在@Watch的方法里改变了其他的状态变量，也会引起状态变更和@Watch的执行；
+
+4. 在第一次初始化的时候，@Watch装饰的方法不会被调用，即认为初始化不是状态变量的改变。只有在后续状态改变时，才会调用@Watch回调方法。
+
+## 限制条件
+
+- 建议开发者避免无限循环。循环可能是因为在@Watch的回调方法里直接或者间接地修改了同一个状态变量引起的。为了避免循环的产生，建议不要在@Watch的回调方法里修改当前装饰的状态变量；
+
+- 开发者应关注性能，属性值更新函数会延迟组件的重新渲染（具体请见上面的行为表现），因此，回调函数应仅执行快速运算；
+
+- 不建议在@Watch函数中调用async await，因为@Watch设计的用途是为了快速的计算，异步行为可能会导致重新渲染速度的性能问题。
+
+- @Watch参数为必选，且参数类型必须是string，否则编译期会报错。不建议开发者传入undefined，传入后编译不会报错，相当于传入"undefined"。
+
+```ts
+// 错误写法，编译报错
+@State @Watch() num: number = 10;
+@State @Watch(change) num: number = 10;
+
+// 正确写法
+@State @Watch('change') num: number = 10;
+change() {
+  console.info(`xxx`);
+}
+```
+
+- @Watch内的参数必须是声明的方法名，否则编译期会报错。
+
+```ts
+// 错误写法，没有对应名称的函数，编译报错
+@State @Watch('change') num: number = 10;
+onChange() {
+  console.info(`xxx`);
+}
+
+// 正确写法
+@State @Watch('change') num: number = 10;
+change() {
+  console.info(`xxx`);
+}
+```
+
+- 常规变量不能被@Watch装饰，否则编译期会报错。
+
+```ts
+// 错误写法
+@Watch('change') num: number = 10;
+change() {
+  console.info(`xxx`);
+}
+
+// 正确写法
+@State @Watch('change') num: number = 10;
+change() {
+  console.info(`xxx`);
+}
+```
+
+## 使用场景
+
+### @Watch和自定义组件更新
+
+以下示例展示组件更新和@Watch的处理步骤。count在CountModifier中由@State装饰，在TotalView中由@Prop装饰。
+
+```TypeScript
+@Component
+struct TotalView {
+  @Prop @Watch('onCountUpdated') count: number = 0;
+  @State total: number = 0;
+
+  // @Watch 回调
+  onCountUpdated(propName: string): void {
+    this.total += this.count;
+  }
+
+  build() {
+    Text(`Total: ${this.total}`)
+  }
+}
+
+@Entry
+@Component
+struct CountModifier {
+  @State count: number = 0;
+
+  build() {
+    Column() {
+      Button('add to basket')
+        .onClick(() => {
+          this.count++;
+        })
+      TotalView({ count: this.count })
+    }
+  }
+}
+```
+
+处理步骤：
+
+1. CountModifier自定义组件的Button.onClick点击事件自增count。
+
+2. 由于@State count变量更改，子组件TotalView中的@Prop被更新，其@Watch('onCountUpdated')方法被调用，更新了子组件TotalView 中的total变量。
+
+3. 子组件TotalView中的Text重新渲染。
+
+### @Watch与@Link组合使用
+
+以下示例说明了如何在子组件中观察@Link变量。
+
+```TypeScript
+class PurchaseItem {
+  public static nextId: number = 0;
+  public id: number;
+  public price: number;
+
+  constructor(price: number) {
+    this.id = PurchaseItem.nextId++;
+    this.price = price;
+  }
+}
+
+@Component
+struct BasketViewer {
+  @Link @Watch('onBasketUpdated') shopBasket: PurchaseItem[];
+  @State totalPurchase: number = 0;
+
+  updateTotal(): number {
+    let total = this.shopBasket.reduce((sum, i) => sum + i.price, 0);
+    // 超过100欧元可享受折扣
+    if (total >= 100) {
+      total = 0.9 * total;
+    }
+    return total;
+  }
+
+  // @Watch 回调
+  onBasketUpdated(propName: string): void {
+    this.totalPurchase = this.updateTotal();
+  }
+
+  build() {
+    Column() {
+      ForEach(this.shopBasket,
+        (item: PurchaseItem) => {
+          Text(`Price: ${item.price.toFixed(2)} €`)
+        },
+        (item: PurchaseItem) => item.id.toString()
+      )
+      Text(`Total: ${this.totalPurchase.toFixed(2)} €`)
+    }
+  }
+}
+
+@Entry
+@Component
+struct BasketModifier {
+  @State shopBasket: PurchaseItem[] = [];
+
+  build() {
+    Column() {
+      Button('Add to basket')
+        .onClick(() => {
+          this.shopBasket.push(new PurchaseItem(Math.round(100 * Math.random())));
+        })
+      BasketViewer({ shopBasket: $shopBasket })
+    }
+  }
+}
+```
+
+处理步骤如下：
+
+1. BasketModifier组件的Button.onClick向BasketModifier shopBasket中添加条目；
+
+2. @Link装饰的BasketViewer shopBasket值发生变化；
+
+3. 状态管理框架调用@Watch函数BasketViewer onBasketUpdated 更新BasketViewer TotalPurchase的值；
+
+4. @Link shopBasket的改变，新增了数组项，ForEach组件会执行item Builder，渲染构建新的Item项；@State totalPurchase改变，对应的Text组件也重新渲染；重新渲染是异步发生的。
+
+效果图如下：
+
+![效果图](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/c9/v3/CFz_A5WbS_SpKAPoEQ0kzw/zh-cn_image_0000002535948094.gif)
+
+### @Watch的触发时机
+
+为了展示@Watch回调触发时间是根据状态变量真正变化的时间，本示例在子组件中同时使用@Link和[@ObjectLink](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-observed-and-objectlink)装饰器，分别观察不同的状态对象。通过在父组件中更改状态变量并观察@Watch回调的先后顺序，来表明@Watch触发的时机与赋值、同步的关系。
+
+```TypeScript
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { common } from '@kit.AbilityKit';
+
+@Observed
+class Task {
+  public isFinished: boolean = false;
+
+  constructor(isFinished: boolean) {
+    this.isFinished = isFinished;
+  }
+}
+
+const DOMAIN = 0x0000;
+
+@Entry
+@Component
+struct ParentComponent {
+  @State @Watch('onTaskAChanged') taskA: Task = new Task(false);
+  @State @Watch('onTaskBChanged') taskB: Task = new Task(false);
+  private context = this.getUIContext().getHostContext() as common.UIAbilityContext;
+  // 请将$r('app.string.watch_text5')替换为实际资源文件，在本示例中该资源文件的value值为"父组件任务A状态:"
+  @State type1: string = this.context!.resourceManager.getStringSync($r('app.string.watch_text5').id);
+  // 请将$r('app.string.watch_text6')替换为实际资源文件，在本示例中该资源文件的value值为"父组件任务B状态:"
+  @State type2: string = this.context!.resourceManager.getStringSync($r('app.string.watch_text6').id);
+
+  onTaskAChanged(changedPropertyName: string): void {
+    // 请将$r('app.string.watch_text12')替换为实际资源文件，在本示例中该资源文件的value值为"观测到父组件任务属性变化:"
+    hilog.info(DOMAIN, this.getUIContext()
+      .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text12').id), changedPropertyName);
+  }
+
+  onTaskBChanged(changedPropertyName: string): void {
+    // 请将$r('app.string.watch_text12')替换为实际资源文件，在本示例中该资源文件的value值为"观测到父组件任务属性变化:"
+    hilog.info(DOMAIN, this.getUIContext()
+      .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text12').id), changedPropertyName);
+  }
+
+  build() {
+    Column() {
+      // 请将$r('app.string.watch_text7')替换为实际资源文件，在本示例中该资源文件的value值为"已完成"
+      // 请将$r('app.string.watch_text8')替换为实际资源文件，在本示例中该资源文件的value值为"未完成"
+      Text(`${this.type1} ${this.taskA.isFinished ? this.getUIContext()
+        .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text7').id) :
+        this.getUIContext()
+          .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text8').id)}`)
+      Text(`${this.type2} ${this.taskB.isFinished ? this.getUIContext()
+        .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text7').id) :
+        this.getUIContext()
+          .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text8').id)}`)
+      ChildComponent({ taskA: this.taskA, taskB: this.taskB })
+      // 请将$r('app.string.watch_text9')替换为实际资源文件，在本示例中该资源文件的value值为"切换任务状态"
+      Button(this.getUIContext()
+        .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text9').id))
+        .onClick(() => {
+          this.taskB = new Task(!this.taskB.isFinished);
+          this.taskA = new Task(!this.taskA.isFinished);
+        })
+    }
+  }
+}
+
+@Component
+struct ChildComponent {
+  @ObjectLink @Watch('onObjectLinkTaskChanged') taskB: Task;
+  @Link @Watch('onLinkTaskChanged') taskA: Task;
+  private context = this.getUIContext().getHostContext() as common.UIAbilityContext;
+  // 请将$r('app.string.watch_text10')替换为实际资源文件，在本示例中该资源文件的value值为"子组件任务A状态:"
+  @State type1: string = this.context!.resourceManager.getStringSync($r('app.string.watch_text10').id);
+  // 请将$r('app.string.watch_text11')替换为实际资源文件，在本示例中该资源文件的value值为"子组件任务B状态:"
+  @State type2: string = this.context!.resourceManager.getStringSync($r('app.string.watch_text11').id);
+
+  onObjectLinkTaskChanged(changedPropertyName: string): void {
+    // 请将$r('app.string.watch_text13')替换为实际资源文件，在本示例中该资源文件的value值为"观测到子组件@ObjectLink关联的任务属性变化:"
+    hilog.info(DOMAIN, this.getUIContext()
+      .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text13').id), changedPropertyName);
+  }
+
+  onLinkTaskChanged(changedPropertyName: string): void {
+    // 请将$r('app.string.watch_text14')替换为实际资源文件，在本示例中该资源文件的value值为"观测到子组件@Link关联的任务属性变化:"
+    hilog.info(DOMAIN, this.getUIContext()
+      .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text14').id), changedPropertyName);
+  }
+
+  build() {
+    Column() {
+      // 请将$r('app.string.watch_text7')替换为实际资源文件，在本示例中该资源文件的value值为"已完成"
+      // 请将$r('app.string.watch_text8')替换为实际资源文件，在本示例中该资源文件的value值为"未完成"
+      Text(`${this.type1} ${this.taskA.isFinished ? this.getUIContext()
+        .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text7').id) :
+        this.getUIContext()
+          .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text8').id)}`)
+      Text(`${this.type2} ${this.taskB.isFinished ? this.getUIContext()
+        .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text7').id) :
+        this.getUIContext()
+          .getHostContext()!.resourceManager.getStringSync($r('app.string.watch_text8').id)}`)
+    }
+  }
+}
+```
+
+处理步骤如下：
+
+1. 当点击按钮切换任务状态时，父组件首先更新了被@ObjectLink关联的taskB，然后更新了被@Link关联的taskA。
+
+2. 观察到日志依次显示：
+
+```text
+观测到父组件任务属性变化: taskB
+观测到父组件任务属性变化: taskA
+观测到子组件@Link关联的任务属性变化: taskA
+观测到子组件@ObjectLink关联的任务属性变化: taskB
+```
+
+3. 通过日志可以看到，父组件的回调顺序和修改顺序一致，而子组件中@Link和@ObjectLink的回调触发顺序与父组件中变量更新的顺序不同。这是因为父组件的变量更新是即时的，但子组件中@Link和@ObjectLink获取更新数据的时机不同。@Link的状态更新是同步的，状态变化会立刻触发@Watch回调。而@ObjectLink的更新依赖于父组件的同步，当父组件刷新并将更新后的变量传递给子组件时，@Watch回调才会触发，因此触发顺序略晚于@Link。
+
+4. 这是符合预期的行为，展示了@Watch回调的触发时机是根据状态变量真正变化的时间。因为@Link直接同步，而@ObjectLink需要等父组件更新子组件变量。类似地，@Prop也可能表现出与@ObjectLink类似的行为，其回调触发时间也会略晚。
+
+### 使用changedPropertyName进行不同的逻辑处理
+
+以下示例说明了如何在@Watch函数中使用changedPropertyName进行不同的逻辑处理。
+
+```TypeScript
+@Entry
+@Component
+struct UsePropertyName {
+  @State @Watch('countUpdated') apple: number = 0;
+  @State @Watch('countUpdated') cabbage: number = 0;
+  @State fruit: number = 0;
+
+  // @Watch 回调
+  countUpdated(propName: string): void {
+    if (propName === 'apple') {
+      this.fruit = this.apple;
+    }
+  }
+
+  build() {
+    Column() {
+      Text(`Number of apples: ${this.apple.toString()}`).fontSize(30)
+      Text(`Number of cabbages: ${this.cabbage.toString()}`).fontSize(30)
+      Text(`Total number of fruits: ${this.fruit.toString()}`).fontSize(30)
+      Button('Add apples')
+        .onClick(() => {
+          this.apple++;
+        })
+      Button('Add cabbages')
+        .onClick(() => {
+          this.cabbage++;
+        })
+    }
+  }
+}
+```
+
+处理步骤如下：
+
+1. 点击Button('Add apples')时，apple的值发生变化。
+
+2. 状态管理框架调用@Watch函数countUpdated，发生变化的状态变量名为apple，满足if逻辑条件，fruit的值被改变。
+
+3. 绑定了apple，fruit状态变量的Text重新渲染。
+
+4. 点击Button('Add cabbages')时，cabbage的值发生变化。
+
+5. 状态管理框架调用@Watch函数countUpdated，发生变化的状态变量名为cabbage，不满足if逻辑条件，fruit的值不发生变化。
+
+6. 绑定了cabbage状态变量的Text重新渲染。