526互联

HarmonyOS学习（一） TypeScript 基础语法

发布时间 2023-12-13 15:27:43作者: leoxuan

HarmonyOS学习（一） TypeScript 基础语法

一、基础类型

1、布尔型 boolean

let isEnd:boolean = false;

2、数字 number

//十进制 2023
let decLiteral:number = 2023;

//二进制 2023
let binaryLiteral:number = 0b11111100111; 

//八进制 2023
let octalLiteral:number = 0o3747;

//十六进制 2023
let hexLiteral:number = 0x7e7;

//输出结果
console.log('decLiteral is ' + decLiteral);
console.log('binaryLiteralis ' + binaryLiteral);
console.log('octalLiteralis ' + octalLiteral);
console.log('hexLiteralis ' + hexLiteral);

3、字符串 string

使用双引号或单引号表示字符串

let name:string = "leo";
name = "jack";

4、数组 array

两种声明方式，第一种在元素类型后面跟上 [] ，表示由此类型元素组成一个数组；第二种方式是使用数组泛型，Array<元素类型>

let array1:number[] = [1, 2, 3];
let arrsy2:Array<string> = ["one", "two", "three"];

5、元组

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

let x:[string, number];
x = ["leo", 10]; //OK 
x = [10, "leo"]; //Error

6、枚举 enum

enum Color {Red, Yellow, Green};
let light:Color = Color.Red;

7、unknown

在一些编程阶段，还不清楚数据类型的变量指定的一个类型。

let notSure:unknown = 4;
notSure = "my name is jack";
notSure = true;

8、无返回值 void

function Test(): void{
   console.log("do some thing“);
}

9、null 和 undefined

let u: undefined = undefined;
let n: null = null;

10、联合类型 Union Types

表示取值可以为多种类型中的一种。

let weekDay: string | number;
weekDay = "monday";
weekDay = 1;

 

二、条件语句

1、if 语句；if...else 语句；if...else if...else语句

let age:number = 18;
//if 语句
if(age < 18) {
  console.log("未成年");
}

//if...else 语句
if(age < 18) {
  console.log("未成年");
}else {
   console.log("成年");
}

//if...else if...else 语句
if(age < 18) {
  console.log("未成年");
}else if(age > 17 & age < 46) {
   console.log("青年");
}else if(age > 45 & age < 70){
    console.log("中年");
}else{
    console.log("老年");
}

 

2、switch case语句

var grade:string = 'A'
switch(grade){
  case 'A':{
    console.log("优");
  }
  case 'B':{
    console.log("良");
  }
  case 'C':{
    console.log("及格");
  }
  default:{
    console.log("不及格");
  }
}

 

三、函数  function

1、函数的定义

函数是一组一起执行一个任务的语句，函数声明要告诉编译器函数的名称、返回类型和参数。

//有名函数getSum，求两个数的和
//参数有数字 a 和 b
//返回值类型为 number
function getSum(a: number, b: number): number{
  return a + b;
}

//匿名函数，给变量设置为number类型
var getSum  = function(a: number, b: number): number{
  return a + b;
}

2、函数的可选参数

可以在参数名旁使用（?）实现可选参数的功能

function getSum(a: number, b: number, c?: number): number{
 if(c) {
   return a + b + c;
 }else {
   return a + b;
 }  
}

3、函数的剩余参数

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

function getEmployeeName(firstName:string, ...restOfName:string[]){
  return firstName + ' ' + restOfName.join(' ');
}

let employeeName1 = getEmployeeName("Jack");
let employeeName2 = getEmployeeName("Jack", "Tom", "Sandy");
function getSum(a: number, b: number, ...c: number[]): number {
 if(c) {   
   let cSum:number = 0;
   for(let i = 0; i < c.length; i++) {
       cSum += c[i];
   }     
   return a + b + cSum;
 }else {
   return a + b;
 }  
}

console.log(getSum(1, 2, 3, 4, 5));

3、箭头函数

匿名函数的简写语法，用于函数表达式，省略了function关键字。

var getSum  = (a: number, b: number) => {
  return a + b;
}

 

四、类 class

1、类的属性，构造函数（方法），方法

TypeScript 基于类的面向对象编程，定义类的关键字是 class ，后面紧跟类的名称。类中包含所创建对象的共同的属性和方法。

class Person {  
  //属性
  private name: string
  private age: number
  
  //构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }   

  //方法
  public getPersonInfo(): string {
    return "My name is " + this.name + " and age is " + this.age;
  }
}

let mingming = new Person("LiMing", 16);
console.log(mingming.getPersonInfo());

 2、类的继承

继承就是子类继承父类的属性和方法，使子类具有和父类相同的行为。 使用关键字 extends 实现

class Student extends Person {
    private score: number;
    
    constructor(name: string, age: number, score: number){
        super(name, age);
        this.score = score;
    }

    public getSutdent(): string{
        return this.getPersonInfo() + " and score is " + this.score;
    }
}

let mingming = new Student("LiMing", 16, 20);
console.log(mingming.getPersonInfo());
console.log(mingming.getSutdent());

 

五、模块 module

根据业务需求和功能划分，将代码拆分成多个文件，这即为模块。模块可以相互加载，使用特殊指令 export 和 import 来交换功能，从另一个模块调用一个模块的功能。

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

//导出这个 类
export class Person {  
  //属性
  private name: string
  private age: number
  
  //构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }   

  //方法
  public getPersonInfo(): string {
    return "My name is " + this.name + " and age is " + this.age;
  }
}
//导入这个类
import { Person } from '../model/bean/Person'

六、迭代器 

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

for..of 语句

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

for...in 语句

let someArray = [1, "string", false];
for(let i in someArray) {
  console.log(i);  //"0", "1", "2"
}

 

在线学习文档： TypeScript 中文网

在线编译平台： TypeScript PlayGround