# typescript部分语法说明

const a = isNumber(input) ? input : String(input);

// 这里的 ？表示这个参数 field 是一个可选参数
function getUser(user: string, field?: string) {
}
class A {
  name?: string // 可选属性
}
interface B {
  pageNumber: number,
  name?: string // 可选属性
}

// 这里 Error对象定义的stack是可选参数，如果这样写的话编译器会提示
// 出错 TS2532: Object is possibly 'undefined'.
return new Error().stack.split('\n');

// 我们可以添加?操作符，当stack属性存在时，调用 stack.split。
// 若stack不存在，则返回空
return new Error().stack?.split('\n');
// 以上代码等同以下代码
const err = new Error();
return err.stack && err.stack.split('\n');

// 使用A对象属性A.B时，如果无法确定A是否为空，则需要用A?.B，表示当A有值的时候才去访问B属性，没有值的时候就不去访问，如果不使用?则会报错
const user = null;
console.log(user.account) // 报错
console.log(user?.account) // undefined

// ! 就是将之后的结果取反，比如：为 True 时返回 False，为 False 时返回True
const a = !isNumber(input);

// 因为接口B里面name被定义为可空的值，但是实际情况是不为空的，
// 那么我们就可以通过在class里面使用！，重新强调了name这个不为空值
class A implemented B {
  name!: string // 属性不能为空
}
interface B {
  name?: string // 属性可以为空
}

const inputRef = useRef<HTMLEInputlement>(null);
// 定义了输入框，初始化是null，但是你在调用他的时候相取输入框的value，这时候dom实例一定是有值的，所以用断言
const value: string = inputRef.current!.value;
// 这样就不会报错了

let user = { name: 'Alice', age: 25 };
// 直接用user.address.length，TypeScript 会认为 user.address 可能是 undefined，因为它没有在 user 对象中定义
// 使用非空断言，告诉 TypeScript 我确信 user.address 存在，可以强制将其视为有效的对象。
console.log(user.address!.length);

console.log(null || 1) // 1
console.log(null ?? 1) // 1
 
console.log(undefined || 1) // 1
console.log(undefined ?? 1) // 1
 
console.log(0 || 1) // 1
console.log(0 ?? 1) // 0

const fn = (info: strong | null | undefined) => {}

interface A { prop1: number; }
interface B { prop2: string; }
type C = A & B;
// 如果一个值的类型是交叉类型A & B，那么该值必须同时满足类型A和类型B的要求。
const obj: C = {
  prop1: 10,
  prop2: 'hello',
};

let someValue: string = "this is a string";
type userId = { name: string}
let jackName: string = (someValue as unknown as userId).name; 

// 当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们只能访问此联合类型的所有类型中共有的属性或方法：
interface Cat { name: string; run(): void; }
interface Fish { name: string; swim(): void; }
function isFish(animal: Cat | Fish) {
  // animal.swim报错：类型“Cat | Fish”上不存在属性“swim”。类型“Cat”上不存在属性“swim”。ts(2339)
  if (typeof animal.swim === 'function') { return true; }
  return animal.name; // 没问题
}

// 此时可以使用类型断言，将 animal 断言成 Fish。这样就可以解决访问 animal.swim 时报错的问题了。
function isFish1(animal: Cat | Fish) {
  if (typeof (animal as Fish).swim === 'function') {  return true; }
  return false;
}

class Animal {
  name: string;
  constructor(theName: string) { this.name = theName; }
  move(distanceInMeters: number = 0) {
      console.log(`${this.name} moved ${distanceInMeters}m.`);
  }
}

class Snake extends Animal {
  constructor(name: string) { super(name); }
  move(distanceInMeters = 5) {
      console.log("Slithering...");
      super.move(distanceInMeters);
  }
}
let sam = new Snake("Sammy the Python");
sam.move();

interface GenericInterface<T> {
  (data: T): void;
}
function identity<T extends GenericInterface<T>>(arg: T): T {
  return arg;
}

