TypeScript入门

二,TypeScript入门

1.什么是TypeScript

TypeScript（简称 TS）是微软公司开发的一种基于 JavaScript （简称 JS）语言的编程语言。它的目的并不是创造一种全新语言，而是增强 JavaScript 的功能，使其更适合多人合作的企业级项目。TypeScript 可以看成是 JavaScript 的超集（superset），即它继承了后者的全部特性，并在此基础上增加了静态类型检查和其他一些特性。

TypeScript 特点
静态类型检查：TypeScript在编译阶段就能够发现并提示潜在的代码错误，使开发者在编码过程中更加高效、安全和可靠。
强类型编程语言：TypeScript是拥有类型语法的JavaScript，适合大型应用和团队开发。
功能更强大，生态更健全：TypeScript是JavaScript的超集，继承了后者的全部特性，并在此基础上增加了静态类型检查和其他一些特性。
可以被编译成纯JavaScript代码，并可以在任何支持JavaScript的运行环境中运行。
属于渐进式，边学边写：TypeScript有很多新概念，如类型、泛型、枚举等，使得学习曲线较陡峭。
JavaScript 与 TypeScript 的区别
TypeScript 是 JavaScript 的超集，扩展了 JavaScript 的语法，因此现有的 JavaScript 代码可与 TypeScript 一起工作无需任何修改，TypeScript 通过类型注解提供编译时的静态类型检查。

TypeScript 可处理已有的 JavaScript 代码，并只对其中的 TypeScript 代码进行编译。

TypeScript语法
TypeScript的语法主要扩展了JavaScript的语法，增强了其功能。以下是一些主要的语法概念：

模块：在TypeScript中，模块化是一种重要的编程方式，有助于将大型程序分解为更小的部分。
函数：函数是TypeScript中的基本单位，用于封装可重用的代码段。
变量：变量是用于存储数据的容器，其类型可以在编译时确定。
语句和注释：语句是执行操作的指令，注释则用于向代码中添加解释或说明。
类和对象：TypeScript是一种面向对象的编程语言，支持类和对象的使用。类是一种用户定义的数据类型，它具有属性和方法。对象则是类的实例。
方法：方法是类的一部分，它定义了可以由对象执行的操作。

2.为什么学习ts

因为ArkTS语言是围绕应用开发在 TypeScript （简称TS）生态基础上做了进一步扩展，继承了TS的所有特性，是TS的超集，所以要学ArkTS语言，前提是得学习TypeScript语言。

使用 TypeScript 的主要原因是提高代码质量和可维护性。静态类型系统可以帮助开发者在编译时捕获错误，减少运行时的错误。此外，TypeScript 还提供了更好的代码组织和重构能力，以及更强大的工具支持。

3.数据类型

官方地址:基础类型 · TypeScript中文网 · TypeScript——JavaScript的超集 (tslang.cn)

https://www.tslang.cn/docs/handbook/basic-types.html

ts相对于js有更强的类型声明:基本数据类型如下:

布尔值

最基本的数据类型就是简单的true/false值，在JavaScript和TypeScript里叫做boolean（其它语言中也一样）。

let isDone: boolean = false;

数字

和JavaScript一样，TypeScript里的所有数字都是浮点数。 这些浮点数的类型是 number。 除了支持十进制和十六进制字面量，TypeScript还支持ECMAScript 2015中引入的二进制和八进制字面量。

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;//16进制
let binaryLiteral: number = 0b1010;//2进制
let octalLiteral: number = 0o744;//八进制

字符串

JavaScript程序的另一项基本操作是处理网页或服务器端的文本数据。 像其它语言里一样，我们使用 string表示文本数据类型。 和JavaScript一样，可以使用双引号（ "）或单引号（'）表示字符串。

let name: string = "bob";
name = "smith";

你还可以使用模版字符串，它可以定义多行文本和内嵌表达式。 这种字符串是被反引号包围（ ```），并且以${ expr }这种形式嵌入表达式

let name: string = `Gene`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ name }.

I'll be ${ age + 1 } years old next month.`;

这与下面定义sentence的方式效果相同：

let sentence: string = "Hello, my name is " + name + ".\n\n" +
    "I'll be " + (age + 1) + " years old next month.";

Null 和 Undefined

