首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >TypeScript--deno前置学习

TypeScript--deno前置学习

作者头像
wfaceboss
发布2019-04-08 10:36:46
2.5K0
发布2019-04-08 10:36:46
举报
文章被收录于专栏:wfacebosswfaceboss

第一节:前言:

1.JavaScript 的发展简史图:

2.关于node与deno:

(1)Node与Deno 的区别:Node 可以工作,而 Deno 不行,Deno 只是一个原型或实验性产品。

(2)Deno 的目标是不兼容 Node,而是兼容浏览器。Deno 不是要取代 Node.js,也不是下一代 Node.js,也不是要放弃 npm 重建 Node 生态。deno 的目前是要拥抱浏览器生态。

(3)使用deno就 需要加载一个 TypeScript 编译器

其实TypeScript现在用的已经很广泛了,无论你使用ng、React还是Vue都可以使用TypeScript来实现的你JavaScript代码。

3. TypeScript是什么

    typeScript 是一种由微软开发的自由和开源的编程语言。它是 JavaScript 的一个超集,TypeScript 在 JavaScript 的基础上添加了可选的静态类型和基于类的面向对象编程。其实TypeScript就是相当于JavaScript的增强版,但是最后运行时还要编译成JavaScript。TypeScript最大的目的是让程序员更具创造性,提高生产力,它将极大增强JavaScript编写应用的开发和调试环节,让JavaScript能够方便用于编写大型应用和进行多人协作。

4.TypeScript和JavaScript的对比

ypeScript 与JavaScript两者的特性对比,主要表现为以下几点:

(1)TypeScript是一个应用程序级的JavaScript开发语言。(这也表示TypeScript比较牛逼,可以开发大型应用,或者说更适合开发大型应用)

(2)TypeScript是JavaScript的超集,可以编译成纯JavaScript。这个和我们CSS离的Less或者Sass是很像的,我们用更好的代码编写方式来进行编写,最后还是有好生成原生的JavaScript语言。

(3)TypeScript跨浏览器、跨操作系统、跨主机、且开源。由于最后他编译成了JavaScript所以只要能运行JS的地方,都可以运行我们写的程序,设置在node.js里。

(4)TypeScript始于JavaScript,终于JavaScript。遵循JavaScript的语法和语义,所以对于我们前端从业者来说,学习前来得心应手,并没有太大的难度。

(5)TypeScript可以重用JavaScript代码,调用流行的JavaScript库。

(6)TypeScript提供了类、模块和接口,更易于构建组件和维护。

 第二节:开发环境的安装(windows环境下)

1.安装Node.js

安装Node.js非常简单,只要到Node官网下载一个最新版本就可以了,相关安装步骤参考链接:https://www.cnblogs.com/zhouyu2017/p/6485265.html

安装好后,可以打开命令行工具,同时按下win+R,然后输入cmd就可以打开,打开后输入

node -v
npm -v

如果看到相关的版本号说明已经安装成功了,看不到版本号就说明你的node.js没有安装成功。

2.安装TypeScript包

在刚才的命令行窗口继续输入如下命令:

npm install typescript -g

然后,输入如下命令,查看相关版本号,正常显示则说明包安装成功。

tsc --version

3.编写HelloWorld程序

1.初始化项目:进入你的编程文件夹后,可以使用 npm init -y来初始化项目,生成package.json文件。

2.创建tsconfig.json文件,在终端中输入tsc --init:它是一个TypeScript项目的配置文件,可以通过读取它来设置TypeScript编译器的编译参数。

3.安装@types/node,使用npm install @types/node --dev-save进行安装。这个主要是解决模块的声明文件问题。

4.编写HelloWorld.ts文件,然后进行保存,代码如下。

var a:string = "HelloWorld"
console.log(a)

5.使用webstorm 创建helloWorld.ts文件,详细可参考 https://www.cnblogs.com/bfwbfw/p/10043101.html

6.在webstorm终端中输入node helloWorld.js就可以看到结果了。

第三节:变量类型

