const object = {
  foo: 271,
  bar: "str",
  "1234": 314,
}
const { foo, bar } = object
console.log(foo) //271
console.log(bar) //str

const object = {
  foo: 271,
  bar: "str",
  "1234": 314,
}
const { foo, "1234": var1234 } = object

console.log( foo ) // 123
console.log( var1234 ) // 314

const nestedObj = {
  foo: 123,
  obj: {
    bar: 1,
    obj2: {
      baz: 2,
    },
  },
}
const { obj: {bar, obj2: { baz }}} = nestedObj

console.log(bar)//1
console.log(baz)//2

const arr = ["hello", 123, true]

const [foo, bar] = arr

console.log(bar) //123

const arr = ["hello", 123, true]
const [foo, bar] = arr

const obj = { foo, arr }

const {
  arr: [x, y],
} = obj

console.log(x) //hello
console.log(y) //123

const arrayObj = [{ a: 1, b: 2 }, { c: 3 }]
const [{b},{c}] = arrayObj

console.log(b) //2
console.log(c) //3

type Obj = {
    [k: string]: number | string
}

const obj : Obj = {
    foo: 1,
    bar: 2,
    baz:'3'
}

const str : string = 'foo'
const obj  = {
    one: 1,
    two: 2,
    [str]: 'test'
} 
//型は以下のように推論される
//const obj: {
//     [x: string]: string | number;
//     one: number;
//     two: number;
// }

console.log(obj.foo) // "test" 

console.log(obj) //{"one": 1, "two": 2,　"foo": "test"} 
//存在しないプロパティにアクセスしても型エラーが出ない。
console.log(obj.notExistProp)　//undefined

const map: Map<string|KeyObj,number> = new Map()
type KeyObj = {key: string}
const keyObj: KeyObj = {key: 'value'}
map.set('key1',1234)
map.set(keyObj,210)

console.log(map) //Map (2) {"key1" => 1234, {"key": "value"} => 210} 
console.log(map.has('key1')) //true
console.log(map.get('key1')) //1234

const map: Map<string|KeyObj,number> = new Map()
type KeyObj = {key: string}
const keyObj: KeyObj = {key: 'value'}
map.set('key1',1234)
map.set(keyObj,210)

for(const key of map.keys()){
console.log(key)
}
//"key1" 
//{"key": "value"} 

for(const value of map.values()){
console.log(value)
}
//1234
//210

for(const[key, value] of map.entries()){
    console.log(key)
    console.log(value)
}
//"key1" 
//1234 
//{"key": "value"} 
//210 

const weakMap = new WeakMap()
//Argument of type 'string' is not assignable to parameter of type 'object'.ts(2345)
weakMap.set('str','test')
//実行時エラーが発生（Invalid value used as weak map key）

const obj: {
    num: number
    readonly readonlyNum: number
} = {
    num:314,
    readonlyNum: 271
}

obj.num = 3141
obj.readonlyNum = 2718 // Cannot assign to 'readonlyNum' because it is a read-only property.(2540)

type readonlyObj = Readonly<{
num: number
name: string
}>

const obj: readonlyObj = {
    num: 314,
    name: 'pi'
}

obj.num = 1 // Cannot assign to 'num' because it is a read-only property.(2540)
obj.name = 'one'// Cannot assign to 'name' because it is a read-only property.(2540)

type readonlyObj = Readonly<{
  num: number
  numObj: {
    name: string
    num: number
  }
}>
const obj: readonlyObj = {
  num: 314,
  numObj: {
    name: "two",
    num: 2,
  },
}

obj.numObj.num = 3 //コンパイルエラーが発生しない
obj.numObj = {name: 'three', num: 3} //Cannot assign to 'numObj' because it is a read-only property.

const obj = {
    obj1: { obj2: { obj3: { num: 3, name: 'three' }}}
} as const

obj.obj1.obj2.obj3.name = 'four' // Cannot assign to 'name' because it is a read-only property.(2540)

const obj = {
    obj1: { obj2: { obj3: { num: 3, name: 'three' }}}
} as const

type NestedObj = typeof obj

type NestedObj = {
    readonly obj1: {
        readonly obj2: {
            readonly obj3: {
                readonly num: 3;
                readonly name: "three";
            };
        };
    };
}

type ReadonlyObj = {
    readonly num: number
}

const obj: ReadonlyObj = {
     num: 314
}

obj.num=271 //Cannot assign to 'num' because it is a read-only property.(2540)

type Obj = {
    num: number
}

type ReadonlyObj = {
    readonly num: number
}


const obj: ReadonlyObj = {
     num: 314
}

const changeNum = (obj: Obj)=>{
    return obj.num = 271
}

console.log(obj) //{ "num": 314 } 
changeNum(obj) // readonlyなプロパティを（コンパイルエラーなしで）書き換えられてしまう。
console.log(obj) //{ "num": 271 } 

type T = { str: string, num: number, obj: { foo: string, bar: boolean } }

//type P = { num: number; str: string;}
type P = Pick<T,"num"|"str">
//type Q = { obj: { foo: string; bar: boolean;};}
type Q = Pick<T,"obj">
//type R = { foo: string; }
type R = Pick<T["obj"], "foo">

type T = { str: string, num: number, obj: { foo: string, bar: boolean } }

//type P = { obj: { foo: string; bar: boolean;};}
type P = Omit<T, "num" | "str">
//type Q = { num: number; str: string;}
type Q = Omit<T, "obj">
//type R = { bar: boolean;}
type R = Omit<T["obj"], "foo">

type T = { str: string, num: number }
type U = T | number | boolean | "314"
//type P = "314"
type P = Extract<U, string>
//type Q = { str: string; num: number;}
type Q = Extract<T, {str: string}>
//type R = never
type R = Extract<U, {foo: boolean}>

