最近公司项目没有那么忙了，有看到微软出手的Ts这个语言大热，很受开发者的热爱，看来这家伙有过人之处，所以啊，就学习一下Ts在Vue里面的应用，未雨绸缪。作为it开发者，一定要保持不断学习的状态，不然很容易咔嚓的。这个行业有个好处，就是可以不断的学习，尝试新的东西，如果用一个技术长达5到10年，写同一句语句或者单词，真的是无聊枯燥。害处是要不断的学习，不喜欢，身体疲惫，也要假装很喜欢的，很有动力的学习。
微软实力宏厚，出品的工具都很优秀，vscode，outlook，办公三大件，window，我都很喜欢。所以同样看好ts这个工具。
Ts中文网--手册指南
TypeScript是JavaScript的一个超集，js是弱类型语音，Ts可以约束变量的类型，弥补了该不足。代码更严谨。我是刚刚开始学习，至于有什么其他优点，还没有体会到。严谨，严谨，严谨。暂时体会到这一点。
一、基础类型
支持布尔，数字，字符串，数组，元祖，枚举，any，Void,Null,Undefined,Never,Object;
感觉any，接口，object，字符串才是使用率最高的吧，其他了解一下就行
let isDone: boolean = false; //布尔
let decLiteral: number = 6; //数字
let name: string = "bob"; //字符串
let list: number[] = [1, 2, 3]; //数组
let x: [string, number] = ['hello', 10]; //元祖
enum Color {Red, Green, Blue} //枚举
let c: Color = Color.Green;
let notSure: any = 4; //any 与never相反
function warnUser(): void { //void
console.log("This is my warning message");
}
let u: undefined = undefined; //undefined与null
let n: null = null;
function infiniteLoop(): never { //never
while (true) {
}
}
declare function create(o: object | null): void; //object
create({ prop: 0 }); // OK
二、接口 (Interface)
接口是什么，上面的类型约束变量是一个个的进行，接口是一堆变量的类型约束。支持可选，只读属性。让开发者成套的撸代码。
使用如下：
interface fData {
carNo: string,
carType: string,
}
export default class extends Vue{
fData: fData | any = {
carNo: '',
registTime: '',
}
}
三、函数
无论是传入的参数，还是返回值，都需要约束类型。支持参数设置默认值，其余参数，this参数。
在vue页面中，get开头的函数是computed计算属性，可以不写返回值的约束类型。大佬灯如是说。
setAsOriderSateToVal(v: number): number {
if(v === 3){
return 7;
}else{
return 0;
}
}
四、泛型（用的应该比较少，看业务需求吧）
泛型就是传啥类型，它返回啥类型。传入数组返回数组；传入字符串返回字符串之类。有点那个自动识别的意思。Java语言有类似的概念。
//================函数中的泛型================
function itself<T>(a: T):T {
return a
}
//隐式调用
console.log(itself(true)) // true
//显示调用 建议初学者用这个，看得懂
console.log(itself<boolean>(true)) // true
//================接口与泛型配合使用================
//有点像，一堆特定类型结构，返回类似该特定的类型结构
interface Human{
name: string,
age: number
}
function create<T>(returnV: T): T{
return returnV;
}
//使用
create<Human>({
name: 'stephenWu5',
age: 18
})
//================可以用泛型接口来结束该函数================
interface cfn<T> {
(arg: T): T
}
let myFun: cfn;
myFun = function<T>(arg: T):T{
return arg;
}
myFun<string>('x') // 返回x
五、枚举
枚举几乎没有使用，之前在公司中需要那种键值对，都是写Json对象，遍历该对象拿到需要的值。
官方给的介绍是： 使用枚举我们可以定义一些带名字的常量。 使用枚举可以清晰地表达意图或创建一组有区别的用例。
其实枚举和Json对象都可以实现业务需求。哪个都无所谓。两者在功能上几乎没有区别。你用哪个还不是一样的用。讲道理是有区别的，要不TypeScript也不会给出。
//json的写法
export const Dierection = { //
SZZS:"上证指数",
SZCZ:"深圳成指",
}
//枚举的写法
enum Dierection{
SZZS = '上证指数',
SZCZ = '深圳成指',
}
印象中都是在前端的查询页面中渲染下拉框时使用。使用语法： v-for="(item,key) of Dierection"。
六、 类型兼容性
其实这个用的也是算少的啰，因为平时写代码的时候习惯需要什么类型，就定义什么类型（连内部的子类型都定义的一模一样），写不一样不就是抬石头砸自己的脚吗？
就是TS语言中赋值时，编译器会检查x中每个属性，能否在y中找到对应属性。主要是用于子类型的检查。
interface Named {
name: string;
}
let x: Named;
let y = { name: 'Alice', location: 'Seattle' };
//y 能给 x提供对应的属性，所以没有报错
x = y;
//这样子就报错了
y = x; //error
官方文档中比较2个函数的例子：
let x = (a: number) => 0;
let y = (b: number, s: string) => 0;
//目前还没有理解为啥是这样，看了官方的解释还是没法理解。也许是参数可以忽略吧。返回值那个例子倒是很容易理解。
y = x; // OK
x = y; // Error
枚举类型与数字类型兼容，数字类型与枚举类型兼容。不同枚举类型之间是不能兼容。
下面的短小内容让我们更好的里面泛型的概念。
因为TypeScript是结构性的类型系统，类型参数只影响使用其做为类型一部分的结果类型。
//
interface Empty<T> {
}
let x: Empty<number>;
let y: Empty<string>;
x = y; // OK, because y matches structure of x
//泛型类型使用时就好像不是一个泛型类型了。
interface NotEmpty<T> {
data: T;
}
let x: NotEmpty<number>;
let y: NotEmpty<string>;
x = y; // Error, because x and y are not compatible
没有指定泛型类型的泛型参数时，默认所有的泛型为any。所以用结果类型比较时，就不会报错。代码如下:
let identity = function<T>(x: T): T {
// ...
}
let reverse = function<U>(y: U): U {
// ...
}
identity = reverse; // OK, because (x: any) => any matches (y: any) => any
七、高级类型（躲开）
一般看到那些高级内容，羞涩难懂,项目中用的少，我都是选择躲开。之前在大学时代啥都学学，很多用不到，浪费时间和力气。经一事长一智。要学多用的。
八、Symbols
之前一段时间在地铁里看一本es6的电子书，了解这个概念。就是一个新型的类型。symbol类型的值是通过Symbol构造函数创建的。就算传入一模一样的字符串参数，他们的值也是不一样的，这个特点让我印象深刻。可以作为对象属性的键值对中的键使用，永远不会和其它键名冲突。
这家伙的使用场景还没有想到，几乎没有使用过，哈哈。
九、命名空间
命名空间就是内部模块，ts所说的模块一般是外部模块。命名空间是为了解决变量名污染和代码维护性而来的。当一个web应用需求越来越多，代码越来越多，为了提高代码的维护性，最好是按照功能拆分一个文件成多个文件。拆分后的文件使用同一个命名空间，那么在使用的时候就如同定义在同一个文件。
使用命名空间里面的变量，接口，方法等，需要xxx.。xxx是命名空间的名称。
//还支持别名呢（多套一个namespace而已）
namespace Shapes {
export namespace Polygons {
export class Triangle { }
export class Square { }
}
}
import polygons = Shapes.Polygons;
let sq = new polygons.Square(); // Same as "new Shapes.Polygons.Square()"
一般上面所说的命名空间用的少，使用的话会增加额外的模块层，可以改名命苦空间了；但是还有一种命名空间叫外部命名空间，它的使用率很高，没有它不行。js的库或者开发者自己写的工具类js，使用普通的javascript写的，如果直接导入到ts文件，它会识别不了，报错。外部命名空间就是出场解决这个问题，让ts编译器识别上述文件变量和方法的类型（不可能用重写jquery等库一遍吧）。
外部命名空间使用主要走两步：
第一步：一般是在原有路径新增一个xxx.d.ts文件；
export = pinyin;
declare namespace pinyin {
export const codefans: (value: string) => any
export const arraySearch: (value: string) => any
export const ucfirst: (value: string) => any
}
第二步： 编辑tsconfig.json文件，添加合适的路径。
"include": [
"src/**/*.ts",
],
十、后续
官网的基础手册后面的内容还有声明合并，jsx，修饰器，Mixins，三斜线指令，文件类型检查等等。粗粗看了一下，声明合并，就是你在声明命名空间，接口，类，枚举时，如果名字重复了，它会帮你做合并处理(当然不是所有的，类不能和其他类，变量合并)，你会用的很少的，因为写代码不会写两个重复的名字（编辑器有提示），你不会傻到抬石头砸自己的脚；jsx会用，但是在vue项目中用的很少，除非是需要那个虚拟dom。以后遇到react项目再详细看；修饰器属于高级的东西，以后熟练TS项目（搞一搞项目），再详细看，否则很难用的到。（其实是我懒不想学哈哈）；Mixins就是支持把源对象的属性，方法复制到目标对象上，官网上有个很好的例子，需要的时候再来copy吧；三斜线指令，文件类型检查了解一下就行了，没有必要细细研究，用的少。以后需要再过来看，时间宝贵。
Ts中文网--声明文件
就是教你如何写声明文件。(项目中大量用到)
结构
全局库。在全局命名空间下可以访问，暴露出x个全局变量。在它的源码中，可以看到：顶级的var语句或function声明，一个或多个赋值语句到window.someName，DOM原始值像document或window是存在的。现在他妈的全局库都转UMD库了。很少保持全局的姿态。全局库的使用模版是global.d.ts。全局插件使用global-plugin.d.ts，全局修改模块使用global-modifying-module.d.ts。
模块化库。工作在模块加载器的环境下。模块化库的源码可以看到：无条件的调用require或define，像import * as a from 'b'; or export c;这样的声明，赋值给exports或module.exports。很多流行的nodejs库都是这类。模块能够作为函数调用，使用module-function.d.ts；模块能够使用new来构造，module-class.d.ts；模块不能被调用或构造，使用module.d.ts文件；如果是模块插件，就使用module-plugin.d.ts
UMD。名字起的很专业，其实就是上面功能的相加。可以模块导入，也可以全局使用。源码里看到了typeof define，typeof window，或typeof module这样的测试，尤其是在文件的顶端，那么它几乎就是一个UMD库。这种库很主流。
举例
这里手把手教你书写。这一块的内容不用记，知道有这个事就行了，以后忘记写了就过来查。都是一些规则而已。重点学会带属性的对象够受用的了。
全局变量
//代码
console.log(foo)
//声明
declare var foo: number;
declare const foo: number; //只读
declare let foo: number; //块级作用域
全局函数
//代码
greet('hello world')
//声明
declare function greet(greeting: string): void;
带属性的对象（使用率最高）
//原代码
let result = myLib.makeGreeting("hello, world");
let count = myLib.numberOfGreetings;
//声明
declare namespace myLib{
function makeGreeting(greeting: string): void;
let numberOfGreetings: number;
}
函数重载
//代码
let x: Widget = getWidget(43);
let arr: Widget[] = getWidget("all of them");
//声明
declare function getWidget(n: number): Widget;
declare function getWidget(s: string): Widget[];
可重用类型（接口）
//代码
greet({
greeting: "hello world",
duration: 4000
});
//声明
interface greetO{
greeting: string;
duration?: number;
}
declare function greet(greeting: greetO):void;
可重用类型（类型别名）
//代码
function getGreeting() {
return "howdy";
}
class MyGreeter extends Greeter { }
greet("hello");
greet(getGreeting);
greet(new MyGreeter());
//声明
type paraType = string || (()=> string) || MyGreeter;
declare function greet(g: paraType): void;
组织类型
//代码
const g = new Greeter("Hello");
g.log({ verbose: true });
g.alert({ modal: false, title: "Current Greeting" });
//声明
declare namespace GreetingLib{
interface LogOptions {
verbose?: boolean;
}
interface AlertOptions {
modal: boolean;
title?: string;
}
}
类
//代码
const myGreeter = new Greeter("hello, world");
myGreeter.greeting = "howdy";
myGreeter.showGreeting();
class SpecialGreeter extends Greeter {
constructor() {
super("Very special greetings");
}
}
//声明
declare class myGreeter{
constructor(){
super(greeting:string)
}
greeting: string;
showGreeting(): void;
}
规范
尽量使用numberstringoolean，不要使用NumberStringBoolean；
回调函数的返回值被忽略时返回void而不是any；
尽量写出回调函数的非可选参数；不要因为回调函数参数个数不同而写不同的重载：用最大参数写一个重载就可以；
当不得不重载时，最细分的重载写在前面，大概的写在后面；否则会被覆盖的；
如果仅仅是尾部参数不同，不要写不同的重载，选择可选参数；
仅仅是某个位置的参数类型不同时，可以使用联合类型。例如number|string
除了第一第二点，其他都是优化的，尽量使用这个规则吧（其实不使用也行，多写几行代码。）
Ts中文网--项目配置
官网详细点。
Ts在Vue中的使用
使用vue-property-decorator这个插件，利用修饰符可以简化书写。
1. @Component （使用率很高）
组件，做前端一定要有组件的能力，提高代码的使用率（省无数代码），开发效率大大提高，省事更省心。有一次面试，面试官说了2次：“会不会写组件？写组件的能力一定要有。”of course。上一家公司快离开时，技术大佬成哥说：有时间多写写自己的组件，提高自己的技术。所以咬咬牙结合项目需求写了两个支持sync特性的组件，还挂在博客园（之前都是维护，没写过自己的）。
//js的写法
export default{
components: {
CountDown,
TcLocpicker,
}
}
//ts的写法
import {
Component,
Vue,
Watch
} from "vue-property-decorator";
@Component({
components: {
CountDown,
TcLocpicker,
},
filters: {
upper(v: string){
if (!v) return '';
return v.toString().toUpperCase();
}
},
})
export default class extends Vue{
}
2. @Prop （常用）
使用过vue的同学都知道，这是父组件传给子组件的参数，使用率很高。它在class里面的写法是
!:是必须要有的意思。
之前我在项目内插入这个ts，有一个关于prop的报错，报错内容不是很详细的，因为是硬加入项目内，其它地方有很多警告。当然项目是可以跑起来的。我找了2小时也找不到，后来发现是Prop的第一个P没有大写。(注意：所有vue-property-decorator的@开头的变量都是大写的)所以啊，写代码细心很重要。还有一个原因我用的是vim编辑器，如果是vscode编辑器，会出现提示内容。所以以后发现报错一定要结合vscode来找才快。
//js的写法
export default{
props:{
mecType: Number
}
}
//ts的写法
export default class extends Vue {
import {Vue, Component,Prop} from 'vue-property-decorator';
//props
//写法1
@Prop(String)
mecType!: string;
//写法2
@Prop([String,Number])
mecType: string | number;
//写法3
@Prop({
type: Number,
default: 0,
required: true,
validator: (value) => {
return [
'InProcess',
'Settled'
].indexOf(value) !== -1
}
})
mecType!: number;
}
3. data （常用）
这个data的使用率是最高的了，就连静态页面也是存在的。有一个.vue文件就有它。
//js的写法
export default{
data: function(){
return {
loading: false,
mec_Type: 'a'
}
}
}
//ts的写法 很简单吧哈哈
export default class extends Vue {
loading: boolean = false;
mec_Type: string = "a"; //选择的机构类型
}
4. methods （常用）
methods里面的方法终于可以不用methods包起来，和那些周期函数created,mounted,
平起平坐了，熬出头了。
//js的写法
export default{
methods: {
fn1: function(){
}
}
}
//ts的写法
export default class extends Vue {
fn1: function(){
}
}
5. computed （较多）
计算属性在组件里面很实用，一般是监听几个变量的变化去改变计算属性值。上一家公司的时候我很少用计算属性，后来用了一下，确实少写许多代码。所以啊，想少写代码，一定去多使用它！,计算属性已经成为我的心头好。
computed在class里面的方法的写法很简单，就是在方法名前面加上get。
//js的写法
export default{
computed: {
currentRoleId() {
return store.getters.roles
},
}
}
//ts的写法 很简单吧哈哈
export default class extends Vue {
get currentRoleId() {
return store.getters.roles
},
}
6. @Watch （较多）
监听一个变量的是否变化，执行一个方法；该方法不能改变这个变量。否则就会没完没了。有一次确实踩过这个坑，页面上的按钮一点，页面卡住了。加上console.log语句，发现打印20000+，真的是流汗。后来周日加班摆平了，血与泪的教训。
//js的写法
export default{
watch: {
'orderSate': {
handler: 'setAsOriderSateToVal',
immediate: true,
deep: true
}
},
methods: {
setAsOriderSateToVal(val, oldVal) { }
}
}
//ts的写法 很简单吧哈哈
export default class extends Vue {
@Watch('orderSate')
onChangeOriderSate(v: any, oldv: any) {
this.setAsOriderSateToVal(v);
};
setAsOriderSateToVal(v){
};
}
7. @Emit （算多）
主要作用就是通讯。其实就是写组件的时候，父组件需要拿到子组件里面的值。怎么办啊，用这个概念从子组件里面发射到父组件里面（emit中文就是发射）。印象中用的最多的就是在页面中按一个添加，弹出一个框，这个框选择一个值，同时这个值传递到页面所在的组件中。
//js的写法
export default{
addToCount(n) {
this.count += n
this.$emit('add-to-count', n)
},
resetCount() {
this.count = 0
this.$emit('reset')
},
}
//ts的写法 很简单吧哈哈
export default class extends Vue {
@Emit()
addToCount(n: number) {
this.count += n
};
@Emit('reset')
resetCount() {
this.count = 0
};
}
8. @Provide和@Inject （少见）
作用是通讯。子组件需要拿到父组件的值，但是业务逻辑复杂时，需要组件之间几层的嵌套，他包她，她包它，它又包另外一个组件。这种情况啊，props不容易拿到，得写好几层props,看到你头痛：我在哪里啊？。所以啊，为了简单达到这个目的: 曾曾子组件一次性拿到父组件的变量，就需要Provide和Inject哈。
//js的写法
export default {
//==========子组件取值=======================
inject: {
foo: 'foo',
bar: 'bar'
},
//或者使用这种方式 --在xx收款项目中确实这样使用过
inject: ['foo','bar'],
//===========父组件注入======================
provide () {
return {
foo: this.foo,
bar: this.baz
}
},
}
//ts的写法 很简单吧哈哈
import {Vue,Component,Inject,Provide} from 'vue-property-decorator';
export default class extends Vue {
//==========子组件取值=======================
@Inject()
foo!: string;
@Inject('bar')
bar!: string;
//===========父组件注入======================
@Provide()
foo = 'foo'
@Provide('bar')
baz = 'bar'
}
总结一下，项目配置这一块其实就是换个写法而已，什么computed，methods，data，watch这些都是一些老的概念，没有出现什么新的概念点。只要记住新的写法或者说写的时候查一下文档就可以了。最后感谢大佬灯给我提供TypeScript的学习资料。现在我已经有维护和迭代TypeScript项目的能力了。
最后，欢迎关注我的公众号。
