TS 的脚步已经拦不住，代码撸起来

简
• 阅读 1433

前言

vue3已经发布了，ts的脚步已经阻拦不住了，还只会es6?别想了，人家都已经在行动了，以下是ts的基本系列教程，ts的基本语法，高级语法等，以及在vue项目中如何应用ts，跟着我赶紧撸起来吧。

基本数据类型

数字
const a: number = 3;
字符串
const b: string = "1";
数组
const c: number[] = [1, 2, 3];  
const d: Array<number> = [1, 3];  
const arr: any[] = [1, "33", true];
元组

可以为数组中的每个参数定义相对应的类型

const e: [number, string] = [1, "ww"];
枚举
enum error {  
  blue = 3,  
  "orange",  
}  
const f: error = error.orange;  
console.log(f); //输出4

tips

  1. 如果未赋值的上一个值是数字那么这个未赋值的值的是上一个值的值+1

  2. 如果未赋值的上一个值未赋值那么输出的就是它的下标

  3. 如果未赋值的上一个值的值是非数字,那么必须赋值

布尔类型
const g: boolean = true;
对象

const i: object = {};
undefined

常用于组合类型

let j: number | undefined;
null
let k: null;
void

指定方法类型，表示没有返回值,方法体中不能return

function aa(): void {  
  console.log(1);  
}  

//如果方法有返回值，可以加上返回值的类型  
function bb(): number {  
  return 1;  
}
never

其他类型 (包括null和undefined)的子类型，代表从不会出现的值

let l: never;  

//匿名函数并抛出异常  
l = (() => {  
  throw new Error("111");  
})();
任意类型

让参数可以是任何一种类型


let h: any = 1;  
h = true;  
h = "st";

函数

函数申明
function cc(): void {}
方法传参
function getUserInfo(name: string, age?: number, school: string = "清华大学") {  
  return `name:${name}--age:${age}--school:${school}`;  
}

tips: ?代表这个参数可传可不传,不传就是undefined,也可定义个默认的值

剩余参数

传递多个时，如果用了剩余参数，就可以把未定义的形参转换为数组。

function sum (a: number, b: number, ...arr: number[]): number {  
  let sum: number = a + b;  
  arr.forEach((element) => {  
    sum += element;  
  });  
  console.log(arr); [3,4,5]    
  return sum;  
}  
console.log(sum(1, 2, 3, 4, 5)); //15
函数重载
function reload(name: string): string;  
function reload(age: number): string;  
function reload(param: any): any {  
  return typeof param === "string" ? `我是:${param}` : `我的年龄:${param}`;  
}  
console.log(reload(18)); //年龄

tips: 被重载的方法，是没有方法体，可以根据参数的类型走其中一个方法并判断参数，但如果传入的参数类型不是任何被重载方法的参数类型就不允许通过。

 第 1 个重载(共 2 个)，“(name: string): string”，出现以下错误。  
   类型“never[]”的参数不能赋给类型“string”的参数。  
 第 2 个重载(共 2 个)，“(age: number): string”，出现以下错误。  
   类型“never[]”的参数不能赋给类型“number”的参数

类


class Person {  
  // 私有变量  
  private name: string;  

  // 构造函数  
  constructor(name: string) {  
    this.name = name;  
  }  

  // 获取名字  
  getName(): string {  
    return this.name;  
  }  

  // 设置名字  
  setName(name: string): void  {  
    this.name = name;  
  }  
}  

let p = new Person("张三");  
p.setName("李四");  
console.log(p);

继承

class Son extends Person {  
 // 静态属性  
  public static age: number = 18;  
  // 学校  
  public school: string;  
  //构造方法  
  constructor(name: string, school: string) {  
    // 访问派生类的构造函数中的 "this" 前，必须调用 "super",初始化父类构造函数 --并把参数传给父类  
    super(name);   
    //把传进来的school赋值给全局变量  
    this.school = school;  
  }  
  //静态方法  
  static run(name: string): string {  
    return `${name}在跑步,他的年龄才${this.age}`;  
  }  
}  

let son = new Son("王五", "清华大学");  
son.setName("赵六"); // 私有类也不能在子类的外部访问,但可通过公开的方法中进行赋值和访问  
console.log(son);  
console.log(Son.run("方七"));  
console.log(Son.age);

tips:

  1. public 在当前类里面，子类，类外面都可以访问

  2. protected 在当前类和子类内部可以访问，类外部无法访问

  3. private 在当前类内部可访问，子类，类外部都无法访问。

  4. 属性不加修饰符,默认就是公有的 (public)

