• 索引簽名和 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){
}