摘要:訪問(wèn)越界的元素,使用聯(lián)合類型替代。構(gòu)造函數(shù)不能聲明返回類型。在子類中運(yùn)行構(gòu)造函數(shù)式繼承實(shí)現(xiàn)對(duì)父類的構(gòu)造函數(shù)繼承。的核心原則之一是對(duì)值所具有的進(jìn)行類型檢查。外部模塊則稱之為模塊語(yǔ)法通過(guò)關(guān)鍵字,將模塊的方法屬性暴露出來(lái)。
介紹
TypeScript是JavaScript的超集,為JavaScript的生態(tài)增加了類型機(jī)制,并最終將代碼編譯為純粹的JavaScirpt代碼。
編譯</>復(fù)制代碼
瀏覽器加載文件編譯
注意,編譯的TypeScript文件需要放在編譯文件之前
</>復(fù)制代碼
</>復(fù)制代碼
自動(dòng)化構(gòu)架工具
1:fis
fis插件:fis-parser-typescript
</>復(fù)制代碼
var fis = require("fis3");
var typescirpt = require("fis3-parser-typescript");
fis.match("**.ts", {
parser: fis.plugin("typescript"),
rExt: ".js"
});
2: gulp
使用gulp插件:gulp-typescript
</>復(fù)制代碼
var gulp = require("gulp");
var ts = require("gulp-typescript");
gulp.task("compileTs", function () {
gulp.src("**.ts")
.pipe(ts())
.pipe(gulp.dest("dist"));
});
gulp.task("default", ["compileTs"]);
基礎(chǔ)類型
typescript囊括了所有JavaScript基本類型
基本類型number 數(shù)字類型
string 字符串類型
boolean 布爾類型
any 任意一種
數(shù)組定義數(shù)組
兩部分:前面一部分表示數(shù)組成員的類型,后面一部分表示告知是一個(gè)數(shù)組。
</>復(fù)制代碼
let arr:number[] = [12, 23];
let colors:any[] = [12, "cyan", "pink"]; // 數(shù)組任意類型
let list:Array = [1, 2, 3]; // 數(shù)組泛型
元組
Tuple
元組類型允許表示一個(gè)已知元素?cái)?shù)據(jù)和類型的數(shù)組,各元素的類型不必相同。
</>復(fù)制代碼
let x: [string, number] = ["cyan", 10];
訪問(wèn)越界的元素,使用聯(lián)合類型替代。
枚舉定義:enum colors { red, green, blue }
表義一種可以一一列舉的數(shù)據(jù)
特點(diǎn):
通過(guò)索引值訪問(wèn)定的數(shù)據(jù)。
通過(guò)定義的數(shù)據(jù)訪問(wèn)索引值。
對(duì)枚舉類型的數(shù)據(jù)添加起始索引值。
</>復(fù)制代碼
enum color {
red = 10, // 默認(rèn)索引值從0 開(kāi)始, 可以指定索引值
green,
blue
}
// 編譯之后: Object {10: "red", 11: "green", 12: "blue", red: 10, green: 11, blue: 12}
空值
void 類型 像是 與 any 類型相反,它表示沒(méi)有任何類型。 當(dāng)一個(gè)函數(shù)沒(méi)有返回值時(shí), 要指定 void 類型。
void 類型 只能賦值: undefiend 和 null。
</>復(fù)制代碼
let unvoid: void = null;
let unvoid1: void = undefined;
undefiend和null
undefeind和null兩者有各自的類型: undefined和null。 和void相似。
</>復(fù)制代碼
let u: undefined = undefined;
let n: null = null;
默認(rèn)情況下null 和undefined 是所有類型的子類型。
可以把null 和undefined賦值給number類型的變量。
類型斷言,類似其它語(yǔ)言里的類型轉(zhuǎn)換。但是不進(jìn)行特殊的數(shù)據(jù)檢查和解構(gòu)。 沒(méi)有運(yùn)行時(shí)的影響,只是在編譯階段其作用。
尖括號(hào)<>語(yǔ)法
</>復(fù)制代碼
let someValue: any = "colors";
let strlength: number = (someValue).length;
console.log(strlength);
變量聲明
let&const
const 是對(duì)let的一個(gè)增強(qiáng),能阻止對(duì)一個(gè)變量再次賦值。
let 和 const 的區(qū)別:
所有變量除了計(jì)劃要去修改的都應(yīng)該使用const。
基本原則就是如果一個(gè)變量不需要對(duì)它寫入,那么其它使用這些代碼的人也不能夠?qū)懭胨鼈儭?br>使用const可以更容易推測(cè)數(shù)據(jù)的流動(dòng)性。
解構(gòu)數(shù)組
不需要指定類型
</>復(fù)制代碼
let input = [1, 2];
let [fisrt, second] = input;
console.log(fisrt, second); // 1 ,2
對(duì)象結(jié)構(gòu)
</>復(fù)制代碼
let o = {
a: "foo",
b: 12,
c: "bar"
}
let {a, b} = o;
console.log( a, b );
函數(shù)
TypeScript函數(shù)可以創(chuàng)建有名字的函數(shù)和匿名函數(shù)
TypeScript函數(shù)執(zhí)行返回值需要定義數(shù)據(jù)類型,如果沒(méi)有結(jié)果則要定義為void。
TypeScript函數(shù),參數(shù)需要定義類型,在調(diào)用的時(shí)候,傳遞的參數(shù)一定要跟定義時(shí)的參數(shù)個(gè)數(shù)一樣。否則編譯報(bào)錯(cuò)。
</>復(fù)制代碼
function add (a:number, b:number):number {
return a + b;
}
let sum = add(10, 20);
console.log( sum );
</>復(fù)制代碼
// 定義void返回值
setProperty();
function setProperty (): void {
console.log("success");
}
可選參數(shù)和默認(rèn)參數(shù)
在TypeScript中可以在參數(shù)名旁邊使用 ? 實(shí)現(xiàn)可選參數(shù)
</>復(fù)制代碼
function count (str1: string, str2?: string): string {
return str1 + "--" + str2;
}
let reslut = count("xixi");
console.log( reslut );
剩余參數(shù)
剩余參數(shù)會(huì)被當(dāng)作個(gè)數(shù)不限的可選參數(shù)。可以一個(gè)都沒(méi)有,同樣也可以有任意個(gè)。
語(yǔ)法:...nameProperty
</>復(fù)制代碼
function builName (numa1: string, ...restOfName: string[]) { // 剩余參數(shù)保存在數(shù)組中
}
Class
在TypeScript中,可以通過(guò)Class來(lái)定義一個(gè)類。在編譯之后,會(huì)編譯成JavaScript一個(gè)閉包函數(shù)類。
語(yǔ)法: class className {}
成員方法,成員屬性在類中添加的屬性會(huì)編譯到構(gòu)造函數(shù)中,該屬性如果不賦值,則不會(huì)被編譯.
在類中添加的方法會(huì)編譯到構(gòu)造函數(shù)的Prototype上。
</>復(fù)制代碼
class Price {
price: number = 10;
fn( num: number ): string {
return num * 2;
}
}
編譯之后的結(jié)果:
</>復(fù)制代碼
//Compiled TypeScript
var Price = (function () {
function Price() {
this.price = 10;
}
Price.prototype.fn = function (num) {
return num * 2;
};
return Price;
})();
靜態(tài)屬性,靜態(tài)方法
靜態(tài)屬性:通過(guò)static關(guān)鍵字定義,定義的該屬性,在 類中訪問(wèn)不到, 因?yàn)槎x在類上。
靜態(tài)方法:通過(guò)static關(guān)鍵字定義,定義的該方法,在類中是訪問(wèn)不到(不能通過(guò)this訪問(wèn)),因?yàn)樵摲椒ǘx在類上。
</>復(fù)制代碼
class Person {
static name: string = "time";
static fn(num: number): void {
console.log("success");
}
}
let p1: Peson = new Person(); // 實(shí)例化
編譯之后:
</>復(fù)制代碼
var Person = (function () {
function Person() {
}
Person.fn = function (num) {
console.log("success");
console.log(Peson.name);
};
Person.name = "time";
return Person;
})();
var p1 = new Person();
構(gòu)造函數(shù)
在實(shí)例化的時(shí)候被調(diào)用
構(gòu)造函數(shù)中定義的語(yǔ)句會(huì)編譯到JavaScript的構(gòu)造函數(shù)中。
構(gòu)造函數(shù)不能聲明返回類型。
類定義的屬性(賦值的屬性)會(huì)被編譯到JavaScirpt的構(gòu)造函數(shù)中。
</>復(fù)制代碼
class Book {
name: string;
page: number = 400;
constructor(bookName: string) {
this.name = bookName;
console.log(bookName);
}
}
let p1: Book = new Book("莊子");
編譯之后:
</>復(fù)制代碼
var Book = (function () {
function Book(bookName) {
this.page = 400;
this.name = bookName;
console.log(bookName);
}
return Book;
})();
var p1 = new Book("莊子");
繼承
語(yǔ)法:子類 extends 父類
</>復(fù)制代碼
class Base {
press: string = "one";
}
class Book extends Base {
name: string = "老子";
sayName(): string {
return this.name;
}
}
let b: Book = new Book();
let bookname = b.sayName();
console.log(bookname);
編譯之后:
通過(guò)的是混合式繼承
</>復(fù)制代碼
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
this.press = "one";
}
return Base;
})();
var Book = (function (_super) {
__extends(Book, _super);
function Book() {
_super.apply(this, arguments);
this.name = "老子";
}
Book.prototype.sayName = function () {
return this.name;
};
return Book;
})(Base);
var b = new Book();
var bookname = b.sayName();
console.log(bookname);
——extends(); 方法
</>復(fù)制代碼
var __extends = this.__extends || function (d, b) { // b 父類
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
目的, 實(shí)現(xiàn)只繼承 父類的原型對(duì)象。 從原型對(duì)象入手
1,function __() {}創(chuàng)建一個(gè)空函數(shù), 目的:空函數(shù)進(jìn)行中轉(zhuǎn),把父類的模板屏蔽掉, 父類的原型取到。
2,__.prototype = b.prototype實(shí)現(xiàn)空函數(shù)的原型對(duì)象 和 超類的原型對(duì)象轉(zhuǎn)換
3,d.prototype = new __()原型繼承
使用for-in循環(huán),子類繼承父類的靜態(tài)屬性或方法。(通過(guò)一個(gè)函數(shù)中轉(zhuǎn),實(shí)現(xiàn),只實(shí)例化一次,且繼承了一次父類的原型對(duì)象)
通過(guò)寄生類繼承父類原型上的屬性或方法。
在子類中運(yùn)行構(gòu)造函數(shù)式繼承實(shí)現(xiàn)對(duì)父類的構(gòu)造函數(shù)繼承。
super()
在包含constructor函數(shù)的子類中必須調(diào)用super().它會(huì)執(zhí)行基類的構(gòu)造方法。
傳遞給super()方法就是實(shí)現(xiàn)構(gòu)造函數(shù)繼承屬性
子類構(gòu)造函數(shù)中添加屬性。
繼承父類構(gòu)造函數(shù)中的屬性,如果子類定義構(gòu)造函數(shù)就必須繼承。
</>復(fù)制代碼
class Base {
press: string = "one";
name: string;
constructor ( bookName: string ) {
this.name = bookName;
}
}
class Book extends Base {
price: number;
// name: string = "老子";
constructor(bookName: string, price: number) {
// 父類繼承屬性
super(bookName); // 會(huì)執(zhí)行父類的 constructor
this.price = price;
}
sayName(): string {
return this.name;
}
}
let b: Book = new Book("老子", 40);
let bookname = b.sayName();
console.log(bookname);
接口
在TypeScript中,接口的作用:為這些類型命名和為你的代碼或第三方代碼定義契約。
TypeScript的核心原則之一是:對(duì)值所具有的shape進(jìn)行類型檢查。
定義一種數(shù)據(jù)格式,來(lái)約束變量的類型。
接口中定義的每個(gè)接口,都可以當(dāng)作一種類型來(lái)使用。
可選實(shí)現(xiàn)成員,可以在后面添加?.
語(yǔ)法:interface names {};
接口定義對(duì)象</>復(fù)制代碼
// 定義接口
interface Person {
name: string;
age: number;
sex: string;
hobby?: any;
}
// 使用接口
function getName (person: Person): string {
return person.name;
}
// 實(shí)現(xiàn)接口
var n: string = getName({
name: "one",
age: 23,
sex: "nv"
});
console.log(n);
接口函數(shù)
語(yǔ)法:interface name {}
定義函數(shù)格式.通過(guò)()來(lái)定義參數(shù)個(gè)數(shù),并聲明函數(shù)返回值類型。
作用:限制了定義該函數(shù)類型的規(guī)范。
</>復(fù)制代碼
// 定義抽象類
interface Add {
(num1: number, num2: number): number;
}
// 使用接口
let fn:Add;
// 實(shí)現(xiàn)接口
fn = function ( num1: number, num2: number ): number {
return num1 + num2;
}
var reslut: number = fn(10 , 20);
console.log(reslut);
類的接口定義
語(yǔ)法:
</>復(fù)制代碼
interface className {
key: type;
fn(arg: type): type;
}
實(shí)現(xiàn)接口:
</>復(fù)制代碼
class Times implements Base {}
作用:保證代碼的安全性
</>復(fù)制代碼
"use strict";
// 時(shí)間接口
interface Base {
current: string;
getCurrentDate(): string;
}
// 使用接口
class Times implements Base {
current: string;
constructor( d: string ){
this.current = d;
}
getCurrentDate (): string {
return this.current;
}
}
let d: Times = new Times(new Date().toString());
console.log(d);
模塊
在TypeScript1.5中:內(nèi)部模塊 是說(shuō)所的命名空間。 外部模塊則稱之為模塊
語(yǔ)法:
</>復(fù)制代碼
module name {}
通過(guò) export關(guān)鍵字, 將模塊的方法屬性暴露出來(lái)。
在模塊的外部訪問(wèn)模塊,需要通過(guò)模塊名稱,點(diǎn)語(yǔ)法調(diào)用模塊內(nèi)部暴露的接口
</>復(fù)制代碼
"use strict";
// 定義模塊
module startModuel {
let info: string = "colors";
// 暴露一個(gè)class
export class Satrt {
name: string;
constructor(name: string) {
this.name = name;
}
getName(): string {
return this.name;
}
}
}
// 實(shí)例化模塊中暴露的接口
let satr:startModuel.Satrt = new startModuel.Satrt("cyan");
console.log( satr );
console.log(satr.getName());
模塊在其自身的作用域里執(zhí)行,而不是在全局作用域里。
一個(gè)模塊里的比那兩,函數(shù),類等等在模塊外部是不可見(jiàn)的,需要通過(guò)export形式向外暴露。
如果一個(gè)模塊想使用其它模塊導(dǎo)出的變量,函數(shù),類,接口等。需要使用import形成引入。
模塊是自聲明的。兩個(gè)模塊之間的關(guān)系是通過(guò)在文件級(jí)別上使用imports和 exports 建立聯(lián)系的。
導(dǎo)出導(dǎo)出聲明
</>復(fù)制代碼
export interface StringValidator {
isAcce(s: string): boolean;
}
export const numberRegExp = /^[0-9]+$/;
導(dǎo)出語(yǔ)句
</>復(fù)制代碼
export class ZipCode implements StringValidator {
isAcce(s: string) {
return s.length === 5 && numberRegExp.test(s);
}
}
// 導(dǎo)出語(yǔ)句
export { ZipCode }
導(dǎo)入
使用關(guān)鍵字:import 來(lái)導(dǎo)入其它模塊中的導(dǎo)出內(nèi)容
</>復(fù)制代碼
import { ZipCode } form "./ZipCode";
let myValid = new ZipCode();
</>復(fù)制代碼
// 對(duì)導(dǎo)入的內(nèi)容重新命名
import {ZipCode as ZVC } form ""./ZipCode;
let myValid = new ZVC();
默認(rèn)導(dǎo)出
每個(gè)模快都有一個(gè)defalut導(dǎo)出。 默認(rèn)導(dǎo)出使用default 關(guān)鍵字標(biāo)記。
例如:JQuery的類庫(kù)有一個(gè)默認(rèn)導(dǎo)出JQuery或$.
</>復(fù)制代碼
let $:jQuery;
export default $;
</>復(fù)制代碼
import $ from "JQuery";
模塊路徑解析
TypeScript存在兩種路徑解析方式: Node和Classic(原本TypeScirpt路徑解析規(guī)則,為了向后兼容)
TypeScript是模范Node運(yùn)行時(shí)解析策略來(lái)編譯階段定義模塊文件。
TypeScript在Node解析邏輯基礎(chǔ)上增加了TypeScript源文件的擴(kuò)展名(.ts,.tsx,.d.ts).
命名空間是位于全局命名空間下的一個(gè)普通的帶有名字的JavaScript對(duì)象
使用關(guān)鍵字:namespace
</>復(fù)制代碼
namescope Valiation {
export interface StringValidator {
isAcce(s: string): boolean;
}
const lettesRegExp = /^[A-Za-z]+$/;
}
多文件的命名空間
不同的文件,但是仍是同一個(gè)命名空間,并且在使用的時(shí)候,就如同他們?cè)谝粋€(gè)文件中定義的一樣。 因?yàn)椴煌募g存在依賴關(guān)系,所以加入了引用標(biāo)簽來(lái)告知編譯器文件之間的關(guān)聯(lián)。
</>復(fù)制代碼
namescope Valiation {
export interface StringValidator {
isAcce(s: string): boolean;
}
}
namescope Valiation {
const lettesRegExp = /^[A-Za-z]+$/;
expots class LetterOnly implements StringValidator {
isAcce(s: string): boolean {
return s.length && lettesRegExp.test(s);
}
}
}
</>復(fù)制代碼
// 測(cè)試
///
///
let strings = ["Hello", "98052"];
let validators: { [s: string]: Validation.StringValidator; } = {};
validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();
strings.forEach(s => {
for (let name in validators) {
console.log(""" + s + "" " + (validators[name].isAcce(s) ? " matches " : " does not match ") + name);
}
});
編譯方式:
把所有輸入的文件編譯一個(gè)輸出文件,需要使用--outFile標(biāo)記
tsc --outFile sample.js Test.ts
變異其會(huì)根據(jù)源碼中引用標(biāo)簽自動(dòng)的對(duì)輸出進(jìn)行排序。
可以多帶帶指定每個(gè)文件
tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts
可以編譯成每一個(gè)文件(默認(rèn)方式),每個(gè)源文件都會(huì)對(duì)應(yīng)生成一個(gè)JavaScript文件。然后,在頁(yè)面上通過(guò)