TypeScript基础

//静态类型，与js不同，定义完类型之后不能给其他值
let b: number = 1;
//与Java不同的是它静态定义之后直接具备了类型的方法Integer.toString();
b.toString

//类似于java中的实现接口就得实现它的方法
interface person {
    name: String
}

const my: person = {
    name: "黄林春"
}

//函数的声明也略有不同，对于形参的类型ts具有绝对的要求
function tsgg(x: number, y: number) {
    return Math.sqrt(x ** 2 + y ** 2)
}

tsgg(3, 4)

//对于开发时的提示体验也不同
function tsgg1(data: { x: number, y: number }) {
    return Math.sqrt(data.x ** 2 + data.y ** 2)
}

tsgg1({ x: 3, y: 4 })

//1、基础类型与对象类型

let x: number
x = 1 //数字类型变量，可以先定义后赋值

const str: String = ""//常量类型不可修改

const nums: number[] = [1, 2, 3] //常量数组类型

class Person { }
const dell: Person = new Person()//对象类型，class规定对象模板

const getNum: (x: number) => number = (x: number) => {
    return x
}
getNum(123) //最终函数不可修改，可直接调用

//2、类型推断与类型注解 

let count: number = 123 //显式写出 number 类型这种叫做类型注解
let count1 = 123 //隐式的尝试根据值的类型去设置变量的类型，这个机制叫做类型推断
//（与js不同的是它是静态编译，不能更改类型）

//类型推断机制用在函数里是很好的
function sum(firstNumber, SecondNumber) {
    return firstNumber + SecondNumber
}
sum(1, 2)
sum("1", "2")//这里可以发现可以用在字符串拼接或者是数字求和上，java则是需要方法重载去实现

//3、函数相关类型

function hello() { }
const hello1 = function () { }
const helli2 = () => { }//三种定义方式

function sum1(): number {
    return 1
}//直接规定返回类型，避免出现隐式转换影响返回
function hello3(): void { }//无返回规定
function errorInfo(): never {
    throw new Error()
}//类似与抛出异常，无法执行完毕的函数采用never这个类型注解
function roundIn(): never {
    while (true) {
        console.log('循环')
    }
}//无限循环函数也不能执行完毕，所以用never去声明
function add({ frist, second }: { frist: number, second: number }): number {
    return frist + second
}//这种对象作为形参的类型注解方式


//4、数组和元组
const numArr = [1, 2, 3]//根据类型推断去定义这个数字数组
const numArr1: (number | string)[] = [1, '2', 3]
const objectArr: { name: string, sno: string, clazz: string }[] = []//自定义对象类型的数组
type Student = { name: string, sno: string, clazz: string }
const StuArr: Student[] = []//借助 type alias类型别名进行定义对象数组的解耦合
class StudentInfo {
    name: string
    sno: string
    clazz: string
}
const info: StudentInfo[] = []

const teacher: [string, string, number] = ["dell", 'male', 18]//这就是一个元组，直接规定每一项的类型

//5、interface接口(接口用于封装，类型用于规定)
interface Person {
    name: string
    readonly age?: number //这里的？代表的是该属性可有可无，readOnly代表该参数仅支持读操作不支持写
    [propName: string]: any //这里代表可多其他属性只要是string类型即可
}
const setName = (person: Person, name) => {
    person.name = name
}
const getName = (person: Person): string => {
    return person.name
}//这里就是用接口封装的Person属性，防止没有name属性而导致set报错（undefined报错）

class User implements Person {
    [propName: string]: any;
    name: string;
    age?: number | undefined;

}
interface Teacher extends Person {
}//与Java雷同，但是转换成js代码时关于接口的代码会直接被剔除，说明接口只是帮助我们校验代码规范的工具

//6、类的定义与继承
interface S {
    eatFood(): string
}
class A implements S {
    protected readonly name: string
    static age = 18 //还支持静态？
    A() {
        return "A is new"
    }//也支持构造方法？不支持，这里的构造器是 constructor这是个默认的构造器仅有这一个
    constructor() {
        console.log("A is new ")
    }
    public eatFood(): string {
        return "eat food"
    }//也支持访问关键字？
    getName() {
        return this.name
    }
}
class B extends A {
    name: string
    constructor() {
        super()//执行子类构造函数时需要也将父类构造器执行一下
    }
    getSuperName() {
        super.getName()
    }
    getName(): string {
        return this.name + super.name
    }
    eatFood(): string {
        return "eat food"
    }
}
const aa = new A()
// A.name = "aa" 这里无法修改name属性 因为规定它只读了
A.age//静态属性的调用与java雷同
aa.getName()
aa.eatFood()
const bb = new B()
bb.name = "dell"
bb.getName()
bb.getSuperName()
bb.eatFood()

class Q {
    constructor(public name: string) {
        this.name = name
    }
}//简化属性，这里是类内部有一个name属性，构造时需要你传递一个name变量的值进来初始化

class W {
    constructor(private name: string) {

    }
    set setName(name: string) {
        this.name = name
    }
    get getName() {
        return this.name
    }
}
const w = new W('frist name')
// 这里直接调用 w.name会报错和Java一样的需要set与get方法对私有变量进行读取与修改
w.getName //直接获取值
w.setName = "second name" //与Java不同的是这里的setter与getter方法都是采取的属性用法而不是当方法来用

//7、抽象类

abstract class E {
    successIsTrue() {
        console.log('success')

    }
    abstract success(): string
    abstract error(): string
}//与java雷同
class R extends E {
    success(): string {
        throw new Error('Method not implemented.');
    }
    error(): string {
        throw new Error('Method not implemented.');
    }

}
enum en {

}//支持枚举

// 基础学习就此结束！！！