type User = { id: number; name?: string };
type PartialUser = Readonly<User>;
// 等同于 type PartialUser = { readonly id: number; readonly name?: string };
const user: PartialUser = { id: 110 };
user.id = 100; // TS报错 无法为“id”赋值，因为它是只读属性

// Readonly工具泛型的定义。将T中的所有属性设置为只读
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

type T0 = Extract<'a' | 'b' | 'c', 'a' | 'f'>;                 // "a"
type T1 = Extract<string | number | (() => void), Function>;   // () => void

type userName = string; // 基本类型
type userId = string | number; // 联合类型
type arr = number[];  
// 对象类型
type Person = {
    id: userId; // 可以使用定义类型
    name: userName;
    age: number; gender: string;
};
// 范型
type Tree<T> = { value: T };
const user: Person = { id: "901", name: "椿", age: 22, gender: "女", };

interface Person { name: string; age: number; } // interface仅限于描述对象类型

// 描述 Object和Function
type Point = { x: number; y: number; };
type SetPoint = (x: number, y: number) => void;
interface Poin1t { x: number; y: number; };
interface SetPoint1 {
  (x: number, y: number): void;
};

// 继承
interface Person1{ name:string }
type Person2 = { name:string }
// interface 继承
interface Student extends Person1 { stuNo: number }
interface Student1 extends Person2 { stuNo: number }
// type 继承
type Student2 = Person1 & { stuNo: number }
type Student3 = Person2 & { stuNo: number }

// 实现 implements
interface ICat{ setName(name:string): void; }
class Cat implements ICat{
  setName(name:string):void{ }
}
// type  
type ICat1 = { setName(name:string): void; }
class Cat1 implements ICat1{
  setName(name:string):void{ }
}
// 无法对联合类型Person进行实现
type Person = { name: string; } | { setName(name:string): void };
// error: A class can only implement an object type or intersection of object types with statically known members.
class Student implements Person {
  name= "张三";
  setName(name:string):void{ }
}

type userName = string
type stuNo = number
type Student = {stuNo: number} | {classId: number}
type Data = [number, string];

// 'interface’具有声明合并的能力，允许多个同名的接口进行合并，通过这样的方式可以扩展接口的成员定义
interface Person { name: string; }
interface Person { age: number; } // 合并后的Person接口包含name和age两个属性

// 'type’不具备声明合并的能力，多次定义同一个类型会报错
type Person1 = { name: string; }
type Person1 = { age: number; } // 报错：标识符“Person1”重复。ts(2300)

interface propInter {
  [key: string] : string // 把这个注释掉，就不报错了，可以加上title: string
}
let props: propInter
type dataType = { title: string }
interface propInter2 { title: string }
const data: dataType = {title: "订单页面"}
const data1: propInter2 = {title: "订单页面"}
props = data // 没问题
// 报错：不能将类型“propInter2”分配给类型“propInter”。 类型“propInter2”中缺少类型“string”的索引签名。ts(2322)
props = data1


interface myInterface{
  title: string
  // [key: string] : string // 加上这个就不报错了
}
type myType = { title: string }
const myIn: myInterface = {title: '123'};
const myTy: myType = {title: '123'};
let record: Record<string, string> = {};
// 报错：不能将类型“myInterface”分配给类型“Record<string, string>”。类型“myInterface”中缺少类型“string”的索引签名。ts(2322)
record = myIn; 
record = myTy; // 没问题
// 这个报错的大致解释： Record<string,string>与{[key:string]：string}相同。只有当该类型的所有属性都已知并且可以对照该索引签名进行检查时，才允许将子集分配给该索引签名类型。在您的例子中，从exampleType到Record<string,string>的所有内容都是可分配的。这只能针对对象字面量类型进行检查，因为一旦声明了对象字面量类型，就无法更改它们。因此，索引签名是已知的。
// 相反，在你使用interface去声明变量时，它们在那一刻类型并不是最终的类型。由于interfac可以进行声明合并，所以总有可能将新成员添加到同一个interface定义的类型上。
// https://www.cnblogs.com/ygyy/p/18191941