Vue3.0 前的 TypeScript 入门实践

最新推荐文章于 2024-04-29 13:35:36 发布

十一T_T

最新推荐文章于 2024-04-29 13:35:36 发布

阅读量2.1k

点赞数 2

分类专栏： typescript 文章标签： typescript

本文链接：https://blog.csdn.net/XJ5210224/article/details/92842663

版权

typescript 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本篇旨在讲Ts混入框架的使用：TypeScript 和 vue-property-decorator
1. 使用官方脚手架构建
npm install -g @vue/cli
# OR
yarn global add @vue/cli
新的Vue CLI工具允许开发者使用 TypeScript 集成环境创建新项目。
运行vue create my-app
cd my-app
yarn serve
2. 项目目录解析

通过tree指令查看目录结构
主要关注shims-tsx.d.ts和 shims-vue.d.ts两个文件
概括：
1.shims-tsx.d.ts，允许你以.tsx结尾的文件，在Vue项目中编写jsx代码
2.shims-vue.d.ts 主要用于 TypeScript 识别.vue 文件，Ts默认并不支持导入 vue 文件，这个文件告诉ts 导入.vue 文件都按VueConstructor<Vue>处理。

此时打开的src/components/HelloWorld.vue，将会发现写法已大有不同

<template>
    <div class="hello">
        <h1>{{ msg }}</h1>
    </div>
</template>
<script lang="ts">
    import { Component, Prop, Vue } from 'vue-property-decorator';
    @Component
    export default class HelloWorld extends Vue {
        @Prop() private msg!: string;
    }
</script>
<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped></style>

