// 普通数据类型
const num: number = undefined
// 函数的默认参数和可选参数
function f1(arg1: string = 'cat', arg2?: boolean): any {
    return `${arg1}+${arg2}`
}
console.log(f1())
// null undefined 和void的区别  null 和undefined是所有类型的子类型 void不是  可以理解就是undefined
let a: void;
let b: number = undefined
// 任意值
let c: any = 'hello word'
// 联合类型
let d: string | number | any = 3
d = true
//   函数中的参数如果是联合类型，函数中的方法要联合类型公用的方法 要不会报错

//--------------------------------------------
// 对象的类型使用接口 interfaces
// 必须得一直(顺序不一定一致)
// 注意interface 中是;(分号)
//  注意一但使用propName  定义了类型   
//那么本定义的对象和他的实际对象类型都得是这个类型，要不然会报错
interface Person {
    name: string;
    [propName: string]: any;
    age?: number;
}

let tom: Person = {
    name: 'Tom',
    age: 1,
    gender: 'male'
};
// 比如这种  两种都会报错 所以使用propName的时候定义为any类型
// interface Son{
//     name:string;
//     [propName:string]:string;
//     a?:number;
// }
// let father:Son={
//     name:'1',
//     age:40,
// }

//  对象中的只读 定义再key前面   属性值不可以修改
interface Read {
    readonly name: string;
}
let R: Read = {
    name: 'name'
}
// 这里修改 name  会报错
// R.name = '333'

//---------------------------------------
//数组的类型
//(数组中的类型必须得都是前面定义的否则会报错)
let arr: number[] = [1, 24, 2]
// 比如这样的会报错
// let arr1:string[] = [1,'3']

//  使用数组泛型定义数组
let arr3: Array<number> = [1, 2]
// 使用接口定义数组
interface Arr {
    [index: number]: number;
}
let Arr4: Arr = [1, 23]
// 对于类数组  使用TS的内置对象IArguments TS 有内置类型
function sum(): any {
    let argus: IArguments = arguments;
}
//一般常见的数组定义就是使用any  任何类型
let arr4: any[] = [{ a: 1 }, '2']

//----------------------------------------
// 定义函数
// 常规的写法
//  参数和类型都会受限制 否则会报错
// 同时?代表可选
function fun(a: string, b?: number): any {

}
// 使用接口定义
interface Fu {
    (a: number, b: number): number
}
let f3: Fu = function (a: number, b: number): number {
    return a + b;
}
// 函数表达式的话
let f: (a: number, b: number) => number = function (a: number, b: number): number {
    return a + b;
}

// 剩余参数也一样 (reset要定义为数组)
function S(a: number[], ...rest: number[]): any {

}
// --------------------------------------------以上是基本数据类型

// 类型断言
// 在函数中判断函数参数的类型  能够直观的判断数据类型
function fs(a: number | string): any {
    if (<number>a) {
        return a;
    } else {
        return 'aa';
    }
}
console.log(fs('a'))

// 定义全局  declare  let a:string = 'a'   declare宣布的意思

//泛型   定义数据的时候不声明类型 再调用的时候声明