Automatic compilation ts File for js：tsc --init

Compile in real time ：tsc -w ./path/file.ts

Type notes ： One is function or Variable Added constraint

Interface ： Use interface Define an object , It defines the data format

TS Basic data type ：

• undefined and null It can be used as a subtype of other types
• To define an array ：

let arr1:number[]=[1,2,3]
let arr2:Array<number>=[1,2,3]

• Enumeration type ：enum

enum Color={
    
	red,
	blue
}

let color:Color=Color.red	// The output is the number of the element , namely 0

• any type ： I'm not sure what type of current data is, and I want to store it , have access to any
• void type ： Function has no return value

function show():void{
    }

• object type
• Joint type ：

function show(str:number|string){
    }

• Types of assertions ：

// If you don't know whether the incoming data is a number or a string , And want to get its length 
if((<string>str).length){
    
	return (<string>str).length
}

Interface

interface IPerson{
    
	readonly name:string,	// Indicates that the property is read-only 
	age?:number		//？ Express age It's OK to have this attribute without 
}

Function type

interface IPerson{
    
	(name:string,age:number):boolean
}

const person:IPerson=function(name:string,age:number):boolean{
    }

Class types

interface IPerson1{
    
	fly1()
}

interface IPerson2{
    
	fly2()
}

// Define an interface to inherit multiple interfaces 
interface IPerson extends IPerson1,IPerson1{
    
}

// Implement the methods in the interface , Class can implement multiple interfaces 
class Person implements IPerson1,IPerson2{
    
	fly1(){
    
		console.log('1')	
	}
	fly2(){
    
		console.log('2')	
	}
}

polymorphic

class Animal{
    }
class Dog extends Animal{
    }
class Pig extends Animal{
    }

const dog:Animal=new Dog()
const pig:Animal=new Pig()

Modifier （ It mainly describes the accessibility of members in a class ）

public		// All accessible 
private		// Class cannot be accessed outside , Subclasses are not accessible 
protected	// Class cannot be accessed outside , Subclasses can be accessed internally 

readonly Decorate the member attributes in the class , Can be in constructor Modify this attribute in 
readonly Decorate the parameters in the constructor in the class , Class will contain this attribute member 
class Person{
    
	constuctor(readonly name:string){
    
		this.name=name
	}
}
const p=new Person('x')
console.log(p.name)	// x

Accessors (get and set)

Static attribute （static）

Can't be in constructor Use in this call static attribute , Only classes can be used . Method of attribute

class Person{
    
	static name1:string
	static show(){
    
		console.log(1)
	}
}

const person=new Person('x')
console.log(Person.name,Person.show())	// Note that Person class , Instead of instance objects person

abstract class ( Contains abstract methods , But the method has no specific implementation )

abstract class Animal{
    
	abstract eat(){
    }
}

class Dog extends Animal{
    
	eat(){
    
		console.log(1)	
	}
}

Function and function type

cosnt add:(x:number)=>number=function(x:number):number{
    }

The remaining parameters

function show(str:string,...args:string[]){
    }

function overloading

function add(x:string,y:string):string
function add(x:number,y:number):number

function add(x:number|string,y:number|string):number|string{
    }

Generic

Defining functions in 、 Interface 、 Class time , The data type to be used cannot be predetermined

function add<T>(value:T):T[]{
    }
const arr=add<number>(200)

// Multiple generics 
function add<T,K>(value:T,num:K):[T,K]{
    }