至此，准备开启新的篇章 TypeScript入门和 vue-property-decorator
3. TypeScript入门
3.1 基本类型和扩展类型
Typescript与Javascript共享相同的基本类型，但有一些额外的类型。
①元组 Tuple
②枚举 enum
③Any 与Void
1. 基本类型合集
let decLiteral: number = 6; // 数字，二、八、十六进制都支持
let hexLiteral: number = 0xf00d;
let name: string = "bob"; // 字符串，单双引都行
let sentence: string = `Hello, my name is ${ name }.
// 数组，第二种方式是使用数组泛型，Array<元素类型>：
let list: number[] = [1, 2, 3];
let list: Array<number> = [1, 2, 3];
let u: undefined = undefined;
let n: null = null;
2. 特殊类型
1. 元组 Tuple
想象元组作为有组织的数组，你需要以正确的顺序预定义数据类型。
const messyArray = [' something', 2, true, undefined, null];
const tuple: [number, string, string] = [24, "Indrek" , "Lasn"]
如果不遵循为元组预设排序的索引规则，那么Typescript会警告。
（tuple第一项应为number类型）
2. 枚举 enum
enum类型是对JavaScript标准数据类型的一个补充。像C#等其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。
// 默认情况从0开始为元素编号，也可手动为1开始
enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;
let colorName: string = Color[2];
console.log(colorName); // 输出'Green'因为上面代码里它的值是2
3. Void
在Typescript中，你必须在函数中定义返回类型。像这样：

若没有返回值，则会报错：
我们可以将其返回值定义为void:
此时将无法 return
4. Any
Emmm...就是什么类型都行，当你无法确认在处理什么类型时可以用这个。
但要慎重使用，用多了就失去使用Ts的意义。
let person: any = "前端劝退师"
person = 25
person = true
主要应用场景有：1.接入第三方库 2.Ts菜逼前期都用
5. Never
用很粗浅的话来描述就是："Never是你永远得不到的爸爸。"
具体的行为是：
① throw new Error(message)
② return error("Something failed")
③ while (true) {} // 存在无法达到的终点

3. 类型断言
简略的定义是：可以用来手动指定一个值的类型。
有两种写法，尖括号和as:
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
let strLength: number = (someValue as string).length;
使用例子有：
当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们只能访问此联合类型的所有类型里共有的属性或方法：
function getLength(something: string | number): number {
return something.length;
}
// index.ts(2,22): error TS2339: Property 'length' does not exist on type 'string | number'.
// Property 'length' does not exist on type 'number'.
如果你访问长度将会报错，而有时候，我们确实需要在还不确定类型的时候就访问其中一个类型的属性或方法，此时需要断言才不会报错：
function getLength(something: string | number): number {
if ((<string>something).length) {
return (<string>something).length;
} else {
return something.toString().length;
}
}
3.2 泛型：Generics
软件工程的一个主要部分就是构建组件，构建的组件不仅需要具有明确的定义和统一的接口，同时也需要组件可复用。支持现有的数据类型和将来添加的数据类型的组件为大型软件系统的开发过程提供很好的灵活性。
在C#和Java中，可以使用"泛型"来创建可复用的组件，并且组件可支持多种数据类型。这样便可以让用户根据自己的数据类型来使用组件。
1. 泛型方法
在TypeScript里，声明泛型方法有以下两种方式：

function gen_func1<T>(arg: T): T {
 return arg;
}
// 或者
let gen_func2: <T>(arg: T) => T = function (arg) {
 return arg;
}

调用方式也有两种：
gen_func1<string>('Hello world');
gen_func2('Hello world'); // 第二种调用方式可省略类型参数，因为编译器会根据传入参数来自动识别对应的类型。
2. 泛型与Any
Ts 的特殊类型 Any 在具体使用时，可以代替任意类型，咋一看两者好像没啥区别，其实不然：

// 方法一：带有any参数的方法
function any_func(arg: any): any {
 console.log(arg.length);
        return arg;
}
// 方法二：Array泛型方法
function array_func<T>(arg: Array<T>): Array<T> {
     console.log(arg.length);
        return arg;
}

方法一，打印了arg参数的length属性。因为any可以代替任意类型，所以该方法在传入参数不是数组或者带有length属性对象时，会抛出异常。
方法二，定义了参数类型是Array的泛型类型，肯定会有length属性，所以不会抛出异常。
3. 泛型类型
泛型接口：

interface Generics_interface<T> {
 (arg: T): T;
}
function func_demo<T>(arg: T): T {
 return arg;
}
let func1: Generics_interface<number> = func_demo;
func1(123); // 正确类型的实际参数
func1('123'); // 错误类型的实际参数

3.3 自定义类型：Interface vs Type alias
Interface，国内翻译成接口。
Type alias，类型别名。

Typescript 中的 interface 和 type 到底有什么区别
1. 相同点
都可以用来描述一个对象或函数：

interface User {
 name: string
 age: number
}
type User = {
 name: string
 age: number
};
interface SetUser {
 (name: string, age: number): void;
}
type SetUser = (name: string, age: number): void;

都允许拓展（extends）：
interface 和 type 都可以拓展，并且两者并不是相互独立的，也就是说interface可以 extends type, type 也可以 extends interface 。虽然效果差不多，但是两者语法不同。

interface extends interface
interface Name { 
 name: string; 
}
interface User extends Name { 
 age: number; 
}

type extends type

type Name = { 
 name: string; 
}
type User = Name & { age: number };

interface extends type

type Name = { 
 name: string; 
}
interface User extends Name { 
 age: number; 
}

type extends interface

interface Name { 
 name: string; 
}
type User = Name & { 
 age: number; 
}

2. 不同点
type 可以而 interface 不行
type 可以声明基本类型别名，联合类型，元组等类型

// 基本类型别名
type Name = string
// 联合类型
interface Dog {
 wong();
}
interface Cat {
 miao();
}
type Pet = Dog | Cat
// 具体定义数组每个位置的类型
type PetList = [Dog, Pet]

type 语句中还可以使用 typeof获取实例的类型进行赋值

// 当你想获取一个变量的类型时，使用 typeof
let div = document.createElement('div');
type B = typeof div

其他骚操作

type StringOrNumber = string | number; 
type Text = string | { text: string }; 
type NameLookup = Dictionary<string, Person>; 
type Callback<T> = (data: T) => void; 
type Pair<T> = [T, T]; 
type Coordinates = Pair<number>; 
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };

interface可以而 type不行
interface 能够声明合并

interface User {
 name: string
 age: number
}
interface User {
 sex: string
}
/*
User 接口为 {
 name: string
 age: number
 sex: string 
} */

interface 有可选属性和只读属性
1. 可选属性
2. 接口里的属性不全都是必需的。有些是只在某些条件下存在，或者根本不存在。例如给函数传入的参数对象中只有部分属性赋值了。带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个?符号。如下所示

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

只读属性
顾名思义就是这个属性是不可写的，对象属性只能在对象刚刚创建的时候修改其值。你可以在属性名前用 readonly来指定只读属性，如下所示：

interface User {
 readonly loginName: string;
 password: string;
}

上面的例子说明，当完成User对象的初始化后loginName就不可以修改了。
3.4 实现与继承：implementsvsextends
extends很明显就是ES6里面的类继承，那么implement又是做什么的呢？它和extends有什么不同？
implement，实现。与C#或Java里接口的基本作用一样，TypeScript也能够用它来明确的强制一个类去符合某种契约
implement基本用法：

interface IDeveloper {
 name: string;
 age?: number;
}
// OK
class dev implements IDeveloper {
 name = 'Alex';
 age = 20;
}
// OK
class dev2 implements IDeveloper {
 name = 'Alex';
}
// Error
class dev3 implements IDeveloper {
 name = 'Alex';
 age = '9';
}

而extends是继承父类，两者其实可以混着用： class A extends B implements C,D,E
搭配 interface和type的用法有：

3.5 声明文件与命名空间：declare 和 namespace
前面我们讲到Vue项目中的shims-tsx.d.ts和shims-vue.d.ts，其初始内容是这样的：

// shims-tsx.d.ts
import Vue, { VNode } from 'vue';
declare global {
 namespace JSX {
 // tslint:disable no-empty-interface
 interface Element extends VNode {}
 // tslint:disable no-empty-interface
 interface ElementClass extends Vue {}
 interface IntrinsicElements {
 [elem: string]: any;
 }
 }
}
// shims-vue.d.ts
declare module '*.vue' {
 import Vue from 'vue';
 export default Vue;
}

declare：当使用第三方库时，我们需要引用它的声明文件，才能获得对应的代码补全、接口提示等功能。
这里列举出几个常用的：

declare var 声明全局变量
declare function 声明全局方法
declare class 声明全局类
declare enum 声明全局枚举类型
declare global 扩展全局变量
declare module 扩展模块

namespace：“内部模块”现在称做“命名空间”
module X { 相当于现在推荐的写法 namespace X {)
跟其他 JS 库协同
类似模块，同样也可以通过为其他 JS 库使用了命名空间的库创建 .d.ts 文件的声明文件，如为 D3 JS 库，可以创建这样的声明文件：

declare namespace D3{
 export interface Selectors { ... }
}
declare var d3: D3.Base;

所以上述两个文件：
shims-tsx.d.ts，在全局变量 global中批量命名了数个内部模块。
shims-vue.d.ts，意思是告诉 TypeScript *.vue 后缀的文件可以交给 vue 模块来处理。
3.6 访问修饰符：private、public、protected
其实很好理解：
1. 默认为public
2. 当成员被标记为private时，它就不能在声明它的类的外部访问，比如：

class Animal {
 private name: string;
 constructor(theName: string) {
 this.name = theName;
 }
}
let a = new Animal('Cat').name; //错误，‘name’是私有的

protected和private类似，但是，protected成员在派生类中可以访问

class Animal {
 protected name: string;
 constructor(theName: string) {
 this.name = theName;
 }
}
class Rhino extends Animal {
 constructor() {
 super('Rhino');
 } 
 getName() {
 console.log(this.name) //此处的name就是Animal类中的name
 }
}

3.7 可选参数 ( ?: )和非空断言操作符（!.）
可选参数

function buildName(firstName: string, lastName?: string) {
 return firstName + ' ' + lastName
}
// 错误演示
buildName("firstName", "lastName", "lastName")
// 正确演示
buildName("firstName")
// 正确演示
buildName("firstName", "lastName")

非空断言操作符：
能确定变量值一定不为空时使用。
与可选参数不同的是，非空断言操作符不会防止出现 null 或 undefined。
let s = e!.name; // 断言e是非空并访问name属性

4. Vue组件的Ts写法
从 vue2.5 之后，vue 对 ts 有更好的支持。根据官方文档，vue 结合 typescript ，有两种书写方式：
**Vue.extend **

 import Vue from 'vue'
 const Component = Vue.extend({
     // type inference enabled
 })

vue-class-component

import { Component, Vue, Prop } from 'vue-property-decorator'
@Component
export default class Test extends Vue {
 @Prop({ type: Object })
 private test: { value: string }
}

理想情况下，Vue.extend 的书写方式，是学习成本最低的。在现有写法的基础上，几乎 0 成本的迁移。
但是Vue.extend模式，需要与mixins 结合使用。在 mixin 中定义的方法，不会被 typescript 识别到
，这就意味着会出现丢失代码提示、类型检查、编译报错等问题。
第二种：
4.1 vue-class-component
我们回到src/components/HelloWorld.vue

<template>
 <div class="hello">
 <h1>{{ msg }}</h1>
 </div>
</template>
<script lang="ts">
import { Component, Prop, Vue } from 'vue-property-decorator';
@Component
export default class HelloWorld extends Vue {
 @Prop() private msg!: string;
}
</script>
<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped></style>

有写过python的同学应该会发现似曾相识：vue-property-decorator这个官方支持的库里，提供了函数 **装饰器（修饰符）**语法
1. 函数修饰符 @
“@”，与其说是修饰函数倒不如说是引用、调用它修饰的函数。
或者用句大白话描述：@: "下面的被我包围了。"
举个例子，下面的一段代码，里面两个函数，没有被调用，也会有输出结果：

test(f){
 console.log("before ...");
 f()
        console.log("after ...");
 }
@test
func(){
    console.log("func was called");
}

直接运行，输出结果：
before ...
func was called
after ...
上面代码可以看出来:
① 只定义了两个函数：test和func，没有调用它们。
② 如果没有“@test”，运行应该是没有任何输出的。
但是，解释器读到函数修饰符“@”的时候，后面步骤会是这样：
① 去调用test函数，test函数的入口参数就是那个叫“func”的函数；
② test函数被执行，入口参数的（也就是func函数）会被调用（执行）；
换言之，修饰符带的那个函数的入口参数，就是下面的那个整个的函数。有点儿类似JavaScript里面的 function a (function () { ... });
2. vue-property-decorator和vuex-class提供的装饰器
vue-property-decorator的装饰器：
@Prop
@PropSync
@Provide
@Model
@Watch
@Inject
@Provide
@Emit
@Component (provided by vue-class-component)
Mixins (the helper function named mixins provided by vue-class-component)
vuex-class的装饰器：
@State
@Getter
@Action
@Mutation
我们拿原始Vue组件模版来看：

import {componentA,componentB} from '@/components';
export default {
    components: { componentA, componentB},
    props: {
 propA: { type: Number },
 propB: { default: 'default value' },
 propC: { type: [String, Boolean] },
 }
 // 组件数据
 data () {
 return {
 message: 'Hello'
 }
 },
 // 计算属性
 computed: {
 reversedMessage () {
 return this.message.split('').reverse().join('')
 }
 // Vuex数据
 step() {
     return this.$store.state.count
 }
 },
 methods: {
 changeMessage () {
 this.message = "Good bye"
 },
 getName() {
     let name = this.$store.getters['person/name']
     return name
 }
 },
 // 生命周期
 created () { },
 mounted () { },
 updated () { },
 destroyed () { }
}

以上模版替换成修饰符写法则是：

import { Component, Vue, Prop } from 'vue-property-decorator';
import { State, Getter } from 'vuex-class';
import { count, name } from '@/person'
import { componentA, componentB } from '@/components';
@Component({
 components:{ componentA, componentB},
})
export default class HelloWorld extends Vue{
    @Prop(Number) readonly propA!: number | undefined
 @Prop({ default: 'default value' }) readonly propB!: string
 @Prop([String, Boolean]) readonly propC!: string | boolean | undefined
 // 原data
 message = 'Hello'
 // 计算属性
    private get reversedMessage (): string[] {
     return this.message.split('').reverse().join('')
 }
 // Vuex 数据
 @State((state: IRootState) => state . booking. currentStep) step!: number
    @Getter( 'person/name') name!: name
 // method
 public changeMessage (): void {
 this.message = 'Good bye'
 },
 public getName(): string {
 let storeName = name
 return storeName
 }
    // 生命周期
 private created ()：void { },
 private mounted ()：void { },
 private updated ()：void { },
 private destroyed ()：void { }
}

正如你所看到的，我们在生命周期列表那都添加private XXXX方法，因为这不应该公开给其他组件。
而不对method做私有约束的原因是，可能会用到@Emit来向父组件传递信息。

4.2 添加全局工具
引入全局模块，需要改main.ts:

import Vue from 'vue';
import App from './App.vue';
import router from './router';
import store from './store';
Vue.config.productionTip = false;
new Vue({
 router,
 store,
 render: (h) => h(App),
}).$mount('#app');

npm i VueI18n

import Vue from 'vue';
import App from './App.vue';
import router from './router';
import store from './store';
// 新模块
import i18n from './i18n';
Vue.config.productionTip = false;
new Vue({
 router, 
 store, 
 i18n, // 新模块
 render: (h) => h(App),
}).$mount('#app');

但仅仅这样，还不够。你需要动src/vue-shim.d.ts：

// 声明全局方法
declare module 'vue/types/vue' {
 interface Vue {
 readonly $i18n: VueI18Next;
 $t: TranslationFunction;
 }
}

之后使用this.$i18n()的话就不会报错了。

4.3 Axios 使用与封装
如果只是想简单在Ts里体验使用Axios，可以安装vue-axios 简单使用Axios

$ npm i axios vue-axios

main.ts添加：

import Vue from 'vue'
import axios from 'axios'
import VueAxios from 'vue-axios'
Vue.use(VueAxios, axios)

然后在组件内使用：
Vue.axios.get(api).then((response) => {
console.log(response.data)
})
this.axios.get(api).then((response) => {
console.log(response.data)
})
this.$http.get(api).then((response) => {
console.log(response.data)
})
1. 新建文件request.ts
文件目录:

-api
 - main.ts // 实际调用
-utils
 - request.ts // 接口封装

2. request.ts文件解析

import * as axios from 'axios';
import store from '@/store';
// 这里可根据具体使用的UI组件库进行替换
import { Toast } from 'vant';
import { AxiosResponse, AxiosRequestConfig } from 'axios';
 /* baseURL 按实际项目来定义 */
const baseURL = process.env.VUE_APP_URL;
 /* 创建axios实例 */
const service = axios.default.create({
 baseURL,
 timeout: 0, // 请求超时时间
 maxContentLength: 4000,
});
service.interceptors.request.use((config: AxiosRequestConfig) => {
 return config;
}, (error: any) => {
 Promise.reject(error);
});
service.interceptors.response.use(
 (response: AxiosResponse) => {
 if (response.status !== 200) {
 Toast.fail('请求错误！');
 } else {
 return response.data;
 }
 },
 (error: any) => {
 return Promise.reject(error);
 });
export default service;

为了方便，我们还需要定义一套固定的 axios 返回的格式，新建ajax.ts：

export interface AjaxResponse {
 code: number;
 data: any;
 message: string;
}

3. main.ts接口调用：

// api/main.ts
import request from '../utils/request';
// get
export function getSomeThings(params:any) {
 return request({
 url: '/api/getSomethings',
 });
}
// post
export function postSomeThings(params:any) {
 return request({
 url: '/api/postSomethings',
 methods: 'post',
 data: params
 });
}

5. 编写一个组件
为了减少时间，我们来替换掉src/components/HelloWorld.vue，做一个博客帖子组件：

<template>
    <div class="blogpost">
        <h2>{{ post.title }}</h2>
        <p>{{ post.body }}</p>
        <p class="meta">Written by {{ post.author }} on {{ date }}</p>
    </div>
</template>
<script lang="ts">
import { Component, Prop, Vue } from 'vue-property-decorator';
// 在这里对数据进行类型约束
export interface Post {
    title: string;
    body: string;
    author: string;
    datePosted: Date;
}
@Component
export default class HelloWorld extends Vue {
    @Prop() private post!: Post;
    get date() {
        return `${this.post.datePosted.getDate()}/${this.post.datePosted.getMonth()}/${this.post.datePosted.getFullYear()}`;
    }
}
</script>
<style scoped>
h2 {
 text-decoration: underline;
}
p.meta {
 font-style: italic;
}
</style>

然后在Home.vue中使用并运行项目：

<template>
 <div class="home">
 <img alt="Vue logo" src="../assets/logo.png">
     <HelloWorld v-for="blogPost in blogPosts" :post="blogPost" :key="blogPost.title" />
 </div>
</template>
<script lang="ts">
import { Component, Vue } from 'vue-property-decorator';
import HelloWorld, { Post } from '@/components/HelloWorld.vue'; // @ is an alias to /src
@Component({
 components: {
 HelloWorld,
 },
})
export default class Home extends Vue {
 private blogPosts: Post[] = [
 {
 title: 'My first blogpost ever!',
 body: 'Lorem ipsum dolor sit amet.',
 author: 'Elke',
 datePosted: new Date(2019, 1, 18),
 },
 {
 title: 'Look I am blogging!',
 body: 'Hurray for me, this is my second post!',
 author: 'Elke',
 datePosted: new Date(2019, 1, 19),
 },
 {
 title: 'Another one?!',
 body: 'Another one!',
 author: 'Elke',
 datePosted: new Date(2019, 1, 20),
 },
 ];
}
</script>

十一T_T

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Vue3.0 前的 TypeScript 入门实践

本篇旨在讲Ts混入框架的使用：TypeScript 和 vue-property-decorator1. 使用官方脚手架构建npm install -g @vue/cli# ORyarn global add @vue/cli新的Vue CLI工具允许开发者使用 TypeScript 集成环境创建新项目。运行vue create my-app cd my-appyarn se...
复制链接

扫一扫