let word = [0, 1];
console.log(join(word));

let word = [0, 1];
console.log(join(word, 1));

let n: number = 4
n = null

let tuple: [string, number]
tuple[3] = "wang"

interface Word {
    firstName: string,
    lastName: string,
}
function join(word: Word) {
    return "hello " + word
}

let isDone:boolean = true/false
let num: number = 20
let str: string = "wang"
let str: string = `wang${num}`
let arr: number[] = [0, 1, 2]
let arr:Array<number> = [0,1,2]
let arr: string[] = ["w", "a", "n","g"]
//元祖
let x:[string,number]
x = ["wang",10]//true
x = [10,"wang"]//false
x[0].sub(1)//true(字符串上的方法)
x[1].sub(1)//false(数字没有方法)
x[1/0].toString()//true(都有的内置方法)
x[0] = "hello"//true
x[1] = 20//true
x[1] = true //false(只能是定义的元祖类型)
//枚举
enum Color{
    Red,
    Green,
    Blue
}
let c:Color = Color.Green
//枚举有顺序 
enum Color {
    Red,
    Green,
    Blue
}
let colorName: string = Color[0]
console.log(colorName);//Red
//编译结果
var Color;
(function (Color) {
    Color[Color["Red"] = 0] = "Red";
    Color[Color["Green"] = 1] = "Green";
    Color[Color["Blue"] = 2] = "Blue";
})(Color || (Color = {}));
var colorName = Color[0];
console.log(colorName);

//可自定义枚举下标，下面的都按顺序递增
enum Color {
    Red=1,
    Green,
    Blue
}
let colorName: string = Color[2]
console.log(colorName);//Green
//any类型
let notSure:any = 4/"wang"/true
let list:any[] = [1,true,"wang"]
//void
function wang():void {
    console.log("this is void")
}
let wang:void = null
let wang:void = undefined

let wang:undefined = undefined
let wang:null = null
let wang:null = undefined

//联合类型
let num:number | null = 4/null
//never
function error(message:string):never{
    throw new Error(message)
}
function fail(){
    return error("error")
}
function inifiniteloop():never{
    while(true){
        
    }
}
//object
declare function create(o:objext|null):void
create(o:{props:0})
create(o:null)
create(o:"wang")
create(o:20)
create(o:false)
create(o:undefined)
//类型断言
//强制转化为一种类型
let someValue:any = "wang"
let strlength:number = (someValue as string).length

interface Point {
   readonly x: number,
   readonly y: number,
}
let p:Point = {x:10,y:20} 

interface Point {
   x: number,
   y: number,
   [propName:number]:any
}
let p:Point = {x:10,z:20} 

interface PointFunc {
 (x: number,y: number):boolean
}
let p:PointFunc
p = function(x: number,y: number):boolean{
	let result = x.search(y)
	return result>-1
}