函数的基础使用
·介绍
函数是JavaScript应用程序的基础。它帮助你实现抽象层,模拟类,信息隐藏和模块。在TypeScript里,虽然已经支持类,命名空间和模块,但函数仍然是主要的定义行为的地方。TypeScript为JavaScript函数添加了额外的功能,让我们可以更容易地使用
·函数定义的方式
export default {}
//匿名函数
const makeMoney=function(salary:number,reward:number):number{
return salary+reward
}
let res=makeMoney(1000,500);
console.log(res);
//有名函数 | 命名函数 | 普通函数
function writeCode(hour:number,sleep:number):number{
return hour;
}
let res1=writeCode(0,1);
console.log(`我今天学习${res1}小时`);
//箭头函数
const seeMeimei=(time:number):void=>{
console.log(`黄兵理每天奖励自己${time}小时`)
}
seeMeimei(24);
//接口函数
type myFunc = (x: number, y: number) => number
const myFunc: myFunc = (a: number, b: number) => a + b
let res2 = myFunc(3, 2)
console.log(res2);
函数参数的处理
export default{}
// 可选参数
const fun1:(a:number,b:number)=>number=(x:number,y:number)=>{
return x
}
const fun2=function(a:number,b?:number):number{
return a
}
fun2(10)
fun2(10,20)
fun2(10,undefined)
// 参数的默认值
const fun3=function(x:number=2,y:number=1,z:number=100){
return x+y+z
}
let res=fun3(100,200,300)
fun3()
fun3(1,2)
console.log(res);
// 函数的剩余参数
const fun4=function(...args:any[]){
console.log(args);
}
fun4(1,2,34,5,"哈哈")
const fun5=function(a:number,b:string,...args:any[]){
console.log(a);
console.log(b);
console.log(args);
}
fun5(10,"heihei",43,"哈哈","嘿嘿")
构造函数
export default {}
//构造函数
var myfunc=new Function("a","b","return a*b");
var res = myfunc(10,20);
console.log(res);
函数重载
重载是方法名字相同,而参数不同,返回类型可以相同也可以不同。
每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
如果参数类型不同,则参数类型应设置为any。
参数数量不同你可以将不同的参数设置为可选。
export default{}
//函数重载
function fun1(a:number,b:number):number
function fun1(a:string,b:string):string
function fun1(a:number,b:string):number
function fun1(a:string,b:number):number
function fun1(a:any,b:any):any{
return a+b
}
console.log(fun1(10,20));
//参数数量不同
function fun2(c:string):string
function fun2(c:number,d:number):number
function fun2(c:any,d?:any):any{
console.log(c);
console.log(d);
}
fun2("刘亦菲")
fun2(18,19)
类
·定义
TypeScript是面向对旅的JavaScript。
类描述了所创建的对象共同的属性和方法。
TypeScript支持面向对象的所有特性,比如类、接口等。
TypeScript类定义方式如下:
定义类的关键字为class,后面紧跟类名,类可以包含以下几个模块(类的数据成员):
·字段-字段是类里面声明的变量。字段表示对象的有关数据。
·构造函数–类实例化时调用,可以为类的对象分配内存。
·方法-方法为对象要执行的操作。
export default{}
class hs{
name:string
age:number
//构造函数
constructor(name:string,age:number){
this.name=name
this.age=age
}
//函数方法
sayHello():void{
console.log(`我的女神叫${this.name},她今年${this.age}岁了`);
}
}
// 实例化类
let p =new hs("李沁",30)
p.sayHello()
class student extends hs{
score:number
constructor(name:string,age:number,score:number){
super(name,age)
this.score=score
}
sayHello(): void {
super.sayHello()
console.log(`我的男神叫${this.name},他今年${this.age}岁了,他的考试成绩是${this.score}`);
}
}
let s=new student("陈赫",32,98)
s.sayHello()
类中的修饰符
public(默认):公有,可以在任何地方被访问
protected:受保护,可以被其自身以及其子类访问
private:私有,只能被其定义所在的类访问。
·ireadonly:可以使用readon1y关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
export default{}
class Person{
public name:string
protected age:number
private sex:string
constructor(name:string,age:number,sex:string){
this.name=name
this.age=age
this.sex=sex
}
say():void{
console.log(`我的名字是${this.name}性别是${this.sex},年龄是${this.age}`);
}
}
class Studemt extends Person{
score:string
constructor(name:string,age:number,sex:string,score:string){
super(name,age,sex)
this.score=score
}
say(): void {
console.log(this.name);
console.log(this.age);
// console.log(this.sex); //私有的
console.log(this.score);
}
}
//**readonly**:可以使用‘readonly`关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Print{
readonly str4string="我是声明时赋值的"
readonly str2 :string
readonly str3:string
readonly str4:string
readonly str5:string
constructor(str2:string,str3:string,str4:string,str5:string)
{
this.str2=str2;
this.str3=str3;
this.str4=str4;
this.str5=str5
}
// say():void{
// this.str2="爱你"
// }
hs():void{
console.log(this.str2,this.str3,this.str4,this.str5);
}
}
let p=new Print("刘亦菲","刘亦菲2","刘亦菲3","刘亦菲4")
p.hs()
static与instanceof
export default {}
// class Person{
// // 字段
// static aa:string
// // 方法
// static sey():void{
// console.log("我叫"+Person.aa);
// }
// }
// Person.aa
// Person.sey()
class Person{}
let a = new Person
let a1 = a instanceof Person
console.log(a1);
class Student extends Person{}
let b = new Student
let b1 = b instanceof Person
console.log(b1);
getter与setter官方的另外一个名字:存取器
通过getters/setters来截取对对象成员的访问
*注意点:*
如果存在get,但没有set,则该属性自动是只读的
如果没有指定setter参数的类型,它将从getter的返回类型中推断出来
访问器和设置器必须有相同的成员可见性
export default {}
class MyName{
private _fullName:string="杨幂";
//读取字段的值
get fullName(){
console.log("get被调用了")
return this._fullName;
}
//为字段赋值
set fullName(newName:string){
console.log("set被调用了")
this._fullName=newName;
}
}
let n=new MyName();
// n.fullName="刘亦菲"; //赋值
console.log(n);
console.log(n.fullName); //取值
2.6抽象类
定义
抽象类做为其它派生类的基类使用。它们一般不会直接被实例化
抽象类是专门用于定义哪些不希望被外界直接创建的类的
抽象类和接口一样用于约束子类
抽象类和接口区别
抽象方法必须包含abstract关键字并且可以包含访问修饰符
接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现
export default {}
abstract class Person{
abstract name:string
abstract age:number
abstract show():string
showName():void{
console.log("hello world");
}
}
class Student extends Person{
name: string="刘亦菲"
age:number=18
show(){
return"仙剑奇侠传一";
}
}
//let p =new Peraon()
let s = new Student();
let res = s.show();
console.log(res)
console.log()