TS-7 函數深入

  • 索引簽名in(映射類型) 的聲明區別
type Hash = {
  [k:string]: unknown
  length: number
}

// 報錯,有in的情況下不能聲明其他屬性
type Hash = {
  [k in string]: unknown
  length: number
}
  • ?本質上是 類型 | undefined
  • readonly類似于const,只能限定地址不變
  • 函數三種聲明方式:
function f1(a:number): number{
  return a+1
}

type F2 = (a:number) => number 

const f2 = (a:number):number => a + 1
---or---
const f2: F2 = (a) => a+1

type F3 = typeof f2
const f3:F3 = function(a){
  return a + 1
}
const f3 = function(a: number):number{
  return a + 1 
}
---or---
type F = () => void
function fn():F{
  return
}
  • 函數柯里化:redux里的connect就是類似
const add = (a:number,b:number) => a + b

const ceateAdd = (a:number) => {
  return (b:number) => {
    return a + b
  }
}
// 簡化:createAdd(6)(14)
const createAdd = (a:number) => (b:number) => a + b
// 單獨聲明類型:
type CreateAdd = (x:number) => (y:number) => number

// add6的類型就是一個函數: (b:number)=>number
const add6 = createAdd(6)  
add6(14) //20
  • 函數重載 overload :本質是同名的函數。能不用就不用,直接用不同函數實現替代。但是如果是寫功能函數給別人用,就可以使用重載使用者體驗良好。
  1. 參數類型不同:用聯合類型,然后js進行類型收窄
// 先聲明
function createDate(n:number): Date
function createDate(year:number,month:number,day:number): Date

//再實現
function createDate(a:number,b?:number,c?:number){
  if(a !== undefined && b !== undefined c !== undefined){
    return new Date(a,b,c)
  }else if(a !== undefined && b === undefined && c === undefined){
    return new Date(a)
  }else{
    throw error('只能接受一個或三個參數')
  }
}
  • ts函數this用法:
type Person = {
  name: string
}

function fn(this: Person,word: string){
  console.log(this.name + '' + word)
}

const p:Peson = {name: 'ricky'}
fn.call(p,'hi')
fn.apply(p,['hi'])
fn.bind(p)('hi') // 柯里化
// 甚至可以
const f1 = fn.bind(p)
const f2 = f1.bind(null,'hi')
f2()
  • ts函數剩余參數
// array就是收集了所有參數的數組
function sum(name: string,...array:number[]){
  return array.reduce((previous,current)=>{
    return previous + current
  },0)
}

console.log(sum('hi',1,2,3,4,5))
  • ts函數展開參數
function sum(...array: number[]) {
  // f(array) 報錯:因為函數f是把參數全收集起來才成了number[],意味著每個參數都要是一個number
  f(...array)
  // or
  f.apply(null,array)
}

function f(...arr: number[]) {
  console.log(arr);
}
  • as const
const a = 'a'
type A = typeof a  // 'a'

let b = 'b'
type B = typeof b // string

let c = 'c' as const
type C = typeof c // 'c'

const arr  = [1,'hi']
type Arr = typeof arr // (number | string)[],因為array是可以改變元素的

const arr  = [1,'hi'] as const
type Arr = typeof arr // readonly [1,'hi']

// 函數使用示例
function f(a:number,b:number){
  return a + b
}
function sum(...arr:number[]){
  // 正確
  const x = [1,2] as const
  f(...x)

  // 報錯
  f(...arr)

  // 報錯: x是 number[],但f只接受兩個參數
  const x = [1,2]
  f(...x) 
}
  • 函數參數對象的解構,剩余參數的使用,以及默認值
type Config = {
  url: string
  method: 'GET' | 'POST'
  data?: unknown
  headers?: unknown
}

const ajax = ({url,method,...rest}:Config = {url:'', method: 'GET'}) => {}
---or---
function ajax({url,method,...rest} = {url:'',method:'GET'} as Config){
}
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容