TypeScript 学习笔记(七)：条件类型

news2024/11/30 9:51:16

条件类型

TS中的条件类型就是在类型中添加条件分支，以支持更加灵活的泛型，满足更多的使用场景。内置条件类型是TS内部封装好的一些类型处理，使用起来更加便利。

一、基本用法

当T类型可以赋值给U类型时，则返回X类型，否则返回Y类型。

T extends U ? X : Y
  • T U X Y 四个是占位符，分别表示四种类型；
  • T extends U表示T类型能被赋值给U类型，这里还涉及到TS类型兼容性。

这个表达式的意思是，如果 T 可以赋值给 U 类型，则是 X 类型，否则是 Y 类型。来看个实际例子：

T的具体类型返回不同类型的字符串，也就是字面量类型

type TypeName<T> =
  T extends string ? "string" :
  T extends number ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

type A = TypeName<'1'> //"string"
type B = TypeName<1> //"number"
type C = TypeName<true> //"blolean"
type D = TypeName<undefined> //"undefined"
type E = TypeName<()=>void> //"function"
type F = TypeName<{}> //"object "

T为联合类型时 :

type G = TypeName<'1'｜ 1 ｜ true> // "string" | "number" | "boolean"
type H = TypeName<()=>void | {}> // "function" | "object"

根据类型参数判断返回类型：

二、分布式条件类型

什么样的条件类型称为分布式条件类型呢？

答案是：条件类型里待检查的类型必须是裸类型（naked type parameter）

1. 什么类型是裸类型？

裸类型是指类型参数没有被包装在其他类型里,比如没有被数组、元组、函数、Promise等等包裹，简而言之裸类型就是未经过任何其他类型修饰或包装的类型。

当分布式条件类型中被检查类型为联合类型，则在运算过程中分解多个分支 。

type typeName<T> = T extends number ? "X" : "Y" ;
type H = typeName<string | number> // "X" | "Y"

//上面typeName在计算类型时，会分解为如下：
type H =  string extends number ? "X" : "Y" ｜ number extends number ? "X" : "Y" 
= "X" | "Y"

// 裸类型参数,没有被任何其他类型包裹，即T
type NakedType<T> = T extends boolean ? "YES" : "NO"
// 类型参数被包裹的在元组内，即[T]
type WrappedType<T> = [T] extends [boolean] ? "YES" : "NO";

2. 分布式如何理解？

分布式条件类型在实例化时会自动分发成联合类型

什么意思呢？

T extends U ? X : Y使用类型参数A | B | C 实例化 T 解析为 (A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y)

结合 乘法分配律 理解一下！

接下来结合具体实例我们来看一下分布式条件类型 与 不含有分布式特性的条件类型

  // 裸类型参数,没有被任何其他类型包裹，即T
  type NakedType<T> = T extends boolean ? 'YES' : 'NO';
  // 类型参数被包裹的在元组内，即[T]
  type WrappedType<T> = [T] extends [boolean] ? 'YES' : 'NO';

  // 含有分布式特性的，待检查类型必须为”裸类型“
  type Distributed = NakedType<number | boolean>; //  = NakedType<number> | NakedType<boolean> =  "NO" | "YES"（结合一下乘法分配律便于理解与记忆哦~）

  // 不含有分布式特性的，待检查的类型为包装或修饰过的类型
  type NotDistributed = WrappedType<number | boolean>; // "NO"

搞明白了分布式条件类型，我们编写这样一个类型工具 NonNullable ，即从类型 T 中排除 null 和 undefined ，我们期待的结果如下：

type a = NonNullable<string | number | undefined | null> // 得到type a = string | number

借助条件类型可以很容易写出来：

type NonNullable<T> = T extends null | undefined ? never : T

注意：never 类型表示不会是任何值，即什么都没有

三、非分布式条件类型

当T被数组、元组、Promise等包裹时，则运算过程中不会分解成多个分支，则该条件类型为非分布式条件类型。

