普通视图

发现新文章，点击刷新页面。

今天 — 2026年2月19日首页

每日一题-计数二进制子串🟢

LeetCode 每日一题题解

2026年2月19日 00:00

给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。

重复出现（不同位置）的子串也要统计它们出现的次数。

示例 1：

输入：s = "00110011"
输出：6
解释：6 个子串满足具有相同数量的连续 1 和 0 ："0011"、"01"、"1100"、"10"、"0011" 和 "01" 。
注意，一些重复出现的子串（不同位置）要统计它们出现的次数。
另外，"00110011" 不是有效的子串，因为所有的 0（还有 1 ）没有组合在一起。

示例 2：

输入：s = "10101"
输出：4
解释：有 4 个子串："10"、"01"、"10"、"01" ，具有相同数量的连续 1 和 0 。

提示：

1 <= s.length <= 10⁵
s[i] 为 '0' 或 '1'

TypeScript 类型体操练习笔记（二）

掘金前端

作者我不吃饼干

2026年2月18日 23:53

进度（90 /188）

其中标记 ※ 的是我认为比较难或者涉及新知识点的题目

刷题也许没有什么意义，但是喜欢一个人思考一整天的灵光一现，也喜欢看到新奇的答案时的恍然大悟，仅此而已。

42. Medium - 1130 - ReplaceKeys ※

实现一个类型 ReplaceKeys，用于替换联合类型中的键，如果某个类型不包含该键则跳过替换。该类型接受三个参数。

一开始我只是想这么写，我想分布式条件类型 + Pick + Omit 来实现。

type ReplaceKeys<U, T, Y> = U extends any 
 ? Omit<U, T & keyof U> & Pick<Y, T & keyof U & keyof Y>
 : any

理论上 case1 是能通过的，但是一直报错。然后我又试了一下，看来判断的 Equal 不认为这两种是相等的：

type T1 = { a: number }
type T2 = { b: number }
type E = Equal<T1 & T2, { a: number, b: number }> // false

不过还是有办法的，我们可以通过一层映射把交叉类型拍平：

type IntersectionToObj<T> = {
  [K in keyof T]: T[K]
}
type E1 = Equal<IntersectionToObj<T1 & T2>, { a: number, b: number }> // true

不过我试了下第二个 case 还是不太好实现，那就直接用映射类型来解决。

利用分布式特性处理联合元素，然后遍历 U 的属性然后按要求进行处理即可。

type ReplaceKeys<U, T, Y> = U extends any
  ? {
    [K in keyof U]: K extends T ? (K extends keyof Y ? Y[K] : never) : U[K]
  }
  : never // 不会进入这个分支

但是看到别人的答案我又开始困惑了：

type ReplaceKeys<U, T, Y> = {
  [K in keyof U]: K extends T ? (K extends keyof Y ? Y[K] : never) : U[K]
}

查了半天只有这个 pr ，官方文档里也没有明确说明。

形如 { [P in keyof T]: X } 的映射类型（其中 T 是类型参数）被称为 isomorphic mapped type（同构映射类型），因为它会产生一个与 T 具有相同结构的类型。通过此 PR，我们使同构映射类型的实例化在联合类型上具有分布性。

43. Medium - 1367 - Remove Index Signature 移除索引签名 ※

实现 RemoveIndexSignature<T>，移除一个对象类型的索引签名。

索引签名（Index Signature）是 TypeScript 中用于描述对象中未明确声明的属性的类型。它允许你定义一个对象可以有任意数量的属性，只要这些属性的键和值符合指定的类型。

interface StringDictionary {
  [key: string]: string;  // 索引签名
  // 表示该对象可以有任意多个属性，键必须是 string 类型，值也必须是 string 类型。
}

和索引签名对应的是具体属性，这两种也可以混合使用，但是具体属性的类型必须是索引签名类型的子类型：

interface MixedType {
  // 具体属性
  name: string;
  age: number;
  // 索引签名
  [key: string]: string | number;  // 必须包含具体属性的类型
}

要处理这个问题，就要针对索引签名的特点，他是一个宽泛的类型（string/number/symbol），而具体属性是一个字面量类型，比如 "name" ，我们依次判断它是否为 string，number 或 symbol 都不是则证明是具体属性，否则为索引签名。

