ts总结

扬光
185 阅读8分钟

ts基础类型

  1. 任意类型：any，相当于跟随用户输入的自动判型
  2. 数字类型：number
  3. 字符串类型：string
  4. 布尔类型：boolean
  5. 数组类型：声明一个数字类型数组①let arr: number[] = [1,2] ②let arr: Array = [1,2]
  6. 元组：各个数据元素不需要一样(区别于数组的一点)，let x: [string,number]; x = ['Runoob',1];
  7. 枚举：enum Color {Red,Green,Blue}; let c:Color = Color.Blue;
  8. void：用于标示方法返回值类型，表示该方法没有返回值
  9. null：对象值缺失
  10. undefined：用于初始化变量为一个未定义的值
  11. never：never是其他类型，包括null和undefined的子类型，代表从不会出现的值?

各种类型的一些注意点

any

  1. any类型就非常接近js这种动态语言的用法，不固定死数据的类型，ts是编译型语言，any可以跳过编译时的类型检查
  2. 用于定义不规定类型的数组 let arr: any[] = [1,false,'fine'];

null和undefined

  1. null表示什么都没有，是一个特殊的类型，表示空对象引用，所以本质上也是一个对象
  2. undefined表示一个没有设置值的变量，typeof一个未设置值的变量会返回undefined
  3. null和undefined是其他任意类型的子类型，可以赋值给其他任意类型
  4. 第3点并不是无条件成立的，ts可以开启严格模式用于空类型校验，这样的话null和undefined只能赋给void或自身类型

never

  1. 一般来说只能被自身类型赋值，在函数中通常是抛异常或者死循环

变量声明

  1. 两个地方需要关注，一个是带不带类型，一个是有没有初值
let uname;   
let uname: string;  
let uname = 'Bob';  
let uname: string = 'Bob';

类型推断

变量作用域

  1. 全局作用域：定义在程序外部，可以在代码的任何位置使用

  2. 类作用域：又称为字段，在类中，但是在方法外定义，类变量可以是静态的，可以通过类名直接访问

  3. 局部作用域： 在方法中定义，只能在声明它的方法中使用

ts中的一些重要对象

Number对象

  1. 创建一个实例对象var num = new Number(value);

  2. Number对象一些属性和方法：[菜鸟教程](TypeScript Number | 菜鸟教程 (runoob.com))

  3. 关注一点，ts是静态语言，一般来说不允许动态的为对象添加属性，但是这些对象中都有一个prototype属性，通过对象名.prototype.新加属性名 = 属性值可以实现动态属性添加，除了Number对象，其他对象也有这个特点

String对象

  1. 创建实例都是通过new来进行
  2. String对象的一些属性和方法：[菜鸟教程]([TypeScript String（字符串） | 菜鸟教程 (runoob.com)))

Array数组对象

  1. 数组对象在上面已经讲过了，第一种元素相同的数组let arr: number[] = [1,2,3];
  2. 第二种像元组一样元素不同类型的数组let arr: any[] = [1,false,'Bob'];
  3. 数组解构：
var arr:number[] = [12,13]; 
var[x,y] = arr; // 将数组的两个元素赋值给变量 x 和 y 
console.log(x);
console.log(y);  //x:12,y:13
  1. 数组的方法比较多，可以自行查阅

Map对象

  1. 创建Map对象
let myMap = new Map([
        ["key1", "value1"],
        ["key2", "value2"]
    ]);
  1. map对象方法

  • map.clear() – 移除 Map 对象的所有键/值对 。

  • map.set() – 设置键值对，返回该 Map 对象。

  • map.get() – 返回键对应的值，如果不存在，则返回 undefined。

  • map.has() – 返回一个布尔值，用于判断 Map 中是否包含键对应的值。

  • map.delete() – 删除 Map 中的元素，删除成功返回 true，失败返回 false，参数是键值。

  • map.size – 返回 Map 对象键/值对的数量。

  • map.keys() - 返回一个 Iterator 对象， 包含了 Map 对象中每个元素的键 。

  • map.values() – 返回一个新的Iterator对象，包含了Map对象中每个元素的值 。

  1. map迭代
let nameSiteMapping = new Map(); 
nameSiteMapping.set("Google", 1); 
nameSiteMapping.set("Runoob", 2); 
nameSiteMapping.set("Taobao", 3); // 迭代 Map 中的 key 
for (let key of nameSiteMapping.keys()) { 
    console.log(key); 
} // 迭代 Map 中的 value 
for (let value of nameSiteMapping.values()) { 
    console.log(value); 
} // 迭代 Map 中的 key => value 
for (let entry of nameSiteMapping.entries()) { 
    console.log(entry[0], entry[1]); 
} // 使用对象解析 
for (let [key, value] of nameSiteMapping) { 
    console.log(key, value); 
}

