准备工作

去鸿蒙官网下载开发环境

点击右侧预浏览，刷新和插销按钮，插销表示热更新，常用按钮。

基础语法

string number boolean const常量 数组

let s : string = "1111";
console.log("string", s);

let n : number = 1;
console.log("number", n);

let bool : boolean = true;

const PI= "asdfasdf";
console.log(PI);

let numbers = [1, 2, 3, 4, 5, 6];
console.log("arr", numbers);

接口

实现接口时，必须实现所有的属性和方法

interface HI{
  a : string;
  b : number;
  c : boolean;
  sing : (song:string) => void;
  dance : ()=>void;
}

let person: HI = {
  a : "123",
  b : 1,
  c : true,
  sing : (song:string)=>{
    console.log("唱首歌", song);
  },
  dance : ()=>{

  }
}
console.log("1", person.a, person.b, person.c);
person.sing("爱的供养");
function fun(){}

联合类型

// 1
let judge : number | string  = 100;
judge = "A";

// 2
let gender : 'man' | 'woman' = 'man';

枚举类型

enum ThemeColor {
  Red = '#ff0f29',
  Orange = '#ff7110',
  Green = '#30b30e'
}
let color : ThemeColor = ThemeColor.Red;

字符串拼接

字符串+数字

数字+字符串

字符串+ 字符串

只要一边是字符串就是拼接。

模板字符串

``里面可以使用变量，方便多个字符串的拼接。

数字和字符串转换

需要注意的是：

        parseInt('1.1a') 直接取整，忽略0.1a

        parseFloat('1.1a') 1.1

        parseFloat('1.a1') 1

        也就是说，parseFloat在遇到非数字时就会截断。

点击事件

.onClick()，参数为一个回调函数

Button('按钮').onClick(()=>{
  AlertDialog.show({
    message : '弹窗'
  })
})

状态管理

注意：struct里的变量必须用this访问且不能使用let定义。

小技巧：点击预览器上面的T标志，可以使用鼠标定位元素对应的代码。

数组操作

添加：

        arr.unshift(); //从开头增加，返回操作后数组长度

        arr.push(); //从结尾增加，返回操作后数组长度

删除：

        arr.shift(); //从开头删除，返回删除的项

        arr.poll(); //从结尾删除，返回删除的项

在指定位置增加/删除n个元素：

        arr.splce(起始位置， 删除个数， 新增元素1， 新增元素2， ...);

if语句

小括号结果不是布尔类型时，会类型转换为布尔值

if(0、空串、null和undefine)这几种均视为false

其他非空值（如对象）均视为true，如空数组和空对象：if( [] )、if( {} )

for...of

对象数组

不能直接使用对象输出，要使用JSON.stringify(对象);

interface Person {
  name : string,
  age : number
}
let arr : Person[] = [
  {name:"111",age: 1},
  {name:"222", age: 2}
]
console.log("", arr[1]); //[object Object]
for (let item of arr){
  console.log(JSON.stringify(item));
}

ForEach—— 渲染控制

注意使用ForEach时，item需要指定类型，index指不定都行，建议写上。

class 

类是用于 创建对象 模板。同时类声明也会引入一个 新类型，可定义其 实例属性、方法 和 构造函数。

一般定义更加复杂的类型时就不适用接口了而使用Class。

1、实例属性：在定义class时必须赋初值，或者使用可选链操作符 ?. 来定义属性

2、不同实例，将来需要有不同的字段初始值，就需要通过构造函数实现

构造函数使用关键字：constructor 来定义，在new对象时调用。如果参数多可是传一个对象，这样可以自由顺序赋值。

3、方法：方法的返回值可以写在函数名之后，用冒号隔开，即：这个函数的类型时返回值类型的。

4、静态属性、方法：一般用作工具属性方法，用类名直接调用。

interface IFood {
  name : string,
  price : number,
  desc : string
}

class Food {
  // 1、属性
  name : string
  price : number
  desc : string
  a ?: number

  // 2、构造
  constructor(mesObj:IFood) {
    this.name = mesObj.name
    this.price = mesObj.price
    this.desc = mesObj.desc
  }

  // 3、方法
  sayHi(name:string):void{
    console.log(this.name, name);
  }

  // 4、静态属性、方法
  static num:number
  static func(){}
}

5、继承extend和super关键字

类可以通过 继承 快速获取另外一个类的 字段 和 方法。只支持单一继承。

子类通过 super 可以访问父类的实例字段、实例方法和构造函数。

super.属性

super.方法

super(1, 2)  //调用父类构造

6、instanceof 类型检测

实例对象 instanceof 类型

typeof 表达式 ： 只能检测简单类型，对象类型结果均为Object。

7、修饰符

泛型

泛型的本质是​​类型参数化​​，通过将数据类型抽象为可在类、接口、方法中灵活指定的类型参数，实现编译时类型安全检测和代码复用。通俗一点就是：类型是可变的！

泛型函数

function 函数名<Type>(temp:Type):Type{
return temp
}
fn<string>('123')
fn<number>(1)

泛型约束

包含关系上类似于继承，所以使用extends，也就是这个泛型必须包含后面接口中的属性。

interface 接口{
属性:类型
}
function 函数<Type extends 接口>(){}
// 传入的类型必须要有 接口中的属性

// ---------------------------------------

interface ILength {
length: number
}
function fn<T extends ILength>(param: T) {
console.log('', param.length)
}

fn([])
fn("1")
interface A {
  id: number
  length: number
}
let a: A = {
  id: 1,
  length: 3
};
fn(a)

多个泛型参数

日常开发的时候，如果有需要，可以添加多个类型变量

function funcA<T, T2>(param1: T, param2: T2) {
console.log('参数 1', param1)
console.log('参数 2', param2)
}
funcA<string, number>('大白菜', 998)
funcA<string[], boolean[]>(['小老虎'], [false])

泛型接口

定义接口的时候，结合泛型定义，就是泛型类

interface 接口<Type>{
// 内部使用Type
}

interface IdFunc<Type> {
id: (value: Type) => Type
ids: () => Type[]
}
let obj: IdFunc<number> = {
id(value) { return value },
ids() { return [1, 3, 5] }
}

泛型类

定义类的时候，结合泛型定义，就是泛型类。

class 类名<Type>{
// 内部可以使用 Type
}

// 定义
class Person <T> {
id: T
constructor(id: T) {
this.id = id
}
getId(): T {
return this.id
}
}
// 使用
let p = new Person<number>(10)