多态

通过抽象方法/方法重载--实现多态--多态的作用是用来定义标准

// 抽象父类  
abstract class Animal {  
  private name: string;  
  constructor(name: string) {  
    this.name = name;  
  }  
  //抽象成员--方法  
  abstract eat(): any;  
  //抽象成员--属性  
  protected abstract ages: Number;  
  sleep(): void {  
    console.log("睡觉");  
  }  
}  

class cat extends Animal {  
  ages: Number = 2;  
  constructor(name: string) {  
    super(name);  
  }  
  //非抽象类“cat”不会自动实现继承自“Animal”类的抽象成员“eat”,  必须手动定义父类中的抽象方法--多态  
  eat(): string {  
    return "猫吃鱼";  
  }  

  //多态  
  sleep(): string {  
    return "猫在睡觉";  
  }  
}  

console.log(new cat("33").sleep());

tips:

  1. 抽象类无法实例化。

  2. 非抽象类继承抽象父类时不会自动实现来自父类的抽象成员,必须手动定义父类中的抽象成员，否则报错。

  3. 抽象成员包括属性和方法

接口

在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范，

在程序设计里面，接口起到一种限制和规范的作用。

接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类里方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可以满足实际需要。ts中的接口类似于java，同时还增加了更灵活的接口类型，包括属性、函数、可索引和类等。

属性接口
interface InterfaceName {  
  first: string;  
  second?: string; //加个问号，接口属性就可以变成可传可不传了，不传默认是undefined。  
}  
//打印变量  
function logParam(name: InterfaceName): void {  
  console.log(name.first, name.second, 11);  
}  
//定义参数  
const obj = { first: "1", second: "fff", three: 1 };  
//logParam({ first: "1", second: "1", three: 1 }); //报错,只能传接口定义的值  
logParam(obj);

tips: 用个变量来存储传入的变量,这样可以传入定义的接口以外的值，否则如果直接传入对象中无接口定义的值会报错，所以建议接口定义了哪些值就传哪些值。

函数类型接口

对方法传入的参数类型,以及返回值类型进行约束,可批量进行约束。

interface keyMap {  
  (key: string, value: string): string;  
}  
let logKeyMap: keyMap = function (key1: string, value: string): string {  
  return key1 + value;  
};  
console.log(logKeyMap("key1", "value"));

tips: 接口只对传入的参数的类型和参数的个数进行约束，不对参数名称进行约束。

可索引接口
  • 约束数组
interface Arr {  
  [index: number]: string;  
}  
let ss: Arr = ["2121"];
  • 约束对象
interface Obj {  
  [index: string]: string;  
}  

let interfaceArr: Obj = { aa: "1" };

tips:

  1. 对数组进行约束,index后必须跟着number类型。

  2. 对对象进行约束,index后必须跟着string类型

  3. 索引签名参数类型必须为 "string" 或 "number"

类类型接口
  • 对类进行约束,类似抽象类的实现。
interface Animals {  
  name: string;  
  eat(): void;  
}  

class Dogs implements Animals {  
  name: string;  
  constructor(name: string) {  
    this.name = name;  
  }  
  eat() {}  
}
  • 接口继承--接口可以继承接口
interface Dog {  
  eat(): void;  
}  

interface Persons extends Dog {  
  work(): void;  
}  

class Cat {  
  code() {  
    console.log("猫在敲代码");  
  }  
}  

//可继承类后再实现接口  
class SuperMan extends Cat implements Persons {  
  eat(): void {  
    console.log(1);  
  }  
  work(): void {  
    console.log(2);  
  }  
}  
let superMan = new SuperMan();  
superMan.code();

tips: 类接口会对类的属性和方法进行约束，类似非抽象类继承抽象类时必须实现某些方法和属性，但对属性和方法的类型的约束更加严格，除了方法void类型可被重新定义外，其他属性或方法的类型定义需要和接口保持一致。

泛型

软件工程中，我们不仅要创建一致的定义良好的api，同时也要考虑可重用性。
组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能

泛型就是解决类、接口、方法的复用性，以及对不特定数据类型的支持。

要求:传入的参数和返回的参数一致

函数的泛型
function getDate<T>(value: T): T {  
  return value;  
}  
console.log(getDate<number>(123));

tips: 这里的T可改成其他任意值但定义的值，和传入的参数以及返回的参数是一样的,一般默认写法是T，也是业内规范的选择。

