COURSE 02 — STYLE

CSS · 装饰之衣

如果说 HTML 给了网页一副骨架,CSS 就是替它挑衣服、理头发、调灯光的人。 这一章从一条最简单的规则开始,走过选择器、盒模型、颜色与排版, 再到 Flex、Grid、定位、动画与响应式,最后把它们缝成一件合身的衣裳。

10 个章节 22+ 段代码 约 5 小时 难度 · 进阶
学习进度 0%
01

CSS 入门:给网页穿衣裳

Cascading Style Sheets · 规则、层叠与渲染

CSS(Cascading Style Sheets,层叠样式表)负责网页的「表现」。它不改变内容本身, 只改变内容被看见的方式:字多大、行多松、颜色偏暖还是偏冷、两块内容之间留多少呼吸。 学会 CSS,你才算真正开始设计一个页面,而不只是把信息摆出来。

在 HTML 课程里我们反复强调:结构归结构,样式归样式。CSS 的全部工作, 就是用一个又一个「选择器 + 声明」的句子,去描述「谁,应该长成什么样」。 它像裁缝量体:先认出人(选择器),再决定肩宽、袖长、配色(声明)。

三种引入方式

同一段样式可以放在三个地方。效果没有区别,但维护成本相差很远:

方式写法适用场景代价
外部样式表<link rel="stylesheet" href="style.css"> 写在 head 里整站复用、浏览器可缓存多一次请求,但最值得
内部样式表<style> … </style>单页试验、邮件模板无法跨页复用
行内样式style="color: #4b6a5a"脚本动态计算、临时覆盖权重高、难维护

最推荐的是外部样式表。一个文件可以服务整站,改一处颜色,所有页面一起更新:

CSS
/* style.css —— 外部样式表,推荐写进独立文件 */
:root {
  --moss: #6f8f7c;
  --paper: #f8f6f0;
}

body {
  margin: 0;
  font-family: "Noto Sans SC", "PingFang SC", sans-serif;
  font-size: 16px;
  line-height: 1.85;
  color: #2e3833;
  background: var(--paper);
}

h1 {
  font-size: 32px;
  line-height: 1.35;
  letter-spacing: .01em;
}

一条规则由什么组成

CSS 的语法短得可以一口气说完:选择器加上一对花括号, 里面是一条条声明。声明由属性、冒号和值组成,以分号收尾。 最后一条声明的分号可以省略,但最好别省,否则以后追加一行很容易出错。

CSS
/* 选择器:找到谁 */
.card-title {
  /* 声明:属性 + 冒号 + 值 + 分号 */
  font-size: 20px;
  color: #4b6a5a;
  line-height: 1.6;
}

/* 注释用斜杠星号包起来,可以跨行 */
/* 属性名不区分大小写,但约定全部小写 */
  • 选择器:定位元素,如 .card-title、nav a。
  • 声明块:花括号里的全部声明,只作用于被选中的元素。
  • 属性:要改变的特征,如 color、font-size、margin。
  • 值:改成什么样,通常带单位,如 20px、1.6、#4b6a5a。
  • 注释:/* … */,只能写在样式里,不能嵌套。

层叠:多条规则如何决胜

「层叠」是 CSS 名字里的第一个词,也是最容易被误解的词。当多条规则同时命中一个元素, 浏览器会按下面的顺序依次比较,直到分出胜负:

  1. 来源与重要性:浏览器默认样式 < 你的普通样式 < 动画 < !important。
  2. 特异性(权重):ID 比类强,类比标签强,具体算法在第 02 章展开。
  3. 书写顺序:前面都一样时,后写的覆盖先写的。
  4. 继承:元素自己没被选中时,才轮到从父级继承来的值。

现代 CSS 还提供了 @layer,可以显式声明「哪一层优先」, 让大型项目的层叠顺序从隐式约定变成白纸黑字的规则。

继承:有些东西会传下去

继承让样式不必重复书写。body 上设置的字号、字体、颜色, 会像家风一样传给后代;但盒子相关的属性不会,因为每个盒子都该有自己的边界。

  • 会继承:color、font-family、font-size、line-height、letter-spacing、text-align、visibility、cursor。
  • 不继承:margin、padding、border、background、width、height、display。
  • 四个关键字:inherit 强制继承、initial 回到初始值、unset 能继承就继承否则初始、revert 回到浏览器默认。

从 CSSOM 到屏幕

浏览器拿到 CSS 之后,并不是立刻往屏幕上涂颜色,而是走完一条流水线:

  1. 解析 HTML,得到 DOM 树。
  2. 解析 CSS,得到 CSSOM(样式规则树)。
  3. 合并成渲染树,只保留真正会显示的节点,display: none 的不在其中。
  4. 布局(layout / reflow):算出每个盒子的位置与大小。
  5. 绘制(paint):把边框、背景、文字画成像素。
  6. 合成(composite):把图层按顺序拼成最终画面。

这条流水线解释了很多性能问题:改 width 会触发重新布局, 改 color 通常只需要重绘,而改 transform 与 opacity 往往只走合成,所以动画要尽量选后者。

别把样式塞回 HTML

行内 style 看起来快,实际上把结构与表现重新绑在一起。半年后你会在几十个文件里搜索同一个颜色。除非是邮件模板或脚本计算出的动态值,否则请写进样式表,并用类名沟通。

「层叠」不就是后面的覆盖前面的吗?

不是。书写顺序只在「来源、重要性、特异性」都打平的时候才起作用。举例:nav a { color: red } 写在文件最后,也覆盖不了前面的 .menu .link { color: green },因为后者的类选择器权重更高。层叠是一套完整的比较规则,顺序只是最后一票。

02

选择器与优先级

Selectors · 选择器 · 特异性 · 层叠顺序

选择器是 CSS 的手指。它指到谁,样式就落在谁身上。写 CSS 的功力, 一大半体现在「能不能用尽量简单、稳定的选择器,准确指到该指的地方」。

初学时常犯的错,是看到哪里不对就给它加一个 ID 或 !important。 这像用胶带修水管:当下不漏了,下一次改动却更难。理解选择器的分类与权重, 你才能写得少、改得动。

基础选择器

写法名称示例说明
p类型选择器p { }命中所有该标签,范围最广
.card类选择器.card { }可复用,日常最主力
#appID 选择器#app { }整页唯一,权重很高
*通配选择器* { box-sizing: border-box }命中所有元素,慎用
[type="email"]属性选择器input[type="email"] { }按属性精确或模糊匹配
CSS
/* 类型:页面上所有段落 */
p {
  margin-bottom: 1em;
}

/* 类:可复用,最常用 */
.card {
  padding: 20px;
}

/* ID:整页唯一,权重最高 */
#site-header {
  position: sticky;
  top: 0;
}

/* 属性:按特征挑选 */
input[type="email"] {
  border-color: #6f8f7c;
}

a[href^="https"]::after {
  content: " ↗";
}

组合与关系选择器

只用基础选择器,样式会写得很散。关系选择器让你描述结构和上下文: 「导航里的链接」「列表的直接子项」「标题后面紧挨着的段落」。

CSS
/* 后代:nav 里任意深度的 a */
nav a {
  color: #4b6a5a;
}

/* 子代:只有直接子元素 */
.menu > li {
  display: inline-block;
}

/* 相邻兄弟:紧跟在 h2 后面的那一个 p */
h2 + p {
  margin-top: 0;
}

/* 通用兄弟:h2 之后所有同级 p */
h2 ~ p {
  color: #58635d;
}

/* 并集:多个选择器共用一份声明 */
h1, h2, h3 {
  font-family: "Noto Serif SC", serif;
}
一条实用原则

能从结构推出来的关系就别写进选择器。比如 .menu > li 比 .menu li 更精确,但如果你以后给菜单加了下拉层级,前者会「失效」,后者会「误伤」。选择器没有绝对的好坏,只有与结构约定是否匹配。

伪类与伪元素

伪类用一个冒号,描述元素的状态或位置,比如「鼠标悬停时」「第三个孩子」; 伪元素用两个冒号,创造一个原本不存在的部分,比如「第一行」「前面加一个小圆点」。 这个区别值得记牢,写错时浏览器不会报错,只会静静地不生效。

