目录
函数
函数的基本使用
函数是JavaScript应用程序的基础。它帮助你实现抽象层，模拟类，信息隐藏和模块。在TypeScript里，虽然已经支持类，命名空间和模块，但函数仍然是主要的定义行为的地方。TypeScript为JavaScript函数添加了额外的功能，让我们可以更容易地使用
匿名函数
const aa = function(a:number,b:number):number{
return a
}
let a1 = aa(8,9)
console.log(a1);有名函数
function bb(a:number,b:number){
return b
}
let b1 = bb(7,6)
console.log(b1);箭头函数
const cc = (a:number,b:number):void=>{
console.log(`我都两年就爱上的巴士的v阿三不擦时间${a}`);
}
cc(10,11)接口函数
type dd = (a:number,b:number)=>number
const d1:dd = (x:number,y:number)=>x+y
let d2 = d1(56,87)
console.log(d2);函数参数的使用
可选参数
const aa:(a:number,b:number)=>number=(x:number,y:number)=>{
return y
}
const bb = function(a:number,b?:number):number{
return a
}
let b1 = bb(10,undefined)
console.log(b1);默认值
let cc = function(a:number,b:number,c:number=20){
return a+b+c
}
let c1 = cc(20,50)
console.log(c1);剩余参数
const dd = function(...a:any[]){
console.log(a);
}
dd(10,50,60,90,'dasd')
const d1 = function(a:number,b:number,...c:any[]){
console.log(a);
console.log(b);
console.log(c);
}
d1(20,50,'dasd','wwww',10)构造函数
var aa = new Function("a","b","return a*b")
var bb = aa(10,50)
console.log(bb);
函数重载
重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。
每个重载的方法(或者构造函数都必须有一个独一无二的参数类型列表。
function aa(a:number,b:number):number
function aa(a:string,b:string):string
function aa(a:string,b:number):string
function aa(a:number,b:string):string
function aa(a:any,b:any):any{
return a+b
}
let a1 = aa(50,'dsd')
console.log(a1);参数数量不同的时候
如果参数类型不同，则参数类型应设置为any。参数数量不同你可以将不同的参数设置为可选。
function bb(a:string):number
function bb(a:number,b:string):void
function bb(a:any,b?:any):any{
console.log(a);
console.log(b);
}
// bb(85)
bb(85,'dasdasdasdasdasdasdasdasd')类
定义
TypeScript是面向对像的JavaScript。类描述了所创建的对象共同的属性和方法。
TypeScript支持面向对象的所有特性，比如类、接口等。
类的基本使用
定义类的关键字为class，后面紧跟类名，类可以包含以下几个模块(类的数据成员)。字段–字段是类里面声明的变量。字段表示对象的有关数据。
构造函数–类实例化时调用，可以为类的对象分配内存。方法–方法为对象要执行的操作。
class Person{
// 字段
name:string
age:number
// 构造函数
constructor(a:string,b:number){
this.name = a
this.age = b
}
// 方法
sey():void{
console.log(`我叫${this.name}我今年${this.age}岁了`);
}
}
// 实例化
let aa = new Person('wd',20)
aa.sey()类的继承
TypeScript支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。货继承使用关键字extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
TypeScript一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承(A继承B，B继承C)。
class Person{
name:string
age:number
constructor(a:string,b:number){
this.name = a
this.age = b
}
sey():void{
console.log(`我叫${this.name}我今年${this.age}岁了`);
}
}
// let aa = new Person('搜索',20)
// aa.sey()
// 继承
class Student extends Person{
sex:string
constructor(name:string,age:number,sex:string){
super(name,age)
this.sex = sex
}
sey():void{
super.sey()
console.log(`我叫${this.name}我今年${this.age}岁了我的性别是${this.sex}`);
}
}
let bb = new Student('订单',20,'女')
bb.sey()static与instanceof
static关键字用于定义类的数据成员（属性和方法)为静态的，静态成员可以直接通过类名调用。
class Person{
// 字段
static aa:string
// 方法
static sey():void{
console.log("我叫"+Person.aa);
}
}
Person.aa
Person.sey()instanceof运算符用于判断对象是否是指定的类型，如果是返回true，否则返回false。
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);修饰符
public：默认，公有的，可以在任何地方被访问
protected：受保护，可以被自身及其子类访问
private：私有，只能被其定义所在的类访问
class Person{
// 字段
// public：默认，公有的，可以在任何地方被访问
// protected：受保护，可以被自身及其子类访问
// private：私有，只能被其定义所在的类访问
public name:string
protected age:number
private sex:string
// 构造函数
constructor(a:string,b:number,c:string){
this.name = a
this.age = b
this.sex = c
}
// 方法
sey():void{
console.log(`我叫${this.name}我今年${this.age}岁了`);
}
}
class Student extends Person{
shengao:number
constructor(a:string,b:number,c:string,d:number){
super(a,b,c)
this.shengao = d
}
sey(): void {
console.log('aa');
this.name='我当时'
this.age= 85
// this.sex = '男'
this.shengao = 185
}
}readonly：可以使用readon1y关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Plll{
// readonly：只读
readonly str:string="可分解可得到内存空间参考"
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
}
sey(){
console.log(this.str2,this.str3,this.str4,this.str5);
// this.str2 = 'dasdasd'
}
}
let b = new Plll('dasdasdasd','dasdasdasdasd','dasdasdas','dwwwasd')
b.sey()getter与setter
官方的另外一个名字:存取器
通过getters/setters来截取对对象成员的访问
如果存在get，但没有set，则该属性自动是只读的
如果没有指定setter 参数的类型，它将从getter的返回类型中推断出来访问器和设置器必须有相同的成员可见性
class Pll{
private _name:string = '球球'
get name():string{
console.log('get被调用了');
return this._name //取
}
set name(newName){
console.log('set被调用了');
this._name = newName //存
}
}
let a = new Pll()
a.name = '王五'
console.log(a);
console.log(a.name);抽象类
定义
抽象类做为其它派生类的基类使用。它们一般不会直接被实例化抽象类是专门用于定义哪些不希望被外界直接创建的类的
抽象类和接口一样用于约束子类
抽象类和接口区别
抽象方法必须包含abstract关键字并且可以包含访问修饰符
接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现
export default {}
abstract class Person{
abstract name:string
abstract age:number
abstract show():string
sey(){
console.log('嗡嗡嗡');
}
}
class Student extends Person{
name:string = '周慧敏'
age:number = 20
show(){
return '我啊倒萨打算'
}
}
let a = new Student()
console.log(a.show());
初始化
初始化顺序：
- 基类的字段被初始化
- 基类构造函数运行
- 子类的字段被初始化
- 子类构造函数运行
export default {}
class fu{
name:string = '请求'
constructor(){
console.log(`大苏打${this.name}`);
}
}
class zi extends fu{
name:string = '王五'
constructor(){
super()
console.log(`大苏打${this.name}`);
}
}
let p = new zi
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