tuple元组

  1. 元组最大的特点就是相当于一个不限制元素类型必须一致的数组，虽然数组也有一个特殊的any
  2. 元组的一些方法
tup.push(ele) //往末尾追加一个元素
tup.pop(ele) //移除元组的最后一个元素
    
//元组解构，和数组解构一样
var a =[10,"Runoob"];
var [b,c] = a

联合类型以及类型自定义命名

  1. var ele: string|number; 表示ele可以是这两种类型中的一种，赋值的时候只要符合任一种就可以编译通过
  2. 联合类型数组：var arr: string[]|number[];
  3. 自定义命名：typeof string s; typeof string|number myType;

接口：相当于自定义出一个类似于对象的数据类型，把对象中的每一个数据类型都规定好

interface Person {
    username: string;
    age: number;
    sayHi: ()=>string
}
    
let person: Person = {
    username: 'Bob',
    age: 20,
    sayHi: ():string =>{return "Hi there"}
};
    
//数组接口，索引可以是number或者string类型
interface myNumberInterface {
    [index:number]:string;  
};
interface myStringInterface {
    [index:string]:string;  
};

let numberList: myNumberInterface = ['Bob','Alice'];
let stringList: myStringInterface['Bob'] = 15;   //这里的Bob就是索引，15才是值，stringList['Bob'] = 15

其实索引为string类型的东西应该很眼熟，就是map类型的形式变种，本质差不多 每一个数据的类型都可以是联合类型，例如number|string|(()=>string)，多复杂都可以，根据需求任意设计

  • 接口继承
interface A{
    A: string;
};
interface B{
    B: string;
};
interface C{
    C: string;
}
//单继承
interface A extends B{
    
}
//多继承
interface A extends B,C{
    
}

所以接口这个东西就非常像Java中的类，但是很有意思的是ts还有一个东西叫类

类

  1. 类的基本形式
class class_name { 
    // 类作用域
}

类中可以有三个东西字段构造函数和方法 2. 类中的字段、构造函数和方法

  • 字段：类中的属性
  • 构造函数：类实例化的时候调用，可以实例对象分配空间
  • 方法：是对象具备的一些功能，比如狗可以打洞，猫可以捉老鼠
class Car { 
    // 字段 
    engine:string; 
    // 构造函数 
    constructor(engine:string) { 
        this.engine = engine 
    } 
    // 方法 
    disp():void { 
        console.log("发动机为 : "+this.engine) 
    } 
}
//实例化传参数
Car car = new Car('benci');
  1. ts类中的属性和方法调用和Java一样可以通过obj.属性/方法，以及继承也和Java基本一致，类比着学习即可
  2. ts类中也有静态属性和静态方法，和Java也是一模一样的，关键字static
  3. ts类中也有重写父类方法的功能
  • 方法重写的规则

1.子类的参数必须与从父类继承来的方法的参数保持一致
2.父类的方法只能被其子类重写
3.构造方法不能被重写
4.如果不能继承一个方法,那么就不能重写这个方法

  • 方法重载的规则

1.被重载的方法必须改变参数列表(可以是参数的个数,也可以为参数的类型)
2.被重载的方法可以改变返回类型
3.方法能够在同一个类中或者同一个子类中被重载

  • 方法重写跟方法重载的区别

1.参数列表 重载必须修改,重写一定不修改
2.返回类型 重载可以修改,重写一定不修改
3.范围 重载方法在一个类中,重写发生在继承类中
4.定义 重载方法名称相同,参数类型或者个数不同,对权限没要求,重写方法名称,参数类型,返回值类型全部相同

  1. 类权限修饰符
  1. public：默认的修饰符，任何地方可以访问
  2. protected：受保护的，只能在类中以及子类中访问
  3. private：只能在本类中访问

接口和类型的区别

  1. 还是结合Java来看，Java中的接口中可以声明属性和方法，但是接口中对于方法不作实现
  2. 当然和Java还是有所区别的，Java里没有对象直接属于接口类型的用法，ts可以直接以对象来实现接口中的方法
  3. ts中类也可以具体实现方法

命名空间

  1. 命名空间一个最主要的作用：解决重名问题
  2. 命名空间使用namespace定义，格式如下：
namespace SomeNameSpaceName { 
    export interface ISomeInterfaceName { } 
    export class SomeClassName { } 
}

命名空间相当于一个封闭的区域，如果都以命名空间来设计接口和类，外部命名空间无法访问，这里的export的作用就是将这些接口和类进行导出，以供外部访问

  • 这里补充一点，如果引用外部的ts，需要特殊的语法规则处理
/// <reference path = "SomeFileName.ts" />
avatar
文章
阅读
粉丝