러닝 타입스크립트 CHAPTER 5 - 함수

function sing(song) {
  console.log(`Singing: ${song}!);
}

function sing(song: string) {
  console.log(`Singing: ${song}!);
}

function singTwo(first: string, second: string) {
  console.log(`${first} / ${second}`)
}

singTwo('Ball and Chain')
// Error: Expected 2 arguments, but got 1.

singTwo('Go Your Own Way', 'The Chain', 'Dreams')
// Error: Expected 2 arguments, but got 3.

singTwo('I Will Survive', 'Higher Love') // OK

function announceSong(song: string, singer?: string) {
  console.log(`Song: ${song}`)

  if (singer) {
    console.log(`Singer: ${singer}`)
  }
}

announceSong('Greensleeves') // OK
announceSong('Greensleeves', undefined) // OK
announceSong('Greensleeves', 'Sia') // OK

function announceSongBy(song: string, singer: string | undefined) {
  /* ... */
}

announceSongBy('Greensleeves')
// Error: Expected 2 arguments, but got 1.

function announceSinger(singer?: string, song: string) {}
// Error: A required parameter cannot follow an optional parameter.

function rateSong(song: string, rating = 0) {
  console.log(`${song} gets ${rating}/5 starts!`)
}

rateSong('Photograph') // OK
rateSong('Set Fire to the Rain', 5) // OK
rateSong('Set Fire to the Rain', undefined) // OK

rateSong('At Last!', '100')
// Error Argument of type '100' is not assignable to parameter of type 'number | undefined'.

function singAllTheSongs(singer: string, ...songs: string[]) {
  for (const song of songs) {
    console.log(`${song}, by ${singer}`)
  }
}

singAllTheSongs('Alicia Keys') // OK
singAllTheSongs('Lady Gaga', 'Bad Romance', 'Just Dance', 'Poker Face') // OK

// 타입: (songs: string[]) => number
function singSongs(songs: string[]) {
  for (const song of songs) {
    console.log(`${song}`)
  }

  return songs.length
}

// 타입: (songs: string[], index: number) => string | undefined
function getSongAt(songs: string[], index: number) {
  return index < songs.length ? songs[index] : undefined
}

function getSongRecordingDate(song: string): Date | undefined {
  switch (song) {
    case 'Strange Fruit':
      return new Date('April 20, 1939') // OK

    case 'Greensleeves':
      return 'unknown'
    // Error: Type 'string' is not assignable to type 'Date'.

    default:
      return undefined // OK
  }
}

let nothingInGiveString: () => string

const songs = ['Juice', 'Shake It Off', "What's Up"]

function runOnSongs(getSongAt: (index: number) => string) {
  for (let i = 0; i < songs.length; i++) {
    console.log(getSongAt(i))
  }
}

function getSongAt(index: number) {
  return `${songs[index]}`
}

runOnSongs(getSongAt) // OK

function logSong(song: string) {
  return `${song}`
}

runOnSongs(logSong)
// Error: Argument of type '(song: string) => string' is not assignable to parameter of type '(index: number) => string'
// Types of parameters 'song' and 'index' are incompatible.
// Type 'number' is not assignable to type 'string'.

// 타입은 string | undefined 유니언을 반환하는 함수
let returnsStringOrUndefined: () => string | undefined

// 타입은 undefined나 string을 반환하는 함수
let maybeReturnsString: (() => string) | undefined

let singer: (song: string) => string

singer = function (song) {
  // song: string의 타입
  return `Singing: ${song.toUpperCase()}` // OK
}

type StringToNumber = (input: string) => number

let StringToNumber: StringToNumber

StringToNumber = (input) => input.length // OK

let songLogger: (song: string) => void

songLogger = (song) => {
  console.log(`${songs}`)
}

songLogger('Heart of Glass')

function returnsVoid() {
  return
}

let lazyValue: string | undefined

lazyValue = returnsVoid()
// Error: Type 'void' is not assignable to type 'string | undefined'

function fail(message: string): never {
  throw new Error(`Invairant failure: ${message}`)
}

function workWithUnsafeParam(param: unknown) {
  if (typeof param !== 'string') {
    fail('param should be a string, not ${typeof param}')
  }

  // parma의 타입은 string
  param.toUpperCase() // OK
}

function createDate(time: number): Date // 오버로드 시그니처
function createDate(month: number, day: number, year: number): Date // 오버로드 시그니처
function createDate(monthOrTimestamp: number, day?: number, year?: number) {
  return day === undefined || year === undefined
    ? new Date(monthOrTimestamp)
    : new Date(year, monthOrTimestamp, day)
} // 구현 시그니처

createDate(554356800) // OK
createDate(7, 27, 1987) // OK

createDate(4, 1)
// Error: No overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.