function foo(): never {//永遠(yuǎn)不會(huì)返回結(jié)果 // 死循環(huán) while(true) {}
 }
function bar(): never {throw new Error()
 } 

function foo(x: string | number): boolean {if (typeof x === 'string') {return true;} else if (typeof x === 'number') {return false;}// 如果不是一個(gè) never 類型，這會(huì)報(bào)錯(cuò)：// - 不是所有條件都有返回值 （嚴(yán)格模式下）// - 或者檢查到無(wú)法訪問的代碼// 但是由于 TypeScript 理解 `fail` 函數(shù)返回為 `never` 類型// 它可以讓你調(diào)用它，因?yàn)槟憧赡軙?huì)在運(yùn)行時(shí)用它來做安全或者詳細(xì)的檢查。return fail('Unexhaustive');
}
function fail(message: string): never {throw new Error(message);
} 

// 沒有返回值的函數(shù)，其返回值類型為 void
function alertName(): void { alert('My name is Tom'); } 

let unusable: void = undefined; 

// 如果什么都不寫，此時(shí)，add 函數(shù)的返回值類型為： void
const add = () => { //
}
// 如果return之后什么都不寫，此時(shí)，add 函數(shù)的返回值類型為： void
const add = () => {  return 
}
const add = (): void => {// 此處，返回的 undefined 是 JS 中的一個(gè)值return undefined
}
// 這種寫法是明確指定函數(shù)返回值類型為 void，與上面不指定返回值類型相同
const add = (): void => {// 
} 

function foo() {return 'abc'
}
function bar() {return 123
}
// unknown類型只能賦值給any和unknown類型
// any類型可以賦值給任意類型
let flag = true
let result: unknown // 最好不要使用any
if (flag) {result = foo()
} else {result = bar()
}
let message: string = result //報(bào)錯(cuò)
let num: number = result //報(bào)錯(cuò)
let num1: unknown = result
let num2: any = result
console.log(result) 

let value: unknown = 123;
console.log(++value )//error:'value' is of type 'unknown'.
console.log(++(value as number) ) 

let value: unknown;
value = 123;
value = "abc";
value = false;

let value1: unknown = 123;
let value2: number;
value2 = value1;

let value1: unknown = 123;
let value2: number;
value2 = value1 as number;

let value1: unknown = 123;
let value2: number;
if (typeof value1 === 'number') {
    value2 = value1;
}

let value1: unknown = 123;
value1++;

let value1: unknown = 123;
(value1 as number)++;

let value1: unknown = 123;
if (typeof value1 === 'number') {
    value1++;
}

let value1: unknown = 123;
let value2: unknown = 123;
console.log(value1 === value2);
console.log(value1 !== value2);

let value1: unknown = 123;
let value2: unknown = 123;
console.log(value1 >= value2);

type MyType = number & unknown;

type MyType = unknown & string;

type MyType1 = unknown | any;
type MyType2 = unknown | number;
type MyType3 = unknown | string | boolean;

type MyType = never extends unknown ? true : false;

type MyType = keyof unknown;

class="language-typescript">class Person {
    name: string = 'BNTang';
    say(): void {
        console.log(`name = ${this.name}`);
    }
}
let p: unknown = new Person();
p.say();
console.log(p.name);

type MyType<T> = {
    [P in keyof T]: any
}
type res = MyType<unknown>