type WrappedTuple<T> = [T] extends [boolean] ? "X" : "Y";
type WrappedArray<T> = T[] extends boolean[] ? "X" : "Y";
type WrappedPromise<T> = Promise<T> extends Promise<boolean> ? "X" : "Y";
type G = WrappedTuple<string | boolean>; // "Y"
type K = WrappedArray<string | boolean>; // "Y"
type L = WrappedPromise<string | boolean>; // "Y"

解析：

//由于计算数据时不会分解成多个分支

// [T] extends [boolean]
//WrappedTuple<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型

//T[] extends boolean[]
//WrappedArray<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型

//Promise<T> extends Promise<boolean>
//WrappedPromise<string | boolean> 中 string | boolean 不是 boolean 类型，也不是其他原始类型

四、结合泛型使用

1. 过滤出公共类型

在联合类型T中过滤出联合类型U中的成员，过滤出来的成员则组成新的类型。下面例子中，如果类型T为类型U的子类型，则返回类型T，否则返回never

type Filter<T, U> = T extends U ? T : never;
type B = Filter<"a" | "b" | "c", "a" | "c" | "d"> ; // "a" | "c"

2. 类型删除

在联合类型T中删除联合类型U中的成员，T类型中的剩余成员则组成新的类型。下面例子中，如果类型T为类型U的子类型，则返回never，否则返回类型T

type Diff<T, U> = T extends U ? never : T;
type A = Diff<"a" | "b" | "c", "a" | "c" | "d">;  // "b"

五、结合 infer 关键字

1. 根据类型参数判断返回类型

  1. 案例一：

条件类型提供一个infer关键字用来推断类型，我们先来看个例子。我们想定义一个条件类型，如果传入的类型是一个数组，则返回它元素的类型；如果是一个普通类型，则直接返回这个类型。来看下不使用 infer 的话，怎么写：

type Type<T> = T extends any[] ? T[number] : T;
type test = Type<string[]>; // test的类型为string
type test2 = Type<string>; // test2的类型为string

这个例子中，如果传入 Type 的是一个数组类型，那么返回的类型为T[number]，也就是该数组的元素类型，如果不是数组，则直接返回这个类型。这里我们是自己通过索引访问类型T[number]来获取类型的，如果使用 infer 关键字则无需自己手动获取，我们来看下怎么使用 infer：

type Type<T> = T extends Array<infer U> ? U : T;
type test = Type<string[]>; // test的类型为string
type test2 = Type<string>; // test2的类型为string

这里 infer 能够推断出 U 的类型，并且供后面使用，你可以理解为这里定义了一个变量 U 来接收数组元素的类型。

  1. 案例二：
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

const foo = (): string => {
  return "hello";
}

const bar = (): number => {
  return 42;
}

const str: ReturnType<typeof foo> = "hello"; // string
const num: ReturnType<typeof bar> = 42; // number

在这个例子中，我们定义了一个 ReturnType 类型，它接受一个泛型类型参数 T。这个类型参数代表一个函数类型，我们通过 T extends (…args: any[]) => infer R 这个条件语句来判断 T 是否是一个函数类型，并提取其返回值类型 R。如果 T 是一个函数类型，则返回 R 类型，否则返回 never 类型。

然后，我们定义了两个函数 foo 和 bar，分别返回字符串和数字。我们使用 typeof 操作符来获取这两个函数的类型，并通过 ReturnType 和 ReturnType 来获取它们的返回类型。

最后，我们声明了两个变量 str 和 num，并分别将它们声明为 ReturnType 和 ReturnType 类型。这样就可以根据不同的函数类型来确定返回类型。

  1. 案例三：
 type IsOptional<T> = T extends { [k: string]: infer U } ? undefined extends U ? true : false : never;

interface Person {
  name: string;
  age?: number;
}

const person1: Person = { name: "Alice" };
const person2: Person = { name: "Bob", age: 30 };

const isOptional1: IsOptional<typeof person1> = true; // true
const isOptional2: IsOptional<typeof person2> = true; // false

在这个例子中，我们定义了一个 IsOptional 类型，它接受一个泛型类型参数 T。这个类型参数代表一个对象类型，我们通过 T extends { [k: string]: infer U } 这个条件语句来判断 T 是否是一个对象类型，并提取其属性类型 U。然后，我们再使用 undefined extends U ? true : false 来判断属性类型 U 是否包含 undefined，如果包含则返回 true，否则返回 false。最后，如果 T 是一个对象类型，则返回 true 或 false 类型，否则返回 never 类型。