TypeScript最大的一个特点就是变量是强类型的,也就是说,在声明变量的时候,我们必须给他一个类型。

TypeScript中的数据类型有:

  • Undefined :
  • Number:数值类型;
  • string : 字符串类型;
  • Boolean: 布尔类型;
  • enum:枚举类型;
  • any : 任意类型,一个牛X的类型;
  • void:空类型;
  • Array : 数组类型;
  • Tuple : 元祖类型;
  • Null :空类型。

(1)Undefined类型

在js中当你定义了一个变量,但没有给他赋予任何值的时候,他就是Undefined类型。

我们现在来看一个例子,比如我们要声明一个年龄的变量age,我们要使用数值类型,也就是Number,但是我们不给他任何的值,我们只是在控制台给它输出,然后我们来看结果。

新建demo01.ts文件,下入下面代码:

//声明数值类型的变量age,但不予赋值
var age:number
console.log(age)

写完后保存代码,进行运行任务,然后生成demo01.js,在终端中使用node demo01.js来进行查看运行结果。控制台输出了undefined

(2)Number类型

在TypeScript中,所有的数字都是Number类型,这不分是整数还是小数。比如下面我们声明一个年龄是18岁,身高是178.5厘米。

新建一个文件demo01_1.ts文件,写入下面代码:

var age:number = 18
var stature:number = 178.5
console.log(age)
console.log(stature)

然后执行转换,查看结果,我们可以在控制台看到结果已经顺利输出,没有任何意外。

在TypeScrip中有几种特殊的Number类型 我们需要额外注意一下:

  • NaN:它是Not a Number 的简写,意思就是不是一个数值。如果一个计算结果或者函数的返回值本应该是数值,但是由于种种原因,他不是数字。出现这种状况不会报错,而是把它的结果看成了NaN。(这就好比我们去泰国外,找了一个大长腿、瓜子脸、水蛇腰的女神。房也开好了,澡也洗完了,发现跟我们的性别统一,我们只能吃个哑巴亏,你绝不会声张)
  • Infinity :正无穷大。
  • -Infinity:负无穷大。

(3)string类型

由单引号或者双引号括起来的一串字符就是字符串。比如:"demo",'121222'

var demo:string = "demo 12121"
console.log(demo)

这时候控制图就会输出 demo 12121 。

(4)boolean布尔类型

布尔类型主要用于逻辑判断,通过对与错的判断是最直观的逻辑处理,boolean类型只有两种值,true和false。

var b:boolean = true
var c:boolean = false

(5)enum 类型

这个世界有很多值是多个并且是固定的,比如:

  • 世界上人的类型:男人、女人。
  • 一年的季节:春、夏、秋、冬。

这种变量的结果是固定的几个数据时,就是我们使用枚举类型的最好时机:

demo01_3.ts

enum REN{ nan , nv }
console.log(REN.nan)  //返回了0,这是索引index。

给这些枚举赋值,可以直接使用=,来进行赋值。

enum REN{
    nan = '男',
    nv = '女',
}
console.log(REN.nan)  //返回了男 这个字

(6)any类型

TypeScript友好的为我们提供了一种特殊的类型any,比如我们在程序中不断变化着类型,又不想让程序报错,这时候就可以使用any了。

var t:any =10 
t = "wfaceboss"
t = true
console.log(t)

(7)Null类型

与 Undefined 类似,都代表空。Null 代表是引用类型为空。

注意:剩余的数组、元组、void 会在后续学到。

第四节:TypeScript的函数

函数可以理解为:把功能相近的需求封装成一个独立的代码块,每次传入不同的变量或参数,就可以实现不同的结果。

1.定义函数

函数就相当于一个工具,如果你想使用这个工具,就要先制作这个工具。这就是我们说的定义函数。在TypeScript里定义函数跟JavaScript稍微有些不同。我们来定义找姐姐的函数吧。