CSS
/* 结构伪类:隔行换色 */
.todo li:nth-child(odd) {
  background: #f7f3ea;
}

/* 状态伪类:还没完成的条目 */
.todo li:not(.done)::before {
  content: "○";
  color: #c58a6f;
  margin-right: 8px;
}

/* 伪元素:已完成打勾 */
.todo li.done::before {
  content: "✓";
  color: #6f8f7c;
}

/* 聚焦时给键盘用户清晰的反馈 */
a:focus-visible {
  outline: 2px solid #6f8f7c;
  outline-offset: 3px;
}

常用的状态伪类还有 :hover、:active、:checked、 :disabled、:empty;结构伪类还有 :first-child、 :last-child、:nth-of-type()、:only-child。 伪元素则常用 ::before、::after、::first-letter、 ::selection、::placeholder、::marker。

:is()、:where() 与 :has()

这三个「函数式伪类」让选择器有了表达能力。:is() 用来合并一组可能的选择器, :where() 与它几乎一样,但权重恒为 0,非常适合写基础重置; :has() 则是父级选择器——根据子元素反向选择父元素。

CSS
/* :is 取参数里最高的权重 */
.article :is(h2, h3) + p {
  color: #2e3833;
}

/* :where 权重恒为 0,适合打底 */
:where(ul, ol) {
  margin: 0;
  padding-left: 0;
}

/* :has 让父级根据子元素变化 */
.card:has(img) {
  padding-top: 0;
}

/* 当 .note 后面还跟着 .note 时,留出间距 */
.note:has(+ .note) {
  margin-bottom: 12px;
}

权重计算表

特异性可以写成一个三元组:(ID 数量, 类/属性/伪类数量, 元素/伪元素数量), 从左到右逐位比较。它不是十进制数字,不要「满十进一」。

来源权重示例
行内样式1000style="color: red"
ID 选择器100#app
类 / 属性 / 伪类10.card、[type="email"]、:hover
元素 / 伪元素1p、::before
通配 / 继承0*、从父级继承来的值
!important最高打破常规层叠,谨慎使用
  • .nav a.active:10 + 1 + 10 = 21,三元组 (0, 2, 1)。
  • #app .card p:100 + 10 + 1 = 111,三元组 (1, 1, 1)。
  • .card:hover:10 + 10 = 20,三元组 (0, 2, 0)。
  • 十一个类选择器 .a.b.c… 的权重仍然小于一个 ID,因为第一位的 0 与 1 已经分出了胜负。
!important 不是快捷键

它会直接跳过整条层叠规则,只留下「谁更 important」。一旦开始用它互相压制,最后会得到一份没人敢改的样式表。合理的用途只有两个:覆盖第三方组件库的内联样式,以及在 prefers-reduced-motion 这类可访问性补丁里强制关闭动画。

动手看看:选择器实验室

下面的预览里,四个元素被不同的选择器命中。试着改一改类名,观察样式如何移动:

Live Preview
CSS
.board {
  display: flex;
  flex-direction: column;
  gap: 10px;
}

.note {
  margin: 0;
  padding: 12px 14px;
  border-radius: 10px;
  background: #f1eee4;
  color: #58635d;
  font-size: 13.5px;
}

/* 第一个孩子换一条暖色边 */
.note:first-child {
  border-left: 3px solid #c58a6f;
}

/* 第二个孩子前面加序号 */
.note:nth-child(2)::before {
  content: "② ";
  color: #6f8f7c;
  font-weight: 600;
}

/* 带 special 的段落单独提亮 */
.note.special {
  background: #e0ece4;
  color: #4b6a5a;
  font-weight: 600;
}

.link {
  align-self: flex-start;
  color: #4b6a5a;
  font-size: 13px;
}

.link::after {
  content: " →";
}
请比较 #main .card 与 .card .title:hover 的权重,谁赢?

#main .card 是 (1, 1, 0),.card .title:hover 是 (0, 3, 0)。逐位比较第一位,1 大于 0,所以前者赢。即使后者加起来「数字更大」,也不能跨位比较——这就是三元组与十进制求和的关键区别。

03

盒模型

Box Model · 内容 · 内边距 · 边框 · 外边距

在 CSS 眼里,页面上几乎所有东西都是一个矩形盒子。理解盒子的四层结构, 以及 width 到底量的是哪一层,是后面所有布局的地基。

很多人第一次被 CSS 打击,是因为写了 width: 100% 再加一点 padding,结果元素撑出父容器、出现横向滚动条。 这不是浏览器的错,只是 width 默认量的不是你以为的那一层。

一个盒子有四层

从里到外依次是:内容区(content)、内边距(padding)、 边框(border)、外边距(margin)。 前三层属于盒子自身,会画背景;外边距是盒子与邻居之间的空气,永远透明。

CSS
.note-card {
  width: 240px;              /* 默认量的是内容区 */
  padding: 16px 20px;        /* 上下 16,左右 20 */
  border: 2px solid #c58a6f;
  margin: 24px;              /* 四边外边距 */
  background: #fffdf9;
}

在默认的 content-box 下,这个盒子实际占用的宽度是 240 + 20 × 2 + 2 × 2 = 284px,再加上左右各 24px 的外边距, 它在页面上占据的水平空间是 332px。高度则由内容撑开,再加同样的 padding 与 border。

box-sizing:让宽度变得可预测

box-sizing: border-box 会把 width 重新定义为「边框以内的总宽」, 内容区自动等于「宽 − 左右 padding − 左右 border」。这时写 width: 100% 再加 padding 也不会溢出,因为 padding 从里面让,而不是从外面长。

CSS
/* 现代项目的标准起手式 */
*,
*::before,
*::after {
  box-sizing: border-box;
}

.a {
  width: 240px;
  padding: 20px;
  border: 2px solid #6f8f7c;   /* 总宽仍是 240px */
}

.b {
  box-sizing: content-box;     /* 回到默认行为 */
  width: 240px;
  padding: 20px;
  border: 2px solid #c58a6f;   /* 总宽 284px */
}
一条几乎无脑的规则

在新项目里,第一行就写 * { box-sizing: border-box }。它会让所有宽度计算符合直觉,也方便百分比布局。少数需要内容撑开的场景,再单独改回 content-box。

外边距折叠:CSS 里少数「反直觉」的规则

在普通文档流中,块级元素的垂直外边距会合并,而不是相加。合并后取两者中较大的值; 如果出现负值,则用最大的正边距加上最小的负边距。水平方向不会折叠。

  1. 相邻兄弟:上面的 margin-bottom 与下面的 margin-top 合并。
  2. 父子:父元素没有 border、padding、内容分隔时,子元素的上边距会「穿透」到父元素外面。
  3. 空盒子:没有内容、没有 border 与 padding 的元素,自己的上下边距也会合并。
CSS
/* 父子折叠:给父级建立 BFC,边距就被关在里面 */
.wrap {
  display: flow-root;
}

/* 相邻折叠:只留一个间距,别让两个 margin 相加 */
.title {
  margin-bottom: 0;
}

.title + .sub {
  margin-top: 8px;
}

/* flex / grid 容器里的子项不会发生外边距折叠 */
.row {
  display: flex;
  gap: 16px;
}

除了 display: flow-root,给父元素加 overflow: hidden、 padding-top 或 border-top 也能阻止折叠。 但 flow-root 是语义最清楚的一种:它只做一件事——建立块级格式化上下文,不附带裁剪效果。

padding 与 border 的细节

  • padding 不能为负;写百分比时,上下左右都按包含块的宽度计算,这一点常被用来做固定比例容器。
  • padding 会撑大背景区域,所以按钮的可点击范围靠它扩展,而不是靠加大字号。
  • border 必须写样式才可见:border: 1px solid #e4dfd3;只写宽度与颜色,边框不会出现。
  • border-radius 可以写一个值、两个值(左上右下 / 右上左下)或用斜杠分别设置水平与垂直半径。
  • 行内元素的上下 padding 会显示,但不会推开行高;需要撑开布局时,把它变成 inline-block。

overflow:盒子装不下内容时

