typescript

一共26章，目前看到第7章，文档地址：https://blog.csdn.net/qq1195566313?type=blog

js基础类型：

Object, String, Number, Boolean, Null, undefined, bigInt, symbol
其中Object包括data,function,array等
symbol类型的对象永远不相等，即便创建的时候传入的值相同，因此可以用来解决属性名冲突的问题，作为标记
bigInt js中的任意精度整数，可以安全储存和操作大整数。即超出Number能够表示的安全
整数范围。

ts基础类型

npm i -g typescript 全局安装typescript
ts是js的超集，所以js基础的类型都包含在内
Object, Boolean, Number, String, null, undefined, symbol, bigInt

如果tsconfig.json 开启了严格模式：”compilerOptions”: { “strict”: true }
- 报错：null不能赋予void类型
| | 使用构造函数 Boolean 创造的对象不是布尔对象：（报错）let b: boolean = new Boolean(1)
事实上new Boolean()返回的是一个Boolean对象：let bool: Boolean = new Boolean(2)
直接使用布尔值： let b1:boolean = true
通过函数返回布尔值：let b2:boolean = Boolean(1) | | js没有空值的概念，ts中可以用void表示没有任何返回值的函数
function voidFun(): void {
console.log(‘test void’)
} |

任意类型

node环境支持的依赖必装：npm i -D @types/node
npm i ts-node —g
查看安装的插件：

• npm list -g -depth 1
• npm list
• 查看node_modules文件夹目录
• npm [name] -v[name]
  • 例如：npm bluebird -v => 2.14.20

any:任意类型
let key:any = 123;
key = true;
key = ‘123’;
声明变量的时候灭有指定任意类型默认为any
let key;
key = true;
key = ‘123’;
如果使用any就是去了ts类型检测的作用
ts3.0引入的unknown类型也被认为是top type，但它更安全。与any一样，所有类型都可以分配给unknown。如果要使用any，可以用unkonw代替
let value:unknow;
value = true; value = 12; value = ‘hello’; value = null; value = undefined; value = Symbol[‘type’];

报错：let names:unknown = ‘123’;
unknow类型不能作为子类，只能作为父类型。any可以作为父类型也可以作为子类型
unknow类型不能复制给其他类型
正确：let name:any = ‘123’; let name2:string = name;
unknow 可复制对象只有unknow和any

• 如果是any类型在对象还没有这个属性的时候还在获取是不会报错的:
  • let obj:any = { b:1 }; abj.a
• 如果是unknow，不能调用属性和方法
  • let obj:unknow = { b:1, ccc:():number => 213 }
    • obj.b
    • obj.ccc()

• 编译：tsc app.ts
  • tsc报错：此系统上禁止运行脚本
    • 管理员运行vscode
    • 终端执行：get-ExecutionPolicy，显示Restricted
    • 终端执行：set-ExecutionPolicy RemoteSigned
    • 终端执行：get-ExecutionPolicy，显示RemoteSigned
• 运行：node app.js

对象

定义对象要用关键字interface
申明变量的时候要定义对象的所有属性
interface Person {
b:string
a:string
}
报错：const p:Person = { a:’12’ }
重名interface可以合并
interface A{ a:string }
interface A{ b:string }
var x:A = { a:’1’,b:’2’ }
继承
interface B extends A { c:string }
var y:B = { a:’1’,b:’1’,c:’1’ }
可用？操作符，说明该属性可以不存在
interface Person{ a?:string,b:string }
不报错：var person:Person = { b:’something’ }

任意属性
interface Person{ a:string, [propName:string]:any }
var person:Person = { a:’me’, c:’whatever..’ }

只读属性readonly
只读属性不允许被赋值，只能读取
interface Person{ b?:string, readonly a:string, [propName: string]:any; }
var person:Person = { a:’qiuhaicong’,c:’lalalla’ }
console.log(person.a)
报错：person.a=’liu’

添加函数
interface Person {
b?:string,
readonly a:string,
[propName:string]: any,
foo():void
}
var person:Person = { a:’笨蛋’,foo:()=>{ console.log(‘lalala’) } }

数组

• 类型中加中括号：let arr:string[] = [‘1’]
• 定义了字符串类型出现数字是不允许的
  • 报错：let arr:string[] = [‘1’,2]
  • 报错：arr.push(34)
• 任意类型的数组：let list:any[] = [ ‘test’,1,[],{a:2} ]

其他

• 数组泛型
  • let arr:Array = [ 2,3 ]
• 接口数组
  • interface NumberArray{ [ index:number ]:number }
  • let arr:NumberArray = [ 1,2,4 ]
• 多维数组
  • let data:number[][] = [[1,2],[2]]

• arguments类数组

  • IArguments 是 TypeScript 中定义好的类型
    • interface IArguments{ [index:number]: any; length:number;callee:Function }
  • function Arr(…args:any):void { let arr:IArguments = arguments }

    函数

• 参数不能多传也不能少传，必须按照约定的类型

  • const fn = (name:string, age:number):string =>{ return name+age }
  • fn(‘李少云’,23)
• 可选参数
  • const fn = (name:string,age?:number):string => { return name + age }
  • fn(‘张三’)
• 接口定义函数
  • interface Add { (num:number,num1?:number,num2?:number):number }
    • const fn:Add = num:number,num1?:number,num2?:number):number =>{ return num+num1+(num2||0) }
• 定义剩余参数
  • const fn ( array:number[], …items:[any] ):any[] =>{ return items }

• 函数重载

  • 方法名字相同，参数不同，返回类型可以相同也可以不相同
  • function fn(params:number):void{ … }
  • function fn(params:string):string{ … }
  • function fn(params:string,…items:any[]):string{ … }

    类型断言|联合类型|交叉类型

• 联合类型

  • let phone: string | number = ‘010-820’
• 类型断言
  • interface A { run:string }
  • interface B { build:string }
  • const fn = (type:A | B):string =>{ return (type as A).run }
  • 类型断言只能欺骗ts编译器，无法避免运行时的错误，反而滥用类型断言可能会导致运行时错误
• any临时断言
  • 报错：window.abc = 123 因为window没有abc这个变量
  • (window as any).abc = 123; 使用any临时断言在any类型的变量上，访问任何属性都是允许的