function searchXiaoJieJie(age:number):string{
    return '找到了'+age+'岁的姐姐' 
}
var age:number = 18
var result:string = searchXiaoJieJie(age)
console.log(result) //找到了18岁的姐姐

上面的程序,先用function关键字声明了一个searchXiaoJieJie的方法,然后我们使用了他,并返回了给我们结果。

需要注意的是:

  1. 声明(定义)函数必须加 function 关键字;
  2. 函数名与变量名一样,命名规则按照标识符规则;
  3. 函数参数可有可无,多个参数之间用逗号隔开;
  4. 每个参数参数由名字与类型组成,之间用分号隔开;
  5. 函数的返回值可有可无,没有时,返回类型为 void;
  6. 大括号中是函数体。

2.形参和实参

(1)形参的使用 函数定义的时候写的参数是形参。从字面意义上我们可以看出,形参就是形式上的参数。我们定义了形参也就规定了此函数的参数个数和参数类型,规范了函数。

function searchXiaoJieJie(age:number):string{
    return '找到了'+age+'岁的姐姐' 
}

比如这个函数,就定义了一个形参,它的类型是数值类型。

(2)实参的使用

调用函数时传递的具体值就是实参。同样从字面理解,实参就是真实的参数,我们在使用的时候,具体真实传递过去的就是实参,比如18,20,22,这些具体的参数就是实参。

var age:number=18
var result:string = searchXiaoJieJie(age)

此时传递的age就是实参。

注意:

在函数调用的时候,我们需要按照形参的规则传递实参,有几个形参就要传递几个实参,并且每一个实参的类型要与对应的形参类型一致。

3. TypeScript语言中的函数参数

TypeScript的函数参数是比较灵活的,它不像那些早起出现的传统语言那么死板。在TypeScript语言中,函数的形参分为:可选形参、默认形参、剩余参数形参等。

(1)有可选参数的函数

可选参数,就是我们定义形参的时候,可以定义一个可传可不传的参数。这种参数,在定义函数的时候通过 ?标注。

比如我们继续作找姐姐的函数,这回不仅可以传递年龄,还可以选择性的传递身材。我们来看如何编写。

function searchXiaoJieJie2(age:number,stature?:string):string{
    let yy:string = ''
    yy = '找到了'+age+'岁'
    if(stature !=undefined){
        yy = yy + stature
    }
    return yy+'的小姐姐'
}
var result:string  =  searchXiaoJieJie2(22,'大长腿')
console.log(result) //找到了22岁大长腿的小姐姐

var result1=string=searchXiaoJieJie2(22)
console.log(result1)//找到了22岁的小姐姐

(2)有默认参数的函数

有默认参数就更好理解了,就是我们不传递的时候,他会给我们一个默认值,而不是undefined了。我们改造上边的函数,也是两个参数,但是我们把年龄和身材都设置默认值。

function searchXiaoJieJie2(age:number=18,stature:string='大胸'):string{
    let yy:string = ''
    yy = '找到了'+age+'岁'
    if(stature !=undefined){
        yy = yy + stature
    }
    return yy+'的小姐姐'
}
var result:string  =  searchXiaoJieJie2()
console.log(result)//找到了18岁大胸的小姐姐

(3)有剩余参数的函数

有时候我们有这样的需求,我传递给函数的参数个数不确定。

剩余参数就是形参是一个数组,传递几个实参过来都可以直接存在形参的数组中。

function searchXiaoJieJie3(...xuqiu:string[]):string{
    let  yy:string = '找到了'
    for (let i =0;i<xuqiu.length;i++){
        yy = yy + xuqiu[i]
        if(i<xuqiu.length){
            yy=yy+'、'
        }
    }
    yy=yy+'的小姐姐'
    return yy
}
var result:string  =  searchXiaoJieJie3('22岁','大长腿','瓜子脸','水蛇腰')
console.log(result)//找到了22岁、大长腿、瓜子脸、水蛇腰、的小姐姐

第五节:三种函数的定义方式

1.函数声明法

函数声明法创建函数是最常用的函数定义法。使用function关键字和函数名去定义一个函数。