类的泛型
class MinClass<T> {  
  public list: T[] = [];  
  //添加  
  add(value: T): void {  
    this.list.push(value);  
  }  

  //求最小值  
  min(): T {  
    //假设这个值最小  
    let minNum = this.list[0];  
    for (let i = 0; i < this.list.length; i++) {  
    //比较并获取最小值  
    minNum = minNum < this.list[i] ? minNum : this.list[i];  
    }  
    return minNum;  
  }  
}  
//实例化类 并且指定了类的T的类型是number  
let minClass = new MinClass<number>();   
minClass.add(23);  
minClass.add(5);  
minClass.add(2);  
console.log(minClass.min());  
 //实例化类 并且指定了类的T的类型是string，则其方法的传参和返回都是string类型  
let minClass2 = new MinClass<string>();  
minClass2.add("23");  
minClass2.add("5");  
minClass2.add("2");  
console.log(minClass2.min());
接口的泛型
  • 第一种写法
interface ConfigFn {  
  //规范参数类型,返回值类型  
  <T>(value: T): T;  
}  

let getData: ConfigFn = function <T>(value: T): T {  
  return value;  
};  

console.log(getData<string>("z11"));
  • 第二种写法

interface ConfigFn<T> {  
  //参数类型 ，返回值类型  
  (value: T): T;  
}  

//接口方法  
function getData<T>(value: T): T {  
  return value;  
}  

//使用接口  
let myGetDate: ConfigFn<string> = getData;  
console.log(myGetDate("3"));

tips:接口的泛型只针对函数类型的接口

类当做参数传入泛型类
//用户类--和数据库表字段进行映射  
class User {  
  username: string | undefined;  
  password: string | undefined;  
  //构造函数-初始化参数  
  constructor(param: {  
    username: string | undefined;  
    password?: string | undefined;  
  }) {  
    this.username = param.username;  
    this.password = param.password;  
  }  
}  


//数据库类  
class Db<T> {  
  add(user: T): boolean {  
    console.log(user);  
    return true;  
  }  
  updated(user: T, id: number): boolean {  
    console.log(user, id);  
    return true;  
  }  
}  

let u = new User({  
  username: "张三",  
});  

//u.username = "李四";  
u.password = "111111";  
let db = new Db<User>();  
db.add(u);  
db.updated(u, 1);

tips: 类的参数名和类型都做了约束。

模块

内部模块称为命名空间，外部模块简称为模块，模块在其自身的作用域里执行，而不是在全局作用域里;

这意味着定义在一个模块里的变量、函数、类等等在模块外部是不可见的，除非你明确的使用export形式之一导出它们。

相反，如果想使用其它模块导出的变量，函数，类，接口等的时候，你必须要导人它们，可以使用import形式之一。

我们可以一些公共的功能单独抽离成一个文件作为一个模块。
模块里面的变量、函数、类等默认是私有的，如果我们要在外部访问模块里面的数据(变量、函数、类)
我们需要通过export暴露模块里面的数据(变量、函数、类...)。
暴露后我们通过import引入模块就可以使用模块里面暴露的数据(变量、函数、类...)

//modules/db.ts  
function getDate(): any[] {  
  console.log("获取数据");  
  return [  
    {  
      userName: "张三",  
    },  

    {  
      userName: "李四",  
    },  
  ];  
}  

//一个模块里面可以用多次  
// export { getDate };  
//一个模块里面只能用一次  
export default getDate;  
 import { getDate as getDbDate } from "./modules/db";  
 import getDbDate from "./modules/db";  
 getDbDate();

tips: 这个调试时浏览器中不能直接使用,可在node和weakpack的环境中调试。

命名空间

在代码量较大的情况下，为了避免各种变量命名相冲突，可将相似功能的函数、类、接口等放置到命名空间内
TypeScript的命名空间可以将代码包裹起来，只对外暴露需要在外部访问的对象。

命名空间和模块的区别

  • 命名空间：内部模块，主要用于组织代码，避免命名冲突。

  • 模块：ts外部模块的简称，侧重代码的复用，一个模块里可能会有多个命名空间。

 // modules/Animal.ts  
export namespace A {  
  interface Animal {  
    name: String;  
    eat(): void;  
  }  

  export class Dog implements Animal {  
    name: String;  
    constructor(theName: string) {  
      this.name = theName;  
    }  
    eat() {  
      console.log("我是" + this.name);  
    }  
  }  
}  

export namespace B {  
  interface Animal {  
    name: String;  
    eat(): void;  
  }  