type T = { str: string, num: number }
type U = T | number | boolean | "314"
//type P = number | boolean | T
type P = Exclude<U, string>

//type Q = never
type Q = Exclude<T, {str: string}>

//type R = number | boolean | T | "314"
type R = Exclude<U, {foo: boolean}>

type T = { str: string, num: number }

// type P = {
//   str?: string | undefined
//   num?: number | undefined
// }
type P = Partial<T>

//type Q = number プリミティブな型はそのまま返ってきている。
type Q = Partial<number>

type NestedObj = { str: string, obj:{ str: string, num: number } }

//type R = {
//     str?: string | undefined;
//     obj?: {
//         str: string;
//         num: number;
//     } | undefined;
// }
type R = Partial<NestedObj>

type T = { str?: string, num: number }

//type P = { str: string; num: number; }
type P = Required<T>
//type Q = number
type Q = Required<number>

type NestedObj = { str?: string, obj?:{ str?: string, num: number } }
// type R = {
//     str: string;
//     obj: {
//         str?: string;
//         num: number;
//     };
// }
type R = Required<NestedObj>

//type P = string
type P = NonNullable<string | null | undefined>

type T = null | {str: string, n: null}
//type Q = { str: string; n: null; }
type Q = NonNullable<T>

type Obj = {str: string, num?: number}

const obj: Obj = {str: "one"}

console.log(obj.str)// "one"
console.log(obj.num)// undefined

type Obj = {
    str: string;
    num?: number | undefined;
}

type T = {str: string, num: number}
type U = {str: string, bool: boolean}

const obj: T | U = {str: "one", num: 1}
const obj2: T | U = {num: 1, bool: true}//T型でもU型でもない場合にはコンパイルエラーとなる。
//Type '{ num: number; bool: true; }' is not assignable to type 'T | U'.
//Property 'str' is missing in type '{ num: number; bool: true; }' but required in type 'U'.(2322)

type T = { str?: string , num: number}
type U = { str: string | undefined , num:number}

const tObj: T = { num: 1}//tObjについてはコンパイルエラーが出ない。
const uObj: U = { num: 1}
//Property 'str' is missing in type '{ num: number; }' but required in type 'U'.(2741)

const uObj2: U = { num: 1, str: undefined} //undefinedを割り当てればコンパイルエラーとはならない。

type T = 'octopus'

const str: T = 'octopus'

//Type '"squid"' is not assignable to type '"octopus"'.(2322)
const str2: T = 'squid'

const a :boolean = true
//const b: boolean と推論される
const b :true | false = true

type Cephalopod = 'octopus' | 'squid'

type T = `${string} is not fish`

//type U = "octopus is not fish" | "squid is not fish"
type U = `${Cephalopod} is not fish`

const tStr: T = 'tuna is not fish'

//Type '"tuna is not fish"' is not assignable to type '"octopus is not fish" | "squid is not fish"'.(2322)
const uStr: U = 'tuna is not fish'

//const constStr: "octopus"
const constStr = 'octopus'

//let letStr: string
let letStr = 'octopus'

type T = 'octopus'

//let letStr: "octopus"
let letStr:T = 'octopus'

//let letStr2: "octopus"
let letStr2 = 'octopus' as const

function isNumberOrString(value: unknown){
  return typeof value === 'number' || typeof value === 'string' 
}

const value: unknown = "314"
if(isNumberOrString(value)){
    //'value' is of type 'unknown'.(18046)
    console.log(value.toString())
}

function isNumberOrString(value: unknown): value is string | number {
  return typeof value === 'number' || typeof value === 'string' 
}

const value: unknown = "314"
if(isNumberOrString(value)){
    //const value: string | number
    console.log(value.toString())// 314
}

function isNumber(value: unknown): asserts value is number {
    if(typeof value !== 'number'){
        throw new Error()
    }
    return;
}

const value: unknown = 314
try{
    // const value: unknown
    console.log(value)// 314

    isNumber(value)

    //const value: number
    console.log(value.toString(16))//　"13a" 
}catch(error){
    console.log('error occurred')
}

type A = {num: number, str: string}

//Type 'A' is not assignable to type 'string | number | symbol'.(2322)
type B = {[num in A]:number}

// type C = {
//     num: number;
//     str: number;
// }
type C = {[num in keyof A]:number}

type T = {
    num: number
    str: string
    bool: boolean
}

// type Obj = {
//     num: "num"[];
//     str: "str"[];
//     bool: "bool"[];
// }
type Obj = {
    [P in keyof T]: P[]
}

// type CopyOfT = {
//     num: number;
//     str: string;
//     bool: boolean;
// }
type CopyOfT = {
    [P in keyof T]: T[P]
}

type IsString<T> = T extends string ? true : false

//type NumIsString = false
type NumIsString = IsString<number>

//type LiteralIsString = true
type LiteralIsString = IsString<'str'>

type ToArray<T> = T extends string ? T[] : never

//type UnionArray = "octopus"[] | "squid"[]
type UnionArray = ToArray<"octopus"|"squid"> 

type X<T> = T extends string ? [T] : never
//type Y = ("octopus" | "squid")[]
type Y = X<"octopus" | "squid" >[number][]

type Obj = {
    readonly num: number
    str ?: string
}

type Homomorphic = {
    [PropertyKey in keyof Obj]: Obj[PropertyKey]
}
// type Homomorphic = {
//     readonly num: number;
//     str?: string | undefined;
// }

type keyStr = "num" | "str" 

type NonHomomorphic = {
    [PropertyKey in keyStr]: Obj[PropertyKey]
}
// type NonHomomorphic = {
//     num: number;
//     str: string | undefined;
// }