type RemoveIndexSignature<T> = {
  [K in keyof T as
  string extends K 
    ? never
    : number extends K 
      ? never
      : symbol extends K 
        ? never
        : K
  ]: T[K]
}`

在评论区看到一个很天才的解法

type RemoveIndexSignature<T, P = PropertyKey> = {
  [K in keyof T as P extends K? never : K extends P ? K : never]: T[K]
}

其中 PropertyKey 上是 TypeScript 的内置类型 type PropertyKey = string | number | symbol;。它的判断过程如下：

P extends K ? never : (K extends P ? K : never)  /* P = string | number | symbol */

// becomes
(string | number | symbol) extends K ? never : (K extends P ? K : never)

// becomes
| string extends K ? never : (K extends string ? K : never)
| number extends K ? never : (K extends number ? K : never)
| symbol extends K ? never : (K extends symbol ? K : never)

本质上和我们上面的写法是一样的，但是利用条件类型的分布性，一下子判断了三种类型。୧(๑•̀◡•́๑)૭

44. Medium - 1978 - Percentage Parser 百分比解析器

实现类型 PercentageParser。根据规则 /^(\+|\-)?(\d*)?(\%)?$/ 匹配类型 T。

匹配的结果由三部分组成，分别是：[正负号, 数字, 单位]，如果没有匹配，则默认是空字符串。

type Sign = '+' | '-'
type PercentageParser<A extends string> =
  A extends `${infer F}%`
  /** 存在 % */
    ? F extends `${infer S extends Sign}${infer N}`
      ? [S, N, '%']
      : ['', F, '%']
  /** 不存在 % */
    : A extends `${infer S extends Sign}${infer N}`
      ? [S, N, '']
      : ['', A, '']

题目不难，加几个分支判断就可以了。或者这样写优雅一点（大概）：

type SignParser<A extends string> = A extends `${infer S extends '+' | '-'}${infer N}` ? [S, N] : ['', A]
type PercentageParser<A extends string> = A extends `${infer F}%` ? [...SignParser<F>, '%'] : [...SignParser<A>, '']

45. Medium - 2070 - Drop Char 删除字符

从字符串中剔除指定字符。

type DropChar<S, C> = S extends `${infer F}${infer R}`
  ? F extends C 
    ? DropChar<R, C>
    : `${F}${DropChar<R, C>}`
  : ''

没有新的知识点，简单题。

46. Medium - 2257 - MinusOne 减一 ※

给定一个正整数作为类型的参数，要求返回的类型是该数字减 1。

有点意思的一道题目，没有新的知识点，但是类似于算法中的模拟题。需要递归加不同情况的判断，复杂度较高。

我先想到了一个比较搞的办法，生成长度为 T 的数组，然后移除一个元素，再获取数组长度。

type MakeArray<T extends number, R extends any[] = []> =
  R['length'] extends T ? R : MakeArray<T, [...R, any]>
type MinusOne<T extends number> = 
  MakeArray<T> extends [infer _F, ...infer R] ? R['length'] : never

1000 以内是可行的，但是再大就会出现错误：

type A = MakeArray<1101> // error: 类型实例化过深，且可能无限。ts(2589)

那么只能换一种方法，通过模拟减法的方式实现，枚举最后一位即可，如果最后一位大于 0 则只需要操作最后一位，否则需要递归处理：

type MinusOne2String<T extends string> =
  T extends `${infer F}0` // 如果最后一位是0，则把此位改为9，然后递归处理（题目限定了是正数）
  ? `${MinusOne2String<F>}9`
  : T extends `${infer F}9` // 其他情况直接把最后一位减一
  ? `${F}8`
  : T extends `${infer F}8`
  ? `${F}7`
  : T extends `${infer F}7`
  ? `${F}6`
  : T extends `${infer F}6`
  ? `${F}5`
  : T extends `${infer F}5`
  ? `${F}4`
  : T extends `${infer F}4`
  ? `${F}3`
  : T extends `${infer F}3`
  ? `${F}2`
  : T extends `${infer F}2`
  ? `${F}1`
  : T extends `${infer F}1`
  ? `${F}0`
  : '0'
// 100-1=099 这种情况需要删除前导零
type removeLeadZero<T extends string> = 
  T extends '0' ? '0' : T extends `0${infer R}` ? removeLeadZero<R> : T 
// 删除前导零后，转换为数字类型
type MinusOne<T extends number> = 
  removeLeadZero<MinusOne2String<`${T}`>> extends `${infer X extends number}` ? X : 0

47. Medium - 2595 - PickByType

从 T 中选择可赋值给 U 的属性类型集合。

type PickByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never ]: T[K]
}

送分题，知识点前面的题目都有涉及。

48. Medium - 2688 - StartsWith

实现 StartsWith<T, U>,接收两个 string 类型参数,然后判断 T 是否以 U 开头,根据结果返回 true 或 false。

type StartsWith<T extends string, U extends string> =
  T extends `${U}${infer F}` ? true : false

送分题+1，模板字符串类型基础。

49. Medium - 2693 - EndsWith

实现 EndsWith<T, U>,接收两个 string 类型参数,然后判断 T 是否以 U 结尾,根据结果返回 true 或 false。

type EndsWith<T extends string, U extends string> =
  T extends `${string}${U}` ? true : false

50. Medium - 2757 - PartialByKeys

实现一个通用的 PartialByKeys<T, K>，它接收两个类型参数 T 和 K。

K 指定应设置为可选的 T 的属性集。当没有提供 K 时，它就和普通的 Partial<T> 一样使所有属性都是可选的。

前面已经讲过 IntersectionToObj 这个小技巧，这里就比较简单了，其中 Partial 是内置的工具类型，可以把一个对象类型的全部属性都变成可选。

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

type PartialByKeys<T , K extends keyof T = keyof T> = 
  IntersectionToObj< Omit<T, K> & Partial<Pick<T, K>> >

51. Medium - 2759 - RequiredByKeys

实现一个通用的 RequiredByKeys<T, K>，它接收两个类型参数 T 和 K。

K 指定应设为必选的 T 的属性集。当没有提供 K 时，它就和普通的 Required<T> 一样使所有的属性成为必选的。

和 PartialByKeys 本质上没有什么区别，Required 也是内置的工具类型，可以把一个对象类型的全部属性，用于将一个类型 T 中的所有属性转换为‌必填属性（即移除其可选性 ?）。

type IntersectionToObj<T> = {
  [K in keyof T]: T[K]
}
type RequiredByKeys<T, K extends keyof T = keyof T> =
  IntersectionToObj<Omit<T, K> & Required<Pick<T, K>>>

52. Medium - 2793 - Mutable ※

实现一个通用的类型 Mutable<T>，使类型 T 的全部属性可变（非只读）。

这题不难，但是涉及到映射类型的一个语法，之前没有涉及过。mapped-types

type Mutable<T extends object> ={
  -readonly [K in keyof T]: T[K]
}

53. Medium - 2852 - OmitByType

从类型 T 中选择不可赋值给 U 的属性成为一个新的类型。

直到了 as 和 Mapped Types 的用法，这也很简单，和之前的 Omit 没什么区别。

type OmitByType<T, U> = {
  [K in keyof T as T[K] extends U ? never : K]: T[K]
}

54. Medium - 2946 - ObjectEntries

实现 Object.entries 的类型版本。

首先这题需要应用分布式条件类型，所以需要先构造一个由类型key组成的联合类型 U 然后 U extends ... 触发分布式。

type ObjectEntries<T, U = keyof T> =
  U extends keyof T ? [U, T[U]] : never

不过有个case 过不去。

type eq = Equal<ObjectEntries<Partial<Model>>, ModelEntries> // false
type o = ObjectEntries<Partial<Model>>
// ["name", string | undefined] | ["age", number | undefined] | ["locations", string[] | null | undefined]

可以看到由于 Partial 导致每个类型都多了一个 undefined。很明显这里需要 Required，但是需要先了解一下它的特性。

type r1 = Required<{ key?: undefined }> // {key: never}
type r2 = Required<{ key: undefined }> // {key: undefined}
type r3 = Required<{ key: string | undefined }> // {key: string | undefined}
type r4 = Required<{ key?: string | undefined }>  // {key:string}

可以看到在存在 ? 时，Required 会删除类型中的 undefined，否则不会。

而此题的要求是：如果类型存在 ? 就删除 undefined，但是如果类型只有 undefined 则不处理。我只能说，题本身不难，但是描述的不清楚，只能看用例。

type ObjectEntries<T, U = keyof T> =
  U extends keyof T 
    ? [U, [T[U]] extends [undefined] ? undefined : Required<T>[U]] 
    : never

55. Medium - 3062 - Shift

实现类型版本的 Array.shift。

type Shift<T extends any[]> = T extends [infer F, ...infer R] ? [...R] : []

infer 的基础应用，在最前面的 First of Array 就了解过了。

56. Medium - 3188 - Tuple to Nested Object

给一个只包含字符串类型的元组 T 和一个类型 U 递归构建一个对象。

type TupleToNestedObject<T extends string[], U> = 
  T extends [infer F extends string, ...infer R extends string[]] 
    ? Record<F, TupleToNestedObject<R, U>> : U

每次提取数组中第一个元素，然后把该元素作为键，递归构造的对象作为值。

57. Medium - 3192 - Reverse

实现类型版本的数组反转 Array.reverse

type Reverse<T extends any[]> = T extends [infer F, ...infer R] 
  ? [...Reverse<R>, F]
  : []

使用递归的方式，每次都把第一个元素移到最后一个。

58. Medium - 3196 - Flip Arguments

实现 lodash 中 _.flip 函数的类型版本。

类型转换函数 FlipArguments<T> 要求函数类型 T，并返回一个新的函数类型，该类型具有与 T 相同的返回类型但参数顺序颠倒。

type FlipArguments<T extends Function> = 
  T extends (...args: infer P) => infer R ? (...args: Reverse<P>) => R : never

通过 infer 获取函数的参数和返回值，并且通过上一题实现的 Reverse 将参数反转。

59. Medium - 3243 - FlattenDepth

递归展开数组至指定深度

首先需要实现一个铺平一次的函数，这个比较简单

type FlattenOnce<A extends any[]> = A extends [infer F, ...infer R]
  ? F extends any[] ? [...F, ...FlattenOnce<R>] : [F, ...FlattenOnce<R>]
  : []

TypeScript 中无法进行数字计算，我们可以通过邪修实现，这点我们在前面的 MinusOne 已经实现，所以这里直接引用 MinusOne 就可以了。

type FlattenDepth<T extends any[], depth extends number = 1> =
  depth extends 0 // 判断深度为零，则已经不需要铺平了
  ? T
  : FlattenOnce<T> extends T // 判断是否铺平前后的结果一致，一致则不需要再处理了
    ? T 
    : FlattenDepth<FlattenOnce<T>, MinusOne<depth>>

当然我们可以用之前在里面用过的用数组记录数字的方法，只不过 TypeScript 中数组长度有限制，当然这一题中是没有问题的，嵌套最多才 5 层

type FlattenDepth<T extends any[], depth = 1, depArr extends any[] = []> = 
  depArr['length'] extends depth
    ? T 
    : FlattenOnce<T> extends T ? T : FlattenDepth<FlattenOnce<T>, depth, [...depArr, any]>

60. Medium - 3326 - BEM style string

使用块（Block）、元素（Element）、修饰符（Modifier）命名（BEM）是 CSS 中类的一种流行命名约定。

例如，块组件表示为 btn，依赖于块的元素表示为 btn__price，更改块样式的修饰符表示为 btn-big 或 btn__prise-warning。

实现 BEM<B，E，M>，从这三个参数生成字符串并集。其中 B 是字符串文字，E 和 M 是字符串数组（可以为空）。

// 把A和B连接，先把B处理为联合类型，然后用S连接
type JoinWithSeparator<A extends string, B extends string[], S extends string, B2Union extends string = B[number]> = 
  B2Union extends any ? `${A}${S}${B2Union}` : never

type BEM<B extends string, E extends string[], M extends string[]> = 
  E['length'] extends 0 // 判断E是否为空
    ? JoinWithSeparator<B, M, '--'> // 如果E为空, B和M连接
    : M['length'] extends 0 // 判断M是否为空
      ? JoinWithSeparator<B, E, '__'> // E不为空，M为空，把B和M连接
      : JoinWithSeparator<JoinWithSeparator<B, E, '__'>, M, '--'> // 都不为空，先把B和E连接，然后再加上M

需要写一个辅助工具类型 JoinWithSeparator 用于连接一个字符和数组，逻辑有点小复杂，已经加了完整注释。

61. Medium - 3376 - InorderTraversal

实现二叉树中序遍历的类型版本。

如果会中序遍历二叉树这题就不难了，不会的可以先学学数据结构。

type InorderTraversal<T extends TreeNode | null> = 
 T extends null 
   ? [] 
   : [...InorderTraversal<T['left']>, T['val'], ...InorderTraversal<T['right']>]

比较麻烦的是，T extends null 语法无法判断第二个分支中 T 不为空，所以可以反过来，判断 T 是否为 TreeNode。

type InorderTraversal<T extends TreeNode | null> =
  T extends TreeNode
  ? [
    ...InorderTraversal<T['left']>,
    T['val'],
    ...InorderTraversal<T['right']>
  ] : []

62. Medium - 4179 - Flip

实现 just-flip-object 的类型版本（把类型的键和值类型反转）。

type Flip<T> = {
  [K in keyof T as T[K] extends number | string | boolean ? `${T[K]}` : never]: K
}

为了保证 T[K] 类型正确，加了一个 extends number | string | boolean 的限制。

63. Medium - 4182 - Fibonacci Sequence 斐波那契序列 ※

实现一个通用的 Fibonacci<T>，它接受一个数字 T 并返回其相应的斐波纳契数。

序列开始：1、1、2、3、5、8、13、21、34、55、89、144...

首先斐波纳契公式 f(n)=f(n-1)+f(n-2) 可以递归实现。由于 TypeScript 类型无法使用加法，所以我们通过数组的元素个数来变向进行计算，至于减法可以复用之前实现的 MinusOne。

type FibonacciArray<T extends number, A extends any[] = []> =
    T extends 1
    ? [any]
    : T extends 2
      ? [any]
      : [...FibonacciArray<MinusOne<MinusOne<T>>>, ...FibonacciArray<MinusOne<T>>]
type Fibonacci<T extends number> = FibonacciArray<T>['length']

看了下别人的答案，优化空间还是很大的，下面是正向计算，Index 表示计算到了第 n 个数字，Cur 表示 f(n)，Prev 表示 f(n-1)

type Fibonacci<
  T extends number,
  Index extends any[] = [any, any],
  Cur extends any[] = [any],
  Prev extends any[] = [any]
> =
  T extends 1 | 2
    ? 1
    : Index['length'] extends T
      ? Cur['length']
      : Fibonacci<T, [...Index, any], [...Cur, ...Prev], Cur>

64. Medium - 4260 - AllCombinations ※

实现 AllCombinations<S> 类型，该类型返回使用 S 中的字符所组成的所有字符串，每个字符最多使用一次。

type AllCombinations<S extends string, P extends string = ''> =
  S extends `${infer F}${infer R}` 
    ? '' | F | `${F}${AllCombinations<`${R}${P}`>}` // S[0] 开头的所有排列情况
      | AllCombinations<R, `${P}${F}`> // 除了 S[0] 开头以外的所有情况
    : ''

很有意思的题目，实现一个字符串中字符的所有组合。我的解法是 AllCombinations<S, P> 表示获取字符串 ${S}${P} 中，以 S 每个字母开头的全排列组合。

所以 AllCombinations<S, ''> 就是答案，而它等于 S[0] 为开头的所有情况，再加上 AllCombinations<S.split(1), S[0]>（伪代码示例）

而 S[0] 为开头的所有情况，就是求 S[0] 连接剩余字符的全排列，也就是 AllCombinations<S.split(1), ''>

65. Medium - 4425 - Greater Than

在本次挑战中，你需要实现一个类似 T > U 的类型： GreaterThan<T, U> 负数无需考虑。

这种题我可以说不难，就是有点恶心。我不喜欢！下面的代码我加了注释，应该可以看懂。

type LengthOfString<S extends string> = Split<S>['length'];
type FirstOfString<S extends string> = S extends `${infer F}${infer R}`
  ? F
  : never;
type RestOfString<S extends string> = S extends `${infer F}${infer R}`
  ? R
  : never;

type Split<S extends string> = S extends `${infer F}${infer R}`
  ? [F, ...Split<R>]
  : [];

// 比较10以内数字的大小
type GreaterThanDigit<
  T extends string,
  U extends string,
  D extends string = '9876543210'
> = D extends `${infer F}${infer R}` // 从大到小依次比较每一个数字
  ? F extends U // 如果先匹配了U 则证明T≤U 返回false
    ? false
    : F extends T // 如果先匹配了T 则证明T>U 返回true
      ? true
      : GreaterThanDigit<T, U, R> // 再尝试匹配下一个数字
  : false;

type GreaterThanString<
  T extends string,
  U extends string,
  LEN_T extends number = LengthOfString<`${T}`>, // T的长度
  LEN_U extends number = LengthOfString<`${U}`>, // U的长度
  FIRST_T extends string = FirstOfString<`${T}`>, // T的长度
  FIRST_U extends string = FirstOfString<`${U}`> // U的长度
> = LEN_U extends LEN_T // 判断长度是否相同
  ? LEN_T extends 1 // 判断相同，长度是否为1
    ? GreaterThanDigit<FIRST_T, FIRST_U> // 长度为1 直接比较首位
    : FIRST_T extends FIRST_U // 长度相同，且长度不为1，依次比较每一位，先判断首位
      ? GreaterThanString<RestOfString<`${T}`>, RestOfString<`${U}`>> // 首位相同 则比较下一位
      : GreaterThanDigit<FIRST_T, FIRST_U> // 首位不同，则比较大小
  : GreaterThan<LEN_T, LEN_U>; // 如果长度不相同，则长度大的数字更大

type GreaterThan<T extends number, U extends number> = GreaterThanString<
  `${T}`,
  `${U}`
>;

66. Medium - 4471 - Zip

在这个挑战中，你需要实现一个类型 Zip<T, U>，其中 T 和 U 必须是元组。

就是把所有元组中的第1项组成结果中的第1项，所有元组中的第2项组成结果中的第2项....所有元组中的第n项组成结果中的第n项，比较简单。

type Zip<T extends any[], U extends any[]> = T extends [infer TF, ...infer TR]
  ? U extends [infer UF, ...infer UR]
    ? [[TF, UF], ...Zip<TR, UR>]
    : []
  : [];

67. Medium - 4484 - IsTuple ※

实现类型 IsTuple, 传入类型 T 并返回类型 T 是否为一个元组类型。

A tuple type is another sort of Array type that knows exactly how many elements it contains, and exactly which types it contains at specific positions.

元组类型 是另一种“数组”类型，它确切地知道它包含多少元素，以及它在特定位置包含哪些类型。

T extends readonly any[] 判断 T 为数组和元素，添加 readonly 可以兼容 readonly [1] 这种情况。

根据定义可以知道，元组类型的长度是固定的，所以 Tuple['length'] 是一个具体的数字，而数组 A['length'] 是 number。

因此，可以通过 number extends T['length'] 来判断 T 是否为元组而不是数组。

type IsTuple<T> = [T] extends [never]
  ? false
  : T extends readonly any[]
    ? number extends T['length']
      ? false
      : true
    : false;

68. Medium - 4499 - Chunk

你知道 lodash 吗？Chunk 是其中一个非常有用的函数，现在让我们实现它。Chunk<T，N> 接受两个必需的类型参数，T 必须是元组，N 必须是大于等于 1 的整数。

type Chunk<
  T extends any[],
  N extends number,
  Result extends any[] = [],
  Current extends any[] = []
> = T extends [infer F, ...infer R] // 判断是否还有元素
  ? Current['length'] extends N // 有元素，判断当前的块已经满了
    ? Chunk<R, N, [...Result, Current], [F]> // 如果当前的块已经满了，把它放进结果数组里
    : Chunk<R, N, Result, [...Current, F]> // 没有满，就把元素放进当前块
  : Current['length'] extends 0 // T中所有元素都处理完了，判断当前块中是否有元素
    ? Result // 当前块为空的，直接返回结果
    : [...Result, Current]; // 否则把当前块放进结果，再返回

69. Medium - 4518 - Fill

Fill 是一个通用的 JavaScript 函数，现在来实现它的类型版本。Fill<T, N, Start?, End?> 接受 4 个参数, T 是一个元组，N 是任意类型， Start and End 是大于等于 0 的整数。把 T 在 [Start.End] 范围内的元素都替换为 N。

type Fill<
  T extends unknown[], // 原数组
  N, // 要填充的类型
  Start extends number = 0, // 开始下标
  End extends number = T['length'], // 结束下标
  Result extends unknown [] = [], // 结果数组
  In extends boolean = false // 是否在[Start,End]范围内
> = T extends [infer F, ...infer R] // T是否存在第一个元素
  ? Result['length'] extends End // 先判断是否为结束下标
    ? Fill<R, N, Start, End, [...Result, F], false>  // 是结束下标，则证明已经填充完了，后面填充T的内容就行
    : Result['length'] extends Start // 不是，判断是否为开始下标
      ? Fill<R, N, Start, End, [...Result, N], true>  // 是开始下标，则填充N，用IN=true表示已经在范围内
      : In extends true // 判断是否在[Start,End]范围内
        ? Fill<R, N, Start, End, [...Result, N], true> // 如果在范围内 则用N填充
        : Fill<R, N, Start, End, [...Result, F], false> // 不在范围内 用T中内容填充
  : Result // 处理完成，返回结果

70. Medium - 4803 - Trim Right

实现 TrimRight<T>，它接收确定的字符串类型并返回一个新的字符串，其中新返回的字符串删除了原字符串结尾的空白字符串。

type TrimRight<S extends string> =
  S extends `${infer F}${' '|'\n'|'\t'}` ? TrimRight<F> : S

71. Medium - 5117 - Without

实现一个像 Lodash.without 函数一样的泛型 Without<T, U>，它接收数组类型的 T 和数字或数组类型的 U 为参数，会返回一个去除 U 中元素的数组 T。

Equal 是玄学，别问，用就完事了。

type Includes<T extends readonly unknown[], U> = 
  T extends [infer F, ...infer Rest]
    ? Equal<F, U> extends true ? true : Includes<Rest, U>
    : false;

type Without<T extends any[], U extends any> = T extends [infer F, ...infer R]
  ? U extends any[]
    ? Includes<U, F> extends true // 如果U是数组类型，使用Includes判断是否包含
      ? Without<R, U>
      : [F, ...Without<R, U>]
    : F extends U // 如果U不是数组，直接判断
      ? Without<R, U>
      : [F, ...Without<R, U>]
  : []

评论区看到了更好的解法，先转成联合在判断是否包含

type ToUnion<T extends any> = T extends any[] ? T[number] : T;

type Without<T extends any[], U extends any> = 
T extends [infer F, ...infer R]
  ? F extends ToUnion<U>
    ? Without<R, U>
    : [F, ...Without<R, U>]
  : [];

72. Medium - 5140 - Without

实现 Math.trunc 的类型版本，它接受字符串或数字，并通过删除所有小数来返回数字的整数部分。

简单的模板字符串模式匹配，注意 '-.3' 这种删除小数点后面的内容后需要手动补 0。

type Trunc<T extends number | string> =
  `${T}` extends `${infer F}.${infer _}`
    ? F extends '-' | ''
      ? `${F}0`
      : F
    : `${T}`;

73. Medium - 5153 - IndexOf

实现类型版本的 Array.indexOf，indexOf<T, U> 接受两个参数，数组 T 和任意类型 U 返回 U 在 T 中第一次出现的下标，不存在返回 -1。

type IndexOf<T extends any[], U, Pre extends any[] = []> =
  T extends [infer F, ...infer R]
    ? Equal<F, U> extends true
      ? Pre['length']
      : IndexOf<R, U, [...Pre, F]>
    : -1

因为 TypeScript 无法进行计算，所以思路还是一样，用一个数组 Pre 记录已经遍历了几个数字，用 Pre['length'] 计数。

74. Medium - 5310 - Join

实现类型版本的 Array.join，Join<T, U>接受一个数组 T 字符串或数字类型 U，返回 T 中的所有元素用 U 连接的字符串，U 默认为 ','。

type Join<
  T extends any[],
  U extends string | number = ',',
  Pre extends string = ''
> = T extends [infer F, ...infer R]
  ? Pre extends ''
    ? Join<R, U, `${F & string}`>
    : Join<R, U, `${Pre}${U}${F & string}`>
  : Pre;

其中 F & string 因为 F 的类型是 any 但是只有一部分类型可以反正模板字符串中，所以这里类型会把报错，通过 & string 限制为 string。

75. Medium - 5317 - LastIndexOf

实现类型版本的 Array.lastIndexOf, LastIndexOf<T, U> 接受数组 T, any 类型的 U, 如果 U 存在于 T 中, 返回 U 在数组 T 中最后一个位置的索引, 不存在则返回 -1

type LastIndexOf<
  T extends any[],
  U,
  Pre extends any[] = [],
  Result extends number = -1
> = T extends [infer F, ...infer R]
? Equal<F, U> extends true // 判断当前的值是否为U
  ? LastIndexOf<R, U, [...Pre, F], Pre['length']> // 如果是，更新Result，然后继续处理
  : LastIndexOf<R, U, [...Pre, F], Result>
: Result

76. Medium - 5360 - Unique 数组去重

实现类型版本的 Lodash.uniq 方法，Unique 接收数组类型 T, 返回去重后的数组类型。

type Includes<T extends readonly unknown[], U> = 
  T extends [infer F, ...infer Rest]
    ? Equal<F, U> extends true ? true : Includes<Rest, U>
    : false;

type Unique<
  T extends any[],
  Result extends any[] = [],
> = T extends [infer F, ...infer R]
  ? Includes<Result, F> extends true
    ? Unique<R, Result>
    : Unique<R, [...Result, F]>
  : Result;

顺便评论区看到另一个，算是利用分布式条件类型更简洁的实现了 Includes 。

type Unique<T, U = never> =
  T extends [infer F, ...infer R]
    ? true extends (U extends U ? Equal<U, [F]> : never)
      ? Unique<R, U>
      : [F, ...Unique<R, U | [F]>]
    : []

77. Medium - 5821 - MapTypes 映射类型

实现 MapTypes<T, R>，把对象 T 中的类型根据 R 做转换。比如 R 为 { mapFrom: string, mapTo: boolean } 表示把 T 中的所有 string 类型改为 boolean。

// 根据类型映射的定义 和 原类型 获取映射后的类型
type getType<T extends { mapFrom: any; mapTo: any }, P> = T extends any
  ? T['mapFrom'] extends P // 利用分布式条件类型，依次判断是否匹配mapFrom类型
    ? T['mapTo'] // 符合的返回对应的mapTo类型
    : never // 不符合返回never 其他类型和never联合只会剩下其他类型
  : never;

type MapTypes<T, R extends { mapFrom: any; mapTo: any }> = {
  // { mapFrom: T[K]; mapTo: any } 是否可以赋值给R
  [K in keyof T]: { mapFrom: T[K]; mapTo: any } extends R
    ? getType<R, T[K]> // 证明他的类型匹配了mapFrom 需要返回对应的mapTo
    : T[K]; // 否则不需要调整
};

78. Medium - 7544 - Construct Tuple 构造元组 ※

构造一个给定长度的元组。

这题简直太水了，递归就可以 TypeScript 最多递归到999层，所以最后一个 case Expect<Equal<ConstructTuple<1000>['length'], 1000>> 会失败。

// 生成元组，但是TS递归只能到999
type ConstructTuple<
  N extends string | number,
  Result extends any[] = []
> = `${Result['length']}` extends `${N}`
  ? Result
  : ConstructTuple<N, [...Result, unknown]>;

但是，让 9999 成功才是有趣的问题，我开始一直想二分，把自己困住了，后来发现简单的按位计算就可以。参考github.com/type-challe…

// 生成元组，但是TS递归只能到999
type ConstructTupleSimple<
  N extends string | number,
  Result extends any[] = []
> = `${Result['length']}` extends `${N}`
  ? Result
  : ConstructTupleSimple<N, [...Result, unknown]>;

// 把数组T中的元素数量*10
type Multi10<T extends any[]> = [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T]

// 从左到右依次计算 例321 = (3*10+2)*10+1
type ConstructTuple<
  L extends number | string,
  Result extends any[] = []
> = `${L}` extends `${infer F}${infer R}`
  ? ConstructTuple<R, [...Multi10<Result>, ...ConstructTupleSimple<F>]>
  : Result;

79. Medium - 8640 - Number Range

构造指定范围内所有数字的联合。

好像在前面做过类似的题目……通过 Arr 辅助记录遍历数字，Result 记录结果，InRange 记录是否在范围内。

type NumberRange<L, H, Arr extends any[] = [], Result = never, InRange = false> =
  Arr['length'] extends L
    ? NumberRange<L, H, [...Arr, unknown], L | Result, true>
    : Arr['length'] extends H
      ? Result | H
      : InRange extends true
        ? NumberRange<L, H, [...Arr, unknown], Arr['length'] | Result, InRange>
        : NumberRange<L, H, [...Arr, unknown], Result, InRange>

也有更直观的解法：

type ConstructUnion<
  N extends string | number,
  Result extends any[] = []
> = `${Result['length']}` extends `${N}`
  ? Result[number]
  : ConstructUnion<N, [...Result, Result['length']]>;

type NumberRange<L extends number, H extends number> =
  | Exclude<ConstructUnion<H>, ConstructUnion<L>>
  | L
  | H;

80. Medium - 8767 - Combination ※

给定一个字符串数组，执行排列和组合。

// 计算T中每个元素开头的 T和P中所有元素组成的全部组合
type Combination<T extends string[], P extends string[] = []> =
  T extends [infer F extends string, ...infer R extends string[]] // 先计算F开头的所有情况
    ? `${F} ${Combination<[...R, ...P]>}` // 首个单词是F 然后连接 其他单词的全排列
        //（在模板字符串中的联合类型会自动生成所有情况的模板字符串结果的联合）
      | Combination<R, [...P, F]> // 继续计算单个单词剩余单词的情况
      | F // 单个单词
    : never

这种题我每次都要花一个小时做出来，头痛。看了下别人的解法很nb，利用联合类型分布式遍历 T，少了一次递归。

type Combination<T extends string[], All = T[number], Item = All>
  = Item extends string
    ? Item | `${Item} ${Combination<[], Exclude<All, Item>>}`
    : never

81. Medium - 8987 - Subsequence ※

给定一个唯一元素数组，返回所有可能的子序列。

type UnionAddT<U extends any[], T> = U extends any ? [T, ...U] : never
type Subsequence<T extends any[]> = T extends [infer F, ...infer R]
  ? Subsequence<R> // 不包含F的所有子序列
      | UnionAddT<Subsequence<R>, F> // 包含F的所有子序列
  : []

这题不难，加了重点标识因为新学了一个语法：当 ... 展开运算符应用到联合类型时，会对联合类型的每个成员分别展开，然后将结果再组成联合类型。

type Subsequence<T extends unknown[]> = T extends [infer X, ...infer Y]
  ? [X, ...Subsequence<Y>] | Subsequence<Y>
  : [];

82. Medium - 9142 - CheckRepeatedChars

实现类型 CheckRepeatedChars<S> 返回 S 中是否有重复字符。

type CheckRepeatedChars<
  T extends string,
  visited = never
> = T extends `${infer F}${infer R}`
  ? F extends visited
    ? true
    : CheckRepeatedChars<R, visited | F>
  : false;

83. Medium - 9286 - FirstUniqueCharIndex

给一个字符串 S 找到第一个不重复字符的下标，不存在返回 -1。 (灵感来自 leetcode 387)（笑死力扣都来了）

type GetRepectChars<T extends string, Once = never, Repeated = never> = 
  T extends `${infer F}${infer R}`
    ? F extends Once
      ? GetRepectChars<R, Once, Repeated | F>
      : GetRepectChars<R, Once | F, Repeated>
    : Repeated

type FirstUniqueCharIndex<T extends string, Repeated = GetRepectChars<T>, Index extends any[] = []> = 
  T extends `${infer F}${infer R}`
    ? F extends Repeated
      ? FirstUniqueCharIndex<R, Repeated, [...Index, F]>
      : Index['length']
    : -1

84. Medium - 9616 - Parse URL Params

实现类型层面的解析器，把 URL 中的参数字符串解析为一个联合。

type ParseUrlParams<T extends string> = T extends `${infer F}/${infer R}`
  ? F extends `:${infer P}`
    ? P | ParseUrlParams<R>
    : ParseUrlParams<R>
  : T extends `:${infer P}`
    ? P
    : never

85. Medium - 9896 - GetMiddleElement

通过实现一个 GetMiddleElement 方法，获取数组的中间元素，用数组表示

如果数组的长度为奇数，则返回中间一个元素如果数组的长度为偶数，则返回中间两个元素

type GetMiddleElement<T extends any[]> =
  T['length'] extends 0 | 1 | 2
    ? T
    : T extends [infer _L, ...infer M, infer _R]
      ? GetMiddleElement<M>
      : []

简单，每次删除前后两个元素，对长度为 0 1 2 的数组特殊处理。

86. Medium - 9898 - Appear only once

找出目标数组中只出现过一次的元素。例如：输入 [1,2,2,3,3,4,5,6,6,6]，输出 [1,4,5]。

// 判断联合类型T中是否存在U
type Includes<T, U> = true extends (T extends any ? Equal<T, U> : never)
  ? true
  : false;

type FindEles<
  T extends any[],
  Pre extends any[] = [],
  Res extends any[] = []
> = T extends [infer F, ...infer R]
  ? Includes<[...Pre, ...R][number], F> extends true // 如果F前后组成的数组是否包含F
    ? FindEles<R, [...Pre, F], Res> // 包含F 则证明不唯一 结果不添加F
    : FindEles<R, [...Pre, F], [...Res, F]> // 不包含F 则证明唯一 结果添加F
  : Res; // 遍历结束 返回结果

87. Medium - 9989 - Count Element Number To Object

通过实现一个 CountElementNumberToObject 方法，统计数组中相同元素的个数。

// 把数组拍平，然后把其中never元素删除
type Flatten<A extends any[]> = A extends [infer F, ...infer R] // 判断A存在第一个元素F
  ? [F] extends [never]
    ? [...Flatten<R>]
    : F extends any[]
    ? [...Flatten<F>, ...Flatten<R>]
    : [F, ...Flatten<R>]
  : [];

type CountElementNumberToObject<
  T extends any[],
  // 辅助计数的对象，用数组计数
  Aux extends Record<string | number, any[]> = {},
  // T中有嵌套数组 把T拍平
  F extends (number | string)[] = Flatten<T>
> = F extends [
  infer L extends number | string, // 取第一个元素
  ...infer R extends (number | string)[]
]
  ? CountElementNumberToObject<
      R,
      {
        [K in keyof Aux | L]: K extends L // 遍历Aux中key
          ? L extends keyof Aux // 遍历到L了，判断如果L是Aux中的key
            ? [...Aux[K], unknown] // 就在对应数组中添加一个元素
            : [unknown] // 不在就新创建一个数组，添加一个元素
          : Aux[K]; // 其他key不做处理
      }
    >
  : {
      [K in keyof Aux]: Aux[K]['length']; // 把结果映射为数组的长度
    };

88. Medium - 10969 - Integer ※

请完成类型 Integer<T>，类型 T 继承于 number，如果 T 是一个整数则返回它，否则返回 never。

type OnlyZero<T> = T extends `${infer F}${infer R}`
  ? F extends '0'
    ? OnlyZero<R>
    : false
  : true;
type ToNumber<T> = T extends `${infer N extends number}` ? N : never;
type Integer<T> = T extends number
  ? number extends T
    ? never
    : `${T}` extends `${infer Int}.${infer Deci}`
    ? OnlyZero<Deci> extends true
      ? ToNumber<Int>
      : never
    : T
  : never;

虽然也不算难，但是一看评论区天塌了。

type Integer<T extends string | number> = number extends T
  ? never
  : `${T}` extends `${string}.${string}`
  ? never
  : T;
// 或者这样，因为 bigint 只能是整数
type Integer<T extends number> = `${T}` extends `${bigint}` ? T : never

我自己试了一下数字转字符串，发现对于多余的小数点后面的 0 会被删除。

type x = `${1.0}` // "1"
type x1 = `${1.2}` // "1.2"
type x2 = `${1.200}` // "1.2"

89. Medium - 16259 - ToPrimitive ※

把对象中类型为字面类型（标签类型）的属性，转换为基本类型。

这题可以枚举类型实现，不过就没啥意思了。看到一种神奇的解法，用到了 valueOf。

type ToPrimitive<T> = T extends (...args: any[]) => any
  ? Function
  : T extends object
    ? { [K in keyof T]: ToPrimitive<T[K]> }
    : T extends { valueOf: () => infer R }
      ? R
      : T;

JavaScript 中每个包装对象都有 valueOf() 方法：

String.prototype.valueOf() 返回 string
Number.prototype.valueOf() 返回 number
...

在 TypeScript 类型系统中，我们可以利用这个特性：

interface String {
  /** Returns the primitive value of the specified object. */
  valueOf(): string;
  // ... 其他方法
}

// string 字面量类型
type Test1 = 'Tom' extends { valueOf: () => infer R } ? R : never
// 'Tom' 是 string 类型，string 有 valueOf(): string
// R = string ✅

type Test2 = 30 extends { valueOf: () => infer R } ? R : never
// 30 是 number 类型，number 有 valueOf(): number
// R = number ✅

90. Medium - 17973 - DeepMutable

实现一个通用的 DeepMutable ，它使对象的每个属性，及其递归的子属性 - 可变。

type DeepMutable<T extends object> = {
  -readonly [K in keyof T]: T[K] extends (...args: any) => any 
    ? T[K]
    : T[K] extends object ? DeepMutable<T[K]> : T[K]
}

LeetCode 每日一题题解
一次遍历，简洁写法（Python/Java/C++/C/Go/JS/Rust）endlesscheng
2026年2月7日 09:22

一次遍历，简洁写法（Python/Java/C++/C/Go/JS/Rust）

LeetCode 每日一题题解

作者 endlesscheng

2026年2月7日 09:22

题意：子串必须形如 $\underbrace{\texttt{0}\cdots \texttt{0}}{k\ 个\ \texttt{0}}\underbrace{\texttt{1}\cdots \texttt{1}}{k\ 个\ \texttt{1}}$ 或者 $\underbrace{\texttt{1}\cdots \texttt{1}}{k\ 个\ \texttt{1}}\underbrace{\texttt{0}\cdots \texttt{0}}{k\ 个\ \texttt{0}}$。只能有一段 $\texttt{0}$ 和一段 $\texttt{1}$，不能是 $\texttt{00111}$（两段长度不等）或者 $\texttt{010}$（超过两段）等。

例如 $s = \texttt{001110000}$，按照连续相同字符，分成三组 $\texttt{00},\texttt{111},\texttt{0000}$。

在前两组中，我们可以得到 $2$ 个合法子串：$\texttt{0011}$ 和 $\texttt{01}$。
在后两组中，我们可以得到 $3$ 个合法子串：$\texttt{111000}$、$\texttt{1100}$ 和 $\texttt{10}$。

一般地，遍历 $s$，按照连续相同字符分组，计算每一组的长度。设当前这组的长度为 $\textit{cur}$，上一组的长度为 $\textit{pre}$，那么当前这组和上一组，能得到 $\min(\textit{pre},\textit{cur})$ 个合法子串，加到答案中。

###py

class Solution:
    def countBinarySubstrings(self, s: str) -> int:
        n = len(s)
        pre = cur = ans = 0
        for i in range(n):
            cur += 1
            if i == n - 1 or s[i] != s[i + 1]:
                # 遍历到了这一组的末尾
                ans += min(pre, cur)
                pre = cur
                cur = 0
        return ans

###java

class Solution {
    public int countBinarySubstrings(String S) {
        char[] s = S.toCharArray();
        int n = s.length;
        int pre = 0;
        int cur = 0;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            cur++;
            if (i == n - 1 || s[i] != s[i + 1]) {
                // 遍历到了这一组的末尾
                ans += Math.min(pre, cur);
                pre = cur;
                cur = 0;
            }
        }
        return ans;
    }
}

###cpp

class Solution {
public:
    int countBinarySubstrings(string s) {
        int n = s.size();
        int pre = 0, cur = 0, ans = 0;
        for (int i = 0; i < n; i++) {
            cur++;
            if (i == n - 1 || s[i] != s[i + 1]) {
                // 遍历到了这一组的末尾
                ans += min(pre, cur);
                pre = cur;
                cur = 0;
            }
        }
        return ans;
    }
};

###c

#define MIN(a, b) ((b) < (a) ? (b) : (a))

int countBinarySubstrings(char* s) {
    int pre = 0, cur = 0, ans = 0;
    for (int i = 0; s[i]; i++) {
        cur++;
        if (s[i] != s[i + 1]) {
            // 遍历到了这一组的末尾
            ans += MIN(pre, cur);
            pre = cur;
            cur = 0;
        }
    }
    return ans;
}

###go

func countBinarySubstrings(s string) (ans int) {
n := len(s)
pre, cur := 0, 0
for i := range n {
cur++
if i == n-1 || s[i] != s[i+1] {
// 遍历到了这一组的末尾
ans += min(pre, cur)
pre = cur
cur = 0
}
}
return
}

###js

var countBinarySubstrings = function(s) {
    const n = s.length;
    let pre = 0, cur = 0, ans = 0;
    for (let i = 0; i < n; i++) {
        cur++;
        if (i === n - 1 || s[i] !== s[i + 1]) {
            // 遍历到了这一组的末尾
            ans += Math.min(pre, cur);
            pre = cur;
            cur = 0;
        }
    }
    return ans;
};

###rust

impl Solution {
    pub fn count_binary_substrings(s: String) -> i32 {
        let s = s.as_bytes();
        let n = s.len();
        let mut pre = 0;
        let mut cur = 0;
        let mut ans = 0;
        for i in 0..n {
            cur += 1;
            if i == n - 1 || s[i] != s[i + 1] {
                // 遍历到了这一组的末尾
                ans += pre.min(cur);
                pre = cur;
                cur = 0;
            }
        }
        ans
    }
}

复杂度分析

时间复杂度：$\mathcal{O}(n)$，其中 $n$ 是 $s$ 的长度。
空间复杂度：$\mathcal{O}(1)$。

专题训练

见下面双指针题单的「六、分组循环」。

分类题单

如何科学刷题？

我的题解精选（已分类）

欢迎关注 B站@灵茶山艾府

【计数二进制子串】计数

LeetCode 每日一题题解

作者 ikaruga

2020年8月10日 10:00

思路

对于 000111 来说，符合要求的子串是 000111 0011 01
1. 不难发现，如果我们找到一段类似 000111 的数据，就可以用来统计答案
2. 即这样前面是连续 0/1 后面是连续 1/0 的数据
3. 这一段的所有 3 个子串，取决于前面 0/1 的个数和后面 1/0 的个数
4. 即 min(cnt_pre, cnt_cur)

图片.png

遍历时，当数字再一次改变时（或到达结尾时），意味着一段结束，并能得到这一段前面和后面数字的个数。
1. 如 11101 来说，当我们遍历到最后的 1 时，1110 就是一段可以用来统计答案的数据
2. 而末尾的 01 则是另一段可以用来统计答案的数据

< 图片.png ,>

小技巧，对字符串结尾增加一个字符，可以将判断逻辑写在一个地方

答题

class Solution {
public:
    int countBinarySubstrings(string s) {
        int ans = 0;
        char last = '-';
        int cnt_pre = 0;
        int cnt_cur = 0;

        s += '-';
        for (auto c : s) {
            if (last != c) {
                last = c;
                ans += min(cnt_pre, cnt_cur);
                cnt_pre = cnt_cur;
                cnt_cur = 0;
            }
            cnt_cur++;
        }
        return ans;
    }
};

致谢

感谢您的观看，如果感觉还不错就点个赞吧，关注我的力扣个人主页，欢迎热烈的交流！

计数二进制子串

LeetCode 每日一题题解

作者 LeetCode-Solution

2020年8月9日 21:31

方法一：按字符分组

思路与算法

我们可以将字符串 $s$ 按照 $0$ 和 $1$ 的连续段分组，存在 $\textit{counts}$ 数组中，例如 $s = 00111011$，可以得到这样的 $\textit{counts}$ 数组：$\textit{counts} = {2, 3, 1, 2}$。

这里 $\textit{counts}$ 数组中两个相邻的数一定代表的是两种不同的字符。假设 $\textit{counts}$ 数组中两个相邻的数字为 $u$ 或者 $v$，它们对应着 $u$ 个 $0$ 和 $v$ 个 $1$，或者 $u$ 个 $1$ 和 $v$ 个 $0$。它们能组成的满足条件的子串数目为 $\min { u, v }$，即一对相邻的数字对答案的贡献。

我们只要遍历所有相邻的数对，求它们的贡献总和，即可得到答案。

不难得到这样的实现：

###C++

class Solution {
public:
    int countBinarySubstrings(string s) {
        vector<int> counts;
        int ptr = 0, n = s.size();
        while (ptr < n) {
            char c = s[ptr];
            int count = 0;
            while (ptr < n && s[ptr] == c) {
                ++ptr;
                ++count;
            }
            counts.push_back(count);
        }
        int ans = 0;
        for (int i = 1; i < counts.size(); ++i) {
            ans += min(counts[i], counts[i - 1]);
        }
        return ans;
    }
};

###Java

class Solution {
    public int countBinarySubstrings(String s) {
        List<Integer> counts = new ArrayList<Integer>();
        int ptr = 0, n = s.length();
        while (ptr < n) {
            char c = s.charAt(ptr);
            int count = 0;
            while (ptr < n && s.charAt(ptr) == c) {
                ++ptr;
                ++count;
            }
            counts.add(count);
        }
        int ans = 0;
        for (int i = 1; i < counts.size(); ++i) {
            ans += Math.min(counts.get(i), counts.get(i - 1));
        }
        return ans;
    }
}

###JavaScript

var countBinarySubstrings = function(s) {
    const counts = [];
    let ptr = 0, n = s.length;
    while (ptr < n) {
        const c = s.charAt(ptr);
        let count = 0;
        while (ptr < n && s.charAt(ptr) === c) {
            ++ptr;
            ++count;
        }
        counts.push(count);
    }
    let ans = 0;
    for (let i = 1; i < counts.length; ++i) {
        ans += Math.min(counts[i], counts[i - 1]);
    }
    return ans;
};

###Go

func countBinarySubstrings(s string) int {
    counts := []int{}
    ptr, n := 0, len(s)
    for ptr < n {
        c := s[ptr]
        count := 0
        for ptr < n && s[ptr] == c {
            ptr++
            count++
        }
        counts = append(counts, count)
    }
    ans := 0
    for i := 1; i < len(counts); i++ {
        ans += min(counts[i], counts[i-1])
    }
    return ans
}

###C

int countBinarySubstrings(char* s) {
    int n = strlen(s);
    int counts[n], counts_len = 0;
    memset(counts, 0, sizeof(counts));
    int ptr = 0;
    while (ptr < n) {
        char c = s[ptr];
        int count = 0;
        while (ptr < n && s[ptr] == c) {
            ++ptr;
            ++count;
        }
        counts[counts_len++] = count;
    }
    int ans = 0;
    for (int i = 1; i < counts_len; ++i) {
        ans += fmin(counts[i], counts[i - 1]);
    }
    return ans;
}

###Python

class Solution:
    def countBinarySubstrings(self, s: str) -> int:
        counts = []
        ptr, n = 0, len(s)
        
        while ptr < n:
            c = s[ptr]
            count = 0
            while ptr < n and s[ptr] == c:
                ptr += 1
                count += 1
            counts.append(count)
        
        ans = 0
        for i in range(1, len(counts)):
            ans += min(counts[i], counts[i - 1])
        
        return ans

###C#

public class Solution {
    public int CountBinarySubstrings(string s) {
        List<int> counts = new List<int>();
        int ptr = 0, n = s.Length;
        
        while (ptr < n) {
            char c = s[ptr];
            int count = 0;
            while (ptr < n && s[ptr] == c) {
                ptr++;
                count++;
            }
            counts.Add(count);
        }
        
        int ans = 0;
        for (int i = 1; i < counts.Count; i++) {
            ans += Math.Min(counts[i], counts[i - 1]);
        }
        
        return ans;
    }
}

###TypeScript

function countBinarySubstrings(s: string): number {
    const counts: number[] = [];
    let ptr = 0, n = s.length;
    
    while (ptr < n) {
        const c = s[ptr];
        let count = 0;
        while (ptr < n && s[ptr] === c) {
            ptr++;
            count++;
        }
        counts.push(count);
    }
    
    let ans = 0;
    for (let i = 1; i < counts.length; i++) {
        ans += Math.min(counts[i], counts[i - 1]);
    }
    
    return ans;
}

###Rust

impl Solution {
    pub fn count_binary_substrings(s: String) -> i32 {
        let mut counts = Vec::new();
        let bytes = s.as_bytes();
        let n = bytes.len();
        let mut ptr = 0;
        
        while ptr < n {
            let c = bytes[ptr];
            let mut count = 0;
            while ptr < n && bytes[ptr] == c {
                ptr += 1;
                count += 1;
            }
            counts.push(count);
        }
        
        let mut ans = 0;
        for i in 1..counts.len() {
            ans += counts[i].min(counts[i - 1]);
        }
        
        ans
    }
}

这个实现的时间复杂度和空间复杂度都是 $O(n)$。

对于某一个位置 $i$，其实我们只关心 $i - 1$ 位置的 $\textit{counts}$ 值是多少，所以可以用一个 $\textit{last}$ 变量来维护当前位置的前一个位置，这样可以省去一个 $\textit{counts}$ 数组的空间。

代码

###C++

class Solution {
public:
    int countBinarySubstrings(string s) {
        int ptr = 0, n = s.size(), last = 0, ans = 0;
        while (ptr < n) {
            char c = s[ptr];
            int count = 0;
            while (ptr < n && s[ptr] == c) {
                ++ptr;
                ++count;
            }
            ans += min(count, last);
            last = count;
        }
        return ans;
    }
};

###Java

class Solution {
    public int countBinarySubstrings(String s) {
        int ptr = 0, n = s.length(), last = 0, ans = 0;
        while (ptr < n) {
            char c = s.charAt(ptr);
            int count = 0;
            while (ptr < n && s.charAt(ptr) == c) {
                ++ptr;
                ++count;
            }
            ans += Math.min(count, last);
            last = count;
        }
        return ans;
    }
}

###JavaScript

var countBinarySubstrings = function(s) {
    let ptr = 0, n = s.length, last = 0, ans = 0;
    while (ptr < n) {
        const c = s.charAt(ptr);
        let count = 0;
        while (ptr < n && s.charAt(ptr) === c) {
            ++ptr;
            ++count;
        }
        ans += Math.min(count, last);
        last = count;
    }
    return ans;
};

###Go

func countBinarySubstrings(s string) int {
    var ptr, last, ans int
    n := len(s)
    for ptr < n {
        c := s[ptr]
        count := 0
        for ptr < n && s[ptr] == c {
            ptr++
            count++
        }
        ans += min(count, last)
        last = count
    }

    return ans
}

###C

int countBinarySubstrings(char* s) {
    int ptr = 0, n = strlen(s), last = 0, ans = 0;
    while (ptr < n) {
        char c = s[ptr];
        int count = 0;
        while (ptr < n && s[ptr] == c) {
            ++ptr;
            ++count;
        }
        ans += fmin(count, last);
        last = count;
    }
    return ans;
}

###Python

class Solution:
    def countBinarySubstrings(self, s: str) -> int:
        ptr, n = 0, len(s)
        last, ans = 0, 0
        
        while ptr < n:
            c = s[ptr]
            count = 0
            while ptr < n and s[ptr] == c:
                ptr += 1
                count += 1
            ans += min(count, last)
            last = count
        
        return ans

###C#

public class Solution {
    public int CountBinarySubstrings(string s) {
        int ptr = 0, n = s.Length;
        int last = 0, ans = 0;
        
        while (ptr < n) {
            char c = s[ptr];
            int count = 0;
            while (ptr < n && s[ptr] == c) {
                ptr++;
                count++;
            }
            ans += Math.Min(count, last);
            last = count;
        }
        
        return ans;
    }
}

###TypeScript

function countBinarySubstrings(s: string): number {
    let ptr = 0, n = s.length;
    let last = 0, ans = 0;
    
    while (ptr < n) {
        const c = s[ptr];
        let count = 0;
        while (ptr < n && s[ptr] === c) {
            ptr++;
            count++;
        }
        ans += Math.min(count, last);
        last = count;
    }
    
    return ans;
}

###Rust

impl Solution {
    pub fn count_binary_substrings(s: String) -> i32 {
        let bytes = s.as_bytes();
        let n = bytes.len();
        let mut ptr = 0;
        let mut last = 0;
        let mut ans = 0;
        
        while ptr < n {
            let c = bytes[ptr];
            let mut count = 0;
            while ptr < n && bytes[ptr] == c {
                ptr += 1;
                count += 1;
            }
            ans += count.min(last);
            last = count;
        }
        
        ans
    }
}

复杂度分析

时间复杂度：$O(n)$。
空间复杂度：$O(1)$。

昨天 — 2026年2月18日首页

腾讯宣布：元宝DAU超5000万，MAU达1.14亿

36氪

2026年2月18日 21:42

2月18日，腾讯正式宣布，元宝日活跃用户（DAU）超5000万，月活跃用户（MAU）已达1.14亿。此前一天，腾讯发布的元宝分10亿现金红包活动报告显示，元宝春节主会场累计抽奖次数超36亿次，用户通过「创作」栏完成AI任务超10亿次。元宝21天内已迭代更新159项功能，今天元宝还公布了更多更新计划。正月初五，用户在元宝派内聊天，元宝会随机掉落红包。同时，在切换不同元宝派时，一起听不会掉线。正月十五元宵节，用户还可以在派里一起看湖南卫视元宵晚会直播。

深度解析 JWT：从 RFC 原理到 NestJS 实战与架构权衡

掘金前端

作者 NEXT06

2026年2月18日 21:22

1. 引言

HTTP 协议本质上是无状态（Stateless）的。在早期的单体应用时代，为了识别用户身份，我们通常依赖 Session-Cookie 机制：服务端在内存或数据库中存储 Session 数据，客户端浏览器通过 Cookie 携带 Session ID。

然而，随着微服务架构和分布式系统的兴起，这种有状态（Stateful）的机制暴露出了明显的弊端：Session 数据需要在集群节点间同步（Session Sticky 或 Session Replication），这极大地限制了系统的水平扩展能力（Horizontal Scaling）。

为了解决这一痛点，JSON Web Token（JWT）应运而生。作为一种轻量级、自包含的身份验证标准，JWT 已成为现代 Web 应用——特别是前后端分离架构与微服务架构中——主流的身份认证解决方案。本文将从原理剖析、NestJS 实战、架构权衡及高频面试考点四个维度，带你全面深入理解 JWT。

2. 什么是 JWT

JWT（JSON Web Token）是基于开放标准 RFC 7519 定义的一种紧凑且自包含的方式，用于在各方之间以 JSON 对象的形式安全地传输信息。

核心特性：

紧凑（Compact） ：体积小，可以通过 URL 参数、POST 参数或 HTTP Header 发送。
自包含（Self-contained） ：Payload 中包含了用户认证所需的所有信息，避免了多次查询数据库。

主要应用场景：

身份认证（Authorization） ：这是最常见的使用场景。一旦用户登录，后续请求将包含 JWT，允许用户访问该令牌允许的路由、服务和资源。
信息交换（Information Exchange） ：利用签名机制，确保发送者的身份是合法的，且传输的内容未被篡改。

3. JWT 的解剖学：原理详解

一个标准的 JWT 字符串由三部分组成，通过点（.）分隔：Header(请求头).Payload（载荷）.Signature（签名信息）。

3.1 Header（头部）

Header 通常包含两部分信息：令牌的类型（即 JWT）和所使用的签名算法（如 HMAC SHA256 或 RSA），一般会有多种算法，如果开发者无选择，那么默认是HMAC SHA256算法。

JSON

{
  "alg": "HS256",
  "typ": "JWT"
}

该 JSON 被 Base64Url 编码后，构成 JWT 的第一部分。

3.2 Payload（负载）

Payload 包含声明（Claims），即关于实体（通常是用户）和其他数据的声明。声明分为三类：

Registered Claims（注册声明） ：一组预定义的、建议使用的权利声明，如：
- iss (Issuer): 签发者
- exp (Expiration Time): 过期时间
- sub (Subject): 主题（通常是用户ID）
- aud (Audience): 受众
Public Claims（公共声明） ：可以由使用 JWT 的人随意定义。
Private Claims（私有声明） ：用于在同意使用这些定义的各方之间共享信息，如 userId、role 等。

架构师警示：
Payload 仅仅是进行了 Base64Url 编码（Encoding） ，而非 加密（Encryption） 。
这意味着，任何截获 Token 的人都可以通过 Base64 解码看到 Payload 中的明文内容。因此，严禁在 Payload 中存储密码、手机号等敏感信息。

3.3 Signature（签名）

签名是 JWT 安全性的核心。它是对前两部分（编码后的 Header 和 Payload）进行签名，以防止数据被篡改。

生成签名的公式如下（以 HMAC SHA256 为例）：

Code

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

原理解析：
服务端持有一个密钥（Secret），该密钥绝不能泄露给客户端。当服务端收到 Token 时，会使用同样的算法和密钥重新计算签名。如果计算出的签名与 Token 中的 Signature 一致，说明 Token 是由合法的服务端签发，且 Payload 中的内容未被篡改（完整性校验）。

4. 实战：基于 NestJS 实现 JWT 认证

NestJS 是 Node.js 生态中优秀的企业级框架。下面演示如何使用 @nestjs/jwt 和 @nestjs/passport 实现标准的 JWT 认证流程。

4.1 依赖安装

Bash

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt
npm install --save-dev @types/passport-jwt

4.2 Module 配置

在 AuthModule 中注册 JwtModule，配置密钥和过期时间。

TypeScript

// auth.module.ts
import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    PassportModule,
    JwtModule.register({
      secret: 'YOUR_SECRET_KEY', // 生产环境请使用环境变量
      signOptions: { expiresIn: '60m' }, // Token 有效期
    }),
  ],
  providers: [AuthService, JwtStrategy],
  exports: [AuthService],
})
export class AuthModule {}

4.3 Service 层：签发 Token

实现登录逻辑，验证用户信息通过后，生成 JWT。

TypeScript

// auth.service.ts
import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(private readonly jwtService: JwtService) {}

  async login(user: any) {
    const payload = { username: user.username, sub: user.userId };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }
}

4.4 Strategy 实现：解析 Token

编写策略类，用于解析请求头中的 Bearer Token 并进行验证。

TypeScript

// jwt.strategy.ts
import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false, // 拒绝过期 Token
      secretOrKey: 'YOUR_SECRET_KEY', // 需与 Module 中配置一致
    });
  }

  async validate(payload: any) {
    // passport 会自动把返回值注入到 request.user 中
    return { userId: payload.sub, username: payload.username };
  }
}

4.5 Controller 使用：路由保护

TypeScript

// app.controller.ts
import { Controller, Get, UseGuards, Request } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller('profile')
export class ProfileController {
  @UseGuards(AuthGuard('jwt'))
  @Get()
  getProfile(@Request() req) {
    return req.user; // 这里是通过 JwtStrategy.validate 返回的数据
  }
}

5. 深度分析：JWT 的优缺点与架构权衡

优点

无状态与水平扩展（Stateless & Scalability） ：服务端不需要存储 Session 信息，完全消除了 Session 同步问题，非常适合微服务和分布式架构。
跨域友好：不依赖 Cookie（尽管可以结合 Cookie 使用），在 CORS 场景下处理更为简单，且天然适配移动端（iOS/Android）开发。
性能：在不涉及黑名单机制的前提下，验证 Token 只需要 CPU 计算签名，无需查询数据库，减少了 I/O 开销。

缺点与挑战

令牌体积：JWT 包含了 Payload 信息，相比仅存储 ID 的 Cookie，其体积更大，这会增加每次 HTTP 请求的 Header 大小，影响流量。
撤销难题（Revocation） ：这是 JWT 最大的痛点。JWT 一旦签发，在有效期内始终有效。服务端无法像 Session 那样直接删除服务器端数据来强制用户下线。

6. 面试高频考点与解决方案（进阶）

在面试中，仅仅展示如何生成 JWT 是远远不够的，面试官更关注安全性与工程化挑战。

问题 1：JWT 安全吗？如何防范攻击？

XSS（跨站脚本攻击） ：如果将 JWT 存储在 localStorage 或 sessionStorage，恶意 JS 脚本可以轻松读取 Token。
- 解决方案：建议将 Token 存储在标记为 HttpOnly 的 Cookie 中，这样 JS 无法读取。
CSRF（跨站请求伪造） ：如果使用 Cookie 存储 Token，则会面临 CSRF 风险。
- 解决方案：使用 SameSite=Strict 属性，或配合 CSRF Token 防御。如果坚持存储在 localStorage 并通过 Authorization Header 发送，则天然免疫 CSRF，但需重点防范 XSS。
中间人攻击：由于 Header 和 Payload 是明文编码。
- 解决方案：必须强制全站使用 HTTPS。

问题 2：如何实现注销（Logout）或强制下线？

既然 JWT 是无状态的，如何实现“踢人下线”？这实际上是无状态与管控性之间的权衡。

方案 A：黑名单机制（Blacklist）
- 将用户注销或被封禁的 Token ID (jti) 存入 Redis，设置过期时间等于 Token 的剩余有效期。
- 每次请求验证时，先校验签名，再查询 Redis 是否在黑名单中。
- 权衡：牺牲了部分“无状态”优势（引入了 Redis 查询），但获得了即时的安全管控。
方案 B：版本号/时间戳控制
- 在 JWT Payload 中加入 token_version。
- 在数据库用户表中也存储一个 token_version。
- 当用户修改密码或注销时，增加数据库中的版本号。
- 权衡：每次验证都需要查询数据库比对版本号，退化回了 Session 的模式，性能开销大。

问题 3：Token 续签（Refresh Token）机制是如何设计的？

为了解决 JWT 有效期过长不安全、过短体验差的问题，业界标准做法是 双 Token 机制：

Access Token：有效期短（如 15 分钟），用于访问业务接口。
Refresh Token：有效期长（如 7 天），仅用于换取新的 Access Token。

流程设计：

客户端请求接口，若 Access Token 过期，服务端返回 401。
客户端捕获 401，携带 Refresh Token 请求 /refresh 接口。
服务端验证 Refresh Token 合法（且未在黑名单/数据库中被禁用），签发新的 Access Token。
关键点：Refresh Token 通常需要在服务端（数据库）持久化存储，以便管理员可以随时禁用某个 Refresh Token，从而间接实现“撤销”用户的登录状态。

7. 结语

JWT 并不是银弹。它通过牺牲一定的“可控性”换取了“无状态”和“扩展性”。

在架构选型时：

如果你的应用是小型单体，且对即时注销要求极高，传统的 Session 模式可能更简单有效。
如果你的应用是微服务架构，或者需要支持多端登录，JWT 是不二之选。
在构建企业级应用时，切勿盲目追求纯粹的无状态。推荐使用 JWT + Access/Refresh Token 双令牌 + Redis 黑名单 的组合拳，以在安全性、性能和扩展性之间取得最佳平衡。

Brevan Howard的加密货币基金2025年下跌30%

36氪

2026年2月18日 18:05

据媒体援引知情人士消息报道，布莱文・霍华德（Brevan Howard）旗下 BH 数字资产基金在 2025 年暴跌约 30%，创下该基金 2021 年成立以来最严重的年度跌幅。该基金曾在 2023 年实现 43% 的收益，2024 年收益达 52%，但在去年遭遇重创。原因是受人工智能冲击、面临颠覆性风险的科技股大幅下跌，连带加密资产也受到剧烈波及。

市场监管总局部署各地从严纠治消费服务乱象全力维护春节期间市场秩序

36氪

2026年2月18日 17:49

春节假期，节日消费、旅游服务等市场火热。为维护春节期间市场价格秩序稳定，市场监管总局部署各地市场监管部门多措并举，加强住宿、餐饮、景区、食品、生活服务等领域价格监管，全力保障人民群众合法权益，守护好春节的“年味”。各级市场监管部门强化价格监测预警，密切关注价格波动趋势；指导经营者合理制定价格，并按规定执行明码标价；及时组织开展价格提醒告诫和行政约谈，指导督促经营者落实价格承诺。聚焦春节假期消费重点地区、重点领域，对各类价格违法行为保持高压态势，严肃查处不按规定明码标价、串通涨价、价格欺诈、哄抬价格等违法行为，查办了一批典型案件。市场监管部门将严格落实监管责任，切实维护市场公平竞争秩序和消费者合法权益，全力营造安全放心、满意舒心的节日消费环境。

消息人士：欧洲央行行长拉加德希望在明年4月法国总统大选前离任

36氪

2026年2月18日 17:27

据英国金融时报报道，一位了解其想法的人士透露，欧洲央行行长拉加德预计将在2027年10月其八年行长任期届满前离职。这位欧洲央行掌门人于2019年11月从国际货币基金组织转任欧洲央行行长，她希望在明年4月法国总统大选前卸任。知情人士透露，拉加德希望让即将卸任的法国总统马克龙和德国总理默茨为欧盟最重要的机构之一物色新任负责人。目前尚不清楚拉加德何时会离任。

海南日用消费品免税店开业首周销售超276万元

36氪

2026年2月18日 16:51

据海南日报报道，海口海关2月18日发布统计数据，2月11日至17日海南自由贸易港岛内居民消费的进境商品“零关税”政策落地首周，共计销售金额276.8万元，购物票数16304票，购物人数14896人次。“零关税”商品销售结构以食品饮料、母婴用品、日化用品为主，消费需求旺盛，市场运行平稳有序。

微软本十年末前将向全球南方 AI 领域投资 500 亿美元

36氪

2026年2月18日 16:29

微软在印度人工智能影响力峰会上宣布，计划在本十年末前投资 500 亿美元，助力将人工智能技术推广至全球南方各国。微软这项旨在发挥 AI 影响力的五大计划包括：建设人工智能普及所需的基础设施；通过技术与技能培训赋能学校及非营利机构人员；强化多语言、多元文化的人工智能能力；推动满足社区需求的本地人工智能创新；评估人工智能普及情况，为未来人工智能政策与投资提供指导。

Linux Tips, Tricks and Tutorials on Linuxize
MySQL/MariaDB Cheatsheethello@linuxize.com (Linuxize)
2026年2月18日 16:25

MySQL/MariaDB Cheatsheet

Linux Tips, Tricks and Tutorials on Linuxize

作者 hello@linuxize.com (Linuxize)

2026年2月18日 16:25

Connect and Exit

Open a SQL session and disconnect safely.

Command	Description
`mysql -u root -p`	Connect as root (prompt for password)
`mysql -u user -p -h 127.0.0.1`	Connect to specific host
`mysql -u user -p -P 3306`	Connect on custom port
`sudo mysql`	Login using Unix socket auth (common on Debian/Ubuntu)
`exit`	Leave MySQL/MariaDB shell

Basic SQL Checks

Run quick checks after connecting.

SQL	Description
`SELECT VERSION();`	Show server version
`SHOW DATABASES;`	List all databases
`USE db_name;`	Switch active database
`SHOW TABLES;`	List tables in current database
`SHOW GRANTS FOR 'user'@'host';`	Show user privileges

Database Management

Create, inspect, and remove databases.

SQL	Description
`CREATE DATABASE db_name;`	Create a database
`CREATE DATABASE db_name CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;`	Create DB with charset/collation
`SHOW DATABASES LIKE 'db_name';`	Check if DB exists
`DROP DATABASE db_name;`	Delete a database
`SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA;`	List schemas via information schema

User Management

Create users and manage authentication.

SQL	Description
`CREATE USER 'app'@'localhost' IDENTIFIED BY 'strong_password';`	Create local user
`CREATE USER 'app'@'%' IDENTIFIED BY 'strong_password';`	Create remote-capable user
`ALTER USER 'app'@'localhost' IDENTIFIED BY 'new_password';`	Change password
`DROP USER 'app'@'localhost';`	Delete user
`SELECT user, host FROM mysql.user;`	List users and hosts

Privileges

Grant, review, and revoke access.

SQL	Description
`GRANT ALL PRIVILEGES ON db_name.* TO 'app'@'localhost';`	Grant full DB access
`GRANT SELECT,INSERT,UPDATE,DELETE ON db_name.* TO 'app'@'localhost';`	Grant specific privileges
`REVOKE ALL PRIVILEGES ON db_name.* FROM 'app'@'localhost';`	Remove DB privileges
`SHOW GRANTS FOR 'app'@'localhost';`	Review granted privileges
`FLUSH PRIVILEGES;`	Reload grant tables

Backup and Restore

Use mysqldump for exports and imports.

Command	Description
`mysqldump -u root -p db_name > db_name.sql`	Backup one database
`mysqldump -u root -p --databases db1 db2 > multi.sql`	Backup multiple databases
`mysqldump -u root -p --all-databases > all.sql`	Backup all databases
`mysql -u root -p db_name < db_name.sql`	Restore into existing database
`gunzip < db_name.sql.gz \| mysql -u root -p db_name`	Restore compressed SQL dump

Import and Export Data

Common import/export patterns.

Command	Description
`mysql -u root -p -e "SHOW DATABASES;"`	Run one-off SQL from shell
`mysql -u root -p db_name -e "SOURCE /path/file.sql"`	Import SQL file via client
`mysql -u root -p -Nse "SELECT NOW();"`	Non-interactive query output
`mysqldump -u root -p db_name table_name > table.sql`	Export one table
`mysql -u root -p db_name < table.sql`	Import one table dump

Service and Health Checks

Verify daemon state and open ports.

Command	Description
`systemctl status mysql`	Check MySQL service status
`systemctl status mariadb`	Check MariaDB service status
`sudo systemctl restart mysql`	Restart MySQL service
`sudo systemctl restart mariadb`	Restart MariaDB service
`ss -tulpn \| grep 3306`	Confirm server is listening

Common Troubleshooting

Quick checks for frequent connection and auth problems.

Issue	Check
`Access denied for user`	Verify user/host pair and password, then check `SHOW GRANTS`
`Can't connect to local MySQL server through socket`	Check service status and socket path in config
`Can't connect to MySQL server on 'host'`	Confirm host/port reachability and firewall rules
`Unknown database`	Verify database name with `SHOW DATABASES;`
Restore fails on collation/charset	Ensure server supports source collation and set utf8mb4 where needed

