TS 笔记
原始数据类型
- string
- number
- boolean
- null
- undefined
- enum
- symbol
空值一般用void表示，void可以表示变量，也可以表示函数返回值。
接口
interface Istate {
name: string
age?: number
[propName: string]: any
}数组表示法
// 类型+方括号
const arr: number [] = [1,2,3];
const arr2: string [] = ['1','2','3'];
const arr3: any [] = [1,'2',true];
// 泛型Array<elemType>
const arr: Array<number> = [1,2,3];
const arr2:Array<string> = ['1','2','3'];
const arr3: Array<any> = [1,'2',true];
// 接口
interface IArr {
[index: number]: number
}
const arr: IArr = [1,2,3];
interface Istate {
name: string
age: number
}
interface IArr2 {
[index: number]: Istate
}
const arr: IArr2 = [{name: 'tom', age: '20'}]函数类型
// 声明式函数
function funcType(name: string, age: number): number {
return age
}
const ageNum: number = funcType('tom', 20)
// 函数类型不确定
function funcType2(name: string, age: number, sex?: string): number {
return age
}
const ageNum2: number = funcType('jack', 18, 'male')
// 函数参数默认值
function funcType3(name: string = 'tom', age: number = 25): number {
return age
}
// 表达式函数
const funcType4 = function(name: string, age: number): number {
return age
}
const funcType5:(name: string, age: number) => number = function(name: string, age: number): number {
return age
}
interface funcType6 {
(name: string, age: number): number
}
const funcType4: funcType6 = function(name: string, age: number): number {
return age
}
// 联合型函数 重载
function getValue(value: string): string;
function getValue(value: number): number;
function getValue(value: string | number): string | number {
return value
}
let a: string = getValue(1)
let b: string = getValue('1')类型断言
let num: number|string = '10'
num = 20
console.log(num.length) // ERROR
// 类型断言
function getAssert(name: string | number) {
return (<string>name).length
// or
return (name as string).length
}类型别名
type strType = string|number|boolean
const str: strType = '10'
str = 10
str = true
// 接口
interface muchType1 {
name: string
}
interface muchType2 {
age: number
}
type muchType = muchType1|muchType2
const obj: muchType = {name: 'tom'}
const obj2: muchType = {age: 10}
const obj3: muchType = {name: 'tom', age: 20}
// 限制字符串选择
type sex = '男'|'女'
function getSex(s: sex): string {
return s
}
getSex('男')枚举
枚举（Enum）类型用于取值被限定在一定范围内的场景
enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat }
// 枚举成员会被赋值为从0开始递增的数字，同时也会被枚举值到枚举名进行反向映射
console.log(Days.Sun) // 0
console.log(Days.Sat) // 6
console.log(Days[0]) // 'Sun'
console.log(Days[6] === 'Sat') // true
// 改变下标
enum Days { Sun = 3, Mon, Tue, Wed, Thu, Fri, Sat }
console.log(Days[4]) // 'Mon'类修饰符
- 公共的 public
- 私有的 private
- 受保护的 protected
private 属性只有在类的内部才能访问
当一个成员变量没有修饰符时，外部是可以访问的，默认为 public
父类将属性定义为私有后，子类不可以访问
父类将属性定义为受保护后，子类可以访问
子类继承父类，子类可以访问父类公开的属性和方法，但是不能直接获取到父类的私有属性或者受保护的属性
class Person {
name = 'Tom'
private age = 18
say() {
console.log(this.name, this.age)
}
}
var p = new Person()
p.say()
console.log(p.name) // Tom
console.log(p.age) // ERROR
// 创建子类
class Child extends Person {
callParent() {
super.say()
}
static test() {
console.log('test')
console.log(this) // ERROR 类的静态方法里不允许使用this
}
}
var c = new Child()
c.callParent()
console.log(c.say())
console.log(c.age)泛型
泛型是指在定义函数、接口或者类的时候，不预先指定具体类型，而在使用的时候再指定类型的一种特性
function createArray<T>(length: number, value: T): Array<T> {
let arr = []
for(let i = 0; i < length; i++) {
arr[i] = value
}
return arr;
}
var strArr: string[] = createArray<string>(3, '1')
var numArr: number[] = createArray<number>(3, 1)
// 接口中采用泛型
interface ICreate {
<T>(name: string, value: T) Array<T>
}
let func: ICreate
func = function<T>(name: string, value: T): Array<T> {
return []
}
var strArr: string[] = func('tom', 'str')
var strArr: number[] = func('tom', 3)本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2020-02-29 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录