世间本就秽浊，罪与爱同歌
cognition
- 高级语言是接近人类的,人类思考
- 低级语言是接近机器的,面向机器
不想太多
做就对了。
早点睡吧，身体折腾不起。
TS笔记
主要记一些理解性的东西
- 类的静态成员属于类而不是属于实例化之后的对象
- 单例模式中会用到静态成员
- TS没有多继承但可以用接口实现类似多继承
- Interface的另一种理解:协议，implement interface 实施协议
- 多个实例化对象就叫多态
- 多种类型尽量用泛型不要用any
- 正则表达式分为原义文本字符、元字符、限定符
- 懒加载就是未访问该对象时不实例化该对象，待到访问该对象时实例化该对象，单例模式中经常用到懒加载。
- 回调(callback)就是在一个函数中传入另一个函数
- 泛型就是通过指定不同类型来控制参数具体的类型
- await是等待异步执行结束请求数据返回才继续执行，而then会将内容放入堆栈，then之后的代码正常顺序执行。
关于字典、对象、JSON
区别挺大的，只是很巧在js中用法看起来好想差不多，都是用点连接，其实这三个概念相差甚远
JSONJSON是和跨语言、序列化、和反序列化相关的，且对数据的类型是有要求的，比如function类型就没法支持
字典字典(dict)是一种通用的和排序无关的组织复杂数据结构的数据类型，有的语言叫散列表、hash对象
对象而说到对象，一般就是和实例化、类相关的,new一个类就可以得到一个对象,有些对象则是由宿主环境直接提供了，比如window对象,window下的screen对象,dom节点对象等的。提到对象应该想到的是属性和方法，继承关系什么的。和序列化啊，字典啊没什么直接关系。
单例模式
单例模式(Singleton Pattern)就一种很简单的设计模式，顾名思义，单例模式指的就是一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建，并且提供唯一的访问该对象的方式。不需要实例化该类的对象。
class PersonManager{
private static instance:PersonManager //定义一个静态的自身类型的属性，后面用来实例化
people_num:number //随便定义一些成员变量
people_id:Array<number>
admin:string
private constructor(num:number,id:Array<number>,admin:string){ //私有的构造方法
this.people_num = num
this.people_id = id
this.admin = admin
}
static Instance(){ //暴露唯一一个实例方法,注意是静态的，静态方法才可不实例化，静态方法才能用this访问静态变量
if (!this.instance){ //判断实例是否存在，如果不存在则赋值一个PersonMnanager实例化对象
this.instance = new PersonManager(40,[1,2,3,4,5],"devil")
}
return this.instance //返回实例
}
}
console.log(PersonManager.Instance().admin) //直接访问该方法即可访问该单一实例
PersonManager.Instance().admin = "devgho"
console.log(PersonManager.Instance().admin)
注:
- 单例模式只能有一个实例
- 单例类必须自己创建自己的唯一实例
- 单例类必须给其他对象提供这一实例
代理模式
代理模式是不由当前实例进行运算而用其他符合协议的类进行代理运算
interface Icalc{ //定义一个计算协议，下面需要用到实现该协议的类
calc(a:number,b:number):number
}
class Proxy1 implements Icalc{ //代理类1
calc(a:number,b:number):number{
return a+b
}
}
class Proxy2 implements Icalc{ //代理类2
calc(a:number,b:number):number{
return a-b
}
}
class Person{
proxy:Icalc //设置代理，定义一个实现了Icalc协议的成员
getnum(num1:number,num2:number){
return this.proxy.calc(num1,num2) //使用该成员进行代理运算并返回
}
}
const person = new Person()
person.proxy = new Proxy1() //指定person实例的proxy对象为Proxy1实例
console.log(person.getnum(1,4)) //Proxy1代理运算
person.proxy = new Proxy2() //指定person实例的proxy对象为Proxy1实例
console.log(person.getnum(1,4)) //Proxy2代理运算
观察者模式
观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。
interface IObserver{
nameChanged(newName:string):void
}
class Person{
private _name = ""
IObservers = new Array<IObserver>()
set name(value:string){
this._name = value
for (let IObserver of this.IObservers){
IObserver.nameChanged(value)
}
}
get name():string{
return this._name
}
}
class Kid implements IObserver{
nameChanged(newName:String):void{
console.log("名称已修改"+newName)
}
}
let person = new Person()
let kid = new Kid()
person.IObservers.push(kid)
person.name = "无敌"
工厂模式
顾名思义，工厂就是用来生产的，工厂模式也就是用工厂方法来创建对象，代替new操作的一种模式。
enum monster_type{ //枚举出要生产的怪物类型
Goblin,
Bulls,
Bully
}
class Monster{
hp:number = 100 //默认属性
static create_monster(mon:monster_type){ //在Monster类中定义创建怪物的方法
switch (mon){ //switch判断怪物类型并返回该类型的类
case monster_type.Goblin:
return new Goblin()
case monster_type.Bulls:
return new Bulls()
case monster_type.Bully:
return new Bully()
}
}
}
class Goblin extends Monster{}
class Bulls extends Monster{}
class Bully extends Monster{}
const bulls = Monster.create_monster(monster_type.Bulls) //创建怪物
console.log(bulls.hp) //输出怪物血量
链表
链表就是在对象中储存下一个对象的地址，多个对象通过next连起来就组成了链表
class Person{ //用next来记录下一个对象的地址
name:string
next:Person
constructor(name:string){
this.name = name
}
}
let person = new Person("宋佳") //创建链表
person.next = new Person("付建锋")
person.next.next = new Person("宋佳&付建锋")
person.next = person.next.next //链表删除一个对象，只需要将next指向下一个
let tmpPerson = new Person("Jia and Feng") //链表插入一个对象
tmpPerson.next = person.next
person.next = tmpPerson
while(person){ //遍历
console.log(person.name)
person = person.next
}
参考: