TypeScript ​

// 数值默认通为 number 类型
let num = 25 // 整数 等价与 let num:number = 25
let flo: number = 25.5 // 浮点数
let hex: number = 0xa05 // 十六进制
let binary: number = 0b1001 // 二进制
let octal: number = 0o751 // 八进制
// 错误示例
// num = '25' // 错误：不能将 string 赋值给原有 number 类型的变量 num

let str: string = 'Hello World!'

let isLogin: boolean = false

// 返回值类型
function returnStr(): string {
 return 'Hello World!'
}
let returnNum = (): number => 222
let returnBool = (): boolean => false
let returnAny = (): any => 'string' || 111 || false

// 返回空
let returnVoid = (): void => {}

// 指定参数类型
let sumValue = (n1: number, n2: number): number => n1 + n2
let strValue = (v1: string, v2: number): string => `${v1}${v2}`

// 指定函数的返回值类型后，就是将接受函数返回值的变量的类型设置为返回值类型，
// 此时该函数表达式变量不可再被修改为其他类型的值，例：
let returnNumber = (): number => 111
// returnNumber = 'string' // 错误，不能将类型 string 赋值给 number
// returnNumber = ():void => {}   // 错误，不能将 void 赋值给number

// 非严格模式下可以给任何类型赋值为 null 或 undefined
// 严格模式下只有 null 和 undefined 可以互相赋值
let myValue = 10
myValue = null
myValue = undefined
// 但是已经声明了类型的 null 和 undefined 只能赋值为各自本身
let myValue: null = null
// myValue = undefined;    // 错误
let myValue2: undefined = undefined
// myValue2 = null // 错误

// any 类型可以赋给任何类型，unknown 类型只能赋值给 any | unknown
let notSure: unknown = 11
notSure = '11'
notSure = false
// let strVal: string = notSure // Error 不能将类型“unknown”分配给类型“string”。ts(2322)
let anyVal: any = notSure
let numVal: number = anyVal // 正确

// string 数组
let names: Array<string> = ['henry', 'bucky'] // 等价于 let names: string[] = ['henry', 'bucky']
// number 数组
let numbers: number[] = [1, 2, 3] // 等价于 let numbers: Array<number> = [1, 2, 3]
// any 数组
let anys: any[] = []
anys[0] = 'string'
anys[1] = 111
anys[2] = false

// 规定了数组中类型的顺序
let colors: [string, number] = ['hello', 111]

enum Color {
 Black, // 0
 Yellow, // 1
 Red, // 2
 Green = 100,
 Blue // 101
}
let myColor: Color = Color.Blue
console.log(Color[0])

unionType = 'Hello, World'
unionType = 12
unionType = true
// unionType = {}  // 错误，只能是 string、number、boolean 中的一种类型

let checkType = 10
console.log(typeof checkType === 'string') // false
console.log(typeof checkType === 'number') // true // 非严格模式报错

interface PersonBasicType {
 name: string
 age: number
}
interface Props {
 sex: string
}
const formatPerson = (person: Props & PersonBasicType): string =>
 `${person.name}${person.age}${person.sex}`
formatPerson({ name: 'John', age: 18, sex: 'male' })

// 简单对象
let obj: { name: string; age: number } = {
 name: 'qiuxc',
 age: 12
}
/*
obj = {
    aaa: 'ss',
    bbb: 234
}  // 错误，参数必须是 name 和 age，即使是对应的类型，不同的变量名也不可以
 */
obj = {
 name: 'summer',
 age: 18
} // 正确
// 复杂对象
let complexObj: { data: number[]; func: (value: number) => number[] } = {
 data: [1, 2, 3],
 func(value: number) {
  this.data.push(value)
  return this.data
 }
}
console.log(complexObj.func(4)) // [1, 2, 3, 4]

type myType = {
 data: number[]
 myFunc: (value: number) => number[]
}
let complexObj2: myType = {
 data: [1, 2, 3],
 myFunc(value: number) {
  this.data.push(value)
  return this.data
 }
}
console.log(complexObj2.myFunc(4)) // [1, 2, 3, 4]

