普通视图

发现新文章,点击刷新页面。
昨天以前首页

React 快速入门:Vue 开发者指南

作者 Lee川
2026年3月15日 18:21

React 快速入门:Vue 开发者指南

通过对比 Vue 和 React,快速掌握 React 核心概念


一、项目结构对比

1.1 依赖管理

React (package.json):

{
  "dependencies": {
    "react": "^19.2.0",
    "react-dom": "^19.2.0"
  }
}

Vue (package.json):

{
  "dependencies": {
    "vue": "^3.4.0"
  }
}

关键差异:

  • React 分两个包:react(核心库)+ react-dom(DOM 渲染器)
  • Vue 只需要一个包
  • React 设计更通用,支持多平台(Web、Native 等)

1.2 入口文件

React (main.jsx):

import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <App />
  </StrictMode>,
)

Vue (main.js):

import { createApp } from 'vue'
import App from './App.vue'

createApp(App).mount('#app')

对比:

  • React 需要显式调用 render()
  • Vue 更简洁,一行完成创建和挂载
  • React 的 StrictMode 提供开发时检查

二、JSX:React 的模板语法

2.1 什么是 JSX?

JSX = JavaScript + XML,允许在 JS 中直接写 HTML 标签。

示例:

function App() {
  const name = "vue";
  return (
    <h1 className="title">Hello {name}!</h1>
  )
}

2.2 JSX vs Vue 模板

特性 React JSX Vue 模板
类名 className class
插值 {name} {{ name }}
事件 onClick={handler} @click="handler"
条件 {condition && <div />} v-if="condition"
列表 {items.map(i => <li />)} v-for="i in items"

2.3 JSX 的本质

JSX 代码:

const element = <h2>标题</h2>

编译后等价于:

const element2 = React.createElement('h2', null, '标题')

为什么使用 JSX?

  1. 更直观,接近 HTML
  2. 完整的 JavaScript 能力
  3. 更好的编辑器支持

三、组件基础

3.1 React 组件

// 函数就是组件
function App() {
  return <h1>Hello React!</h1>
}

export default App

关键点:

  • 组件是函数
  • 返回 JSX
  • 组件名必须大写(区分 HTML 标签)

3.2 组件组合

function Header() {
  return <header><h1>首页</h1></header>
}

function Articles() {
  return <div>文章列表</div>
}

function App() {
  return (
    <>
      <Header />
      <Articles />
    </>
  )
}

Fragment (<>):不会创建额外 DOM 节点,类似 Vue 的 <template>

3.3 Props 传递

// 父组件
function App() {
  return <UserProfile name="张三" />
}

// 子组件
function UserProfile({ name }) {
  return <h1>欢迎,{name}!</h1>
}

对比 Vue:

<template>
  <UserProfile :name="'张三'" />
</template>

<script setup>
const props = defineProps({ name: String })
</script>

四、状态管理:useState

4.1 基本用法

import { useState } from 'react';

function App() {
  const [name, setName] = useState("vue");
  
  return <h1>Hello {name}!</h1>
}

解析:

  • useState 返回数组:[状态值,更新函数]
  • "vue" 是初始值
  • 调用 setName() 会触发重新渲染

4.2 多个状态

function App() {
  const [name, setName] = useState("vue");
  const [todos, setTodos] = useState([
    { id: 1, title: "学习 react" },
    { id: 2, title: "学习 node" },
  ]);
  const [isLoggedIn, setIsLoggedIn] = useState(false);
  
  return (
    <>
      <h1>Hello {name}!</h1>
      {isLoggedIn ? <div>已登录</div> : <div>未登录</div>}
    </>
  )
}

4.3 不可变更新

// ❌ 错误:直接修改
todos.push(newTodo);
setTodos(todos);

// ✅ 正确:创建新数组
setTodos([...todos, newTodo]);

// ✅ 更新对象
setUser({ ...user, age: 26 });

为什么?

  • React 使用浅比较检测变化
  • 不可变数据更可预测
  • 支持并发特性

对比 Vue:

<script setup>
const todos = ref([])
// Vue 支持直接修改
todos.value.push(newTodo)
</script>

Vue 使用 Proxy 自动追踪变化,React 要求不可变更新。


五、事件处理

5.1 基本用法

function App() {
  const [count, setCount] = useState(0);
  
  const handleClick = () => {
    setCount(count + 1);
  };
  
  return <button onClick={handleClick}>+1</button>
}

