Ts的接口、泛型、自定义类型

一、概述

TypeScript(TS)是一种强类型的JavaScript超集,它为JavaScript代码提供了类型检查功能。在TypeScript中,接口(Interfaces)、泛型(Generics)和自定义类型(Custom Types)是定义和强化代码类型的三种重要方式。

二、接口(Interfaces)
接口是用来定义对象、类或函数的形状(shape)的一种类型系统。它描述了一组属性的集合,这些属性包括名称和类型。接口在TypeScript中是通过关键字interface来定义的。

简单接口:

interface Person {
  name: string;
  age: number;
}

函数接口:

interface ClickHandler {
  (event: MouseEvent): void;
}

接口的继承
接口可以继承另一个接口,使用extends关键字:

interface Shape {
  color: string;
}

interface Square extends Shape {
  sideLength: number;
}

三、泛型(Generics)
泛型是一种可以在定义函数、接口、类的时候,不预先指定具体的类型,而是在使用的时候再指定类型的特性。它允许你在不牺牲类型安全性的同时编写可重用的组件。

泛型函数:

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

泛型类

class Box<T> {
  private content: T;
  constructor(content: T) {
    this.content = content;
  }
  getContent(): T {
    return this.content;
  }
}

泛型接口

interface ResponseData<T> {
  data: T;
  status: number;
}

四、自定义类型(Custom Types)
自定义类型通常是指那些使用TypeScript提供的类型系统来创建的新类型。这包括了使用type关键字定义的类型、联合类型、元组类型等。

使用type自定义接口类型

type Point = {
  x: number;
  y: number;
};

 联合类型:

type MaybeNumber = number | null;

元组类型

type Pair<T1, T2> = [T1, T2];

五、defineProps

 是 Vue 3 中引入的一个新的 API,用于在组件内部定义和验证 props。这个 API 使得组件的 props 定义更加清晰和可维护,并且提供了更好的类型检查支持。

App向组件person传递数据

App.vue:

<template><!--html-->
    <div class="app">
        <Person :list="personlist"/>
    </div>
</template>
<script lang="ts" setup name="App">//javascript
import Person from './components/Person.vue'
  import { reactive } from 'vue'
    import { type PersonInter,type Persons} from './types/index'
  let personlist=reactive<Persons>([
    {id:'0212', name:"张三",age:18 },
    {id:'0213', name:"李四",age:19 },
    {id:'0214', name:"王五",age:20 }
  ])
</script>

<style>/*css样式*/ 
     .app{
        background-color: #ddd;
        box-shadow: 0 0 10px;
        border-radius: 10px;
        padding: 20px;
     }
</style>

 Person.vue:

<!--vue简单框架-->
<template>
<div class="person">
    <ul v-for="p in list" :key="p.id">
        <li>
            {{ p.name }}--{{p.age  }}
        </li>
    </ul>
</div>
</template>

<script lang='ts'setup name="">
    import { DefineProps,withDefaults } from 'vue';
    import {PersonInter, Persons} from '../types/index'
    //只接收list
    defineProps(['list'])
    //接收list,并且限制类型
    defineProps<{list:Persons}>()
     //接收list+限制类型+限制必要性+限制默认值
     withDefaults(defineProps<{list?:Persons}>(),{
        list:()=>[{id:"23812",name:'康师傅',age:37}]
     })
</script>

<style scoped>
</style>

type文件夹下的index.ts

//定义一个接口,用来限制对象的属性
export interface PersonInter{
    id:string,
    name:string,
    age:number
}
//自定义类型
/* export type Persons=Array<PersonInter> */
export type Persons=PersonInter[]

### 回答1: Ts 泛型在函数中的使用举例:比如我们有一个函数,它可以接收任意类型的参数,但是我们又希望在函数内部对这些参数进行一些操作,那么我们就可以使用泛型来实现这个功能。例如: function identity<T>(arg: T): T { return arg; } 这个函数接收一个泛型参数 T,它可以是任意类型。在函数内部,我们直接返回这个参数,这样就可以实现对任意类型的参数进行操作了。 ### 回答2: TypeScript (TS) 是一种静态类型语言,它引入了泛型概念,用于在函数中进行通用类型的处理。下面是一个使用泛型的函数示例: ```typescript function reverseArray<T>(arr: T[]): T[] { return arr.reverse(); } const numbers = [1, 2, 3, 4, 5]; const reversedNumbers = reverseArray(numbers); console.log(reversedNumbers); // [5, 4, 3, 2, 1] const strings = ['Hello', 'World']; const reversedStrings = reverseArray(strings); console.log(reversedStrings); // ['World', 'Hello'] ``` 上述示例中,函数 `reverseArray` 使用了泛型 `<T>`,表示该函数可以接受通用类型 `T` 的数组作为参数,并返回相同类型的数组。在函数体内,首先调用了数组的 `reverse` 方法,然后将结果返回。 在代码中调用 `reverseArray` 函数时,可以传入不同类型的数组参数。比如,`numbers` 是一个整数数组,`strings` 是一个字符串数组。通过使用泛型,我们可以方便地处理这些不同类型的数组,并获得相应的结果。 在编译阶段,TypeScript 会根据实际传入的参数类型进行类型推导,确保传入的参数类型和返回值类型一致,从而提供编译时的类型检查。这样可以避免传入错误类型的参数导致运行时错误的问题。 总之,通过使用泛型,我们可以在函数中编写通用的代码,以适应不同类型的数据,并且在编译阶段进行类型检查,提高代码的可靠性和可维护性。 ### 回答3: 泛型在函数中的使用可以提供更加灵活和通用的编程方式,以下是一个关于泛型在函数中的使用举例: 举例我们有一个函数 `findMax`,用于找到数组中的最大值。如果我们只是针对具体的数值类型进行编写,那么函数的重用性会受到限制。但是通过使用泛型,我们可以编写一个能够适用于不同类型的数组的函数。 ```java public static <T extends Comparable<T>> T findMax(T[] array) { T max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i].compareTo(max) > 0) { max = array[i]; } } return max; } ``` 在这个例子中,使用了 `<T extends Comparable<T>>` 这样的语法来声明泛型 `T`,并限制了 `T` 的类型必须是实现了 `Comparable` 接口类型,这样我们就可以使用 `compareTo` 方法来比较不同类型的对象。 通过使用泛型,我们可以在调用这个函数时传入不同类型的数组,例如 `Integer[]`、`Double[]` 或者自定义的类数组,而不需要针对每种类型编写不同的函数。 ```java Integer[] integers = {1, 2, 3, 4, 5}; Double[] doubles = {1.5, 2.3, 0.9, 4.7}; String[] strings = {"apple", "banana", "orange"}; System.out.println(findMax(integers)); // 输出:5 System.out.println(findMax(doubles)); // 输出:4.7 System.out.println(findMax(strings)); // 输出:orange ``` 通过这个例子,我们可以看到泛型在函数中的使用,使得我们能够更加灵活地处理不同类型的数据,提高了代码的可重用性和通用性。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值