开发环境搭建
安装Node.js
Node.js : Node.js (nodejs.org)
安装TS
npm i -g typescript
测试
编写代码
代码编译
tsc name
编译监视
tsc name -w : 自动监视文件修改
批量监视
ts同级目录下创建tsconfig.json文件，控制台输入tsc -w
tsconfig.json 参数配置
{
// include 用来指定哪些ts文件需要被配置
"include": [
// * 表示任意文件
// ** 表示任意目录
"./*"
],
// exclude 用来指定哪些ts不需要被编译
"exclude": [
"./03_hi.ts"
],
// compilerOptions 编译器选项
"compilerOptions": {
// target 指定ts被编译为js的版本
"target": "es6",
// module 指定要是有的模块化标准
"module": "system",
// 用来指定项目中要使用的库
"lib": ["es6","DOM"],
// 用来指定编译后文件所在的目录
"outDir": "./dist",
// 将代码合并为一个js
"outFile": "./dist/app.js",
// 是否对js文件进行编译
"allowJs": false,
// 是否对js文件进行语法检查
"checkJs": false,
// 是否允许注释
"removeComments": false,
// 不生成编译后的文件
"noEmit": false,
// 如果有错误时，不生成编译后的文件
"noEmitOnError": false,
// 是否开启严格模式
"alwaysStrict": true,
// 不允许明确类型的this
"noImplicitThis": false,
// 严格的检查空值
"strictNullChecks": false,
// 所有严格检查的总开关
"strict": false
}
}
类型申明
联合类型
any 与 unknown 区别
-
any 可以赋值给任意
-
unknown 不可以赋值给其他类型的变量
断言
never
限制对象参数
限制方法参数
数组
元组
枚举
类型别名
面向对象
属性定义
// 使用 class 定义类
class Person{
name:string = "zhangsan";
// 静态属性,不需要创建对象也可以使用
static age:number=18
// 只读属性
readonly sex = "male"
}
方法定义
// 使用 class 定义类
class Person{
name:string = "zhangsan";
// 静态属性,不需要创建对象也可以使用
static age:number=18
// 只读属性
readonly sex = "male"
// 定义方法
sayHi(){
console.log("hi")
}
// 静态方法
static sayHello(){
console.log("hello")
}
}
构造方法
class Dog{
name:string
age:number
// 构造函数会在对象创建时调用
constructor(name:string,age:number){
this.name = name;
this.age = age
}
}
继承
(function(){
class Animal{
name:string
age:number
constructor(name:string,age:number){
this.name = name;
this.age = age
}
say(){
console.log("ooo")
}
}
class Dog extends Animal{
run(){
console.log(`${this.name} running`)
}
}
class Cat extends Animal{
say(){
console.log("mmm")
}
}
new Dog("huang",4).run()
new Cat("a1",4).say()
})();
super
(function(){
class Animal{
name:string
constructor(name:string){
this.name = name;
}
say(){
console.log("ooo")
}
}
class Dog extends Animal{
age:number;
constructor(name:string,age:number){
super(name)
this.age = age
}
say(){
super.say()
}
}
console.log(new Dog("huang",4))
})();
抽象类
(function(){
// 以 abstract 开头的类为抽象类
// 比普通类相比，不能用来创建对象
// 抽象类就是专门用来继承的
abstract class Animal{
name:string
constructor(name:string){
this.name = name;
}
// 定义一个抽象方法
// 抽象方法使用 abstract 开头，没有方法体
// 抽象方法只能定义在抽象类中，子类必须必须对抽象方法进行重写
abstract say():void
}
class Dog extends Animal{
age:number;
constructor(name:string,age:number){
super(name)
this.age = age
}
say(){
console.log("www")
}
}
console.log(new Dog("huang",4))
})();
接口
(function(){
type myType = {
name:string,
age:number,
[propname:string]:any
}
const obj : myType = {
name:"zhangsan",
age:12
}
// 用来定义一个类结构
interface myInterface{
name:string,
age:number
}
interface myInterface{
gender:number
}
const obj2 : myInterface = {
name:"zhangsan",
age:12,
gender:1
}
interface myInterface2{
gender:number
say():void
}
class MyClass implements myInterface2{
name: string;
gender: number;
constructor(name:string,gender:number){
this.gender = gender
this.name = name
}
say(){
console.log("hi")
}
}
})();
属性封装
(function(){
class MyClass{
private _name: string;
private gender: number;
constructor(name:string,gender:number){
this.gender = gender
this._name = name
}
say(){
console.log("hi")
}
getName(){
return this._name
}
get name(){
return this._name
}
}
})();
泛型
function f<T>(a:T){
return a;
}
f(10)
// 手动指定类型
f<string>("hi")
// 可以指定多个范型
function f2<T,K>(a:T,b:K):T{
console.log(b)
return a;
}
interface Inter{
len:number
}
// 泛型T必须实现Inter
function f3<T extends Inter>(a:T):number{
return a.len
}
