cos

// IBytedancer型を持つオブジェクトを作成
// Iはカスタム型（命名規則）を示し、クラスやオブジェクトと区別します
const bytedancer: IBytedancer = {
    jobId: 9303245,
    name: 'Lin',
    sex: 'man',
    age: 28,
    hobby: 'swimming',
}
// IBytedancer型を定義
interface IBytedancer {
	/* 読み取り専用プロパティreadonly:オブジェクト初期化外での値の設定を制約 */
	readonly jobId: number;
    name: string;
    sex: 'man' | 'woman' | 'other';
    age: number;
    /* オプションプロパティ:このプロパティは存在しない可能性があります */
    hobby?: string;
    /* 任意プロパティ:すべてのオブジェクトプロパティがこのプロパティのサブタイプであることを制約 */
    [key: string]: any; // any すべての型
}
/* エラー: "jobId"に割り当てできません。これは読み取り専用プロパティです */
bytedancer.jobId = 12345;
/* 成功:任意プロパティの下で任意のプロパティを追加できます */
bytedancer.plateform = 'data';
/* エラー:プロパティ"name"が不足していますが、hobbyは省略可能です */
const bytedancer2: IBytedancer = {
    jobId: 89757,
    sex: "woman",
    age: 18,
}

function add(x, y!) {
	return x + y;
}
const mult = (x, y) =>  x * y;

function add(x: number, y: number): number {
	return x + y;
}
const mult: (x: number, y: number) => number = (x, y) => x * y;
// 簡略化された書き方、IMultインターフェースを定義
interface IMult {
	(x: number, y: number): number ;
}
const mult: IMult = (x, y) => x * y;

/* getDate関数をオーバーロード、timestampは省略可能な引数 */
function getDate(type: 'string', timestamp?: string): string;
function getDate(type: 'date', timestamp?: string): Date;
function getDate(type: 'string' | 'date', timestamp?: string): Date | string {
    const date = new Date(timestamp);
    return type === 'string' ? date.toLocaleString() : date;
};
const x = getDate('date'); // x: Date
const y = getDate('string', '2018-01-10'); // y: string

interface IGetDate {
	(type : 'string', timestamp ?: string): string; // この場所の戻り値の型をanyに変更すれば通過します
	(type : 'date', timestamp?: string): Date;
	(type: 'string' | 'date', timestamp?: string): Date | string;
}
/* エラー：型"(type: any, timestamp: any) => string | Date"を"IGetDate"型に割り当てることができません。
	型"string | Date"を型"string"に割り当てることができません。
	型 "Date"を型"string"に割り当てることができません。ts(2322) */
const getDate2: IGetDate = (type, timestamp) => {
	const date = new Date(timestamp); 
	return type === 'string' ? date.toLocaleString() : date;
}

/* 「型+角括弧」で表現 */
type IArr1 = number[];
/* ジェネリック表現 これらの2つが最も一般的です */ 
type IArr2 = Array<string | number | Record<string, number>>;

