原始类型
let num: number = 1
let name: string = '张三'
let isDone: boolean = true
let nl: null = null
let unde: undefined = undefined
let sym: symbol = Symbol ( '123' )
let an: any = 666
let unusable: void = undefined
function test ( ) : void { }
非原始类型
let obj: object = { a: 1 }
let obj1: object = [ 1 , 2 , 3 ]
let obj2: object = 100
let obj3: object = 'hello'
let obj: Object = { a: 1 }
let obj1: Object = [ 1 , 2 , 3 ]
let obj2: Object = 360
let obj2: Object = 'world'
let obj: { } = { a: 1 }
let obj1: { } = [ 1 , 2 , 3 ]
let obj2: { } = 360
let obj2: { } = 'world'
数组类型
let arr1: number [ ] = [ 1 , 2 , 3 ]
let arr1: any [ ] = [ 'wang' , 2 , false ]
let arr2: Array < number > = [ 1 , 2 , 3 ]
let arr3: [ number , string , boolean ] = [ 10 , 'hello' , true ]
联合类型
let lh: string | number | boolean = 'jiuming'
let constant: 1 | 'good' = '1'
let obj: { a: 1 } | { b: 2 }
交叉类型
let obj: { name: string , age: number } & { height: number , age: 18 }
obj = {
name: 'zhangsan' ,
age: 18 ,
height: 180
}
接口
interface IObj {
name: string ;
age: number
}
let obj: IObj
obj = {
name: 'mike' ,
age: 26
}
interface IArr {
[ idx: number ] : number | string
}
let arr: IArr = [ 1 , 2 , 3 '4' , '5' ]
interface IFun {
( name: string , age: number ) : void
}
let fn: IFun = ( name: string , age: number ) => { }
fn ( "小明" , 16 )
interface IExternal {
skin: string
}
interface IInternal {
organ: string
}
interface IPerson extend IExternal, IInternal {
heigth: number
}
let p: IPerson = {
skin: '古铜色' ,
organ: '身体机能健康' ,
heigth: 180
}
interface IObj {
a: number
}
interface IObj {
b: string
}
let obj: IObj = {
a: 1 ,
b: 'zxc'
}
interface IPerson {
name: string
age: number
height? : number
}
let man: IPerson = {
name: 'wangming' ,
age: 18 ,
height: 180
}
interface IPerson {
readonly name: string
}
let p: IPerson = {
name: 'lisa'
}
p. name = 'Julie'
类型别名
type strAndNum = string | number
let p: strAndNum = 1
type ObjType = {
a: string ,
b: number & 1
}
let obj: ObjType = {
a: 'xxx' ,
b: 1
}
interface IObj {
a: string
}
type TStr = IObj[ 'a' ]
let s: TStr = 'hello'
type color = 'red' | 'bule' | 'green'
let c: color = 'red'
函数
interface IFn {
( name: string ) => string
}
let fn: IFn = ( name: string ) => {
return name
}
fn ( 'wangwu' )
type TFn = ( name: string ) => string
let fn1: TFn = ( name: string ) => {
return name
}
interface IObj {
fn: IFn
}
let obj: IObj = {
fn : ( name) => {
return name
}
}
obj. fn ( 'jordan' )
type TObj = {
fn : ( name: string ) => void
}
let obj1: TObj = {
fn : ( name) => { }
}
枚举
enum Color { Red, Green, Blue}
let c: number = Color. Red
let color: string = Color[ 0 ]
enum Color { Red = 100 , Green, Blue}
let n: number = Color. Red
let n2: number = Color. Green
泛型
function fn < T > ( n: T ) : T {
return n
}
fn < string > ( 'Bob' )
fn < boolean > ( true )
fn < 'Mike' > ( 'Mike' )
function fn2 < T , G > ( n: T , m: G ) {
return ` ${ n} ${ m} 岁了! `
}
fn2 < string , number > ( '晓明' , 18 )
type StrOrNum = string | number
type TObj< T , G > = {
name: T ,
getName : ( ) => G
}
let obj: TObj< StrOrNum , StrOrNum > = {
name: '' ,
getName ( ) {
return 'xiaoming'
}
}
type StrOrNum = string | number
interface IObj< T , G > {
name: T ,
getName : ( ) => G
}
let obj: IObj< StrOrNum , string > = {
name: 007 ,
getName ( ) {
return '007'
}
}
interface IObj< T extends string | number , G = string > {
name: T ,
getName : ( ) => G
}
let obj: IObj< string > = {
name: 'xxx' ,
getName ( ) {
return 'xxx'
}
}
类
class Person {
name: string = 'xiaoming'
constructor ( n: string ) {
this . name = n
}
getName ( ) {
return this . name
}
}
let p = new Person ( '嘻嘻' )
let obj: Person = {
name: '666' ,
getName ( ) {
return 'xxx'
}
}