函数定义的方式
//匿名函数 两个number类型参数 返回值为number类型
const fun = function(a:number,b:number):number{
return a+b
}
//调用
console.log(fun(10,20))
//有名函数 fu1就是函数名 括号后不限定则默认any
function fu1(name:string,age:number){
return name
}
//调用
console.log(fu1("张三",20))
//箭头函数 不使用function关键字 void类型表示不可设置返回值
//推荐多使用箭头函数
const fu2 = (time:number):void=>{
console.log(time)
}
fu2(2022)
函数参数
可选参数
添加:问号?
默认参数
//默认参数 z:number = 100 100为z的默认值 当不传z的值时使用,
const fun2 = function(x:number,y:number,z:number = 100){
return x+y+z;
}
//调用函数 都不会报错
fun2(100,200)
fun2(100,200,300)
给默认参数设置了默认值之后,他其实不传也不会报错了,变为了一个可选参数一样
剩余参数
剩余参数时放在函数声明的时候所有参数的最后
搭配解构赋值使用
//剩余参数
const fun3 = function(x:number,y:string,...args:any[]){
console.log(x);
console.log(y)
console.log(args)
函数重载
函数相同,函数的参数及个数不同
//函数重载语法格式
export default {};
// 创建一个重载函数
function chong(num1: any, num2: any) {
return num1 + num2;
}
console.log(chong("12312", 123)); //12312123
console.log(chong(12312, 123)); //12435
注意点;重载要写在函数定义前面
需要使用function关键字来定义函数
类
类的使用
TypeScript是面向对象的JavaScript
类描述了所创建的对象共同的属性和方法
TypeScript支持面向对象的所有特性,比如类、接口等
类名首字母建议大写
//语法格式
class class_name{
//类作用域
}
定义类的关键字为class,后面紧跟类名,类可以包括以下几个模块(类的数据成员):
- 字段 — 字段是类里面声明的变量,字段表示对象的有关数据
- 构造函数 — 类实例化时调用,可以为类的对象分配内存 构造函数中的this指向该类
- 方法 — 方法为对象执行的操作,
export default {}; //创建一个类 class Person { //字段 属性:属性值 name: string; age: number; //构造函数 参数可以与属性不一致 此参数可理解为形参 constructor(name: string, age: number) { //this指向的是该Person类 this.name = name; this.age = age; } //函数(方法) say(): void { console.log(`我的名字叫${this.name},今年${this.age}岁`); } } // 实例化 let stu1 = new Person("老六", 10); // 调用函数 stu1.say(); //我的名字叫老六,今年10岁
类的继承
TypeScript支持继承类,即可以在创建类的时候继承一个已存在的类,这个已存在的类为父类,继承它的类被称为子类。
类继承使用的关键字为extends,子类除了不能继承父类的私有成员(方法和属性)和构造函数,其他都可以继承。
TypeScript一次只能继承一个类,不支持继承多个类,但TypeScript支持多重继承(A继承B,B继承C)
export default {};
//语法格式
//class son_class_name extends fa_class_name
//super() 子类构造中使用super() 表示调用父类的构造函数
//super.方法名() 表示调用父类中的方法
// 创建一个类
class Person {
// 属性
name: string;
age: number;
// 构造函数
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
// 方法
say(): void {
console.log(`我叫${this.name},我是父类`);
}
}
// 子类继承父类
class Son extends Person {
// 子类属性
score: number;
// 构造函数
constructor(name: string, age: number, score: number) {
// 调用父类属性 super()
super(name, age);
this.score = score;
}
// 子类方法
say(): void {
// 调用父方法
super.say(); //我叫赵六, 我是父类;
// 重写父类方法
console.log(`我叫${this.name},我是子类`); //我叫赵六, 我是子类;
}
}
// 实例化
let stu1 = new Son("张三", 20, 99);
// 调用实例化的对象
stu1.say();
static与instanceof
static关键字用于定义类的数据成员(属性和方法)为静态的,静态成员可以直接通过类名调用。
instanceof运算符用于判断对象是否是指定的类型,如果是返回true,否则返回false;
// instaceof 判断对象是否是某个指定类型 格式:对象名 instaceof 类名 返回布尔值
// 创建一个类
class Student {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
let stu1 = new Student("李四", 14);
console.log(stu1 instanceof Student); //true
类中的修饰符
- public(默认):共有,可以在任何地方被访问
- protected:受保护,可以被其自身及其子类访问
- private:私有,只能被其定义所在的类访问
- readonly:可以使用readonly关键字将属性设置为可读的,只读属性必须在声明时或构造函数里被初始化
getter与setter
官方的另一个名字:存取器
通过getters/setters来截取对对象成员的访问
注意:
如果存在get,但没有set,则该属性自动是只读的
如果没有指定setter参数的类型,他将从getter的返回类型中推断出来
访问器和设置其必须有相同的成员可见性
export default {}
class GetNameClass{
private _fullName:string="万妮达"
get fullName(){
return this._fullName;
}
set fullName(newName:string){
console.log("set被调用了");
this._fullName = newName;
}
}
let n=new GetNameClass()
n.fullName="杨和苏"
console.log(n);
console.log(n.fullName);
抽象类
抽象类作为其他派生类的基类使用,他们一般不会直接被实例化
抽象类是专门用于定义那些不希望被外界直接创建的类
抽象类和接口一样用于约束子类
抽象类和接口的区别:
抽象方法必须包含abstract关键字并且可以包含访问修饰符
接口中只能定义约束,不能定义具体实现,而抽象类中即可以定义约束,又可以定义具体实现
export default {};
// 声明一个抽象类
abstract class Person {
abstract name: string;
abstract age: number;
show() {}
}
// 声明一个类继承
class Student extends Person {
name: string = "张三";
age: number = 20;
}
let stu1 = new Student();
console.log(stu1); //Student { name: '张三', age: 20 }
类的初始化顺序
-
基类的字段被初始化
-
基类构造函数运行
-
子类的字段被初始化
-
子类构造函数运行
export default {}; // 父类 class Old { name: string = "张三"; constructor() { console.log(`我的名字是:${this.name}`); } } // 子类 class Young extends Old { name: string = "李四"; constructor() { super(); } } let y = new Young(); console.log(y); //1、我的名字是:张三 Old类 //2、Young { name: '李四' } Young类