Related Guides

Use these articles for detailed MySQL/MariaDB workflows.

Guide	Description
`How to Manage MySQL Databases and Users from the Command Line`	End-to-end admin workflow
`How to Create MySQL Users Accounts and Grant Privileges`	User and privilege setup
`How to Back Up and Restore MySQL Databases with Mysqldump`	Backup and restore patterns
`How to Show a List of All Databases in MySQL`	Database discovery commands
`List (Show) Tables in a MySQL Database`	Table listing commands
`How to Check the MySQL Version`	Version checks and verification

谷歌开发者大会定于5月19日至20日举办

36氪

2026年2月18日 16:06

当地时间2月17日，谷歌母公司Alphabet宣布，2026年谷歌开发者大会（Google I/O 2026）将于5月19日至20日举办。

国际能源署：能源创新进入聚焦安全新阶段

36氪

2026年2月18日 15:30

国际能源署17日发布的《能源创新现状》报告指出，能源创新已进入聚焦安全的新阶段，储能技术已跃居全球创新活动的前沿。报告说，能源技术已形成数万亿美元规模的全球市场，正成为电池、变压器、涡轮机、电机、换热器等领域的创新引擎。全球约十分之一的专利与能源相关，超过化工、医药或交通领域，凸显其在国家安全、产业战略和经济表现中的核心地位。报告还说，一项针对能源领域专家和从业者的调查显示，能源安全已成为2025年能源创新的主要驱动力，各国日益重视加强本土技术能力和保障关键供应链安全。根据报告，储能已成为全球创新活动的前沿领域。电池相关专利在全部能源专利中的占比将在2023年40%的基础上进一步上升。