function add(n1:number,n2:number):number{
    return n1+n2
}

2.函数表达式法

函数表达式法是将一个函数赋值给一个变量,这个变量名就是函数名。通过变量名就可以调用函数了。这种方式定义的函数,必须在定义之后,调用函数。下面例子中等号右边的函数没有函数名,称为匿名函数。

var add = function(n1:number,n2:number):number{
    return n1+n2
}
console.log(add(1,4))

3.箭头函数

箭头函数是 ES6 中新增的函数定义的新方式,我们的 TypeScript 语言是完全支持 ES6 语法的。箭头函数定义的函数一般都用于回调函数中。

var add = (n1:number,n2:number):number=>{
    return n1+n2
}
console.log(add(1,4))

第六节:函数中变量的作用域

定义在函数内部的变量与定义在函数外部的变量是不一样的,作用的范围也不一样。

每个变量都有一个起作用的范围,这个范围就是变量的作用域。在TypeScript语言中变量作用域划分是以函数为标准的。

 1.函数作用域演示

我们来举个例子,现在要制作一个整形的方法,然后在函数里用var定义一个shape的变量,我们再函数的外部读取这个变量,你会发现是读取不到的。

function zhengXing():void{
    var  shape = '刘德华'
    console.log( shape)
}
zhengXing()
console.log(shape)//报错,shape is not defined

2.认识全局变量和局部变量

  • 局部变量:函数体内定义的变量就是局部变量。
  • 全局变量: 函数体外 定义的变量就是全局变量。

我们改造上边的程序,把shape办理移动到全局,然后再进行输出。

var shape= '刘德华'
function zhengXing():void{
    console.log('你被整形成了'+shape+'的样子')
}
zhengXing()//你被整成了刘德华的样子
console.log(shape)//刘德华

这时候shape变量是全局的,所以在函数内也可以调用,在函数外也可以调用。

 3.局部变量和全局变量重名

当局部变量与全局变量重名的时候,在函数体内是局部变量起作用;如果重名,就有变量提升。

还是上边整形的例子,你是想整形成刘德华,但是函数体内部声明了一个马德华。虽然一字之差,但是样子可是完全不同的。我们来看代码如何实现:

var shape:string = '刘德华'
function zhengXing():void{
    var shape:string = '马德华'
    console.log('你被整形成了'+shape+'的样子')
}
zhengXing()//你被整形成了马德华的样子

这回你会发现,你并没有变成刘德华而是变成了马德华。那你说我我想变成刘德华,我在函数没声明新变量前打印到控制台行不行?

var shape:string = '刘德华'
function zhengXing():void{
    console.log('你整形成了'+shape+'的样子')
    var shape:string = '马德华'
    console.log('技术胖整形成了'+shape+'的样子')
}
zhengXing()
console.log(shape)

代码改造成了这样,但是你会发现,我们输出的结果如下:

你被整形成了undefined的样子

产生这个结果的原因就是变量提升,他的真实代码是这样的。

var shape:string = '刘德华'
function zhengXing():void{
    var  yangzi:string
    console.log('技术胖整形成了'+shape+'的样子')
    shape = '马德华'
    console.log('技术胖整形成了'+shape+'的样子')
}
zhengXing()
console.log(shape)

也就是当内部声明了和全局的变量同名时,就会出现变量提升的效果,声明语句会提升到函数的第一句。这就是变量提升的含有。

4.let关键字变量的作用域

在早期javascript的变量作用域只有全局和局部,并且是以函数划分的,但在其他语言中,作用域的划分是以一对大括号作为界限的。

所以,JavaScript就遭到了无数开发者的吐槽,甚至说javascript不适合开发大型语言,容易内存溢出。JavaScript团队意识到了这一点,在ES6中推出了let关键字。

使用let关键字的变量就是一个块级作用域变量。实际工作中多使用let来声明你的变量,让程序更有条例。 来看一段程序:

function zhengXing():void{
    var shape_a:string = '刘德华'
    {
        let  shape_b:string = '小沈阳'
        console.log('技术胖整形成了'+shape_b+'的样子')
    }
    console.log('你被整形成了'+shape_a+'的样子')
    console.log('你被整形成了'+shape_b+'的样子')
}
zhengXing()

注意:这时候编译后,我们运行,你会发现是可以执行的,并且打印到了控制台正确的结果。 这是因为ts编译成js,他自动给我们加了ES5的处理,ES5里是没有let关键字的,现在我们再改一下编译好的程序,你会发现shape_b

这个关键字就找不到了。

第七节:引用类型-数组

TypeScript中的数据分为值类型和引用类型。引用类型中封装了很多对属性,每一对属性都有属性名和属性值。

在TypeScript中也给我们提供了一些引用类型,例如:Array(数组)、String(字符串)、Date(日期对象)、RegExp(正则表达式)等

1.初始化数组的两种方法

创建数组时可以指定数组的容量,也可以直接向数组中存储数据。

声明数组的方法

声明数组跟声明一个普通变量是一样的,都是通过 var let 关键字实现的,只不过数组的类型说明符比较复杂而已。

let arr1:number[ ]     //声明一个数值类型的数组


let arr2:Array<string>  //声明一个字符串类型的数组

2.给数组赋值:

数组是存储大量数据的集合,声明数组之后,需要给数组存储数据。这时候有两种方法:

  • 字面量赋值法:直接使用“[ ]”对数组进行赋值。
  • 构造函数赋值法:

(1)字面量赋值法

//定义一个空数组,数组容量为0
let arr1:number[] = []
//定义一个数组时,直接给数组赋值
let arr2:number[] = [1,2,3,4,5]
//定义数组 的同事给数组赋值
let arr3:Array<string> = ['a','b','c']
let arr4:Array<boolean> = [ true,false,false]

需要注意的是,在TypeScript中指定数据类型的数组只能存储同一类型的数组元素。

//报错! 必须存储number类型的数据
let arr5:number[] = [1,2,true]

(2)构造函数赋值法

在 TypeScript 中使用 Array 这个引用类型来表示数组的,那么每一个数组都是 Array 类型的实例。那么,我们在创建数组的时候也可以使用构造函数来进行赋值。

let arr1:number[] = new Array()
let ara2:number[] = new Array(1,2,3,4,5)
let arr3:Array<string> = new Array('a','b','c')
let arr4:Array<boolean> = new Array(true,false,false)

3.元组 ---特殊的数组

元组是一种特殊的数组,元组类型允许表示一个已知元素数量和类型的数组,各元素的类型不必相同。比如,你可以定义一对值分别为string和number类型的元组。

//声明一个元祖类型
let x : [string,number]
//正确的初始化
x = ['hello',10]
//错误的初始化方法
x = [10,'hello']

第八节:引用类型--字符串

在TypeScript中存在两种类型的字符串:基本类型字符串和引用类型字符串。

字符串的两种类型:

(1)基本类型字符串:由单引号或者双引号括起来的一串字符串。

(2)引用类型字符串:用new 实例化的 String类型。

引用类型的出现给字符串增加一系列方法了。以至于可以更方便操作字符串。

需要说明的是这两种声明字符串的方法没有什么不同。基本类型的字符串可以直接使用引用类型的属性和方法。

相关的字符串学习参考:http://www.cnblogs.com/zengfp/p/9883073.html

第九节:引用类型-日期对象

TypeScript中使用Date这个引用类型来存储日期对象,如果你要声明一个日期变量时,记得也要注明它的类型是Date。

创建日期对象

日期对象是Date的实例,可以使用构造函数的方法进行创建。并且构造函数中可以传递多种类型的参数。

1.不传递任何参数

构造函数中不传递参数时,Date()构造函数将根据当前日期和时间创建一个Date对象。我们看下面的例子理解一下。

let d:Date = new Date()
console.log(d) //2018-12-01T02:51:24.770Z

2.传递一个整数