interface Alarm {
 alert(): void
}
class Door {}
// SecurityDoor 类继承 Door 类并使用 implements 为 SecurityDoor 类拓展方法
class SecurityDoor extends Door implements Alarm {
 alert() {
  console.log('防盗门的报警功能')
 }
}
class Car implements Alarm {
 alert() {
  console.log('车的报警功能')
 }
}
// 接口继承类
class Ponit {
 x: number
 y: number
 constructor(x: number, y: number) {
  this.x = x
  this.y = y
 }
}
interface Ponit3d extends Ponit {
 z: number
}
let ponit: Ponit3d = { x: 1, y: 2, z: 3 }

// 抽象类
abstract class Person {
 public name: string
 protected age: number
 public constructor(name: string, age: number) {
  this.name = name
  this.age = age
 }
 public abstract sayHi()
}

class Man extends Person {
 sayHi() {
  console.log('Hi, my name is ' + this.name)
 }
}

const jonny: Man = new Man('Jonny', 20)
jonny.sayHi()

// 声明泛型函数
function createArray<T>(length: number, value: T): Array<T> {
 return new Array(length).fill(value)
}

// Array<string>
console.log(createArray<string>(5, 'qxc')) //[ 'qxc', 'qxc', 'qxc', 'qxc', 'qxc' ]

// // Array<number>
console.log(createArray<number>(5, 6)) //[ 6, 6, 6, 6, 6 ]
console.log(createArray(5, '6')) //[ '6', '6', '6', '6', '6' ]

// 多个类型参数
function swap<T, U, A>(tuple: [T, U, A]): [A, U, T] {
 return [tuple[2], tuple[1], tuple[0]]
}
// [boolean, string, number]
console.log(swap([1, '1', true])) // [true, '1', 1]

// 泛型参数约束
interface Lengthwise {
 length: number
}
function getLength<T extends Lengthwise>(value: T): number {
 return value.length
}
getLength([1, 2, 3]) // 3

// 泛型接口-函数
interface ValueArray {
 <T>(Value: T): Array<T>
}
let ValueArray: ValueArray
ValueArray = <T>(val: T): Array<T> => new Array(val)

// 泛型类
class GenericValue<T> {
 value: T
 joint(x: T, y: T): T[] {
  return [x, y]
 }
}

// 泛型参数默认类型
function temp<T = string>(name: T): T {
 return name
}

interface PersonBasicType {
 name: string
 age: number
}
interface Props {
 sex: string
}
const formatPerson = (person: Props & PersonBasicType): string =>
 `${person.name}${person.age}${person.sex}`

type formatPersonType = typeof formatPerson
// type formatPersonType = (person: Props & PropsType) => string

const people: PersonBasicType & Props = {
 name: 'qiuxc',
 age: 21,
 sex: 'male'
}
type PersonFullType = typeof people
const newPeople: PersonFullType = {
 name: 'Sunny',
 age: 28,
 sex: 'woman'
}

type PersonAllKeysType = keyof PersonFullType // name | age | sex
const xq: PersonAllKeysType = 'name'
type StrKType = keyof string // "toString" | "charAt" | "charCodeAt" | "concat" | "indexOf" | "lastIndexOf" | "localeCompare" | ...
type NumKType = keyof number // "toString" | "toFixed" | "toExponential" | "toPrecision" | "valueOf" | "toLocaleString"
type BooKtype = keyof boolean // "valueOf"

// 使用 keyof 指定参数类型
const getProps = <T extends object, K extends keyof T>(obj: T, key: K): T[K] =>
 obj[key]
getProps(newPeople, 'age') // <PersonBasicType & Props, "age">(obj: PersonBasicType & Props, key: "age") => number
getProps(newPeople, 'name') // <PersonBasicType & Props, "name">(obj: PersonBasicType & Props, key: "name") => string
getProps(newPeople, 'sex') // <PersonBasicType & Props, "sex">(obj: PersonBasicType & Props, key: "sex") => string

type Keys = 'a' | 'b' | 'c'
type Obj = {
 [k in Keys]: any
} // type Obj = { a: any; b: any; c: any; }

// 获取函数返回值类型
type RT<T> = T extends () => infer R ? R : T;
const rs = () => 'abc';
type RSRT = RT<typeof rs>;  // type RSRT = string（获取到函数 rs 的返回值类型为 string）