巴菲特段永平大幅减持苹果

36氪

2026年2月18日 15:04

最新披露的文件显示，在巴菲特卸任CEO前的最后一个季度，伯克希尔·哈撒韦公司对科技股的持仓进行了大幅调整，大举减持了苹果、亚马逊。其中，纽约时报是伯克希尔四季度唯一新建仓的个股，买入数量为506.7万股。与此同时，知名投资人段永平也在2025年第四季度减持了苹果，减持数量为247.06万股，减持幅度达7.09%。值得注意的是，段永平似乎正大举押注AI，其在第四季度大举增持了663.93万股英伟达，还建仓买入了三家AI“新面孔”。

春节前三天湖北全省A级景区接待游客超523万人次

36氪

2026年2月18日 14:44

2026年春节假期前3天，湖北文旅市场迎来新春开门红，全省文旅市场有序运行、热度攀升，叠加节中高性价比机票的拉动，入鄂游、在鄂游双向火热，马年新春的荆楚大地年味浓郁、游人如织。据统计，假期前3天全省A级旅游景区累计接待游客523.28万人次，综合收入21.94亿元，同比分别增长2.46％、10.53%。

掘金前端
对象数组的排序与分组：sort / localeCompare / 自定义 compareSuperEugene
2026年2月18日 13:56