传递一个整数,这个整数代表的是距离1970-01-01 00:00:00的毫秒数。例如:传入参数为1000,将创建一个表示1970-01-01 00:00:01的日期对象。

我们举个例子,传递一个整数,看一下结果。

let d:Date = new Date(1000)
let da:Date = new Date(2000)
console.log(d)  //1970-01-01T00:00:01.000Z
console.log(da) //1970-01-01T00:00:02.000Z

3.传递一个字符串

如果传递一个表示日期的字符串,就会生成相对应的日期对象。字符串的格式常用:yyyy/MM/dd hh:mm:ssyyyy-MM-dd hh:mm:ssyyyy-MM-ddThh:mm:ss等,具体可以参看下面的例子。

let d1:Date = new Date('2018/12/01 09:30:00')
let d2:Date = new Date('2018-12-01 09:30:00')
let d3:Date = new Date('2018-12-01T09:30:00')
console.log(d1)
console.log(d2)
console.log(d3)

然,他们打印出来的结果时完全相同的(都是2018-12-01T01:30:00.000Z),所以在开发中你不用太过于纠结使用哪种方式进行声明。

4.传递表示年月日时分秒的变量

let d:Date = new Date(year,month,day,hours,minutes,seconds,ms);
  • year 表示年份,4位数字。
  • month表示月份,数值是0(1月)~11(12月)之间的整数。
  • day 表示日期。数值是1~31之间的整数。
  • hours 表示小时,数值是0-23之间的整数。
  • minutes 表示分钟数,数值是0~59之间的整数。
  • seconds 表示秒数,数值是0~59之间的整数。
  • ms 表示毫秒数,数值是0~999之间的整数。

第10节:引用类型-正则表达式

用于验证最好最强大的手段目前为止就是正则表达式。TypeScript的RegExp类表示正则表达式。

认识正则表达式:

创建正则表达式和字符串犹如一对好基友(类似),创建正则表达式也提供了两种方法,一种是才采用new 关键字,另一种是采用字面量的方式。

1.构造函数法

构造函数中可以传一个参数,也可以传递两个参数。一个是字符串描述,另一个是修饰符,比如g是全局修饰符,i是忽略大小写,m是多行模式。

let reg1:RegExp = new RegExp("baidu.com")  //表示字符串规则里含有abcefg
console.log(reg1)// 结果为     /baidu.com/

2.字面量法

简而言之,直接写正则表达式。

let reg3:RegExp = /baidu.com/
let reg4:RegExp = /baidu.com/gi

RegExp中的常用方法

RegExp对象包含两个方法:test( )和exec( ),功能基本相似,用于测试字符串匹配。

  • test(string) :在字符串中查找是否存在指定的正则表达式并返回布尔值,如果存在则返回 true,不存在则返回 false。
  • exec(string) : 用于在字符串中查找指定正则表达式,如果 exec() 方法执行成功,则返回包含该查找字符串的相关信息数组。如果执行失败,则返回 null。

看一个例子:

let reg1:RegExp =  /baidu/i
let website:string = 'baidu.com.com'
let result:boolean = reg1.test(website)
console.log(result)    //true

这时候控制台打印出来的是true,那么我们再来看一下exec的使用方法。

let reg1:RegExp =  /baidu/i
let website:string = 'baidu.com'
console.log(reg1.exec(website))
//[ 'baidu', index: 0, input: 'baidu.com' ]

输出的结果变为了[ 'baidu', index: 0, input: 'baidu.com' ]

相关正则可以查看一下这篇文章:http://www.runoob.com/regexp/regexp-tutorial.html

第11节: 面向对象编程-类的声明和使用

类的出现可以让前端程序员抽象层次、增加维护性和复用性。当然这一系列的类的操作,我们都叫他面向对象编程。TypeScript就是一个基于类的面向对象编程语言。

认识类与对象:

类是对象具体事务的一个抽象,对象是类的具体表现。

类的定义

认识TypeScript基于类的面向对象编程,就需要从一个简单的类开始。

