快速入门
学习TypeScript 对于Harmony0s,应用开发至关重要。在Harmonyos 中，主力编程语言为 ArKTS，它是基于 TypeScript 的一种语言，其通过与ArkUI 框架的匹配，拓展了声明式UI和状态管理等能力，使开发者能够以更简洁自然的方式开发跨应用。Typescript 本身是 Javaseript 的超集，通过引入静态类型定义等特性，提高了代码的可维护性和可读性，有助于在编码阶段检测潜在错误，提高开发效率另外，学习Typeseript还为处理Harmenyos 应用中的 UI 和应用状态提供了更强大的支持，在并发任务方面也有相应的扩展。为更好地对HarmonyOs进行开发需要掌握Typescript语言，本接我们重点介绍TypeScript 语言。
基本类型使用：
```
//定义boolean类型变量
let isOff= true
let isOn =false
console.log(isOff)
console.log(isOn)
//定义数字类型的变量
let a : number =12
let b : number =3.1415926
//二进制
let c : number =0b1100
console.log(c)
//定义字符串类型/数组类型
let aStr = "hello"
//数组类型
//第一种
let arr1 : number[]=[1,2,3,4,5,6,7]
console.log(arr1)
console.log(arr1[0])
//第二种
let arr2: Array<string>=["a","b","c"]
console.log(arr2)
//对数据组最后进行添加操作
arr2.push("hello")
arr2.push("he")
console.log(arr2)
//删除数组最后面一个数据
arr2.pop()
console.log(arr2)
//在数组任意位置进行添加或者是删除
//arr2.splice("下标","0=添加，1=删除","内容")
arr2.splice(2,0,"native")
console.log(arr2)
```
元组的使用：
```
//元组
let t1:[string,number]
t1 = ['hello',100]
//需要按照let t1:[string,number] 设定的内容进行添加，否则报错
console.log(t1)
console.log(t1[0])
//枚举
//enum 类型是对Javascript 标准数据类型的一个补充，
// 使用枚举类型可以为一组数值赋予友好的名字。例如我们这里定义Color为Red，
// Green和Blue，到时候就可以使用 Coler.Green 来定义颜色。
enum sex{
MAIL="男",
NU="女",
}
let a:sex=sex.MAIL
let b:sex=sex.NU
console.log(a)
console.log(b)
```
Unknown
enum 类型是对Javascript 标准数据类型的一个补充，使用枚举类型可以为一组数值赋予友好的名字。例如我们这里定义Color为Red，Green和Blue，到时候就可以使用 color.Green 来定义颜色。
```
//定义未知类型
//之后可以进行任意类型赋值
let show : unknown;
show=4;
show="hello";
show=false;
//viod ： 函数没有返回值
function myFunc(): void{
console.log("执行函数，没有返回值")
}
myFunc()
//Null undefined
// console.log(efg)
let n =null
let m =undefined
//联合类型
//定义变量可以是字符串也可以是数值。
let myF : string | number = 100
// let myF : string | number = "hello"
```
TS条件语句
if语句
```
//最简单的if语句
let age : number =60
if (age >= 18 && age<=20){
console.log("已经成年")
}else if(age>=18 && age<=60){
console.log("中年")
}else{
console.log("老年")
}
```
使用swith进行判断（多条件的等于判断）
```
let gender= "MAIL"
switch(gender){
case "MAIL" :{
console.log("男")
break;
}
case "FEMAIL" :{
console.log("女")
break;
}
default:{
console.log("不能确定")
break;
}
}
```
循环语句
```
//循环
//for循环
//第一种
// let i:number;
// for( i = 1;i<=10 ;i++ ){
// console.log(i)
// }
//第二种
// let j :any; //Any为任意类型
// let nums : Array<number>=[10,11,12]
// for (j in nums){
// console.log(nums[j])
// }
```
函数
函数
是一组一起执行一个任务的语句，函数声明要告诉编译器函数的名称、返回类型和参数。Typescript可以创建有名字的函数和匿名函数
```
//普通函数
//定义一个普通函数 :number返回值
function add(x:number,y:number):number{
return x + y
}
//函数调用
let result:number =add(10,29)
console.log(result)
//匿名函数(老版本)
let add_func =function (x:number,y:number){
return x + y
}
console.log(add_func(10,20))
//定义一个可选参数
function text1(x:number,name?:string):void{
console.log(x,name)
}
text1(10)
function text2(x:number,name?:string):void{
if(name){
console.log(x,name)
}else{
console.log(x)
}
}
text2(10)
//剩余函数
function text3(x:number,...other:Array<string>):void{
console.log(x)
if(other.length == 0){
console.log("剩余参数没有传")
}else{
let i :any;
for (i in other){
console.log(other[i])
}
}
}
text3(20)
```
箭头函数
ES6版本的TypeScript提供了一个箭头函数，它是定义匿名函数的简写语法，用于函数表达式，它省略了函数关键字。箭头函数的定义如下，其函数是一个语句块
其中，括号内是函数的入参，可以有0到多个参数，头后是函数的代码块。我们可以将这个箭头函数赋值给一个变量，如下所示
```
//箭头函数
let let1=(x:number,y:number)=>{
return x + y
}
console.log(let1(1,2))
```
类
Typescript 支持基于类的面向对象的编程方式，定义类的关键字为class，后面紧跟类名。类描述了所创建的对象共同的属性和方法。
```
//类实例
//定义一个类
//private 私有属性
//public 公有属性
class Person{
private name:string
private age :number
//定义构造函数（方法）
constructor(name:string,age:number){
this.name = name
this.age =age
}
//公共成员函数
public getPersonInfo() :string{
return `我的名字是：${this.name} ,年龄 ${this.age}`
}
}
//构造Person类的实例
//使用new方法传入
let p=new Person ("张三",27)
console.log(p.getPersonInfo())
```
继承
继承就是子类继承父类的特征和行为，使得子类具有父类相同的行为。Typescript中允许使用继承来扩展现有的类，对应的关键字为extends。如下案例中，我们定义employee 是继承于person的employee l person 新增了一个属性 department,我们可以这样去定义它的构造方法，通过super 关键字实际上就调用了person 中的构造方法，初始化name和age，并在构造方法中初始化好了department，employee有个公有方法，getemployeeinfo 获取雇员的信息，其中调用 getpersoninfo 来获取雇员的姓名、年龄信息
```
//类实例
//定义一个类
//private 私有属性
//public 公有属性
//protected 表示在一个包里面都可以使用
class Person{
private name:string
private age :number
//定义构造函数（方法）
constructor(name:string,age:number){
this.name = name
this.age =age
}
//公共成员函数
public getPersonInfo() :string{
return `我的名字是：${this.name} ,年龄 ${this.age}`
}
}
//构造Person类的实例
//使用new方法传入
let p=new Person ("张三",27)
console.log(p.getPersonInfo())
//继承
//定义一个类继承Person
//extends
class Employee extends Person {
private department :string;
constructor(name:string,age:number,department:string){
//super() 调用父类的构造函数
super(name,age)
this.department=department
//department 子类新定义的
}
//定义属于子类自己的构造函数
public getEmpInfo(): string{
return this.getPersonInfo()+`,我工作的部门是：${this.department}`
}
}
let emp=new Employee("王五",22,"行政")
console.log(emp.getEmpInfo())
console.log(emp.getPersonInfo())
```
模块
随着应用越来越大，通常要将代码拆分成多个文件，即所谓的模块(module)。模块可以相互加载，并可以使用特殊的指令export和import来换功能，从另一个模块调用一个模块的函数。
两个模块之间的关系是通过在文件级别上使用import和export建立的。模块里面的变量、函数和类等在模块外部是不可见的，除非明确地使用export导出它们。类似地，我们必须通过 import 导入其他模块导出的变量、函数、类等。
首先在src文件夹下新建
在终端编译TS命令
//编译ts文件命令：tsc "文件名"
完成后效果：
编译完成之后，在终端就可以使用node执行编译后的js文件
//编译ts文件命令：node "文件名"
可迭代对象
一个对象实现了 Symbol.iterator属性时，我们认为它是可迭代的。一些内置的类型如Array，Map, Set，string，Int32Array，Uint32Array等都具有可迭代性。
```
//可迭代性 ，可迭代对象
let str1:any = "adadadada"
// console.log(str1[Symbol.iterator])
// for...of 遍历可迭代对象中每一个元素 i 代表其中一个元素
// for...in 遍历可迭代对象中每一个元素 i 代表其中一个元素的下标
for (let i of str1){
console.log(i)
}
for (let j in str1){
console.log(j)
}
//map类型 ：每个元素都有两个元素组成：key，value
let map1=new Map<string,number>()
map1.set('a',1)
map1.set('name',12)
map1.set('age',10)
for (let k of map1){
console.log(k[1])
}
```
