理解更深的鸿蒙的嵌套属性和@State装饰器，引用是更改了吗？深层拷贝。

代码如下：

复制代码

interface address{
  street:string
}
interface shuju{
  id:number
  name:string
  address:address
}
@Entry
@Component
struct Test5 {
  @State message: string = 'Hello World';
  @State lizi:shuju= {
    id:1,
    name:'aaa',
    address:{
      street:'haerbing'
    }
}
  build() {
    Column(){
      Text(this.lizi.address.street)
        .fontSize(34)
      Button('修改街道')
        .onClick(()=>{
          this.lizi.address.street='十三巷'
        })
      Text(this.lizi.name)
        .fontSize(34)
      Button('修改名字')
        .onClick(()=>{
          this.lizi.name='小网'
        })
    }
  }
}

使用效果：

刚开始的界面是这样的，

只点击修改名字：

如果第一次点击修改街道，text控件不变，点击修改名字，两个text都变。

总结，嵌套属性中，如果@state的第一层没变就不会带动已经修改数值的text控件立即响应，如果@state的第一层变了，已经修改完成的深层嵌套的数值也会带动立即响应，如果只单独点击深层嵌套是不会发生立即响应的。

例子2

代码：

复制代码

import { router } from '@kit.ArkUI'


interface user1{
  id:number
  name:string
}

interface address1{
  city:string
  street:string
}
interface Order {
  id: number;
  user: user1;
  address: address1;

}
@Entry
@Component
struct Test4 {
  @State message: string = 'Hello World';
  @State me:Order={
    id:1,
    user:{
      id:2,
      name:'aaa'
    },
    address:{
      city:'广东',
      street:'十三巷'
    }
  }
  @State me1:Order[]=[{
    id:3,
    user:{
      id:2,
      name:'aaa'
    },
    address:{
      city:'广东',
      street:'十三巷'
    }
  },
    {
      id: 21,
      user: {
        id: 2,
        name: 'aaa'
      },
      address: {
        city: '广东',
        street: '十三巷'
      }
    }
  ]
  build() {
    Column() {
      Text(this.me.user.name)
        .fontColor('#ffd04747') // 修正：颜色值格式（需引号包裹）
        .margin({ bottom: 20 }) // 增加间距，提升体验

      // 示例：修改address.city
      Button('修改name属1性')
        .backgroundColor('#007DFF')
        .onClick(() => {
          // ✅ Fix: Manual object reassignment (no spread operator)
          // Step 1: Create a new User1 object (copy all properties + update name)
          const newUser: user1 = {
            id: this.me.user.id, // Copy original id
            name: 'kkk1231'            // Update target property
          }

          // Step 2: Create a new Order object (copy all properties + replace user)
          const newOrder: Order = {
            id: this.me.id, // Copy original order id
            user: newUser, // Use new user object
            address: this.me.address // Keep original address (unchanged)
          }
          // router.pushUrl({
          //   url:'pages/k/test3'
          // })
          // Step 3: Assign new object to @State variable (trigger UI update)
          this.me = newOrder
        })
      Text(this.me.address.street)
        .fontSize(34)
      Button("修改街道")
        .onClick(() => {
          this.me.address.street = 'shasanjie'
        })

      Text(String(this.me.id))
        .fontSize(34)
      Button("修改街道")
        .onClick(() => {
          this.me.id = 1111
        })

      Text(String(this.me1[0].id))
        .fontSize(34)
      Button("修改街道me1")
        .onClick(() => {

          this.me1[0].id = 1223111
          if(this.me1[0].id===1223111)
          {
            this.me1[0].id=12321
          }
          if (this.me1[0].id==12321) {
            this.me1[0].id=90
          }
          this.me1 = [...this.me1];

        })
    }
  }
}

数组引用和数组本身：

新数组新引用

let arr1 = [1, 2, 3];

let arr2 = [...arr1]; // 新数组，新的引用

若 this.me1 = [...this.me1];

则更换了新引用。

若

let arr1 = [1, 2, 3];

let arr2 = arr1; // 复制的是引用，不是数组本身

arr2[0] = 100;

console.log(arr1); // [100, 2, 3] ← arr1 也被改变了

arr1 和 arr2 指向同一个数组对象
修改 arr2 的元素，arr1 也会看到变化

这就是 数组引用 的特性。

推荐一个句子

typescript代码：

复制代码

// 原数组
let arr1 = [1, 2, 3];
let arr2 = arr1; // arr2 指向同一个数组

console.log("初始 arr1:", arr1); // [1,2,3]
console.log("初始 arr2:", arr2); // [1,2,3]

// 更换引用
arr1 = [4, 5, 6]; // arr1 指向新数组

console.log("更换引用后 arr1:", arr1); // [4,5,6]
console.log("更换引用后 arr2:", arr2); // [1,2,3] ❌ arr2 没变

为什么最后arr2的数组没变？

最后看到 arr2 没变，是因为 更换引用只是改变了变量指向的数组，而没有修改原数组本身

如何判断是否引用了？

修改其中的一个值，如果跟着改变就是相同引用，如果不跟着改变就是不相同引用。

学习代码：

复制代码

//怎么判断是不是引用
//定义两个，引用互替，取第一个arr1的第一个值替换，
// 如果引用相同，则改一个，其中的另一个就会随之改变
// 如果引用不一样，改变一个，另一个就不会改变
let arr1 = [12, {id: 1}, {id: 2}];
// let arr2 = [...arr1];
// arr1[0]=122
// let arr2=arr1

let arr2 = arr1.map(item =>
{
    if (typeof item === 'object' && item !== null)
    {
        return {
            id: item.id
        }
    }
})
// let arr2 = arr1.map(item => {
//     console.log("item",typeof item)
//     if (typeof item === 'object' && item !== null) {
//         return {...item}; // 新对象
//     }
//     return item; // 基本类型直接拷贝
// });
// arr1[1].id = 100
console.log("arr2", arr2)
console.log("arr1", arr1)
console.log(arr1[1]=== arr2[1]); // true，对象引用相同

// let arr3=[1,2,3]
// let arr4=[...arr3]
//
// // arr3[0]=56
// console.log("2arr4[]",arr4)
// console.log(arr3[0] === arr4[0]); // true，对象引用相同
//
//
// let arr5=[1,2,3]
// let arr6=arr5
//
//
// console.log("2arr5[]",arr5)
// console.log("2arr6[]",arr6)
// console.log(arr5=== arr6); // true，对象引用相同