对象数组的排序与分组：sort / localeCompare / 自定义 compare

掘金前端

作者 SuperEugene

2026年2月18日 13:56

日常开发里，列表、表格、统计几乎都绕不开「对象数组」的排序和分组。本文不讲底层原理，只讲怎么选、为什么选、容易踩哪些坑。适合会写 JS 但概念有点混的同学，也适合想补齐基础的前端老手。

一、Array.sort 到底在干什么

1.1 三个关键点

要点	说明
原地排序	`sort()` 会直接修改原数组，不会返回新数组
默认行为	不传比较函数时，按字符串逐个字符比较
`compare` 返回值	负数：a 排前面；0：不变；正数：b 排前面

有没有同学会有这样的疑问：compare 返回值？这是啥？解释：

这里的 compare 指的是 Array.sort() 方法中传入的比较函数（也就是你后面写的 (a, b) => a - b 这种形式）。
简单说：当你用sort()排序时，传入的这个函数就是 compare，它的作用是告诉 sort() 两个元素（a 和 b）该怎么排，返回值直接决定排序结果，和表格里的说明完全对应。
比如 nums.sort((a, b) => a - b) 中，(a, b) => a - b 就是 compare 比较函数。

1.2 第一个坑：数字数组直接用 `sort`

const nums = [10, 2, 1];
nums.sort(); // 这一步已经把原数组 nums 改了！以为会得到 [1, 2, 10]
console.log(nums); // 打印的是被修改后的原数组，不是初始值。实际得到 [1, 10, 2] —— 按字符串 "10"、"2"、"1" 比较了！
// ✅ 正确写法
nums.sort((a, b) => a - b);   // 升序 [1, 2, 10]
nums.sort((a, b) => b - a);   // 降序 [10, 2, 1]