值行为常见用途
visible默认值,内容溢出到盒子外面刻意做出「出框」效果
hidden裁剪溢出部分,且建立 BFC圆角容器裁剪图片
scroll总是显示滚动条需要稳定滚动条占位的区域
auto需要时才出现滚动条最常用的滚动容器
clip裁剪,但不建立滚动容器纯视觉裁剪

做横向滚动的卡片列表时,overflow-x: auto 配合 overscroll-behavior-x: contain 可以避免滚动到尽头时把整页一起带走。 需要给滚动条留位置,可以用 scrollbar-gutter: stable 防止内容左右跳动。

动手看看:content-box 与 border-box

两个盒子写了同样的 width: 160px 与 padding: 18px,只是盒模型不同:

Live Preview
CSS
.row {
  display: flex;
  gap: 18px;
  align-items: flex-start;
  flex-wrap: wrap;
}

.box {
  width: 160px;
  padding: 18px;
  border: 3px solid #6f8f7c;
  background: #e0ece4;
  color: #4b6a5a;
  font-size: 12.5px;
  border-radius: 6px;
}

.content-box {
  box-sizing: content-box;
}

.border-box {
  box-sizing: border-box;
  border-color: #c58a6f;
  background: #f4e4da;
  color: #9c6148;
}

.label {
  display: block;
  font-family: "Cascadia Code", Consolas, monospace;
  font-size: 11px;
  letter-spacing: .04em;
}

.hint {
  flex-basis: 100%;
  margin: 4px 0 0;
  font-size: 12px;
  color: #8a938d;
}
一个 content-box 盒子写了 width: 240px; padding: 20px; border: 2px solid,它的总宽是多少?

240 + 20 × 2 + 2 × 2 = 284px。如果改成 border-box,总宽仍是 240px,内容区则缩小为 240 − 40 − 4 = 196px。这就是为什么加了全局 border-box 之后,布局突然变得好算。

04

颜色、背景与阴影

Color & Surface · 颜色 · 背景 · 渐变 · 阴影

颜色是页面的温度。同样一张卡片,米白底配苔绿字,像一封手写的信; 纯白底配纯黑字,则像一份说明书。CSS 给了你调色的权利,也给了你克制它的工具。

这一章的四件事——颜色、背景、圆角与阴影——构成了界面的「材质」。 它们不改变布局,却决定了页面是冷、是暖、是轻、是重。学会少用一点, 比学会堆叠更多效果更难,也更值得。

颜色的几种写法

写法示例特点
颜色关键字tomato、transparent、currentColor可读性好,但数量有限
十六进制#4b6a5a、#4b6a5a80最常用,末两位可带透明度
rgb / rgbargb(75 106 90 / .65)适合程序计算与调透明度
hslhsl(145 24% 34%)按色相、饱和度、亮度调色,做同色系最方便
CSS
:root {
  --moss: #6f8f7c;
  --moss-soft: rgba(111, 143, 124, .18);
}

