러닝 타입스크립트 CHAPTER 7 - 인터페이스

type Poet = {
  born: number
  name: string
}

interface Poet {
  born: number
  name: string
}

interface Book {
  author?: string
  pages: number
}

// OK
const ok: Book = {
  author: 'Rita Dove',
  pages: 80,
}

// OK
const missing: Book = {
  pages: 80,
}

interface Page {
  readonly text: string
}

function read(page: Page) {
  // OK: text 속성을 수정하지 않고 읽는 것
  console.log(page.text)

  page.text += '!'
  // Error: Cannot assign to 'text' because it is read-only property.
}

interface HasBothFunctionTypes {
  property: () => string
  method(): string
}

const hasBoth: HasBothFunctionTypes = {
  property: () => '',
  method() {
    return ''
  },
}

hasBoth.property() // OK
hasBoth.method() // OK

type FunctionAlias = (input: string) => number

interface CallSignature {
  (input: string): number
}

// 타입: (input: string) => number
const typedFunctionAlias: FunctionAlias = (input) => input.length // OK

// 타입: (input: string) => number
const typedCallSignature: CallSignature = (input) => input.length // OK

interface FunctionWithCount {
  count: number
  (): void
}

let hasCallCount: FunctionWithCount

function keepsTrackOfCalls() {
  keepsTrackOfCalls.count += 1
  console.log(`I've been called ${keepsTrackOfCalls.count} times!`)
}

keepsTrackOfCalls.count = 0

hasCallCount = keepsTrackOfCalls // OK

function doesNotHaveCount() {
  console.log('No idea!')
}

hasCallCount = doesNotHaveCount
// Error: Property 'count' is missing in type
// '() => void' but required in type 'FunctionWithCalls'

interface WordCounts {
  [i: string]: number
}

const counts: WordCounts = {}

counts.apple = 0 // OK
counts.cherry = 1 // OK

counts.cherry = false
// Error: Type 'boolean' is not assignable to type 'number'.

interface DatesByName {
  [i: string]: Date
}

const publishDates: DatesByName {
  Frankenstein: new Date('1 January 1818')
}

publishDates.Frankenstein // 타입 Date
console.log(publishDates.Frankenstein.toString()) // OK

publishDates.Beloved // 타입은 Date이지만 런타임 값은 undefined
console.log(publishDates.Beloved.toString())
// 타입 시스템에서는 오류가 나지 않지만 실제 런타임에서는 오류가 발생
// Runtime error: Cannot read property 'toString'
// of undefined (reading publishDates.Beloved)

interface ChapterStarts {
  preface: 0
  [i: string]: number
}

const correctPreface: ChapterStarts = {
  preface: 0,
  night: 1,
  shopping: 5,
}

const wrongPreface: ChapterStarts = {
  preface: 1,
  // Error: Type '1' is not assignable to type '0'.
}

// OK
interface MoreNarrowNumbers {
  [i: number]: string
  [i: string]: string | undefined
}

// OK
const mixesNumbersAndStrings: MoreNarrowNumbers = {
  0: '',
  key1: '',
  key2: undefined,
}

interface MoreNarrowStrings {
  [i: number]: string | undefined
  // Error: 'number' index type 'string | undefined'
  // is not assignable to 'string' index type 'string'.
  [i: string]: string
}

interface Novel {
  author: {
    name: string
  }
  setting: Setting
}

interface Setting {
  place: string
  year: number
}

interface Writing {
  title: string
}

interface Novella extends Writing {
  pages: number
}

// OK
let myNovella: Novella = {
  pages: 195,
  title: 'Ethan Frome',
}

interface WithNullableName {
  name: string | null
}

interface WithNonNullableName extends WithNullableName {
  name: string
}

interface WithNumericName extends WithNullableName {
  // Error: Interface 'WithNumericName' incorrectly extends interface 'WithNullableName'.
  // Types of property 'name' are incompatible.
  // Type 'string | number' is not assignable to type 'string | null'.
  // Type 'number' is not assignable to type 'string'.
  name: number | string
}

interface GivesNumber {
  giveNumber(): number
}

interface GivesString {
  giveString(): string
}

interface GivesBothAndEither extends GivesNumber, GivesString {
  giveEither(): number | string
}

function useGivesBoth(instance: GivesBothAndEither) {
  instance.giveEither() // 타입: number | string
  instance.giveNumber() // 타입: number
  instance.giveString() // 타입: string
}

interface Merged {
  fromFirst: string
}

interface Merged {
  fromSecond: number
}

// interface Merged {
//    fromFirst: string
//    fromSecond: number
// }

interface Window {
  myEnvironmentVariable: string
}

window.myEnvironmentVariable // 타입: string

interface MergedProperties {
  same: (input: boolean) => string
  different: (input: string) => string
}

interface MergedProperties {
  same: (input: boolean) => string // ok
  different: (input: number) => string
  // Error: Subsequent property declarations must have the same type.
  // Property 'different' must be of type '(input: string) => string',
  // but here has type '(input: number) => string'.
}

interface MergedMethods {
  different(input: string): string
}

interface MergedMethods {
  different(input: number): string // OK
}