给你一个数组 nums，你可以执行以下操作任意次数：
返回将数组变为 非递减 所需的 最小操作次数 。
如果一个数组中每个元素都大于或等于它前一个元素（如果存在的话），则称该数组为非递减。
示例 1：
输入： nums = [5,2,3,1]
输出： 2
解释：
登录(3,1) 的和最小，为 4。替换后 nums = [5,2,4]。(2,4) 的和为 6。替换后 nums = [5,6]。数组 nums 在两次操作后变为非递减。
示例 2：
输入： nums = [1,2,2]
输出： 0
解释：
数组 nums 已经是非递减的。
提示：
1 <= nums.length <= 105-109 <= nums[i] <= 109Problem: 3510. 移除最小数对使数组有序 II
[TOC]
先不管是否为递增数组，当作一道新题目，每次操作选择相邻的最小和。然后合并
要获取最小的相邻值，那就用最小堆，两个相邻值合并相当于区间合并，用area来模拟区间合并：
# 区间合并后，当前 i 的区间范围，-inf 即为被合并了
area = [ (i,i) for i in range(n) ]
并初始化堆，堆中包含三个值：
for i in range(n-1):
heappush(heap,(nums[i]+nums[i+1],i,i+1))
模拟合并的代码：
while True:
while heap:
num,l,r = heap[0]
if area[l][1] + 1 != r or nums[l] + nums[r] != num:
heappop(heap)
else:
break
# 合并完了
if not heap:
break
# 操作
num,l,r = heappop(heap)
# 两个区间
a,b = area[l]
x,y = area[r]
# 求和合并
nums[a] = num
nums[y] = num
# 区间合并
area[b] = area[x] = (-inf,-inf)
area[a] = (a,y)
area[y] = (a,y)
# 和前后区间合并并入堆
if y + 1 < n and area[y+1][0] != -inf:
heappush(heap,(num + nums[y+1],l,y+1))
if a - 1 >= 0 and area[a-1][0] != -inf:
heappush(heap,(num + nums[area[a-1][0]],area[a-1][0],l))
现在考虑判断每次操作后，合并后的数组是否递增：
看到区间修改和区间查询，应该要想到线段树了
一般出现区间修改都考虑lazy线段树，但这题不需要，因为每次被合并的区间都不会再对该区间中的子区间进行操作，也就是不会有lazy标记下放了，所以不需要lazy标记
f[k] 中维护三个值：
# 真实值，是否递增，区间左侧值，区间右侧值
self.f = [[False,-1,-1] for _ in range(4*n)]
这个合并不难：
def pushup(self,lp,rp):
lf,a,b = lp
rf,x,y = rp
if not lf or not rf:
return (False,-1,-1)
if b <= x:
return (True,a,y)
else:
return (False,-1,-1)
最后就是在第一步模拟操作时加入 区间修改和区间查询 ，以及操作数统计就好了。
更多题目模板总结，请参考2024年度总结与题目分享
###Python3
# 标记不下放版本
class SegmentTree:
def __init__(self,nums):
n = len(nums)
self.nums = nums
# 真实值，是否递增，区间左侧值，区间右侧值
self.f = [[False,-1,-1] for _ in range(4*n)]
self.buildTree(1,0,n-1)
self.n = n
def pushup(self,lp,rp):
lf,a,b = lp
rf,x,y = rp
if not lf or not rf:
return (False,-1,-1)
if b <= x:
return (True,a,y)
else:
return (False,-1,-1)
# 初始化，求区间和
def buildTree(self,k,l,r):
# 叶子节点
if l == r:
self.f[k] = (True,self.nums[l],self.nums[l])
return
mid = (l+r)//2
self.buildTree(2*k,l,mid)
self.buildTree(2*k+1,mid+1,r)
# 每个k掌管 [2*k,2*k+1]
self.f[k] = self.pushup(self.f[2*k],self.f[2*k+1])
def update(self,start,end,x):
return self._update(1,0,self.n-1,start,end,x)
def _update(self,k,l,r,start,end,x):
# 序号为k的点，掌管范围是l～r， 在区间start～end上，
# 待更新区间刚好等于当前标准区间，则直接更新
if l == start and r == end:
# 肯定递增
self.f[k] = [True,x,x]
return
mid = (l+r)//2
if end <= mid: # 只在左子树
self._update(2*k,l,mid,start,end,x)
# 注意这里的return
elif start > mid: # 只在右子树
self._update(2*k+1,mid+1,r,start,end,x)
else:
# 否则对左右子树都需要处理
self._update(2*k, l, mid, start,mid,x)
self._update(2*k+1,mid+1,r, mid+1,end,x)
# 后缀数组更新，左右子树更新后更新当前子树
self.f[k] = self.pushup(self.f[2*k],self.f[2*k+1])
def query(self):
return self.f[1][0]
# 范围内含有1的个数
def _query(self,k,l,r,start,end):
# update时对于标准区间已经更新，返回即可
if l == start and r == end: # 叶子节点
return self.f[k]
mid = (l+r)//2
# 需要更新，标记下放
if not self.v[k]:
self._update(2*k,l,mid,l,mid)
self._update(2*k+1,mid+1,r,mid+1,r)
self.v[k] = True
if end <= mid:
return self._query(2*k,l,mid,start,end) # 注意这里的p已经加上了v[k]的影响
elif start > mid:
return self._query(2*k+1,mid+1,r,start,end)
leftPart = self._query(2*k,l,mid,start,mid)
rightPart = self._query(2*k+1,mid+1,r,mid+1,end)
return leftPart + rightPart
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
'''
相邻和最小的 a,b
a = a + b
移除b
非递减
1e5
线段树
nums[i] nums[j] 合并的话
相当于
区间修改 把区间 [i,j] 换成相同的值为 nums[i] + nums[j]
区间查询 查询整个区间是否递增
那就是线段树
快速找最小：
堆 + 并查集模拟删除
'''
n = len(nums)
# 值，区间 [l,r] 两端点相加
heap = []
# 区间合并后，当前 i 的区间范围，-inf 即为被合并了
area = [ (i,i) for i in range(n) ]
for i in range(n-1):
heappush(heap,(nums[i]+nums[i+1],i,i+1))
tree = SegmentTree(nums)
res = 0
while not tree.query():
res += 1
while heap:
num,l,r = heap[0]
if area[l][1] + 1 != r or nums[l] + nums[r] != num:
heappop(heap)
else:
break
# 操作
num,l,r = heappop(heap)
# 两个区间
a,b = area[l]
x,y = area[r]
# 求和合并
nums[a] = num
nums[y] = num
tree.update(a,y,num)
# 区间合并
area[b] = area[x] = (-inf,-inf)
area[a] = (a,y)
area[y] = (a,y)
# 和前后区间合并并入堆
if y + 1 < n and area[y+1][0] != -inf:
heappush(heap,(num + nums[y+1],l,y+1))
if a - 1 >= 0 and area[a-1][0] != -inf:
heappush(heap,(num + nums[area[a-1][0]],area[a-1][0],l))
return res
为了快速模拟题目的操作，我们需要维护三种信息：
不断模拟操作，直到 $\textit{dec} = 0$。
题目说「用它们的和替换这对元素」，设操作的这对元素的下标为 $i$ 和 $\textit{nxt}$，操作相当于把 $\textit{nums}[i]$ 增加 $\textit{nums}[\textit{nxt}]$，然后删除 $\textit{nums}[\textit{nxt}]$。
在这个过程中，$\textit{dec}$ 如何变化？
设操作的这对元素的下标为 $i$ 和 $\textit{nxt}$，$i$ 左侧最近剩余下标为 $\textit{pre}$，$\textit{nxt}$ 右侧最近剩余下标为 $\textit{nxt}_2$。
操作会影响 $\textit{nums}[i]$ 和 $\textit{nums}[\textit{nxt}]$，也会影响周边相邻元素的大小关系。所以每次操作，我们需要重新考察 $4$ 个元素值的大小关系，下标从左到右为 $\textit{pre},i,\textit{nxt},\textit{nxt}_2$。
上述过程中，同时维护（添加删除）新旧相邻元素和以及下标。
本题视频讲解，欢迎点赞关注~
###py
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
sl = SortedList() # (相邻元素和，左边那个数的下标)
idx = SortedList(range(len(nums))) # 剩余下标
dec = 0 # 递减的相邻对的个数
for i, (x, y) in enumerate(pairwise(nums)):
if x > y:
dec += 1
sl.add((x + y, i))
ans = 0
while dec > 0:
ans += 1
s, i = sl.pop(0) # 删除相邻元素和最小的一对
k = idx.bisect_left(i)
# (当前元素，下一个数)
nxt = idx[k + 1]
if nums[i] > nums[nxt]: # 旧数据
dec -= 1
# (前一个数，当前元素)
if k > 0:
pre = idx[k - 1]
if nums[pre] > nums[i]: # 旧数据
dec -= 1
if nums[pre] > s: # 新数据
dec += 1
sl.remove((nums[pre] + nums[i], pre))
sl.add((nums[pre] + s, pre))
# (下一个数，下下一个数)
if k + 2 < len(idx):
nxt2 = idx[k + 2]
if nums[nxt] > nums[nxt2]: # 旧数据
dec -= 1
if s > nums[nxt2]: # 新数据（当前元素，下下一个数）
dec += 1
sl.remove((nums[nxt] + nums[nxt2], nxt))
sl.add((s + nums[nxt2], i))
nums[i] = s # 把 nums[nxt] 加到 nums[i] 中
idx.remove(nxt) # 删除 nxt
return ans
###java
class Solution {
private record Pair(long s, int i) {
}
public int minimumPairRemoval(int[] nums) {
int n = nums.length;
// (相邻元素和，左边那个数的下标)
TreeSet<Pair> pairs = new TreeSet<>((a, b) -> a.s != b.s ? Long.compare(a.s, b.s) : a.i - b.i);
int dec = 0; // 递减的相邻对的个数
for (int i = 0; i < n - 1; i++) {
int x = nums[i];
int y = nums[i + 1];
if (x > y) {
dec++;
}
pairs.add(new Pair(x + y, i));
}
// 剩余下标
TreeSet<Integer> idx = new TreeSet<>();
for (int i = 0; i < n; i++) {
idx.add(i);
}
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nums[i];
}
int ans = 0;
while (dec > 0) {
ans++;
// 删除相邻元素和最小的一对
Pair p = pairs.pollFirst();
long s = p.s;
int i = p.i;
// (当前元素，下一个数)
int nxt = idx.higher(i);
if (a[i] > a[nxt]) { // 旧数据
dec--;
}
// (前一个数，当前元素)
Integer pre = idx.lower(i);
if (pre != null) {
if (a[pre] > a[i]) { // 旧数据
dec--;
}
if (a[pre] > s) { // 新数据
dec++;
}
pairs.remove(new Pair(a[pre] + a[i], pre));
pairs.add(new Pair(a[pre] + s, pre));
}
// (下一个数，下下一个数)
Integer nxt2 = idx.higher(nxt);
if (nxt2 != null) {
if (a[nxt] > a[nxt2]) { // 旧数据
dec--;
}
if (s > a[nxt2]) { // 新数据（当前元素，下下一个数）
dec++;
}
pairs.remove(new Pair(a[nxt] + a[nxt2], nxt));
pairs.add(new Pair(s + a[nxt2], i));
}
a[i] = s; // 把 a[nxt] 加到 a[i] 中
idx.remove(nxt); // 删除 nxt
}
return ans;
}
}
###cpp
class Solution {
public:
int minimumPairRemoval(vector<int>& nums) {
int n = nums.size();
set<pair<long long, int>> pairs; // (相邻元素和，左边那个数的下标)
int dec = 0; // 递减的相邻对的个数
for (int i = 0; i + 1 < n; i++) {
int x = nums[i], y = nums[i + 1];
if (x > y) {
dec++;
}
pairs.emplace(x + y, i);
}
set<int> idx; // 剩余下标
for (int i = 0; i < n; i++) {
idx.insert(i);
}
vector<long long> a(nums.begin(), nums.end());
int ans = 0;
while (dec > 0) {
ans++;
// 删除相邻元素和最小的一对
auto [s, i] = *pairs.begin();
pairs.erase(pairs.begin());
auto it = idx.lower_bound(i);
// (当前元素，下一个数)
auto nxt_it = next(it);
int nxt = *nxt_it;
dec -= a[i] > a[nxt]; // 旧数据
// (前一个数，当前元素)
if (it != idx.begin()) {
int pre = *prev(it);
dec -= a[pre] > a[i]; // 旧数据
dec += a[pre] > s; // 新数据
pairs.erase({a[pre] + a[i], pre});
pairs.emplace(a[pre] + s, pre);
}
// (下一个数，下下一个数)
auto nxt2_it = next(nxt_it);
if (nxt2_it != idx.end()) {
int nxt2 = *nxt2_it;
dec -= a[nxt] > a[nxt2]; // 旧数据
dec += s > a[nxt2]; // 新数据（当前元素，下下一个数）
pairs.erase({a[nxt] + a[nxt2], nxt});
pairs.emplace(s + a[nxt2], i);
}
a[i] = s; // 把 a[nxt] 加到 a[i] 中
idx.erase(nxt); // 删除 nxt
}
return ans;
}
};
###go
// import "github.com/emirpasic/gods/v2/trees/redblacktree"
func minimumPairRemoval(nums []int) (ans int) {
n := len(nums)
type pair struct{ s, i int }
// (相邻元素和，左边那个数的下标)
pairs := redblacktree.NewWith[pair, struct{}](func(a, b pair) int { return cmp.Or(a.s-b.s, a.i-b.i) })
dec := 0 // 递减的相邻对的个数
for i := range n - 1 {
x, y := nums[i], nums[i+1]
if x > y {
dec++
}
pairs.Put(pair{x + y, i}, struct{}{})
}
// 剩余下标
idx := redblacktree.New[int, struct{}]()
for i := range n {
idx.Put(i, struct{}{})
}
for dec > 0 {
ans++
it := pairs.Left()
s := it.Key.s
i := it.Key.i
pairs.Remove(it.Key) // 删除相邻元素和最小的一对
// (当前元素，下一个数)
node, _ := idx.Ceiling(i + 1)
nxt := node.Key
if nums[i] > nums[nxt] { // 旧数据
dec--
}
// (前一个数，当前元素)
node, _ = idx.Floor(i - 1)
if node != nil {
pre := node.Key
if nums[pre] > nums[i] { // 旧数据
dec--
}
if nums[pre] > s { // 新数据
dec++
}
pairs.Remove(pair{nums[pre] + nums[i], pre})
pairs.Put(pair{nums[pre] + s, pre}, struct{}{})
}
// (下一个数，下下一个数)
node, _ = idx.Ceiling(nxt + 1)
if node != nil {
nxt2 := node.Key
if nums[nxt] > nums[nxt2] { // 旧数据
dec--
}
if s > nums[nxt2] { // 新数据（当前元素，下下一个数）
dec++
}
pairs.Remove(pair{nums[nxt] + nums[nxt2], nxt})
pairs.Put(pair{s + nums[nxt2], i}, struct{}{})
}
nums[i] = s // 把 nums[nxt] 加到 nums[i] 中
idx.Remove(nxt) // 删除 nxt
}
return
}
用最小堆（懒删除堆）代替维护 pair 的有序集合。
用双向链表代替维护下标的有序集合。进一步地，可以用两个数组模拟双向链表的 $\textit{prev}$ 指针和 $\textit{next}$ 指针。
如果堆顶下标 $i$ 被删除，或者 $i$ 右边下标 $\textit{nxt}$ 被删除，或者堆顶元素和不等于 $\textit{nums}[i]+\textit{nums}[\textit{nxt}]$，则弹出堆顶。
###py
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
n = len(nums)
h = [] # (相邻元素和，左边那个数的下标)
dec = 0 # 递减的相邻对的个数
for i, (x, y) in enumerate(pairwise(nums)):
if x > y:
dec += 1
h.append((x + y, i))
heapify(h)
lazy = defaultdict(int)
# 每个下标的左右最近的未删除下标
left = list(range(-1, n)) # 加一个哨兵，防止下标越界
right = list(range(1, n + 1))
ans = 0
while dec:
ans += 1
while lazy[h[0]]:
lazy[heappop(h)] -= 1
s, i = heappop(h) # 删除相邻元素和最小的一对
# (当前元素，下一个数)
nxt = right[i]
if nums[i] > nums[nxt]: # 旧数据
dec -= 1
# (前一个数，当前元素)
pre = left[i]
if pre >= 0:
if nums[pre] > nums[i]: # 旧数据
dec -= 1
if nums[pre] > s: # 新数据
dec += 1
lazy[(nums[pre] + nums[i], pre)] += 1 # 懒删除
heappush(h, (nums[pre] + s, pre))
# (下一个数，下下一个数)
nxt2 = right[nxt]
if nxt2 < n:
if nums[nxt] > nums[nxt2]: # 旧数据
dec -= 1
if s > nums[nxt2]: # 新数据（当前元素，下下一个数）
dec += 1
lazy[(nums[nxt] + nums[nxt2], nxt)] += 1 # 懒删除
heappush(h, (s + nums[nxt2], i))
nums[i] = s
# 删除 nxt
l, r = left[nxt], right[nxt]
right[l] = r # 模拟双向链表的删除操作
left[r] = l
return ans
###py
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
n = len(nums)
h = [] # (相邻元素和，左边那个数的下标)
dec = 0 # 递减的相邻对的个数
for i, (x, y) in enumerate(pairwise(nums)):
if x > y:
dec += 1
h.append((x + y, i))
heapify(h)
# 每个下标的左右最近的未删除下标
left = list(range(-1, n)) # 加一个哨兵，防止下标越界
right = list(range(1, n + 1)) # 注意最下面的代码，删除 nxt 的时候额外把 right[nxt] 置为 n
ans = 0
while dec:
ans += 1
# 如果堆顶数据与实际数据不符，说明堆顶数据是之前本应删除，但没有删除的数据（懒删除）
while right[h[0][1]] >= n or h[0][0] != nums[h[0][1]] + nums[right[h[0][1]]]:
heappop(h)
s, i = heappop(h) # 删除相邻元素和最小的一对
# (当前元素，下一个数)
nxt = right[i]
if nums[i] > nums[nxt]: # 旧数据
dec -= 1
# (前一个数，当前元素)
pre = left[i]
if pre >= 0:
if nums[pre] > nums[i]: # 旧数据
dec -= 1
if nums[pre] > s: # 新数据
dec += 1
heappush(h, (nums[pre] + s, pre))
# (下一个数，下下一个数)
nxt2 = right[nxt]
if nxt2 < n:
if nums[nxt] > nums[nxt2]: # 旧数据
dec -= 1
if s > nums[nxt2]: # 新数据（当前元素，下下一个数）
dec += 1
heappush(h, (s + nums[nxt2], i))
nums[i] = s
# 删除 nxt
l, r = left[nxt], right[nxt]
right[l] = r # 模拟双向链表的删除操作
left[r] = l
right[nxt] = n # 表示删除 nxt
return ans
###java
class Solution {
private record Pair(long s, int i) {
}
public int minimumPairRemoval(int[] nums) {
int n = nums.length;
// (相邻元素和，左边那个数的下标)
PriorityQueue<Pair> h = new PriorityQueue<>((a, b) -> a.s != b.s ? Long.compare(a.s, b.s) : a.i - b.i);
int dec = 0; // 递减的相邻对的个数
for (int i = 0; i < n - 1; i++) {
int x = nums[i];
int y = nums[i + 1];
if (x > y) {
dec++;
}
h.offer(new Pair(x + y, i));
}
// 每个下标的左右最近的未删除下标
int[] left = new int[n + 1];
int[] right = new int[n + 1];
for (int i = 0; i <= n; i++) {
left[i] = i - 1;
right[i] = i + 1;
}
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nums[i];
}
int ans = 0;
while (dec > 0) {
ans++;
// 如果堆顶数据与实际数据不符，说明堆顶数据是之前本应删除，但没有删除的数据（懒删除）
while (right[h.peek().i] >= n || h.peek().s != a[h.peek().i] + a[right[h.peek().i]]) {
h.poll();
}
// 删除相邻元素和最小的一对
Pair p = h.poll();
long s = p.s;
int i = p.i;
// (当前元素，下一个数)
int nxt = right[i];
if (a[i] > a[nxt]) { // 旧数据
dec--;
}
// (前一个数，当前元素)
int pre = left[i];
if (pre >= 0) {
if (a[pre] > a[i]) { // 旧数据
dec--;
}
if (a[pre] > s) { // 新数据
dec++;
}
h.offer(new Pair(a[pre] + s, pre));
}
// (下一个数，下下一个数)
int nxt2 = right[nxt];
if (nxt2 < n) {
if (a[nxt] > a[nxt2]) { // 旧数据
dec--;
}
if (s > a[nxt2]) { // 新数据（当前元素，下下一个数）
dec++;
}
h.add(new Pair(s + a[nxt2], i));
}
a[i] = s; // 把 a[nxt] 加到 a[i] 中
// 删除 nxt
int l = left[nxt];
int r = right[nxt];
right[l] = r; // 模拟双向链表的删除操作
left[r] = l;
right[nxt] = n; // 表示删除 nxt
}
return ans;
}
}
###cpp
class Solution {
public:
int minimumPairRemoval(vector<int>& nums) {
int n = nums.size();
priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> pq; // (相邻元素和，左边那个数的下标)
int dec = 0; // 递减的相邻对的个数
for (int i = 0; i + 1 < n; i++) {
int x = nums[i], y = nums[i + 1];
if (x > y) {
dec++;
}
pq.emplace(x + y, i);
}
// 每个下标的左右最近的未删除下标
vector<int> left(n + 1), right(n);
ranges::iota(left, -1);
ranges::iota(right, 1);
vector<long long> a(nums.begin(), nums.end());
int ans = 0;
while (dec) {
ans++;
// 如果堆顶数据与实际数据不符，说明堆顶数据是之前本应删除，但没有删除的数据（懒删除）
while (right[pq.top().second] >= n || pq.top().first != a[pq.top().second] + a[right[pq.top().second]]) {
pq.pop();
}
auto [s, i] = pq.top();
pq.pop(); // 删除相邻元素和最小的一对
// (当前元素，下一个数)
int nxt = right[i];
dec -= a[i] > a[nxt]; // 旧数据
// (前一个数，当前元素)
int pre = left[i];
if (pre >= 0) {
dec -= a[pre] > a[i]; // 旧数据
dec += a[pre] > s; // 新数据
pq.emplace(a[pre] + s, pre);
}
// (下一个数，下下一个数)
int nxt2 = right[nxt];
if (nxt2 < n) {
dec -= a[nxt] > a[nxt2]; // 旧数据
dec += s > a[nxt2]; // 新数据（当前元素，下下一个数）
pq.emplace(s + a[nxt2], i);
}
a[i] = s;
// 删除 nxt
int l = left[nxt], r = right[nxt];
right[l] = r; // 模拟双向链表的删除操作
left[r] = l;
right[nxt] = n; // 表示删除 nxt
}
return ans;
}
};
###go
func minimumPairRemoval(nums []int) (ans int) {
n := len(nums)
h := make(hp, n-1)
dec := 0 // 递减的相邻对的个数
for i := range n - 1 {
x, y := nums[i], nums[i+1]
if x > y {
dec++
}
h[i] = pair{x + y, i}
}
heap.Init(&h)
lazy := map[pair]int{}
// 每个下标的左右最近的未删除下标
left := make([]int, n+1) // 加一个哨兵，防止下标越界
right := make([]int, n)
for i := range n {
left[i] = i - 1
right[i] = i + 1
}
remove := func(i int) {
l, r := left[i], right[i]
right[l] = r // 模拟双向链表的删除操作
left[r] = l
}
for dec > 0 {
ans++
for lazy[h[0]] > 0 {
lazy[h[0]]--
heap.Pop(&h)
}
p := heap.Pop(&h).(pair) // 删除相邻元素和最小的一对
s := p.s
i := p.i
// (当前元素，下一个数)
nxt := right[i]
if nums[i] > nums[nxt] { // 旧数据
dec--
}
// (前一个数，当前元素)
pre := left[i]
if pre >= 0 {
if nums[pre] > nums[i] { // 旧数据
dec--
}
if nums[pre] > s { // 新数据
dec++
}
lazy[pair{nums[pre] + nums[i], pre}]++ // 懒删除
heap.Push(&h, pair{nums[pre] + s, pre})
}
// (下一个数，下下一个数)
nxt2 := right[nxt]
if nxt2 < n {
if nums[nxt] > nums[nxt2] { // 旧数据
dec--
}
if s > nums[nxt2] { // 新数据（当前元素，下下一个数）
dec++
}
lazy[pair{nums[nxt] + nums[nxt2], nxt}]++ // 懒删除
heap.Push(&h, pair{s + nums[nxt2], i})
}
nums[i] = s
remove(nxt)
}
return
}
type pair struct{ s, i int } // (相邻元素和，左边那个数的下标)
type hp []pair
func (h hp) Len() int { return len(h) }
func (h hp) Less(i, j int) bool { a, b := h[i], h[j]; return a.s < b.s || a.s == b.s && a.i < b.i }
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v any) { *h = append(*h, v.(pair)) }
func (h *hp) Pop() any { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
###go
func minimumPairRemoval(nums []int) (ans int) {
n := len(nums)
h := make(hp, n-1)
dec := 0 // 递减的相邻对的个数
for i := range n - 1 {
x, y := nums[i], nums[i+1]
if x > y {
dec++
}
h[i] = pair{x + y, i}
}
heap.Init(&h)
// 每个下标的左右最近的未删除下标
left := make([]int, n+1) // 加一个哨兵，防止下标越界
right := make([]int, n)
for i := range n {
left[i] = i - 1
right[i] = i + 1
}
remove := func(i int) {
l, r := left[i], right[i]
right[l] = r // 模拟双向链表的删除操作
left[r] = l
right[i] = n // 表示 i 已被删除
}
for dec > 0 {
ans++
// 如果堆顶数据与实际数据不符，说明堆顶数据是之前本应删除，但没有删除的数据（懒删除）
for right[h[0].i] >= n || nums[h[0].i]+nums[right[h[0].i]] != h[0].s {
heap.Pop(&h)
}
p := heap.Pop(&h).(pair) // 删除相邻元素和最小的一对
s := p.s
i := p.i
// (当前元素，下一个数)
nxt := right[i]
if nums[i] > nums[nxt] { // 旧数据
dec--
}
// (前一个数，当前元素)
pre := left[i]
if pre >= 0 {
if nums[pre] > nums[i] { // 旧数据
dec--
}
if nums[pre] > s { // 新数据
dec++
}
heap.Push(&h, pair{nums[pre] + s, pre})
}
// (下一个数，下下一个数)
nxt2 := right[nxt]
if nxt2 < n {
if nums[nxt] > nums[nxt2] { // 旧数据
dec--
}
if s > nums[nxt2] { // 新数据（当前元素，下下一个数）
dec++
}
heap.Push(&h, pair{s + nums[nxt2], i})
}
nums[i] = s
remove(nxt)
}
return
}
type pair struct{ s, i int } // (相邻元素和，左边那个数的下标)
type hp []pair
func (h hp) Len() int { return len(h) }
func (h hp) Less(i, j int) bool { a, b := h[i], h[j]; return a.s < b.s || a.s == b.s && a.i < b.i }
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v any) { *h = append(*h, v.(pair)) }
func (h *hp) Pop() any { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
欢迎关注 B站@灵茶山艾府
在 Three.js 中，想要渲染任何东西，你需要理解3个核心概念：
import * as THREE from 'three';
// 1️⃣ 创建场景 - 所有物体的容器
const scene = new THREE.Scene();
// 2️⃣ 创建相机 - 决定我们从哪里看
const camera = new THREE.PerspectiveCamera(
75, // 视野角度
innerWidth / innerHeight, // 宽高比
0.1, // 近裁剪面
1000 // 远裁剪面
);
camera.position.z = 5; // 把相机往后移，才能看到原点的物体
// 3️⃣ 创建渲染器 - 把3D内容画到网页上
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
// 4️⃣ 画线！
// 定义线条经过的点
const points = [
new THREE.Vector3(-2, 0, 0), // 左边的点
new THREE.Vector3(0, 2, 0), // 顶部的点
new THREE.Vector3(2, 0, 0) // 右边的点
];
// 用这些点创建几何体
const geometry = new THREE.BufferGeometry().setFromPoints(points);
// 创建线条材质（绿色）
const material = new THREE.LineBasicMaterial({ color: 0x00ff00 });
// 组合几何体和材质，创建线条对象
const line = new THREE.Line(geometry, material);
// 把线条添加到场景中
scene.add(line);
// 5️⃣ 渲染！
renderer.render(scene, camera);
| 步骤 | 代码 | 说明 |
|---|---|---|
| 1 | BufferGeometry().setFromPoints(points) |
定义线条的形状（经过哪些点） |
| 2 | LineBasicMaterial({ color }) |
定义线条的外观（颜色） |
| 3 | new THREE.Line(geometry, material) |
把形状和外观组合成线条对象 |
📂 核心代码与完整示例： my-three-app
如果你喜欢本教程，记得点赞+收藏！关注我获取更多Three.js开发干货
所谓首屏，就是用户看到当前页面的第一屏，首屏时间就是第一屏被完全加载出来的时间点。
比如一个电商网站，首屏就包括导航栏、搜索框、商品头图等内容。那么，如何采集用户的首屏时间呢？
你可能会说，我直接用 Chrome DevTools 看一下就行了。
每次拿 Chrome DevTools 一看，好像自家网站的性能杠杠的，页面加载嘎嘎快，但结果却是用户反馈进入网站很卡，究其原因，这是由 Chrome DevTools 的局限性导致的：
Chrome DevTools 是内网访问，往往网络环境很好，而用户的网络环境就很复杂，在偏远地区或者电梯、地铁等弱网环境体验会更差。所以通过 Chrome DevTools 采集到的数据是不够准确的。所以我们需要通过添加相关代码进行采集，然后把采集到的数据上报到服务器中，这样就能获取大量用户的首屏时间数据。
采集方式一般有两种，手动采集和自动化采集。
手动采集一般是通过埋点的方式来实现：
优点：
缺点：
自动化采集就是指插入一段通用代码进行自动化采集。
优点：
缺点：
自动化采集对于不同的场景，采集方案也不一样:
SSR 来说，客户端拿到的就是拼接好的 html 字符串，所以直接采集 DOMContentLoaded 的时间即可。SPA 应用来说，DOMContentLoaded 的时间并不一定准确，因为里面的内容开始只有一个容器 <div id="app"></div>，后续内容是通过 js 动态渲染出来的，而用户需要看到完整的首屏实际内容，才能算首屏加载完成了。那么，如何准确采集单页面（SPA）应用的首屏时间呢？
首先先了解下单页应用的渲染大概流程：
index.html 文件；html 解析器解析 html 文件，并加载 css、js 等资源。js 代码，初始化框架 Vue/React/Angular，执行里面相关生命周期钩子，使用 xhr/axios 请求数据，并渲染 DOM 到页面上。那么，我们的核心就是需要知道，渲染 DOM 到页面上的时间。以 Vue 框架为例，它有一个 mounted(Vue2 Options API)、onMounted(Vue3 Composition API ) 钩子，可以拿到 DOM 加载的时间，那么我们是不是能利用这个钩子来进行首屏时间的采集呢？
显然是不行的，这样做有如下缺点：
mounted 采集的首屏时间就不准确了，如果要知道准确的时间，需要等请求完成的时间点进行采集，这样会侵入业务代码，违背了通用性，再说如果有多个请求抽离在各个地方，还需要用类似 Promise.all 进行整合，还是需要修改业务代码。mounted 的时间，图片内容可能并没有加载完，用户也看不到内容。所以，我们应该采用 MutationObserver 进行采集。它能监听 DOM 树的更改并执行相关的回调。核心的统计思路就是：在页面初始化时，使用 MutationObserver 监听 DOM 元素，当其发生变化时，程序会标记变化的元素，并记录时间点和分数，存储到数组中，当达到如下条件时，说明首屏渲染已经结束：
30s 还没结束。4 次且 1s 内分数不再变化。9 次且分数不再变化。统计分数过程如下：
1 ，渲染完成得 1 分，没增加一层权重增加 0.5，第三层的权重为 3.5，也就是渲染完成得 3.5 分。最终，我们拿到一个记录了时间点和分数的数组，然后通过数组的后一项 - 数组前一项求出元素分数变化率，找到变化率最大点的分数对应的时间，即为首屏时间。
那这样算出来的首屏时间是否准确呢？其实不然，像我们之前说的首屏为一张图片的情况，就采集的不准。
所以对于图片来说，我们需要拿到页面中所有的 img，其来源主要有两方面：
img 标签：通过拿到 dom 节点，判断其 nodeName.toUpperCase === 'IMG'。background: url("https://static.xxx.png")。可以通过如下方式来拿到：if (dom.nodeName.toUpperCase !== 'IMG') {
const domStyle = window.getComputedStyle(dom);
const imgUrl = domStyle.getPropertyValue('background-image') || domStyle.getPropertyValue('background');
}
拿到图片的 url 之后，通过 performance.getEntriesByName(imgUrl)[0].responseEnd 获取图片的加载时间，然后拿到图片最长的加载时间和之前变化率最大点的分数对应的时间进行对比，哪个更长哪个就是最终的首屏时间。
Chrome DevTools 拿到的首屏时间存在偏差。DOMContentLoaded 时间即可，而单页应用则需要使用 MutationObserver 监听 DOM，并设置元素权重，统计每个元素的分数和时间，最终拿到变化率最大的分数及时间点。我问大家一个问题，什么是 AI 的产品形态？
大模型只是底层的处理引擎，你总是需要一个应用层产品，对接用户的需求。这种 AI 的应用层，就称为"智能体"（agent）。
那么，问题就变成了，"智能体"应该是什么样？
早期的智能体只是对话应用（上图），后面加入了推理，可以思考复杂问题。
后来，向专业领域发展，演变出编程智能体（coding agent）、图像智能体、视频智能体等等，或者接入 MCP，获得外部应用操作能力，比如生成 Office 文件、操作浏览器。
这些形态基本已经成熟了，很多公司开始探索，下一阶段的智能体会是什么形态？
我最近在用 MiniMax 刚发布的 AI native Workspace（AI 原生工作台），欣喜地觉得，这可能就是答案。
这个新产品，同时加入了 Anthropic 公司最近提出的两个新概念：Cowork 和 Skill。
所谓 Cowork，简单说，就是一个"计算机操作助手"。它本质是编程智能体的图形界面版，让不懂编程的用户，用自然语言说出需求，再通过 AI 生成底层代码并执行，自动操作本地计算机完成任务。
而 Skill 就更简单了，它是一篇预设的提示词，相当于"使用手册"，向 AI 详细描述如何完成某一种特定任务。可以这样理解，每一个 Skill 就是一个专家，让 AI 拥有特定领域的技能。
这两个东西，一个是操作助手，一个是专家模式。前者用 AI 来操作计算机，后者让 AI 具备专门技能。
它们结合起来会怎样？
MiniMax AI native Workspace 就是这样一个产品，探索性地将 Cowork 和 Skill 结合在一起，同时具备两种能力，完全是一种全新的产品形态。
它的桌面端（desktop）提供 Cowork 能力，专家模式（experts）则提供 Skill 能力。
下面，我来展示，它跟传统智能体的差异在哪里。
它的桌面客户端定位就是"AI 原生工作台"，具备以下能力。
- 直接访问本地文件：能够读写，以及自动上传或下载文件。
- 自动化工作流程：能够分解任务，运行 Web 自动化。
- 交付专业成果：运行结束后可以生成高质量的交付产物，比如 Excel 电子表格、PowerPoint 幻灯片、格式化文档。
- 长时间运行任务：对于复杂任务，可以长时间运行，不受对话超时或上下文限制的影响。
注意，由于它可以操作计算机，并跟互联网通信，执行之前，一定要指定目录，防止读写不该操作的目录，而且要有备份，防止原始文件被删改。
首先，前往官网下载桌面客户端，Windows/Mac 版本均有，新注册用户目前可以免费试用3天。
安装后运行，直接进入任务界面，就是一个传统的对话框。
这时指定运行目录，就进入"工作台"模式，可以对该目录进行操作。软件会跳出一个警告，提示风险。
这时，就可以让它执行各种任务了。比如，我让它整理各种电子服务的发票 PDF 文件，然后生成一个汇总的 Excel 文档。
这时，它会在当前目录里面，自动安装一个 Python 虚拟环境，然后生成 Python 脚本并执行。
很快就生成好了 Excel 文件。
以此类推，各种文件整理的事情，都能交给它，比如整理照片、文件重命名等等。
它还能进行网页自动化，比如自动浏览某个网页，并提取信息、总结内容。
上面展示了它的工作台功能，可以担当"数字员工"，下面再来看看它的"专家系统"。
所谓"专家系统"，就是注入特定的提示词文件，扩展智能体的技能，相当于深度的知识和能力注入。用户还可以上传私有知识库。
大家可以打开它的网页端，点击左边栏的"探索专家"。
系统内置了一些"预设专家"，可以直接使用。
我选了一个系统提供的"Icon 制作器"，就是制作 Logo 的技能，看看好不好用。
我要求制作一个"熊猫吃冰淇淋"的 Logo，系统提示要选择一种设计风格。
最后生成了两个文件（坐姿和站姿）供选择，效果还不错。
除了预设的专家，系统也允许你创建"我的专家"，也就是某种自定义技能。
你需要输入能力描述和指令，还可以添加对应的 MCP、SubAgent、环境变量、Supabase 数据库等等。
我直接把 Anthropic 公司提供的 Skill 文件输入，看看效果。
我选了 frontend-design（前端设计）技能，输入以后就可以在"我的专家"分页上看到。
注意，系统目前只支持输入技能描述文件，还不支持上传静态资源文件（asset），希望后面可以加上。
选中这个专家以后，我要求生成一个算法可视化页面。
"生成一个排序算法可视化网站，列出常见排序算法的可视化动画。选中某个算法后，会展示该算法的动画效果。"
生成过程大概十分钟左右，就得到了结果。系统生成了十种排序算法的动画，并直接部署上线。
我后来又调整了一下动画配色，大家可以去这个网站看看效果，还是很酷的。
AI native Workspace 将 AI 智能体引入了本地计算机，可以进行自动化操作，同时加入技能接口，允许注入外部知识和能力。并且，所有操作都可以通过自然语言对话完成，对用户的要求低。
这一下子打开了 AI 智能体的想象空间，它所能完成的任务，将不再受限于模型的能力，而只受限于我们的想象力。
我认为，这个产品代表了下一阶段 AI 智能体的发展方向，将开启很多全新的可能性，等待我们去探索。
（完）
思路与算法
由于数据范围非常小，故直接按题意模拟即可。
遍历 $\textit{nums}$ 的相邻元素，维护最小相邻数对和的同时判断 $\textit{nums}$ 是否满足非严格单调递增，如果不满足条件则更新数组，将相邻数对合并为新元素。重复以上操作，直到满足非严格单调递增的条件或 $\textit{nums}$ 的长度为 $1$ 为止。
代码
###C++
class Solution {
public:
int minimumPairRemoval(std::vector<int>& nums) {
int count = 0;
while (nums.size() > 1) {
bool isAscending = true;
int minSum = std::numeric_limits<int>::max();
int targetIndex = -1;
for (size_t i = 0; i < nums.size() - 1; ++i) {
int sum = nums[i] + nums[i + 1];
if (nums[i] > nums[i + 1]) {
isAscending = false;
}
if (sum < minSum) {
minSum = sum;
targetIndex = static_cast<int>(i);
}
}
if (isAscending) {
break;
}
count++;
nums[targetIndex] = minSum;
nums.erase(nums.begin() + targetIndex + 1);
}
return count;
}
};
###Java
class Solution {
public int minimumPairRemoval(int[] nums) {
List<Integer> list = new ArrayList<>();
for (int num : nums) {
list.add(num);
}
var count = 0;
while (list.size() > 1) {
var isAscending = true;
var minSum = Integer.MAX_VALUE;
var targetIndex = -1;
for (var i = 0; i < list.size() - 1; i++) {
var sum = list.get(i) + list.get(i + 1);
if (list.get(i) > list.get(i + 1)) {
isAscending = false;
}
if (sum < minSum) {
minSum = sum;
targetIndex = i;
}
}
if (isAscending) {
break;
}
count++;
list.set(targetIndex, minSum);
list.remove(targetIndex + 1);
}
return count;
}
}
###Python
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
count = 0
while len(nums) > 1:
isAscending = True
minSum = float("inf")
targetIndex = -1
for i in range(len(nums) - 1):
pair_sum = nums[i] + nums[i + 1]
if nums[i] > nums[i + 1]:
isAscending = False
if pair_sum < minSum:
minSum = pair_sum
targetIndex = i
if isAscending:
break
count += 1
nums[targetIndex] = minSum
nums.pop(targetIndex + 1)
return count
###C#
public class Solution {
public int MinimumPairRemoval(int[] nums) {
var count = 0;
var list = nums.ToList();
while (list.Count > 1) {
var isAscending = true;
var minSum = int.MaxValue;
var targetIndex = -1;
for (var i = 0; i < list.Count - 1; i++) {
var sum = list[i] + list[i + 1];
if (list[i] > list[i + 1]) {
isAscending = false;
}
if (sum < minSum) {
minSum = sum;
targetIndex = i;
}
}
if (isAscending) {
break;
}
count++;
list[targetIndex] = minSum;
list.RemoveAt(targetIndex + 1);
}
return count;
}
}
###JavaScript
var minimumPairRemoval = function (nums) {
let count = 0;
while (nums.length > 1) {
let isAscending = true;
let minSum = Infinity;
let targetIndex = -1;
for (let i = 0; i < nums.length - 1; i++) {
const sum = nums[i] + nums[i + 1];
if (nums[i] > nums[i + 1]) {
isAscending = false;
}
if (sum < minSum) {
minSum = sum;
targetIndex = i;
}
}
if (isAscending) {
break;
}
count++;
nums[targetIndex] = minSum;
nums.splice(targetIndex + 1, 1);
}
return count;
}
###TypeScript
function minimumPairRemoval(nums: number[]): number {
let count = 0;
while (nums.length > 1) {
let isAscending = true;
let minSum = Infinity;
let targetIndex = -1;
for (let i = 0; i < nums.length - 1; i++) {
const sum = nums[i] + nums[i + 1];
if (nums[i] > nums[i + 1]) {
isAscending = false;
}
if (sum < minSum) {
minSum = sum;
targetIndex = i;
}
}
if (isAscending) {
break;
}
count++;
nums[targetIndex] = minSum;
nums.splice(targetIndex + 1, 1);
}
return count;
}
###Go
func minimumPairRemoval(nums []int) int {
count := 0
for len(nums) > 1 {
isAscending := true
minSum := 1 << 31 - 1
targetIndex := -1
for i := 0; i < len(nums)-1; i++ {
sum := nums[i] + nums[i+1]
if nums[i] > nums[i+1] {
isAscending = false
}
if sum < minSum {
minSum = sum
targetIndex = i
}
}
if isAscending {
break
}
count++
nums[targetIndex] = minSum
nums = append(nums[:targetIndex+1], nums[targetIndex + 2:]...)
}
return count
}
###C
int minimumPairRemoval(int* nums, int numsSize) {
int count = 0;
int size = numsSize;
while (size > 1) {
int isAscending = 1;
int minSum = INT_MAX;
int targetIndex = -1;
for (int i = 0; i < size - 1; i++) {
int sum = nums[i] + nums[i + 1];
if (nums[i] > nums[i + 1]) {
isAscending = 0;
}
if (sum < minSum) {
minSum = sum;
targetIndex = i;
}
}
if (isAscending) {
break;
}
count++;
nums[targetIndex] = minSum;
for (int i = targetIndex + 1; i < size - 1; i++) {
nums[i] = nums[i + 1];
}
size--;
}
return count;
}
###Rust
impl Solution {
pub fn minimum_pair_removal(nums: Vec<i32>) -> i32 {
let mut count = 0;
let mut nums = nums.clone();
while nums.len() > 1 {
let mut is_ascending = true;
let mut min_sum = i32::MAX;
let mut target_index = -1;
for i in 0..nums.len() - 1 {
let sum = nums[i] + nums[i + 1];
if nums[i] > nums[i + 1] {
is_ascending = false;
}
if sum < min_sum {
min_sum = sum;
target_index = i as i32;
}
}
if is_ascending {
break;
}
count += 1;
let ti = target_index as usize;
nums[ti] = min_sum;
nums.remove(ti + 1);
}
count
}
}
复杂度分析
时间复杂度：$O(n^2)$，其中 $n$ 是 $\textit{nums}$ 的长度。合并数对最多进行 $n$ 次；判断单调性、寻找数对和删除数组中的元素均需要消耗 $O(n)$ 的时间，故总时间复杂度为 $O(n^2)$。
空间复杂度：$O(1)$，只用到了常数个变量。
思路与算法
除了直接在数组上移除元素外，也可以采用模拟链表的思路，从而支持 $O(1)$ 的删除操作。考虑维护一个 $\textit{next}$ 数组，代表下标 $i$ 处元素的下一个元素所在位置。由于不管是判断单调性，还是寻找最小相邻数对和，都只是对线性表的顺序遍历，因此遍历部分的逻辑基本和方法一基本相同，只需要在删除元素的时候维护 $\textit{next}$ 数组，将目标元素的下一个元素指向下下个元素即可。
代码
###C++
class Solution {
public:
int minimumPairRemoval(std::vector<int>& nums) {
int n = nums.size();
std::vector<int> next(n);
std::iota(next.begin(), next.end(), 1);
next[n - 1] = -1;
int count = 0;
while (n - count > 1) {
int curr = 0;
int target = 0;
int targetAdjSum = nums[target] + nums[next[target]];
bool isAscending = true;
while (curr != -1 && next[curr] != -1) {
if (nums[curr] > nums[next[curr]]) {
isAscending = false;
}
int currAdjSum = nums[curr] + nums[next[curr]];
if (currAdjSum < targetAdjSum) {
target = curr;
targetAdjSum = currAdjSum;
}
curr = next[curr];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]];
nums[target] = targetAdjSum;
}
return count;
}
};
###Java
class Solution {
public int minimumPairRemoval(int[] nums) {
var n = nums.length;
var next = new int[n];
Arrays.setAll(next, i -> i + 1);
next[n - 1] = -1;
var count = 0;
while (n - count > 1) {
var curr = 0;
var target = 0;
var targetAdjSum = nums[target] + nums[next[target]];
var isAscending = true;
while (curr != -1 && next[curr] != -1) {
if (nums[curr] > nums[next[curr]]) {
isAscending = false;
}
var currAdjSum = nums[curr] + nums[next[curr]];
if (currAdjSum < targetAdjSum) {
target = curr;
targetAdjSum = currAdjSum;
}
curr = next[curr];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]];
nums[target] = targetAdjSum;
}
return count;
}
}
###Python
class Solution:
def minimumPairRemoval(self, nums: List[int]) -> int:
next_node = list(range(1, len(nums) + 1))
next_node[-1] = None
count = 0
while len(nums) - count > 1:
curr = 0
target = 0
target_adj_sum = nums[target] + nums[next_node[target]]
is_ascending = True
while curr is not None and next_node[curr] is not None:
if nums[curr] > nums[next_node[curr]]:
is_ascending = False
curr_adj_sum = nums[curr] + nums[next_node[curr]]
if curr_adj_sum < target_adj_sum:
target = curr
target_adj_sum = curr_adj_sum
curr = next_node[curr]
if is_ascending:
break
count += 1
next_node[target] = next_node[next_node[target]]
nums[target] = target_adj_sum
return count
###C#
public class Solution {
public int MinimumPairRemoval(int[] nums) {
var next = new int?[nums.Length];
for (var i = 0; i < nums.Length - 1; i++) next[i] = i + 1;
var count = 0;
while (nums.Length - count > 1) {
int? curr = 0;
var target = 0;
var targetAdjSum = nums[target] + nums[next[target]!.Value];
var isAscending = true;
while (curr is not null && next[curr.Value] is not null) {
var nextVal = next[curr.Value]!.Value;
if (nums[curr.Value] > nums[nextVal]) {
isAscending = false;
}
var currAdjSum = nums[curr.Value] + nums[nextVal];
if (currAdjSum < targetAdjSum) {
target = curr.Value;
targetAdjSum = currAdjSum;
}
curr = next[curr.Value];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]!.Value];
nums[target] = targetAdjSum;
}
return count;
}
}
###JavaScript
var minimumPairRemoval = function (nums) {
const next = nums.map((_, i) => i + 1);
next[nums.length - 1] = null;
let count = 0;
while (nums.length - count > 1) {
let curr = 0;
let target = 0;
let targetAdjSum = nums[target] + nums[next[target]];
let isAscending = true;
while (curr !== null && next[curr] !== null) {
if (nums[curr] > nums[next[curr]]) {
isAscending = false;
}
let currAdjSum = nums[curr] + nums[next[curr]];
if (currAdjSum < targetAdjSum) {
target = curr;
targetAdjSum = currAdjSum;
}
curr = next[curr];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]];
nums[target] = targetAdjSum;
}
return count;
}
###TypeScript
function minimumPairRemoval(nums: number[]): number {
const next = nums.map<number | null>((_, i) => i + 1);
next[nums.length - 1] = null;
let count = 0;
while (nums.length - count > 1) {
let curr: number | null = 0;
let target = 0;
let targetAdjSum = nums[target] + nums[next[target]!];
let isAscending = true;
while (curr !== null && next[curr] !== null) {
if (nums[curr] > nums[next[curr]!]) {
isAscending = false;
}
let currAdjSum = nums[curr] + nums[next[curr]!];
if (currAdjSum < targetAdjSum) {
target = curr;
targetAdjSum = currAdjSum;
}
curr = next[curr];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]!];
nums[target] = targetAdjSum;
}
return count;
}
###Go
func minimumPairRemoval(nums []int) int {
n := len(nums)
next := make([]int, n)
for i := 0; i < n; i++ {
next[i] = i + 1
}
next[n - 1] = -1
count := 0
for n - count > 1 {
curr := 0
target := 0
targetAdjSum := nums[target] + nums[next[target]]
isAscending := true
for curr != -1 && next[curr] != -1 {
if nums[curr] > nums[next[curr]] {
isAscending = false
}
currAdjSum := nums[curr] + nums[next[curr]]
if currAdjSum < targetAdjSum {
target = curr
targetAdjSum = currAdjSum
}
curr = next[curr]
}
if isAscending {
break
}
count++
next[target] = next[next[target]]
nums[target] = targetAdjSum
}
return count
}
###C
int minimumPairRemoval(int* nums, int n) {
int* next = (int*)malloc(n * sizeof(int));
if (next == NULL) {
return -1;
}
for (int i = 0; i < n; i++) {
next[i] = i + 1;
}
next[n - 1] = -1;
int count = 0;
while (n - count > 1) {
int curr = 0;
int target = 0;
int targetAdjSum = nums[target] + nums[next[target]];
int isAscending = 1;
while (curr != -1 && next[curr] != -1) {
if (nums[curr] > nums[next[curr]]) {
isAscending = 0;
}
int currAdjSum = nums[curr] + nums[next[curr]];
if (currAdjSum < targetAdjSum) {
target = curr;
targetAdjSum = currAdjSum;
}
curr = next[curr];
}
if (isAscending) {
break;
}
count++;
next[target] = next[next[target]];
nums[target] = targetAdjSum;
}
free(next);
return count;
}
###Rust
impl Solution {
pub fn minimum_pair_removal(nums: Vec<i32>) -> i32 {
let n = nums.len();
let mut nums = nums.clone();
let mut next: Vec<isize> = (0..n as isize).map(|i| i + 1).collect();
next[n - 1] = -1;
let mut count = 0;
while (n as i32 - count) > 1 {
let mut curr: isize = 0;
let mut target: isize = 0;
let mut target_adj_sum = nums[0] + nums[next[0] as usize];
let mut is_ascending = true;
while curr != -1 && next[curr as usize] != -1 {
let curr_idx = curr as usize;
let next_idx = next[curr_idx] as usize;
if nums[curr_idx] > nums[next_idx] {
is_ascending = false;
}
let curr_adj_sum = nums[curr_idx] + nums[next_idx];
if curr_adj_sum < target_adj_sum {
target = curr;
target_adj_sum = curr_adj_sum;
}
curr = next[curr_idx];
}
if is_ascending {
break;
}
count += 1;
let target_idx = target as usize;
let next_target = next[target_idx] as usize;
next[target_idx] = next[next_target];
nums[target_idx] = target_adj_sum;
}
count
}
}
复杂度分析
时间复杂度：$O(n^2)$，其中 $n$ 是 $\textit{nums}$ 的长度。具体分析同方法一，只是删除操作此时只需 $O(1)$ 即可完成。
空间复杂度：$O(n)$，$\textit{next}$ 数组需要使用 $O(n)$ 的辅助空间。
一个命令，管理所有 AI Skill。告别重复安装，拥抱统一管理。
想象一下这个场景：你同时使用 Cursor、Claude Code、Windsurf 等多个 AI 编程助手。每次发现一个好用的技能（Skill），你都需要：
更糟糕的是，如果你是一个技能开发者，想要测试你的技能在不同 AI 代理上的表现，你需要：
eskill 是一个革命性的 CLI 工具，它彻底改变了 AI 代理技能的管理方式。
一个统一的技能库，自动分发到所有 AI 代理
# 安装一个技能
eskill install my-awesome-skill
# ✨ 自动检测并链接到：
# ✅ Cursor (~/.cursor/skills)
# ✅ Claude Code (~/.claude/skills)
# ✅ Windsurf (~/.windsurf/skills)
# ✅ Cline (~/.cline/skills)
# ✅ Gemini Code (~/.gemini/skills)
# ✅ GitHub Copilot (~/.copilot/skills)
# ✅ ... 还有更多！
就这么简单！ 一次安装，所有已安装的 AI 代理都能立即使用。
所有技能统一存储在 ~/.emp-agent/skills/，通过符号链接（symlink）技术智能分发到各个 AI 代理。
优势：
自动检测你系统中已安装的所有 AI 代理，无需手动配置。
支持的 AI 代理（13+）：
还在不断增加中！
支持从多种来源安装技能：
# 从 NPM 安装
eskill install @myorg/react-skill
# 从 Git 仓库安装
eskill install https://github.com/user/repo/tree/main/skills/my-skill
# 从本地目录安装（开发模式）
eskill install ./my-local-skill --link
这是技能开发者的福音！
# 进入你的技能目录
cd ~/projects/my-skill
# 链接到开发环境
eskill install . --link
# ✨ 现在修改代码，所有 AI 代理立即生效！
# 无需重新打包，无需重新安装
开发体验提升 10 倍！
# 安装到所有代理（默认）
eskill install my-skill
# 只安装到特定代理
eskill install my-skill --agent cursor
# 强制重新安装
eskill install my-skill --force
使用操作系统的符号链接功能，实现零拷贝的技能分发：
~/.emp-agent/skills/my-skill/ # 实际存储位置
├── SKILL.md
└── references/
~/.cursor/skills/my-skill -> ~/.emp-agent/skills/my-skill # 符号链接
~/.claude/skills/my-skill -> ~/.emp-agent/skills/my-skill # 符号链接
优势：
支持复杂的 Git URL 解析：
# 支持分支
eskill install https://github.com/user/repo/tree/dev/skills/my-skill
# 支持子目录
eskill install https://github.com/user/repo/tree/main/packages/skill
# 自动提取技能名称
痛点： 需要在多个 AI 代理上使用相同的技能
解决方案：
eskill install react-best-practices
# 自动在所有已安装的代理上可用
痛点： 开发技能时需要频繁测试
解决方案：
eskill install . --link
# 修改代码，立即在所有代理上测试
痛点： 团队成员需要统一管理技能
解决方案：
# 统一从 NPM 或 Git 安装
eskill install @team/shared-skills
# 确保团队使用相同版本的技能
痛点： 想尝试新技能，但不确定是否适合
解决方案：
eskill install experimental-skill
eskill list # 查看所有已安装的技能
eskill remove experimental-skill # 轻松卸载
# 使用 pnpm（推荐）
pnpm add -g @empjs/skill
# 或使用 npm
npm install -g @empjs/skill
# 或使用 yarn
yarn global add @empjs/skill
# 或使用 bun
bun install -g @empjs/skill
# 查看可用的技能
eskill list
# 安装一个技能
eskill install <skill-name>
# 查看已安装的技能
eskill list
# 查看支持的 AI 代理
eskill agents
| 特性 | 传统方式 | eskill |
|---|---|---|
| 安装步骤 | 每个代理单独安装 | 一次安装，全平台可用 |
| 存储空间 | 每个代理一份副本 | 统一存储，节省空间 |
| 更新效率 | 需要逐个更新 | 一次更新，全部生效 |
| 开发体验 | 打包→安装→测试循环 | 链接模式，即时生效 |
| 管理复杂度 | 高（多个目录） | 低（统一管理） |
eskill 正在快速发展，未来将支持：
试试看，只需要 30 秒：
# 1. 安装 eskill
pnpm add -g @empjs/skill
# 2. 查看你的 AI 代理
eskill agents
# 3. 安装一个技能试试
eskill install <any-skill-name>
如果它不能提升你的效率，卸载它只需要：
npm uninstall -g @empjs/skill
但相信我，一旦你体验过统一管理的便利，就再也回不去了！ 🎉
现在就试试 eskill，让 AI 代理技能管理变得前所未有的简单！
pnpm add -g @empjs/skill
一个命令，改变你的工作流。 ✨
Array
modules是Nuxt.js扩展，可以扩展它的核心功能并添加无限。
例如(nuxt.config.js)：
export default {
modules: [
// Using package name
'@nuxtjs/axios',
// Relative to your project srcDir
'~/modules/awesome.js',
// Providing options
['@nuxtjs/google-analytics', { ua: 'X1234567' }],
// Inline definition
function() {}
]
}
安装过程中，它会让我们选择模块。
Axios - Promise based HTTP client
// nuxt.config.js
{
modules: [
'@nuxtjs/axios' // 前面安装nuxtjs的时候没选，也可以后续一条命令去装上去 ==> npm install @nuxtjs/axios -initial-scale
]
}
// 笔记.html
一、安装nuxt的axios
1.1 npm install @nuxtjs/axios -S
1.2 nuxt.config.js进行配置
modules: [
'@nuxtjs/axios',
]
二、安装axios
2.1 npm install axios -S
在每一个页面中或者每个component中用axios。
<template>
<div>页面</div>
</template>
<script>
import axios from 'axios'
export default {
name: 'IndexPage'
}
</script>
在nuxt中如何请求接口。两种方式：
请求接口一定是首先先把服务器端的接口拿到了。然后再打开页面，这个时候源代码中就有接口数据了。那这个时候蜘蛛就可以爬取到这个数据了。如果还是像vue一样，这个页面打开了，再把数据返回来，那蜘蛛就抓取不到了。
在页面中有一个生命周期。叫asyncData。
Nuxt.js扩展了Vue.js，增加了一个叫asyncData的方法，使得我们可以在设置组件的数据之前能异步获取或处理数据。
这个是个生命周期。
asyncData方法会在组件（限于页面组件）每次加载之前被调用。可在服务端或路由更新之前被调用。
在这个方法被调用的时候，第一个参数被设定为当前页面的上下文对象，可以用asyncData方法来获取数据，
三、asyncData生命周期 || 方法
pages 目录中的页面组件才可以去用
***注意components内的.vue文件是不可以使用的。
// index.vue
<template>
<div>首页</div>
</template>
<script type="text/script">
export default {
data() {},
asyncData(app) {
console.log(app)
}
}
</script>
可以看到，app对象下面有一个$axios；
在控制台，和在服务端都可以打印出来。
所以也可以这样子写：
// index.vue
<template>
<div>首页</div>
</template>
<script type="text/script">
export default {
data() {},
asyncData({ $axios }) {
console.log($axios)
}
}
</script>
这样子就可以去请求接口，放进去。
接口给过来，都是后端代码上面去解决跨域问题。至于nuxt如何解决跨域，待会说。
这里写一个async 和 await
// pages/index.vue
<template>
<div>首页</div>
</template>
<script>
export default {
name: 'IndexPage',
async asyncData({ $axios }) {
const res = await $axios('后端给的接口地址')
console.log(res)
}
}
</scirpt>
拿到数据之后呢，要把数据渲染到也米娜上，如果是vue的话，
// pages/index.vue
<template>
<div>
<ul>
<li v-for='item in list' :key='item.id'>
{{ item.imageName }}
</li>
</ul>
</div>
</template>
<script>
export default {
name: 'IndexPage',
data () {
return {
list: []
}
},
async asyncData({ $axios }) {
const res = await $axios('后端给的接口地址')
const list = res.data
console.log(res)
// 要这样
return { list }
// 不要这样
this.list = list
}
}
</scirpt>
按照vue来讲，这上面完全没问题，但是nuxt中不行。其实不是nuxt不行，而是asyncData不行，在asyncData中是不能写this的，因为在asyncData中this是undefined。
注意：在asyncData中没有this。
其实在这个地方，有写到，说要return。说白了,nuxt.js会将asyncData返回的数据融合组件data方法返回的数据并返回给当前组件。
其实就是data () { return { list: [] } }，和asyncData里面的return 合并数据，然后。
然后重新去看页面，就可以看到页面生效了。
还有方式请求接口。
四、fetch生命周期 || 方法
首先fetch是在aysncData之后的生命周期，然后fetch也有参数({ $axios })，它也是当前组件的上下文，所以这里的$axios也有接口请求，
// pages/index.vue
<template>
<div>
<News />
<ul>
<li v-for='item in list' :key='item.id'>
{{ item.imageName }}
</li>
</ul>
</div>
</template>
<script>
export default {
name: 'IndexPage',
data () {
return {
list: [],
items: []
}
},
async asyncData({ $axios }) {
const res = await $axios('后端给的接口地址')
const list = res.data
console.log(res)
// 要这样
return { list }
// 不要这样
this.list = list
},
// 注意fetch里面是可以有this的
async fetch({ $axios }) {
const res = await $axios('后端给的接口地址')
const list = res.data
this.items = list
}
}
</scirpt>
不过在页面上能拿到数据，不过在template上打印出来是空数组。所以说在页面级的请求用asyncData。
四、fetch生命周期 || 方法
fetch是有this的
在components下创建个News.vue:
<template>
<div>111</div>
</template>
<script>
export default {
// 注意fetch里面是可以有this的
async fetch({ $axios }) {
const res = await $axios('后端给的接口地址')
const list = res.data
this.items = list
}
}
</script>
刚刚提到的一点，asyncData在页面级别的组件是可以拿到的，可以执行的，在某个组件中，component中。asyncData是不能用在component上的，那它这种只能引入fetch，必须用fetch。
fetch方法用于在渲染页面前填充应用的状态树（store）数据，与asyncData方法类似，不同的是它不会设置组件的数据。
四、fetch生命周期 || 方法
fetch是有this的
在components下创建个News.vue:
<template>
<div>111</div>
</template>
<script>
export default {
// 注意fetch里面是可以有this的
async fetch({ $axios }) {
// 在组件中，这里是没有$axios的，
const res = await $axios('后端给的接口地址')
const list = res.data
this.items = list
}
}
</script>
<template>
<div>
111
{{ list }}
</div>
</template>
<script>
export default {
data () {
return {
list
}
},
// 注意fetch里面是可以有this的
async fetch() {
// 正确
const res = await this.$axios('后端给的接口地址')
const list = res.data
this.list = list
}
}
</script>
本文档涵盖Three.js中高级着色器图形特效的实现方法，基于实际代码示例进行讲解。
最终效果如图：
import * as THREE from "three";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
import gsap from "gsap";
import * as dat from "dat.gui";
import deepVertexShader from "../shaders/deep/vertex.glsl";
import deepFragmentShader from "../shaders/deep/fragment.glsl";
// 创建带有多个uniforms的着色器材质
const shaderMaterial = new THREE.ShaderMaterial({
vertexShader: deepVertexShader,
fragmentShader: deepFragmentShader,
uniforms: {
uColor: {
value: new THREE.Color("purple"),
},
// 波浪的频率
uFrequency: {
value: params.uFrequency,
},
// 波浪的幅度
uScale: {
value: params.uScale,
},
// 动画时间
uTime: {
value: 0,
},
uTexture: {
value: texture,
},
},
side: THREE.DoubleSide,
transparent: true,
});
通过dat.GUI实时控制着色器参数：
// 控制频率参数
gui
.add(params, "uFrequency")
.min(0)
.max(50)
.step(0.1)
.onChange((value) => {
shaderMaterial.uniforms.uFrequency.value = value;
});
// 控制幅度参数
gui
.add(params, "uScale")
.min(0)
.max(1)
.step(0.01)
.onChange((value) => {
shaderMaterial.uniforms.uScale.value = value;
});
UV坐标是纹理映射的基础，也是创建各种图形效果的关键：
void main(){
// 1. 通过顶点对应的uv，决定每一个像素在uv图像的位置，通过这个位置x,y决定颜色
// gl_FragColor =vec4(vUv,0,1) ;
// 2. 对第一种变形
// gl_FragColor = vec4(vUv,1,1);
// 3. 利用uv实现渐变效果,从左到右
float strength = vUv.x;
gl_FragColor =vec4(strength,strength,strength,1);
}
利用GLSL内置数学函数创建复杂效果：
// 随机函数
float random (vec2 st) {
return fract(sin(dot(st.xy,vec2(12.9898,78.233)))*43758.5453123);
}
// 噪声函数
float noise (in vec2 _st) {
vec2 i = floor(_st);
vec2 f = fract(_st);
// 四个角落的随机值
float a = random(i);
float b = random(i + vec2(1.0, 0.0));
float c = random(i + vec2(0.0, 1.0));
float d = random(i + vec2(1.0, 1.0));
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(a, b, u.x) +
(c - a)* u.y * (1.0 - u.x) +
(d - b) * u.x * u.y;
}
使用数学函数绘制各种几何图形：
// 绘制圆形
float strength = 1.0 - step(0.5,distance(vUv,vec2(0.5))+0.25) ;
gl_FragColor =vec4(strength,strength,strength,1);
// 绘制圆环
float strength = step(0.5,distance(vUv,vec2(0.5))+0.35) ;
strength *= (1.0 - step(0.5,distance(vUv,vec2(0.5))+0.25)) ;
gl_FragColor =vec4(strength,strength,strength,1);
// 波浪效果
vec2 waveUv = vec2(
vUv.x+sin(vUv.y*100.0)*0.1,
vUv.y+sin(vUv.x*100.0)*0.1
);
float strength = 1.0 - step(0.01,abs(distance(waveUv,vec2(0.5))-0.25)) ;
gl_FragColor =vec4(strength,strength,strength,1);
在动画循环中更新时间uniform：
const clock = new THREE.Clock();
function animate(t) {
const elapsedTime = clock.getElapsedTime();
shaderMaterial.uniforms.uTime.value = elapsedTime; // 更新时间
requestAnimationFrame(animate);
renderer.render(scene, camera);
}
// 使用时间创建波浪动画
float strength = step(0.9,sin(cnoise(vUv * 10.0)*20.0+uTime)) ;
// 波纹效果
float strength = sin(cnoise(vUv * 10.0)*5.0+uTime) ;
// 使用混合函数混颜色
vec3 purpleColor = vec3(1.0, 0.0, 1.0);
vec3 greenColor = vec3(1.0, 1.0, 1.0);
vec3 uvColor = vec3(vUv,1.0);
float strength = step(0.9,sin(cnoise(vUv * 10.0)*20.0)) ;
vec3 mixColor = mix(greenColor,uvColor,strength);
gl_FragColor =vec4(mixColor,1.0);
uniform sampler2D uTexture;
void main(){
vec4 textureColor = texture2D(uTexture,vUv);
textureColor.rgb*=height;
gl_FragColor = textureColor;
}
// 旋转函数
vec2 rotate(vec2 uv, float rotation, vec2 mid)
{
return vec2(
cos(rotation) * (uv.x - mid.x) + sin(rotation) * (uv.y - mid.y) + mid.x,
cos(rotation) * (uv.y - mid.y) - sin(rotation) * (uv.x - mid.x) + mid.y
);
}
// 使用旋转函数
vec2 rotateUv = rotate(vUv,-uTime*5.0,vec2(0.5));
// 万花筒效果
float angle = atan(vUv.x-0.5,vUv.y-0.5)/PI;
float strength = mod(angle*10.0,1.0);
gl_FragColor =vec4(strength,strength,strength,1);
// 雷达扫描效果
vec2 rotateUv = rotate(vUv,-uTime*5.0,vec2(0.5));
float alpha = 1.0 - step(0.5,distance(vUv,vec2(0.5)));
float angle = atan(rotateUv.x-0.5,rotateUv.y-0.5);
float strength = (angle+3.14)/6.28;
gl_FragColor =vec4(strength,strength,strength,alpha);
本章深入探讨了Three.js中高级着色器图形特效的实现方法，包括：
通过掌握这些技术，可以创建出丰富的视觉效果和动态图形。
本文档涵盖Three.js中着色器编程的基础概念和实现方法，基于实际代码示例进行讲解。
最终效果如图：
着色器(Shader)是运行在GPU上的小程序，用于计算3D场景中每个像素的颜色。在Three.js中，有两种主要的着色器：
import * as THREE from "three";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
import gsap from "gsap";
import * as dat from "dat.gui";
// 顶点着色器
import basicVertexShader from "../shader/raw/vertex.glsl";
// 片元着色器
import basicFragmentShader from "../shader/raw/fragment.glsl";
RawShaderMaterial直接使用GLSL代码，不会自动添加默认的uniforms和attributes：
// 创建原始着色器材质
const rawShaderMaterial = new THREE.RawShaderMaterial({
vertexShader: basicVertexShader,
fragmentShader: basicFragmentShader,
side: THREE.DoubleSide,
uniforms: {
uTime: {
value: 0,
},
uTexture: {
value: texture,
},
},
});
// 创建着色器材质
const shaderMaterial = new THREE.ShaderMaterial({
vertexShader: `
void main(){
gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4( position, 1.0 ) ;
}
`,
fragmentShader: `
void main(){
gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);
}
`,
});
顶点着色器负责处理3D空间中的顶点位置，以下是一个包含动画效果的顶点着色器：
precision lowp float;
attribute vec3 position;
attribute vec2 uv;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
// 获取时间
uniform float uTime;
varying vec2 vUv;
varying float vElevation;
void main(){
vUv = uv;
vec4 modelPosition = modelMatrix * vec4( position, 1.0 );
// 添加基于时间的波浪动画
modelPosition.z = sin((modelPosition.x+uTime) * 10.0)*0.05 ;
modelPosition.z += sin((modelPosition.y+uTime) * 10.0)*0.05 ;
vElevation = modelPosition.z;
gl_Position = projectionMatrix * viewMatrix * modelPosition ;
}
片元着色器负责确定每个像素的颜色，以下是一个处理纹理和高度的片元着色器：
precision lowp float;
varying vec2 vUv;
varying float vElevation;
uniform sampler2D uTexture;
void main(){
// 根据UV,取出对应的颜色
float height = vElevation + 0.05 * 20.0;
vec4 textureColor = texture2D(uTexture,vUv);
textureColor.rgb*=height;
gl_FragColor = textureColor;
}
Uniforms是在JavaScript代码和着色器之间传递数据的变量：
const rawShaderMaterial = new THREE.RawShaderMaterial({
vertexShader: basicVertexShader,
fragmentShader: basicFragmentShader,
side: THREE.DoubleSide,
uniforms: {
uTime: {
value: 0, // 时间变量，用于动画
},
uTexture: {
value: texture, // 纹理变量
},
},
});
在动画循环中更新uniform值：
const clock = new THREE.Clock();
function animate(t) {
const elapsedTime = clock.getElapsedTime();
// 更新着色器中的时间uniform
rawShaderMaterial.uniforms.uTime.value = elapsedTime;
requestAnimationFrame(animate);
renderer.render(scene, camera);
}
使用平面几何体展示着色器效果：
// 创建平面
const floor = new THREE.Mesh(
new THREE.PlaneBufferGeometry(1, 1, 64, 64), // 细分更多，波浪效果更明显
rawShaderMaterial
);
scene.add(floor);
创建一个简单的黄色平面着色器：
// 创建基础着色器材质
const shaderMaterial = new THREE.ShaderMaterial({
vertexShader: `
void main(){
gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4( position, 1.0 ) ;
}
`,
fragmentShader: `
void main(){
gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0); // 黄色
}
`,
});
精度声明：在片元着色器中声明精度
precision lowp float; // 低精度
precision mediump float; // 中等精度
precision highp float; // 高精度
变量类型：
attribute：每个顶点独有的数据（如位置、UV坐标）uniform：所有顶点共享的数据（如时间、纹理）varying：在顶点着色器和片元着色器之间传递的数据性能优化：避免在着色器中使用复杂运算，尽可能在CPU端预计算
调试技巧：通过将中间计算结果输出到颜色来调试着色器
本章介绍了Three.js中着色器编程的基础知识，包括：
通过掌握这些基础知识，可以进一步探索更复杂的着色器效果。
你肯定遇到过这种情况。页面上有一个倒计时，显示“距离活动结束还有 10 秒”。你屏住呼吸，准备在最后一刻点击抢购按钮。但奇怪的是，倒计时从 10 跳到 9 时，好像停顿了一下，或者跳得特别快。最终，你点击按钮时，系统提示“活动已结束”。
这不是你的错觉。前端实现的倒计时，确实存在误差。今天，我们就来聊聊这个误差是怎么产生的，以及我们能做些什么来减小它。
要理解误差，我们得先看看最常见的前端倒计时是怎么工作的。
setInterval 与 setTimeout
大多数倒计时使用 JavaScript 的 setInterval 或递归的 setTimeout 来实现。代码逻辑很简单：
元凶一：JavaScript 的单线程与事件循环
JavaScript 是单线程语言。这意味着它一次只能做一件事。setInterval 和 setTimeout 指定的延迟时间，并不是精确的“等待 X 毫秒后执行”，而是“等待至少 X 毫秒后，将回调函数放入任务队列”。
什么时候执行呢？要等主线程上当前的任务都执行完了，才会从队列里取出这个回调来执行。
想象一下：
setInterval(fn, 1000)，希望每秒跑一次。fn 执行了。fn 被放入队列。但此时主线程正在处理一个复杂的动画计算，花了 200 毫秒。fn 直到第1.2秒才真正开始执行。这就产生了至少 200 毫秒的延迟。
元凶二：浏览器标签页休眠
为了节省电量，当用户切换到其他标签页或最小化浏览器时，当前页面的 setInterval 和 setTimeout 会被“限流”。它们的执行频率会大大降低，可能变成每秒一次，甚至更慢。
如果你的倒计时在后台运行了5分钟，再切回来，它可能直接显示“已结束”，或者时间跳了一大截。
元凶三：系统时间依赖
很多倒计时是这样计算剩余时间的：
剩余秒数 = Math.floor((目标时间戳 - Date.now()) / 1000);
这里有两个潜在问题：
Date.now() 的精度：它返回的是系统时间。如果用户手动修改了电脑时间，或者系统时间同步有微小偏差，倒计时就会出错。知道了原因，我们就可以对症下药。解决方案的目标是：让显示的时间尽可能接近真实的世界时间。
这是最基础的改进，核心思想是：不依赖计时器的周期，而是依赖绝对时间。
具体做法：
在倒计时启动时，记录一个精确的开始时间戳（startTime = Date.now()）和目标结束时间戳（endTime）。
在每次更新函数中，不再简单地“减1秒”，而是重新计算：
const now = Date.now();
const elapsed = now - startTime; // 已经过去的时间
const remainingTime = endTime - now; // 剩余时间
const displaySeconds = Math.floor(remainingTime / 1000);
动态调整下一次执行的时间。例如，我们希望每 1000 毫秒更新一次显示，但上次执行晚了 50 毫秒，那么下次就只延迟 950 毫秒。
function updateTimer() {
// ... 计算并显示时间
const deviation = Date.now() - (startTime + expectedElapsed); // 计算偏差
const nextTick = 1000 - deviation; // 调整下次间隔
setTimeout(updateTimer, Math.max(0, nextTick)); // 确保间隔不为负数
}
优点：
• 实现相对简单。 • 能有效抵消单次延迟的累积。一次慢了，下次会找补回来一些。
缺点：
• 无法解决浏览器标签页休眠导致的长时间停滞。
• 仍然依赖 Date.now()，受系统时间影响。
既然主线程繁忙会导致延迟，那我们就把计时任务放到一个独立的线程里去。
Web Worker 可以让脚本在后台线程运行。在这个线程里运行的 setInterval 不容易被主线程的繁重任务阻塞。
实现思路：
timer.worker.js），在里面用 setInterval 向主线程发送消息。优点：
• 计时更稳定，受主线程影响小。 • 代码分离，逻辑清晰。
缺点：
• 仍然无法解决浏览器标签页休眠限流的问题。 • 增加了一定的架构复杂度。
这是目前最精确、最可靠的方案。核心原则是：前端不再信任本地时间，而是以服务器时间为准，并持续校准。
步骤拆解：
第一步：获取权威的服务器时间
在页面加载或倒计时开始时，向服务器发送一个请求。服务器在响应中返回当前的服务器时间戳。
注意：这个时间戳应该放在 HTTP 响应的
Date头或body里，避免受到网络传输时间的影响。更专业的做法是，计算一个往返延迟（RTT），然后估算出当前的准确服务器时间。
第二步：在前端建立一个“虚拟的服务器时钟”
我们不在前端直接使用 Date.now()，而是自己维护一个时钟：
// 假设通过 API 得到：serverTime 是服务器当前时间，rtt 是网络往返延迟
const initialServerTime = serverTime + rtt / 2; // 估算的准确服务器时间
const localTimeAtThatMoment = Date.now();
// 此后，要获取“当前服务器时间”，就用这个公式：
function getCurrentServerTime() {
const nowLocal = Date.now();
const elapsedLocal = nowLocal - localTimeAtThatMoment;
return initialServerTime + elapsedLocal;
}
这个时钟的原理是：服务器告诉我们一个“起点时间”，我们记录下那个时刻的本地时间。之后，我们相信本地时间的流逝速度是基本准确的（电脑的晶体振荡器很稳定），用本地流逝的时间加上服务器的起点时间，就得到了连续的“服务器时间”。
第三步：用这个虚拟时钟驱动倒计时
倒计时的更新函数，使用 getCurrentServerTime() 来计算剩余时间，而不是 Date.now()。
第四步：定期校准
本地时钟的流逝速度可能有微小偏差（时钟漂移）。我们可以设置一个间隔（比如每1分钟或5分钟），悄悄地再向服务器请求一次时间，来修正我们的 initialServerTime 和 localTimeAtThatMoment，让虚拟时钟始终与服务器保持同步。
这个方案的优点非常突出：
• 抗干扰：用户修改本地时间，完全不影响倒计时。 • 高精度：误差主要来自时钟漂移和网络延迟，通过定期校准可以控制在极低水平（百毫秒内）。 • 一致性：所有用户看到的倒计时基于同一时间源，公平公正。
当然，它的实现也最复杂，需要前后端配合。
面对不同的场景，你可以这样选择：
• 对精度要求不高的展示型倒计时（如文章发布后的阅读时间）：使用方案一（优化计时器逻辑） 就足够了。简单有效。 • 营销活动、秒杀抢购倒计时：必须使用方案三（服务器时间同步） 。这是保证公平性和准确性的底线。方案一和方案二可以作为辅助，让更新更平滑。
React 的 Context API 是一种组件间共享数据的机制，它允许你在组件树中传递数据而不必手动逐层传递 props，特别适合"全局"数据的共享（如主题、用户认证信息等）。
创建context：
import { createContext, useContext } from 'react';
export type ThemeType = 'light' | 'dark';
export interface ThemeContextType {
theme: ThemeType;
toggleTheme: () => void;
}
// 1. 创建 Context
export const ThemeContext = createContext<ThemeContextType>({
theme: 'light',
toggleTheme: () => {},
});
type ThemeProviderProps = {
children: React.ReactNode;
} & ThemeContextType;
// 2. 创建 Provider 组件
export const ThemeProvider = ({
children,
theme,
toggleTheme,
}: ThemeProviderProps) => {
return (
<ThemeContext.Provider value={{
theme,
toggleTheme,
}}>
{children}
</ThemeContext.Provider>
);
};
// 3. 自定义 Hook（可选，提升可读性）
export const useTheme = () => useContext(ThemeContext);
顶层组件 top.tsx
"use client";
import React, { useState } from 'react';
import { ThemeContext, ThemeContextType, ThemeType } from './context';
import Button from '../../components/button';
function App() {
const [theme, setTheme] = useState<ThemeType>('light');
const toggleTheme = () => {
setTheme(prev => prev === 'light' ? 'dark' : 'light');
};
const value: ThemeContextType = { theme, toggleTheme };
return (
<ThemeContext.Provider value={value}>
<div
style={{
padding: '20px',
background: theme === 'dark' ? '#000' : '#fff',
color: theme === 'dark' ? '#fff' : '#000'
}}
>
<h1>Current theme: {theme}</h1>
<Button />
</div>
</ThemeContext.Provider>
);
}
export default App;
Button组件
import React from 'react';
import { useTheme } from '../hook-api/use-context/context';
export default function Button() {
const { theme, toggleTheme } = useTheme();
return (
<button onClick={toggleTheme}>Toggle Theme {theme}</button>
);
}
性能问题：当 Provider 的 value 发生变化时，所有使用该 Context 的子组件都会重新渲染（即使只用到部分字段）。为避免不必要的重渲染：
value 拆分为多个 Context；useMemo 稳定 value 引用；不要滥用：Context 不是万能的状态管理工具。对于复杂状态逻辑，建议结合 useReducer 或使用 Redux、Zustand 等状态库。
use-context-selector 是一个 React 上下文（Context）优化库，它解决了 React 原生 useContext 在性能上的一个关键问题：当上下文值变化时，所有使用该上下文的组件都会重新渲染，即使它们只依赖上下文中的一小部分数据。
App.tsx
'use client'
import React, { StrictMode } from 'react';
import { MyProvider } from './context';
import CounterA from './components/CounterA';
import CounterB from './components/CounterB';
function App() {
return (
<StrictMode>
<MyProvider>
<CounterA />
<CounterB />
</MyProvider>
</StrictMode>
);
}
export default App;
context.tsx
'use client'
import { useState } from 'react';
import{ createContext } from 'use-context-selector';
const MyContext = createContext({} as any);
export function MyProvider({ children }: any) {
const [countA, setCountA] = useState(0);
const [countB, setCountB] = useState(0);
const state: any = {
countA,
setCountA,
countB,
setCountB,
};
return (
<MyContext.Provider value={state}>
{children}
</MyContext.Provider>
);
}
export default MyContext;
CounterA.tsx
'use client'
import React from 'react';
import { useContextSelector, useContext } from 'use-context-selector';
import MyContext from '../context';
function CounterA() {
const countA = useContextSelector(MyContext, (v) => v.countA);
const setCountA = useContextSelector(MyContext, (v) => v.setCountA);
const increment = () =>
setCountA((s) => s -1);
console.log('CounterA rendered');
return (
<div>
<p>{new Date().getTime()}</p>
<p>Counter A: {countA}</p>
<button onClick={increment}>
Increment A
</button>
</div>
);
}
export default CounterA;
CounterB.tsx
'use client'
import React from 'react';
import { useContextSelector, useContext } from 'use-context-selector';
import MyContext from '../context';
function CounterB() {
const countB = useContextSelector(MyContext, (v) => v.countB);
const setCountB = useContextSelector(MyContext, (v) => v.setCountB);
const increment = () =>
setCountB((s) => s -1);
console.log('CounterB rendered');
return (
<div>
<button onClick={increment}>
Increment B
</button>
<p>{new Date().getTime()}</p>
<p>Counter B: {countB}</p>
</div>
);
}
export default CounterB;
适合人群
- Flutter 开发者，想入门 BLE
- 手上没有任何蓝牙硬件
- 经常遇到「设备能连上，但怎么都通信不了」
本教程将带你 从 0 到 1 跑通一套完整的 BLE 通信流程：
BLE 并不是「连上设备就能发数据」。
它的真实结构是：
设备（Device）
└── 服务（Service，UUID）
└── 特征（Characteristic，UUID + 属性）
👉 Service / Characteristic 选错一个，通信必失败
我们使用 Nordic 官方工具 nRF Connect 来模拟一个 BLE 外设（Server）。
安装到 Android 真机 后打开。
首页点击：
Configure GATT Server
选择系统内置：
Sample configuration
然后找到 Test Service，复制它的 Service UUID
📌 这个 UUID 后面会反复用到：
回到首页，点击 ADVERTISE，新建一个广播。
当你在设备列表看到该设备：
说明：
Flutter 启动后扫描 BLE 设备：
📌 此时只是 看到设备，还不能通信。
点击设备后：
scan → connect
连接成功，才有后续步骤。
连接完成后，客户端会向服务端请求：
你这个设备，提供了哪些 Service？
在服务列表中：
👉 Service 点错，后面全部白做
进入 Service 后，会看到多个 Characteristic：
📌 对不支持 Write 的 Characteristic 写数据：
不报错，但一定没反应
服务端数据不会自动刷新：
❗不是通信失败，是 UI 问题。
BLE 通信 = 连设备 + 找对 Service + 用对 Characteristic
本文由TinyPro贡献者王晨光同学原创。
TinyPro 是一套基于 TinyVue 打造的前后端分离后台管理系统，支持菜单配置、国际化、多页签、权限管理等丰富特性。 TinyPro 在桌面端具备良好的体验和模块化架构，但随着移动办公、平板展示等场景增多，移动端体验的短板逐渐显现：
为此启动了 TinyPro 移动端适配项目，目标是在不破坏现有结构的前提下，实现“一次开发，跨端流畅”的体验。
本次移动端适配要求在复杂的中后台系统中实现「一次开发，多端自适应」，既要保证样式灵活，又要维持可维护性和构建性能。
在技术选型阶段，综合评估了三种常见方案：
| 方案 | 优点 | 缺点 |
|---|---|---|
| 纯 CSS 媒体查询 | 简单直接、依赖少 | 样式分散、逻辑重复、维护困难 |
| TailwindCSS 响应式类 | 社区成熟、类名直观、生态完善 | 样式表体积大、断点固定、不够灵活 |
| UnoCSS 原子化方案 | 按需生成、性能极轻、断点与变体完全可定制 | 需要自行配置规范与规则体系 |
最终选择了 UnoCSS + Less 的混合架构：
max-<bp>）：支持“桌面端优先”策略，通过 max-width 实现移动端自适应，样式逻辑更直观。UnoCSS 是一个 按需生成的原子化 CSS 引擎，最大的特点是 零冗余与高度可定制。 不同于 TailwindCSS 的预编译方式，UnoCSS 会在构建阶段根据实际使用的类名即时生成样式规则，从而显著提升构建性能与灵活性.
在配置中通过 presetMini() 与 presetAttributify() 组合使用，使开发者既可以写：
<div class="p-4 text-center bg-gray-100 max-md:p-2"></div>
也可以使用属性化语法：
<div p="4" text="center" bg="gray-100" max-md:p="2"></div>
presetMini 提供轻量原子类体系，presetAttributify 则允许以声明式方式书写样式，更直观、组件化友好。
TinyPro 的适配核心之一，是在 uno.config.ts 中建立统一的断点体系，并通过自定义 max-<bp> 前缀实现“桌面端优先”的响应式策略。
const breakpoints = {
sm: '641px', // 手机（小屏）
md: '769px', // 平板竖屏
lg: '1025px', // 平板横屏 / 小型笔电
xl: '1367px', // 常规笔电
'2xl': '1441px', // 高清笔电
'3xl': '1921px', // 桌面大屏
}
并通过自定义 variants 扩展 max-<bp> 前缀:
variants: [
(matcher) => {
const match = matcher.match(/^max-([a-z0-9]+):/)
if (match) {
const bp = match[1]
const value = breakpoints[bp]
if (!value) return
return {
matcher: matcher.replace(`max-${bp}:`, ''),
parent: `@media (max-width: ${value})`,
}
}
},
]
让开发者能自然地书写：
<div class="w-1/2 max-md:w-full"></div>
含义：
默认宽度为 50%，在宽度小于 769px 的设备上改为 100%。
TinyPro 采用「桌面端优先（max-width）」的布局策略：默认以桌面端布局为基础，在移动设备上再进行针对性优化。相比常见的「移动端优先（min-width）」方式，这种做法更符合中后台系统的特性，同时让 UnoCSS 的断点逻辑更直观，并确保主屏体验的稳定性。
优先级
布局与滚动
图表自适应
resize 监听，在侧边栏展开/收起、窗口缩放、语言切换等场景下保持自适应。vw 宽度与较小字号，保证图表展示效果与可读性。表单与模态框
useResponsiveSize()，控制弹窗在小屏下铺满显示，大屏保持固定宽度。导航与交互
性能优化
responsive.ts 中对 resize 事件处理增加节流机制，避免窗口缩放等场景下的频繁无效渲染。<tiny-layout>
<tiny-row class="flex justify-center max-md:flex-wrap">
<tiny-col class="w-1/4 max-md:w-1/2 max-sm:w-full max-md:mb-4">···</tiny-col>
···
<tiny-col class="w-1/4 max-md:w-1/2 max-sm:w-full max-md:mb-4">···</tiny-col>
</tiny-row>
</tiny-layout>
<div class="theme-line flex max-sm:grid max-sm:grid-cols-4 max-sm:gap-2">
<div···
</div>
</div>
<template>
<section class="p-4 sm:p-6 lg:p-8 max-sm:text-center">
<tiny-dialog :width="modalSize">...</tiny-dialog>
</section>
</template>
<script setup lang="ts">
import { useResponsiveSize } from '@/hooks/responsive'
const { modalSize } = useResponsiveSize() // 小屏 100%，大屏 768px
</script>
<template>
<div class="container">
<tiny-grid ref="grid" :fetch-data="fetchDataOption" :pager="pagerConfig" :size="gridSize" :auto-resize="true" align="center">
···
</tiny-grid>
</div>
</template>
<script setup lang="ts">
import { useResponsiveSize } from '@/hooks/responsive'
const { gridSize } = useResponsiveSize() // 小屏为mini grid，大屏为medium grid
</script>
useResponsive 获取屏幕断点状态 sm/md/lg，如：在模板中结合 v-if="!lg" 控制分隔线的渲染，从而实现了小屏下纵向菜单才显示分隔线的效果<template>
<ul class="right-side" :class="{ open: menuOpen }">
<!-- 小屏下才显示分隔线 -->
<li v-if="!lg">
<div class="divider"></div>
</li>
···
</ul>
</template>
<script lang="ts" setup>
import { useResponsive } from '@/hooks/responsive'
const { lg } = useResponsive()
</script>
通过本次移动端适配， TinyPro 实现了“从桌面到掌心”的统一体验： 开发者可以继续沿用熟悉的组件体系与布局方式，同时享受 UnoCSS 带来的原子化灵活性与性能优势。在不改变核心架构的前提下，TinyPro 变得更轻盈、更顺滑，也更符合移动时代的使用场景。
欢迎加入 OpenTiny 开源社区。添加微信小助手：opentiny-official 一起参与交流前端技术～
OpenTiny 官网：opentiny.design
OpenTiny 代码仓库：github.com/opentiny
TinyPro源码：github.com/opentiny/ti…
欢迎进入代码仓库 Star🌟TinyPro、TinyEngine、TinyVue、TinyNG、TinyCLI、TinyEditor 如果你也想要共建，可以进入代码仓库，找到 good first issue标签，一起参与开源贡献~
近日在使用小米AI大模型MIMO时，被其顶部的透视跟随动画深深吸引，移步官网（ mimo.xiaomi.com/zh/ ）
现在基于这个交互的拆解，逐步来复刻交互效果
采用「静态底层+动态上层」的双层视觉结构，通过CSS绝对定位实现图层叠加，既保证初始状态的视觉完整性，又能让交互效果精准作用于上层，不干扰底层基础展示。两层分工明确，具体如下：
| 图层 | 类名 | 内容 | 功能 |
|---|---|---|---|
| 底层 | .z-1 |
中文标题 "你好，世界！" 和灰色 "HELLO" 文字矩阵 | 静态背景展示 |
| 上层 | .z-2 |
英文标题 "Hello , World!" 和白色 "HELLO" 文字矩阵 | 鼠标交互时的动态效果层 |
<div class="container" @mouseenter="onMouseEnter" @mouseleave="onMouseLeave" @mousemove="onMouseMove">
<!-- 底层内容 -->
<div class="z-1">
<div class="line" v-for="line in 13">
<span class="line-item" v-for="item in 13">HELLO</span>
</div>
</div>
<h1 class="title-1">你好，世界！</h1>
<!-- 上层交互内容 -->
<div class="z-2" :style="{ 'clip-path': circleClipPath }">
<div class="hidden-div">
<div class="line" v-for="line in 13">
<span class="line-item" v-for="item in 13">HELLO</span>
</div>
</div>
<h1 class="title-2">Hello , World!</h1>
</div>
</div>
关键说明：hidden-div用于包裹上层文字矩阵，配合.z-2的定位规则，确保遮罩效果精准覆盖；两层文字矩阵尺寸一致，保证视觉对齐，增强透视沉浸感。
轨迹点系统是实现平滑鼠标跟随效果的核心，通过维护6个轨迹点的位置信息，创建出具有弹性延迟的跟随动画。
// 轨迹点系统
const trailSystem = ref({
targetX: 0,
targetY: 0,
trailPoints: Array(6).fill(null).map(() => ({ x: 0, y: 0 })),
animationId: 0,
isInside: false
});
设计思路：6个轨迹点是兼顾流畅度与性能的平衡值——点太少则拖尾效果不明显，点太多则增加计算开销，配合递减阻尼系数，实现“头快尾慢”的自然跟随。
通过计算鼠标位置和轨迹点的关系，动态生成 clip-path CSS 属性值，实现跟随鼠标的圆形/椭圆形遮罩效果。
// 计算clip-path值
const circleClipPath = computed(() => {
if (!showCircle.value) {
return 'circle(0px at -300px -300px)'; // 完全隐藏状态
}
// 复制轨迹系统数据进行计算
const system = JSON.parse(JSON.stringify(trailSystem.value));
// 更新轨迹点
for (let t = 0; t < 6; t++) {
const prevX = t === 0 ? system.targetX : system.trailPoints[t - 1].x;
const prevY = t === 0 ? system.targetY : system.trailPoints[t - 1].y;
const damping = 0.7 - 0.04 * t; // 阻尼系数，后面的点移动更慢
const deltaX = prevX - system.trailPoints[t].x;
const deltaY = prevY - system.trailPoints[t].y;
// 平滑插值
system.trailPoints[t].x += deltaX * damping;
system.trailPoints[t].y += deltaY * damping;
}
// 获取第一个点（头部）和最后一个点（尾部）
const head = system.trailPoints[0];
const tail = system.trailPoints[5];
const diffX = head.x - tail.x;
const diffY = head.y - tail.y;
const distance = Math.sqrt(diffX * diffX + diffY * diffY);
let clipPathValue = '';
if (distance < 10) { // 如果距离很近，显示圆形
clipPathValue = `circle(200px at ${head.x}px ${head.y}px)`;
} else {
// 创建椭圆形的polygon，连接头尾两点
const angle = Math.atan2(diffY, diffX); // 连接角度
const points = [];
// 从头部开始，画半个椭圆
for (let i = 0; i <= 30; i++) {
const theta = angle - Math.PI / 2 + Math.PI * i / 30;
const x = head.x + 200 * Math.cos(theta);
const y = head.y + 200 * Math.sin(theta);
points.push(`${x}px ${y}px`);
}
// 从尾部开始，画另半个椭圆
for (let i = 0; i <= 30; i++) {
const theta = angle + Math.PI / 2 + Math.PI * i / 30;
const x = tail.x + 200 * Math.cos(theta);
const y = tail.y + 200 * Math.sin(theta);
points.push(`${x}px ${y}px`);
}
clipPathValue = `polygon(${points.join(', ')})`;
}
return clipPathValue;
});
实现了完整的鼠标交互逻辑，包括鼠标进入、离开和移动时的状态管理和动画控制。
| 事件 | 处理函数 | 功能 |
|---|---|---|
| mouseenter | onMouseEnter | 激活交互效果，初始化轨迹点 |
| mouseleave | onMouseLeave | 停用交互效果，重置轨迹点 |
| mousemove | onMouseMove | 更新目标点位置，驱动动画 |
核心原理：使用6个轨迹点，每个点跟随前一个点移动，并应用不同的阻尼系数，实现平滑的拖尾效果。
技术优势：
核心原理：利用CSS clip-path属性的动态特性，结合轨迹点位置计算，实时生成不规则遮罩，替代Canvas/SVG的图形绘制方案，用更轻量化的方式实现复杂视觉效果。
技术优势：
will-change: clip-path 提示浏览器，提前分配渲染资源，减少重排重绘，提升动画流畅度渲染性能：
will-change: clip-path 提示浏览器优化渲染事件处理：
动画性能：
requestAnimationFrame 实现流畅的动画效果本次复刻的小米MiMo透视动画，核心价值在于“用简单技术组合实现高级视觉效果”——无需复杂图形库，仅依托Vue3响应式能力与CSS clip-path属性，就能打造出兼具质感与性能的交互组件。其核心亮点可概括为三点：
该组件的实现思路可灵活迁移至其他场景：
<template>
<div class="hero-container" @mouseenter="onMouseEnter" @mouseleave="onMouseLeave" @mousemove="onMouseMove">
<div class="z-1">
<div class="line" v-for="line in 13">
<span class="line-item" v-for="item in 13">HELLO</span>
</div>
</div>
<h1 class="title-1">你好，世界</h1>
<!-- 第二个div，鼠标移入后需要显示的内容，通过clip-path:circle(0px at -300px -300px)达到隐藏效果 -->
<div class="z-2" :style="{ 'clip-path': circleClipPath }">
<div class="hidden-div">
<div class="line" v-for="line in 13">
<span class="line-item" v-for="item in 13">HELLO</span>
</div>
</div>
<h1 class="title-2">HELLO , World</h1>
</div>
</div>
</template>
<script setup>
import { ref, computed, onMounted, onUnmounted } from 'vue'
const showCircle = ref(false)
const containerRef = ref(null)
const trailSystem = ref({
targetX: 0,
targetY: 0,
trailPoints: Array(6)
.fill(null)
.map(() => ({ x: 0, y: 0 })),
animationId: 0,
isInside: false,
})
const circleClipPath = computed(() => {
if (!showCircle.value) {
return 'circle(0px at -300px -300px)'
}
// 复制轨迹系统数据进行计算
const system = JSON.parse(JSON.stringify(trailSystem.value))
// 更新轨迹点
for (let t = 0; t < 6; t++) {
const prevX = t === 0 ? system.targetX : system.trailPoints[t - 1].x
const prevY = t === 0 ? system.targetY : system.trailPoints[t - 1].y
const damping = 0.7 - 0.04 * t // 阻尼系数，后面的点移动更慢
const deltaX = prevX - system.trailPoints[t].x
const deltaY = prevY - system.trailPoints[t].y
// 平滑插值
system.trailPoints[t].x += deltaX * damping
system.trailPoints[t].y += deltaY * damping
}
// 获取第一个点（头部）和最后一个点（尾部）
const head = system.trailPoints[0]
const tail = system.trailPoints[5]
const diffX = head.x - tail.x
const diffY = head.y - tail.y
const distance = Math.sqrt(diffX * diffX + diffY * diffY)
let clipPathValue = ''
if (distance < 10) {
// 如果距离很近，显示圆形
clipPathValue = `circle(200px at ${head.x}px ${head.y}px)`
} else {
// 创建椭圆形的polygon，连接头尾两点
const angle = Math.atan2(diffY, diffX) // 连接角度
const points = []
// 从头部开始，画半个椭圆
for (let i = 0; i <= 30; i++) {
const theta = angle - Math.PI / 2 + (Math.PI * i) / 30
const x = head.x + 200 * Math.cos(theta)
const y = head.y + 200 * Math.sin(theta)
points.push(`${x}px ${y}px`)
}
// 从尾部开始，画另半个椭圆
for (let i = 0; i <= 30; i++) {
const theta = angle + Math.PI / 2 + (Math.PI * i) / 30
const x = tail.x + 200 * Math.cos(theta)
const y = tail.y + 200 * Math.sin(theta)
points.push(`${x}px ${y}px`)
}
clipPathValue = `polygon(${points.join(', ')})`
}
return clipPathValue
})
// 动画循环函数
const animate = () => {
if (showCircle.value) {
// 更新轨迹点
for (let t = 0; t < 6; t++) {
const prevX = t === 0 ? trailSystem.value.targetX : trailSystem.value.trailPoints[t - 1].x
const prevY = t === 0 ? trailSystem.value.targetY : trailSystem.value.trailPoints[t - 1].y
const damping = 0.7 - 0.04 * t // 阻尼系数，后面的点移动更慢
const deltaX = prevX - trailSystem.value.trailPoints[t].x
const deltaY = prevY - trailSystem.value.trailPoints[t].y
// 平滑插值
trailSystem.value.trailPoints[t].x += deltaX * damping
trailSystem.value.trailPoints[t].y += deltaY * damping
}
// 请求下一帧
trailSystem.value.animationId = requestAnimationFrame(animate)
}
}
const onMouseEnter = (event) => {
const container = event.currentTarget
const rect = container.getBoundingClientRect()
const x = event.clientX - rect.left
const y = event.clientY - rect.top
showCircle.value = true
// 初始化目标位置和轨迹点
trailSystem.value.targetX = x
trailSystem.value.targetY = y
trailSystem.value.isInside = true
// 初始化所有轨迹点到当前位置
for (let i = 0; i < 6; i++) {
trailSystem.value.trailPoints[i] = { x, y }
}
// 开始动画
if (!trailSystem.value.animationId) {
trailSystem.value.animationId = requestAnimationFrame(animate)
}
}
const onMouseLeave = (event) => {
const container = event.currentTarget
const rect = container.getBoundingClientRect()
const x = event.clientX - rect.left
const y = event.clientY - rect.top
showCircle.value = false
trailSystem.value.isInside = false
// 将目标点移出容器边界，使轨迹点逐渐拉回
let targetX = x
let targetY = y
if (x <= 0) targetX = -400
else if (x >= rect.width) targetX = rect.width + 400
if (y <= 0) targetY = -400
else if (y >= rect.height) targetY = rect.height + 400
trailSystem.value.targetX = targetX
trailSystem.value.targetY = targetY
// 停止动画
if (trailSystem.value.animationId) {
cancelAnimationFrame(trailSystem.value.animationId)
trailSystem.value.animationId = 0
}
}
const onMouseMove = (event) => {
if (showCircle.value) {
const container = event.currentTarget
const rect = container.getBoundingClientRect()
const x = event.clientX - rect.left
const y = event.clientY - rect.top
trailSystem.value.targetX = x
trailSystem.value.targetY = y
}
}
</script>
<style scoped>
.hero-container {
cursor: crosshair;
background: #faf7f5;
border-bottom: 1px solid #000;
justify-content: center;
align-items: center;
width: 100%;
height: 500px;
display: flex;
position: relative;
overflow: hidden;
}
.z-1 {
pointer-events: auto;
-webkit-user-select: none;
user-select: none;
flex-direction: column;
justify-content: flex-start;
width: 100%;
height: 100%;
display: flex;
position: absolute;
top: 0;
left: 0;
overflow: hidden;
}
.z-1 .line {
display: flex;
align-items: center;
white-space: nowrap;
color: #0000000d;
letter-spacing: 0.3em;
flex-wrap: nowrap;
font-size: 52px;
font-weight: 700;
line-height: 1.6;
display: flex;
}
.z-1 .line-item {
cursor: default;
flex-shrink: 0;
margin-right: 0.6em;
transition:
color 0.3s,
text-shadow 0.3s;
font-family: inherit !important;
}
.z-1 .line:nth-child(odd) {
margin-left: -2em;
background-color: rgb(245, 235, 228);
}
.title-1 {
z-index: 1;
color: #000;
letter-spacing: 0.02em;
text-align: center;
margin: 0;
font-size: 72px;
font-weight: 700;
}
.z-2 {
pointer-events: none;
z-index: 10;
will-change: clip-path;
background: #000;
justify-content: center;
align-items: center;
width: 100%;
height: 100%;
display: flex;
position: absolute;
top: 0;
left: 0;
}
.z-2 .hidden-div {
pointer-events: none;
-webkit-user-select: none;
user-select: none;
flex-direction: column;
justify-content: flex-start;
width: 100%;
height: 100%;
display: flex;
position: absolute;
top: 0;
left: 0;
overflow: hidden;
}
.z-2 .hidden-div .line {
white-space: nowrap;
color: #ffffff1f;
letter-spacing: 0.3em;
flex-wrap: nowrap;
font-size: 32px;
font-weight: 700;
line-height: 1.6;
display: flex;
}
.z-2 .hidden-div .line:nth-child(odd) {
margin-left: -0.5em;
}
.title-2 {
font-size: 72px;
color: #fff;
letter-spacing: 0.02em;
text-align: center;
white-space: nowrap;
margin: 0;
font-size: 72px;
font-weight: 700;
}
</style>
小米的前端一直很牛，非常有创意，我也通过F12学习源码体会到了新的思路，希望大家也多多关注小米和小米的技术～
Gemini生成
在编程世界里，代码的执行方式主要分两种：同步 (Synchronous) 和 异步 (Asynchronous)。
概念： 代码从上到下，一行一行执行。上一行代码没有执行完，下一行代码绝对不会开始。
生活类比： 想象你在银行柜台办理业务。
代码表现：
console.log("1. 开始点餐");
alert("我是同步的弹窗，我不关掉，你什么都做不了！"); // 这里会卡住
console.log("2. 吃饭");
如果不点击弹窗的确定，"2. 吃饭" 永远不会打印出来。这就是“阻塞”。
概念： 遇到耗时的任务（比如从网络下载图片、读取文件），程序不会傻等，而是把任务交给“别人”（浏览器或操作系统）去处理，自己继续往下执行后面的代码。等耗时任务做完了，再通知程序回来处理结果。
生活类比： 想象你在奶茶店点单。
代码表现：
console.log("1. 点单：我要一杯奶茶");
// 这是一个模拟异步的函数，假设需要 2 秒钟
setTimeout(() => {
console.log("3. 奶茶好了！(这是异步回来的结果)");
}, 2000);
console.log("2. 找个位置坐下玩手机");
控制台的打印顺序是：
1. 点单...2. 找个位置... (注意：这里直接跳过了等待，先执行了！)3. 奶茶好了...
你可能会问：“同步多简单啊，逻辑清晰，为什么要搞这么复杂的异步？”
这和 JS 的出身有关：
总结第一部分：
JavaScript/TypeScript 的异步演进史，其实就是一部与“代码可读性”抗争的历史。我们的目标始终未变：让异步代码看起来像同步代码一样简单易懂。
我们分三个阶段来讲：
在 Promise 出现之前（大约是 2015 年 ES6 标准发布前），我们处理异步只有一种办法：回调函数。
什么是回调？ 简单来说，就是你定义一个函数，但你自己不调用它，而是把它作为参数传给另一个函数（比如网络请求函数）。你告诉对方：“等你做完你的事，回头(Call back)调用一下我这个函数，把结果传给我。”
场景模拟： 我们要去数据库获取用户信息。
// 定义一个回调函数的类型：接收 string 类型的数据，没有返回值
type MyCallback = (data: string) => void;
function getUserData(callback: MyCallback) {
console.log("1. 开始向服务器请求数据...");
// 模拟耗时 1 秒
setTimeout(() => {
console.log("2. 服务器返回数据了");
const data = "张三";
// 关键点：任务做完后，手动调用传进来的函数
callback(data);
}, 1000);
}
// 使用
getUserData((name) => {
console.log(`3. 拿到用户名：${name}`);
});
问题在哪里？ 如果是这一层简单的调用，看起来还不错。但现实往往很残酷。
场景升级： 现在的业务逻辑变成了这样，必须严格按顺序执行：
代码会变成什么样？
// 伪代码演示，注意看缩进的形状
getUserName((name) => {
console.log(`拿到名字: ${name}`);
// 在回调里面嵌套第二个请求
getUserId(name, (id) => {
console.log(`拿到ID: ${id}`);
// 在回调里面嵌套第三个请求
getUserOrders(id, (orders) => {
console.log(`拿到订单: ${orders}`);
// 如果还有第四步... 屏幕就要炸了
getOrderDetails(orders[0], (detail) => {
// ...
});
});
});
});
这就是著名的“回调地狱”（也就是“厄运金字塔”）：
if (error) ...，极其容易漏掉。为了解决“回调地狱”，社区提出了一种新的规范，后来被纳入了 ES6 标准，这就是 Promise。
什么是 Promise？ 它是一个对象，代表了“一个未来才会知道结果的操作”。 你可以把它想象成一张披萨店的取餐小票。 当你拿到这个 Promise（小票）时，披萨还没好，但它承诺未来会给你两个结果中的一个：
Promise 最大的贡献：链式调用 (Chaining) 它把“回调地狱”的横向嵌套，拉直成了纵向的链条。
TypeScript 中的 Promise 写法：
我们看看上面的“回调地狱”用 Promise 改写后是什么样：
// 假设这些函数现在返回的是 Promise，而不是接受回调
// getUserName() -> 返回 Promise<string>
getUserName()
.then((name) => {
console.log(`拿到名字: ${name}`);
// 返回下一个异步任务，继续往下传
return getUserId(name);
})
.then((id) => {
console.log(`拿到ID: ${id}`);
return getUserOrders(id);
})
.then((orders) => {
console.log(`拿到订单: ${orders}`);
})
.catch((error) => {
// 重点：这里一个 catch 可以捕获上面任何一步发生的错误！
console.error("出错了:", error);
});
完整代码
// 1. 获取用户名的函数
// 返回值类型：Promise<string> -> 承诺未来会给出一个 string
function getUserName(): Promise<string> {
return new Promise((resolve, reject) => {
console.log("--- 1. 开始请求用户名 ---");
// 模拟网络耗时 1秒
setTimeout(() => {
const isSuccess = true; // 模拟：假设请求成功
if (isSuccess) {
// 成功了！调用 resolve，把数据 "张三" 传出去
// 这个 "张三" 会传给下一个 .then((name) => ...) 里的 name
resolve("张三");
} else {
// 失败了！调用 reject
// 这会跳过后面的 .then，直接进入最后的 .catch
reject("获取用户名失败：网络连接断开");
}
}, 1000);
});
}
// 2. 获取用户ID的函数
// 接收参数 name，返回 Promise<number>
function getUserId(name: string): Promise<number> {
return new Promise((resolve, reject) => {
console.log(`--- 2. 正在查 ${name} 的ID ---`);
setTimeout(() => {
// 假设我们查到了 ID 是 10086
resolve(10086);
}, 1000);
});
}
// 3. 获取订单的函数
// 接收参数 id，返回 Promise<string[]> (字符串数组)
function getUserOrders(id: number): Promise<string[]> {
return new Promise((resolve, reject) => {
console.log(`--- 3. 正在查 ID:${id} 的订单 ---`);
setTimeout(() => {
// 返回订单列表
resolve(["奶茶", "炸鸡", "Switch游戏机"]);
}, 1000);
});
}
// --- 实际调用部分（就是你刚才看到的那段代码） ---
console.log("程序启动...");
getUserName()
.then((name) => {
// 这里接收到的 name 就是 resolve("张三") 里的 "张三"
console.log(`✅ 拿到名字: ${name}`);
// 关键点：这里 return 了下一个 Promise 函数的调用
// 这样下一个 .then 才会等到 getUserId 完成后才执行
return getUserId(name);
})
.then((id) => {
// 这里接收到的 id 就是 resolve(10086) 里的 10086
console.log(`✅ 拿到ID: ${id}`);
return getUserOrders(id);
})
.then((orders) => {
// 这里接收到的 orders 就是那个数组
console.log(`✅ 拿到订单: ${orders}`);
})
.catch((error) => {
console.error(`❌ 流程中断: ${error}`);
})
.finally(() => {
// (可选) finally 不管成功失败都会执行
console.log("--- 流程结束 ---");
});
Promise 的核心状态（面试常考）： 一个 Promise 一定处于以下三种状态之一：
.then。.catch。TS 类型小贴士：
在 TypeScript 中，Promise 是有泛型的。
如果一个异步函数最终返回一个字符串，它的类型是 Promise<string>。
如果返回一个数字，类型是 Promise<number>。
// 这是一个返回 Promise 的函数定义示例
function wait(ms: number): Promise<string> {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve("时间到！");
}, ms);
});
}
总结第二部分：
.then() 链式调用，把代码拉直了，解决了缩进问题，并且统一了错误处理（.catch()）。但是……你有没有发现，Promise 虽然比回调好，但还是有很多 .then()？代码里充斥着很多小括号和箭头函数，看起来依然不像我们要的“同步代码”。
这就是为什么我们需要第三部分：Async/Await（终极解决方案）。
好的，来到最激动人心的部分了！Async/Await 是现代 JavaScript/TypeScript 开发的标配。
学会了这个，你就不再需要写那些繁琐的 .then 链条了。代码会变得像写同步代码（比如 Java 或 Python）一样直观。
让我们用刚才定义的三个函数（getUserName, getUserId, getUserOrders）来演示。它们本身的定义不需要改，只需要改调用的方式。
哪怕逻辑再清晰，依然有很多回调函数嵌套。
function runOldWay() {
getUserName()
.then(name => getUserId(name))
.then(id => getUserOrders(id))
.then(orders => console.log(orders))
.catch(err => console.error(err));
}
看！没有回调函数了！全是赋值语句！
// 1. 必须在函数前加 async 关键字
async function runNewWay() {
try {
console.log("开始任务...");
// 2. 使用 await 等待结果，直接赋值给变量
// JS 引擎运行到这里会暂停，直到 getUserName 里的 resolve 被调用
const name = await getUserName();
console.log(`拿到名字: ${name}`);
// 上一行没拿到结果前，这一行绝不会执行
const id = await getUserId(name);
console.log(`拿到ID: ${id}`);
const orders = await getUserOrders(id);
console.log(`拿到订单: ${orders}`);
} catch (error) {
// 3. 错误处理回归原始的 try...catch
// 只要上面任何一个 await 的 Promise 被 reject，就会跳到这里
console.error("出错了:", error);
}
}
// 调用这个异步函数
runNewWay();
await 到底做了什么？当你写下 const name = await getUserName(); 时，发生了什么？
runNewWay 的执行被暂停在这一行。runNewWay 停了，但主线程没有卡死（没有阻塞）。浏览器可以去处理点击事件、渲染动画，或者执行 runNewWay 外面的其他代码。getUserName 在后台跑（比如等待网络请求）。getUserName 完成并 resolve 了结果，runNewWay 会被“唤醒”。结果被赋值给 name，然后继续执行下一行代码。注意： await 只能用在 async 函数内部。（虽然最新的 TS/JS 支持 Top-level await，但在普通函数里还是不行的）。
在 TypeScript 中，async 函数的返回值类型永远是 Promise。
就算你 return 的是一个普通数字，TS 也会自动帮你不装成 Promise。
// 普通函数
function add(a: number, b: number): number {
return a + b;
}
// Async 函数
// 虽然看起来 return 3，但 TS 推断出的返回类型是 Promise<number>
async function addAsync(a: number, b: number): Promise<number> {
return a + b;
}
// 调用时必须处理 Promise
const result = addAsync(1, 2); // result 是 Promise<number>
// 正确用法：
// await addAsync(1, 2) 或 addAsync(1, 2).then(...)
代码分析
const result = addAsync(1, 2);: 无论有没有加await, async函数都是返回Promise<>对象. 如果没有添加await, 依然会执行该异步函数, 但是不会在这里等待, 会立刻执行下面的函数, 这个addAsync函数就在后台默默执行.
有时候会故意不写await, 比如下面这个场景:
async function initPage() {
// 发送两个请求，但我不想串行等待（不希望 A 完了才做 B）
const taskA = getUserInfo(); // 没写 await，请求发出去了
const taskB = getBanners(); // 没写 await，请求也发出去了
console.log('两个请求都已经发出去了，正在后台跑...');
// 稍后我再一起等它们的结果
const user = await taskA;
const banner = await taskB;
}
try...catch 替代 .catch，用赋值替代 .then。await 这一行打断点，你可以清楚地看到之前的变量状态，这在 .then 链条里是很难做到的。现在，你已经掌握了最主流的异步写法。
接下来，我们要进入第四部分：TypeScript 里的异步类型。这部分会教你如何在真实的工作中（比如调用后端 API）定义那些复杂的数据接口。这一步是 TS 开发者的日常。
前面的内容其实大都也是 JavaScript 的知识（除了简单的类型标注）。到了这里，我们要讲只有 TypeScript 才能提供的强大功能：如何在异步操作中获得完美的类型提示和安全保障。
这一部分对于前端开发（尤其是对接后端 API）至关重要。
Promise<T>
我们在前面的例子里稍微提到了这个。Promise 是一个泛型类。
这就好比 Array<number> 表示“装数字的数组”，Promise<User> 表示“承诺未来给你一个 User 对象”。
基本语法：
// 函数返回值类型
function fetchData(): Promise<TypeOfTheResult> { ... }
实战场景：定义 API 响应结构
假设后端给你这样一个 JSON 数据结构：
// 后端返回的用户数据
{
"id": 1,
"username": "admin",
"isActive": true
}
步骤一：定义 Interface (接口) 我们要先告诉 TS，这个数据长什么样。
interface User {
id: number;
username: string;
isActive: boolean;
// 甚至可以有可选属性
avatarUrl?: string;
}
步骤二：在异步函数中使用
// 这里的返回值类型 Promise<User> 非常重要！
async function fetchCurrentUser(): Promise<User> {
const response = await fetch('/api/user');
// 解析 JSON
const data = await response.json();
// 这里其实有一个类型断言的过程，告诉 TS 这个 data 就是 User
// 在实际项目中，通常 fetch 封装库（如 axios）会帮我们做泛型传递
return data as User;
}
步骤三：享受类型提示
当你调用这个函数时，神奇的事情发生了：
async function main() {
const user = await fetchCurrentUser();
// 当你敲下 user. 的时候，VS Code 会自动弹窗提示：
// - id
// - username
// - isActive
// - avatarUrl
console.log(user.username);
// 如果你拼写错误，立刻报错！
console.log(user.usrname); // ❌ 报错：User 类型上不存在 usrname
}
在真实工作中，我们通常使用 axios 库来发请求。axios 的类型定义非常完善，支持传入泛型。
import axios from 'axios';
// 1. 定义接口
interface Article {
title: string;
content: string;
views: number;
}
// 2. 发送请求
async function getArticle(id: number) {
// axios.get 是个泛型函数：axios.get<T>(url)
// 我们传入 <Article>，告诉 axios 返回的数据体 data 是 Article 类型
const response = await axios.get<Article>(`/api/articles/${id}`);
// response.data 现在的类型就是 Article
return response.data;
}
// 3. 调用
async function showArticle() {
const article = await getArticle(101);
// 此时 article 就是 Article 类型
console.log(article.title); // ✅ 安全
}
有时候异步操作可能会返回不同的结果，或者可能失败。
场景： 搜索用户，可能找到，也可能没找到（null）。
interface UserInfo {
name: string;
age: number;
}
// 返回值类型是 UserInfo 或者 null
async function findUser(name: string): Promise<UserInfo | null> {
if (name === 'Ghost') {
return null;
}
return { name: 'RealUser', age: 18 };
}
async function check() {
const user = await findUser('Ghost');
// 这里 user 可能是 null，TS 会强迫你做检查
// console.log(user.name); // ❌ 报错：user 可能为 null
if (user) {
console.log(user.name); // ✅ 现在安全了
}
}
Promise<T>）。interface。这一步做好了，你的代码健壮性会提升一个档次，再也不用担心拼错字段名或者不知道后端返回了啥。
准备好进入最后一部分了吗？我们将讨论实战中的错误处理和并行技巧（比如怎么让两个请求同时发，而不是一个等一个）。
好，我们进入最后一部分：实战与错误处理 (Best Practices)。
这部分是区分“新手”和“熟练工”的分水岭。新手写的异步代码往往在网络正常时能跑，一旦网络抖动或者需要优化性能时就崩了。
在 Async/Await 模式下，我们使用传统的 try...catch 来捕获异步错误。
基本套路：
async function safeGetData() {
try {
// 可能会炸的代码放在 try 里
const data = await fetchData();
console.log("成功:", data);
} catch (error) {
// 1. 网络断了
// 2. 服务器 500 了
// 3. JSON 解析失败了
// 所有错误都会汇聚到这里
console.error("出大问题了:", error);
// TS 小坑：catch(error) 这里的 error 默认类型是 unknown 或 any
// 如果要访问 error.message，最好断言一下
if (error instanceof Error) {
console.log("错误信息:", error.message);
}
} finally {
// (可选) 无论成功失败都会执行，适合关闭 loading 动画
console.log("关闭 Loading 转圈圈");
}
}
为什么这很重要？
如果不写 try...catch，一旦 await 的 Promise 失败（Rejected），整个函数会抛出异常。如果上层也没人捕获，你的程序可能会崩溃（在 Node.js 中可能会导致进程退出，在前端会导致控制台报红且后续逻辑中断）。
这是面试和实战中极高频的考点。
场景： 你需要在一个页面同时展示“用户信息”和“最近订单”。这俩接口互不相关。
新手写法 (串行 - 慢)： 就像排队，先买奶茶，买完再排队买炸鸡。
async function loadPageSerial() {
console.time("串行耗时");
const user = await getUser(); // 假设耗时 1s
const orders = await getOrders(); // 假设耗时 1s
// 总耗时：1s + 1s = 2s
console.timeEnd("串行耗时");
}
高手写法 (并行 - 快)： 我和朋友分头行动，我买奶茶，他买炸鸡，最后一起吃。
async function loadPageParallel() {
console.time("并行耗时");
// 技巧：Promise.all 接收一个 Promise 数组
// 它会同时启动数组里的所有任务
const [user, orders] = await Promise.all([
getUser(), // 任务 A
getOrders() // 任务 B
]);
// 总耗时：max(1s, 1s) = 1s
// 只有当两个都完成了，await 才会继续往下走
console.timeEnd("并行耗时");
console.log(user, orders);
}
Promise.all 的特点：
Promise.all 直接抛出错误（进入 catch），其他的成功了也没用。进阶：Promise.allSettled (ES2020)
如果你不希望“一败则败”（比如用户信息挂了，但我还是想展示订单），可以使用 Promise.allSettled。它会等待所有任务结束，不管成功还是失败，并返回每个任务的状态。
需求： 有一个用户 ID 列表 [1, 2, 3]，要依次获取他们的详细信息。
错误写法 (forEach)：
async function wrongLoop() {
const ids = [1, 2, 3];
// ❌ 这种写法 await 不生效！forEach 不支持 async 回调
ids.forEach(async (id) => {
const user = await getUser(id);
console.log(user);
});
console.log("结束了？");
// 实际结果：先打印 "结束了？"，然后那 3 个请求才在后台慢慢跑。
}
正确写法 1 (for...of) —— 串行（一个接一个）：
async function serialLoop() {
const ids = [1, 2, 3];
for (const id of ids) {
// ✅ 能够正确暂停，拿完 id:1 再拿 id:2
const user = await getUser(id);
console.log(user);
}
console.log("真·结束了");
}
正确写法 2 (map + Promise.all) —— 并行（同时跑）：
async function parallelLoop() {
const ids = [1, 2, 3];
// 1. 先把 ID 数组映射成 Promise 数组
const promises = ids.map(id => getUser(id));
// 2. 再用 Promise.all 等待它们全部完成
const users = await Promise.all(promises);
console.log("所有用户都拿到:", users);
}
恭喜你，你已经走完了 TypeScript 异步编程的完整路径！
Promise<T> 和接口 (Interface) 来约束异步数据的形状，获得极致的代码提示。try...catch 兜底错误。Promise.all 做并发优化。forEach 里用 await。\
本文所说的组件状态建模规则，特别适用于：Dialog 生命周期长、渲染早于数据的组件
UI 状态建模（template）的第一目标不是语义最精确，而是结构稳定、可渲染、可推导
简单说，template绑定的变量初始值不能为undefined或者null，最好是预定义的空模板。
| 层级 | 例子 | 规则 |
|---|---|---|
| UI 结构状态 | 表单字段、列表项、dialog 内容 | 必须结构稳定 |
| UI 行为状态 | visible / loading / disabled | 可 boolean / enum |
| 业务数据状态 | 接口返回对象 | 可 null / undefined |
template建模只会和UI结构状态和行为状态有关，和业务数据状态无关。
const element = ref(null)
{{ element.id }}
const element = ref({
id: '',
name: '',
})
理由不是“防报错”这么简单，而是：
render / computed / watch(immediate)
会在“业务数据尚未准备好”之前运行
| 状态 | 推荐建模 |
|---|---|
| UI状态尚未准备好 | 空的属性确定的数据结构 |
| 业务对象不存在 | null |
| 接口失败 | error state |
computed从undefined或者null变化为{id:'xxx'}，这就称作不稳定
// 不稳定
const id = computed(() => props.element.id)
props.element = { id: '' }
const id = computed(() => props.element?.id ?? '')
方案二是 防御，不是建模优雅
watch(
() => props.element,
(el) => {
// 这里 ≈ setup 中直接访问
},
{ immediate: true }
)
所以规则是：
凡是会被 watch(immediate) 读取的数据
都必须在 setup 结束前是安全的
安全的意思是watch的回调函数中需要用guard子句排除到props.element是undefined或者null这种情况。不然会报错。
useSomething(element)
if (!element || !element.id) return
这是 composable 的防御职责
如果你在组件内部写满 if (!xxx) return
那说明状态模型有问题
visible = false // 控制显示
element = {id:"", ...} // 内容占位
不要用 visible = false 的同时element=ref(null)
这里又一次说明null和空数据结构的区别：null表示不存在，空数据结构表示存在，但内容未准备好。不存在的就不能正常渲染，空的数据结构是可以正常渲染的。