// 获取函数参数类型
type PT<T> = T extends (...args: infer P) => any ? P : any;
const ps1 = (str: string) => str;
type PS1PT = PT<typeof ps1>;  // type PS1PT = [str: string]（获取到 ps1 函数的参数类型为 [str: string]）
const ps2 = (a: number, b: number) => a + b;
type PS2PT = PT<typeof ps2>;  // type PS2PT = [a: number, b: number]（获取到 ps2 函数的参数类型为 [a: number, b: number]

const logging = <T extends { a: 1; b: 2 }>(val: T): void => console.log(val)

// 在对象中获取一些属性的值，然后建立对应的集合。下面这种写法可以约束第二个数组参数中的值
const getValues = <T, K extends keyof T>(obj: T, keys: K[]): T[K][] =>
 keys.map((key: K) => obj[key])
getValues({ a: 1, b: '2' }, ['a', 'b']) // => (string | number)[]
// getValues({a: 1, b: '2'}, ['a', 'b', 'c']) // 不能将类型“"c"”分配给类型“"a" | "b"”。ts(2322)

interface TestInterface {
 name: string
 age: number
}
type OptionalTestInterface<T> = {
 [k in keyof T]?: T[k]
}
type newTestInterface =
 OptionalTestInterface<TestInterface> /* type newTestInterface = {name?: string; age?: number} */
const objInterface: newTestInterface = { name: 'qiuxc', age: 18 }

interface User {
 name: string
 id: number
}
const user: Partial<User> = {
 name: 'qiuxc'
}

// 但是 Partial<T> 有个局限性，就是只支持处理第一层的属性，如果要处理多层，就可以自己实现
type DeepPartial<T> = {
 [k in keyof T]?: T[k] extends object ? DeepPartial<T[k]> : T[k]
}
interface NewUser extends User {
 loves: {
  movie: boolean
  music: boolean
 }
}
const newUser: DeepPartial<NewUser> = {
 name: 'qiuxc',
 loves: {
  movie: false
 }
}

// 示例：先将类型的属性变成非必选，再变成必选
type OptionalUser = Partial<User>
const u1: OptionalUser = { name: 'John' }
type RequiredUser = Required<User>
const u2: RequiredUser = { name: 'John'} // Error: 类型 "{ name: string; }" 中缺少属性 "id"，但类型 "Required<User>" 中需要该属性

const u3: Readonly<User> = {
 name: 'qiuxc',
 id: 18
}
// u3.id = 11 // Error: 无法分配到 "id" ，因为它是只读属性。ts(2540)

interface Todo {
 title: string
 description: string
 completed: boolean
}
type TodoPriview = Pick<Todo, 'title' | 'completed'>
/* type TodoPriview = {
 title: string
 completed: boolean
} */

type PageInfo = 'home' | 'about' | 'contact'
type NewPageInfo = Record<PageInfo, { title: string }>
/* type NewPageInfo = {
 home: {
  title: string
 }
 about: {
  title: string
 }
 contact: {
  title: string
 }
} */
const homepage: NewPageInfo = {
 home: { title: 'Home' },
 about: { title: 'About' },
 contact: { title: 'Contact' }
}

const returnPerson = (name: string, age: number) => ({ name, age })
type ReturnPersonReturnType = ReturnType<typeof returnPerson>
// type ReturnPersonReturnType = { name: string; age: number; }
const foo: ReturnPersonReturnType = { name: 'foo', age: 1 }
// const bar: ReturnPersonReturnType = 1 // Error: 不能将类型“number”分配给类型“{ name: string; age: number; }”。ts(2322)

type T0 = Exclude<'a' | 'b' | 'c', 'a'> // type T0 = "b" | "c"

type T4 = Extract<'a' | 'b' | 'c', 'a'> // type T4 = "a"

interface AboutBook {
 lookBook: string
 writeBook: string
 buyBook: string
}
type BookThing = Omit<AboutBook, 'lookBook'>
/* type BookThing = {
 writeBook: string
 buyBook: string
} */

type F0 = (v1: number, v2: string, v3: boolean) => any
type ParamsType = Parameters<F0> // type ParamsType = [v1: number, v2: string, v3: boolean]