类型声明，分类与使用

let a:string=''hello world'

type A =string

let a='hello world'

let a = 'hello world';

class fn {}
let a=fn
type A=fn

let b : bigint =1n

// 创建一个 symbol 类型的值
let sym: symbol = Symbol('mySymbol');
// 创建一个对象，并使用 symbol 作为属性键
let obj: { [key: symbol]: string } = {};
obj[sym] = 'Hello, symbol!';
// 尝试使用普通字符串作为键来访问该属性会失败
console.log(obj['mySymbol']); // undefined，因为属性键是 symbol 类型，不是字符串
// 使用正确的 symbol 键来访问属性
console.log(obj[sym]); // 输出："Hello, symbol!"

let a:string|number = 'hello'
a='hello world';
a=000

type A={
    username:string
}
type B={
    age:number
}
let a: A & B = { username: 'muying', age: 20 }

function fn(n:1|2|3) {
    switch (n) {
        case 1:
            break;
        case 2:
            break;
        case 3:
            break;
        default:
             // 检测n是否可以走到这里，看所有值全部被使用到
            let m:never=n;
            break;
    }
}
fn(1)

let a:any='hello'
a=123

let a:unknown='hello'
a=123

let a:unknown='hello world';
(a as []).map(()=>{});

let a:string|undefined=undefined;
b!.length

let a:number[]=[1,2,3]

let a:Array<number>=[1,2,3]

let arr:(number|string)[]=[1,2,3,'hello','world']

let arr:[number:string]=[1,'hello'];

type Person = {
  name: string;
  age: number;
  greet(): void;
};

const john: Person = {
  name: 'XiaoMu',
  age: 20,
  greet() {
    console.log('Hello World');
  }
};

type Person = {
  name: string;
  age?: number; // 可选属性
  greet(): void;
};
const jane: Person = {
  name: 'XiaoMu',
  greet() {
    console.log('Hello World');
  }
  // age 属性在这里是可选的，所以可以省略
};

type Person = {
  readonly id: number; // 只读属性
  name: string;
};
const person: Person = {
  id: 1,
  name: 'XiaoMu'
};
// 下面这行代码将会引发错误，因为 id 是只读的,不能被修改
// person.id = 2;

type Dictionary = {
  [key: string]: string; // 使用 string 类型的键和值的索引签名
};
const dict: Dictionary = {
  firstName: 'XiaoMu',
  lastName: 'XiaoBu'
};
// 索引签名允许你使用任何 string 类型的键来访问值
console.log(dict['firstName']); // 输出: XiaoMu

//type one
type Obj={username:string}
let obj={} as Obj
obj.username='nice'
//type two
let users ：{username：string，age：number}[]=[]
// 可以向这个数组中添加符合 { username: string, age: number } 类型的对象
users .push({ username: 'XiaoMu', age: 20 });

// TS要求：实参的个数跟形参的个数必须相同
function fn(count:number,m?:string) {
    console.log(count,'count')
}
fn(123)
fn(123,'hello world')

// // 如果()后在跟一个类型值，表示需要返回的类型值
// function fn1(count: number, m?: string): number {
//     console.log(count, 'count')
//     return count
// }

// fn1(20)

// // 函数表达式
// let test: (count: number, m?: string) =>number=function fn(m,n) {
//     console.log(m, 'count')
//     return 123
// }

function overloadFunc(name: string): string;
function overloadFunc(age: number): string;
function overloadFunc(nameOrAge: string | number): string {
  // 注意：这里只有一个实现
  if (typeof nameOrAge === 'string') {
    return `Hello, ${nameOrAge}`;
  } else {
    return `Age: ${nameOrAge}`;
  }
}
// 使用函数
const greeting = overloadFunc('XiaoMu'); // 调用字符串版本的函数
const ageStatement = overloadFunc(20);   // 调用数字版本的函数

type A = {
    username: string
}
let fn: A = {
    username: 'xiaomu'
};

type A={
 (n:number):number
 username?:string
}
let fn:A=(n)=>{return n}
fn.username='xiaomu'

type A = {
  (n:number,m:number):any
  (n:string,m:string):any
}
function fn(n:number,m:number):any
function fn(n:string,m:string):any
function fn(n:number|string,m:number|string):any{
}
let a:A=fn;

interface Callable {
  (arg: string): void;
}
// 实现这个接口的函数
const myFunction: Callable = (arg) => {
  console.log(arg);
};
// 调用函数 
myFunction('Hello, world!');

enum Color {
    Red,
    Green,
    Blue
}
console.log(Color.Red);  // 输出: 0
console.log(Color.Green); // 输出: 1
console.log(Color.Blue); // 输出: 2

enum Color {
    Red = 1,
    Green,
    Blue = 4
}
console.log(Color.Green); // 输出: 2，因为Green在Red之后，所以它的值是Red的值加1
console.log(Color);//未映射过的原有枚举

enum Color {
    Red,
    Green,
    Blue
}
console.log(Color[0]);  // 输出: Red
console.log(Color[1]); // 输出: Green
console.log(Color[2]); // 输出: Blue
console.log(Color);//映射过的原有枚举

enum Roles {
    SUPER_ADMIN = 'super_admin ',
    ADMIN = 'admin',
    USER = 'user'
}
if(Roles.ADMIN=='admin'){
    console.log(Roles.ADMIN,'Roles.ADMIN')
}

const enum Color {
    Red,
    Green,
    Blue
}
let myColor: Color = Color.Red; // 在TypeScript代码中，这是类型安全的 let myColor=0
// 假设你有一个接受Color类型参数的函数
function printColor(color: Color) {
    // ...
}
printColor(Color.Green); // 在TypeScript代码中，这也是类型安全的 printColor(1);