问：为什么按字符串比较会得到 [1, 10, 2]？答：sort() 默认的字符串比较规则是「逐字符按 Unicode 码点比较」，不是看数字大小，步骤拆解如下：

先把数组里的数字都转成字符串：10→"10"、2→"2"、1→"1"；
从第一个字符开始比，字符的 Unicode 码点："1"（码点 49）< "2"（码点 50）；
具体比较过程：
- 比较 "1" 和 "10"：第一个字符都是 "1"（码点相同），但 "1" 没有第二个字符，所以 "1" < "10"；
- 比较 "10" 和 "2"：第一个字符 "1" < "2"，所以 "10" < "2"

1.3 第二个坑：原数组被改了

const original = [3, 1, 2];
const sorted = original.sort((a, b) => a - b);

console.log(sorted);   // [1, 2, 3]
console.log(original); // [1, 2, 3] —— 原数组也被改了！

// ✅ 需要保留原数组时，先浅拷贝再排序
const sorted2 = [...original].sort((a, b) => a - b);

二、对象数组按不同字段排序

2.1 按数字排序

const users = [
  { name: '张三', age: 25 },
  { name: '李四', age: 18 },
  { name: '王五', age: 30 }
];

// 按 age 升序
users.sort((a, b) => a.age - b.age);
// 结果：李四(18) → 张三(25) → 王五(30)