  export class Dog implements Animal {  
    name: String;  
    constructor(theName: string) {  
      this.name = theName;  
    }  
    eat() {}  
  }  
}
 import { A, B } from "./modules/Animal";  
 let ee = new A.Dog("小贝");  
 ee.eat();

装饰器

  • 类装饰器：类装饰器在类申明之前被申明(紧靠着类申明)，类装饰器应用于类构造函数，可以用于监视，修改或者替换类定义。
function logClass(params: any) {  
  console.log(params);  
  //params 就是指代当前类--HttpClient  
  params.prototype.apiUrl = "动态扩展属性";  
  params.prototype.run = function () {  
    console.log("动态扩展方法");  
  };  
  params.prototype.getDate = function () {  
    console.log("动态扩展方法2");  
  };  
}  

@logClass  
class HttpClient {  
  constructor() {}  
  getDate() {  
    console.log(1);  
  }  
}  

let http: any = new HttpClient();  
console.log(http.apiUrl);  
http.run();  
http.getDate();

tips: 装饰器会覆盖被装饰的类中的方法。

  • 装饰器工厂

可传参的装饰器


function logClassB(param: string) {  
  return function (target: any) {  
    console.log(target, "装饰器以下的类");  
    console.log(param, "装饰器传进来的属性");  
  };  
}  

@logClassB("小慧")  
class HttpClients {  
  constructor() {}  
  getDate() {}  
}  

let https: any = new HttpClients();  
console.log(https);
  • 构造函数装饰器
function logClassC(target: any) {  
  console.log(target, 1111);  
  //用在这里继承目标类并重载方法和属性  
  return class extends target {  
    a: any = "我是修改后的属性";  
    getDate() {  
      console.log(this.a + "--装饰器中的方法输出的");  
    }  
  };  
}  

@logClassC  
class HttpClient2 {  
  public a: string | undefined;  
  constructor() {  
    this.a = "我是构造函数里面的a";  
  }  
  getDate() {  
    console.log(this.a);  
  }  
}  
const https2 = new HttpClient2();  
https2.getDate();

来自：SegmentFault，作者：yaoxfly

链接：https://segmentfault.com/a/1190000031793196

泛型接口变量JavascriptJavascriptJavascript
点赞
收藏
评论区
推荐文章
blmius blmius
•
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时，报错：原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等，这样可以更容易地在不同的环境中使用MySQL。全局s
4129
0
0
Karen110 Karen110
•
3年前
一篇文章带你了解JavaScript日期
日期对象允许您使用日期（年、月、日、小时、分钟、秒和毫秒）。一、JavaScript的日期格式一个JavaScript日期可以写为一个字符串:ThuFeb02201909:59:51GMT0800(中国标准时间)或者是一个数字:1486000791164写数字的日期，指定的毫秒数自1970年1月1日00:00:00到现在。1\.显示日期使用
1573
0
0
helloworld_34035044 helloworld_34035044
•
2年前
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时，如何在新增行里自动增加id呢？能新增整数排序id吗？目前可以在新增行里自动增加id，但只能用uuid函数增加UUID编码，不能新增整数排序id。uuid函数说明：获取一个UUID，可以在填报表中用来创建数据ID语法：uuid()或uuid(sep)参数说明：sep布尔值，生成的uuid中是否包含分隔符''，缺省为
1147
0
0
待兔 待兔
•
4个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
1070
0
0
Jacquelyn38 Jacquelyn38
•
3年前
2020年前端实用代码段，为你的工作保驾护航
有空的时候，自己总结了几个代码段，在开发中也经常使用，谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
2388
0
0
Stella981 Stella981
•
3年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签，将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
1347
0
0
Wesley13 Wesley13
•
3年前
00：Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork)，斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。Java是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。
1255
0
0
Stella981 Stella981
•
3年前
Django中Admin中的一些参数配置
设置在列表中显示的字段，id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
1173
0
0
Wesley13 Wesley13
•
3年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
1519
0
0
Python进阶者 Python进阶者
•
10个月前
Excel中这日期老是出来00：00：00，怎么用Pandas把这个去除
大家好，我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下：这日期老是出来00：00：00，怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下：pd.toexcel之前把这
507
0
0
简
简
Lv1
惊起归鸿不成字，辞柯落叶最知秋。
文章
20
粉丝
2
获赞
2
热门文章
深度解读ArrayMap优势与缺陷
Android技术架构演进与未来
Flutter 移动应用开发指南
解读Dart虚拟机的参数列表
源码解读Linux等待队列