分享Typescript的13個基礎語法
一.Ts是什麼
首先，強類型不允許隨意的隱式類型轉換，而弱類型是允許的。JavaScript就是經典的弱類型語言。而Typescript可以說是JavaScript的超集，在JS的基礎上新增瞭許多語法特性，使得類型不再可以隨意轉換，能大大減少開發階段的錯誤。
二. 基本語法
1.聲明原始數據類型
在變量後面指定一個關鍵字表示其隻能為什麼類型。
string類型：
const a: string = 'auroras'
number類型：
const b: number = 666 // 包括 NAN Infinity
boolean類型：
const c: boolean = true
null類型：
const d: null = null
undefined類型：
const e: undefined = undefined
symbol類型：
const h: symbol = Symbol()
2.聲明Object類型
首先，object類型不單單可以指定對象，還可以指定數組或函數：
const foo1: object = {};
const foo2: object = [];
const foo3: object = function(){};
如果隻想指定為對象，如下，對象屬性都要提前聲明好類型：
const obj: {name: string,age: number} = {
name: '北極光',
age:18
}
2.1聲明數組類型
可以指定聲明Array且通過<>指定元素類型，比如指定聲明元素都為數字的數組：
const arr: Array<number> = [1,2,3]
第二種方式如下，也指定聲明元素都為數字的數組：
const arr: number[] = [1,2,3]
2.2聲明元組類型
就是要提前指定數組裡每個元素的類型，嚴格一一對應：
const tuple: [number,string,boolean] = [666,'auraros',true]
3.聲明枚舉類型
通過關鍵字enum聲明一個枚舉類型，如：
enum Status {
pedding = 1,
resolve = 2,
reject = '3'
}
//訪問
console.log(Status.pedding);
如果全不寫值，默認值為從0開始遞增。如果第一個元素為字符類型，就必須全部定義值。如果第一個元素指定為一個數字，後面元素不寫值，那值為第一個元素值按位置大小遞增的結果。
4.函數參數與返回類型
函數聲明式：
指定函數傳入參數類型，指定返回值類型，調用時傳入參數個數與類型都必須相同：
括號裡指定每個參數類型，括號右邊指定返回值的類型。
function fun (name:string,age:number):string{
return 'sss'
}
fun('auroras',18);
如果傳入參數不確定傳不傳，那麼可以給參數加個‘？’表明它是可選的：
function fun (name:string,age?:number):string{
return 'sss'
}
fun('auroras');
或者給參數添加默認值，那也會成為可選參數：
function fun (name:string,age:number=666):string{
return 'sss'
}
fun('auroras');
如果參數個數不確定，可以用擴展運算符加解構賦值表示，當然要傳入與指定類型一致的：
function fun (name:string,age:number=666,...res:number[]):string{
return 'sss'
}
fun('auroras',1,2,3);
函數表達式：
const fun2:(name:string,age:number)=>string = function(name:string,age:number){
return 'sss'
}
定義接口時再詳細說。
5.任意類型
通過指定any關鍵字表示任意類型，跟原來 js 一樣，可以任意賦不同類型的值：
let num:any = 1; num = 'a'; num = true;
6.類型斷言
類型斷言就是明確的告訴typescript這個變量就是某種類型的，百分之百確定。不用typescript在一些情況下要自己推斷某些沒有明確定義或者多變的場景是什麼類型。
可以通過 as+類型 斷言它就是某種類型的：
const res = 1; const num = res as number;
也可以通過 <類型> 形式斷言（不推薦）：
const res = 1; const num = <number>res
7.接口基本使用
接口可以理解為一種規范，一種契約。可以約束一個對象裡應該有哪些成員，這些成員都是怎麼樣的。
通過interface定義一個Post接口，這個接口是一個對象，規則為有一個name屬性類型為string，age屬性類型為number。
interface Post {
name:string;
age:number
}
然後比如有一個函數 printPost ，它的參數 post 使用我們定義的 Post 接口的規則，那麼調用此函數傳參時要傳入符合 Post 接口規則的數據。
interface Post {
name:string;
age:number
}
function printPost(post: Post){
console.log(post.name);
console.log(post.age);
}
printPost({name:'asd',age:666})
當然，函數傳參時可能有些參數是可選的，那麼我們可以給接口也定義可選的成員，通過屬性後加一個‘？’指定可選成員：
interface Post {
name:string;
age:number;
sex?:string;
}
const auroras: Post = {
name:'asd',
age: 18
}
如果用readonly修飾成員，那麼這個成員屬性在初始化後便不可修改：
interface Post {
name:string;
age:number;
sex?:string;
readonly like:string
}
const auroras: Post = {
name:'asd',
age: 18,
like: 'natrue'
}
auroras.name = 'aaaa';
//保錯
auroras.like = 'wind';
如果連成員屬性名稱都不確定，那麼可以聲明動態成員，要指定成員名字類型與成員值的類型，如：
interface Post {
[prop:string]:string
}
const auroras: Post = {
name:'asd',
like: 'natrue'
}
8.類基本使用
描述一類具體事物的抽象特征。ts增強瞭es6中class類的相關語法。
首先，類的屬性使用前必須提前聲明好：
class Person {
name: string;
age: number;
constructor(name:string,age:number){
this.name = name;
this.age = age;
}
sayHi(msg:string):void {
console.log(`hi,${msg},i am ${this.name}`);
}
}
9.類的訪問修飾符
private 修飾私有屬性，隻能在類內部訪問。public 修飾公用屬性（默認），
外部也可訪問：
class Person {
public name: string;
private age: number;
constructor(name:string,age:number){
this.name = name;
this.age = age;
}
sayHi(msg:string):void {
console.log(`hi,${msg},i am ${this.name}`);
console.log(this.age);
}
}
const jack = new Person('jack',20);
//Person類公有屬性可以訪問
console.log(jack.name);
//Person類私有屬性不可以訪問
console.log(jack.age);
protected修飾為受保護的，外部也不可訪問。但與 private 的區別是若是繼承的子類是可以訪問的。
class Person {
public name: string;
private age: number;
// protected
protected gender: boolean;
constructor(name:string,age:number){
this.name = name;
this.age = age;
this.gender = true;
}
sayHi(msg:string):void {
console.log(`hi,${msg},i am ${this.name}`);
console.log(this.age);
}
}
class children extends Person{
constructor(name:string,age:number){
super(name,age,);
//可以訪問
console.log(this.gender);
}
}
10.類隻讀屬性
給屬性設置 readonly 則為隻讀屬性，該屬性初始化後便不可再修改。
class Person {
public name: string;
private age: number;
// readonly
protected readonly gender: boolean;
constructor(name:string,age:number){
this.name = name;
this.age = age;
this.gender = true;
}
sayHi(msg:string):void {
console.log(`hi,${msg},i am ${this.name}`);
console.log(this.age);
}
}
11.類與接口
一些類與類之間有些許共同的特征，這些共同的特征可以抽象成為接口。
比如 Person 類和 Animal 類，雖然是不同類，但是人和動物都會吃東西和走路等，這些共同的特征可以由接口定義。最後一個特征就定義一個接口。
//吃接口
interface Eat {
eat(food:string):void
}
//行進接口
interface Run {
run(behavior:string):void
}
//人
class People implements Eat,Run {
eat(food:string){
console.log(`在餐桌上吃${food}`);
}
run(behavior:string){
console.log(`站著${behavior}`);
}
}
//動物
class Animal implements Eat,Run {
eat(food:string){
console.log(`在地上上吃${food}`);
}
run(behavior:string){
console.log(`爬著${behavior}`);
}
}
12.抽象類
約束子類必須有某些成員，有點類似接口，不同的是抽象類可以包含一些具體的實現。比如動物類應該為一個抽象類，它的子類有貓，狗，熊貓等。它們都是動物，也有一些共同的特征。定義一個類為抽象類後，就不能再new實例瞭，隻能被其子類繼承。
其中abstract 定義抽象類，類裡用abstract定義一個抽象方法，子類必須實現抽象方法。
abstract class Animal {
eat(food:string){
console.log(`在地上吃${food}`);
}
abstract run (behavior:string):void
}
//貓
class Dog extends Animal{
run(behavior:string):void{
console.log(behavior);
}
}
const d1 = new Dog();
d1.eat('骨頭')
d1.run('四腳爬行')
//兔子
class rabbit extends Animal{
run(behavior:string):void{
console.log(behavior);
}
}
const r1 = new rabbit();
d1.eat('蘿卜')
d1.run('蹦蹦跳跳')
13.泛型
泛型就是在定義函數，接口或者類的時候沒有指定具體類型，等到使用時才指定具體類型。極大程度的復用代碼。
比如有一個 identity 函數，這個函數會返回任何傳入它的值，且傳入的類型與返回的類型應該是相同的。如果傳入數字，不用泛型的話，
這個函數可能是下面這樣：
function identity(arg:number):number{
return arg
}
如果傳入字符串，這個函數可能是下面這樣：
function identity(arg:string):string{
return arg
}
這樣的話太麻煩，所以可以使用泛型，一般用大寫 T 表示泛型，它可以適用於多個類型，且傳入類型與返回類型是相同的。
function identity<T>(arg:T):T{
return arg
}
到此這篇關於分享Typescript的14個基礎語法的文章就介紹到這瞭,更多相關Typescript的14個基礎語法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- typescript快速上手的基礎知識篇
- TypeScript中extends的正確打開方式詳解
- TypeScript基本類型之typeof和keyof詳解
- TypeScript保姆級基礎教程
- TypeScript定義接口(interface)案例教程