/* 空型、無割り当てを表します */
type IEmptyFunction = () => void;
/* 任意型はすべての型のサブタイプです */
type IAnyType = any;
/* 列挙型:列挙値から列挙名への正および逆のマッピングをサポートします */
enum EnumExample {
    add = '+',
	mult = '*',
}
EnumExample['add'] === '+';
EnumExample['+'] === 'add';
enum ECorlor { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
ECorlor['Mon'] === 0;
ECorlor[0] === 'Mon';
/* ジェネリック */
type INumArr = Array<number>;

function getRepeatArr(target) {
	return new Array(100).fill(target); 
}
type IGetRepeatArr = (target: any) => any[];
/* 具体的な型を事前に指定せず、使用時に型を指定する特性 */
type IGetRepeatArrR = <T>(target: T) => T[];

/* ジェネリックインターフェース＆複数のジェネリック */
interface IX<T, U> {
	key: T;
	val: U;
}
/* ジェネリッククラス */
class IMan<T> {
	instance: T;
}
/* ジェネリックエイリアス */
type ITypeArr<T> = Array<T>;

/* ジェネリック制約:ジェネリックが文字列であることを制限 */
type IGetRepeatStringArr = <T extends string>(target: T) => T[];
const getStrArr: IGetRepeatStringArr = target => new Array(100).fill(target);
/* エラー:型"number"の引数は型“string"の引数に割り当てることができません */
getStrArr(123);

/* ジェネリックパラメータのデフォルト型 */
type IGetRepeatArr<T = number> = (target: T) => T[]; // 構造内のデフォルト割り当てに似ています
const getRepeatArr: IGetRepeatArr = target => new Array(100).fill(target); // ここでのIGetRepeatArrは型エイリアスであり、この型エイリアスに引数を渡していません
/* エラー:型"string"の引数は型“number"の引数に割り当てることができません */
getRepeatArr('123');

/* typeキーワードを使用してIObjArrのエイリアスタイプを定義 */
type IObjArr = Array<{
	key: string;
	[objKey: string]: any;
}>
function keyBy<T extends IObjArr>(objArr: Array<T>) {
	/* 型を指定しない場合、resultの型は{} */
	const result = objArr.reduce((res, val, key) => {
		res[key] = val;
		return res;
	}, {});
    /* asキーワードを使用してresultの型を正しい型としてアサート */
    return result as Record<string, T>; 
}

/* 特定の文字列/数字の固定値を指定することを許可 */
/* IDomTagはhtml、body、div、spanのいずれかでなければなりません */
type IDomTag = 'html' | 'body' | 'div' | 'span';
/* IOddNumberは1、3、5、7、9のいずれかでなければなりません */
type IOddNumber = 1 | 3 | 5 | 7 | 9;

const bookList = [ {	// 普通のjs
	author:'xiaoming',
    type:'history',
    range: '2001 -2021',
}, {
    author:'xiaoli',
    type:'Story',
    theme:'love',
}] 
// ts 冗長
interface IHistoryBook {
    author:String;
    type:String;
    range:String
}
interface IStoryBook { 
    author:String;
    type:String;
    theme:String;
}
type IBookList = Array<IHistoryBook | IStoryBook>;

type IBookList = Array<{
	author: string;
} & ({
	type: 'history';
	range: string;
} | {
	type: 'story';
	theme: string;
})>; 
/* authorはstring型のみであり、typeは'history'/'story'のいずれかで、typeが異なる場合は可能な属性が異なります */

interface IA { a: 1, a1: 2 }
interface IB { b: 1, b1: 2 }
function log(arg: IA | IB) {
    /*エラー:型"IA | IB"には"a"プロパティが存在しません。型"IB"には"a"プロパティが存在しません
    結論:ユニオン型にアクセスする際、プログラムの安全性のために、ユニオン型の交差部分のみをアクセスできます*/

	if(arg.a) {
        console.log(arg.a1);
    } else {
        console.log(arg.b1);
    }
}

interface IA { a: 1, a1: 2 }
interface IB { b: 1, b1: 2 }

/*型ガード:関数を定義し、その戻り値が型述語であり、有効範囲は子スコープ */
function getIsIA(arg: IA | IB): arg is IA {
    return !!(arg as IA).a;
}
function log2(arg: IA | IB) {
    /* エラーが発生しません */
	if(getIsIA(arg)) {
        console.log(arg.a1);
    } else {
        console.log(arg.b1);
    }
}

// reverse関数を実装し、配列または文字列を反転させる
function reverse(target: string | Array<any>) {
	/* typof型保護*/
    if (typeof target === 'string') {
       return target.split('').reverse().join('');
    }
    /* instance型保護*/
    if (target instanceof Object) {
        return target.reverse();
    }
}

// logBook関数を実装し、
// 関数は書籍の型を受け取り、関連する特徴をloggerします
function logBook(book: IBookItem) {
	// ユニオン型+型保護=自動型推論
	if (book.type === 'history'){
		console.log(book.range);
    } else{
        console.log(book.theme);
    }
}

function merge1(sourceObj, targetObj) {	// jsでは、実装が複雑で、汚染しないためにはこうする必要があります
    const result = { ...sourceObj };
    for(let key in targetObj) {
        const itemVal = sourceObj[key];
        itemVal && ( result[key] = itemVal );
    }
    return result;
}
function merge2(sourceObj, targetObj) {// もしこの2つの引数の型に問題がなければ、こうできます
    return { ...sourceObj, ...targetObj };
}

interface ISource0bj { 
    x?: string; 
    y?: string; 
}
interface ITarget0bf {
    x: string;
    y: string;
}
type IMerge = (source0bj: ISource0bj, target0bj: ITarget0bj) => ITargetObj;
/* 型実装が冗長:もしobj型が複雑であれば、sourceとtargetを宣言するために大量の重複が必要で
エラーが発生しやすい:もしtargetがkeyを増減させると、sourceが連動して削除する必要があります */

interface IMerge {
    <T extends Record<string, any>>(sourceObj: Partial<T>, targetObj: T): T;
}
// Partial内部実装
type IPartial<T extends Record<string, any>> = {
            [P in keyof T]?: T[P];
}
// インデックス型:キーワード[keyof]は、オブジェクト内のすべてのkeyを含む文字列リテラルを取得することに相当します。例えば
type IKeys = keyof{a: string; b: number }; // => type IKeys ="a" | "b"
// キーワード[in]は、文字列リテラルの中の1つの可能性を取得することに相当し、ジェネリックPと組み合わせると、各keyを示します。
// キーワード[?]は、オブジェクトのオプションを設定することにより、サブセット型を自動的に推論することができます。

// delayCallの型宣言をどのように実装するか
// delayCallは関数を引数として受け取り、1秒遅延して関数を実行します
// その戻り値は、引数関数の戻り値の結果です
function delayCall(func) {
    return new Promise(resolve => {
        setTimeout(() => {
            const result = func();
            resolve(result);
        }, 1000);
    });
}

type IDelayCall= <T extends () => any>(func: T) => ReturnType<T>;
type IReturnType<T extends (...args: any) => any> = T extends(...args: any ) => infer R ? R : any;
    
// 重要なキーワード[extends]は、ジェネリックが出現する際に、型推論を示し、三項演算子に類似した表現です。
// 例えばT === 判断型?型A:型B
// 重要なキーワード[infer]は、型推論の中で出現し、型変数を定義することを示し、型を指すことができます。