如何用vue-cli3腳手架搭建一個基于ts的基礎(chǔ)腳手架的方法

npm i nrm -g // 安裝
nrm ls // 查看可用源，及當(dāng)前源，帶*的是當(dāng)前使用的源
nrm use taobao // 切換源，使用源
nrm add <registry> <url> // 其中reigstry為源名，url為源的路徑
nrm del <registry> // 刪除對應(yīng)的源
nrm test npm // 測試源的響應(yīng)速度

npm i @vue/cli -g // 全局安裝

vue --version // 檢查是否安裝

npm list -g --depth 0 // 查看全局安裝的包
npm outdated -g --depth=0 // 查看需要更新的全局包
npm update 包名 -g // 更新全局安裝的包

vue create vue-cli3-ts

winpty vue.cmd create vue-cli3-ts

vue add @vue/typescript

// - 啟動服務(wù)
npm run serve
// - 打包編譯
npm run build
// - 執(zhí)行l(wèi)int
npm run lint
// - 執(zhí)行單元測試
npm run test:unit

<script lang="ts">
import { Component, Prop, Vue } from 'vue-property-decorator';

@Component
export default class HelloWorld extends Vue {
 @Prop() private msg!: string;
}
</script>

let title: string; // 類型注解
title = 'ts'; // 正確
title = 4; // 錯誤

let text = 'txt'; // 類型推論
text = 2; // 錯誤

let names: string[]; // Array<string>
names = ['Tom'];

let foo: any;
foo = 'foo';
foo = 3;

let list: any[];
list = [1, true, 'free'];
list[1] = 100;

function greeting (person: string): string {
 return 'Hello, ' + person;
}

// void 類型，常用于沒有返回值的函數(shù)
function warnUser (): void {
 alert('This is msg');
}

<template>
 <div class="hello">
 <input type="text" placeholder="請輸入新特性" @keyup.enter="addFeature" />
 <ul>
 <li v-for="feature in features" :key="feature">{{feature}}</li>
 </ul>
 </div>
</template>

<script lang="ts">
import { Component, Prop, Vue } from 'vue-property-decorator';

@Component
export default class Demo extends Vue {

 // 相當(dāng)于 data 中的數(shù)據(jù)項
 features: string[];
 constructor () {
 super();
 this.features = ['類型注解', '類型推論', '編譯型語言'];
 }

 // 相當(dāng)于 methods 中的方法
 addFeature (event: any) {
 console.log(event);
 this.features.push(event.target.value);
 event.target.value = '';
 }
}
</script>

constructor (private name = 'Tom') {
 super();
}

name: string;
constructor () {
 super();
 this.name = 'Tom';
}

get fullName () { return this.name; }
set fullName (val) { this.name = val; }

<template>
 <p>特性數(shù)量：{{count}}</p>
</template>
<script lang="ts">
 export default class Demo extends Vue {
 // 定義 getter 作為計算屬性
 get count () {
  return this.features.length;
 }
 }
</script>

interface Person {
 firstName: string;
 lastName: string;
}
function greeting (person: Person) {
 return `Hello, ${person.firstName} ${person.lastName}`;
}
const user = {firstName: 'Jane', lastName: 'user'};
console.log(greeting(user));

<template>
 <li v-for="feature in features" :key="feature.id">{{feature.name}}</li>
</template>
<script lang="ts">
 // 定義一個接口約束feature的數(shù)據(jù)結(jié)構(gòu)
 interface Feature {
 id: number;
 name: string;
 }
 
 export default class Demo extends Vue {
 private features: Feature[];
 
 constructor () {
  super();
  
  this.features = [
  {id: 1, name: '類型注解'},
  {id: 2, name: '類型推論'},
  {id: 3, name: '編譯型語言'}
  ]
 }
 }
</script>

interface Result<T> {
 data: T;
}

// 不使用泛型
interface Result {
 data: Feature[];
}

function getData<T>(): Result<T> {
 const data: any = [
 {id: 1, name: '類型注解'},
 {id: 2, name: '類型推論'},
 {id: 3, name: '編譯型語言'} 
 ];
 return {data};
}

// 調(diào)用
this.features = getData<Feature[]>().data;

function getData<T>(): Promise<Result<T>> {
 const data: any = [
 {id: 1, name: '類型注解'},
 {id: 2, name: '類型推論'},
 {id: 3, name: '編譯型語言'} 
 ];
 return Promise.resolve<Result<T>>({data});
}

// 調(diào)用 async 方式
async mounted () {
 this.features = (await getData<Feature[]>()).data;
}

// 調(diào)用 then 方式
mouted () {
 getData<Feature[]>().then((res: Result<Feature[]>) => {
 this.features = res.data;
 })
}

export default class Demo extends Vue {
 // Props() 參數(shù)是為 vue 提供屬性選項
 // !稱為明確賦值斷言，它是提供給ts的
 @Prop({type: String, require: true})
 private msg!: string;
}

