目录

• 1.基础类型
• • 1.1 any
  • 1.2 number
  • 1.3 string
  • 1.4 boolean
  • 1.5数组类型
  • 1.6元组
  • 1.7枚举类型enum
  • 1.8 void
  • 1.9undefined和null
  • 1.10联合类型|
• 2.变量声明var
• 3.函数
• • 3.1声明function
  • 3.2调用
  • 3.3函数返回值return
  • 3.4函数参数
  • 3.5可选参数？
  • 3.6默认参数
  • 3.7剩余参数...
• 4.类
• • 4.1定义类class
  • 4.2创建类对象new
  • 4.3访问类属性方法.
  • 4.4类的继承extends
  • 4.5方法重写
  • 4.6访问修饰符
• 5.接口
• • 5.1定义接口interface
  • 5.2接口继承extends
  • 5.3类实现接口implements

1.基础类型

1.1 any

any 关键字表示任意数据类型，声明为该类型的变量可以赋予任意类型的值

var data: any;   // 声明data为any类型data = true;console.log(typeof data);      // booleandata = 'OpenHarmony';console.log(typeof data);      // stringdata = 100;console.log(typeof data);      // numberdata = 10.5console.log(typeof data);      // number

1.2 number

number 关键字来表示数字类型：整数+浮点数

data = 3.14;console.log(typeof data)      // numberdata = 0b10001;console.log(typeof data)      // number

1.3 string

字符串类型，使用单引号（'）或双引号（"）来表示字符串类型，也可以使用反引号（`）来定义多行文本和内嵌表达式

var data: string;data = "Hello, OpenHarmony";data = 'Hello, OpenHarmony';data = `Hello, ${data}`console.log(data)      // Hello, Hello, OpenHarmony

1.4 boolean

true 和 false无引号

var data: boolean = false;data = true;data = false;

1.5数组类型

没有提供专门的关键字来表示数组类型，声明一个数组可以使用元素类型后边加**[]**或者数组泛型的方式

var scores: number[] = [90, 88]; // 声明一个number数组var names: string[] = ["张三", "李四"];  // 声明一个string数组var address: Array = ["Beijing", "Tianjin"];  // 声明一个string数组console.log(names[0])     // 访问数组console.log(scores[0].toString())// 访问数组console.log(address[0])   // 访问数组for(var i = 0; i < address.length; i++) {      // 遍历数组  console.log(address[i])}for(var index in address) {      // 遍历数组  console.log(address[index])}

1.6元组

元组来表示已知元素数量和类型的数组，元组内的各元素的类型不必相同，但是对应位置的类型必须一致

var user: [string, number, string]; // 定义一个元组user = ["张三", 18, 'Beijing'];      // 初始化元组，对应位置类型必须一致console.log(`姓名：${user[0]}`)      // 姓名：张三console.log(`年龄：${user[1]}`)      // 年龄：18console.log(`住址：${user[2]}`)      // 住址：Beijing

1.7枚举类型enum

enum 关键字表示枚举类型，枚举类型主要用于定义数值的集合