然后，我们定义了一个 Person 接口，它包含一个必须属性 name 和一个可选属性 age。我们声明了两个变量 person1 和 person2，分别表示一个只有必须属性的 Person 对象和一个同时包含必须属性和可选属性的 Person 对象。

最后，我们使用 IsOptional 和 IsOptional 分别获取这两个对象的属性是否可选，并将它们声明为 true 或 false 类型。这样就可以根据对象类型的属性是否可选来确定返回类型。

2. 根据条件类型判断函数参数类型

  1. 案例一：
type FunctionReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

定义了FunctionReturnType条件类型，它会检查类型T是否为函数类型，如果是则通过infer获取函数的返回值类型R，否则返回never类型。具体案例如下：

type FRT1 = FunctionReturnType<() => number> //number

type FRT2 = FunctionReturnType<(x: string, y: number) => string[]> //string

type FRT3 = FunctionReturnType<() => void>//void

type FRT4 = FunctionReturnType<() => {}>//{}

type FRT5 = FunctionReturnType<1>//never
  1. 案例二：
 type ArgumentType<T> = T extends (arg: infer U) => any ? U : never;

const foo = (arg: string) => {
  return arg.toUpperCase();
}

const str: ArgumentType<typeof foo> = "hello"; // string

在这个例子中，我们定义了一个 ArgumentType 类型，它接受一个泛型类型参数 T。这个类型参数代表一个函数类型，我们通过 T extends (arg: infer U) => any 这个条件语句来判断 T 是否是一个函数类型，并提取其参数类型 U。如果 T 是一个函数类型，则返回参数类型 U，否则返回 never 类型。

然后，我们定义了一个 foo 函数，它接受一个字符串类型的参数，并将其转换为大写字母。我们使用 typeof 操作符来获取 foo 函数的类型，并通过 ArgumentType 来获取其参数类型。

  1. 案例三：

下面的示例演示在协变位置上同一类型变量的多个候选类型将会被推断为联合类型：

type Foo<T> = T extends { a: infer U, b: infer U } ? U : never;
type t1 = Foo<{ a: string, b: string }>;  // string
type t2 = Foo<{ a: string, b: number }>;  // string | number

同样在逆变位置上同一类型变量的多个候选类型将会被推断为交叉类型：

type Bar<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
type t1 = Bar<{ a: (x: string) => void, b: (x: string) => void }>;  // string
type t2 = Bar<{ a: (x: string) => void, b: (x: number) => void }>;  // string & number

协变与逆变

3. 根据类型的属性来判断函数的返回类型

假设我们有一个名为 fetchData 的函数，它从服务器获取数据并将其解析为特定类型。我们希望函数的返回类型根据请求的不同而有所区别，因此我们可以使用条件类型来实现这一点。

interface User {
  name: string;
  age: number;
}

interface Post {
  title: string;
  content: string;
}

type RequestType = "user" | "post";

const fetchData = <T extends RequestType>(type: T): T extends "user" ? User : Post => {
  // 根据请求类型获取不同的数据
  if (type === "user") {
    return { name: "John", age: 30 } as any;
  } else {
    return { title: "TypeScript is awesome", content: "..." } as any;
  }
}

const user = fetchData("user"); // User 类型
const post = fetchData("post"); // Post 类型

在这个例子中，我们定义了一个名为 fetchData的函数，它接受一个泛型类型参数 T，这个类型参数代表请求的类型，可以是 user 或 post。我们使用条件类型 T extends “user” ? User : Post 来决定返回的类型，如果请求的类型是 user，则返回 User 类型，否则返回 Post 类型。

然后，我们在函数体中根据请求类型获取不同的数据，返回的类型也会根据请求类型发生变化。

最后，我们分别调用 fetchData函数，并将其返回值分别赋值给 user 和 post 变量，这样就可以根据请求类型获取不同的数据，并且保证返回类型的正确性。