TypeScript里，undefined和null两者各自有自己的类型分别叫做undefined和null。 和 void相似，它们的本身的类型用处不是很大：

// Not much else we can assign to these variables!
let u: undefined = undefined;
let n: null = null;

默认情况下null和undefined是所有类型的子类型。 就是说你可以把 null和undefined赋值给number类型的变量。

然而，当你指定了--strictNullChecks标记，null和undefined只能赋值给void和它们各自。 这能避免 很多常见的问题。 也许在某处你想传入一个 string或null或undefined，你可以使用联合类型string | null | undefined。 再次说明，稍后我们会介绍联合类型。

注意：我们鼓励尽可能地使用--strictNullChecks，但在本手册里我们假设这个标记是关闭的。

Any

有时候，我们会想要为那些在编程阶段还不清楚类型的变量指定一个类型。 这些值可能来自于动态的内容，比如来自用户输入或第三方代码库。 这种情况下，我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查。 那么我们可以使用 any类型来标记这些变量：

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

在对现有代码进行改写的时候，any类型是十分有用的，它允许你在编译时可选择地包含或移除类型检查。 你可能认为 Object有相似的作用，就像它在其它语言中那样。 但是 Object类型的变量只是允许你给它赋任意值 - 但是却不能够在它上面调用任意的方法，即便它真的有这些方法：

let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

当你只知道一部分数据的类型时，any类型也是有用的。 比如，你有一个数组，它包含了不同的类型的数据：

let list: any[] = [1, true, "free"];

list[1] = 100;

Object

object表示非原始类型，也就是除number，string，boolean，symbol，null或undefined之外的类型。

使用object类型，就可以更好的表示像Object.create这样的API。例如：

declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error

数组

TypeScript像JavaScript一样可以操作数组元素。 有两种方式可以定义数组。 第一种，可以在元素类型后面接上 []，表示由此类型元素组成的一个数组：

let list: number[] = [1, 2, 3];

第二种方式是使用数组泛型，Array<元素类型>：

let list: Array<number> = [1, 2, 3];

元组 Tuple

元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。 比如，你可以定义一对值分别为 string和number类型的元组。

// Declare a tuple type
let x: [string, number];
// Initialize it
x = ['hello', 10]; // OK
// Initialize it incorrectly
x = [10, 'hello']; // Error

当访问一个已知索引的元素，会得到正确的类型：

console.log(x[0].substr(1)); // OK
console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'

当访问一个越界的元素，会使用联合类型替代：

x[3] = 'world'; // OK, 字符串可以赋值给(string | number)类型

console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString

x[6] = true; // Error, 布尔不是(string | number)类型

联合类型是高级主题，我们会在以后的章节里讨论它。

枚举

enum类型是对JavaScript标准数据类型的一个补充。 像C#等其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。

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

默认情况下，从0开始为元素编号。 你也可以手动的指定成员的数值。 例如，我们将上面的例子改成从 1开始编号：

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

或者，全部都采用手动赋值：

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

枚举类型提供的一个便利是你可以由枚举的值得到它的名字。 例如，我们知道数值为2，但是不确定它映射到Color里的哪个名字，我们可以查找相应的名字：

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];

console.log(colorName);  // 显示'Green'因为上面代码里它的值是2

Void

某种程度上来说，void类型像是与any类型相反，它表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void：

function warnUser(): void {
    console.log("This is my warning message");
}

声明一个void类型的变量没有什么大用，因为你只能为它赋予undefined和null：

let unusable: void = undefined;

Never

never类型表示的是那些永不存在的值的类型。 例如， never类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型； 变量也可能是 never类型，当它们被永不为真的类型保护所约束时。

never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never。

下面是一些返回never类型的函数：

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}

// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}

// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

类型断言

有时候你会遇到这样的情况，你会比TypeScript更了解某个值的详细信息。 通常这会发生在你清楚地知道一个实体具有比它现有类型更确切的类型。

通过类型断言这种方式可以告诉编译器，“相信我，我知道自己在干什么”。 类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。 它没有运行时的影响，只是在编译阶段起作用。 TypeScript会假设你，程序员，已经进行了必须的检查。

类型断言有两种形式。 其一是“尖括号”语法：

let someValue: any = "this is a string";

let strLength: number = (<string>someValue).length;

另一个为as语法：