// 按 age 降序
users.sort((a, b) => b.age - a.age);

写法记忆：升序 a - b，降序 b - a。

2.2 按字符串排序

// 按 name 字母/拼音顺序
users.sort((a, b) => a.name.localeCompare(b.name));

直接用 a.name > b.name ? 1 : -1 可以工作，但遇到中文、大小写、多语言时容易出问题，所以更推荐 localeCompare，后面会细讲。

2.3 按日期排序

日期有两种常见形式：字符串和时间戳。

const orders = [
  { id: 1, date: '2025-02-15' },
  { id: 2, date: '2025-01-20' },
  { id: 3, date: '2025-02-10' }
];

// 方式一：YYYY-MM-DD 格式的字符串可以直接用 localeCompare
orders.sort((a, b) => a.date.localeCompare(b.date));

// 方式二：转时间戳（适用各种日期格式）
orders.sort((a, b) => new Date(a.date) - new Date(b.date));

建议：后端返回的日期如果是 YYYY-MM-DD，用 localeCompare 即可；格式不统一时，统一用 new Date() 转时间戳再比较。

2.4 多字段排序

先按 A 排序，A 相同再按 B 排序，可以用 || 链式比较：

users.sort((a, b) => {
  if (a.age !== b.age) return a.age - b.age;  // 先按年龄
  return a.name.localeCompare(b.name);        // 年龄相同再按姓名
});

// 更简洁的写法
users.sort((a, b) => a.age - b.age || a.name.localeCompare(b.name));

原理：a.age - b.age 为 0 时，0 || xxx 会取后面的 localeCompare 结果。

三、localeCompare：字符串排序的正确姿势

3.1 为什么不用 >、< 比较字符串？

const arr = ['张三', '李四', '王五', 'apple', 'Apple'];
arr.sort((a, b) => a > b ? 1 : -1);  // 按 Unicode 比较，中文结果不符合直觉
arr.sort((a, b) => a.localeCompare(b));  // 按语言规则，更符合人类习惯

localeCompare 可以：

中文按拼音
控制大小写敏感
数字按数值比较（如 "10" 在 "2" 后面）

3.2 常用用法

// 指定语言（中文按拼音）
'张三'.localeCompare('李四', 'zh-CN');  // 负数，张在李后面

// 忽略大小写
'apple'.localeCompare('Apple', undefined, { sensitivity: 'base' });  // 0，视为相等

// 数字按数值比较
['10', '2', '1'].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
// 结果：['1', '2', '10']

3.3 兼容性说明

现代浏览器和 Node 都支持 localeCompare。带 options 配置的 localeCompare 写法，在老环境（旧浏览器 / 旧 Node 版本）中可能表现不一致，生产环境建议先小范围验证。

// 忽略大小写（options：{ sensitivity: 'base' }）
'apple'.localeCompare('Apple', undefined, { sensitivity: 'base' });
// 数字按数值比较（options：{ numeric: true }）
['10','2'].sort((a,b) => a.localeCompare(b, undefined, { numeric: true }));

老环境问题：像旧版 IE、低版本 Node（比如 Node.js 10 以下），对这些options配置支持不完善（比如不识别numeric: true），导致排序结果出错，所以生产环境要先小范围验证。

3.4 补充`localeCompare`带`options`写法老环境兼容技巧

核心兼容思路：降级处理——先判断环境是否支持localeCompare的options配置，支持则用带options的简洁写法，不支持则降级为基础写法，保证排序效果一致，且代码简单可直接套用（无需额外引入兼容库）。

场景1：忽略大小写排序（对应`options: { sensitivity: 'base' }`）音标：/sensəˈtɪvəti/

老环境兼容写法（适配旧IE、低版本Node）：

// 兼容函数：忽略大小写比较两个字符串
function compareIgnoreCase(a, b) {
  // 先统一转小写，再用基础localeCompare（老环境均支持无options写法）
  const lowerA = a.toLowerCase();
  const lowerB = b.toLowerCase();
  return lowerA.localeCompare(lowerB, 'zh-CN'); // 中文场景可加语言标识
}

