❌

普通视图

发现新文章，点击刷新页面。
昨天 — 2025年10月14日技术

仅用几行 CSS，实现优雅的渐变边框效果

✇掘金 前端
作者 序猿杂谈
2025年10月14日 22:30

概述

在网页设计中，渐变边框（Gradient Border） 是一种常见的视觉效果，能让元素的边框呈现出丰富的色彩过渡，常用于按钮、卡片或装饰性容器中，增强界面的层次感与视觉吸引力。

gradient_border_button.jpg

background: 
linear-gradient(90deg, #d38312, #a83279) padding-box, 
linear-gradient(90deg, #ffcc70, #c850c0) border-box;
background-clip: padding-box, border-box;

许多人在实现渐变边框时，第一反应是使用 border-image、伪元素（:before / :after），或套两层容器：外层模拟边框，内层放内容。例如：

<div class="outer">
  <div class="inner"></div>
</div>

.outer {
  width: 100px;
  height: 100px;
  padding: 10px;
  border-radius: 12px;
  background: linear-gradient(90deg, #d38312, #a83279);
}
.inner {
  width: 100%;
  height: 100%;
  border-radius: inherit;
  background: linear-gradient(90deg, #ffcc70, #c850c0);
}

但事实上，只需几行简洁的 CSS，无需多层结构，就能实现优雅可控的渐变边框。

原理

在理解实现方式之前，我们先回顾一下 CSS 背景的层叠机制。

在 CSS 中，一个元素的背景（background ↪）可以由多层组成，每一层都可以单独指定作用范围，例如：

  • padding-box：作用于内容 + 内边距区域。
  • border-box：作用于包括边框在内的整个盒子。

当我们设置了透明边框（border: 10px solid transparent）后，border-box 层的背景就能透过边框区域被看到。

利用这一特性，我们可以通过两层线性渐变来制造边框的渐变效果：

background:
  linear-gradient(90deg, #d38312, #a83279) padding-box,  /* 内层渐变 */
  linear-gradient(90deg, #ffcc70, #c850c0) border-box;   /* 外层渐变 */
background-clip: padding-box, border-box;

其中：

  • 第一层控制内容区渐变；
  • 第二层控制边框区域渐变；
  • background-clip 用来精确限定各层渐变的绘制范围。

代码实现

以下是一个完整可运行的示例👇

<!DOCTYPE html>
<html lang="zh-CN">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>渐变边框按钮</title>
    <style>
      body {
        height: 100vh;
        display: flex;
        justify-content: center;
        align-items: center;
      }

      .box {
        padding: 15px 45px;
        border-radius: 10px;

        /** ⭐️ 关键属性：设置边框粗细，并用透明填充，让背景的 border-box 渐变可见 */
        border: 2px solid transparent;

        /** ⭐️ 关键属性：多层背景实现渐变边框 */
        background: 
          linear-gradient(90deg, #d38312, #a83279) padding-box, 
          linear-gradient(90deg, #ffcc70, #c850c0) border-box;
        background-clip: padding-box, border-box;

        display: flex;
        justify-content: center;
        align-items: center;
        cursor: pointer;

        font-size: 18px;
        font-weight: bold;
        color: white;

        font-family: Georgia, "Times New Roman", Times, serif;
      }
    </style>
  </head>
  <body>
    <div class="box">Details</div>
  </body>
</html>

动态扩展

在此基础上，我们还可以轻松添加交互动画。例如，为按钮添加渐变流动的 hover 效果：

gradient_border_button_hover.gif

实现代码如下：

<!DOCTYPE html>
<html lang="zh-CN">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>渐变边框按钮</title>
    <style>
      body {
        height: 100vh;
        display: flex;
        justify-content: center;
        align-items: center;
      }

      .box {
        border-radius: 10px;
        box-shadow: 0 0 20px #eee;
        padding: 15px 45px;
        transition: 0.5s;

        background-size: 200% auto;
        background-image: linear-gradient(to right, #d38312 0%, #a83279 51%, #d38312 100%);

        cursor: pointer;
        color: white;
        text-transform: uppercase;
      }
      .box:hover {
        background-position: right center; /* change the direction of the change here */
      }
    </style>
  </head>
  <body>
    <div class="box">Hover me</div>
  </body>
</html>

总结

通过本文，我们掌握了使用 多层 background + background-clip + 透明边框 实现渐变边框的核心技巧。

要点回顾：

  1. 使用透明边框：border: 10px solid transparent;
  2. 通过多层背景实现不同区域渐变；
  3. 用 background-clip 精确控制绘制范围。

React 状态管理中的循环更新陷阱与解决方案

✇掘金 前端
作者 AI日报_訾博ZiBo
2025年10月14日 21:17

React 状态管理中的循环更新陷阱与解决方案

问题抽象

在前端开发中，我们经常遇到这样的场景：需要根据初始数据自动回显UI状态，但数据需要分批异步加载。这时容易陷入一个经典的状态同步循环陷阱。

核心矛盾

初始数据: [A, B, C]  (需要回显3项)
         ↓
第一批加载: 找到 A → 回显 A
         ↓
状态同步: 将当前状态 [A] 写回初始数据
         ↓
初始数据: [A]  (丢失了 B, C)
         ↓
第二批加载: 只知道需要回显 A，无法回显 B, C

问题本质

两个 useEffect 形成了不对等的双向绑定：

// Effect 1: 数据 → 视图（分批加载）
useEffect(() => {
  const itemsToShow = source.filter(item => targetIds.includes(item.id))
  setSelected(itemsToShow)  // 部分数据
}, [availableData])

// Effect 2: 视图 → 数据（立即同步）
useEffect(() => {
  targetIds = selected.map(item => item.id)  // 覆盖原始数据
}, [selected])

关键问题：Effect 2 不知道 Effect 1 还没完成，就把部分结果当作最终结果同步回去了。

核心解决思想

思想1：识别"中间状态" vs "最终状态"

通过数据对比判断当前是否处于回显的中间过程：

useEffect(() => {
  const newIds = selected.map(item => item.id)
  const originalIds = initialData.split(',')
  
  // 关键判断：新数据是原始数据的真子集 → 中间状态
  const isPartialState = 
    newIds.every(id => originalIds.includes(id)) &&  // 是子集
    newIds.length < originalIds.length                // 且不完整
  
  // 只在非中间状态时同步
  if (!isPartialState) {
    syncBackToSource(newIds)
  }
}, [selected])

核心逻辑：

  • 子集 + 不完整 = 中间状态 → 不同步
  • 完整 或 包含新增 = 最终状态 → 同步

思想2：保护"原始意图"

维护一个不可变的原始数据引用：

const originalIntent = useRef(null)

// 首次接收时保存原始意图
useEffect(() => {
  if (!originalIntent.current) {
    originalIntent.current = initialData
  }
}, [initialData])

// 始终基于原始意图进行回显
useEffect(() => {
  const targetIds = originalIntent.current.split(',')
  const found = availableData.filter(item => targetIds.includes(item.id))
  
  // 增量更新，不覆盖
  setSelected(prev => {
    const merged = [...prev]
    found.forEach(item => {
      if (!merged.some(m => m.id === item.id)) {
        merged.push(item)
      }
    })
    return merged
  })
}, [availableData])

思想3：单向数据流 + 完成标志

明确区分"回显阶段"和"编辑阶段"：

const [phase, setPhase] = useState('loading')  // loading | editing

// 回显阶段：数据 → 视图
useEffect(() => {
  if (phase === 'loading') {
    const found = availableData.filter(item => targetIds.includes(item.id))
    setSelected(found)
    
    // 判断是否完成
    if (found.length === targetIds.length) {
      setPhase('editing')  // 切换阶段
    }
  }
}, [availableData, phase])

// 编辑阶段：视图 → 数据
useEffect(() => {
  if (phase === 'editing') {
    syncBackToSource(selected)
  }
}, [selected, phase])

通用模式总结

模式1：子集检测模式

适用场景：数据逐步加载，需要保护完整性

function shouldSync(current, original) {
  const isSubset = current.every(item => original.includes(item))
  const isIncomplete = current.length < original.length
  return !(isSubset && isIncomplete)  // 非中间状态才同步
}

模式2：原始意图保护模式

适用场景：需要确保回显完整性，防止数据丢失

const intent = useRef(initialData)
// 所有操作基于 intent.current 而非可能被修改的 initialData

模式3：阶段切换模式

适用场景：明确的流程阶段，需要清晰的状态机

const phases = {
  INITIALIZING: 'init',
  LOADING: 'loading',
  READY: 'ready',
  EDITING: 'editing'
}

设计原则

  1. 单一职责：一个 Effect 只负责一个方向的数据流
  2. 意图保护：保护用户/系统的原始意图不被中间状态破坏
  3. 状态识别：能够识别出"过渡状态"和"稳定状态"
  4. 延迟同步：在不确定的情况下，宁可延迟同步也不要过早同步
  5. 幂等性：同步操作应该是幂等的，多次执行结果一致

反模式警示

❌ 反模式1：盲目双向绑定

// 错误：不加判断的双向绑定
useEffect(() => setA(b), [b])
useEffect(() => setB(a), [a])  // 容易形成循环

❌ 反模式2：忽略异步本质

// 错误：假设数据一次性就绪
useEffect(() => {
  const items = findItems(ids)
  setSelected(items)
  updateSource(items)  // 可能还没加载完
}, [availableData])

❌ 反模式3：过度依赖副作用

// 错误：在副作用中修改依赖的数据源
useEffect(() => {
  const result = process(source)
  source = result  // 修改了依赖，可能导致循环
}, [source])

实战技巧

  1. 添加调试标记：在开发时输出状态转换日志
  2. 使用 TypeScript：类型系统帮助发现潜在的状态不一致
  3. 编写测试：针对边界情况编写单元测试
  4. 代码审查：重点关注 useEffect 的依赖关系图

总结

状态同步的循环更新问题本质是时序控制和状态识别的问题：

  • 时序控制：何时应该同步，何时应该等待
  • 状态识别：当前是中间状态还是最终状态

解决方案的核心是：在不确定的情况下，保护原始数据的完整性，等待明确的信号再进行同步。

记住：数据流应该像河流一样单向流动，而不是像池塘一样相互影响。

一个前端工程师的年度作品：从零开发媲美商业级应用的后台管理系统！

✇掘金 前端
作者 琢磨先生TT
2025年10月14日 16:04
过去一年，我花了无数个夜晚，在一次次打磨与推翻中，完成了自己最满意的作品 —— Art Design Pro。 这不是一个普通的后台模板。 它是一场关于 「设计美学」与「工程化开发」 的融合实验
❌
❌