enum Color { // 定义一个枚举  Red,  Green,  Blue}var c: Color = Color.Blue; // 定义枚举类型console.log(c.toString()); // 2

1.8 void

void 关键字表示函数的返回类型为空，也就是函数没有返回值

function print(msg: string): void { // 函数没有返回值  console.log(msg)}

1.9undefined和null

undefined 关键字表示声明了一个变量但并没有赋值的情况
null 关键字表示一个对象没有初始化

1.10联合类型|

| 将一个变量设置成多种类型，赋值的时候可以根据设置的类型来赋值

var data: string | number; // 设置data为联合类型data = 'OpenHarmony';      // 正确data = 99;   // 正确data = true; // 编译报错，类型不匹配

2.变量声明var

声明变量的类型并赋值初始值，格式：
var [变量名] : [类型] = 值;
var osName:string = "OpenHarmony";
声明变量的类型但不赋值初始值，格式：
var [变量名] : [类型];

声明变量并赋值初始值，但不设置类型，格式：
var [变量名] = 值;
var osName = "OpenHarmony";
声明变量并没有设置类型和初始值，该类型可以是任意类型，默认值为 undefined，格式：
var [变量名];
var osName;

TS强类型，如果将不同的类型赋值给变量会编译错误
var count: number = "hello";

3.函数

3.1声明function

function关键字声明：function function_name() {}

function log(msg: string) { // 声明一个函数  console.log(msg);  // 代码块}

3.2调用

函数只有通过调用才可以执行函数内的代码

log("Hello, OpenHarmony");  // 调用函数

3.3函数返回值return

function function_name(): return_type {    return value; // return语句}

// 定义sayHi函数，该函数的返回类型为stringfunction sayHi():string {     return "Hello!" }function execute() {      // 定义execute函数    var msg = sayHi();    // 调用sayHi()函数    console.log(msg);     // 打印sayHi()函数的返回值}execute();  // 调用execute()函数

3.4函数参数

function func_name(参数1 :数据类型1, 参数2 :数据类型2) {}

function add(x: number, y: number): number { // 定义add函数，该函数返回类型为nubmer, 接收两个number类型的参数x    return x + y;}console.log(add(1,2))   // 3

3.5可选参数？

如果函数定义了参数则必须传递这些参数否则报错，如果不想传递这些参数，可以添加 ?
function func_name(参数1 :数据类型1, 参数2？ :数据类型2) {}

理解：不确定个数的变量相加

function add(x: number, y?: number) {  if (y) {    return x + y;  } else {    return x;  }}console.log(add(10).toString());     // 10console.log(add(10, 10).toString()); // 20

如果参数不全是可选参数，那么可选参数的位置必须放在最后

3.6默认参数

如果不想传递参数除了使用可选参数外，也可以使用默认参数，当不传入该参数时则使用默认值

function func_name(参数1 :数据类型1, 参数2 :数据类型2= 默认值 {}

 // 设置x和y的默认值function add(x: number = 20, y: number = 50) {  return x + y;}console.log(add(10).toString());// 60console.log(add(10, 10).toString());   // 20

3.7剩余参数…

不确定要向函数传递多个参数的情况下，可以使用剩余参数，剩余参数前边以 … 为前缀数据类型为数组的形式提供function func_name(参数1: 数据类型1, 参数2: 数据类型2, ...参数: 数据类型[]) {}

function add(param1: number, param2: number, ...params: number[]) {   var result = param1 + param2;  // 遍历剩余参数  for(var i = 0; i < params.length; i++) {     result += params[i];  }  return result;}console.log(add(1, 2, 3, 4, 5).toString()); // 15

4.类

4.1定义类class

class class_name {}

class Person {  name: string;  age: number;  constructor(name: string, age: number) {    this.name = name;    this.age = age;  }  info(): string {    return "name: " + this.name + ", age: " + this.age;  }}

4.2创建类对象new

var 对象名 = new 类名([ args ])

// 创建一个Person对象var person = new Person('harmony', 10); 

4.3访问类属性方法.

对象.属性名 // 访问属性
对象.方法名() // 访问方法

var person = new Person('harmony', 10); // 创建一个personconsole.log(person.name); // harmonyconsole.log(person.age.toString());   // 10console.log(person.info());      // name: harmony, age: 10

4.4类的继承extends

class 子类名 extends 父类名{}

4.5方法重写

子类可以重写父类的方法，在重写父类方法的时候也可以使用 super 关键字调用父类的方法

class Zhangsan extends Person { // 重写父类方法  info(): string {      console.log(super.info());    // 调用父类方法    return "Hello, " + this.name;// 重新实现info方法  }}

4.6访问修饰符

public（默认）：公有，可以在任何地方被访问。

protected：受保护，可以被其自身以及其子类访问。

private：私有，只能被其定义所在的类访问。

5.接口

接口是一系列抽象方法的声明，接口定义后需要具体的类实现

5.1定义接口interface

interface 接口名 {抽象方法}

interface IPerson { // 定义一个接口  name: string;     // 定义接口的一个属性  say: () => string;// 定义接口的一个方法}var person: IPerson = {    // 创建一个接口的实例  name: "OpenHarmony",     // 设置属性值  say: () => {      // 实现接口方法    return "Hello, " + person.name;  }}console.log(person.name);  // OpenHarmonyconsole.log(person.say()); // Hello, OpenHarmony

5.2接口继承extends

接口可以使用 extends 关键字继承其它接口来扩展自己，接口既支持单继承又支持多继承，多继承时接口间使用逗号 , 分隔
单继承：interface 子接口 extends 父接口 {}
多继承：interface 子接口 extends 父接口1,父接口2,父接口3…… {}

5.3类实现接口implements

类可以使用 implements 关键字实现一个接口，一个类实现接口后必须声明和实现接口的所有属性和方法

interface IPerson {   // 定义一个接口  name: string;// 定义接口的属性  say: () => string;  // 定义接口的方法}class Person implements IPerson {   // 类型实现接口  name: string;// 必须声明接口属性  constructor(name: string) {// 在构造方法对属性初始化    this.name = name;  }  say(): string {     // 实现接口的方法    return `Hello, I'm ${this.name}`;  }}class Teacher implements IPerson {  // 类型实现接口  constructor(public name: string) {// 声明接口属性简化方式  }  say(): string {     // 实现接口的方法    return `Hello, I'm ${this.name}`;  }}var person: IPerson = new Person("王大爷"); // 创建IPerson实现类console.log(person.say());   // Hello, I'm 王大爷console.log(person.name);    // 王大爷person = new Teacher("王老师");      // 创建IPerson实现类console.log(person.say());   // Hello, I'm 王老师console.log(person.name);    // 王老师

杭州女装网