当前位置：首页 > article >正文

鸿蒙进阶篇-剩余和展开、简单和复杂类型

article 2024/11/14 12:04:41

“在科技的浪潮中，鸿蒙操作系统宛如一颗璀璨的新星，引领着创新的方向。作为鸿蒙开天组，今天我们将一同踏上鸿蒙基础的探索之旅，为您揭开这一神奇系统的神秘面纱。”

各位小伙伴们我们又见面了,我就是鸿蒙开天组,下面让我们进入今天的学习,鸿蒙进阶篇-剩余和展开、简单和复杂类型

在鸿蒙中:

“剩余” 参数允许函数接收数量不定的额外参数，并将它们以数组的形式进行处理，增强了函数在参数处理上的灵活性。

“展开” 常用于数组或对象操作中，例如将数组元素展开为独立的参数传递给函数，或者将对象的属性展开为独立的键值对。

“简单类型” 通常指基本的数据类型，如整数、浮点数、布尔值、字符和字符串等。它们具有固定的大小和简单的操作，在内存中的表示相对直接。

“复杂类型” 则包括数组、对象、类等。这些类型由多个简单类型或其他复杂类型组合而成，具有更丰富的结构和操作方式，需要更多的内存和处理逻辑来管理和操作。

总的来说，“剩余” 和 “展开” 是在编程中处理参数和数据结构的方式，而 “简单类型” 和 “复杂类型” 则是对数据类型的分类，反映了数据的结构和复杂度。

剩余和展开
接下来学习一个运算符 ...
...在不同的情况下有不同的效果，分别是剩余参数和展开

剩余参数
通过剩余参数的语法，我们可以将函数或方法中一个不定数量的参数表示为一个数组
附上官方文档链接https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/rest_parameters

// 剩余参数 【只能写在最后一位】
function 函数名(参数1,参数2,...剩余参数数组){
  // 逻辑代码
  // 剩余参数之前的参数 挨个获取即可
  // 剩余参数：以数组的形式获取
}

展开
出于程序稳定性，以及运行性能考虑，在 ArkTS 中 ...(展开运算符) 只能用在数组上
附上官方文档链接https://docs.openharmony.cn/pages/v4.0/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md#%E9%83%A8%E5%88%86%E6%94%AF%E6%8C%81%E5%B1%95%E5%BC%80%E8%BF%90%E7%AE%97%E7%AC%A6

下面展示一个案例来理解:

const numArr1: number[] = [1, 2, 3, 4]
const numArr2: number[] = [5, 6, 7]

// 合并到一起
const totalArr: number[] = [...numArr1, ...numArr2]

// 添加
const numArr3: number[] = [8, 9, 10]
const numArr4: number[] = [11, 12, 13]

// 将 numArr4 展开，传递给push
numArr3.push(...numArr4)
console.log('', totalArr)

@Entry
@Component
struct Example01 {
  build() {
    Column() {
      Column() {
        Column() {
        }
        .margin(10)

      }.width(250)
      .height(500)
      .backgroundColor('#eee')
      .border({ width: 2, color: 'green', style: BorderStyle.Solid })

    }.width('100%')
  }
}

简单类型和复杂类型

ArkTS中的数据类型整体可以分为两大类:
1 基本数据类型（简单数据类型）
number 数字型、string 字符串型、boolean布尔型、undefined未定义、null空类型
2 引用数据类型（复杂数据类型）
Object、Function、Array
这两类数据在内存中保存的方式略有不同，导致在日常开发中对这两类数据进行赋值操作时会有不同的结果

下面展示一个案例来理解:

比如如下代码:
1
num1和 num2 的值分别是？
2
p1.name和p2.name 分别是?

// 基本数据类型
let numA: number = 10
let numB: number = numA
numB++
console.log('numA:', numA) // ?
console.log('numB:', numB) // ?


// 引用数据类型
class Person {
  name: string = ''

  constructor(name: string) {
    this.name = name
  }
}

const p1: Person = new Person('jack')
const p2: Person = p1
// 修改 P2 是否会报错
p2.name = 'rose'

console.log('p1.name:', p1.name) // ?
console.log('p2.name:', p2.name) // ?

@Entry
@Component
struct Example01 {
  build() {
    Column() {
      Column() {
        Column() {
        }
        .margin(10)

      }.width(250)
      .height(500)
      .backgroundColor('#eee')
      .border({ width: 2, color: 'green', style: BorderStyle.Solid })

    }.width('100%')
  }
}

为了弄明白上述现象的原因，就需要搞清楚这两种数据类型在内存存储的差异是什么

内存中堆栈空间
咱们可以把内存理解为有 2 类空间：
1栈：访问速度快，基本数据类型存放到栈里面
2堆：存储容量大，引用数据类型存放到堆里面

基本数据类型和复杂数据类型是如何保存的呢?

基本数据类型存储
变量的数据直接存放在栈空间中，访问速度快

引用数据类型存储
1 栈空间：存放变量的内存地址（堆中的地址）
2 堆空间：存放变量的值

站在内存角度看变量赋值

基本数据类型
num1 num2 都保存在堆内存中，虽然值相同，但是各自是独立的空间，后续操作互不影响

let num1: number = 10
let num2: number = num1

引用数据类型
p1 和 p2 栈内存中有各自独立的空间，但是保存的是堆内存的地址，指向的是同一个数据：
修改 p2.name ，p1.name 也会受到影响，因为是同一份数据

class Person {
  name: string = ''

  constructor(name: string) {
    this.name = name
  }
}

const p1: Person = new Person('jack')
const p2: Person = p1
p2.name = 'rose'