编程语言介绍

ArkTS是HarmonyOS主力应用开发语言。它在TypeScript (简称TS)的基础上，匹配ArkUI框架，扩展了声明式UI、状态管理等相应的能力，让开发者以更简洁、更自然的方式开发跨端应用。

• JavaScript是一种属于网络的高级脚本语言，已经被广泛用于Web应用开发，常用来为网页添加各式各样的- 动态功能，为用户提供更流畅美观的浏览效果。
• TypeScript 是 JavaScript 的一个超集，它扩展了 JavaScript 的语法，通过在JavaScript的基础上添加静态类型定义构建而成，是一个开源的编程语言。
• ArkTS兼容TypeScript语言，拓展了声明式UI、状态管理、并发任务等能力。
  由此可知，TypeScript是JavaScript的超集，ArkTS则是TypeScript的超集，他们的关系如下图所示：

关系图

ArkTS

• 声明式U
• 组件化
• 状态管理

JavaScript是一种属于网络的高级脚本语言，已经被广泛用于Web应用开发，常用来为网页添加各式各样的动态功能，为用户提供更流畅美观的浏览效果。
TypeScript 是JavaScript 的一个超集，它扩展了 JavaScript 的语法通过在JavaScript的基础上添加静态类型定义构建而成，是一个开源的编程语言。
ArkTS基于TypeScript语言，拓展了声明式UI、状态管理、并发任务等能力。
本节课介绍TypeScript的基础语法，下一节课介绍ArkTS声明式的相关语法

const 常量声明
var 变量声明
let 变量声明

一. 语法介绍： boolean

1. 布尔值 boolean(true,false)
   let isDone:boolean = false;
2. 数字 number
   TS里面，所有的数字都是浮点数，浮点数类型是number，支持十进制，二进制，八进制，十六进制。

let decLiteral:number = 2023;
let binaryLiteral:number = 0b11111100111;
let octalLiteral:number = 0o3747;
let hexLiteral:number = 0x7e7;