4. 根据类型的成员来判断其他类型

假设我们有一个名为 HasName 的类型，它表示一个具有 name 属性的类型。我们希望定义一个名为 PickWithName 的类型，它接受一个泛型类型参数 T，并从中选择具有 name 属性的子类型。

interface User {
  name: string;
  age: number;
}

interface Post {
  title: string;
  content: string;
}

type HasName = { name: string };

type PickWithName<T> = T extends HasName ? T : never;

type UserWithName = PickWithName<User>; // User 类型
type PostWithName = PickWithName<Post>; // never 类型

在这个例子中，我们定义了一个 HasName类型，它代表具有 name属性的类型。然后，我们定义了一个名为 PickWithName 的类型，它接受一个泛型类型参数 T，并使用条件类型 T extends HasName ? T : never 来判断 T 是否具有 name属性，如果是，则返回 T，否则返回 never 类型。

最后，我们分别使用 PickWithName 类型别名 PickWithName 来选择具有 name属性的子类型，并将其分别赋值给 UserWithName 和 PostWithName 变量。

5. 根据类型的可选属性来添加或删除属性修饰符

假设我们有一个名为 Person 的类型，它有两个属性 name 和 age，其中 name 属性是必需的，而 age 属性是可选的。我们希望定义一个名为 MakeFieldsOptional 的类型，它接受一个泛型类型参数 T，并将 T 中所有可选属性的修饰符从必需改为可选，将所有必需属性的修饰符保持不变。

type Person = {
  name: string;
  age?: number;
};

type MakeFieldsOptional<T> = {
  [P in keyof T]?: T[P];
};

type OptionalPerson = MakeFieldsOptional<Person>; // { name?: string; age?: number; }

在这个例子中，我们首先定义了一个 Person 类型，它有一个必需的 name 属性和一个可选的 age 属性。

然后，我们定义了一个名为 MakeFieldsOptional 的类型，它使用映射类型 [P in keyof T]?: T[P]，将 T 中所有可选属性的修饰符从必需改为可选，将所有必需属性的修饰符保持不变。

最后，我们使用 MakeFieldsOptional 类型别名来将 Person 类型中所有可选属性的修饰符从必需改为可选，将其赋值给 OptionalPerson 变量。

6. 元组转为联合类型 tuple转union

[string, number] -> string | number

type ElementOf<T> = T extends Array<infer P> ? P : never;
type Tuple = [string, number];
type TupleToUnion = ElementOf<Tuple>; // type TupleToUnion = string | number

7. 联合类型转成交叉类型

string | number -> string & number

type T1 = { name: string };
type T2 = { age: number };
type ToIntersection<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
// 由于U需要同时满足T1的定义、T2的定义，因此U需要包含T1、T2所有的类型，因此T3就是T1 & T2
type T3 = ToIntersection<{ a: (x: T1) => void, b: (x: T2) => void }>; // type T3 = T1 & T2

重点：

  • U extends any 是具有分布式有条件类型特性，因为待检查类型 U 为裸类型
  • (U extends any ? (k: U) => void : never) extends ((k: infer I)=> void) 最后一个 extends 前面作为待检查类型，因为被函数包装，因此不具有分布式有条件类型特性
   type UnionToIntersection<U> = ((k: string) => void | (k: number) => void) extends ((k: infer I) => void) ? I : never;

根据 逆变特性 推断出的 I 应该具备 string 和 number 的类型，故为交叉类型 string & number，而该交叉类型在 vscode 中表现为 never

六、结合keyof关键字

1. 获取对象属性类型

keyof主要是获取某个对象/类型的属性名来构成新类型。我们可以使用条件类型和 keyof 关键字来获取对象的属性。具体案例如下：

type PropertyType<T, K extends keyof T> = K extends keyof T ? T[K] : never;

上面代码定义了类型为PropertyType<T, K extends keyof T>，通过检查K是否是T的一个属性名，如果是则返回该属性类型，否则返回never。

type Obj = { a: string; b: number };
type A = PropertyType<Obj, "a">; // string
type B = PropertyType<Obj, "c">; // never

