类型相关
数组类型
定义数组类型有两种方式。
let arr: number[] = [1, 2, 3, 4]
let arr: string[] = ['1', '2', '3']
//第二种
let arr: Array<number> = [1, 2, 3, 4]
let arr: Array<string> = ['1', '2', '3']
元组类型，属于数组的一种，可以定义多种类型。
let arr: [string, number, boolean] = ['ts', 1, true]
枚举类型
enum 枚举名 {
标识符 = 整形常数
标识符 = 整形常数
标识符 = 整形常数
}
enum Flag {
success = 1,
error = -1,
}
var f: Flag = Flag.success
console.log(f)// 1
enum Color { red, blue, orange }
let c: Color.blue
console.log(c)//1
enum Color { red, blue=5, orange }
let c: Color.orange
console.log(c)//6
我们发现枚举类型有值的时候拿值，没值会把枚举的索引作为值。在他之前的枚举有值，会在那个值上面累加。
void 类型
表示没有任何类型。
function console(): viod{
console.log('123')
}
function console(): number{
return 123
}
一般用在定义的方法没有返回值的时候，如果有返回值，返回值得按照函数的定义类型
函数相关
普通定义
//普通
function getInfo(name: string, age: number): string {
return `${name}---${age}`
}
getInfo('coolFish', 20)
一个普通的函数定义，需要定义参数类型和返回值的类型，方法的形参和实参必须一致，如果要不一致不许配置可选阐述。
可选参数
//可选参数
function getInfo(name: string, age?: number): string {
if(age){
return `${name}---${age}`
}else{
return name
}
getInfo('coolFish')
默认参数
//默认参数
function getInfo(name: string='coolFish', age?: number): string {
if(age){
return `${name}---${age}`
}else{
return name
}
getInfo('yzy')
剩余参数
//原本
function sum(a: number, b: number, c: number, d: number): number {
return a + b + c + d
}
console.log(sum(1, 2, 3, 4))
//使用剩余参数
function sum(...result: number[]): number {
let sum = 0
for (let i = 0; i < result.length; i++) {
sum += result[i]
}
return sum
}
console.log(sum(1, 2, 3, 4))
//分离定义
function sum(a: number, ...result: number[]): number {
let sum = 0
for (let i = 0; i < result.length; i++) {
sum += result[i]
}
return sum
}
console.log(sum(1, 2, 3, 4))
函数重载
function getInfo(name: string): string;
function getInfo(name: number): string;
function getInfo(str: any): any {
if (typeof str === 'string') {
return '名字' + str;
} else {
return '年龄' + str
}
}
console.log(getInfo(25))
console.log(getInfo('coolFish'))
小结：根据参数不同类型，执行不同逻辑，叫做方法的重载。
TS中的类
基本写法
class Person {
name: string;
constructor(name: string) {
this.name = name
}
getName(): string {
return this.name
}
setName(name: string): void {
this.name = name
}
}
const p = new Person('coolFish')
console.log(p.getName())
console.log(p.setName('yzy'))
实例方法
实例方法，需要实例化后才能使用。
class Person {
public:name:string;
public:age:number=20;
constructor(name: string) {
this.name = name
}
run(): string {
return `${this.name}在跑步`
}
getName(): string {
return this.name
}
}
let p = new Person('coolFish')
p.run()
静态方法和静态属性
静态方法里面，没法直接调用类里面的属性。 静态属性可以在静态方法中使用。
//实例方法，需要实例化后才能使用
class Person {
public name: string;
public age: number = 20;
static sex: "男"
constructor(name: string) {
this.name = name
}
static work() {
return this.name + '正在敲代码'
//
}
static MySex() {
return `我的性别${Person.sex}`
//
}
}
Person.work()
Person.MySex()
super
super 作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次 super() 函数。注意：作为函数时，super() 只能用在子类的构造函数之中，用在其他地方就会报错。
类里的修饰符
- public : 公有，在类里面，子类，类外面都可 访问
- protected ：保护类型，在类里面，子类里面都可访问，类外部没法访问
- private ：私有，只有在类里面可以访问
属性不加修饰符，默认就是公有属性
