接口
例如我們這定義一個叫做printPost的函數，那這個函數可以接收一個文章對象參數post，然後在函數的內部去打印文章的title, 然後再去打印他的content屬性。
function printPost (post) {
console.log(post.title);
console.log(post.content);
}
那這個時候對於這個函數所接收的post對象他就有一定的要求，也就是我們所傳入的這個對象必須要存在一個title屬性和一個content屬性，只不過這種要求他實際上是隱性的，他沒有明確的表達出來。
那這種情況下我們就可以使用接口去表現出來這種約束，這裏我們可以嘗試先去定義一個接口。
定義接口的方式呢就是使用interface這樣一個關鍵詞，然後後面跟上接口的名稱，這裏我們可以叫做post，然後就是一對{}，然後{}裏面就可以添加具體的成員限制。這裏我們添加一個title和content，類型都是string。
interface Post {
title: string;
content: string;
}
注意這裏我們可以使用逗號分割成員，但是更標準的做法是使用分號去分割，而且呢這個分號跟js中絕大多數的分號是一樣的，可以省略，那關於是否應該在代碼當中明確使用每一個分號，個人的編碼習慣是不加，你可以根據你所在的團隊或者是項目對應的編碼規範來去決定要不要加分號，這個問題我們不做過多討論。
完成過後我們這裏可以給這個post參數的類型設置為我們剛剛所定義的Post接口。
function printPost (post: Post) {
console.log(post.title);
console.log(post.content);
}
printPost({
title: 'hello',
content: 'typescript'
})
那此時就是显示的要求我們所傳入的對象他必須要有title和content這兩個成員了，那這就是接口的一個基本作用。
一句話去總結，接口就是用來約束對象的結構，那一個對象去實現一個接口，他就必須要去擁有這個接口當中所約束的所有的成員。
我們可以編譯一下這個代碼，編譯過後我們打開對應的js文件，我們在js當中並不會發現有任何跟接口相關的代碼，也就是說TypeScript中的接口他只是用來為我們有結構的數據去做類型約束的，在實際運行階段呢，實際這種接口他並沒有意義。
可選成員，只讀成員
對於接口中約定的成員，還有一些特殊的用法，我們依次來看一下。
首先是可選成員，如果說我們在一個對象當中，我們某一個成員他是可有可無的話，那這樣的話我們對於約束這個對象的接口來說我們可以使用可選成員這樣一個特性。
例如我們這裏添加一個subTitle這樣一個成員，他的類型同樣是string，不過我們這裏的文章不一定是每一個都有subTitle，這種況下我們就可以在subTitle後面添加一個問號，這就表示我們這個subTitle成員他是可有可無的了。
interface Post {
title: string;
content: string;
subTitle?: string;
}
那這種用法呢其實就是相當於給這個subTitle標記他的類型是string或者是undefined。這就是可選成員。
接下來我們再來看一下只讀成員這樣一個特性，那這裏我們再給Post接口添加一個summary這樣一個成員，那一般邏輯上來講的話文章的summary他都是從文章的內容當中自動提取出來的，所以說我們不應該允許外界去設置他。
那這種情況下我們可以使用readonly這樣一個關鍵詞，去修飾一下這裏的summary。那添加了readonly過後我們這個summary他在初始化完成過後就不能夠再去修改了。如果我們再去修改就會報錯。這就是只讀成員。
interface Post {
title: string;
content: string;
subTitle?: string;
readonly summary: string;
}
最後我們再來看一個動態成員的用法，那這種用法一般是適用於一些具有動態成員對象，例如程序當中的緩存對象，那他在運行過程中就會出現一些動態的鍵值。
這裏我們來新建一個新的接口，因為我們在定義的時候我們是無法知道會有那些具體的成員，所以說我們就不能夠去指定，具體的成員名稱，而是使用一個[], 這個[]中使用key: string。
這個key並不是固定的，可以是任意的名稱, 只是代表了我們屬性的名稱，他是一個格式，然後後面這個string就是成員名的類型，也就是鍵的類型，後面我們可以跟上動態屬性的值為string。
interface Cache {
[key: string]: string;
}
完成以後我們再來創建一個cache對象，讓他去實現這個接口，那這個時候我們就可以在這個cache對象上動態的去添加任意的成員了, 只不過這些成員他都必須是stringd類型的鍵值。
const cache: Cache = {};
cache.foo = 'value1';
cache.bar = 'value2'
類的基本使用
類可以說是面向對象編程中一個最重要的概念，關於類的作用這裏我們再簡單描述一下。他就是用來描述一類具體事物的抽象特徵，我們可以以生活角度去舉例。
例如手機就屬於一個類型，那這個類型的特徵呢就是能夠打電話，發信息。那在這個類型下面呢他還會有一些細分的子類，那這種子類他一定會滿足父類的所有特徵，然後再多出來一些額外的特徵。例如只能手機，他除了可以打電話發短信還能夠使用一些app。
那我們是不能直接去使用類的，而是去使用這個類的具體事物，例如你手中的只能手機。
那類比到程序的角度，類也是一樣的，他可以用來去描述一類具體對象的一些抽象成員，那在ES6以前，JavaScript都是通過函數然後配合原型去模擬實現的類。那從ES6開始，JavaScript中有了專門的class。
而在TypeScript中，我們除了可以使用所有ECMAScript的標準當中所有類的功能，他還添加了一些額外的功能和用法，例如我們對類成員有特殊的訪問修飾符，還有一些抽象類的概念。
那對於ECMAScript標準中的class，我們這裏就不單獨去介紹了，如果你不太熟悉，你可以去參考ECMAScript前面的文章。
這裏我們來着重介紹一下，在TypeScript中額外多出來的一些新的類的一些特性，我們可以先來聲明一個叫做Person的類型，然後我們在這個類型當中去聲明一下constructor構造桉樹，在構造函數當中我們接收一個name和age參數，那這裏我們仍然可以使用類型註解的方式去標註我們這個地方每個參數的類型。
然後在這個構造函數的裏面我們可以使用this去為當前這個類型的屬性去賦值，不過這裏直接去使用this訪問當前類的屬性會報錯，說的是當前這個Person類型上面並不存在對應的name和age。
class Person {
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
這是因為在TypeScript中我們需要明確在類型中取聲明他所擁有的一些屬性，而不是直接在構造函數當中動態通過this去添加。
那在類型聲明屬性的方式就是直接在類當中去定義, 那這個語法呢是ECMAScript2016標準當中定義的，那我們同樣可以在這裏給name和gae屬性添加類型。那他也可以通過等號去直接賦值一個初始值，不過一般情況下我們還是會在構造函數中動態的為屬性賦值。
需要注意的是，在TypeScript中類的屬性他必須要有一個初始值，可以在等號後面去賦值，或者是在構造函數當中去初始化，兩者必須做其一，否則就會報錯。
class Person {
name: string = 'init name';
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
那以上就是在TypeScript中類屬性在定義上的一些細微差異，其實具體來說就是我們類的屬性他在使用之前必須要現在類型當中去聲明，那這麼做的目的其實就是為了給我們的屬性去做一些類型的標註。
那除此之外呢我們仍然可以按照ES6標準當中的語法，為這個類型去聲明一些方法，例如我們這裏添加一個叫做sayHi的方法，那在這個方法當中我們仍然可以使用函數類型註解的方式去限制參數的類型和返回值的類型。
那在這個方法的內部呢我們同樣可以使用this去訪問當前實例對象，也就可以訪問到對應的屬性。
class Person {
name: string = 'init name';
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
sayHi(msg: string): void {
console.log(`I am ${this.name}, ${msg}`);
}
}
那以上就是類在TypeScript中的一個基本使用。
類的訪問修飾符
接下來我們再來看幾個TypeScript中類的一些特殊用法，那首先就是類當中成員的訪問修飾符，類中的每一個成員都可以使用訪問修飾符去修飾他們。
例如我們這裏給age屬性前面去添加一個private，表示這個age屬性是一個私有屬性，這種私有屬性只能夠在類的內部去訪問，這裏我們創建一個Person對象, 我們打印tom的name屬性和age屬性。可以發現name可以訪問，age就會報錯，因為age已經被我們標記為了私有屬性。
class Person {
name: string = 'init name';
private age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
sayHi(msg: string): void {
console.log(`I am ${this.name}, ${msg}`);
}
}
const tom = new Person('tom', 18);
console.log(tom.name);
console.log(tom.age);
除了private以外，我們還可以使用public修飾符去修飾成員，意思是他是一個共有成員，不過再TypeScript中，類成員的訪問修飾符默認就是public，所以我們這裏加不加public效果都是一樣的。不過我們還是建議大家手動去加上這種public的修飾符，因為這樣的話，我們的代碼會更加容易理解一點。
class Person {
public name: string = 'init name';
private age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
sayHi(msg: string): void {
console.log(`I am ${this.name}, ${msg}`);
}
}
最後還有一個叫做protected修飾符，說的就是受保護的，我們可以添加一個gender的屬性，他的訪問修飾符我們就使用protected，我們同樣在構造函數中初始化一下gender。
完成過後我們在實例對象上去訪問gender，會發現也是訪問不到的，也就是protected也不能在外部直接訪問。
class Person {
public name: string = 'init name';
private age: number;
protected gender: boolean;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
this.gender = true;
}
sayHi(msg: string): void {
console.log(`I am ${this.name}, ${msg}`);
}
}
const tom = new Person('tom', 18);
console.log(tom.name);
// console.log(tom.age);
console.log(tom.gender);
那他跟private的區別到底在什麼地方呢, 這裏我們可以再定義一個叫做Student的類型，我們讓這個類型去繼承自Person，我們在構造函數中嘗試訪問父類的gender，是可以訪問到的。那意思就是protected只允許在子類當中去訪問對應的成員。
class Student extends Person {
constructor(name: string, age: number) {
super(name, age); // 子類需要調用super將參數傳給父類。
console.log(this.gender);
}
}
那以上就是TypeScript當中對於類額外添加的三個訪問修飾符。分別是private，protected和public，那他們的作用可以用來去控制類當中的成員的可訪問級別。
那這裏還有一個需要注意的點，就是對於構造函數的訪問修飾符，那構造函數的訪問修飾符默認也是public，那如果說我們把它設置為private，那這個類型就不能夠在外部被實例化了，也不能夠被繼承，那在這樣一種情況下，我們就只能夠在這個類的內部去添加一個靜態方法，然後在靜態方法當中去創建這個類型的實例，因為private只允許在內部訪問。
例如我們這裏再去添加一個叫create的靜態方法，那static也是ES6標準當中定義的，然後我們就可以在這個create方法中去使用new的方式去創建這個類型的實例，因為new的方式就是調用了這個類型的構造函數。
此時我們就可以在外部去使用create靜態方法創建Student類型的對象了。
class Student extends Person {
private constructor(name: string, age: number) {
super(name, age); // 子類需要調用super將參數傳給父類。
console.log(this.gender);
}
static create(name: string, age: number) {
return new Student(name, age);
}
}
const jack = Student.create('jack', 18);
那如果我們把構造函數標記為protected，這樣一個類型也是不能在外面被實例化的，但是相比於private他是允許繼承的，這裏我們就不單獨演示了。
類的只讀屬性
對屬性成員我們除了可以使用private和protected去控制它的訪問級別，我們還可以使用一個叫做readonly的關鍵詞去把這個成員設置為只讀的。
這裏我們將gender屬性設置為readonly，注意這裏如果說我們的屬性已經有了訪問修飾符的話，那readonly應該跟在訪問修飾符的後面，對於只讀屬性，我們可以選擇在類型聲明的時候直接通過等號的方式去初始化，也可以在構造函數當中去初始化，二者只能選其一。
也就是說我們不能在聲明的時候初始化，然後在構造函數中修改它，因為這樣的話已經破壞了readonly。
class Person {
public name: string = 'init name';
private age: number;
protected readonly gender: boolean;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
this.gender = true;
}
sayHi(msg: string): void {
console.log(`I am ${this.name}, ${msg}`);
console.log(this.age);
}
}
const tom = new Person('tom', 18);
console.log(tom.name);
在初始化過後呢, 這個gender屬性就不允許再被修改了，無論是在內部還是外部，他都是不允許修改的。
以上就是readonly這樣一個只讀屬性，還是比較好理解的。
類與接口
相比於類，接口的概念要更為抽象一點，我們可以接着之前所說的手機的例子來去做比。我們說手機他是一個類型，這個實例的類型都是能夠打電話，發短信的，因為手機這個類的特徵呢就是打電話，發短信。
但是呢，我們能夠打電話的，不僅僅只有手機，在以前還有比較常見的座機，也能夠打電話，但是座機並不屬於手機這個類目，而是一個單獨的類目，因為他不能夠發短信，也不能夠拿着到處跑。
那在這種情況下就會出現，不同的類與類之間也會有一些共同的特徵，那對於這些公共的特徵我們一般會使用接口去抽象，那你可以理解為手機也可以打電話，因為他實現了能夠打電話的協議，而座機也能夠打電話因為他也實現了這個相同的協議。
那這裏所說的協議呢我們在程序當中就叫做接口，當然如果說你是第一次接受這種概念的話，那可能理解起來會有些吃力，個人的經驗就是多思考，多從生活的角度去想，如果實在想不通，更粗暴的辦法就是不斷的去用，用的過程當中慢慢的去總結規律時間長了自然也就好了。
class Person {
eat (food: string): void {}
run (distance: number) {}
}
class Animal {
eat (food: string): void {}
run (distance: number) {}
}
這裏我們來看一個例子，我們定義好了兩個類型，分別是Person和Animal，也就是人類和動物類，那他們實際上是兩個完全不同的類型，但是他們之間也會有一些相同的特性。例如他們都會吃東西都會跑。
那這種情況下就屬於不同的類型實現了一個相同的接口，那可能有人會問，我們為什麼不給他們之間抽象一個公共的父類，然後把公共的方法都定義到父類當中。
那這個原因也很簡單，雖然人和動物都會吃，都會跑，但是我們說人吃東西和狗吃東西能是一樣的么，那他們只是都有這樣的能力，而這個能力的實現肯定是不一樣的。
那在這種情況下我們就可以使用接口去約束這兩個類型之間公共的能力，我們定義一個接口叫做EatAndRun，然後我們在這個接口當中分別去添加eat和run這兩個方法成員的約束。
那這裏我們就需要使用這種函數簽名的方式去約束這兩個方法的類型，而我們這裡是不做具體的方法實現的。
interface EatAndRun {
eat (food: string): void;
run (distance: number): void;
}
那有了這個接口過後呢，我們再到Person類型後面，我們使用implements實現以下這個EatAndRun接口, 那此時在我們這個類型中就必須要有對應的成員，如果沒有就會報錯，因為我們實現這個接口就必須有他對應的成員。
class Person implements EatAndRun {
eat (food: string): void {}
run (distance: number) {}
}
那這裏我們需要注意的一點是，在C#和Java這樣的一些語言當中他建議我們盡可能讓每一個接口的定義更加簡單，更加細化。就是我們EatAndRun這樣一個接口當中我們抽象了兩個方法，那就相當於抽象了兩個能力，那這兩個能力必然會同時存在么？是不一定的。
例如說摩托車也會跑，但是就不會吃東西，所以說我們更為合理的就是一個接口只去約束一個能力，然後讓一個類型同時去實現多個接口，那這樣的話會更加合理一些，那我們這裏可以把這個接口拆成一個Eat接口和Run接口，每個接口只有一個成員。
然後我們就可以在類型的後面使用逗號的方式，同時去實現Eat和Run這兩個接口。
interface Eat {
eat (food: string): void;
}
interface Run {
run (distance: number): void;
}
class Person implements Eat, Run {
eat (food: string): void {}
run (distance: number) {}
}
那以上呢就是用接口去對類進行一些抽象，那這裏再多說一句題外話，就是大家千萬不要把自己框死在某一門語言或者是技術上面，最好可以多接觸，多學習一些周邊的語言或者技術，因為這樣的話可以補充你的知識體系。
那最簡單來說，一個只了解JavaScript的開發人員，即便說他對JavaScript有多麼精通，那他也不可能設計出一些比較高級的產品。
例如我們現在比較主流的一些框架，他們大都採用一些MVVM的這樣一些思想，那這些思想呢他實際上最早出現在微軟的WPS技術當中的，如果說你有更寬的知識面的話，那你可以更好的把多家的思想融合到一起，所以說我們的視野應該放寬一點。
抽象類
最後我們再來了解一下抽象類，那抽象類在某種程度上來說跟接口有點類似，那他也是用來約束子類當中必須要有某一個成員。
但是不同於接口的是，抽象類他可以包含一些具體的實現，而接口他只能夠是一個成員的一個抽象，他不包含具體的實現。
那一般比較大的類目我們都建議大家使用抽象類，例如我們剛剛所說的動物類，那其實他就應該是抽象的，因為我們所說的動物他只是一個泛指，他並不夠具體，那在他的下面一定會有一些更細化的劃分，比如說小狗，小貓之類的。
而且我們在生活當中一般都會說我們買了一條狗，或者說買了一隻貓，從來沒有人說我們買了一個動物。
abstract class Animal {
eat (food: string): void {}
}
我們有一個Animal類型，那他應該像我們剛剛說的那樣，被定義成抽象類，定義抽象類的方式就是在class關鍵詞前面添加一個abstract，那這個類型被定義成抽象類過後，他就只能夠被繼承，不能夠再去實例化。
在這種情況下我們就必須使用子類去繼承這個抽象類, 這裏我們定義一個叫做Dog的類型, 然後我們讓他繼承自Animal，那在抽象類當中我們還可以去定義一些抽象方法，那這種抽象方法我們可以使用abstract關鍵詞來修飾，我們這裏定義一個叫做run的抽象方法, 需要注意的是抽象方法也不需要方法體.
當父類中有抽象方法時，我們的子類就必須要去實現這個方法。
那此時我們再去使用這個子類所創建的對象時，就會同時擁有父類當中的一些實例方法以及自身所實現的方法。那這就是抽象類的基本使用。
abstract class Animal {
eat (food: string): void {}
abstract run (distance: number): void;
}
class Dog extends Animal {
run (distance: number): void {}
}
關於抽象類呢，更多的還是去理解他的概念，他在使用上並沒有什麼複雜的地方。
泛型
泛型（Generics）是指在定義函數、接口或者類的時候， 不預先指定其類型，而是在使用是手動指定其類型的一種特性。
比如我們需要創建一個函數， 這個函數會返回任何它傳入的值。
function identity(arg: any): any {
return arg
}
identity(3) // 3
這代代碼編譯不會出錯，但是存在一個顯而易見的缺陷， 就是沒有辦法約束輸出的類型與輸入的類型保持一致。
這時，我們可以使用泛型來解決這個問題；
function identity<T>(arg: T): T {
return arg
}
identity(3) // 3
我們在函數名後面加了 , 其中的 T 表示任意輸入的類型， 後面的 T 即表示輸出的類型，且與輸入保持一致。
當然我們也可以在調用時手動指定輸入與輸出的類型, 如上述函數指定 string 類型：
identity<number>(3) // 3
在泛型函數內部使用類型變量時， 由於事先並不知道它是那種類型， 所以不能隨意操作它的屬性和方法：
function loggingIdentity<T>(arg: T): T {
console.log(arg.length) // err
return arg
}
上述函數中 類型 T 上不一定存在 length 屬性， 所以編譯的時候就報錯了。
這時，我們可以的對泛型進行約束，對這個函數傳入的值約束必須包含 length 的屬性， 這就是泛型約束:
interface lengthwise {
length: number
}
function loggingIdentity<T extends lengthwise>(arg: T): T {
console.log(arg.length) // err
return arg
}
loggingIdentity({a: 1, length: 1}) // 1
loggingIdentity('str') // 3
loggingIdentity(6) // err 傳入是參數中未能包含 length 屬性
這樣我們就可以通過泛型約束的方法對函數傳入的參數進行約束限制。
多個參數時也可以在泛型約束中使用類型參數 如你聲明了一個類型參數， 它被另一類型參數所約束。現在想要用屬性名從對象里湖區這個屬性。並且還需確保這個屬性存在於這個對象上， 因此需要咋這兩個類型之間使用約束，
簡單舉例來說： 定義一個函數， 接受兩個參數 第一個是個對象 obj，第二個個參數是第一參數 key 是對象裏面的鍵名， 需要輸入 obj[key]
function getProperty<T, K extends keyof T>(obj: T, key: K) {
return obj[key]
}
let obj = { a: 1, b: 2, c: 3 }
getProperty(obj, 'a') // success
getProperty(obj, 'm') // err obj 中不存在 m 這個參數
我們可以為泛型中的類型參數指定默認類型。當使用泛型時沒有在代碼中直接指定類型參數，從實際值參數中也無法推測出時，這個默認類型就會起作用
function createArr<T = string>(length: number, value: T): Array<T> {
let result: T[] = []
for( let i = 0; i < lenght; i++ ) {
result[i] = value
}
return result
}
簡單來說，泛型就是把我們定義時不能夠明確的類型變成一個參數，讓我們在使用的時候再去傳遞這樣一個類型參數。
類型聲明
在項目開發過程中我們難免會用到一些第三方的npm模塊，而這些npm模塊他不一定都是通過TypeScript編寫的，所以說他所提供的成員呢就不會有強類型的體驗。
比如我們這裏安裝一個lodash的模塊，那這個模塊當中就提供了很多工具函數，安裝完成過後我們回到代碼當中，我們使用ES Module的方式import導入這個模塊，我們這裏導入的時候TypeScript就已經報出了錯誤，找不到類型聲明的文件，我們暫時忽略。
這裏我們提取一下camelCase的函數，那這個函數的作用就是把一個字符串轉換成駝峰格式，那他的參數應該是一個string，返回值也應該是一個string，但是我們在調用這個函數逇時候並沒有任何的類型提示。
import { camelCase } from 'lodash';
const res = camelCase('hello typed');
那在這種情況下我們就需要單獨的類型聲明，這裏我們可以使用detar語句來去聲明一下這個函數的類型，具體的語法就是declare function 後面跟上函數簽名, 參數類型是input，類型是string，返回值也應該是string
declare function camelCase (input: string ): string;
那有了這樣一個聲明過後，我們再去使用這個camelCase函數。這個時候就會有對應的類型限制了。
那這就是所謂的類型聲明，說白了就是一個成員他在定義的時候因為種種原因他沒有聲明一個明確的類型，然後我們在使用的時候我們可以單獨為他再做出一個明確的聲明。
那這種用法存在的原因呢，就是為了考慮兼容一些普通的js模塊，由於TypeScript的社區非常強大，目前一些比較常用的npm模塊都已經提供了對應的聲明，我們只需要安裝一下它所對應的這個類型聲明模塊就可以了。
lodash的報錯模塊已經提示了，告訴我們需要安裝一個@types/lodash的模塊，那這個模塊其實就是我們lodash所對應的類型聲明模塊，我們可以安裝這個模塊。安裝完成過後，lodash模塊就不會報錯了。在ts中.d.ts文件都是做類型聲明的文件，
除了類型聲明模塊，現在越來越多的模塊已經在內部繼承了這種類型的聲明文件，很多時候我們都不需要單獨安裝這種類型聲明模塊。
例如我們這裏安裝一個query-string的模塊，這個模塊的作用就是用來去解析url當中的query-string字符串，那在這個模塊當中他就已經包含了類型聲明文件。
我們這裏直接導入這個模塊，我們所導入的這個對象他就直接會有類型約束。
那以上就是對TypeScript當中所使用第三方模塊類型聲明的介紹。
那這裏我們再來總結一下，在TypeScript當中我們去引用第三方模塊，如果這個模塊當中不包含所對應的類型聲明文件，那我們就可以嘗試去安裝一個所對應的類型聲明模塊，那這個類型聲明模塊一般就是@types/模塊名。
那如果也沒有這樣一個對應的類型聲明模塊，那這種情況下我們就只能自己使用declare語句去聲明所對應的模塊類型，那對於declare詳細的語法這裏我們不再單獨介紹了，有需要的話可以單獨去查詢一下官方文檔。
作者：隱冬
鏈接：https://juejin.cn/post/6897779423858737166
來源：掘金 著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。
站長推薦
1.雲服務推薦: 國內主流雲服務商，各類雲產品的最新活動，優惠券領取。地址：阿里雲騰訊雲華為雲
2.廣告聯盟: 整理了目前主流的廣告聯盟平台，如果你有流量，可以作為參考選擇適合你的平台點擊進入
鏈接: http://www.fly63.com/article/detial/9859