.hex { color: #4b6a5a; }          /* 六位十六进制 */
.hex-alpha { color: #4b6a5a80; }  /* 末两位是透明度 */

.rgb { color: rgb(75 106 90); }            /* 新语法用空格分隔 */
.rgba { color: rgb(75 106 90 / .65); }     /* 斜杠后是 alpha */

.hsl { color: hsl(145 24% 34%); }          /* 色相 饱和度 亮度 */

.badge {
  background: hsl(28 45% 92%);
  color: hsl(20 45% 38%);
}

/* 跟随文字颜色,做边框与下划线最方便 */
.ghost {
  color: currentColor;
  border-bottom: 1px solid currentColor;
}

background 属性族

background 不是单个属性,而是一组属性的简写。初学时建议分开写, 等清楚每一层在做什么,再用简写压缩代码。

  • background-color:底色,永远在最底层。
  • background-image:一张图或一层渐变,可以叠加多层,前面的盖住后面的。
  • background-repeat:是否平铺,常用 no-repeat。
  • background-position:定位,如 center、30% 20%。
  • background-size:尺寸,cover 铺满可能裁切,contain 完整但可能留白。
  • background-clip:背景画到哪一层,text 可以做渐变文字。
CSS
.hero {
  background-color: #f1eee4;
  background-image: linear-gradient(135deg, rgba(224, 236, 228, .9), rgba(250, 240, 233, .65));
  background-repeat: no-repeat;
  background-position: center;
  background-size: cover;
}

/* 简写:position 与 size 之间必须用斜杠 */
.banner {
  background: linear-gradient(120deg, #e0ece4, #f8f6f0) center / cover no-repeat;
}

/* 用渐变画一张「纸纹」,不需要任何图片 */
.paper {
  background-image: radial-gradient(rgba(111, 143, 124, .18) 1px, transparent 1px);
  background-size: 18px 18px;
}

渐变:没有图片的光

渐变本质上是一张由浏览器生成的图,因此它可以放在任何接受 background-image 的地方。 线性渐变沿一条线过渡,径向渐变从一个中心散开,锥形渐变绕中心旋转。 给颜色加「硬停止」(两个色标写同一个位置)可以画出清晰的色带。

CSS
.sunrise {
  background: linear-gradient(120deg, #f5ead4, #f4e4da 45%, #e0ece4);
}

.glow {
  background: radial-gradient(circle at 30% 20%, #fffdf9, #e0ece4 60%, #cfe3d6);
}

.dial {
  background: conic-gradient(from 210deg, #6f8f7c, #c3a061, #c58a6f, #6f8f7c);
}

/* 硬停止:0 8px 是实色,8px 16px 是纸色,于是得到条纹 */
.stripes {
  background-image: repeating-linear-gradient(45deg, #e0ece4 0 8px, #f8f6f0 8px 16px);
}
渐变的脾气

两种色相相差太远时,中间会经过一段发灰的过渡。想让渐变干净,尽量选同一色相、只改亮度与饱和度;或者让中间色标偏向其中一端。渐变文字记得准备一个纯色 color 作为兜底。

圆角、阴影与滤镜

border-radius 把直角磨圆;box-shadow 给盒子一层光或一层重量; filter 则像给元素加了一片镜头。三者都只影响绘制,不改变布局位置。

CSS
.card {
  border-radius: 18px;
  box-shadow: 0 18px 40px -28px rgba(46, 56, 51, .55);
  filter: saturate(.92) contrast(1.02);
}

/* 只给下面两个角留圆角 */
.sheet {
  border-radius: 0 0 16px 16px;
}

/* 多层阴影叠出一圈描边 */
.avatar {
  border-radius: 50%;
  box-shadow: 0 0 0 4px #fffdf9, 0 0 0 5px #e4dfd3;
}

/* 毛玻璃:半透明底 + 背景模糊 */
.glass {
  background: rgba(255, 253, 249, .7);
  backdrop-filter: blur(12px);
}
box-shadow 的值含义
0 18px水平偏移 0,垂直偏移 18px,正值向下
40px模糊半径,越大越柔
-28px扩散半径,负值让阴影收缩
rgba(46, 56, 51, .55)阴影颜色,通常用带透明度的深色
inset可选,写在最后,表示内阴影

常用的滤镜有 blur()、brightness()、contrast()、 saturate()、grayscale()、sepia() 和 drop-shadow()。 其中 drop-shadow() 会沿着不透明轮廓投影,做不规则图形(比如 SVG 图标)时比 box-shadow 更自然。

先检查对比度

浅灰字配米白底很文艺,但正文对比度低于 4.5:1 时,很多人在阳光下根本读不清。装饰性文字可以淡,正文请保持足够深。浏览器开发者工具里可以直接查看对比度数值。

动手看看:一张有温度的卡片

预览里的卡片只用了渐变、圆角、一层阴影和一点点滤镜,没有引用任何图片:

Live Preview
CSS
.poster {
  max-width: 380px;
  margin: 0 auto;
  padding: 30px 28px;
  border-radius: 22px;
  background:
    radial-gradient(circle at 88% 8%, rgba(255, 253, 249, .9), transparent 42%),
    linear-gradient(135deg, #f5ead4, #f4e4da 48%, #e0ece4);
  border: 1px solid rgba(228, 223, 211, .8);
  box-shadow: 0 26px 50px -34px rgba(46, 56, 51, .55);
  filter: saturate(.96);
}

.eyebrow {
  display: block;
  font-size: 10px;
  letter-spacing: .24em;
  text-transform: uppercase;
  color: #7c8781;
  margin-bottom: 10px;
}

.poster h4 {
  margin: 0 0 10px;
  font-family: "Songti SC", "SimSun", serif;
  font-size: 25px;
  line-height: 1.4;
  color: #2e3833;
}

.poster p {
  margin: 0 0 18px;
  font-size: 13.5px;
  line-height: 1.95;
  color: #5a655f;
}

.pill {
  display: inline-block;
  padding: 4px 13px;
  border-radius: 999px;
  background: rgba(255, 253, 249, .7);
  border: 1px solid rgba(228, 223, 211, .9);
  font-size: 11.5px;
  color: #6f8f7c;
}
opacity: .5 与 background: rgb(0 0 0 / .5) 有什么区别?

opacity 作用于整个元素及其所有子元素,文字、边框、图片会一起变透明,而且会创建层叠上下文;rgba 只让这一层颜色透明,文字仍然清晰。做半透明背景时,优先用带 alpha 的颜色。

05

字体与文本排版

Typography · 字体栈 · 行高 · 中文排版

网页的主要内容仍然是文字。字体、字号、行高、字距与对齐方式, 决定了读者是「愿意读下去」,还是「扫一眼就走」。

排版没有神秘公式,它更像调音:正文行高松一点,标题收紧一点, 中英文之间留一点气口。所有这些微小的差异,最后会变成一种说不清但感受得到的舒适。

字体栈:给浏览器一条退路

font-family 可以写一串字体,浏览器从左到右找,找到第一个可用的就停。 最后一定要放一个通用族名(serif、sans-serif、monospace)兜底。

CSS
body {
  font-family: "Noto Sans SC", "PingFang SC", "Microsoft YaHei", sans-serif;
}

/* 标题用衬线体,气质会安静下来 */
.quote {
  font-family: "Noto Serif SC", "Songti SC", "SimSun", Georgia, serif;
}

/* 等宽字体让数字与代码对齐 */
code, pre {
  font-family: "JetBrains Mono", "Cascadia Code", Consolas, monospace;
}

字体名里有空格时必须加引号。中文界面常见的组合是「思源黑体 / 苹方 / 微软雅黑」, 它们在 macOS、Windows 与 Android 上各自可用,视觉差异不会太突兀。

@font-face:把字体带在身边

想用一款特定字体,可以用 @font-face 引入。优先使用 woff2, 它压缩率最好;中文全字库动辄数 MB,正式项目通常只保留用到的字,或使用分片加载。

CSS
@font-face {
  font-family: "Qinghe Serif";
  src: url("fonts/qinghe-serif.woff2") format("woff2");
  font-weight: 400;
  font-style: normal;
  font-display: swap;      /* 先显示系统字体,字体到了再替换 */
}

h1 {
  font-family: "Qinghe Serif", "Songti SC", serif;
  font-weight: 400;
}
  • font-display: swap 避免文字长时间空白,代价是可能出现一次字体跳动。
  • font-display: optional 更激进:网络慢时直接用系统字体,本次不再替换。
  • 使用 unicode-range 可以把一个字体拆成多个分片,按需加载。
  • 字体文件放本地,既稳定也避免第三方请求;同时注意授权许可。

字号、行高与字距

正文字号通常 16px 起步,行高在 1.6 到 2.0 之间。中文的方块字比拉丁字母更「满」, 行高偏紧会显得密不透风;标题则可以收紧到 1.25 左右,让几行字更像一个整体。

CSS
body {
  font-size: 16px;
  line-height: 1.85;
}

h1 {
  font-size: clamp(30px, 4vw + 1rem, 48px);
  line-height: 1.3;
  letter-spacing: .01em;
}

.lead {
  font-size: 1.0625rem;
  line-height: 2;
}

.eyebrow {
  font-size: .75rem;
  letter-spacing: .26em;
  text-transform: uppercase;
}

p { text-wrap: pretty; }   /* 避免最后一行只剩一两个字 */
h2 { text-wrap: balance; } /* 让多行标题长度更均衡 */

行高写无单位数字(如 1.85)时,子元素会继承这个倍数, 再按自己的字号计算;写 30px 则会继承一个固定值,子元素字号一变就可能挤在一起。 所以正文行高优先用倍数。

对齐、缩进与断行

  • text-align:left 最易读,center 适合短标题,right 常用于数字列。
  • text-indent: 2em:首行缩进两个汉字,中文长文的传统做法。
  • white-space:nowrap 禁止换行,pre-wrap 保留空格与换行。
  • overflow-wrap: anywhere:长链接或英文单词撑破容器时的救命绳。
  • hyphens: auto:英文自动断词,需要配合 lang 属性才可靠。

文本溢出:一行与多行

卡片标题只允许一行、摘要只允许两行,是很常见的需求。单行用 text-overflow: ellipsis,多行用 -webkit-line-clamp。 两者都必须配合 overflow: hidden 才生效。

CSS
.single-line {
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
}

.clamp-2 {
  display: -webkit-box;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 2;
  overflow: hidden;
}

/* 长单词与网址不再撑破卡片 */
.break-word {
  overflow-wrap: anywhere;
}
中文排版的几个小习惯

正文左对齐,别轻易两端对齐;行高至少 1.7;标题与正文之间留出比段间距更大的空白;中英文与数字之间手动加一个空格(或等待 text-autospace 普及);引号用中文全角「」,省略号用「……」。这些细节不会被人夸,但会被人感觉到。

动手看看:一张排版练习

下面这段文字用了衬线标题、首字下沉、较松的行高与克制的字距:

Live Preview
CSS
.essay {
  max-width: 430px;
  margin: 0 auto;
  padding: 26px 28px;
  background: #fffdf9;
  border: 1px solid #e4dfd3;
  border-radius: 16px;
}

.eyebrow {
  margin: 0 0 12px;
  font-size: 10px;
  letter-spacing: .28em;
  color: #8a938d;
  text-transform: uppercase;
}

.essay h4 {
  margin: 0 0 16px;
  font-family: "Songti SC", "SimSun", serif;
  font-size: 26px;
  font-weight: 600;
  letter-spacing: .04em;
  line-height: 1.4;
  color: #2e3833;
}

.essay p {
  margin: 0 0 12px;
  font-size: 14px;
  line-height: 2;
  color: #4f5a54;
  text-align: left;
}

.essay .drop::first-letter {
  float: left;
  font-family: "Songti SC", "SimSun", serif;
  font-size: 44px;
  line-height: .9;
  padding: 2px 8px 0 0;
  color: #6f8f7c;
}

.essay .quote {
  margin: 16px 0 0;
  font-size: 12px;
  color: #8a938d;
  letter-spacing: .1em;
  text-align: right;
}
为什么正文推荐 line-height: 1.8,而不是 line-height: 29px?

无单位倍数会被子元素继承并在各自的字号上重新计算,29px 则是固定值直接继承。若子元素字号是 32px,固定 29px 的行高会让文字挤在一起;而 1.8 会自动变成 57.6px。标题与正文混排时,这个差别非常明显。

06

Flexbox 弹性布局

Flexbox · 一维布局的温柔解法

在 Flexbox 出现之前,前端用 float、inline-block 和负边距 拼凑布局,每一种都带着补丁的味道。Flexbox 换了一种思路: 让容器来决定,里面的项目如何分配空间、如何对齐。

它适合一维排布——一行,或一列。导航栏、按钮组、卡片列表、 垂直居中,这些日常问题用 Flexbox 往往两三行就能解决。

两根轴:主轴与交叉轴

给容器加上 display: flex 之后,容器里就出现了一根主轴 和一根与它垂直的交叉轴。主轴的方向由 flex-direction 决定: row 是水平,column 是垂直。 后面所有对齐属性,都是相对这两根轴说话的。

CSS
.gallery {
  display: flex;
  flex-direction: row;             /* 主轴:水平方向 */
  justify-content: space-between;  /* 沿主轴分配空间 */
  align-items: center;             /* 沿交叉轴对齐 */
  flex-wrap: wrap;                 /* 一行放不下就换行 */
  gap: 12px;                       /* 项目之间的间距 */
}

记住一句话:justify-content 管主轴,align-items 管交叉轴。 当 flex-direction 换成 column,这两个属性的视觉方向也随之交换。

容器属性

属性常用值作用
flex-directionrow / column / 加 -reverse决定主轴方向
flex-wrapnowrap / wrap是否换行
justify-contentflex-start / center / space-between / space-around / space-evenly主轴上的分布
align-itemsstretch / center / flex-start / baseline单行项目在交叉轴上的对齐
align-contentflex-start / center / space-between多行之间的分布,需要先换行
gap12px / 16px 8px项目间距,不产生外边距折叠
CSS
.nav {
  display: flex;
  align-items: center;
  gap: 8px;
}

/* 左边 logo,右边导航与按钮:一个 auto 就够了 */
.nav .logo {
  margin-right: auto;
}

.nav a {
  padding: 8px 14px;
  border-radius: 999px;
}

/* 主轴换成纵向后,justify-content 控制上下分布 */
.stack {
  display: flex;
  flex-direction: column;
  justify-content: center;
  min-height: 240px;
}

项目属性与 flex 简写

容器负责「怎么排」,项目负责「我占多少」。三个属性分别是 flex-grow(有剩余空间时怎么长)、flex-shrink(空间不够时怎么缩)、 flex-basis(初始占多大)。日常写 flex 简写即可。

CSS
.row {
  display: flex;
  gap: 16px;
  align-items: stretch;   /* 默认值,卡片自动等高 */
}

.row .card {
  flex: 1 1 220px;        /* grow | shrink | basis */
  min-width: 0;           /* 允许内部文字收缩,避免撑破 */
}

.row .wide {
  flex: 2 1 320px;
}

/* 三种常见简写 */
.fixed { flex: none; }   /* 0 0 auto,不伸不缩 */
.auto  { flex: auto; }   /* 1 1 auto */
.equal { flex: 1; }      /* 1 1 0%,等分剩余空间 */
  • flex: 1 里的 1 只写了 grow,shrink 默认 1,basis 默认 0%,所以是「等分」。
  • flex-basis: auto 会先看元素的 width;0% 则忽略内容宽度,完全按比例分。
  • 子项里如果有长文本,记得加 min-width: 0,否则它的最小内容宽度会把布局撑开。
  • 想让某个项目单独对齐,用 align-self;想改变顺序,用 order,但别滥用,它会打乱键盘阅读顺序。

几个常用配方

  • 水平垂直居中:容器 display: flex + justify-content: center + align-items: center。
  • 两端对齐的导航:justify-content: space-between,或给左侧项目 margin-right: auto。
  • 等高卡片:align-items: stretch(默认),子项 flex: 1,内容用 margin-top: auto 推到底部。
  • 可换行的标签云:flex-wrap: wrap + gap: 8px,比计算宽度可靠得多。
  • 页脚吸底:整页 display: flex; flex-direction: column; min-height: 100vh,主内容 flex: 1。
Flexbox 的心智模型

先确定主轴,再想「剩余空间怎么分」。如果项目没有按预期伸缩,检查三件事:容器有没有设宽高、项目有没有 min-width 或固定 width、flex-basis 是不是被内容撑住了。

动手看看:导航与等高卡片

下面的预览用 Flexbox 同时完成了导航两端对齐、按钮靠右与三张卡片等高:

Live Preview
CSS
.bar {
  display: flex;
  align-items: center;
  gap: 10px;
  padding: 12px 16px;
  background: #fffdf9;
  border: 1px solid #e4dfd3;
  border-radius: 14px;
}

.logo {
  font-family: "Songti SC", "SimSun", serif;
  font-size: 17px;
  letter-spacing: .08em;
  color: #4b6a5a;
}

.links {
  display: flex;
  gap: 4px;
  margin-left: auto;
}

.links a {
  padding: 5px 10px;
  border-radius: 999px;
  font-size: 12px;
  color: #58635d;
  text-decoration: none;
}

.links a:hover {
  background: #e0ece4;
  color: #4b6a5a;
}

.cta {
  border: 0;
  padding: 7px 15px;
  border-radius: 999px;
  background: #4b6a5a;
  color: #fbf9f3;
  font-size: 12px;
  cursor: pointer;
}

.cards {
  display: flex;
  gap: 12px;
  align-items: stretch;
  margin-top: 14px;
}

.card {
  flex: 1 1 0;
  min-width: 0;
  padding: 16px;
  border: 1px solid #e4dfd3;
  border-radius: 12px;
  background: #f8f6f0;
  display: flex;
  flex-direction: column;
}

.card h4 {
  margin: 0 0 6px;
  font-size: 14px;
  color: #2e3833;
}

.card p {
  margin: 0 0 12px;
  font-size: 12px;
  line-height: 1.8;
  color: #8a938d;
}

.card span {
  margin-top: auto;
  font-size: 11px;
  color: #6f8f7c;
}
flex: 1 完整写出来是什么?它和 flex: auto 有什么不同?

flex: 1 等于 flex: 1 1 0%,项目从 0 开始等分剩余空间,内容宽度不参与初始分配;flex: auto 等于 1 1 auto,会先把内容宽度作为基准,再把剩余空间按比例分。前者更容易得到严格等宽,后者更尊重内容。

07

Grid 网格布局

Grid · 二维布局的秩序感

如果 Flexbox 是「把东西排成一行」,Grid 就是「先在纸上画好格子,再把东西放进去」。 它同时处理行与列,适合整页布局、卡片墙、图集这类需要二维秩序的场景。

很多人第一次用 Grid 会被 fr、minmax()、 auto-fit 这些词吓到。其实只要理解一句话: Grid 先定义轨道,再决定项目占几条轨道、如何对齐。

定义网格

grid-template-columns 与 grid-template-rows 用空格分隔每个轨道的尺寸。除了固定像素,还可以用 fr(剩余空间的份数) 与 minmax()(最小到最大的范围)。

CSS
.layout {
  display: grid;
  grid-template-columns: 200px minmax(0, 1fr) 200px;
  grid-template-rows: auto 1fr auto;
  gap: 16px 20px;   /* 行间距 16,列间距 20 */
}

/* 1fr 表示剩余空间的一份;minmax(0, 1fr) 防止内容撑破 */
.side {
  grid-column: 1;
  grid-row: 1 / 3;   /* 从第 1 条线跨到第 3 条线 */
}

.main {
  grid-column: 2 / 4;
}

注意 1fr 的默认最小尺寸是 auto,长单词或长表格可能把它撑破。 写 minmax(0, 1fr) 才能得到真正可收缩的列,这一点在嵌套 Grid 时尤其重要。

repeat、auto-fit 与 minmax

重复的轨道用 repeat() 简化。配合 auto-fit 与 minmax(180px, 1fr),可以得到一个「不用写媒体查询也会自动换列」的卡片墙: 容器宽就多排几列,窄就少排几列,每列最小 180px。

CSS
.auto-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
  gap: 16px;
}

.fixed-grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 16px;
}

/* 图集:第一张占两列 */
.gallery {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
  gap: 10px;
}

.gallery .wide {
  grid-column: span 2;
}
  • auto-fit:先尽量多放轨道,再把空轨道「折叠」,剩下的项目拉伸填满。
  • auto-fill:也尽量多放轨道,但空轨道保留占位,项目不会被拉伸。
  • minmax(180px, 1fr):每列至少 180px,有剩余就平分。
  • gap 不会在容器边缘产生间距,比给项目写 margin 干净。

命名区域:让布局自己说话

grid-template-areas 用一张「字符画」描述页面结构, 每个名字对应一块区域。它最大的好处是可读性——半年后回来看,仍然一眼能懂。

CSS
.page {
  display: grid;
  grid-template-columns: 220px 1fr;
  grid-template-rows: 64px 1fr auto;
  grid-template-areas:
    "header header"
    "sidebar main"
    "footer footer";
  min-height: 100vh;
  gap: 1px;
}

.page-header { grid-area: header; }
.page-side   { grid-area: sidebar; }
.page-main   { grid-area: main; }
.page-footer { grid-area: footer; }

/* 小屏时把字符画重新排一遍 */
@media (max-width: 720px) {
  .page {
    grid-template-columns: 1fr;
    grid-template-areas:
      "header"
      "main"
      "sidebar"
      "footer";
  }
}

对齐与间距

Grid 有两套对齐:justify-* 管列方向(水平),align-* 管行方向(垂直)。 在容器上写 justify-items / align-items 影响所有项目; 在项目上写 justify-self / align-self 只影响自己。 两个方向同时设置时,可以用 place-items 与 place-content 简写。

  • place-items: center:每个项目在自己的格子里居中,做图标墙很方便。
  • place-content: center:整个网格在容器里居中,适合内容比容器小的场景。
  • justify-content: space-between:轨道之间拉开距离,但项目本身不变形。
  • gap: 16px 24px:先行后列,和 margin 的四值顺序不同,别记混。

Grid 还是 Flex?

维度GridFlexbox
方向二维,同时控制行与列一维,一行或一列
思路先画布局,再放内容由内容决定如何排列
适合整页骨架、卡片墙、图集、表单栅格导航、按钮组、居中、等高卡片
典型语句grid-template-columns: repeat(3, 1fr)display: flex; gap: 12px

实际项目里两者经常嵌套:页面外层用 Grid 划分区域,某个区域内部用 Flexbox 排列按钮。 不要为了「统一」强行二选一,选那个让代码更短的。

别让 1fr 骗了你

1fr 的实际最小值是 auto,遇到长英文单词、pre 代码块或横向表格时,列会被内容顶宽,甚至撑出容器。需要严格收缩时写 minmax(0, 1fr);给子项加 min-width: 0 也有效。

动手看看:自适应图集

拖动浏览器窗口改变宽度,列数会自动增减。整个图集没有写一行媒体查询:

Live Preview
CSS
.gallery {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(110px, 1fr));
  grid-auto-rows: 74px;
  gap: 10px;
}

.tile {
  display: grid;
  place-items: center;
  border-radius: 12px;
  background: #e0ece4;
  color: #4b6a5a;
  font-family: "Cascadia Code", Consolas, monospace;
  font-size: 12px;
  letter-spacing: .1em;
  border: 1px solid rgba(111, 143, 124, .18);
}

.tile:nth-child(2n) {
  background: #f4e4da;
  color: #9c6148;
  border-color: rgba(197, 138, 111, .22);
}

.tile:nth-child(3n) {
  background: #f5ead4;
  color: #8f6f33;
  border-color: rgba(195, 160, 97, .22);
}

/* 宽图占两列、两行 */
.tile.wide {
  grid-column: span 2;
  grid-row: span 2;
}
auto-fit 与 auto-fill 在项目很少时有什么可见差别?

auto-fit 会把空轨道折叠,剩下的项目被拉伸,每张卡片变宽;auto-fill 保留空轨道,项目维持原始宽度,右侧留下空白。项目数量足够填满一行时,两者看起来一样。

08

定位与层叠

Position & Stacking · 定位 · 包含块 · 层叠上下文

前面几章的布局都在回答「元素放在哪一行、哪一列」。定位回答的是另一个问题: 「让它脱离原来的位置,精确地贴到某个地方」。角标、弹层、吸顶导航、抽屉, 都靠这一章的知识。

定位不难,难的是「相对谁定位」和「谁盖住谁」。前者叫包含块,后者叫层叠上下文。 把这两个概念弄清楚,z-index: 9999 却依然被盖住的怪事就不会再发生了。

position 的五个值

值参照物是否占位常见用途
static正常文档流占位默认值,偏移属性无效
relative自己原来的位置占位微调位置、给子元素当定位参照
absolute最近的已定位祖先不占位角标、下拉菜单、装饰图形
fixed视口(或被变换的祖先)不占位回到顶部、固定侧栏、遮罩
sticky最近的滚动容器占位吸顶标题、表头、目录
CSS
.ticket {
  position: relative;   /* 自己不动,但成为子元素的参照 */
  padding: 18px 20px;
  border: 1px solid #e4dfd3;
  border-radius: 12px;
  background: #fffdf9;
}

.badge {
  position: absolute;
  top: -9px;
  right: 14px;
  padding: 3px 10px;
  border-radius: 999px;
  background: #c58a6f;
  color: #fffdf9;
  font-size: 11px;
  letter-spacing: .08em;
}

relative 最常被用作「定位锚点」:它自己几乎不移动, 却让内部的 absolute 有了参照。如果祖先都没有定位, absolute 会一路向上,最终相对初始包含块定位—— 它的大小等于视口,但会随着文档一起滚动,所以看起来常常「跑偏」。

包含块与 inset

绝对定位元素的包含块,是最近一个 position 不为 static 的祖先的 内边距盒。固定定位通常以视口为包含块,但只要祖先有 transform、filter、perspective 或 will-change,那个祖先就会「截胡」,成为新的包含块。 这也是很多固定弹层在动画容器里错位的原因。

CSS
.cover {
  position: relative;
  overflow: hidden;
  border-radius: 16px;
}

/* 用 inset: 0 让遮罩铺满父级 */
.cover::before {
  content: "";
  position: absolute;
  inset: 0;
  background: linear-gradient(180deg, transparent, rgba(38, 50, 44, .55));
  pointer-events: none;
}

/* 居中一把:绝对定位 + 自动外边距 */
.dialog {
  position: fixed;
  inset: 0;
  width: min(92vw, 420px);
  height: max-content;
  margin: auto;
  z-index: 100;
}

inset 是 top、right、bottom、left 的简写。给绝对定位元素同时设置 inset: 0 与 margin: auto, 再配上固定宽高,就能得到一个水平垂直居中的弹窗,比计算 50% 与负边距更省心。

z-index 与层叠上下文

z-index 只对已定位元素或 flex / grid 项目生效。 它的数值不是全局的,而是在同一个层叠上下文里比较。 一个元素一旦创建了新的层叠上下文,它的子元素无论 z-index 多大, 都只能在这个「小世界」里排序,无法越过父级的层级。

  • 根元素 html 本身就是最外层的层叠上下文。
  • position 为 relative / absolute / fixed / sticky 且 z-index 不为 auto。
  • opacity 小于 1、transform、filter、backdrop-filter、perspective 不为 none。
  • isolation: isolate、mix-blend-mode 不为 normal、contain: paint。
  • flex / grid 的子项且 z-index 不为 auto。
CSS
/* 吸顶导航:要盖住正文,但不能盖住弹窗 */
.topbar {
  position: sticky;
  top: 0;
  z-index: 60;
}

/* 弹窗:独立的层叠上下文,内部再排也不影响外面 */
.modal {
  position: fixed;
  inset: 0;
  z-index: 100;
  isolation: isolate;
  background: rgba(46, 56, 51, .35);
}

/* 抽屉:默认藏在右侧,打开时滑入 */
.drawer {
  position: fixed;
  top: 0;
  right: 0;
  bottom: 0;
  width: 280px;
  z-index: 90;
  transform: translateX(100%);
  transition: transform .3s ease;
}

.drawer.open {
  transform: translateX(0);
}
z-index 失效的三个原因

1. 元素没有定位(或不是 flex / grid 项目),z-index 根本不会生效;
2. 某个祖先创建了层叠上下文,你的 9999 只在祖先的小世界里有效;
3. 同层里另一个元素在 DOM 中更靠后,且 z-index 相同——后出现的盖住先出现的。

常见案例的思路

  • 角标:父级 relative,角标 absolute,用 top 与 right 贴边。
  • 吸顶:position: sticky; top: 0,注意祖先不能有 overflow: hidden,否则会失去吸附效果。
  • 弹层:遮罩 fixed; inset: 0,内容居中;打开时给 body 加 overflow: hidden 锁住滚动。
  • 下拉菜单:外层 relative,菜单 absolute; top: 100%,再加一点 padding-top 作为鼠标移动的缓冲带。

动手看看:角标与吸顶

上面的卡片用绝对定位放角标,下面的区域用粘性定位做吸顶条。滚动下半部分试试:

Live Preview
CSS
.stage {
  display: grid;
  gap: 14px;
}

.ticket {
  position: relative;
  padding: 16px 18px;
  border: 1px solid #e4dfd3;
  border-radius: 12px;
  background: #fffdf9;
}

.badge {
  position: absolute;
  top: -8px;
  right: 12px;
  padding: 3px 9px;
  border-radius: 999px;
  background: #c58a6f;
  color: #fffdf9;
  font-size: 10px;
  letter-spacing: .1em;
}

.ticket h4 {
  margin: 0 0 4px;
  font-size: 14px;
  color: #2e3833;
}

.ticket p {
  margin: 0;
  font-size: 12px;
  color: #8a938d;
}

.scroller {
  height: 132px;
  overflow-y: auto;
  border: 1px solid #e4dfd3;
  border-radius: 12px;
  background: #f8f6f0;
}

.sticky-bar {
  position: sticky;
  top: 0;
  z-index: 2;
  padding: 8px 12px;
  background: #e0ece4;
  color: #4b6a5a;
  font-size: 11.5px;
  letter-spacing: .06em;
}

.scroller p {
  margin: 0;
  padding: 9px 12px;
  font-size: 12px;
  color: #58635d;
  border-bottom: 1px dashed #e4dfd3;
}
父元素有 transform: translateY(0),子元素的 position: fixed 还会相对视口固定吗?

不会。transform 不为 none 的祖先会成为固定定位元素的新包含块,于是子元素相对这个祖先固定,而不是相对视口。滚动页面时,它会跟着祖先一起走,看起来就像「fixed 失效了」。filter、perspective 也有同样的效果。

09

过渡、变换与动画

Motion · 过渡 · 变换 · 关键帧

好的动效不是「会动」,而是「动得合理」。它告诉用户「这里发生了变化」, 给操作一个回应,或者只是让页面呼吸一下。CSS 提供了三层工具: 过渡、变换与关键帧动画。

动效最难的部分不是写属性,而是克制。150 到 300 毫秒通常足够; 入场用缓出,离场用缓入;能不动的就不动。尤其要尊重那些 在系统里打开了「减少动态效果」的人。

transition:从一个状态平滑到另一个

过渡本身不产生动画,它只是规定「当某个属性变化时,用多久、以什么节奏完成」。 所以它一定要有触发条件,最常见的是 :hover、:focus、 :checked,或由 JavaScript 增删的类名。

CSS
.btn {
  background: #4b6a5a;
  color: #fbf9f3;
  transform: translateY(0);
  transition:
    background-color .25s ease,
    transform .25s ease;
}

.btn:hover {
  background: #405d4e;
  transform: translateY(-2px);
}

/* 给键盘用户同样的反馈 */
.btn:focus-visible {
  outline: 2px solid #6f8f7c;
  outline-offset: 3px;
}
  • 四个子属性:transition-property、duration、timing-function、delay。
  • 只有可插值的属性才能平滑过渡,display 从 none 到 block 不会渐变。
  • 不要写 transition: all,它会把布局属性也一起监听,既慢又容易产生意外。
  • 过渡写在基础状态上,鼠标移出时才有回程动画;只写在 :hover 里,移出会瞬间复位。

transform:不影响布局的形变

transform 可以平移、缩放、旋转、倾斜。它最大的特点是 不改变文档流:元素在布局里仍占原来的位置,只是绘制时被变换了。 因此它非常适合做动画,不会引起周围元素重排。

CSS
.photo {
  overflow: hidden;
  border-radius: 16px;
}

.photo img {
  display: block;
  width: 100%;
  transform: scale(1.02) rotate(-.4deg);
  transform-origin: center;
  transition: transform .5s cubic-bezier(.2, .7, .2, 1);
}

.photo:hover img {
  transform: scale(1.08) rotate(0deg);
}

/* 位移百分比相对元素自身尺寸 */
.tip {
  transform: translate(-50%, -100%);
}

/* 3D 需要给父级 perspective */
.scene {
  perspective: 800px;
}

.card-3d:hover {
  transform: rotateY(12deg) translateZ(20px);
}

多个变换函数按从右到左的顺序作用于元素,所以 translate() rotate() 与 rotate() translate() 的结果不同。 transform-origin 决定围绕哪个点变换,默认是元素中心。 另外,任何非 none 的 transform 都会创建层叠上下文与包含块。

@keyframes 与 animation

过渡需要状态变化来触发;关键帧动画则可以自己播放,还能循环、往返、停在最后一帧。 用 @keyframes 定义时间轴,再用 animation 把它挂到元素上。

CSS
@keyframes float {
  0%, 100% {
    transform: translateY(0);
    opacity: .85;
  }
  50% {
    transform: translateY(-10px);
    opacity: 1;
  }
}

.leaf {
  animation: float 6s ease-in-out infinite;
}

/* 多个动画用逗号分隔 */
.orb {
  animation:
    float 5s ease-in-out infinite,
    glow 3s ease-in-out infinite alternate;
}

@keyframes glow {
  from { box-shadow: 0 0 0 0 rgba(111, 143, 124, .35); }
  to   { box-shadow: 0 0 0 12px rgba(111, 143, 124, 0); }
}
子属性作用常用值
animation-name使用哪个关键帧float
animation-duration一次播放多久6s、300ms
animation-timing-function节奏曲线ease-in-out、cubic-bezier()、steps(4)
animation-delay延迟多久开始.2s、负值可从中途开始
animation-iteration-count播放次数1、infinite
animation-direction方向normal、reverse、alternate
animation-fill-mode播放前后保留哪一帧both、forwards、backwards
animation-play-state播放或暂停running、paused

性能与可访问性

浏览器最擅长动画两个属性:transform 与 opacity, 因为它们可以在合成线程上完成,不必重新布局或重绘。反之,动画 width、height、top、left、 margin 会不断触发布局,帧率很容易掉下去。

CSS
/* 尊重系统的「减少动态效果」设置 */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: .001ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: .001ms !important;
    scroll-behavior: auto !important;
  }
}

/* will-change 只在真正需要时短暂使用 */
.drawer {
  will-change: transform;
}

.drawer.idle {
  will-change: auto;
}
动效的三个数字

微交互 150–250ms,页面级过渡 250–350ms,循环的环境动画可以更慢但幅度要小。ease-out 适合元素入场(快进慢出),ease-in 适合离场,ease-in-out 适合来回循环。超过 500ms 的等待,用户会开始怀疑页面卡住了。

动手看看:一段会呼吸的动画

预览里的光点、横线与文字都只用 transform 与 opacity:

Live Preview
CSS
.motion-stage {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 18px;
  padding: 26px 20px;
}

.orb {
  width: 54px;
  height: 54px;
  border-radius: 50%;
  background: radial-gradient(circle at 32% 28%, #fffdf9, #a9c9b6 60%, #6f8f7c);
  animation: breathe 3.2s ease-in-out infinite;
}

@keyframes breathe {
  0%, 100% { transform: scale(1); opacity: .8; }
  50%      { transform: scale(1.14); opacity: 1; }
}

.line {
  position: relative;
  width: 190px;
  height: 3px;
  border-radius: 999px;
  background: #e4dfd3;
  overflow: hidden;
}

.line i {
  position: absolute;
  inset: 0;
  width: 42%;
  border-radius: inherit;
  background: linear-gradient(90deg, #6f8f7c, #c3a061);
  animation: slide 2.6s ease-in-out infinite alternate;
}

@keyframes slide {
  from { transform: translateX(0); }
  to   { transform: translateX(138%); }
}

.caption {
  margin: 0;
  font-size: 12px;
  letter-spacing: .08em;
  color: #8a938d;
  animation: fade 3.2s ease-in-out infinite;
}

@keyframes fade {
  0%, 100% { opacity: .45; }
  50%      { opacity: 1; }
}
为什么位移动画推荐 transform: translateX(),而不是改 left?

left 参与布局计算,每一帧变化都可能触发重新布局与重绘;transform 只改变绘制阶段的位置,通常可以在合成线程上完成,帧率更稳。此外 left 需要元素先定位,而 transform 对任何元素都有效。

10

响应式与自定义属性

Responsive & Variables · 断点 · 相对单位 · 自定义属性

页面会被手机、平板、笔记本和一块很宽的显示器同时打开。响应式不是「为每种设备写一套」, 而是让同一套结构在不同宽度下都能自然地呼吸。

这一章还会讲到 CSS 变量。它让颜色、间距、圆角这些反复出现的值有了名字, 改一次就能全站生效,也让「换主题」从体力活变成几行代码。

视口与移动优先

第一步永远是 <meta name="viewport" content="width=device-width, initial-scale=1.0">。 没有它,手机浏览器会假装自己有 980px 宽,再把页面缩小,媒体查询就会全部算错。

「移动优先」的意思是:基础样式先写给窄屏,再用 min-width 逐步为大屏增加细节。这样默认样式最简单,增强是叠加的,不容易互相覆盖。

CSS
/* 基础:窄屏,单列 */
.card {
  padding: 16px;
  border-radius: 12px;
}

/* 平板:两列 */
@media (min-width: 720px) {
  .card {
    padding: 24px;
    border-radius: 16px;
  }
}

/* 桌面:三列,内容更宽 */
@media (min-width: 1080px) {
  .card {
    padding: 32px;
  }
}

断点不要照抄「iPhone 多少像素」。设备太多,永远抄不完。更可靠的做法是 把浏览器窗口慢慢拉窄,在布局开始显得拥挤、文字行长超过约 75 个字符、 或卡片被压扁的那一刻,记下宽度,那就是你的断点。

相对单位

单位相对谁适合
px绝对像素边框、细线、需要精确的尺寸
em当前元素的字号组件内部的间距,随字号缩放
rem根元素字号全站字号、间距,尊重用户设置
%父级对应属性宽度、高度(高度常需父级有确定值)
vw / vh视口宽 / 高全屏区块、流体字号
dvh / svh动态 / 最小视口高移动端全屏,避开地址栏伸缩
ch一个「0」的宽度控制正文行长
CSS
html {
  font-size: 100%;      /* 跟随用户默认字号,通常 1rem = 16px */
}

h2 {
  font-size: 2rem;      /* 32px */
  line-height: 1.3;
}

.tag {
  font-size: .75rem;    /* 12px */
  padding: .4em .9em;   /* 随自己的字号缩放 */
}

.prose {
  max-width: 68ch;      /* 一行约 68 个字符,最舒服的阅读宽度 */
}

.hero {
  min-height: 60vh;
  min-height: 60dvh;    /* 现代浏览器用动态视口高 */
}

em 会逐层相乘,嵌套几层后很容易失控;rem 只认根字号,更适合做全局尺度。 vw 在移动端要小心:100vw 包含滚动条宽度,可能出现横向滚动。 需要全宽时,优先 width: 100%,或 min(100vw, 100%)。

clamp():一行写完流体排版

clamp(最小值, 首选值, 最大值) 会取三者中间的那个值。 把首选值写成 vw 与 rem 的混合,字号就能随屏幕平滑变化, 又不会小到看不清、大到失控。它比一串媒体查询更简洁,也更连贯。

CSS
h1 {
  font-size: clamp(26px, 4vw + 1rem, 46px);
  line-height: 1.3;
}

.wrap {
  width: min(92vw, 1120px);
  margin-inline: auto;
}

/* 卡片内边距也跟着视口轻微变化 */
.card {
  padding: clamp(16px, 3vw, 32px);
}

/* min() / max() 同样好用:取更小或更大的那个 */
.thumb {
  width: max(120px, 18vw);
}

min() 与 max() 可以和 calc() 自由嵌套。 例如 width: min(92vw, 1120px) 表示「最多 1120px,但永远给视口留 8% 的边」, 比写多个断点更稳。

CSS 自定义属性(变量)

以 -- 开头的属性就是自定义属性。它可以在任意选择器里定义, 像普通属性一样被继承;用 var() 取值,还能写一个兜底值。 变量的价值在于命名:--moss 比 #6f8f7c 更容易被理解与替换。

CSS
:root {
  --moss: #6f8f7c;
  --ink: #2e3833;
  --gap: 16px;
  --radius: 16px;
}

.card {
  padding: var(--gap);
  border-radius: var(--radius);
  color: var(--ink);
  border: 1px solid color-mix(in srgb, var(--moss) 30%, #e4dfd3);
}

/* 局部覆盖:只影响这个区块内的后代 */
.theme-warm {
  --moss: #c58a6f;
  --radius: 22px;
}

/* 第二个参数是兜底值 */
.tag {
  border: 1px solid var(--moss, #6f8f7c);
}
  • 变量区分大小写,--Moss 与 --moss 是两个东西。
  • 变量本身不参与计算,取出来的是「字面值」,需要单位时要把单位写进变量。
  • 变量不能用在媒体查询的条件里,但可以在 @media 内部重新赋值。
  • @property 可以给变量声明类型、初始值与是否继承,让动画与计算更可靠。
  • 切换主题时,只需在根元素换一组变量,而不是改几十条规则。

把它们缝在一起

  1. 用 Grid 或 Flexbox 搭出结构,先不写颜色。
  2. 用 rem 与 clamp() 定下字号与间距的尺度。
  3. 把主色、纸色、圆角、阴影收进 :root 变量。
  4. 用 minmax() 与 auto-fit 让卡片墙自己适应宽度。
  5. 最后再加过渡与一两个关键帧,让交互有回应。

你会发现,真正让页面「好看」的不是某个高级属性,而是尺度一致、留白克制、 颜色有主次。CSS 的功夫,最后都落在这些安静的判断上。

两个常见坑

1. 只用 vw 写字号,用户放大页面时文字不跟着变大,伤害可访问性;用 clamp() 时至少让最小值与首选值包含 rem。
2. 变量写在 :root 却被组件内的同名变量覆盖,排查时先看继承链,再看是否拼错了大小写。

动手看看:流体排版与变量

拖动窗口,标题与卡片宽度会平滑变化;颜色与圆角全部来自变量:

Live Preview
CSS
:root {
  --moss: #6f8f7c;
  --ink: #2e3833;
  --paper: #fffdf9;
  --gap: clamp(14px, 3vw, 26px);
  --radius: clamp(12px, 3vw, 22px);
}

.fluid {
  width: min(100%, 430px);
  margin: 0 auto;
  padding: var(--gap);
  border-radius: var(--radius);
  background: var(--paper);
  border: 1px solid color-mix(in srgb, var(--moss) 28%, #e4dfd3);
  box-shadow: 0 22px 44px -34px rgba(46, 56, 51, .55);
}

.fluid h4 {
  margin: 0 0 8px;
  font-size: clamp(20px, 4vw + .5rem, 30px);
  line-height: 1.35;
  color: var(--ink);
}

.fluid p {
  margin: 0 0 14px;
  font-size: clamp(12.5px, 1.2vw + .7rem, 15px);
  line-height: 1.9;
  color: #5a655f;
}

.chips {
  display: flex;
  flex-wrap: wrap;
  gap: 6px;
}

.chips span {
  padding: .3em .8em;
  border-radius: 999px;
  background: color-mix(in srgb, var(--moss) 14%, #fffdf9);
  color: var(--moss);
  font-size: .72rem;
  letter-spacing: .04em;
}
font-size: clamp(16px, 2.5vw, 24px) 在 1600px 与 320px 宽的屏幕上分别是多少?

1600px 时首选值是 40px,超过最大值,取 24px;320px 时首选值是 8px,低于最小值,取 16px。中间的宽度才会真正按 2.5vw 变化。clamp 的三个参数顺序不能颠倒,否则浏览器会取到意料之外的值。

写到这里,CSS 的主线就走完了:从一条规则,到选择器与盒模型, 再到颜色、排版、Flex、Grid、定位、动画与响应式。剩下的不是记更多属性, 而是多看、多改、多删。接下来打开 JavaScript 课程, 让页面从「好看」变成「会回应」。

样式不是往页面上堆东西,而是把不需要的东西,一件一件拿掉。
—— 青禾手记