2. 实现映射类型

映射类型是泛型类型的一种，可用于把原有的对象类型映射成新的对象类型。我们可以使用条件类型和 keyof关键字来实现Partial类型，Partial类型是TS工具类之一。具体案例如下：

type Partial<T> = {
 [K in keyof T]? : T[K]
}

定义类型Partial，遍历T中所有属性，然后通过?将所有属性变成可选属性。

type obj = {a:string,b:number}
type R = Partial<obj>//{a?:string,b?:number}

注意：Partial是TS的工具类，所以声明Partial是会报错的，可以换个标识符名称。
在这里插入图片描述

七、内置条件类型

 // 找出T中不包含U的部分
  type Diff<T, U> = T extends U ? never : T;
  type R1 = Diff<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R1: 'd'
  // 由于U中的'a','b','c'都是T中的子类型，因此R1的类型就是'd'

  // 找出T中包含U的部分
  type Filter<T, U> = T extends U ? T : never;
  type R2 = Filter<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R2: 'a' | 'b' | 'c'

1. Exclude

  • 从T中排除掉U，和上面的Diff相同
type Exclude<T, U> = T extends U ? never : T;
type R3 = Exclude<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R3: 'd'

2. Extract

  • 从T中找出包含U的部分，和上面的filter相同
type Extract<T, U> = T extends U ? T : never;
type R4 = Extract<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R4: 'a' | 'b' | 'c'

3. NonNullable

  • 从T中找出不为null和undefined的参数
type NonNullable<T> = T extends null | undefined ? never : T;
type R5 = NonNullable<'a' | null | undefined | 'd'>; // R5: 'a' | 'd'

4. ReturnType 和 Parameters

  • infer：推断的意思，是一个关键字
  • ReturnType 获取函数的返回类型
  • Parameters 获取函数参数类型，返回一个元组
  // 1.1
  // ReturnType 获取函数的返回类型
  type ReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
  function getUser() {
    return {
      name: '张三',
      age: 10
    }
  }
  // TS可以从参数中推断返回值类型
  type ReturnUser = ReturnType<typeof getUser>; // type ReturnUser = {name: string;age: number;}

  // 1.2
  // Parameters 获取函数参数类型，返回一个元组
  type Parameters<T> = T extends (...args: infer P) => any ? P : never;
  function getPerson(a: string, b: number) {
    return {
      name: '李四',
      age: 18
    }
  }
  type ParamsType = Parameters<typeof getPerson>; // type ParamsType = [a: string, b: number]

5. InstanceType 和 ConstructorParameters

  • InstanceType 获取构造函数的实例类型
  • ConstructorParameters 获取类的构造函数的参数类型
namespace e {
  class Person {
    name: string;
    constructor(name: string) {
      this.name = name;
    }
    getName() {
      console.log(this.name);
    }
  }

  // ConstructorParameters 获取类的构造函数的参数类型
  type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (
    ...args: infer P) => any ? P : never;
  type Params = ConstructorParameters<typeof Person> // type Params = [name: string]