3. 字符串 string，使用单引号(')或双引号(")

let name: string = "Tom";
name = 'Mick';

4. 数组

TypeScript有两种表示方式：第一种在元素后面添加[]; 第二种方式，使用数组泛型,Array<元素类型>

let list1 :number[] = [1,3,5];
let list2 :Array<number> = [1,3,5];

5. 元组

元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。

let x:[string, number];
x = ['hello', 10]; // OK: 和元组定义的顺序是一致的
x = [10, 'hello']; // Error，和定义的顺序不一致，所以报错。

6. 枚举: 对javaScript标准数据类型的一个补充，使用枚举类型可以为一组数值赋予友好的名字。

enum Color {Red, Green, Blue};
let c:Color = Color.Green;

7. unknown, 可以复制其很多类型。any也是同样的效果。
   有时候，想要为那些编程阶段还不清楚的变量指定一个类型，可以使用unknown类型来标记这些变量。

let notSure :unknown = 4;
notSure = 'maybe a string';
notSure = false;

8. void（空的表示）
   当一个函数没有返回值时，通常会见到其返回值类型是void

function test(): void {
    console.log('this function is void');
}

9、null 和 undefined（空的表示）
TypeScript里，undefined和null两者各自有自己的类型分别叫做undefined和null。

let u: undefined = undefined;
let n: null = null;
let b :any = '123'
b = true;
b = 111

10、联合类型，用的比较多。
联合类型 (Union Types) 表示取值可以为多种类型中的一种。

let myFavoriteNumber: string | number; // string或number。
myFavoriteNumber = 'seven'.
myFavoriteNumber = 7;

11. 其他类型
    函数Function
    大数字的表示：bigint

let bigInt : bigint = 100n;
let sym: symbol = Symbol('key')
// 对象声明
let obj: object = {name: "Tom"}

二. 条件语句

if...else if...else if....else 语句
switch-case:

三. 函数的定义。

函数是一组一起执行一个任务的语句，函数声明要告诉编译器函数的名称、返回类型和参数。
TypeScript可以创建有名字的函数和匿名函数，其创建方法如下：

// 有名函数: 给变量设置为number类型
function add(x: number, y: number): number {
    return x + y;
}
// 匿名函数: 给变量设置为number类型
let myAdd = function (x: number, y: number): number {
    return x + y;
}

3.1 函数的可选参数
在参数名旁边，使用(?)实现可选参数的功能，比如像让lastName可选：

function buildName(firstName: string, lastName?: string) {
    if(lastName) {
        return firstName + "  " + lastName;
    } else {
        return firstName;
    }
}
let result1 = buildName('bob');
let result1 = buildName('bob', "Adams");

3.2 函数的剩余参数：

剩余参数会被当做个数不限的可选参数。 可以一个都没有，同样也可以有任意个。
可以使用省略号(...) 进行定义:

function getEmployeeName(firstName: string, ...restOfName: string[]) {
    return firstName + ' ' + restOfName.join(' ');
}
let employeeName1 = getEmployeeName('Tom');
let employeeName2 = getEmployeeName('Tom', 'Sandy', 'Lucas', 'Mick');

3.3 箭头函数
ES6版本的TypeScript提供了一个箭头函数，它是定义匿名函数的简写语法，用于函数表达式，它省略了function关键字。箭头函数的定义如下，其函数是一个语句块:
([param1, parma2,...param n]) => {
// 代码块
}
其中，括号内是函数的入参，可以有0到多个参数，箭头后是函数的代码块。我们可以将这个箭头函数赋值给一个变量，如下所示:
let arrowFun = ( [param1, parma2,...param n])=> {
// 代码块
}
调用：arrowFun (param1, param2, ... paramN)

箭头函数示例；

function testNumber(num: number) {
    if(num>0){
        console.log(num+ "是正数");
    }else if(num<0>){
        console.log(num+ "是负数");
    } else {
        console.log(num+ "是0");
    }
}
let arrowFun = (num: number) => {
    if(num>0){
        console.log(num+ "是正数");
    }else if(num<0>){
        console.log(num+ "是负数");
    } else {
        console.log(num+ "是0");
    }
}
testNumber(1); //输出日志：1 是正数
arrowFun(-1); //输出日志：-1 是负数

4. 自运行函数
   ((a:int, b:int)): int => {
   return a+b;
   }(1, 3)

四. 类的定义。

TypeScript支持基于类的面向对象的编程方式，定义类的关键字为 class，后面紧跟类名。类描述了所创建的对象共同的属性和方法。
TypeScript支持基于类的面向对象的编程方式，定义类的关键字为class，后面紧跟类名称。
类描述了所创建的对象共同的属性和方法。

class Person {
    private name: string
    private age：number
    constructor(name:string, age:number) {
        this.name = name;
        this.number = number;
    }
    public getPersonInfo():string {
       return `My name is ${this.name} and age is ${this.age}`;
    }
}
let person1 = new Person('Lili', 18);
const p2 = new Person('Lili');
person1.getPersonInfo();

4.1 继承 extends

继承就是子类继承父类的特征和行为，使得子类具有父类相同的行为。
TypeScript中允许使用继承来扩展现有的类，对应的关键字为extends。
TS支持多继承，可以extends多个类。
在TypeScript中，有public、private、protected修饰符

class Employee extends Person {
    private department:string;
    constructor(name:string, age:number, department:string) {
        super(name,age);
        this.department = department;
    }
    public getEmployeeInfo(): string {
         return this.getPersonInfo() + ` and work in ${this.department}`;
    }
}

let person2 = new Employee('Tom', 28, 'HuaWei');
person2.getPersonInfo();
person2.getEmployeeInfo();

五. 模块。[ export 和 import ]

随着应用越来越大，通常要将代码拆分成多个文件，即所谓的模块 (module) 。
模块可以相互加载并可以使用特殊的指令 export 和 import 来交换功能，从另一个模块调用一个模块的函数。

两个模块之间的关系是通过在文件级别上使用 import 和 export 建立的。模块里面的变量、函数和类等在模块外部是不可见的，除非明确地使用 export 导出它们。
类似地，我们必须通过 import 导入其他模块导出的变量、函数、类等。

导出：任何声明（比如变量，函数，类，类型别名或接口）都能够通过添加export关键字来导出
导入：模块的导入操作与导出一样简单。 可以使用以下 import形式之一来导入其它模块中的导出内容。

export class NewsData {
    title: string;
    content: string;
    constructor(title: string, content: string) {
        this.title = title.
        this.content = content;
}}

导入类：
import {NewsData} from '../common/bean/NewsData';

六. 迭代器。for..of

当一个对象实现了Symbol.iterator属性时，我们认为它是可迭代的。一些内置的类型如Array，Map,Set，String，Int32Array，Uint32Array等都具有可迭代性。

for...of语句。

let someArray = [1, "string", false];
for(let entry of someArray) {
    console.log(entry); // 1, "string", false
}

for..of vs for..in语句。

let list =[4,5,6];
for(let in list) { // 对数组的下标（键）进行遍历
    console.log(i); // 0,1,2 打印下标索引。
}
for(let i of list) { // 对数组的元素（值）进行遍历。
    console.log(i); // 4,5,6
}

七. 抽象类

不能被实例化，但是可以被继承。
abstract class Phone {

}