关键点:

  • 事件名驼峰命名:onClick(不是 onclick
  • 传递函数引用:onClick={handleClick}
  • 不是调用:onClick={handleClick()}

5.2 事件传参

function App() {
  const handleDelete = (id) => {
    console.log('删除:', id);
  };
  
  return (
    <ul>
      {todos.map(todo => (
        <li key={todo.id} onClick={() => handleDelete(todo.id)}>
          {todo.title}
        </li>
      ))}
    </ul>
  )
}

使用箭头函数传参,简单直观。

5.3 对比 Vue

特性 React Vue
语法 onClick={handler} @click="handler"
阻止默认行为 e.preventDefault() .prevent 修饰器
事件对象 自动传递 $event

六、条件渲染

6.1 三元运算符

{isLoggedIn ? <div>已登录</div> : <div>未登录</div>}

6.2 逻辑与运算符

{isLoggedIn && <div>已登录</div>}

6.3 对比 Vue

React:

{count > 0 ? <p>{count}</p> : <p>无数据</p>}

Vue:

<p v-if="count > 0">{{ count }}</p>
<p v-else>无数据</p>

设计哲学:

  • React:使用 JavaScript 原生语法
  • Vue:使用模板指令

七、列表渲染

7.1 使用 map

function App() {
  const todos = [
    { id: 1, title: "学习 react" },
    { id: 2, title: "学习 node" },
  ];
  
  return (
    <ul>
      {todos.map(todo => (
        <li key={todo.id}>
          {todo.title}
        </li>
      ))}
    </ul>
  )
}

7.2 key 的重要性

// ✅ 正确:使用唯一 ID
<li key={todo.id}>

// ❌ 错误:使用索引
<li key={index}>

为什么需要 key?

  • 帮助 React 识别元素
  • 优化虚拟 DOM diff
  • 避免不必要的重新渲染

7.3 对比 Vue

React:

{todos.map(todo => <li key={todo.id}>{todo.title}</li>)}

Vue:

<li v-for="todo in todos" :key="todo.id">
  {{ todo.title }}
</li>

八、完整示例

import { useState } from 'react';
import './App.css';

function App() {
  // 状态管理
  const [name, setName] = useState("vue");
  const [todos, setTodos] = useState([
    { id: 1, title: "学习 react", done: false },
    { id: 2, title: "学习 node", done: false },
    { id: 3, title: "学习 js", done: false },
  ]);
  const [isLoggedIn, setIsLoggedIn] = useState(false);

  // 事件处理
  const toggleLogin = () => {
    setIsLoggedIn(!isLoggedIn);
  }

  // JSX 元素
  const element = <h2>JSX 是 React 的语法扩展</h2>

  return (
    <> 
      {element}
      <h1>Hello <span className="title">{name}!</span></h1>
      
      {/* 条件渲染 + 列表渲染 */}
      {todos.length > 0 ? (
        <ul>
          {todos.map((todo) => (
            <li key={todo.id}>
              {todo.title}
            </li>
          ))}
        </ul>
      ) : (<div>暂无待办事项</div>)}
      
      {/* 条件渲染 */}
      {isLoggedIn ? <div>已登录</div> : <div>未登录</div>}
      
      {/* 事件绑定 */}
      <button onClick={toggleLogin}>
        {isLoggedIn ? "退出登录" : "登录"}
      </button>
    </>
  )
}

export default App

代码要点:

  1. 使用 useState 管理三个状态
  2. 三元运算符实现条件渲染
  3. map 方法实现列表渲染
  4. 箭头函数处理事件
  5. Fragment (<>) 包裹多个元素

九、核心差异总结

9.1 设计哲学

方面 React Vue
定位 库 (Library) 框架 (Framework)
模板 JSX (JavaScript) 模板语法 (HTML-like)
状态更新 不可变 可变
学习曲线 较陡峭 较平缓
灵活性 中等

9.2 代码对比

React:

import { useState } from 'react';

function App() {
  const [count, setCount] = useState(0);
  
  return (
    <div>
      <p>计数:{count}</p>
      <button onClick={() => setCount(count + 1)}>+1</button>
    </div>
  )
}

Vue:

<script setup>
import { ref } from 'vue'

const count = ref(0)
</script>

<template>
  <div>
    <p>计数:{{ count }}</p>
    <button @click="count++">+1</button>
  </div>
</template>

9.3 关键记忆点

  1. JSX 用 {} 插值,不是 {{ }}
  2. 类名用 className,不是 class
  3. 事件用 onClick,不是 @click
  4. 状态不可变更新,不能直接修改
  5. 列表需要 key,使用唯一 ID
  6. 条件用三元运算符,不是 v-if

十、常见陷阱

陷阱 1:直接修改状态

// ❌ 错误
count = count + 1;

// ✅ 正确
setCount(count + 1);

陷阱 2:忘记 key

// ❌ 错误
{items.map(item => <div>{item.name}</div>)}

// ✅ 正确
{items.map(item => <div key={item.id}>{item.name}</div>)}

陷阱 3:混淆 class

// ❌ 错误
<div class="container">

// ✅ 正确
<div className="container">

陷阱 4:事件立即执行

// ❌ 错误
<button onClick={handleClick()}>

// ✅ 正确
<button onClick={handleClick}>

十一、学习建议

11.1 学习路线

第 1 周:基础

  • JSX 语法
  • 组件定义
  • useState

第 2 周:进阶

  • 事件处理
  • 条件/列表渲染
  • useEffect

第 3 周:生态

  • React Router
  • 状态管理
  • UI 组件库

11.2 思维转换

从 Vue 到 React,需要转变:

  1. 从模板到 JSX:接受"一切皆 JavaScript"
  2. 从可变到不可变:习惯创建新对象
  3. 从指令到函数:用原生语法替代指令

11.3 选择建议

选 React 如果:

  • JavaScript 基础好
  • 需要灵活性
  • 想开发跨平台应用

选 Vue 如果:

  • 快速上手
  • 喜欢完整方案
  • 主要开发 Web 应用

总结

React 核心要点:

  1. ✅ JSX 是 JavaScript 扩展,不是 HTML
  2. ✅ 组件是函数,返回 JSX
  3. ✅ useState 管理状态,不可变更新
  4. ✅ 事件用 onClick,传递函数引用
  5. ✅ 条件用三元运算符,列表用 map
  6. ✅ key 帮助优化渲染,必须提供

最后的话:

React 和 Vue 都是优秀框架,没有绝对好坏。理解差异,选择适合的,持续学习才是关键。

资源推荐:

祝你学习顺利! 🚀

CSS 几何美学:从基础图形到创意绘制的艺术之旅

作者 Lee川
2026年3月15日 15:38

CSS 几何美学:从基础图形到创意绘制的艺术之旅

在 Web 开发的浩瀚星空中,CSS(层叠样式表)往往被视作排版与配色的工具。然而,在资深前端工程师的眼中,CSS 更是一支神奇的画笔。无需依赖任何外部图片资源,仅凭几行代码,我们就能在浏览器画布上勾勒出千变万化的几何图形。

本文将深入解析代码中的图形奥秘,并在此基础上拓展更多高阶画法,带您领略“纯 CSS 绘图”的无限可能。


第一章:代码解码——基础图形的构建逻辑

您提供的代码片段虽然简短,却蕴含了 CSS 绘图的三大核心原理:边框 Trick(Border Trick)圆角裁剪(Border-Radius)变换旋转(Transform)。让我们逐一拆解。

1. 三角形的魔法:边框的障眼法

代码中的 .triangle 类展示了经典的“边框绘图法”。

.triangle {
    width: 5px;
    height: 5px;
    border: 15px solid transparent;
    border-top-color: #f00;
}

原理解析: 当一个元素的宽和高极小(甚至为 0),而边框(border)很宽时,浏览器的渲染引擎会将四个边框渲染为四个梯形,并在中心交汇。

  • border 设为 transparent(透明),意味着我们只保留了边框的“形状”,隐藏了颜色。
  • 单独设置 border-top-color 为红色,就只留下了上方的梯形。
  • 由于底边极窄,这个梯形最终变成了一个完美的等腰三角形注:代码中注释掉的部分展示了四色边框的效果,那是四个不同颜色的三角形拼接成的正方形,是理解此原理的绝佳实验。

2. 扇形与圆弧:圆角的极致运用

代码提供了两种扇形画法,分别代表了两种不同的思路。

思路 A:宽高比控制 (.sector)

.sector {
    width: 100px;
    height: 100px;
    border-radius: 100px 0 0; /* 左上角半径极大,其余为0 */
    background-color: #00f;
}

通过设置 border-radius 的四个值(左上、右上、右下、左下),我们可以独立控制每个角的曲率。当左上角的半径值大于元素本身宽高时,它就会形成一个 90 度的扇形(四分之一圆)。

思路 B:边框与圆角结合 (.sector2)

.sector2 {
    border: 100px solid transparent;
    width: 0;
    border-radius: 100px;
    border-top-color: #f00;
}

这是在三角形原理基础上的进化。给一个宽为 0、边框透明的元素加上 border-radius,会让原本尖锐的边框交汇处变得圆润,从而切割出弧形边缘,形成扇形。

3. 箭头与椭圆:变换与比例

  • 箭头 (.arrow):利用 border 只保留右边和下边,再通过 transform: rotate(45deg) 旋转 45 度,两条边瞬间合二为一,形成一个指向右下方的箭头。这是对话框气泡尾部的经典实现方式。
  • 椭圆 (.oval):最简单的图形。只要 width 不等于 height,再配合 border-radius: 50%,正方形就会拉伸成完美的椭圆。

第二章:进阶扩展——解锁更多 CSS 图形秘籍

基于上述原理,我们可以进一步探索更复杂的图形绘制,无需 SVG 或 Canvas,仅用 CSS 即可实现。

1. 平行四边形 (Parallelogram)

想要让矩形“倾斜”起来?不要直接旋转整个元素(否则内容也会歪斜),请使用 skew 变换。

.parallelogram {
    width: 150px;
    height: 60px;
    background: #8e44ad;
    transform: skew(-20deg); /* 水平倾斜 -20 度 */
}
/* 如果内部有文字,需要反向倾斜回来 */
.parallelogram span {
    display: block;
    transform: skew(20deg); 
}

应用场景:科技感的数据看板、动态按钮背景。

2. 六角星 (Hexagram) / 大卫之星

这是两个等边三角形的叠加。利用伪元素 ::before::after 可以轻松实现,无需额外 HTML 标签。

.star {
    position: relative;
    width: 0;
    height: 0;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
    border-bottom: 80px solid #f1c40f; /* 正三角 */
}
.star::before, .star::after {
    content: "";
    position: absolute;
    width: 0;
    height: 0;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
}
.star::before {
    border-bottom: 80px solid #f1c40f;
    top: 30px; /* 调整位置以重叠 */
    transform: rotate(60deg);
}
.star::after {
    border-bottom: 80px solid #f1c40f;
    top: 30px;
    transform: rotate(-60deg);
}

原理:利用绝对定位将三个三角形(一个本体,两个伪元素)以 60 度差值旋转叠加。

3. 心形 (Heart)

心形是浪漫网页设计的标配,它由两个圆形和一个旋转的正方形组合而成。

.heart {
    position: relative;
    width: 50px;
    height: 50px;
    background-color: #e74c3c;
    transform: rotate(-45deg); /* 整体旋转 45 度 */
}
.heart::before, .heart::after {
    content: "";
    position: absolute;
    width: 50px;
    height: 50px;
    background-color: #e74c3c;
    border-radius: 50%; /* 变成圆形 */
}
.heart::before {
    top: -25px; /* 向上移半个身位 */
    left: 0;
}
.heart::after {
    left: 25px; /* 向右移半个身位 */
    top: 0;
}

视觉效果:两个圆分别位于正方形的上方和右方,旋转后完美融合成心形。

4. 对话气泡 (Speech Bubble)

结合“三角形箭头”和“圆角矩形”,我们可以快速制作聊天气泡。

.bubble {
    position: relative;
    width: 120px;
    height: 80px;
    background: #3498db;
    border-radius: 10px;
    padding: 10px;
    color: white;
}
/* 利用伪元素制作尾巴 */
.bubble::after {
    content: "";
    position: absolute;
    bottom: -10px; /* 定位到底部下方 */
    left: 20px;
    width: 0;
    height: 0;
    border-left: 10px solid transparent;
    border-right: 10px solid transparent;
    border-top: 10px solid #3498db; /* 颜色与气泡一致 */
}

5. 加载动画:旋转的圆环 (Loader)

静态图形是基础,动态图形才是灵魂。利用 border 的部分透明化加上 animation,可以制作流畅的 Loading 效果。

.loader {
    width: 40px;
    height: 40px;
    border: 4px solid #f3f3f3; /* 灰色底色 */
    border-top: 4px solid #3498db; /* 蓝色高亮 */
    border-radius: 50%;
    animation: spin 1s linear infinite;
}

@keyframes spin {
    0% { transform: rotate(0deg); }
    100% { transform: rotate(360deg); }
}

原理:一个只有顶部有颜色的圆环,通过无限旋转,视觉上就像在“吃豆人”一样转动,给用户明确的等待反馈。


第三章:为什么选择纯 CSS 绘图?

在 SVG 和 Canvas 如此强大的今天,我们为什么还要钻研 CSS 画图?

  1. 性能极致:CSS 图形由浏览器原生渲染引擎直接绘制,无需下载额外的图片资源,减少了 HTTP 请求,提升了页面加载速度。
  2. 无限缩放:基于矢量的边框和圆角特性,CSS 图形在任何分辨率屏幕(Retina屏、4K屏)下都清晰锐利,绝无锯齿。
  3. 灵活可控:通过 CSS 变量(Custom Properties)和伪类(:hover, :active),图形可以轻易地响应交互、改变颜色或形状,这是静态图片难以比拟的。
  4. 代码即设计:设计师的意图直接转化为代码,减少了切图环节,让前端开发更加流畅。

结语

从那个小小的红色三角形开始,我们看到了 CSS 蕴含的巨大能量。它不仅仅是样式的描述语言,更是一套严谨的几何构建系统。

掌握这些技巧,意味着您不再受限于素材库。无论是需要一个简单的下拉箭头,还是一个复杂的动态徽章,您都可以信手拈来,用代码编织出视觉的奇迹。下一次,当您面对空白的设计稿时,请记得:您的键盘,就是最强大的画笔。

从“DOM 操作”到“数据驱动”:Vue 如何重塑前端开发思维

作者 Lee川
2026年3月14日 18:22

从“DOM 操作”到“数据驱动”:Vue 如何重塑前端开发思维

导读:在传统的 Web 开发中,我们习惯于像“外科医生”一样精准地操作每一个 DOM 节点;而在 Vue 的世界里,我们更像是“指挥官”,只需关注数据的变化,剩下的交给框架。本文将通过深度剖析一段现代 Vue 3 待办事项(Todo List)代码,对比传统 demo.html 的实现缺陷,带你深入理解 Vue 的核心开发哲学与代码美学。


一、传统开发的困境:被 DOM 绑架的逻辑

假设我们手头有一份传统的 demo.html 文件(基于原生 JavaScript 或 jQuery 实现)。在这类文件中,实现一个待办事项列表通常意味着:

  1. 手动获取元素document.getElementById('input'), querySelectorAll('li')
  2. 繁琐的事件监听addEventListener('click', ...)addEventListener('keydown', ...)
  3. 直接的 DOM 操作:添加任务时 createElementappendChild;完成任务时 classList.toggle;统计数量时遍历 DOM 节点计数。
  4. 状态同步噩梦:数据变了要手动改 DOM,DOM 变了要手动改数据。一旦遗漏,页面显示与数据不一致的 Bug 随之而来。

这种“命令式”编程让开发者陷入了细节的泥潭:代码耦合严重、维护困难、性能隐患大


二、Vue 的革命:代码深度解析

当我们转向你提供的这段 Vue 3 <script setup> 代码时,会发现一种截然不同的优雅。让我们逐行拆解,看看 Vue 是如何通过响应式系统声明式渲染计算属性来解决传统痛点的。

2.1 响应式基石:ref 与数据焦点

import {ref, computed} from 'vue'

// 响应式数据
const title = ref();
const todos = ref([
  { id:1, title:'吃鸡', done:true },
  { id:2, title:'睡觉', done:true }
]);
  • 传统做法:你需要定义一个数组变量,然后每次修改它时,都要记得去更新页面上的列表。
  • Vue 做法:使用 ref() 将普通变量包裹成响应式引用
    • titletodos 不再是普通变量,而是带有“魔法”的数据容器。
    • 核心逻辑:正如代码注释所言,“vue focus 标题数据业务,修改数据,余下的 dom 更新 vue 替我们做了”。你只需要关心 title.value 是什么,todos.value 里有什么,完全不需要知道页面上有几个 <li> 标签。
    • 访问机制:在 <script> 中通过 .value 访问真实数据(如 title.value),而在 <template> 中 Vue 会自动解包,直接使用 {{ title }}

2.2 声明式渲染:模板即逻辑

<h2>{{ title }}</h2>
<input type="text" v-model="title" @keydown.enter="addTodo">

<ul v-if="todos.length">
  <li v-for="todo in todos" :key="todo.id">
      <input type="checkbox" v-model="todo.done">
      <span :class="{done: todo.done}">{{ todo.title }}</span> 
  </li>
</ul>
<div v-else>
  暂无计划
</div>

这段模板代码展示了 Vue 三大指令的精妙配合,彻底摒弃了手动操作 DOM:

A. 双向绑定 v-model
  • 代码v-model="title"v-model="todo.done"
  • 解析:这是 Vue 最强大的特性之一。
    • 在输入框中,它将输入内容与 title 变量绑定。用户打字,title 自动变;代码修改 title,输入框自动变。
    • 在复选框中,它将勾选状态与 todo.done 绑定。
    • 对比传统:传统写法需要监听 input 事件更新变量,监听变量变化更新 input 值,代码量翻倍且容易出错。Vue 一行搞定。
B. 事件修饰符 @keydown.enter
  • 代码@keydown.enter="addTodo"
  • 解析
    • @v-on: 的缩写,用于监听事件。
    • .enter事件修饰符,意为“只在按下回车键时触发”。
    • 优势:无需在 JS 中写 if (event.key === 'Enter') 判断逻辑,语义清晰,代码极简。注释中提到“不用 addEventListener”,正是指这种声明式绑定的便捷性。
C. 条件与列表渲染 v-if / v-for / :key
  • 代码v-if="todos.length"v-for="todo in todos" :key="todo.id"
  • 解析
    • 智能空状态v-ifv-else 实现了“有数据显示列表,无数据显示提示”的逻辑切换,无需手动 display: none
    • 高效循环v-for 根据 todos 数组自动生成 <li>
    • Key 的作用:key="todo.id" 是 Vue 优化渲染的关键。它给每个节点发了“身份证”,当数组顺序变化或删除项时,Vue 能精准复用 DOM 节点,而不是暴力销毁重建,极大提升性能。
D. 动态 Class 绑定 :class
  • 代码:class="{done: todo.done}"
  • 解析
    • :v-bind: 的缩写。
    • 这是一个对象语法:当 todo.donetrue 时,应用 done 类(灰色删除线);为 false 时,不应用。
    • 数据驱动视图:你不需要写 element.classList.add('done'),只需改变数据 todo.done = true,样式自动生效。

2.3 性能与逻辑的升华:computed 计算属性

代码中两处使用了 computed,这是区分新手与高手的关键。

场景一:统计未完成数量
// 依赖于 todos 响应式数据的计算属性
const active = computed(() => {
  return todos.value.filter(todo => !todo.done).length
})
  • 模板调用{{ active }} / {{ todos.length }}
  • 深度分析
    • 缓存机制:注释写道“computed 缓存 性能优化 只有 todos 变化时才会重新计算”。如果用户只是在输入框打字(触发组件重渲染),但未改变 todos 数组,active 不会重新执行 filter,直接返回缓存结果。
    • 对比劣势方案:如果在模板中直接写 {{ todos.filter(...).length }},每次组件更新(哪怕无关)都会重新遍历数组,浪费性能。
    • 逻辑复用:复杂的过滤逻辑被封装在 JS 中,模板保持干净。
场景二:全选/全不选的高级技巧
const allDone = computed({
  get() {
    return todos.value.every(todo => todo.done)
  },
  set(val) {
    todos.value.forEach(todo => todo.done = val)
  }
})
  • 模板调用<input type="checkbox" v-model="allDone">
  • 深度分析:这是 computed读写模式(Getter/Setter)。
    • **Get **(读):当页面渲染时,检查是否所有任务都完成了 (every)。如果是,全选框自动勾选。
    • **Set **(写):当用户点击全选框时,触发 set,将所有任务的 done 状态设为 val
    • 神奇之处:一个 v-model 同时实现了“状态同步”和“批量修改”。传统 JS 需要分别编写“检查所有状态更新全选框”和“监听全选框更新所有状态”两段逻辑,极易出现不同步 Bug。Vue 将其收敛为一个计算属性,逻辑严密且优雅。

2.4 业务逻辑封装:addTodo 函数

const addTodo = () => {
  if(!title.value) return; // 数据校验
  todos.value.push({
    id: Date.now(), // 使用时间戳生成唯一 ID,比 Math.random() 更可靠
    title: title.value,
    done: false
  })
  // 注意:这里没有操作 DOM!
  // 只要 push 进数组,Vue 会自动在页面上添加一个新的 <li>
}
  • 纯粹的数据操作:函数内部没有任何 document 相关代码。
  • ID 策略:使用 Date.now() 生成唯一 ID,配合 :key 确保列表渲染稳定。
  • 自动响应push 操作触发 Vue 的响应式系统,视图自动更新。

三、思维跃迁:从“怎么做”到“是什么”

通过这段代码,我们可以清晰地看到 Vue 带来的思维转变:

维度 传统 DOM 操作 (demo.html) Vue 数据驱动 (当前代码)
关注点 How:怎么找到元素?怎么添加类名?怎么监听事件? What:数据是什么?状态是什么?
状态同步 手动双向同步,易出错 自动双向绑定 (v-model)
列表渲染 手动循环创建/删除节点 声明式循环 (v-for),自动 Diff
复杂逻辑 分散在事件回调中,难以维护 封装在 computed 中,自动缓存
代码量 多且冗余 少而精悍
可维护性 低,牵一发而动全身 高,逻辑与视图分离

核心心法总结

  1. 数据是唯一真理:不要直接操作 DOM。想改变页面?先改变数据。
  2. 声明式优于命令式:告诉 Vue 你想要什么结果(v-if, v-for),而不是告诉它一步步怎么做。
  3. 计算属性是性能利器:涉及复杂推导或频繁使用的数据,务必使用 computed 利用缓存。
  4. 组合式 API 的内聚性<script setup> 让相关逻辑(如 todos, active, addTodo)聚集在一起,代码组织更符合人类思维。

四、结语

这段看似简单的 Todo List 代码,实则是现代前端开发哲学的缩影。它展示了 Vue 如何通过响应式系统将开发者从繁琐的 DOM 操作中解放出来,让我们能专注于业务逻辑本身。

demo.html 的“手动挡”到 Vue 的“自动挡”,不仅仅是语法的升级,更是开发效率与代码质量质的飞跃。当你习惯了“修改数据即修改视图”的思维模式后,你会发现,构建复杂的交互应用变得前所未有的简单、高效且充满乐趣。

这,就是 Vue 赋予我们的超能力。

从“手工砌砖”到“魔法蓝图”:响应式驱动界面的诞生与实战

作者 Lee川
2026年3月14日 15:44

从“手工砌砖”到“魔法蓝图”:响应式驱动界面的诞生与实战

在编程的世界里,用户界面(UI)的构建方式经历了一场从“体力活”到“智力活”的深刻革命。这场革命的核心,就是从**“命令式地操作 DOM”转向“声明式地数据驱动”**。

为了让你彻底理解这一变革,我们将穿越时空,通过具体的代码对比,看看曾经的开发者是如何在“泥潭”中挣扎,而现在的我们又是如何利用响应式系统轻松驾驭界面的。


第一章:蛮荒时代——“手工砌砖”的痛苦

在互联网的早期(或者在使用原生 JavaScript/jQuery 的时代),浏览器只是一个简单的文档查看器。如果你想让界面上的文字变一下,或者增加一行列表,你必须像一个泥瓦匠一样,亲手去搬动每一块“砖头”(DOM 节点)。

1.1 场景:做一个简单的计数器

需求:页面上有一个数字显示当前计数,还有一个按钮,每点一次,数字加 1。

❌ 过去的做法(命令式 DOM 操作)

在那个年代,你的思维过程是这样的:

  1. 我要去 HTML 里找到那个显示数字的元素。
  2. 我要监听按钮的点击事件。
  3. 点击发生时,我要拿到当前的数字。
  4. 把数字加 1。
  5. 最关键的一步:我要手动把新数字写回那个元素里。

代码示例(原生 JavaScript):

<!-- 1. 定义 HTML 结构 -->
<div id="app">
  <h1 id="count-display">0</h1>
  <button id="increment-btn">点击加 1</button>
</div>

<script>
  // 2. 手动获取 DOM 元素(就像去仓库找砖头)
  const countDisplay = document.getElementById('count-display');
  const incrementBtn = document.getElementById('increment-btn');

  // 3. 定义一个变量存数据
  let count = 0;

  // 4. 手动绑定事件
  incrementBtn.addEventListener('click', () => {
    // 业务逻辑:数据加 1
    count = count + 1;
    
    // ⚠️ 痛苦之源:手动更新视图!
    // 如果忘了写这一行,界面永远不会变,但数据已经变了(状态不一致)
    // 如果页面有10个地方显示这个 count,你得改10次!
    countDisplay.innerText = count; 
    
    console.log("手动更新了 DOM,好累...");
  });
</script>
💡 痛点分析
  • 关注点偏移:你本该思考“点击后业务逻辑是什么”,却被迫花费大量精力在 getElementByIdinnerText 这些繁琐的 DOM 操作上。
  • 容易出错:如果你修改了 count 却忘了更新 countDisplay,界面就错了(数据与视图不同步)。
  • 难以维护:如果后来需求变了,要在三个不同的地方显示这个数字,你就得在三处地方都写上 xxx.innerText = count。代码变得像蜘蛛网一样乱。

第二章:黎明时刻——“魔法蓝图”的降临

随着 Vue、React 等框架的出现,世界变了。我们不再手动操作 DOM,而是引入了一位“管家”(响应式系统)。

核心理念你只管修改数据,界面自动会变。 你只需要画一张“蓝图”(模板),告诉框架:“这里显示 count”。至于 count 变了怎么更新界面?那是框架的事,与你无关。

2.1 同样的场景:计数器

需求:同上。

✅ 现在的做法(声明式 + 响应式)

现在的思维过程是这样的:

  1. 定义一个响应式数据 count
  2. 在模板里直接写 {{ count }}(这就是蓝图)。
  3. 点击时,只修改 count 的值。
  4. 结束。剩下的交给框架。

代码示例(Vue 3 风格):

<!-- 引入 Vue 3 -->
<script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>

<div id="app">
  <!-- 1. 声明式模板:直接告诉 Vue 这里显示 count -->
  <!-- 不需要给 h1 起 id,也不需要手动找它 -->
  <h1>{{ count }}</h1>
  
  <!-- 2. 事件绑定:点击直接调用函数 -->
  <button @click="increment">点击加 1</button>
</div>

<script>
  const { createApp, ref } = Vue;

  createApp({
    setup() {
      // 3. 定义响应式数据 (ref)
      // 这是一个有“魔法”的变量,它被修改时,所有用到它的地方都会收到通知
      const count = ref(0);

      // 4. 定义方法
      const increment = () => {
        // ⚡️ 核心时刻:只改数据!
        count.value++; 
        
        // 🎉 奇迹发生:
        // 你完全不需要写 document.getElementById...
        // 你完全不需要写 innerText = ...
        // Vue 检测到 count 变了,自动把页面上的 {{ count }} 更新为最新值
        console.log("数据已变,界面自动同步,真爽!");
      };

      // 把数据和方法暴露给模板使用
      return {
        count,
        increment
      };
    }
  }).mount('#app');
</script>
🚀 先进在哪里?
  1. 代码量减半:不需要找节点,不需要手动赋值。
  2. 单向数据流:数据是唯一的真理来源(Single Source of Truth)。你永远不会遇到“数据是 5,界面显示 4”这种 Bug。
  3. 可维护性极强:哪怕你在页面上写了 100 个 {{ count }},你也只需要改一次 count.value,所有地方瞬间同步更新。

第三章:进阶实战——列表的动态增删

如果说计数器只是热身,那么列表的动态增删才是真正体现“手工砌砖”与“魔法蓝图”差距的战场。

3.1 场景:待办事项列表

需求:有一个输入框,输入内容后回车,列表增加一项;点击列表项,该项删除。

❌ 过去的痛苦(原生 JS 实现逻辑推演)

如果用原生 JS 做这个,你需要处理:

  1. 监听输入框的 keydown 事件。
  2. 获取输入值,判空。
  3. 创建新的 li 元素 (document.createElement('li'))。
  4. 设置 li 的文本内容。
  5. 难点:给这个新生成的 li 里的“删除按钮”绑定点击事件(事件委托或直接绑定)。
  6. li 插入到 ul 中 (ul.appendChild(li))。
  7. 更难的是删除:点击删除时,要找到这个 li 对应的父节点,把它移除 (parent.removeChild(child)), 同时还要更新你内存里的数组数据,保持同步。

稍微想象一下代码长度:至少需要 30-40 行逻辑严密的 DOM 操作代码,稍有不慎就会内存泄漏或事件绑定失效。

✅ 现在的优雅(Vue 响应式实现)

在响应式世界里,我们只关心数组的变化。

<div id="todo-app">
  <h2>待办事项</h2>
  
  <!-- 双向绑定:输入框直接绑定到 newItem 变量 -->
  <input v-model="newItem" @keyup.enter="addTodo" placeholder="输入任务回车添加" />
  
  <!-- 列表渲染:v-for 指令 -->
  <!-- 意思是:items 数组里有几个元素,就生成几个 li -->
  <ul>
    <li v-for="(item, index) in items" :key="item.id">
      {{ item.text }} 
      <button @click="removeTodo(index)">删除</button>
    </li>
  </ul>
  
  <p v-if="items.length === 0">暂无任务,太轻松了!</p>
</div>

<script>
  const { createApp, ref } = Vue;

  createApp({
    setup() {
      const newItem = ref('');
      // 响应式数组
      const items = ref([
        { id: 1, text: '学习响应式原理' },
        { id: 2, text: '编写代码示例' }
      ]);

      // 添加逻辑:只操作数组
      const addTodo = () => {
        if (!newItem.value.trim()) return;
        // 往数组里 push 一个对象
        items.value.push({
          id: Date.now(),
          text: newItem.value
        });
        newItem.value = ''; // 清空输入框,界面自动清空
        
        // 🎉 此时:
        // 1. 新的 <li> 自动出现在列表中
        // 2. 删除按钮自动绑好了事件
        // 3. 如果列表从空变有,"暂无任务"提示自动消失
        // 全程无需触碰 DOM!
      };

      // 删除逻辑:只操作数组
      const removeTodo = (index) => {
        // 从数组里 splice 掉一项
        items.value.splice(index, 1);
        
        // 🎉 此时:
        // 对应的 <li> 自动从页面上移除
        // 事件监听器自动被清理(防止内存泄漏)
      };

      return {
        newItem,
        items,
        addTodo,
        removeTodo
      };
    }
  }).mount('#todo-app');
</script>

3.2 深度解析:为什么这很“先进”?

  1. 心智负担极低

    • 过去:你要同时维护“内存里的数组”和“页面上的 DOM 列表”,确保它们永远一致。这就像一边开车一边还要自己铺路。
    • 现在:你只维护“数组”。页面是数组的投影。数组变了,投影自然变。你只需要关注业务数据。
  2. 自动的事件管理

    • 在原生 JS 中,动态添加的 DOM 元素,你需要重新绑定事件,或者使用复杂的事件委托。
    • 在 Vue 中,@click 写在模板里,无论列表怎么变,新生成的元素天然就带着事件监听器,删除元素时监听器也自动销毁。
  3. 条件渲染的自动化

    • 注意代码中的 <p v-if="items.length === 0">
    • 当数组为空时,这段 HTML 自动出现;当数组有数据时,它自动消失。你不需要写 if/else 去控制 display: noneremoveChild

第四章:总结——从小白到架构师的思维跃迁

通过上面的对比,我们可以清晰地看到响应式驱动界面带来的巨大飞跃:

特性 传统 DOM 操作 (过去) 响应式数据驱动 (现在)
核心动作 查找节点 -> 修改属性 -> 插入/删除节点 修改数据变量
关注点 How (如何实现界面变化) What (数据应该是什么状态)
同步机制 手动同步,易出错 自动同步,永不失联
代码复杂度 随功能线性甚至指数增长 保持简洁,逻辑清晰
适合人群 需要精通底层细节的专家 专注于业务逻辑的开发者

给小白的建议

如果你刚开始学习前端,请忘掉 document.getElementById忘掉 innerHTML忘掉 手动添加事件监听器。

试着培养一种新的直觉:

  1. 数据先行:先想清楚我的页面需要哪些数据(比如 count, userList, isVisible)。
  2. 模板声明:在 HTML 里用 {{ }}v-for 把这些数据“画”出来。
  3. 事件驱动:在按钮点击时,只负责修改那些数据。

当你习惯了这种**“数据流动,界面随之起舞”**的感觉时,你就真正掌握了现代前端开发的精髓。这不仅仅是学会了一个框架,更是掌握了一种更高效、更优雅的构建数字世界的方法。

🚀 JavaScript 内存大揭秘:从“栈堆搬家”到“闭包时空胶囊”

作者 Lee川
2026年3月13日 18:07

🚀 JavaScript 内存大揭秘:从“栈堆搬家”到“闭包时空胶囊”

第一章:舞台搭建 —— 内存的三大分区

在代码运行之前,JavaScript 引擎先画好了三块地皮。请看这张图,这是所有故事发生的物理地基

c2e28f0b62e932380333c67696ea1599.jpg

  1. 🟠 代码空间 (Code Space):存放我们的剧本(源代码)。
  2. 🔴 栈空间 (Stack)“临时更衣室”
    • 特点:进出极快,空间小,自动整理。
    • 住谁?函数执行的上下文基本数据类型(数字、布尔值等)。
    • 规则:后进先出(LIFO),函数执行完,里面的东西立马被清空。
  3. 🔵 堆空间 (Heap)“大型仓库”
    • 特点:空间大,存取稍慢,需要保洁员(垃圾回收器 GC)定期打扫。
    • 住谁?对象、数组、函数等复杂的大件物品。

💡 核心隐喻

  • 是演员手里的提词卡(写着简单的数字或地址)。
  • 是后台巨大的道具库(放着复杂的布景和道具)。
  • 演员(变量)手里通常只拿着一张写有道具编号的卡片(引用地址),而不是直接把道具扛在肩上。

第二章:基本类型的“独立副本” —— 深度解析 1.js

让我们先看 1.js 的代码,看看它在栈空间里是怎么“变魔术”的。

📜 代码剧本 (1.js)

function foo() {
    var a = 1;      // 步骤 A
    var b = a;      // 步骤 B
    a = 2;          // 步骤 C
    console.log(a); // 输出 2
    console.log(b); // 输出 1  <-- 为什么 b 没变?
}
foo();

🎬 内存现场直播

步骤 A:var a = 1;

引擎在栈空间开辟了一个格子,贴上标签 a,里面直接放入数字 1

  • 栈状态[ a: 1 ]
  • 堆状态:空(基本类型不住堆)
步骤 B:var b = a; (关键瞬间!)

这是新手最容易误解的地方。

  • 错误理解ba 绑定了,ab 也变。
  • 真相:引擎在栈空间又开辟了一个全新的格子,贴上标签 b。它读取 a 格子里的值(也就是 1),然后复制了一份放到 b 的格子里。
  • 栈状态
    [ a: 1 ]
    [ b: 1 ]  <-- 这是一个独立的副本!
    
  • 此时,a 和 b 毫无关系,只是数值碰巧相同。
步骤 C:a = 2;

引擎找到标签 a 的格子,把里面的 1 擦掉,写上 2

  • 栈状态
    [ a: 2 ]  <-- 只有这里变了
    [ b: 1 ]  <-- b 毫发无损,因为它存的是独立的副本
    
🏁 结局
  • console.log(a) -> 读到 2
  • console.log(b) -> 读到 1

🧠 记忆口诀基本类型是“复印机”。 b = a 是把 a 的内容复印了一份给 b。以后 a 怎么改,跟 b 手里的复印件没关系。


第三章:引用类型的“共享地址” —— 深度解析 2.js

现在难度升级,看看 2.js 中的对象。这时候,堆空间登场了。

📜 代码剧本 (2.js)

function foo() {
    var a = {name: "极客时间"};  // 步骤 A
    var b = a;                    // 步骤 B
    a.name = '极客邦';            // 步骤 C
    console.log(a); 
    console.log(b);               // 输出什么?居然也变了?
}
foo();

🎬 内存现场直播

步骤 A:var a = {name: "极客时间"};
  1. 堆空间行动:引擎发现是个对象(大件物品),不能在栈里直接放。于是它在堆空间申请了一块地盘(假设地址是 1001),把 {name: "极客时间"} 这个对象存进去。
  2. 栈空间行动:在栈里创建变量 a。但是 a 里面不存对象本身,而是存那个对象的门牌号(地址) 1001
  • 栈状态[ a: 1001 (地址) ]
  • 堆状态地址 1001 -> { name: "极客时间" }
步骤 B:var b = a; (最关键的时刻!)
  • 动作:引擎在栈里创建变量 b。它读取 a 里的内容。

  • 注意a 里的内容是 1001(地址)。所以,引擎把 1001 复制给了 b

  • 结果ab 现在都拿着同一张写着 1001 的纸条。它们指向同一个堆内存地址。

  • 栈状态

    [ a: 1001 ]  \
                  +--> 指向堆里的同一个对象
    [ b: 1001 ]  /
    
  • 堆状态地址 1001 -> { name: "极客时间" }

步骤 C:a.name = '极客邦';
  • 动作:引擎通过 a 找到地址 1001,冲进堆空间,把那个对象里的 name 属性改成了 '极客邦'

  • 关键点:它修改的是堆里的实物,而不是栈里的地址。

  • 堆状态更新地址 1001 -> { name: "极客邦" } (实物被改了!)

🏁 结局
  • console.log(a):拿着地址 1001 去堆里看 -> 看到 { name: "极客邦" }
  • console.log(b):拿着地址 1001 去堆里看 -> 还是看到 { name: "极客邦" }

🧠 记忆口诀引用类型是“遥控器”。

  • ab 是两个不同的遥控器(栈里的变量)。
  • 但它们都对着同一台电视机(堆里的对象)。
  • 你用 a 遥控器换了台(修改属性),b 遥控器看到的画面自然也跟着变了。

第四章:闭包的“时空胶囊” —— 结合图片深度拆解

为什么函数执行完了,里面的变量还能被记住?这就是闭包的魔法。我们结合您提供的后三张图来还原这个过程。

场景设定

function foo() {
    var myName = "极客时间";
    var test1 = 1;
    
    function inner() {
        var test2 = 2;
        console.log(myName); // 这里的 myName 从哪来?
    }
    
    return inner; // 把内部函数扔出去
}

var bar = foo(); // foo 执行完了,按理说它的变量该消失了
bar();           // 但这里依然能打印 "极客时间"

第一阶段:函数执行中

foo() 正在运行时:

  1. 调用栈 (Call Stack) 压入了一个 foo 的执行上下文。
  2. 变量环境里记录了:
    • myName: "极客时间"
    • test1: 1
    • inner: 函数定义(包含了一个秘密武器:对外部作用域的引用
  3. 此时一切正常,myName 就安稳地待在 foo 的栈帧里。

第二阶段:返回与引用的建立

这是最神奇的一步!

  1. foo 函数执行结束,按常理,它的执行上下文应该从调用栈弹出,里面的 myName 应该被销毁。
  2. 但是! 因为 inner 函数(现在赋值给了全局变量 bar)在定义时,偷偷通过作用域链抓住了 foo 的变量环境。
  3. 内存迁移
    • 原本应该在栈里随函数结束而消失的 myNametest1,因为被 inner 引用了,引擎被迫将它们从栈空间“转移”或“保留”在堆空间中(或者说,包含这些变量的整个作用域对象被移到了堆上持久化)。
    • 如上图所示,clourse(foo) (即 inner) 在栈里,但它手里紧紧攥着一个地址 1003
    • 地址 1003 指向堆空间里的一个对象,里面赫然躺着 { myName: "极客时间", test1: 1 }

第三阶段:调用闭包

当我们调用 bar() (即 inner) 时:

  1. 引擎创建 inner 的执行上下文。
  2. 代码遇到 console.log(myName)
  3. 引擎在当前上下文没找到 myName
  4. 它顺着作用域链(那个秘密武器),找到了堆里地址 1003 对应的环境。
  5. 成功读取:"极客时间"。

🧠 闭包本质总结: 闭包不是某种特殊的语法,而是函数与其词法环境的组合

  • 普通函数:用完即走,栈帧清空,数据消失。
  • 闭包函数:因为“有人”(外部引用)还需要它内部的变量,所以引擎不敢清空栈帧,而是把这些变量打包扔到堆里长期保存,直到没人再需要这个函数为止。
  • 代价:这些变量会一直占用内存,直到 bar = null 断开引用,垃圾回收器才会来清理。

第五章:一图胜千言 —— 总结对比

为了让您彻底清晰,我们把刚才的分析浓缩成一张对比表:

特性 基本类型 (1.js) 引用类型 (2.js) 闭包 (5.html/6.html)
存储位置 只在栈 栈存地址,堆存实体 变量被强行保留在堆
赋值行为 值拷贝 (复印文件) 引用拷贝 (复制遥控器) 作用域捕获 (带走整个房间)
修改影响 互不影响 互相影响 (改的是同一份数据) 内部函数可读写外部私有变量
生命周期 函数结束即销毁 对象无引用时被 GC 回收 比定义它的函数活得更久
形象比喻 两个独立的苹果 两个人看同一个投影 把家里的家具搬到了公共仓库

💡 给开发者的终极建议

  1. 处理基本类型:放心大胆地赋值,不用担心改了一个影响另一个。
  2. 处理对象/数组:小心!b = a 之后,你以为你在操作 b,其实你可能在修改 a 的数据。如果需要独立副本,请使用扩展运算符 [...a]Object.assign 进行深拷贝/浅拷贝
  3. 使用闭包
    • 好处:创造私有变量,模拟类,函数柯里化。
    • 风险:如果不小心在闭包里引用了巨大的 DOM 节点或大对象,且长期不释放,会导致内存泄漏
    • 解决:不需要时,手动将引用置为 null (bar = null),告诉垃圾回收器“可以打扫了”。

希望这次结合内存动态流转生活化比喻的讲解,能让您对 JavaScript 的内存机制和闭包有透彻的理解!如果还有哪个环节觉得不够直观,请随时告诉我,我们可以针对那个点继续深挖。

❌
❌