  // InstanceType 获取构造函数的实例类型
  type Instance = InstanceType<typeof Person>;
  let instance: Instance = {
    name: '张三',
    getName() {}
  }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/768687.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

一探究竟：人工智能、机器学习、深度学习

一探究竟：人工智能、机器学习、深度学习

一、人工智能 1.1 人工智能是什么&#xff1f; 1956年在美国Dartmounth 大学举办的一场研讨会中提出了人工智能这一概念。人工智能&#xff08;Artificial Intelligence&#xff09;&#xff0c;简称AI&#xff0c;是计算机科学的一个分支&#xff0c;它企图了解智能的实质&am…
阅读更多...
拦截器是什么

拦截器是什么

拦截器 package com.qf.config;import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;public class MyIntercep…
阅读更多...
VSCode下载安装（保姆级--一步到胃）

VSCode下载安装（保姆级--一步到胃）

前言 Visual Studio Code&#xff08;简称“VSCode” &#xff09;是Microsoft在2015年4月30日Build开发者大会上正式宣布一个运行于 Mac OS X、Windows和 Linux 之上的&#xff0c;针对于编写现代Web和云应用的跨平台源代码编辑器&#xff0c;可在桌面上运行&#xff0c;并且…
阅读更多...
零售行业门店综合管理系统怎么做？店务系统有什么功能？

零售行业门店综合管理系统怎么做？店务系统有什么功能？

线下门店则变成了零售行业的重要战场。今时不同往日&#xff0c;现在线下门通常得需要兼多种角色&#xff0c;无论是对于门店员工还是管理者来说经营难度和工作强度都在显著增加。像传统落后的门店管理存在着库存失衡&#xff0c;服务效率低&#xff0c;信息滞后且准确度低等问…
阅读更多...
使用IDEA社区版创建SpringBoot项目

使用IDEA社区版创建SpringBoot项目

文章目录 1.关于IDEA社区版的版本2.下载Spring Boot Helper3.创建项目4.配置Maven国内源4.1找不到settings.xml的情况4.2找得到settings.xml的情况 4.3删除repository目录下的所有文件和目录5.加载项目6.解决org.springframework.boot:spring-boot-starter-parent:pom:2.7.13.R…
阅读更多...
学员管理系统——面向对象

学员管理系统——面向对象

文章目录 前言基本思路Student.pymain.pyStudentManage.py菜单 menu()根据菜单实现程序的大概逻辑add_student() 添加学员信息delete_student() 删除学员信息modify_studnet() 修改学员信息search_student() 查找学员信息print_student() 显示所有学员信息save_student() 保存学…
阅读更多...
使用qt的webengine让客户端嵌入网页

使用qt的webengine让客户端嵌入网页

前提 在windows下&#xff0c;qt下 界面 用qt的界面设计拉上一些东西&#xff0c;一个跑按钮&#xff0c;一个刷新按钮&#xff0c;一个弹出框按钮&#xff0c;地址栏是为了填入新的https地址&#xff0c;一个verticalLayout是为了限定webengine的显示&#xff0c;需要包含 …
阅读更多...
UI界面中的图标设计趋势与最佳实践

UI界面中的图标设计趋势与最佳实践

作为UI设计师&#xff0c;在日常的工作中&#xff0c;避免不了做图标规范。今天跟大家聊一聊&#xff0c;UI设计中的图标设计。 规范的重要性不用多说了&#xff0c;没有规范多个设计师绘制的图标会有很多差异&#xff0c;描边粗细、角度、圆角度等等。今天的文章和大家聊一下…
阅读更多...
opencv-14 图像加密和解密

opencv-14 图像加密和解密

在OpenCV中&#xff0c;图像加密和解密是通过对图像像素进行一系列的变换和操作来实现的 通过按位异或运算可以实现图像的加密和解密。 通过对原始图像与密钥图像进行按位异或&#xff0c;可以实现加密&#xff1b;将加密后的图像与密钥图像再次进行按位异或&#xff0c;可以实…
阅读更多...
MFC第十八天 非模式对话框、对话框颜色管理、记事本项目（查找替换、文字和背景色、Goto(转到)功能的开发）

MFC第十八天 非模式对话框、对话框颜色管理、记事本项目（查找替换、文字和背景色、Goto(转到)功能的开发）

文章目录 非模式对话框非模式对话框的特点非模式对话框与QQ聊天窗口开发非模态对话框&#xff08;Modeless Dialog&#xff09;和模态对话框&#xff08;Modal Dialog&#xff09;区别 记事本开发CFindReplaceDialog类的成员查找替换(算法分析)使用RichEdit控件 开发Goto(转到)…
阅读更多...
监控程序可以监控网站的端口流量情况

监控程序可以监控网站的端口流量情况

https://github.com/louislam/uptime-kuma
阅读更多...
Django实现接口自动化平台（十三）接口模块Interfaces序列化器及视图【持续更新中】

Django实现接口自动化平台（十三）接口模块Interfaces序列化器及视图【持续更新中】

相关文章&#xff1a; Django实现接口自动化平台&#xff08;十二&#xff09;自定义函数模块DebugTalks 序列化器及视图【持续更新中】_做测试的喵酱的博客-CSDN博客 本章是项目的一个分解&#xff0c;查看本章内容时&#xff0c;要结合整体项目代码来看&#xff1a; pytho…
阅读更多...
3.13 Bootstrap 页面标题(Page Header)

3.13 Bootstrap 页面标题(Page Header)

文章目录 Bootstrap 页面标题&#xff08;Page Header&#xff09; Bootstrap 页面标题&#xff08;Page Header&#xff09; 页面标题&#xff08;Page Header&#xff09;是个不错的功能&#xff0c;它会在网页标题四周添加适当的间距。当一个网页中有多个标题且每个标题之间…
阅读更多...
MotionBert论文解读及详细复现教程

MotionBert论文解读及详细复现教程

MotionBert&#xff1a;统一视角学习人体运动表示 通过学习人体运动表征&#xff0c;论文原作者提出了处理以人为中心的视频任务的统一方法。使用双流时空transformer&#xff08;DSTformer&#xff09;网络实现运动编码器&#xff0c;能够全面、自适应地捕获骨骼关节之间的远…
阅读更多...
数据结构——六大排序 （插入，选择，希尔，冒泡，堆，快速排序）

数据结构——六大排序 （插入，选择，希尔，冒泡，堆，快速排序）

1. 插入排序 1.1基本思路 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中&#xff0c;直到所有的记录插入完为止&#xff0c;得到一个新的有序序列 我们熟知的斗地主就是一个插入排序 1.2 代码实现 我们这里将一个无序数组变成有序数组 插入排序时…
阅读更多...
CVE-2017-15715

CVE-2017-15715

CVE-2017-15715 一、环境搭建二、漏洞原理三、漏洞复现 一、环境搭建 如下介绍kali搭建的教程 cd ~/vulhub/httpd/CVE-2017-15715 // 进入指定环境 docker-compose build // 进行环境编译 docker-compose up -d // 启动环境docker-compose ps使用这条命令查看当前正在…
阅读更多...
放射显影多肽1778691-88-5，DOTA Methyltetrazine ，四甲基四嗪修饰大环配体

放射显影多肽1778691-88-5，DOTA Methyltetrazine ，四甲基四嗪修饰大环配体

资料编辑|陕西新研博美生物科技有限公司小编MISSwu​ 中文名称&#xff1a;四甲基四嗪修饰大环配体 英文名称&#xff1a;FOLATE-NOTA&#xff0c; Methyltetrazine-DOTA 规格标准&#xff1a;1g、5g、10g CAS&#xff1a;1778691-88-5 分子式&#xff1a;C37H52N12O12 分子量…
阅读更多...
学习opencv.js之基本使用方法（读取，显示，灰度化，边缘检测，特征值点检测）

学习opencv.js之基本使用方法（读取，显示，灰度化，边缘检测，特征值点检测）

opencv.js是什么 OpenCV.js 是 OpenCV&#xff08;Open Source Computer Vision Library&#xff09;的 JavaScript 版本。OpenCV 是一个广泛使用的计算机视觉和图像处理库&#xff0c;提供了一系列功能强大的算法和工具&#xff0c;用于处理图像、视频、特征提取、对象识别等…
阅读更多...
php裁剪图片，并给图片加上水印

php裁剪图片，并给图片加上水印

本次以裁剪四个图片为例&#xff0c;图片如下 代码如下 public function cutImg($imgUrl){try{// 读取原始图片$src_img imagecreatefromjpeg($imgUrl);// 获取原始图片的宽度和高度$src_width imagesx($src_img);$src_height imagesy($src_img);// 计算每个部分的宽度和高…
阅读更多...
【C语言督学训练营 第十九天】关于C语言语法的一些补充

【C语言督学训练营 第十九天】关于C语言语法的一些补充

文章目录 1.条件运算符与逗号运算符2.自增自减运算符3.位运算4.switch do-while补充5.二维数组&二级指针6.总结 1.条件运算符与逗号运算符 条件运算符是C语言中唯一的一种三目运算符。三目运算符代表有三个操作数;双目运算符代表有两个操作数,如逻辑与运算符就是双目运算符…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023