tsfresh是什么

转载

JAVA小侠影 2024-07-11 19:18:11

文章标签 tsfresh是什么 typescript 泛型子类抽象类 文章分类 架构后端开发

TS指南

1. TS基本类型

类型声明语法：

let 变量: 类型;
 
 let 变量：{
 	属性1：类型，
 	属性2：类型，
 	[propName: string]: any // 表示任意属性
 }
 
 let 变量: 类型 = 值;
 
 function fn(参数: 类型, 参数: 类型): 类型{
     ...
 }
 ```

自动类型判断

TS拥有自动的类型判断机制
当对变量的声明和赋值是同时进行的，TS编译器会自动判断变量的类型
所以如果你的变量的声明和赋值时同时进行的，可以省略掉类型声明

类型：

类型	例子	描述
number	1, -33, 2.5	任意数字
string	‘hi’, “hi”, `hi`	任意字符串
boolean	true、false	布尔值true或false
字面量	其本身	限制变量的值就是该字面量的值
any	*	任意类型
unknown	*	类型安全的any
void	空值（undefined）	没有值（或undefined）
never	没有值	不能是任何值
object	{name:‘孙悟空’}	任意的JS对象
array	[1,2,3]	任意JS数组
tuple	[4,5]	元素，TS新增类型，固定长度数组
enum	enum{A, B}	枚举，TS中新增类型

几个比较特殊的类型示例:

never 一般用在报错

function error(message: string): never {
    throw new Error(message);
  }

tuple 元组

let x: [string, number];
  x = ["hello", 10];

enum 枚举

enum Color { // 默认0开始 0,1,2
    Red,
    Green,
    Blue,
  }
  let c: Color = Color.Green;
  
  enum Color { // 此时从1开始 1,2,3
    Red = 1,
    Green,
    Blue,
  }
  let c: Color = Color.Green;
  
  enum Color { //自定义 此时为 1,2,4
    Red = 1,
    Green = 2,
    Blue = 4,
  }
  let c: Color = Color.Green;

类型断言

有些情况下，变量的类型对于我们来说是很明确，但是TS编译器却并不清楚，此时，可以通过类型断言来告诉编译器变量的类型，断言有两种形式：

第一种

let someValue: unknown = "this is a string";
  let strLength: number = (someValue as string).length;

第二种

let someValue: unknown = "this is a string";
  let strLength: number = (<string>someValue).length;

2. 类（class）

定义类：

class 类名 {
  	属性名: 类型;
  	
  	constructor(参数: 类型){
  		this.属性名 = 参数;
  	}
  	
  	方法名(){
  		....
  	}
  
  }

示例：

class Person{
      name: string;
      age: number;
  
      constructor(name: string, age: number){
          this.name = name;
          this.age = age;
      }
  
      sayHello(){
          console.log(`大家好，我是${this.name}`);
      }
  }

使用类：

const p = new Person('孙悟空', 18);
  p.sayHello();

3. 面向对象的特点

3.1 封装

对象实质上就是属性和方法的容器，它的主要作用就是存储属性和方法，这就是所谓的封装
默认情况下，对象的属性是可以任意的修改的，为了确保数据的安全性，在TS中可以对属性的权限进行设置

3.1.1 只读属性（readonly）：

如果在声明属性时添加一个readonly，则属性便成了只读属性无法修改

3.1.2 属性三种修饰符：

public（默认值），可以在类、子类和对象中修改
protected ，可以在类、子类中修改
private ，可以在类中修改

示例：

public

class Person{
      public name: string; // 写或什么都不写都是public
      public age: number;
  
      constructor(name: string, age: number){
          this.name = name; // 可以在类中修改
          this.age = age;
      }
  
      sayHello(){
          console.log(`大家好，我是${this.name}`);
      }
  }
  
  class Employee extends Person{
      constructor(name: string, age: number){
          super(name, age);
          this.name = name; //子类中可以修改
      }
  }
  
  const p = new Person('孙悟空', 18);
  p.name = '猪八戒';// 可以通过对象修改

protected

class Person{
      protected name: string;
      protected age: number;
  
      constructor(name: string, age: number){
          this.name = name; // 可以修改
          this.age = age;
      }
  
      sayHello(){
          console.log(`大家好，我是${this.name}`);
      }
  }
  
  class Employee extends Person{
  
      constructor(name: string, age: number){
          super(name, age);
          this.name = name; //子类中可以修改
      }
  }
  
  const p = new Person('孙悟空', 18);
  p.name = '猪八戒';// 不能修改

private

class Person{
      private name: string;
      private age: number;
  
      constructor(name: string, age: number){
          this.name = name; // 可以修改
          this.age = age;
      }
  
      sayHello(){
          console.log(`大家好，我是${this.name}`);
      }
  }
  
  class Employee extends Person{
  
      constructor(name: string, age: number){
          super(name, age);
          this.name = name; //子类中不能修改
      }
  }
  
  const p = new Person('孙悟空', 18);
  p.name = '猪八戒';// 不能修改

3.1.3 属性存取器

对于一些不希望被任意修改的属性，可以将其设置为private

直接将其设置为private将导致无法再通过对象修改其中的属性
我们可以在类中定义一组读取、设置属性的方法，这种对属性读取或设置的属性被称为属性的存取器
读取属性的方法叫做setter方法，设置属性的方法叫做getter方法
示例：

class Person{
      private _name: string;
  
      constructor(name: string){
          this._name = name;
      }
  
      get name(){
          return this._name;
      }
  
      set name(name: string){
          this._name = name;
      }
  
  }
  
  const p1 = new Person('孙悟空');
  console.log(p1.name); // 通过getter读取name属性
  p1.name = '猪八戒'; // 通过setter修改name属性

3.1.4 静态属性

静态属性（方法），也称为类属性。使用静态属性无需创建实例，通过类即可直接使用
静态属性（方法）使用static开头
示例：

class Tools{
      static PI = 3.1415926;
      
      static sum(num1: number, num2: number){
          return num1 + num2
      }
  }
  
  console.log(Tools.PI);
  console.log(Tools.sum(123, 456));

3.1.5 this

在类中，使用this表示当前对象

3.2 继承

继承时面向对象中的又一个特性
通过继承可以将其他类中的属性和方法引入到当前类中

示例：

class Animal{
      name: string;
      age: number;
  
      constructor(name: string, age: number){
          this.name = name;
          this.age = age;
      }
  }
  
  class Dog extends Animal{
  
      bark(){
          console.log(`${this.name}在汪汪叫！`);
      }
  }
  
  const dog = new Dog('旺财', 4);
  dog.bark();

通过继承可以在不修改类的情况下完成对类的扩展
重写

发生继承时，如果子类中的方法会替换掉父类中的同名方法，这就称为方法的重写
示例：

class Animal{
      name: string;
      age: number;
  
      constructor(name: string, age: number){
          this.name = name;
          this.age = age;
      }
  
      run(){
          console.log(`父类中的run方法！`);
      }
  }
  
  class Dog extends Animal{
  
      bark(){
          console.log(`${this.name}在汪汪叫！`);
      }
  
      run(){
          console.log(`子类中的run方法，会重写父类中的run方法！`);
      }
  }
  
  const dog = new Dog('旺财', 4);
  dog.bark();

在子类中可以使用super来完成对父类的引用

3.3 抽象类（abstract class）

抽象类是专门用来被其他类所继承的类，它只能被其他类所继承不能用来创建实例

abstract class Animal{
      abstract run(): void;
      bark(){
          console.log('动物在叫~');
      }
  }
  
  class Dog extends Animals{
      run(){
          console.log('狗在跑~');
      }
  }

使用abstract开头的方法叫做抽象方法，抽象方法没有方法体只能定义在抽象类中，继承抽象类时抽象方法必须要实现

4. 接口（Interface）

接口的作用类似于抽象类，不同点在于接口中的所有方法和属性都是没有实值的，换句话说接口中的所有方法都是抽象方法。接口主要负责定义一个类的结构，接口可以去限制一个对象的接口，对象只有包含接口中定义的所有属性和方法时才能匹配接口。同时，可以让一个类去实现接口，实现接口时类中要保护接口中的所有属性。

示例（检查对象类型）：

interface Person{
      name: string;
      sayHello():void;
  }
  
  function fn(per: Person){
      per.sayHello();
  }
  
  fn({name:'孙悟空', sayHello() {console.log(`Hello, 我是 ${this.name}`)}});

示例（实现）

interface Person{
      name: string;
      sayHello():void;
  }
  
  class Student implements Person{
      constructor(public name: string) {
      }
  
      sayHello() {
          console.log('大家好，我是'+this.name);
      }
  }

5. 泛型（Generic）

定义一个函数或类时，有些情况下无法确定其中要使用的具体类型（返回值、参数、属性的类型不能确定），此时泛型便能够发挥作用。

举个例子：

function test(arg: any): any{
  	return arg;
  }

上例中，test函数有一个参数类型不确定，但是能确定的时其返回值的类型和参数的类型是相同的，由于类型不确定所以参数和返回值均使用了any，但是很明显这样做是不合适的，首先使用any会关闭TS的类型检查，其次这样设置也不能体现出参数和返回值是相同的类型
使用泛型：

function test<T>(arg: T): T{
  	return arg;
  }

这里的<T>就是泛型，T是我们给这个类型起的名字（不一定非叫T），设置泛型后即可在函数中使用T来表示该类型。所以泛型其实很好理解，就表示某个类型。
那么如何使用上边的函数呢？

方式一（直接使用）：

test(10)

使用时可以直接传递参数使用，类型会由TS自动推断出来，但有时编译器无法自动推断时还需要使用下面的方式

方式二（指定类型）：

test<number>(10)

也可以在函数后手动指定泛型

可以同时指定多个泛型，泛型间使用逗号隔开：

function test<T, K>(a: T, b: K): K{
      return b;
  }
  
  test<number, string>(10, "hello");

使用泛型时，完全可以将泛型当成是一个普通的类去使用

类中同样可以使用泛型：

class MyClass<T>{
      prop: T;
  
      constructor(prop: T){
          this.prop = prop;
      }
  }

除此之外，也可以对泛型的范围进行约束

interface MyInter{
      length: number;
  }
  
  function test<T extends MyInter>(arg: T): number{
      return arg.length;
  }

使用T extends MyInter表示泛型T必须是MyInter的子类，不一定非要使用接口类和抽象类同样适用。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：mysql procedure怎么执行

下一篇：java ut中加log

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

tsfresh是什么

tsfresh是什么

目录

TS指南

1. TS基本类型

2. 类（class）

3. 面向对象的特点

3.1 封装

3.1.1 只读属性（readonly）：

3.1.2 属性三种修饰符：

3.1.3 属性存取器

3.1.4 静态属性

3.1.5 this

3.2 继承

3.3 抽象类（abstract class）

4. 接口（Interface）

5. 泛型（Generic）

51CTO博客