我要评论typescript是js的超集，目前很多前端框架都开始使用它来作为项目的维护管理的工具，还在不断地更新，添加新功能中，我们学习它，才能更好的在的项目中运用它，发挥它的最大功效
//readonly 只能修饰属性，不能修饰方法
//readonly修饰的属性，必须手动添加明确的类型，否则就是字面量类型
class person {
//只读属性
readonly age:number = 18
constructor(age:number) {
this.age = age
}
//错误展示
// readonly setage() {
// // this.age = 20
// }
}
//接口或者{}表示的对象类型,里面的属性也是可以用readonly来修饰的
interface iperson{
readonly name:string
}
let obj: iperson = {
name:'jack'
}
obj.name = 'rose'
//类型兼容性
//分为结构化类型系统和标明类型系统
//ts采用的是结构化类型系统，也叫duck typing(鸭子类型)
//类型检查关注的是值所具有的形式
//也就是在结构类型系统中，如果两个类型对象具有相同的形状，则认为他们属于同一类型
class point {
x: number
y:number
}
class point2d {
x: number
y:number
}
const p: point = new point2d()
//如果在表明类型系统中（c#,java）则两个类型不是同的
class point3d{
x: number
y: number
z:number
}
const p1: point = new point3d()
const p2: point = new point()
//错误演示
const p3: point3d = new point()
//point3d 至少与point相同，则ponit兼容point3d
//所以成员多的ponit3d可以赋值给成员少的ponit
//接口之间的兼容性，类似于class
//函数之间的兼容性比较复杂
//参数个数，参数多的的兼容参数少的，即参数少的可以赋值给参数多的
//参数类型,相同位置的参数类型要相同（原始类型）或兼容（对象类型）
//返回值类型
type f1 = (a: number) => void
type f2 = (a: number, b: number) => void
let f1: f1
let f2: f2 = f1
//错误演示,参数多的不能付给参数少的
let f3: f1 = f2
//参数多的兼容少的，少的可以赋值给多的
const arr = [1,2,3,4,5]
const a1 = arr.map((el) => el)
const a2 = arr.map(() => console.log('1111111'))
type f3 = (a: number) => string
type f4 = (a: number) => string
let f4: f3
let f5:f4
f4 = f5
f5 = f4
//技巧:将对象拆开，把每个属性看做一个个参数，参数少的就可以赋值给参数多的
//返回值类型
//如果返回值类型是基本类型，相同则互相兼容
type f8 = () =>string
type f9 = () => string
let f8: f8
let f9: f9 = f8
f8 = f9
//若果是对象类型，则成员多的可以赋值给少的
type f10 = () => {name:string}
type f11 = () => { name: string, age: number }
let f10: f10
let f11: f11
f10 = f11
//错误演示
f11 = f10
//交叉类型
//类似于接口继承，用于组合多个类型为一个类型（常用语对象类型）
//是新类型同时具备了多个类型的属性类型
interface person {
name:string
}
interface age{
age:number
}
type iperson = person & age
let obj: iperson = {
name: "gaofeng",
age: 20,
}
type p = {name:string}
type a = { age: number }
type c = p & a
let obj2: c = {
name: 'gaogeng',
age:30
}
//交叉类型和接口继承的对比
//相同点:都可以实现对象类型的组合
//不同点：实现继承时，处理同名类型冲突的方式不一样
//接口继承会报错，交叉类型没有错误
interface a1 {
fn:(a:string) => string
}
interface b1 extends a1 {
fn:(a:number) => string
}
interface c1 {
fn:(a:number) => string
}
type c4 = a1 & c1
let c: c4 = {
fn(name:string|number) {
// return name as string
return <string>name
}
}
c.fn('task...')
c.fn(33333)
关注我的个人公众号，获取更多前后端开发经验知识
发表评论