typescript笔记2 函数 类 接口

let func = function(name:string, age:number):string{
	return `${name}:${age}`
}
// 对象类型，对象属性可以用逗号或者分号分隔
let func1 = function(p:{ name:string, age:number }):string{
	return `${p.name}:${p.age}`
}

type Person = {name:string,age:number}
let func1 = function({ name:_name, age:_age } : Person):string{
	return `${_name}:${_age}`
}

function func(name:string, age?:number):string{}
function func(p:{ name:string, age?:number}):string{}

function func(name:string, age:number = 20):string{}

function func(...nums:number[]):number{
	for(let i=0;i<nums.length;i++){}
	return 0
}

function func<Type>(arr: Type[]): Type | undefined { 
    return arr[0]
}
func<string | number>(['a','b', 1, 4]) // 可调用时指定类型
func([1,2,3]) //可根据参数类型自动推断返回类型

function func<Type extends { length: number }>(a: Type, b: Type): Type { 
	if(a.length >= b.length) {
		return a;
	} else {
		return b;
	}
}
func<string>('abc','cdefg')
func([1,2,3],[4,5]) 

function func(name:string):string; // 重载签名
function func(name:string,age?:number):string; // 重载签名
function func(name:string,age?:number):string { // 实现签名
    return ''
}
func1('PSR')
func1('PSR',18)
func1(true) // 报错

function len1(x: any[] | string){
	return x.length
}
function len2(s:string):number
function len2(arr:any[]):number
function len2(x:any){
	return x.length
}
len1(Math.random()>0.5?'hello':[4,5,6]
len2(Math.random()>0.5?'hello':[4,5,6] // 报错,因为此处参数为联合类型 string | any[] 与重载签名参数不兼容

function call(fn: (name:string) => string){
	fn('hello')
}
type Func = (name:string) = > string
function call1(fn: Func){}

type Func = {
	description: string
	(name: string): string
}
function call(fn: Func){
	console.log(`${fn.description} returnd: ${fn('hello')}`)
}
function func1(name:string):string {
	return string
}
func1.description = 'func1'

type MyConstructor = {
	new (s: string): MyClass
}
function fn(c: MyConstructor) {
	return new c('hello')
}

type CallOrConstructor {
	new (s: string): Date
	(n: number): number
}
function fn(date: CallOrConstructor) {
	let d = new date('2022')
	let n = date(2022)
}

function Person(name) {
    this.name = name // 实例属性
    this.func1 = function () {
        // 实例方法
    }
}
Person.prototype.age = 18 // 静态属性
Person.prototype.func2 = function () {
    // 静态方法
}
// 对象冒充继承，继承实例属性和方法，无法继承静态属性和方法,实例化子类时可以给父类传参
function Student(name) {
    Person.call(this, name)
}
// 原型链实现继承，可以继承所有属性方法，实例化子类时无法给父类传参
Student.prototype = new Person()

class Person {
    name: string; // 实例属性
    constructor(name: string) { // 构造函数
        this.name = name
    }
    setName(name: string): void {
        // 实例方法
        this.name = name
    }
    getName(): string {
        return this.name
    }	
	static func1(): void {
		// 静态方法
	}
}

let p = new Person('张三')

// 继承
class Student extends Person {
    constructor(name: string) {
        super(name);
    }
    setName(name: string) { // 重写函数
        super.setName(name);
        console.log(name)
    }
}

class Person{
	name: string; // 默认公有
	private age: number;
	protected setName(name:string): void {
	}
}

abstract class Person {
	abstract eat():void;
}
class Student extends Person {
	eat():void {
	}
}

class MyClass<T> {
	list:T[]=[]
	add(value:T):void{
		this.list.push(value)
	}
	get(index:number):T {
		return this.list[number]
	}
}

interface FullName {
    firstName: string
    lastName: string
}
function func(name: FullName): void {
    console.log(`${name.firstName} - ${name.lastName}`)
}
let obj = {
    age: 20,
    firstName: 'p',
    lastName: 'r'
}
func(obj) // 不报错
func({
    firstName: 'p',
    lastName: 'r',
    age: 20 // 报错
})

interface FullName {
    firstName: string
    lastName: string
}
// 扩展并定义新接口
interface FullName2 extends FullName {
	middleName: string
}
// 声明合并，直接给接口增加属性
interface FullName {
	nickName: string
}

type FullName = {
	firstName: string
	lastName: string
}
// 扩展并定义新类型
type FullName2 = FullName & {
	middleName: string
}

interface func {
	(key:string, value:string):string
}
let func1:func = function(key:string,value:string):string{
	return ''
}

interface Animal {
	name:string
	eat(str:string):void
}
class Dog implements Animal {
	name:string
	constructor(name:string){}
	eat() { // 可以不写参数，但是不实现此函数会报错
		console.log(this.name)
	}
}

type t = typeof something

interface ConfigFn{
	<T>(value:T):T;
}
let getData:ConfigFn = function<T>(value:T):T{
	return value;
}
getData<string>('1234')

interface ConfigFn<T>{
	(value:T):T;
}
let getData:ConfigFn<string> = function(value:string):string{
	return value;
}
getData('1234')