前端|你好，我叫TypeScript04──函数与类

函数与类

前言本

文章是Typescript系列学习文章，旨在利用碎片时间快速高效上手学习Typescript，也可以对Typescript进行复习知识点，温故知新。

10年积累的成都网站建设、网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有巩义免费网站建设让你可以放心的选择与我们合作。

前文回顾

  • 《你好，我叫Typescript 01 ── 数据类型》
  • 《你好，我叫Typescript 02 ── 变量与接口》
  • 《你好，我叫Typescript 03 ── 泛型》

函数

「蹦蹦」：跳跳，好几天不见，我最近在学习Typescript又遇到了新问题，亟需你的解答。

「跳跳」：啥问题呀，蹦蹦。

「蹦蹦」：什么是快乐星球，什么是...不对不对 什么是函数?TS的函数和JS的函数有啥区别?

「跳跳」：那就带你一起研究。

介绍

「跳跳」：函数是定义行为的语法，其实是为JS添加额外的功能。同样的可以创建有名称的函数和匿名函数。

 
 
 
 
    
  
  
  
  
  1. function add(num1:number,num2:number):number{ 
    2.   
  
  
  
  2.   return num1 + num2; 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. console.log(add(1,2));//3 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. let addNum = (num1:number,num2:number):number => num1+num2; 
    8.   
  
  
  
  8. console.log(addNum(1,2));//3 
    9.

我们可以给每个参数添加类型之后再为函数本身添加返回值类型。 TypeScript能够根据返回语句自动推断出返回值类型，因此我们通常省略它。

简而言之，函数类型包含「参数类型」和「返回值类型」两个部分，当写出完整类型的时候，两部分都需要完整书写。其实，可以以参数列表的形式写出参数类型，为每一个参数指定一个名字和类型，增加代码的可读性。

只要参数类型是匹配的，那么就认为它是有效的函数类型，而不在乎参数名是否正确。

第二部分是返回值类型。如之前提到的，返回值类型是函数类型的必要部分，如果函数没有返回任何值，你也必须指定返回值类型为 void而不能留空。

在赋值语句的一边指定了类型但是另一边没有类型的话，TypeScript编译器会自动识别出类型。

函数参数定义的方式

1.直接声明函数参数

 
 
 
 
    
  
  
  
  
  1. function add(num1:number,num2:number):number{ 
    2.   
  
  
  
  2.   return num1 + num2; 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4. add(1,2);//3 
    5.

2.解构赋值声明函数参数

 
 
 
 
    
  
  
  
  
  1. function add({num1,num2}:{num1:number,num2:number}):number{ 
    2.   
  
  
  
  2.   return num1 + num2; 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4. add({x:1,y:2});//3 
    5.

3.剩余参数声明函数参数

 
 
 
 
    
  
  
  
  
  1. function add(...rest:number[]){ 
    2.   
  
  
  
  2.   return rest.reduce((pre,cur)=>pre+cur); 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4. add(2,3,4,5);//14 
    5.   
  
  
  
  5. add("yichuan",3);//报错，不能使用字符串 
    6.

4.命名式声明函数参数

 
 
 
 
    
  
  
  
  
  1. type add = (num1:number,num2:number)=>number; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. interface add{ 
    4.   
  
  
  
  4.   (x:number,y:number):number 
    5.   
  
  
  
  5. } 
    6.

调用方式：

 
 
 
 
    
  
  
  
  
  1. let addFun:add=>(num1,num2)=>num1+num2; 
    2.

5.可选参数和默认参数

 
 
 
 
    
  
  
  
  
  1. function add(num1:number,num2:number,num3?:number):number{ 
    2.   
  
  
  
  2.   return num1 + num2; 
    3.   
  
  
  
  3. } 
    4.

显而易见：num1和num2是默认参数，num3是可选参数。切记，默认参数放前面，可选参数放后面。

this

在JS中的this指向问题很恼火，this的指向是在函数被调用时进行指定的，但是得整明白函数调用的上下文是什么，这是比较困扰的。其实两者没多大区别。

幸运的是，TS能够通知你错误地使用了this的地方。

函数重载

函数重载或方法重载是使用相同名称和不同参数数量或类型创建多个方法的一种能力。

 
 
 
 
    
  
  
  
  
  1. function addFun(num1:number,num2:number):number; 
    2.   
  
  
  
  2. function addFun(num1:string,num2:string):string; 
    3.   
  
  
  
  3. function addFun(num1:string,num2:number):string; 
    4.   
  
  
  
  4. function addFun(num1:number,num2:string):string; 
    5.   
  
  
  
  5. function addFun(num1:any,num2:any):any{ 
    6.   
  
  
  
  6.   if(typeof num1 === "string" || typeof num2 === "string"){ 
    7.   
  
  
  
  7.     return num1.toString() + num2.toString(); 
    8.   
  
  
  
  8.   } 
    9.   
  
  
  
  9.   return num1 + num2; 
    10.   
  
  
  
  10. } 
    11.   
  
  
  
  11. console.log(addFun(1,2)); 
    12.

「蹦蹦」：我们可以看到大多数的库源码都是进行函数重载的方式，这是为什么?

「跳跳」：这是因为使用函数重载后，其他人只要看到函数重载声明就可以知道函数的调用方式。

函数重载的方式，就是ts会从一开始查找类型，如果匹配就返回函数类型，如果不匹配就到下一个。 因此，在定义重载的时候，一定要把最精确的定义放在最前面。「tips: 维护一个公共组件时, 可使用这种方式让使用者和后面维护者快速知道函数的调用方式.」

类

「蹦蹦」：TS的类和JS有啥不同?

「跳跳」：在es6前，传统的Javascript需要使用函数和原型链继承的方式才能实现可重用的组件，但是这种对于不了解JS原型链原理的程序员却显得困难。而ES6引入了类的思想，使得程序员可以基于类进行面向对象的方式编程。

类的属性和方法

「蹦蹦」：在面向对象编程的语言中，类可以创造对象的蓝图，描述所要创建对象的公共属性和方法。

 
 
 
 
    
  
  
  
  
  1. class Person{ 
    2.   
  
  
  
  2.   //实例属性 
    3.   
  
  
  
  3.   name: string; 
    4.   
  
  
  
  4.   age: number; 
    5.   
  
  
  
  5.   //私有字段 
    6.   
  
  
  
  6.   #score:number; 
    7.   
  
  
  
  7.   //静态属性 
    8.   
  
  
  
  8.   static height:number = 180; 
    9.   
  
  
  
  9.   // 
    10.   
  
  
  
  10.   readonly weight:number = 130; 
    11.   
  
  
  
  11.   //构造函数 
    12.   
  
  
  
  12.   constructor(name:string,age:number,score:number){ 
    13.   
  
  
  
  13.     this.name = name; 
    14.   
  
  
  
  14.     this.age = age; 
    15.   
  
  
  
  15.     this.#score = score; 
    16.   
  
  
  
  16.   } 
    17.   
  
  
  
  17.   //实例方法 
    18.   
  
  
  
  18.   getName(){ 
    19.   
  
  
  
  19.     return this.name; 
    20.   
  
  
  
  20.   } 
    21.   
  
  
  
  21.   //静态方法 
    22.   
  
  
  
  22.   static getAge(){ 
    23.   
  
  
  
  23.     return this.age; 
    24.   
  
  
  
  24.   } 
    25.   
  
  
  
  25. } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. let person:Person = new Person("wenbo",12); 
    28.   
  
  
  
  28. console.log(person.getName()); 
    29.   
  
  
  
  29. console.log(Person.height); 
    30.   
  
  
  
  30. person.name = "zhaoshun"; 
    31.   
  
  
  
  31. console.log(person.getName()); 
    32.   
  
  
  
  32. Person.height = 170; 
    33.   
  
  
  
  33. console.log(Person.height); 
    34.   
  
  
  
  34. person.weight = 110; 
    35.   
  
  
  
  35. console.log(person.weight); 
    36.
  • 实例属性(成员属性)：直接在类中定义的属性就是实例属性，需要通过对象的实例进行访问。
  • 静态属性(类属性)：在属性前使用static关键字可以定义类属性(静态属性)，可以直接通过类进行访问。
  • 私有字段：在属性前加上#，即可将属性变成私有属性，不能在包含的类之外访问，甚至不能被检测到。每个私有属性都唯一限定了其包含的类，不能在私有属性上使用ts的可访问修饰符(public、private)。
  • 构造函数(执行初始化操作)：构造函数会在对象创建时调用，在实例方法中，this就表示当前的实例.在构造函数中当前对象就是当前新建的那个对象，可以通过this向新建的对象中添加属性。
  • 实例方法(成员方法)：直接在类中定义的方法就是实例方法，需要通过对象的实例进行调用。在方法中可以通过this来表示当前调用方法的对象。谁调用该方法，就指向谁。
  • 静态方法(类方法)：在方法前使用static关键字可以定义类方法(静态方法)，可以直接通过类进行访问。

继承

基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。

 
 
 
 
    
  
  
  
  
  1. class Animal { 
    2.   
  
  
  
  2.     move(distanceInMeters: number = 0) { 
    3.   
  
  
  
  3.         console.log(`Animal moved ${distanceInMeters}m.`); 
    4.   
  
  
  
  4.     } 
    5.   
  
  
  
  5. } 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. class Dog extends Animal { 
    8.   
  
  
  
  8.     bark() { 
    9.   
  
  
  
  9.         console.log('Woof! Woof!'); 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. const dog = new Dog(); 
    14.   
  
  
  
  14. dog.bark(); 
    15.   
  
  
  
  15. dog.move(10); 
    16.   
  
  
  
  16. dog.bark(); 
    17.

如上所示是最基本的继承：类从基类中继承了属性和方法。这里，Dog是一个派生类，它派生自Animal基类，通过 extends关键字。派生类通常被称作 子类，基类通常被称作 超类。

因为Dog继承了Animal的功能，因此我们可以创建一个Dog的实例，它能够bark()和move()。

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

在TS中可以给类的属性、方法及构造器设置修饰符，来限定它们的作用范围。默认修饰符是public，因此可以当前类和子类自由访问程序中定义的成员。

「tip: 在写类时, 要养成随手添加成员修饰符的习惯.」

 
 
 
 
    
  
  
  
  
  1. class Father{ 
    2.   
  
  
  
  2.   //公共成员 
    3.   
  
  
  
  3.   public name:string; 
    4.   
  
  
  
  4.   //私有成员 
    5.   
  
  
  
  5.   private age:number; 
    6.   
  
  
  
  6.   //受保护成员 
    7.   
  
  
  
  7.   protected address:string; 
    8.   
  
  
  
  8.   public constructor(name:string,age:number,address:string){ 
    9.   
  
  
  
  9.     this.name = name; 
    10.   
  
  
  
  10.     this.age = age; 
    11.   
  
  
  
  11.     this.address = address; 
    12.   
  
  
  
  12.   } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.   public eat(meters:number){ 
    15.   
  
  
  
  15.     console.log(`${this.name} moved ${meters}`); 
    16.   
  
  
  
  16.   } 
    17.   
  
  
  
  17. } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. class Son extends Father{ 
    20.   
  
  
  
  20.   constructor(){ 
    21.   
  
  
  
  21.     super() 
    22.   
  
  
  
  22.   } 
    23.   
  
  
  
  23.   test(){ 
    24.   
  
  
  
  24.     console.log(this.name);//可访问 
    25.   
  
  
  
  25.     console.log(this.age);//属性“age”为私有属性，只能在类“Father”中访问。 
    26.   
  
  
  
  26.     console.log(this.address);//可访问 
    27.   
  
  
  
  27.   } 
    28.   
  
  
  
  28. } 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30. const bigLiu = new Father("bigLiu",32,"四川省成都市"); 
    31.   
  
  
  
  31. console.log(bigLiu.name);//可访问 
    32.   
  
  
  
  32. console.log(bigLiu.age);//属性“age”为私有属性，只能在类“Father”中访问。 
    33.   
  
  
  
  33. console.log(bigLiu.address);//属性“address”受保护，只能在类“Father”及其子类中访问。  
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. const smallLiu = new Son(); 
    36.   
  
  
  
  36. console.log(bigLiu.name);//可访问 
    37.   
  
  
  
  37. console.log(bigLiu.age);//属性“age”为私有属性，只能在类“Father”中访问。 
    38.   
  
  
  
  38. console.log(bigLiu.address);//属性“address”受保护，只能在类“Father”及其子类中访问。  
    39.

访问器(存取器)

TypeScript支持通过 getters/setters来截取对对象成员的访问。它能帮助你有效的控制对对象成员的访问。

 
 
 
 
    
  
  
  
  
  1. class Greeter { 
    2.   
  
  
  
  2.    constructor(message: string) { 
    3.   
  
  
  
  3.        this.greeting = message; 
    4.   
  
  
  
  4.    } 
    5.   
  
  
  
  5.    greeting: string; 
    6.   
  
  
  
  6.    get hello() { 
    7.   
  
  
  
  7.        return this.greeting; 
    8.   
  
  
  
  8.    } 
    9.   
  
  
  
  9.    set hi(x) { 
    10.   
  
  
  
  10.        this.greeting = x; 
    11.   
  
  
  
  11.    } 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13. const x = new Greeter('eeee') 
    14.   
  
  
  
  14. x.hi('22'); 
    15.   
  
  
  
  15. x.hello = '2' // 报错, 不能修改 
    16.

实际上就是使用getters/setters来截取对对象成员的访问。解析出来的源码如下:

抽象类

使⽤ abstract 关键字声明的类，我们称之为抽象类。抽象类不能被实例化，因为它⾥⾯包含⼀个或多个抽象⽅法。所谓的抽象⽅法，是指不包含具体实现的⽅法：

 
 
 
 
    
  
  
  
  
  1. abstract class Person { 
    2.   
  
  
  
  2. constructor(public name: string){} 
    3.   
  
  
  
  3. abstract say(words: string) :void; 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5. // Cannot create an instance of an abstract class.(2511) 
    6.   
  
  
  
  6. const lolo = new Person(); // Error 
    7.

抽象类不能被直接实例化，我们只能实例化实现了所有抽象⽅法的⼦类。具体如下所示：

 
 
 
 
    
  
  
  
  
  1. abstract class Person { 
    2.   
  
  
  
  2.   constructor(public name: string){} 
    3.   
  
  
  
  3.     // 抽象⽅法 
    4.   
  
  
  
  4.     abstract say(words: string) :void; 
    5.   
  
  
  
  5.   } 
    6.   
  
  
  
  6.   class Developer extends Person { 
    7.   
  
  
  
  7.   constructor(name: string) { 
    8.   
  
  
  
  8.   super(name); 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10. say(words: string): void { 
    11.   
  
  
  
  11.   console.log(`${this.name} says ${words}`); 
    12.   
  
  
  
  12.   } 
    13.   
  
  
  
  13. } 
    14.   
  
  
  
  14. const lolo = new Developer("lolo"); 
    15.   
  
  
  
  15. lolo.say("I love ts!"); // lolo says I love ts! 
    16.

小结

「跳跳」：其实本篇文章主要介绍了：函数和类的概念、继承、各种属性等等。

参考文章

  • 阿宝哥的《重学TS》
  • 《TS中文文档》

文章标题：前端|你好，我叫TypeScript04──函数与类
网站地址：http://www.shufengxianlan.com/qtweb/news47/3997.html

成都网站建设公司_创新互联，为您提供静态网站、域名注册、网站建设、软件开发、标签优化、微信公众号

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

同城分类信息

成都SEO优化　　 　东电技改　　 　吉安网站建设　　 　做网站的公司　　 　东方电机技改　　 　中国电信成都枢纽中心　　 　华川商务　　 　成都服务器租赁　　 　成都广告设计　　 　绵阳机房托管　　 　网站空间　　 　众诚伟业　　 　网站解决方案　　 　广安网站建设　　 　网站设计　　 　重庆网站制作　　 　蓬溪网站建设　　 　重庆教育培训网站建设　　 　成都二枢电信服务器托管　　 　名片印刷厂