我们模拟一个小姐姐的类,小姐姐需要有年龄,有姓名,会说“小哥哥好”。

看下面的例子:

class XiaoJieJie{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name = name
        this.age = age 
    }
    say(){
        console.log('小哥哥好')
    }
}
let jiejie:XiaoJieJie = new XiaoJieJie('小红',18)
console.log(jiejie)
jiejie.say()

我们先用class关键字声明了一个类,并在里边声明了nameage属性。constructor为构造函数。构造函数的主要作用是给类中封装的属性进行赋值。

第12节: 面向对象编程-修饰符

访问修饰符

TypeScript语言和Java还有C#很像(因为我只会这两个面向对象的语言),类中属性的访问可以用访问修饰符来进行限制。访问修饰符分为:public、protected、private。

  • public:公有修饰符,可以在类内或者类外使用public修饰的属性或者行为,默认修饰符。
  • protected:受保护的修饰符,可以本类和子类中使用protected修饰的属性和行为。
  • private : 私有修饰符,只可以在类内使用private修饰的属性和行为。

我们还是写一个小姐姐的类,但是我们使用一些访问修饰符来修饰。

class XiaoJieJie2{
    public sex:string
    protected name:string
    private age:number
    public constructor(sex:string,name:string,age:number){
        this.sex=sex
        this.name=name
        this.age=age
    }
    public sayHello(){
        console.log('小哥哥好')
    }
    protected sayLove(){
        console.log('我爱你')
    }
}
var jiejie2:XiaoJieJie2 = new XiaoJieJie2('女','热巴',22)
console.log(jiejie2.sex)
console.log(jiejie2.name)   //报错
console.log(jiejie2.age)    //报错
jiejie2.sayHello()
jiejie2.sayLove()  

只读属性修饰符

使用readonly修饰符将属性设置为只读,只读属性必须在生命时或者构造函数里被初始化(注意)。

我们声明一个man的抽象类,里边只有一个属性sex,并且是只读。

class Man{
    public readonly sex:string = '男'
}
var man:Man = new Man()
man.sex='女'

在编辑器里你就会发现报错了,我们就不强行编译了。

第13节: 面向对象编程-继承和重写

类的继承

继承:允许我们创建一个类(子类),从已有的类(父类)上继承所有的属性和方法,子类可以新建父类中没有的属性和方法。

(1)先来创建一个父类。

class Jspang{
    public name:string
    public age : number
    public skill: string
    constructor(name:string,age:number,skill:string){
        this.name = name
        this.age = age
        this.skill = skill
    }
    public interest(){
        console.log('玩')
    }
}
let jspangObj:Jspang = new Jspang('大头爸爸',18,'web')
jspangObj.interest()

作了一个的抽象类,有姓名,有年龄,有技能,然后还有一个函数是兴趣。类创建好之后我们就进行了实例化。

(2)继承父类

class JsShuai extends Jspang{
    public xingxiang:string = '帅气'
    public zhuangQian(){
        console.log('一天赚了一个亿')
    }
}
let shuai = new JsShuai("小头儿子",15,'领导力')
shuai.interest()
shuai.zhuangQian()

extends关键字就是继承的重点,是关键词。TypeScript不支持多重继承。

类方法的重写

重写就是在子类中重写父类的方法。

比如:在子类中重写父类中的interest方法。

class JsShuai extends Jspang{
    public xingxiang:string = '帅气'
    public interest(){
        super.interest()
        console.log('建立电商平台')
    }
    public zhuangQian(){
        console.log('一天赚了一个亿')
    }
}

先是继承了父类的方法,然后通过super关键字调用了父类的方法,实现了技能的增加。

第14节:面向对象编程-接口

在通常情况下,接口是用来定义一些规范,使用这些接口,就必须实现按照接口中的规范来走。

认识接口

定义接口的关键字是interface。我们现在就来定义一个接口,这个接口是用来规范丈夫的。

interface Husband {
    sex:string
    interest:string
}
let myhusband:Husband ={ sex:'男',interest:'看书、运动'}
console.log(myhusband)

