1.类型
//rename data type
type NAME = string
const jackName : NAME = 'Jack Jay'
//rename mixed data type
type PHONE = string | number
const jackPhone : PHONE = '123321'
const maryPhone : PHONE = 121212
//like interface
type Person = {
name:string,
age:number
}
const jack : Person = {
name:'Jack',
age:12
}
// cannot rewrite and mixed
// throw error
type Rewrite = {
name:string
}
type Rewrite = {
age:number
}
// cannot extends but can mixed
interface Father {
name:string
}
type Son = Father & {
age:number
}
const john : Son = {
name:'',
age:12
}
2.元组
//confirm each type of element in array and length
const arr : [string,number,boolean] = ['123',123,true]
arr[0].split('')
arr[1].toFixed(2)
3.类
3.1 public private protected
// public: everyone can use
// private: only the class inside which inited it can use
// protected: the calss inited and the sub class can use
class Person {
public name = 'Person'
private age = 18
protected phone = 12345
}
class Jack extends Person {
log() {
console.log(this.name)
console.log(this.age)
console.log(this.phone)
}
}
const jack = new Jack()
jack.log()
3.2 class使用数据类型
//must init the value before use constructor
//class use data type
class Animal {
public name
constructor(name:string) {
this.name = name
}
}
3.3 readonly
// only can be changed in constructor
class Book{
public readonly name
constructor(name:string) {
this.name = name
}
}
3.4 abstract
// abstract class can't be inited
// abstract method must be rewrite by sub class
abstract class Animal {
public name
constructor(name:string) {
this.name = name
}
public abstract eat() : any
}
class Dog extends Animal {
public age
constructor(name:string,age:number) {
super(name)
this.age = age
}
public eat() : any {
}
}
const dog = new Dog('123',123)
3.5 interface
// class implements a interface and rewrite interface method
interface Alarm {
alert():void
}
class Door implements Alarm {
alert(){
}
}
class Car implements Alarm {
alert() {
}
}
//interface can extends interface
interface Open {
open():void
}
interface Alarm extends Open {
alert():void
}
class Door implements Alarm {
alert(){
}
open() {}
}
//class extends multiple interface
interface Open {
open():void
}
interface Alarm {
alert():void
}
class Door implements Alarm, Open {
alert(){
}
open() {}
}
//interface extends class
interface Inter extends Name{
a:string
}
class Name {
name: string
age : number
constructor(name:string, age:number) {
this.name = name
this.age = age
}
}
const obj : Inter = {
a:'123',
name:'123',
age:123
}
4.泛型
//when don't konw input type, use <T> instead of data type
// T is customized
function fun<T>(a:T):T{
return a
}
fun(123)
//use more than one
function fun2<T, U>(tuple:[T,U]):[U,T] {
return [tuple[1],tuple[0]]
}
fun2([1,'2'])
// function use parameter varible but don't know data type
// extends interface to add a varible
// while using fun, the parameter must obey the interface rule
interface Length {
length:number
}
function fun<T extends Length>(a:T):T{
console.log(a.length)
return a
}
fun('123')
fun(1)//throw error
// don't konw parameter data type,
interface FUN {
<T>(a:number,b:T):Array<T>
}
let fun: FUN = function<T>(a: number, b: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < a; i++) {
result[i] = b;
}
return result;
}
//or
interface FUN2<T> {
(a:number,b:T):Array<T>
}
let fun2 : FUN2<any> = function<T>(a: number, b: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < a; i++) {
result[i] = b;
}
return result;
}
// calss variable don't know data type
class Person <T> {
value:T
constructor(value:T) {
this.value = value
}
add(a:number,b:T):Array<T>{
return []
}
}
const person = new Person<string>('12')