let someValue: any = "this is a string";

let strLength: number = (someValue as string).length;

两种形式是等价的。 至于使用哪个大多数情况下是凭个人喜好；然而，当你在TypeScript里使用JSX时，只有 as语法断言是被允许的。

4.变量声明

变量的声明有三种方式:var,let,const

var

var存在作用域的问题,对于函数和代码块无效等因此不建议使用

<script>
        function a(num) {
            if (num > 10) {
                var aa = 100;
            }
            console.log(aa);
        }
        a(11);//100
        a(9);//undefind

        function f() {
            var a = 10;
            return function g() {
                var b = a + 1;
                return b;
            }
        }

        var g = f();
        alert(g());
</script>

let

1.同级作用域不能声明多个相同变量

2.严格遵守块级作用域

//let声明变量的方式和var一样
let num1;
//let在相同作用域中不能多次声明同一变量
//let num1;

function a(num) {
    let num2=9;
    if (num > 10) {
        //在不同作用域可以多次声明
        let num2=10;
        let aa = 100;
    }
    //使用let时无法通过编译
    //console.log(aa);
}
//let声明的变量有块作用域的限制
//let声明的变量只可以在自己的大括号中使用
//作用域:出了大括号就不认识了
//console.log(num2);

const

与let声明相似，但是就像它的名字所表达的，它们被赋值后不能再改变。 换句话说，它们拥有与 let相同的作用域规则，但是不能对它们重新赋值。

//const声明变量和let一样,但是声明后无法再次赋值,相当于常量
const bum3=10;
// bum3=2;
//必须赋值
// const bm;

5.函数

1.无参函数

• 函数可以不写返回值
• 函数可以在函数名后添加void关键字,添加void关键字之后就不能有return语句了
• 函数可以直接使用return语句返回值
• 函数可以指定返回值类型,只需要在函数名后添加指定类型就可以了,但是返回值必须符合返回值类型

//无参函数
function aa(){
    console.log("这是无参函数")
}
aa();
//完整的无返回值的函数  void代表没有返回值
function aaa():void{
    console.log("这是无参函数");
    //加上返回值无法通过编译
    // return 123;
}
function aa2(){
    console.log("这是无参函数");
    return 2;
}
let aa3=aa2();
//无参有返回值
function aaa3():string{
    //必须添加return语句,类型错误无法通过编译
    return "你好";
}

//匿名函数
let aa4=function(){
    console.log("匿名");
}
aa4();

2.有参函数

参数必须声明数据类型

调用函数时必须按照数据类型写入数据

有多个参数时可以用逗号隔开

function aa6(str:string){
    console.log(str);
}
aa6("你好");
//调用函数时必须按照数据类型写入数据
//aa6(123);
function aa7(a:number,b:number){
    return a-b;
}
let sum=aa7(1,2);

3.特殊参数

1)可选参数

使用?来代替可选的参数

//可选参数
function aa8(a:string,b?:string){
    console.log( a+","+b);
}
aa8("你好","世界");//你好,世界
aa8("你好");//你好,undefined

2)剩余参数

当不确定有多少个参数时可以使用 … 来代替

// 未知数量的参数
function aa9(str:string,...s:string[]):void{
    let st=str+s.join();
    console.log(st);
}
aa9("你好:","张三","李四","王五");

6.类

TypeScript 是面向对象的 JavaScript。

类描述了所创建的对象共同的属性和方法。

TypeScript 支持面向对象的所有特性，比如 类、接口等。

TypeScript 类定义方式如下：

class class_name { 
    // 类作用域
}

定义类的关键字为 class，后面紧跟类名，类可以包含以下几个模块（类的数据成员）：

• 字段 − 字段是类里面声明的变量。字段表示对象的有关数据。
• 构造函数 − 类实例化时调用，可以为类的对象分配内存。
• 方法 − 方法为对象要执行的操作。

//创建学生类
class student {
    //类成员:属性
    name: string;
    //构造函数
    constructor(name: string) {
        this.name = name;
    }
    //方法
    getName():string{
        return this.name;
    }
}
//通过new关键字实例化(创建对象)
let stu=new student("张三");
//通过对象名.调用属性和方法
let names=stu.getName();
console.log("我的名字是"+names);

访问修饰符

public共有的

protected受保护的

private私有的