TS中的数据类型及变量

ts基础数据类型：

布尔：boolean（true, false）
数字：number (6,0xffff,0b10101,0o,772)
字符串：string:('aaaa')
数组：number[] ([1,2,3])
数组泛型：Array<number> （[1,2,3]）
元组：[string,number] (['11',11])
枚举：enum (COLOR {red=1,Green,Blue})
Any:类型不受限制（主要用来重构代码和使用别人的依赖）
void：表示函数无返回类型
Null 和 Undefined
null和undefined是所有类型的子类型
理论上可以复制给任何类型
但是当使用了- - strictNullChecks标记
就只能赋值给自己的类型
Object
非原始类型，也就是除了上诉类型以外的其他对象类型
object类型上挂载了很多处理对象的方法

类型断言

就是强制转换的类型，人为的类型强制转换
第一种使用尖括号 (<string> someValue).length
第二种使用as关键字 (someValue as string).length

变量：

ts中使用let和const声明变量，并且具有块级作用域（花括号作用域）

使用最小特权原则，所有变量除了你计划去修改的都应该使用const

解构

数组解构：

const [first ,second] = [1,2]

对象解构

const {a,b} = {a:1,b:2}

解构可以加默认值 {a,b=100}

展开

...操作符有展开的作用
let first = [1,2,3]
let a=[1,...first]

接口

ts的核心原则之一是对变量类型进行强制检查。可以叫做填鸭式辩型或者结构性子类型化。

可选属性

接口可以声明可选属性，实现不一定需要具有此类属性
interface ISquare{
color?:string;
width?:number;
}

只读属性

有些属性只能在对象实例化的时候赋值
interface Point{
readonly x:number;
readonly y:number;
}

let p:point = {x:1,y:100}
p1.x=5 //error

ReadonlyArray<T> 类型可以创建一个只读的数组
let r:ReadonlyArray<number> = [1,2,3]
r[0] = 2 //error

readonly vs const
如果限制的是对象则使用const 如果限制的是对象的属性则使用readonly

一般情况下，接口的实现需要满足刚好覆盖其中的所有属性，但是有时候会有动态添加额外属性的需求

interface Square {
color:string;
width;number;
[propName:string]:any
}

接口定义函数类型：

interface SeacFunc{
(a:string,b:number):boolean;
}

let myFunc = function (a:string,b:number):boolean {
  return true
}

类类型：

同java这类语言一样

interface IClock {
    currentTime: Date;
    setTime(time: Date): void;
}

class homeClock implements IClock {
    constructor(timeNow: Date) {
        if (timeNow) {
            this.setTime(timeNow)
        }
    }
    currentTime: Date = new Date();
    setTime(time: Date) {
        this.currentTime = time
    }
}

##接口继承（扩展）,可多接口继承
interface Shape{
color:string;
}

interface Content{
  text:string;
}

interface square extends shape,Content {
    width:number
}

类

继承：

extends 关键字：类型java

通过super关键字指代父类（this指代本类）这个例子也演示了如何在子类中重写父类的方法

    name: string;
    constructor(name: string) {
        this.name = name
    }
    move(distanceInMeters: number = 0) {
        console.log(`Animal ${this.name} moved ${distanceInMeters}m.`);
    }
}

class Dog extends Animal {
    constructor(name: string) {
        super(name)
    }
    bark() {
        console.log('Woof! Woof!');
        super.move(100)
    }
}

公共，私有与受保护的修饰符：

private 私有修饰符只能在本类中被访问的成员
public 公共修饰符所有地方都能访问
protected 受保护修饰符在继承类中能被访问

readonly 修饰只读属性必须在声明或者构造函数中被初始化

属性存取器：(属性劫持)

class student {
    private _name: string = '';
    get name() {
        return this._name + '1111';
    }

    set name(value) {
        this._name = value + '222'
    }
}

let a = new student()
a.name = 'aaa'
console.log(a.name)

抽象类

一般作为派生类的基类使用，不能被实例化，抽象类和接口不同的是：抽象类有更多成员的细节
abstract关键字用于定义抽象类和抽线方法
子类继承了抽象类可以去重写里面的方法

函数

完整定义一个函数

let myFunc: (x: number, y: number) => number = function (x1: number, y1: number): number {
    return x1 + y1
}

console.log(myFunc(1, 2))

类型推断

let myFunc: (x: number, y: number) => number = function (x1, y1){
    return x1 + y1
}

函数赋值是不用指定具体类型，会根据类型进行推断

可选参数和默认参数

function(x?: number, y: number = 100): number {
    return x + y
}

剩余参数

将未知的参数合并到一个集合中

function func(x: number, ...argslist: number[]) {
    let sum: number = x;
    if (argslist.length) {
        argslist.forEach(item => {
            sum += item
        })
    }
    return sum
}

console.log(func(1, 2, 3, 4, 5, 6))

this用法及箭头函数

js语言中，this是在函数调用时指定的，函数内部的this指向调用该函数的对象，如果没有对象，则指向window，严格模式下则为undefined

特别的，箭头函数可以在创建函数时就指定this的指向

重载

即：函数签名一样，但参数类型，个数和返回值类型不同；
js是动态类型，且参数可变，不存在重载的说法
但是TS可以跟c#一样，定义方法的重载

泛型

当创建函数或者对象时，不确定参数的类型，或者可以适用多种类型时，可以用泛型定义
和any不同，any完全不约束传入参数的类型，但是泛型会约束传入参数和返回值的类型一致性

泛型方法

function func<T>(name: T): T {
    return name
}
console.log(123)

泛型接口

interface GebericNumber<T> {
    menber1: T;
    setmen(name: string, ob: T): T;
}

泛型约束

如果不对泛型做约束，所有的类型都需要通过操作验证，比如string有length属性但是boolean没有，如果我们直接在泛型上使用length属性，就会报错，假设我们通过泛型约束去约束类型必须有length属性（即必须继承包含length属性的接口）就不会报错了

interface lengthWise {
    length: number;
}

class iden<T extends lengthWise>{
    name: T;
    send(arg: T): T {
        console.log(arg.length)
        return arg
    }
}

let testObj = new iden()
testObj.send('111')

高级类型

联合类型

希望一个变量同时支持多种类型，使用竖线分割

function unions(name: string, value: string | number) {
    if (typeof value == 'number') {
        return name + ' numbber'
    }
    else {
        return name + ' string'
    }
}

console.log(unions('aa', 111))
console.log(unions('aa', 'bbb'))

this类型

this类型表示的是某个类或者接口本身

class basicCal {
    public value: number = 0;
    constructor(val: number) {
        this.value = val
    }

    public add(optor: number): this {
        this.value += optor
        return this
    }
}

let cal: number = new basicCal(5).add(6).value

console.log(cal)

ts 自学笔记