我们通过接口,定义了一个找老公的接口,并且给他了两个必选项:性别和兴趣爱好.

可选参数的接口

对老公的标准如果我们有一些可选项,这些并不是都需要显示出来的,在有些情况下,我们只需要传入部分参数。我们可以使用问号?的形式来设置可选参数。

比如:现在我们还希望老公的标准,有一条是给我“买包包”,但是这个是隐喻的,不是直接显示出来的。我们修改我们的接口。

interface Husband {
    sex:string
    interest:string
    maiBaoBao?:Boolean
}
let myhusband:Husband ={ sex:'男',interest:'看书、运动',maiBaoBao:true}
console.log(myhusband)

上面的代码maiBaoBao选项就是可选的,可以写也可以不写。

规范函数类型接口

我们还可以使用接口来规范函数类型的接口,比如现在要找老公这件事,我们规定有一些资源,然后我们需要哪些资源,在函数中进行匹配,最后返回是否匹配成功。

interface  SearchMan{
    (source:string,subString:string):boolean
}
let mySearch:SearchMan

mySearch = function(source:string,subString:string):boolean{
    let flag =source.search(subString)
    return (flag != -1)
} 
console.log(mySearch('高、富、帅、德','胖')) //false

第15节:面向对象编程-命名空间

在制作大型应用的时候,为了让程序更加有层次感和变量之间不互相干扰,我们可以使用命名空间来构建程序。

举个小例子:比如“德华”这件事,帅哥也有叫德华的,二师兄也有叫德华的。那我们要如何区分呢?。

命名空间的使用

当然命名空间就是解决这个问题的,命名空间,又称内部模块,被用于组织有些具有内在联系的特性和对象。我们来看一个例子:

namespace shuaiGe{
    export class Dehua{
        public name:string = '刘德华'
        talk(){
            console.log('我是帅哥刘德华')
        }
    }
}
namespace bajie{
    export class Dehua{
        public name:string = '马德华'
        talk(){
            console.log('我是二师兄马德华')
        }
    }
}
let dehua1:shuaiGe.Dehua   = new shuaiGe.Dehua()
let dehua2:shuaiGe.Dehua   = new bajie.Dehua()
dehua1.talk()

通过命名空间我们很好的把程序变的清晰了。

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2018-12-01 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 第一节:前言:
  •  第二节:开发环境的安装(windows环境下)
    • 1.安装Node.js
      • 2.安装TypeScript包
        • 3.编写HelloWorld程序
        • 第三节:变量类型
        • 第四节:TypeScript的函数
        • 第五节:三种函数的定义方式
        • 第七节:引用类型-数组
        • 第八节:引用类型--字符串
          • 字符串的两种类型:
          • 第九节:引用类型-日期对象
            • 2.传递一个整数
              • 3.传递一个字符串
                • 4.传递表示年月日时分秒的变量
                • 第10节:引用类型-正则表达式
                  • 认识正则表达式:
                    • RegExp中的常用方法
                    • 第11节: 面向对象编程-类的声明和使用
                      • 认识类与对象:
                        • 类的定义
                        • 第12节: 面向对象编程-修饰符
                          • 访问修饰符
                            • 只读属性修饰符
                            • 第13节: 面向对象编程-继承和重写
                              • 类的继承
                                • 类方法的重写
                                • 第14节:面向对象编程-接口
                                  • 认识接口
                                    • 可选参数的接口
                                      • 规范函数类型接口
                                      • 第15节:面向对象编程-命名空间
                                        • 命名空间的使用
                                        相关产品与服务
                                        命令行工具
                                        腾讯云命令行工具 TCCLI 是管理腾讯云资源的统一工具。使用腾讯云命令行工具,您可以快速调用腾讯云 API 来管理您的腾讯云资源。此外,您还可以基于腾讯云的命令行工具来做自动化和脚本处理,以更多样的方式进行组合和重用。
                                        领券
                                        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档