// 通知父類新增事件，若未指定事件名則函數(shù)名作為事件名（駝峰變中劃線分隔）
@Emit()
private addFeature(event: any) {// 若沒有返回值形參將作為事件參數(shù)
 const feature = { name: event.target.value, id: this.features.length + 1 };
 this.features.push(feature);
 event.target.value = "";
 return feature;// 若有返回值則返回值作為事件參數(shù)
}

@Watch('msg')
onRouteChange(val:string, oldVal:any){
 console.log(val, oldVal);
}

// 類裝飾器表達(dá)式會在運(yùn)行時當(dāng)作函數(shù)被調(diào)用，類的構(gòu)造函數(shù)作為其唯一的參數(shù)。
function log(target: Function) {
 // target是構(gòu)造函數(shù)
 console.log(target === Foo); // true
 target.prototype.log = function() {
 console.log(this.bar);
}
// 如果類裝飾器返回一個值，它會使用提供的構(gòu)造函數(shù)來替換類的聲明。
}
@log
class Foo {
 bar = 'bar'
}
const foo = new Foo();
// @ts-ignore
foo.log();

<template>
 <div>{{msg}}</div>
</template>
<script lang='ts'>
 import { Vue } from "vue-property-decorator";
 function Component(options: any) {
 return function(target: any) {
  return Vue.extend(options);
 };
 }
 
 @Component({
 props: {
  msg: {
  type: String,
  default: ""
  }
 }
 })
 export default class Decor extends Vue {}
</script>

import Vue from 'vue';
import Component, { createDecorator, mixins } from 'vue-class-component';
export { Component, Vue, mixins as Mixins };

export function Prop(options) {
 if (options === void 0) { options = {}; }
 return function (target, key) {
 applyMetadata(options, target, key);
 createDecorator(function (componentOptions, k) {
  ;
  (componentOptions.props || (componentOptions.props = {}))[k] = options;
 })(target, key);
 };
}

/** @see {@link https://github.com/vuejs/vue-class-component/blob/master/src/reflect.ts} */
var reflectMetadataIsSupported = typeof Reflect !== 'undefined' && typeof Reflect.getMetadata !== 'undefined';
function applyMetadata(options, target, key) {
 if (reflectMetadataIsSupported) {
 if (!Array.isArray(options) &&
  typeof options !== 'function' &&
  typeof options.type === 'undefined') {
  options.type = Reflect.getMetadata('design:type', target, key);
 }
 }
}

export function createDecorator(factory) {
 return function (target, key, index) {
 var Ctor = typeof target === 'function'
  ? target
  : target.constructor;
 if (!Ctor.__decorators__) {
  Ctor.__decorators__ = [];
 }
 if (typeof index !== 'number') {
  index = undefined;
 }
 Ctor.__decorators__.push(function (options) { return factory(options, key, index); });
 };
}

module.exports = {
 devServer: {
 proxy: {
  '/api': {
  target: '<url>',
  changeOrigin: true,
  pathRewrite: {
  '^/api': ''
  }
  }
 }
 }
}

devServer: {
 before (app) {
 before (app) {
  app.get('/api/getList', (req, res) => {
  res.json({data: [{id: 1, name: 'vue'}]})
  })
 }
 }
}

"build:report": "vue-cli-service build --report"

configureWebpack: {
 externals: { // cdn 外鏈，避免包太大，首屏優(yōu)化
 'vue': 'Vue',
 'vue-router': 'VueRouter',
 'vuex': 'Vuex'
 }
}

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.6.10/vue.min.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/vue-router/3.1.3/vue-router.min.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/vuex/3.1.2/vuex.min.js"></script>

<!-- built files will be auto injected -->

<link rel="dns-prefetch" href="cdnjs.cloudflare.com" rel="external nofollow" >
<link  rel="preload" as="script">
<link  rel="preload" as="script">
<link  rel="preload" as="script">

devServer: {
 port: 8888
}

const WebpackBuildNotifierPlugin = require('webpack-build-notifier');
const path = require('path');

module.exports = {
 // 鏈?zhǔn)讲僮? chainWebpack: config => {
 // 移除 prefetch 插件，移動端對帶寬敏感
 // 路由懶加載，只對用戶頻繁操作的路由，通過 注釋 提前獲取
 // component: () => import(/* webpackChunkName: "about" */ /* webpackPrefetch: true */'../views/About.vue')
 config.plugins.delete('prefetch');
 
 // 生產(chǎn)打包才提示，開發(fā)不提示
 if (process.env.NODE_ENV === 'production') {
  config.plugin('build-notify').use(WebpackBuildNotifierPlugin, [{
  title: "My Project Webpack Build",
  logo: path.resolve("./img/favicon.png"),
  suppressSuccess: true
  }])
 }
 }
}