ts的一些标准用法

### 基本类型

let a:number = 12

布尔类型(boolean)

数子类型(number)

字符串类型（string）

数组类型（array）

元组类型（tuple） a:Array<number> = [1,2,3]

枚举类型（enum）

任意类型（any）

null和 undefined

void类型

naver类型

let num: number = 8

let str: string = "44"

let a:any[]=[1,"1",true]

let arr:number[]=[1,2,3,4]

let arr2:Array<string> = ['123','234']

// 没有返回值
const foo:void = function (){
    console.log(1)
}

###对象的基本用法

cnost a : { name:string, age: number} = { name: "小明",age: 18}

// 注意 
cnost b: {} = { name: "小明",age: 18}
console.log(b)
console.log(b.name)  // 这里会报错， 没有什么那么的类型

###数组的基本用法

const arr:string[] = ['a','b','c']
const arrNum: number[] = [1,2,3]

const arrA: (number | string | {}) = [1,2,3,'a','b',{name:"aa"}]

###函数的基本用法

// age可填可不填
function getName(name: string, age?: number) {
    if (age) {
        return name + "今年" + age + "岁";
    } else {
        return name + "今年100岁";
    }
}
getName("小明", 12);

// 三元运算符，剩余参数
function getArr(...result: number[]) {
    let a = 0;
    for (let i = 0; i < result.length; i++) {
        a += result[i];
    }
    return a;
}
getArr(1, 2, 3, 4, 5, 6);

###重载

function cz(value: string);
function cz(value: number);
function cz(value: any) {
    if (typeof value == "string") {
        return "我是字符串类型";
    } else if (typeof value == "number") {
        return "我是数字类型";
    } else {
        return "我是any类型";
    }
}
console.log(cz(123)); // 我是数字类型
console.log(cz("123"));// 我是字符串类型

### class

// private 私有的 只允许内部使用 不能继承
// protected 被保护的，内部使用  允许继承
// public  公开的 默认的
class A {
    constructor (private age:number){
        
    }

    get age (){ return this.age}
}

### 接口

interface fullName{
    name1: string,
    name2: number,
    data?: string
}

function getName(nameObj:fullName){

}

getName({name1:"1",name2:2})


// 别名
type aa = {name: string,age:number}
let AA: aa = {name: "a",age: 2}
// 接口
interface aa {name: string,age:number}
let AA: aa = {name: "a",age: 2}

他们俩个的区别就是  接口只能生命对象类型，  type 可以是任何类型

 

### 函数类型接口

## 加密函数

// 传入key，value， 返回string类型

interface encrypt{

(key:string,value:string):string

}

const md5:encrypt = (key:string,value:string):string=>{}

md5("a","b")

## 可索引数据对象和约束

// 数组的约束(下标是number类型，数组里每个值必须是string类型)
interface userArr {
    [index: number]: string;
}
let arr: userArr = ["123", "1233"];

console.log(arr[0]); // '123'

// 对象的约束(下标是string类型，对象里每个值必须是string类型)
interface userObj {
    [index: string]: string;
}

let obj: userObj = { name: "sss" };
console.log(arr[0]); // '123'
// 类  类型接口

interface animal {
    name: string;
    eat(str: string): void;
}

class Dog implements animal {
    name: string;
    constructor(name: string) {
        this.name = name; // 需要初始化一下
    }
    eat() {
        console.log(this.name);
    }
}
console.log(new Dog("hhh").eat());
let dog = new Dog("hhh");
dog.eat();

##接口扩展 接口继承

// 定义一个类型
interface animal {
    eat(): void;
}
// 继承 animal接口
interface person extends animal {
    // 定义自己的方法
    work(): void;
}

// 定义类

class Web implements person {
    constructor() {}

    eat() {
        console.log("吃东西");
    }
    work() {
        console.log("工作");
    }
}
new Web().eat();
new Web().work();

## 泛型

解决接口复用性以及对不特定数据类型的支持

function getData<T>(value: T): T {
    return value;
}

console.log(getData<number>(123));
console.log(getData<string>("abc"));

// 类的泛型

class MinClass<T> {
    public list: T[] = [];
    add(value: T) {
        this.list.push(value);
    }
}

let a = new MinClass<number>();
a.add(123);
a.add(34);
let b = new MinClass<string>();
b.add("qwe");
b.add("fff");

###命名空间

避免命名冲突

// 命名空间

namespace Dog {
    interface animal {
        name: string;
        color: string;
    }

    export function dong(params: animal) {
        return params.name + params.color + "旺";
    }
}
namespace Cat {
    interface animal {
        name: string;
        color: string;
    }

    export function dong(params: animal) {
        return params.name + params.color + "喵";
    }
}

console.log(Dog.dong({ name: "小花", color: "白色" }));
console.log(Cat.dong({ name: "大黄", color: "黄色色" }));