// 用法（和带options写法效果一致）
const arr = ['apple', 'Apple', 'Banana', 'banana'];
arr.sort(compareIgnoreCase); // 结果：['apple', 'Apple', 'Banana', 'banana']

场景2：数字字符串按数值排序（对应`options: { numeric: true }`）

老环境兼容写法（避免老环境不识别numeric 音标：/njuːˈmerɪk/ 配置导致排序错乱）：

// 兼容函数：数字字符串按数值排序
function compareNumericStr(a, b) {
  // 降级思路：转成数字比较（贴合原文数字排序逻辑，老环境完全支持）
  const numA = Number(a);
  const numB = Number(b);
  return numA - numB; // 升序，降序则改为numB - numA
}

// 用法（和带options写法效果一致）
const arr = ['10', '2', '1', '25'];
arr.sort(compareNumericStr); // 结果：['1', '2', '10', '25']

关键注意点

无需判断环境：上述兼容写法兼容所有环境（老环境正常运行，新环境也不影响效果），不用额外写环境判断代码，简化开发。
生产环境验证：如果老环境占比极低，可直接用带options写法，上线前用老环境（如IE11、Node.js 8）简单测试1个排序案例即可。

四、分组统计：从排序到 `groupBy` 【分组】

排序和分组是两个不同操作：

排序：改变顺序，不拆分数组
分组：按某个字段把数组拆成多组

JS 没有内置 groupBy，可以用 reduce 实现：

const orders = [
  { id: 1, status: 'paid', amount: 100 },
  { id: 2, status: 'pending', amount: 50 },
  { id: 3, status: 'paid', amount: 200 }
];

const byStatus = orders.reduce((acc, item) => {
  const key = item.status;
  if (!acc[key]) acc[key] = [];
  acc[key].push(item);
  return acc;
}, {});

// 结果：
// {
//   paid: [{ id: 1, ... }, { id: 3, ... }],
//   pending: [{ id: 2, ... }]
// }

分组后再排序

分组后，如果每组内部还要排序：

Object.keys(byStatus).forEach(key => {
  byStatus[key].sort((a, b) => b.amount - a.amount);  // 每组按金额降序
});

分组 + 统计

需要同时统计每组数量或汇总值时：

const stats = orders.reduce((acc, item) => {
  const key = item.status;
  if (!acc[key]) {
    acc[key] = { list: [], total: 0, count: 0 };
  }
  acc[key].list.push(item);
  acc[key].total += item.amount;
  acc[key].count += 1;
  return acc;
}, {});

// 结果示例：{ paid: { list: [...], total: 300, count: 2 }, ... }

五、踩坑速查表

坑点	错误表现	正确写法
数字数组排序错乱	`[10, 2, 1].sort()` → `[1, 10, 2]`	`arr.sort((a, b) => a - b)`
原数组被修改	排序后原数组也变了	`[...arr].sort(...)`
中文排序不对	直接用 `>`、`<` 比较	`a.localeCompare(b, 'zh-CN')`
多字段排序只写了一层	只按第一个字段排	`a.age - b.age \|\| a.name.localeCompare(b.name)`
日期格式不统一	字符串比较出错	`new Date(a.date) - new Date(b.date)`

六、小结

数字排序：用 (a, b) => a - b 或 b - a，不要用默认 sort()。
字符串排序：优先用 localeCompare，尤其是中文和多语言场景。
日期排序：YYYY-MM-DD 用 localeCompare，其他格式用时间戳。
多字段排序：用 || 串联多个比较。
分组：用 reduce 做 groupBy，再按需对每组排序或统计。
保留原数组：排序前先 [...arr] 浅拷贝。

这些写法足够覆盖大部分日常需求，记住上面的速查表，可以少踩很多坑。

以上就是本次的学习分享，欢迎大家在评论区讨论指正，与大家共勉。

我是 Eugene，你的电子学友。

如果文章对你有帮助，别忘了点赞、收藏、加关注，你的认可是我持续输出的最大动力～

Linux Tips, Tricks and Tutorials on Linuxize
UFW Cheatsheethello@linuxize.com (Linuxize)
2026年2月17日 17:55

UFW Cheatsheet

Linux Tips, Tricks and Tutorials on Linuxize

作者 hello@linuxize.com (Linuxize)

2026年2月17日 17:55

Basic Commands

Start with status and firewall state.

Command	Description
`ufw status`	Show firewall status and rules
`ufw status verbose`	Show detailed status and defaults
`sudo ufw enable`	Enable UFW
`sudo ufw disable`	Disable UFW
`sudo ufw reload`	Reload rules
`sudo ufw reset`	Reset UFW to defaults

Default Policies

Set default inbound and outbound behavior.

Command	Description
`sudo ufw default deny incoming`	Deny all incoming by default
`sudo ufw default allow outgoing`	Allow all outgoing by default
`sudo ufw default deny outgoing`	Deny all outgoing by default
`sudo ufw default allow incoming`	Allow all incoming (not recommended on servers)

Allow and Deny Rules

Allow or block traffic by port and protocol.

Command	Description
`sudo ufw allow 22`	Allow port 22 (TCP and UDP)
`sudo ufw allow 80/tcp`	Allow HTTP over TCP
`sudo ufw allow 443/tcp`	Allow HTTPS over TCP
`sudo ufw deny 25`	Deny SMTP port 25
`sudo ufw reject 23`	Reject Telnet connections
`sudo ufw limit 22/tcp`	Rate-limit SSH connections

Rule Management

List, delete, and clean specific rules.

Command	Description
`sudo ufw status numbered`	List rules with numbers
`sudo ufw delete allow 80/tcp`	Delete matching rule
`sudo ufw delete 3`	Delete rule by number
`sudo ufw delete deny 25`	Delete a deny rule

IP-Based Rules

Allow or deny traffic from specific hosts and networks.

Command	Description
`sudo ufw allow from 203.0.113.10`	Allow all traffic from one IP
`sudo ufw deny from 203.0.113.10`	Block all traffic from one IP
`sudo ufw allow from 203.0.113.10 to any port 22`	Allow SSH from one IP
`sudo ufw allow from 10.0.0.0/24 to any port 3306`	Allow MySQL from a subnet
`sudo ufw deny from 198.51.100.0/24 to any port 22 proto tcp`	Deny TCP SSH from subnet

Application Profiles

Use service profiles from /etc/ufw/applications.d/.

Command	Description
`sudo ufw app list`	List available application profiles
`sudo ufw app info "Nginx Full"`	Show ports/protocols for profile
`sudo ufw allow "OpenSSH"`	Allow profile rules
`sudo ufw deny "Nginx HTTP"`	Deny profile rules
`sudo ufw delete allow "OpenSSH"`	Remove allowed profile

Logging

Control and inspect UFW logging.

Command	Description
`sudo ufw logging on`	Enable logging
`sudo ufw logging off`	Disable logging
`sudo ufw logging low`	Set low log level
`sudo ufw logging medium`	Set medium log level
`sudo ufw logging high`	Set high log level

Common Server Setup

Baseline rules for a web server.

Command	Description
`sudo ufw default deny incoming`	Deny incoming by default
`sudo ufw default allow outgoing`	Allow outgoing by default
`sudo ufw allow OpenSSH`	Keep SSH access
`sudo ufw allow 80/tcp`	Allow HTTP
`sudo ufw allow 443/tcp`	Allow HTTPS
`sudo ufw enable`	Activate firewall
`sudo ufw status verbose`	Verify active rules

Troubleshooting

Quick checks for common UFW issues.

Issue	Check
SSH access lost after enable	Ensure `OpenSSH` is allowed before `ufw enable`
Rule did not apply	Run `sudo ufw reload` and re-check with `ufw status numbered`
Service still unreachable	Confirm service is listening (`ss -tulpn`) and port/protocol match
Rules conflict	Check order with `ufw status numbered` and delete/re-add as needed
UFW not active at boot	Verify service state with `systemctl status ufw`

Related Guides

Use these guides for full UFW workflows.

Guide	Description
`How to Set Up a Firewall with UFW on Ubuntu 20.04`	Full UFW setup on Ubuntu 20.04
`How to Set Up a Firewall with UFW on Ubuntu 18.04`	UFW setup on Ubuntu 18.04
`How to Set Up a Firewall with UFW on Debian 10`	UFW setup on Debian 10
`How to List and Delete UFW Firewall Rules`	Rule management and cleanup

普通视图

42. Medium - 1130 - ReplaceKeys ※

43. Medium - 1367 - Remove Index Signature 移除索引签名 ※

44. Medium - 1978 - Percentage Parser 百分比解析器

45. Medium - 2070 - Drop Char 删除字符

46. Medium - 2257 - MinusOne 减一 ※

47. Medium - 2595 - PickByType

48. Medium - 2688 - StartsWith

49. Medium - 2693 - EndsWith

50. Medium - 2757 - PartialByKeys

51. Medium - 2759 - RequiredByKeys

52. Medium - 2793 - Mutable ※

53. Medium - 2852 - OmitByType

54. Medium - 2946 - ObjectEntries

55. Medium - 3062 - Shift

56. Medium - 3188 - Tuple to Nested Object

57. Medium - 3192 - Reverse

58. Medium - 3196 - Flip Arguments

59. Medium - 3243 - FlattenDepth

60. Medium - 3326 - BEM style string

61. Medium - 3376 - InorderTraversal

62. Medium - 4179 - Flip

63. Medium - 4182 - Fibonacci Sequence 斐波那契序列 ※

64. Medium - 4260 - AllCombinations ※

65. Medium - 4425 - Greater Than

66. Medium - 4471 - Zip

67. Medium - 4484 - IsTuple ※

68. Medium - 4499 - Chunk

69. Medium - 4518 - Fill

70. Medium - 4803 - Trim Right

71. Medium - 5117 - Without

72. Medium - 5140 - Without

73. Medium - 5153 - IndexOf

74. Medium - 5310 - Join

75. Medium - 5317 - LastIndexOf

76. Medium - 5360 - Unique 数组去重

77. Medium - 5821 - MapTypes 映射类型

78. Medium - 7544 - Construct Tuple 构造元组 ※

79. Medium - 8640 - Number Range

80. Medium - 8767 - Combination ※

81. Medium - 8987 - Subsequence ※

82. Medium - 9142 - CheckRepeatedChars

83. Medium - 9286 - FirstUniqueCharIndex

84. Medium - 9616 - Parse URL Params

85. Medium - 9896 - GetMiddleElement

86. Medium - 9898 - Appear only once

87. Medium - 9989 - Count Element Number To Object

88. Medium - 10969 - Integer ※

89. Medium - 16259 - ToPrimitive ※

90. Medium - 17973 - DeepMutable

复杂度分析

专题训练

分类题单

思路

答题

致谢

方法一：按字符分组

1. 引言

2. 什么是 JWT

3. JWT 的解剖学：原理详解

3.1 Header（头部）

3.2 Payload（负载）

3.3 Signature（签名）

4. 实战：基于 NestJS 实现 JWT 认证

4.1 依赖安装

4.2 Module 配置

4.3 Service 层：签发 Token

4.4 Strategy 实现：解析 Token

4.5 Controller 使用：路由保护

5. 深度分析：JWT 的优缺点与架构权衡

优点

缺点与挑战

6. 面试高频考点与解决方案（进阶）

问题 1：JWT 安全吗？如何防范攻击？

问题 2：如何实现注销（Logout）或强制下线？

问题 3：Token 续签（Refresh Token）机制是如何设计的？

7. 结语

Connect and Exit #

Basic SQL Checks #

Database Management #

Connect and Exit

Basic SQL Checks

Database Management

User Management

Privileges

Backup and Restore

Import and Export Data

Service and Health Checks

Common Troubleshooting

Related Guides

1.2 第一个坑：数字数组直接用 `sort`

3.4 补充`localeCompare`带`options`写法老环境兼容技巧

场景1：忽略大小写排序（对应`options: { sensitivity: 'base' }`）音标：/sensəˈtɪvəti/

场景2：数字字符串按数值排序（对应`options: { numeric: true }`）

四、分组统计：从排序到 `groupBy` 【分组】

Basic Commands

Default Policies

Allow and Deny Rules

Rule Management

IP-Based Rules

Application Profiles

Logging

Common Server Setup

Troubleshooting

Related Guides