w wyl123ly 的博客
MD

前端-03-CSS布局-Flex与Grid

62 KB 2026.10.11 原文件

前端-03-CSS布局-Flex与Grid

这篇笔记讲什么

布局是 CSS 里唯一"没有它就做不出页面"的部分。这篇先讲清正常流与格式化上下文这两个底层概念(它们是所有布局的默认状态),再讲五种定位(position)与层叠上下文(Stacking Context)——即"为什么设了 z-index: 9999 还是被盖住",然后是两大现代布局系统 Flexbox(一维)与 Grid(二维)的完整属性表与选型对比,最后是响应式设计(媒体查询、容器查询、clamp() 流体排版)与四个常见布局实战(三栏、圣杯、粘性页脚、侧边栏抽屉)。全篇示例都能直接粘贴运行。

是什么

布局(layout) 指浏览器决定"每个盒子放在哪里、占多大"的过程。它的输入是 CSS 的尺寸、位置与对齐属性,输出是每个盒子的最终几何位置。

CSS 里同时存在多套布局模式(layout mode),它们互不干扰,各管一片区域:

布局模式由什么建立负责什么
正常流(Normal Flow)默认状态块级元素自上而下堆叠,行内元素从左到右排列,文字排版
浮动(Float)float 非 none文字环绕图片等;历史上被滥用为栅格方案
定位布局(Positioned Layout)position 非 static把盒子从流中取出,精确放到指定位置
Flex 布局(Flexible Box Layout)display: flex一维排列与空间分配(一行或一列)
Grid 布局(Grid Layout)display: grid二维排列(同时控制行与列)
表格布局(Table Layout)display: tableHTML 表格的算法,也可用于非表格元素

Flex 与 Grid 的官方定位(W3C 规范原文):

Flexbox focuses on space distribution within an axis... Grid enforces 2-dimensional alignment.

—— <https://www.w3.org/TR/css-grid-1/>

也就是说:Flex 解决"这一行/这一列里怎么分空间",Grid 解决"整个页面切成格子后谁放哪个格子"。

为什么

为什么需要 Flex 和 Grid,不能继续用浮动和定位?

用浮动做布局的痛点(2010 年前后的主流做法):

  1. 浮动元素脱离正常流,父元素高度塌陷,必须额外"清除浮动"(clear: both 或伪元素 hack)。
  2. 垂直居中几乎做不到。要么用 line-height(只能单行)、要么用绝对定位 + 负 margin(要知道元素高度)、要么用 display: table-cell(HTML 结构被迫改成表格语义)。
  3. 等高分栏做不到。三栏布局里想三栏等高,只能给每栏写死高度或用"背景图撑高"的 hack。
  4. 顺序与源码绑定。想让主内容在源码里靠前、视觉上靠右,就要用负 margin 硬推,计算极难维护。

用绝对定位做布局的痛点:一旦用了 position: absolute,元素就脱离了文档流——它不再撑开父元素,也不会跟随其他内容的高度变化。用它搭整页骨架等于放弃自动布局。

Flex / Grid 解决的正是这些:

老方案的痛点Flex / Grid 的解法
父元素高度塌陷容器自动包住子项(建立了独立的格式化上下文)
垂直居中困难align-items: center 一行搞定
等高分栏困难交叉轴默认 stretch,同排子项自动等高
空间分配要手算百分比flex: 1 或 1fr 声明"按比例分"
顺序与源码绑定order / grid-area 可调视觉顺序(源码顺序仍服务无障碍)
响应式要重写整套规则只改容器的几行声明,如 grid-template-columns

一句话记住选型

一行或一列里的排列 → Flex;整页骨架或需要"行列同时对齐" → Grid。 两者不是竞争关系,而是配合关系:Grid 搭大骨架,骨架里的每个格子内部用 Flex 排布。

核心内容

一、布局的历史演进

年代主流方案核心思路致命痛点
1996–2003<table> 布局用表格单元格摆位置语义完全错误(a11y 灾难)、HTML 嵌套地狱、加载慢(要等整表下载完才渲染)、改一处动全身
2003–2012浮动 float + clear让块级元素横排父元素塌陷、等高困难、垂直居中困难、需要 clearfix hack
2005–2015display: inline-block行内块横排元素间空白符产生 4px 间隙、vertical-align 行为反直觉、无法等分空间
2007–2018绝对定位 + 负 margin精确坐标完全脱离流、尺寸写死、不可自适应
2009–现在Flexbox一维弹性分配多行对齐能力有限;列方向上 flex-basis 的 auto 语义容易混淆
2017–现在Grid二维网格 + 命名区域概念更多;老浏览器需查 caniuse(IE 只支持旧语法,一般不再考虑)

现在写新项目时,浮动只用于它原本的用途(文字环绕),布局一律用 Flex / Grid。

二、正常流与格式化上下文

正常流(Normal Flow)的两套规则
对比项块级(block-level)行内级(inline-level)
排列方向块流方向(横排文字时自上而下)行内方向(横排文字时从左到右)
换行每个盒子独占一行排满一行后折到下一行
width未设置时撑满包含块(auto = 填满剩余)不适用(宽度由内容决定)
height由内容决定不适用(行高由 line-height 决定)
margin 垂直有效,且会折叠无效(不影响行高)
padding 垂直有效会绘制出来但不撑开行高,视觉上会与邻行重叠
典型元素div、p、h1、sectionspan、a、strong、em

行内格式化上下文(Inline Formatting Context) 里还有几个容易踩的点:

  • 行内盒(inline box)在一行内被排列成行盒(line box),行盒的高度由其中最高的内容决定。
  • vertical-align 只在行内上下文中有效,它的参照物是行盒的基线(baseline),不是父元素的顶/底——这就是它"看起来不听话"的原因。
  • 行内元素之间的换行与空格会渲染成一个空格宽度的间隙。inline-block 并排时出现的莫名缝隙就是这么来的。现代做法:改用 display: flex,间隙问题直接消失。
格式化上下文(Formatting Context)与 BFC

格式化上下文是一块"内部布局规则自成一体"的区域。最常见也最需要理解的是 BFC(Block Formatting Context,块级格式化上下文)——一个独立的块级布局环境。

BFC 内部的布局规则:

  1. 内部盒子的排列不影响外部,外部的浮动也不会侵入 BFC 内部。
  2. BFC 的高度计算包含其内部的浮动子元素(所以它能包住浮动)。
  3. BFC 与它的子元素之间外边距不折叠。

如何触发 BFC:

触发方式副作用评价
display: flow-root无副作用,专为此设计✅ 首选
display: flex / grid子项变成 flex/grid item,布局规则改变布局本来就是 Flex/Grid 时顺带获得
overflow: hidden / auto / scroll会裁剪溢出内容或出现滚动条⚠️ 常用但可能裁掉阴影、下拉菜单、tooltip
float: left / right元素本身脱离正常流❌ 为了 BFC 而浮动是本末倒置
position: absolute / fixed元素脱离正常流❌ 同上
contain: layout / content / paint性能优化属性,副作用是限制绘制可用于性能敏感场景
根元素 <html>—天然是 BFC

BFC 能解决的三个经典问题:

/* 问题 1:父元素高度塌陷(子元素浮动,父元素高度为 0) */
.parent {
  /* 老办法:overflow: hidden(会裁剪溢出内容) */
  /* 新办法: */
  display: flow-root;   /* 高度自动包含浮动子元素 */
}

/* 问题 2:子元素 margin-top 跑到父元素外面(父子外边距折叠) */
.card {
  display: flow-root;   /* 阻止折叠,margin 老老实实待在内部 */
}

/* 问题 3:浮动元素覆盖了普通文本(实现"文字环绕"或"两栏自适应") */
.text {
  overflow: hidden;     /* 让文本块成为 BFC,从而不与左侧浮动重叠 */
}

现代写法的结论

需要"包住浮动""阻止外边距折叠"时,优先写 display: flow-root:它是唯一语义纯粹、无副作用的方案。overflow: hidden 虽然常见,但它会裁掉子元素的阴影、绝对定位的下拉菜单,是很隐蔽的 bug 来源。当然,如果已经在用 Flex / Grid,容器天然就是独立格式化上下文,这些问题根本不会出现。

三、定位(position)

值参照物(包含块)是否脱离正常流是否占原位置典型用途
static无(忽略 top/left 等偏移)否占默认值。什么都不做
relative自身原本的位置否仍占(原位置保留)微调位置、给 absolute 子元素当参照物、配合 z-index
absolute最近的已定位祖先是(不占位)不占(后续内容顶上来)徽标、下拉菜单、关闭按钮、覆盖层
fixed视口(viewport)是不占固定顶栏、悬浮客服按钮、全屏遮罩
sticky滚动容器(粘住前是正常流位置)否占吸顶表头、粘性侧边栏、字母索引条
absolute 的参照规则:这是最容易搞错的一条

absolute 元素以最近的"已定位祖先"(positioned ancestor) 的内边距盒(padding box) 为参照。判断顺序:

  1. 从自身往上找祖先元素;
  2. 第一个 position 不是 static 的祖先就是包含块;
  3. 如果一路到根都没有,则包含块是初始包含块(initial containing block)——大小约等于视口。
/* 典型错误:父元素没写 position,子元素相对整个页面定位 */
.badge {
  position: absolute;
  top: 0; right: 0;   /* 跑到页面右上角去了! */
}

/* 正确:父元素加 position: relative(其余什么都不改) */
.card {
  position: relative;  /* 只为了让子元素有个参照物 */
}
.badge {
  position: absolute;
  top: 8px; right: 8px;
}

relative 作为"参照物"用时不需要写任何偏移量。它的偏移量是相对自身原位置计算的,写 top: 10px 就是向下移 10px(原位置仍占着),这也是"relative 微调"的语义。

sticky 的生效条件与失效原因

sticky 是最容易"明明写了却不粘"的属性。它要生效必须同时满足四个条件:

条件说明
1. 指定了阈值必须写 top/bottom/left/right 中的至少一个,只写 position: sticky 什么都不会发生
2. 有滚动容器祖先中必须有可滚动的元素(或页面本身);祖先全是 overflow: visible 且页面不滚动就不会粘
3. 祖先链上没有 overflow: hidden/auto/scroll只要有一个祖先设置了这些值,粘性就会"被困"在那个祖先的滚动区域里,看起来像失效了
4. 有可移动的空间父容器的高度必须大于 sticky 元素自身高度。父容器和它一样高,就无处可粘
/* 常见失效场景:外层祖先写了一个 overflow: hidden */
.page { overflow-x: hidden; }        /* ← 这可能让整页的 sticky 失效 */
.thead th {
  position: sticky;
  top: 0;
  z-index: 1;                        /* 粘住后可能压在内容上,需配合层叠顺序 */
  background: #fff;                  /* 必须有不透明背景,否则下面的行会透出来 */
}

sticky 最常见的三个坑

1. 只写了 position: sticky 没写 top → 完全不生效(最常见)。

2. 祖先有 overflow: hidden → 粘性被限制在该祖先内(很多"布局容器"会随手加这个)。

3. sticky 元素没有不透明背景 → 粘住后下方内容从它背后透出来,看起来像"重影"。

4. 表格里粘表头失效:<thead>/<tr> 在部分浏览器上不能直接 sticky,要在 <th> 上写。

四、z-index 与层叠上下文

层叠上下文(Stacking Context) 是页面里一个独立的"三维小世界"。同一层级内,z-index 决定谁压谁;不同层叠上下文之间,子元素的 z-index 再大也压不过外层上下文的兄弟。

这就是"设了 z-index: 9999 还是被盖住"的原因:那个 9999 是在它自己的上下文里最大,而它的整个上下文被另一个上下文压住了。

哪些情况会创建层叠上下文(简化清单):

触发条件备注
根元素 <html>整个页面的根上下文
position: absolute/relative/fixed/sticky 且 z-index 不为 auto最常见的触发方式
position: fixed / sticky即使 z-index: auto 也创建(现代浏览器)
display: flex / grid 的子项且 z-index 不为 auto注意:是子项而非容器
opacity 小于 1极隐蔽:opacity: .99 就会创建
transform / filter / backdrop-filter / perspective 不为 none极隐蔽,动画中很常见
mix-blend-mode 不为 normal—
isolation: isolate专门用于主动创建上下文,无其他副作用
will-change 指定了会创建上下文的属性常用于动画优化,副作用就是创建上下文
contain: layout / paint / strict / content—

层叠顺序规则(同一层叠上下文内,从下到上):

  1. 上下文的背景与边框(形成上下文的那个元素自身);
  2. z-index 为负的层叠上下文 / 定位元素;
  3. 正常流中的块级盒子(非定位);
  4. 浮动盒子;
  5. 正常流中的行内级盒子(含文字);
  6. z-index: 0 / auto 的定位元素;
  7. z-index 为正的层叠上下文 / 定位元素。
/* 复现"9999 被盖住" */
.modal { position: fixed; z-index: 9999; }   /* 想盖住一切 */
.sidebar { position: relative; z-index: 1; transform: translateZ(0); }
/* 若 .modal 是 .sidebar 的后代,那么 .modal 的 9999 只在 .sidebar 的上下文内有效,
   .sidebar 的 z-index: 1 低于外层某个 z-index: 10 的元素 → 整个 modal 都被盖住 */

排查与解决:

  • DevTools 的 z-index 提示:Firefox 与 Chrome 的 Elements 面板会显示当前元素所属的层叠上下文。
  • 首选解法:把 z-index 写小、写少,用 isolation: isolate 明确划出上下文边界,而不是靠加更大的数字。
  • 约定层级刻度(如 --z-dropdown: 100; --z-modal: 1000; --z-toast: 2000),避免 9999 军备竞赛。

五、Flexbox

主轴与交叉轴
概念含义
主轴(main axis)由 flex-direction 决定的排列方向
交叉轴(cross axis)与主轴垂直的方向
main-start / main-end主轴上的起点与终点
cross-start / cross-end交叉轴上的起点与终点

关键:justify-content 管主轴,align-items / align-content / align-self 管交叉轴。改 flex-direction 后两者的作用方向会互换——这是新手最大的困惑来源。

flex-direction主轴方向justify-content 控制align-items 控制
row(默认)水平从左到右水平位置垂直位置
row-reverse水平从右到左水平位置(起点在右)垂直位置
column垂直从上到下垂直位置水平位置
column-reverse垂直从下到上垂直位置(起点在下)水平位置
容器属性
属性取值作用
displayflex / inline-flex建立 flex 容器;直接子元素成为 flex 项
flex-directionrow(默认) / row-reverse / column / column-reverse定主轴方向
flex-wrapnowrap(默认) / wrap / wrap-reverse是否换行;默认不换行且强行压缩
flex-flow<direction> <wrap>上面两者的简写
justify-contentflex-start / flex-end / center / space-between / space-around / space-evenly主轴上的分布
align-itemsstretch(默认) / flex-start / flex-end / center / baseline单行时交叉轴上的对齐
align-contentstretch(默认) / flex-start / flex-end / center / space-between / space-around多行时各行在交叉轴上的分布;只有一行时不生效
gap如 1rem / 1rem 2rem项之间的间距。替代 margin 方案的现代做法

justify-content / align-content 分布值对比(假设 3 个子项,容器有剩余空间):

值效果
flex-start全部靠起点,剩余空间堆在末尾
flex-end全部靠终点
center整体居中,两端空白相等
space-between首尾贴边,项之间等分剩余空间
space-around每项左右各有相等间隙,首尾各得半个间隙
space-evenly所有间隙(含首尾)完全相等
项目属性
属性默认值作用
flex-grow0有剩余空间时,按比例放大。0 = 不参与放大
flex-shrink1空间不足时,按比例缩小。0 = 不缩小(可能溢出)
flex-basisauto放大/缩小前的初始主轴尺寸。auto = 看 width/height;0 = 完全按比例分
flex0 1 auto上面三个的简写
align-selfauto(继承 align-items)单独调整某项在交叉轴的对齐
order0视觉顺序,值小的在前。不影响源码顺序与朗读顺序

flex 简写的展开含义(这是必须背下来的对照表):

简写展开含义典型场景
flex: 11 1 0可放大可缩小,基准 0 → 所有 flex: 1 的项等宽等分栏、等宽按钮组
flex: auto1 1 auto按内容大小分配,剩余空间按比例加内容不等但要按比例分
flex: none0 0 auto不放大不缩小,保持自身尺寸固定宽度的图标/侧栏
flex: 0 1 auto默认值不放大,但可缩小默认行为
flex: 22 1 0占 2 份主内容区 + 侧栏 = flex: 2 + flex: 1
flex: 0 0 200px—固定 200px,不参与弹性固定侧边栏

flex: 1 与 flex: auto 的关键差别

flex: 1 的 flex-basis 是 0,所以内容多少不影响最终宽度,几个项严格等宽。

flex: auto 的 flex-basis 是 auto(即内容宽度),所以内容多的项更宽,剩余空间再按比例加。

想让"内容长度不同的三个按钮等宽" → 用 flex: 1(并配 min-width: 0,见下)。

水平垂直居中的多种写法对比
方案代码优缺点
Flex(推荐)容器 display: flex; justify-content: center; align-items: center;不需要知道尺寸,单行代码,兼容性极好
Grid(同样好)容器 display: grid; place-items: center;最短;place-items 是 align-items + justify-items 的简写
Grid 单元素子元素 place-self: center只想居中某一个子元素时
绝对定位 + transform父 relative;子 absolute; inset: 0; margin: auto;不需要知道尺寸。加 inset: 0 后 margin: auto 会四向平分
绝对定位 + 负 margin子 absolute; top: 50%; left: 50%; margin: -20px 0 0 -40px;必须知道尺寸,现代项目已不推荐
line-height容器 line-height: 60px;只能居中单行文字,且容器高度写死
table-cell父 display: table-cell; vertical-align: middle;老方案;会带来表格布局的副作用
/* 最常用的一套 */
.center {
  display: flex;
  justify-content: center;   /* 主轴(水平)居中 */
  align-items: center;       /* 交叉轴(垂直)居中 */
  min-height: 100vh;
}

/* Grid 版,更短 */
.center-grid {
  display: grid;
  place-items: center;
  min-height: 100vh;
}
导航栏与卡片列表完整示例
/* 导航栏:左 logo,右菜单,中间自动撑开 */
.navbar {
  display: flex;
  align-items: center;
  gap: 1.5rem;
  padding: 0.75rem 1rem;
  background: #fff;
  border-bottom: 1px solid #d0d7de;
}
.navbar__logo { font-weight: 700; }
.navbar__menu {
  display: flex;
  gap: 1rem;
  list-style: none;
  margin: 0 auto 0 0;   /* 右外边距 auto → 把后面的元素推到最右 */
  padding: 0;
}
.navbar__actions { display: flex; gap: .5rem; }

卡片列表(等高卡片 + 底部按钮对齐) 是 flex 的经典组合拳:

.card-list {
  display: flex;
  flex-wrap: wrap;       /* 允许换行 */
  gap: 1rem;
}
.card {
  flex: 1 1 18rem;       /* 基准 18rem,可放大可缩小 */
  display: flex;         /* 卡片自己也是容器 */
  flex-direction: column;/* 内部竖向排列 */
  border: 1px solid #d0d7de;
  border-radius: 12px;
  padding: 1rem;
}
.card__body { flex: 1; }        /* 撑满剩余高度 */
.card__footer { margin-top: auto; }  /* 双保险:把页脚推到最底部 */

为什么 margin-top: auto 能把内容推到底部

在 flex 容器中,auto 外边距会吸收该方向上的所有剩余空间。所以给最后一个子项写 margin-top: auto,它就会被推到容器底部;同理,给导航栏中某个元素写 margin-left: auto 会把后面所有元素推到右侧。这是 Flex 里非常好用但常被忽略的技巧。

六、Grid

基础概念
术语含义
网格线(grid line)分割网格的横线与纵线,从 1 开始编号,负数从末尾倒数(-1 是最右/最下一条)
网格轨道(grid track)两条相邻网格线之间的空间,即"一行"或"一列"
网格单元格(grid cell)一行与一列的交点,最小单位
网格区域(grid area)一个或多个相邻单元格组成的矩形区域
显式网格(explicit grid)由 grid-template-* 明确定义的行列
隐式网格(implicit grid)内容超出显式网格时浏览器自动添加的行列,用 grid-auto-rows/columns 控制其尺寸
容器属性
属性说明
display: grid / inline-grid建立网格容器
grid-template-columns / -rows定义列 / 行的数量与尺寸
grid-template-areas用字符串画出示意图,给区域命名
grid-template上面三者的简写(可读性差,实际少用)
grid-auto-columns / -rows隐式轨道的尺寸
grid-auto-flowrow(默认) / column / dense:自动放置的顺序与是否"回填空洞"
gap / row-gap / column-gap轨道间距
justify-items / align-items / place-items所有子项在各自单元格内的对齐
justify-content / align-content / place-content整个网格在容器内(网格总尺寸小于容器时)的对齐
fr 单位

fr 表示"剩余空间的一份"。分配算法:

  1. 先减去所有固定尺寸轨道(如 200px、auto 算出的尺寸)与所有 gap;
  2. 剩下的空间按 fr 的数值比例分配。

例如容器 1000px、gap: 20px、三列 1fr 2fr 1fr:

得到 240px、480px、240px。

fr 与 auto 的区别:fr 是"分配剩余空间",auto 是"先按内容算尺寸"(minmax(auto, auto))。所以 auto 1fr 表示"左列宽度由内容决定,右列吃掉剩下的全部"。

1fr 不会小于内容的 min-content 宽度

1fr 实际等价于 minmax(auto, 1fr),其中的 auto 最小值是内容的 min-content 尺寸。所以一个长英文单词或长 URL 会把列撑宽,导致溢出。修正办法:显式写 minmax(0, 1fr),或给子项加 min-width: 0。

repeat() / minmax() / auto-fit 与 auto-fill
/* repeat():重复轨道定义 */
grid-template-columns: repeat(3, 1fr);            /* 等价 1fr 1fr 1fr */
grid-template-columns: repeat(2, 100px 1fr);      /* 可重复多个轨道 → 100px 1fr 100px 1fr */

/* minmax():给轨道一个尺寸区间 */
grid-template-columns: minmax(200px, 1fr) 2fr;    /* 第一列 200px 到 1fr 之间 */
grid-template-columns: minmax(0, 1fr);            /* 允许收缩到 0,防溢出 */

/* 响应式自动列:不需要任何媒体查询 */
grid-template-columns: repeat(auto-fit, minmax(16rem, 1fr));

auto-fit 与 auto-fill 的区别是 Grid 最常考的一点:

值行为视觉效果
auto-fill尽量多放空轨道,即使没有内容3 个项目也保留 5 个轨道的宽度 → 项目挤在左边,右边留白
auto-fit先按 auto-fill 算,然后把空轨道折叠为 03 个项目就平分整行宽度 → 项目被拉伸铺满

一句话:auto-fit 让少量项目撑满整行(通常是我们想要的),auto-fill 保留轨道位置(需要对齐栅格时用)。

grid-template-areas 命名区域
.layout {
  display: grid;
  grid-template-columns: 200px 1fr 200px;
  grid-template-rows: auto 1fr auto;
  grid-template-areas:
    "header header header"
    "sidebar main   aside"
    "footer footer footer";
  gap: 1rem;
  min-height: 100vh;
}
.layout > header  { grid-area: header; }
.layout > nav     { grid-area: sidebar; }
.layout > main    { grid-area: main; }
.layout > aside   { grid-area: aside; }
.layout > footer  { grid-area: footer; }

/* 区域名相同的单元格自动合并;用 . 表示空格子 */
.grid-with-hole {
  grid-template-areas:
    "a a ."
    "b b c";
}

这是可读性最高的 Grid 写法:CSS 里的字符串排布和设计稿的版式一一对应,改版式只改字符串,不用碰任何子元素的规则。响应式切换也只需在媒体查询里重写这一处。

项目定位与 span
.item {
  /* 方式一:指定起止网格线 */
  grid-column: 1 / 3;          /* 从第 1 条列线到第 3 条列线(跨 2 列) */
  grid-row: 2 / 4;

  /* 方式二:起点 + 跨越数(更不易算错) */
  grid-column: 2 / span 2;     /* 从第 2 条线起,跨 2 列 */
  grid-row: span 2;            /* 只写跨越数,起点自动放置 */

  /* 方式三:负数索引 */
  grid-column: 1 / -1;         /* 从最左到最右(跨满整行) */

  /* 方式四:命名区域 */
  grid-area: header;
}

grid-area 是 grid-row-start / grid-column-start / grid-row-end / grid-column-end 的简写,顺序为上、左、下、右(顺时针)。

响应式卡片墙完整示例
.wall {
  display: grid;
  /* 关键一行:每列最小 16rem,能塞几列就塞几列,剩余空间平分 */
  grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
  gap: 1rem;
  padding: 1rem;
}
.wall__item {
  display: flex;
  flex-direction: column;
  border: 1px solid #d0d7de;
  border-radius: 12px;
  overflow: hidden;
}
.wall__item img { width: 100%; aspect-ratio: 16 / 9; object-fit: cover; }
.wall__item--wide { grid-column: span 2; }   /* 特色卡占两列 */

/* 窄屏时不让"占两列"的卡溢出 */
@media (max-width: 40rem) {
  .wall__item--wide { grid-column: auto; }
}

注意 minmax(min(16rem, 100%), 1fr) 里嵌套 min() 的用途:当容器本身窄于 16rem 时(例如手机竖屏),16rem 的最小值会导致横向溢出,min(16rem, 100%) 让最小值不超过容器宽度,从而彻底避免横向滚动条。

七、Flex 与 Grid 的选型对比

对比项FlexboxGrid
维度一维(一行或一列)二维(行列同时)
布局思路自下而上:由内容决定布局自上而下:先定义网格,再放内容
尺寸来源内容优先,再分配剩余空间轨道定义优先,内容影响 auto 轨道
空间分配flex-grow / flex-shrink / flex-basisfr / minmax() / repeat()
对齐控制容器级 justify-content / align-items;项目级 align-self容器级 + 项目级,且行列独立(justify-self / align-self)
重叠能力需借助负 margin 或定位原生支持(多个项放同一区域)
顺序调整orderorder + grid-area(可用命名区域大幅重排)
响应式靠 flex-wrap 自动换行靠 auto-fit/auto-fill + minmax() 或媒体查询
典型场景导航栏、按钮组、卡片内容、表单行、工具栏整页骨架、卡片墙、仪表盘、复杂二维对齐

决策流程:

  1. 内容只需要沿一个方向排列吗?→ Flex(导航栏、标签组、卡片内部布局)。
  2. 需要行列同时对齐,或者元素要跨越行列吗?→ Grid(页面骨架、卡片墙、报表)。
  3. 需要按容器宽度自动决定列数吗?→ Grid + repeat(auto-fit, minmax(...)),一行代码替代媒体查询。
  4. 内容长度决定尺寸、且要沿主轴分配剩余空间?→ Flex(flex: 1 系列)。
  5. 两者结合才是常态:Grid 搭骨架,格子内部用 Flex。

一个实用的判断口诀

问自己:"我是在排一条线,还是在排一张表?" 线 → Flex;表 → Grid。

八、响应式设计

视口 meta(移动端的前提)
<meta name="viewport" content="width=device-width, initial-scale=1">

不写它,移动浏览器会以约 980px 的虚拟宽度渲染页面再整体缩小,媒体查询也按 980px 判定 → 所有移动端断点全部失效。这是响应式失效的第一大原因。

媒体查询语法
/* 基本形式:媒体类型 + 特性条件 */
@media screen and (min-width: 48rem) { /* ... */ }

/* 范围语法(现代写法,语义更清楚) */
@media (width >= 48rem) and (width < 64rem) { }
@media (30rem <= width <= 60rem) { }

/* 逻辑运算 */
@media (min-width: 48rem) and (orientation: landscape) { }
@media (hover: hover) and (pointer: fine) { }      /* 有真实鼠标 */
@media (prefers-color-scheme: dark) { }            /* 系统深色模式 */
@media (prefers-reduced-motion: reduce) { }        /* 用户要求减少动画 */
@media print { }                                   /* 打印样式 */
@media not all and (monochrome) { }                /* 取反 */

媒体查询不能使用 CSS 变量:@media (min-width: var(--bp)) 是无效的。但在查询块内部重新赋值变量是有效的,这是组织响应式主题的好办法:

:root { --gutter: 1rem; --cols: 1; }
@media (min-width: 48rem) {
  :root { --gutter: 2rem; --cols: 3; }   /* 合法:块内赋值 */
}
断点选择策略
策略写法优点缺点
移动优先(Mobile First)基础样式给小屏,用 min-width 逐级增强符合现代使用占比;样式表天然"渐增",覆盖关系简单桌面端调试时需从最小屏看起
桌面优先(Desktop First)基础样式给大屏,用 max-width 逐级降级设计稿通常是桌面版,先写更直观容易出现"越补越乱"的覆盖链

移动优先是当前的主流推荐做法(也是 min-width 用得更多的原因)。断点不要照抄设备型号,而是跟着内容走:把窗口从窄往宽拖,找出"当前布局开始显得难看"的那几个宽度,把它们设为断点。

/* 移动优先的骨架 */
.wrap { padding: 1rem; }                       /* 手机:单列 */
@media (min-width: 40rem) { .grid { grid-template-columns: repeat(2, 1fr); } }
@media (min-width: 64rem) { .grid { grid-template-columns: repeat(4, 1fr); } }
容器查询 @container(新一代响应式)

媒体查询看的是视口宽度;容器查询(Container Queries) 看的是父容器宽度。这对组件化开发意义重大:同一个卡片组件放进窄侧栏就变竖排、放进宽主区就变横排,组件不需要知道自己在页面哪里。

/* 1. 声明这个元素是可查询容器,并指定查询哪个维度 */
.card-wrap {
  container-type: inline-size;   /* 允许按宽度查询 */
  container-name: card;          /* 可选:给容器起名 */
}

/* 2. 在组件内部按容器宽度写规则 */
.card { display: grid; gap: .5rem; }

@container card (min-width: 30rem) {
  .card {
    grid-template-columns: 12rem 1fr;   /* 容器够宽 → 图左文右 */
    align-items: center;
  }
}
对比项媒体查询 @media容器查询 @container
参照物视口最近的查询容器
适用层级页面级布局组件级布局
复用性组件在不同宽度区域里表现一致(不理想)组件随所在容器自适应,可跨页面复用
支持情况全支持较新特性,使用前查 <https://caniuse.com/container-queries>
clamp() 流体排版
/* clamp(最小值, 理想值, 最大值) */
h1 {
  /* 字号在 1.75rem 到 3rem 之间,随视口线性变化 */
  font-size: clamp(1.75rem, 1rem + 3vw, 3rem);
}

/* 容器宽度也用 clamp,避免超大屏上一行字太长 */
.prose {
  width: min(65ch, 100% - 2rem);
  margin-inline: auto;
}

/* 流体间距 */
.section {
  padding-block: clamp(2rem, 5vw, 6rem);
}

clamp(min, val, max) 等价于 max(min, min(val, max)):理想值超出范围时被夹在边界上。它的价值是"用一个表达式替代三四个断点",让字号与间距平滑变化,不会在断点处"跳一下"。

无障碍注意

用 vw 做字号时,一定要给 clamp() 一个以 rem 为单位的上下限。纯 font-size: 3vw 会让浏览器缩放到 200% 时字体不跟着变大,违反 WCAG 的"文本可缩放"要求。写成 clamp(1rem, 3vw, 2rem) 就安全了——下限是可缩放的 rem。

九、常见布局实战

1. 三栏布局(两侧固定,中间自适应)
/* 方案 A:Flex(最直观) */
.three-col { display: flex; gap: 1rem; }
.three-col__side { flex: 0 0 200px; }   /* 固定 */
.three-col__main { flex: 1; min-width: 0; }  /* 自适应;min-width: 0 防内容溢出 */

/* 方案 B:Grid(更简洁,且天然等高) */
.three-col-grid {
  display: grid;
  grid-template-columns: 200px minmax(0, 1fr) 200px;
  gap: 1rem;
  align-items: start;   /* 不想等高时;默认 stretch 就是等高 */
}
2. 圣杯布局(Holy Grail Layout)

经典需求:主内容在源码里排在侧栏之前(利于 SEO 与屏幕阅读器),但视觉上排在中间。Grid 让它变成几行声明:

body.holy-grail {
  display: grid;
  grid-template-columns: 12rem minmax(0, 1fr) 12rem;
  grid-template-rows: auto 1fr auto;
  grid-template-areas:
    "header  header header"
    "nav     main   aside"
    "footer  footer footer";
  gap: 1rem;
  min-height: 100vh;
}
.holy-grail > header { grid-area: header; }
.holy-grail > nav    { grid-area: nav; }
.holy-grail > main   { grid-area: main; }
.holy-grail > aside  { grid-area: aside; }
.holy-grail > footer { grid-area: footer; }

/* 窄屏降级为单列,只需重写区域图 */
@media (max-width: 48rem) {
  body.holy-grail {
    grid-template-columns: minmax(0, 1fr);
    grid-template-areas:
      "header"
      "nav"
      "main"
      "aside"
      "footer";
  }
}

需求:内容不足一屏时页脚贴在视口底部,内容长时页脚跟随内容之后。

/* 方案 A:Flex(兼容性最好) */
.page { display: flex; flex-direction: column; min-height: 100vh; }
.page__main { flex: 1; }   /* 把页脚顶到底部 */

/* 方案 B:Grid(更短) */
.page {
  display: grid;
  grid-template-rows: auto 1fr auto;
  min-height: 100dvh;   /* dvh 解决移动端地址栏导致的 100vh 溢出 */
}

为什么用 100dvh 而不是 100vh

移动浏览器的地址栏会随滚动收放,100vh 是按"地址栏隐藏时"的高度算的,所以会略微超出可视区域并产生滚动。dvh(dynamic viewport height)会跟随实际可视高度变化;svh 是最小高度、lvh 是最大高度。

4. 侧边栏抽屉(Off-canvas Drawer)
.drawer {
  position: fixed;
  inset: 0 auto 0 0;          /* 上右下左:贴着左侧、满高 */
  width: min(20rem, 85vw);    /* 手机上最多占 85% 宽 */
  background: #fff;
  transform: translateX(-100%);   /* 默认移出屏幕左侧 */
  transition: transform .25s ease;
  z-index: 100;
  overscroll-behavior: contain;   /* 抽屉内滚动到底时不"传染"给页面 */
}
.drawer.is-open { transform: translateX(0); }

/* 遮罩 */
.drawer-mask {
  position: fixed;
  inset: 0;
  background: rgb(0 0 0 / .45);
  opacity: 0;
  visibility: hidden;             /* 同时做无障碍与可点击性开关 */
  transition: opacity .25s, visibility .25s;
  z-index: 99;
}
.drawer.is-open + .drawer-mask,
.drawer-mask.is-open { opacity: 1; visibility: visible; }

/* 尊重"减少动画"偏好 */
@media (prefers-reduced-motion: reduce) {
  .drawer, .drawer-mask { transition: none; }
}

用 transform 而不是 left 做动画,是因为 transform 只触发合成(composite),不触发重排与重绘,在低端设备上更流畅(见 前端-09-前端工程化与调试 的性能部分)。

抽屉的无障碍要点

抽屉打开时应当:① 把焦点移入抽屉;② 把抽屉外的内容设为 inert 或 aria-hidden="true",防止 Tab 键跑出去;③ 支持 <kbd>Esc</kbd> 关闭;④ 关闭后把焦点还给触发按钮。纯 CSS 做不到这些,需要少量 JavaScript。

怎么用:可直接粘贴运行的最小完整示例

保存为 layout-demo.html,双击打开。它用 Grid 搭整页骨架 + Flex 排布格子内部,包含导航栏、卡片墙、粘性表头、侧边栏抽屉与响应式降级,即可用于理解也可直接改成你的页面。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>CSS 布局示例:Grid + Flex</title>
  <style>
    :root {
      --surface: #fff;
      --bg: #f6f8fa;
      --fg: #1f2328;
      --muted: #59636e;
      --brand: #0b5fff;
      --border: #d0d7de;
      --radius: 12px;
      --z-drawer: 100;
      --z-mask: 99;
    }
    *, *::before, *::after { box-sizing: border-box; }

    body {
      margin: 0;
      background: var(--bg);
      color: var(--fg);
      font-family: system-ui, "Microsoft YaHei", "PingFang SC", sans-serif;
      line-height: 1.6;
    }

    /* ===== Grid 搭骨架:页头 / 侧栏 + 主区 / 页脚,页脚永远在底部 ===== */
    .page {
      display: grid;
      grid-template-columns: 14rem minmax(0, 1fr);
      grid-template-rows: auto 1fr auto;
      grid-template-areas:
        "header header"
        "sidebar main"
        "footer footer";
      gap: 1rem;
      min-height: 100dvh;
      padding: 1rem;
    }
    .page > header  { grid-area: header; }
    .page > nav     { grid-area: sidebar; }
    .page > main    { grid-area: main; min-width: 0; }
    .page > footer  { grid-area: footer; }

    /* ===== Flex 排导航栏 ===== */
    .navbar {
      display: flex;
      align-items: center;
      gap: 1rem;
      padding: .75rem 1rem;
      background: var(--surface);
      border: 1px solid var(--border);
      border-radius: var(--radius);
    }
    .navbar__brand { font-weight: 700; }
    .navbar__menu {
      display: flex; gap: 1rem; list-style: none;
      margin: 0 auto 0 0; padding: 0; font-size: .95rem;
    }
    .navbar__menu a { color: var(--muted); text-decoration: none; }
    .navbar__menu a:hover { color: var(--brand); }

    .sidebar {
      background: var(--surface);
      border: 1px solid var(--border);
      border-radius: var(--radius);
      padding: 1rem;
      align-self: start;              /* 别拉伸到整页高 */
      position: sticky;               /* 粘性侧栏:条件齐备才生效 */
      top: 1rem;
      max-height: calc(100dvh - 2rem);
      overflow: auto;
    }
    .sidebar ul { margin: 0; padding-left: 1.1rem; }

    /* ===== Grid 卡片墙:一行替代所有断点 ===== */
    .wall {
      display: grid;
      grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
      gap: 1rem;
    }
    .card {
      display: flex;                  /* 卡片内部用 Flex */
      flex-direction: column;
      background: var(--surface);
      border: 1px solid var(--border);
      border-radius: var(--radius);
      padding: 1rem;
    }
    .card--wide { grid-column: span 2; }   /* 特色卡横向占两列 */
    .card__title { margin: 0 0 .25rem; font-size: 1.05rem; }
    .card__body { margin: 0 0 1rem; color: var(--muted); font-size: .95rem; }
    .card__footer { margin-top: auto; }    /* 按钮始终贴底,卡片内按钮对齐 */

    .btn {
      font: inherit; cursor: pointer;
      padding: .5rem 1rem; border-radius: 8px;
      border: 1px solid transparent;
      background: var(--brand); color: #fff;
    }
    .btn--ghost { background: transparent; color: var(--brand); border-color: var(--brand); }
    :focus-visible { outline: 3px solid var(--brand); outline-offset: 2px; }

    /* ===== 表格:粘性表头 ===== */
    .table-wrap { overflow: auto; max-height: 16rem; border: 1px solid var(--border); border-radius: var(--radius); background: var(--surface); }
    table { border-collapse: collapse; width: 100%; font-size: .95rem; }
    th, td { padding: .5rem .75rem; text-align: left; border-bottom: 1px solid var(--border); }
    thead th {
      position: sticky;      /* 粘在滚动容器顶部 */
      top: 0;
      background: var(--surface);   /* 必须不透明,否则下面的行会透出来 */
      z-index: 1;
    }

    /* ===== 定位演示:徽标与抽屉 ===== */
    .badge-demo { position: relative; display: inline-block; margin-top: 1rem; }
    .badge {
      position: absolute; top: -8px; right: -8px;   /* 参照最近的已定位祖先 */
      background: #d1242f; color: #fff;
      font-size: .75rem; line-height: 1;
      padding: .25rem .4rem; border-radius: 999px;
    }

    .drawer {
      position: fixed;
      inset: 0 auto 0 0;
      width: min(18rem, 85vw);
      background: var(--surface);
      border-right: 1px solid var(--border);
      padding: 1rem;
      transform: translateX(-100%);
      transition: transform .25s ease;
      z-index: var(--z-drawer);
    }
    .drawer.is-open { transform: translateX(0); }
    .mask {
      position: fixed; inset: 0;
      background: rgb(0 0 0 / .45);
      opacity: 0; visibility: hidden;
      transition: opacity .25s, visibility .25s;
      z-index: var(--z-mask);
      border: 0; padding: 0;         /* button 当遮罩时清掉默认样式 */
    }
    .mask.is-open { opacity: 1; visibility: visible; }

    /* ===== 响应式降级:窄屏变单列 ===== */
    @media (max-width: 48rem) {
      .page {
        grid-template-columns: minmax(0, 1fr);
        grid-template-areas:
          "header"
          "main"
          "sidebar"
          "footer";
      }
      .sidebar { position: static; max-height: none; }
      .card--wide { grid-column: auto; }
    }

    @media (prefers-reduced-motion: reduce) {
      .drawer, .mask { transition: none; }
    }
  </style>
</head>
<body>
  <div class="page">
    <header>
      <div class="navbar">
        <span class="navbar__brand">Layout Demo</span>
        <ul class="navbar__menu">
          <li><a href="#wall">卡片墙</a></li>
          <li><a href="#table">表格</a></li>
        </ul>
        <button class="btn btn--ghost" type="button" id="openDrawer">打开抽屉</button>
      </div>
    </header>

    <nav class="sidebar" aria-label="侧边栏导航">
      <h2 style="font-size:1rem;">目录</h2>
      <ul>
        <li>正常流与 BFC</li>
        <li>定位与 z-index</li>
        <li>Flexbox</li>
        <li>Grid</li>
      </ul>
    </nav>

    <main>
      <h1 style="margin-top:0;">Grid 骨架 + Flex 细节</h1>
      <p style="color:var(--muted);">
        把窗口从宽拖到窄,观察:侧栏与卡片自动降级为单列,卡片墙列数自动变化,页脚始终在底部。
      </p>

      <section id="wall" class="wall" style="margin-block:1rem;">
        <article class="card card--wide">
          <h2 class="card__title">特色卡片(跨两列)</h2>
          <p class="card__body">由 <code>grid-column: span 2</code> 实现;窄屏时通过媒体查询取消跨越,避免溢出。</p>
          <div class="card__footer"><button class="btn" type="button">主要操作</button></div>
        </article>
        <article class="card">
          <h2 class="card__title">卡片 A</h2>
          <p class="card__body">描述文字长短不一。</p>
          <div class="card__footer"><button class="btn btn--ghost" type="button">查看</button></div>
        </article>
        <article class="card">
          <h2 class="card__title">卡片 B</h2>
          <p class="card__body">这段描述刻意写得比较长,用来验证同一行的卡片会不会被撑成不同高度——Flex 的默认 <code>align-items: stretch</code> 会让它们等高。</p>
          <div class="card__footer"><button class="btn btn--ghost" type="button">查看</button></div>
        </article>
        <article class="card">
          <h2 class="card__title">卡片 C</h2>
          <p class="card__body">想加更多?直接复制这段 HTML,列数会自动重算。</p>
          <div class="card__footer"><button class="btn btn--ghost" type="button">查看</button></div>
        </article>
      </section>

      <section id="table">
        <h2>粘性表头</h2>
        <div class="table-wrap">
          <table>
            <thead>
              <tr><th scope="col">方案</th><th scope="col">维度</th><th scope="col">典型用途</th></tr>
            </thead>
            <tbody>
              <tr><th scope="row">Flexbox</th><td>一维</td><td>导航栏、按钮组</td></tr>
              <tr><th scope="row">Grid</th><td>二维</td><td>页面骨架、卡片墙</td></tr>
              <tr><th scope="row">定位</th><td>—</td><td>徽标、抽屉、遮罩</td></tr>
              <tr><th scope="row">正常流</th><td>一维</td><td>正文排版</td></tr>
              <tr><th scope="row">浮动</th><td>—</td><td>文字环绕</td></tr>
            </tbody>
          </table>
        </div>
        <p style="color:var(--muted);font-size:.9rem;">在表格区域内滚动,表头会粘在顶部。</p>
      </section>

      <div class="badge-demo">
        <button class="btn btn--ghost" type="button">消息</button>
        <span class="badge">3</span>
      </div>
      <p style="color:var(--muted);font-size:.9rem;">
        徽标用 <code>position: absolute</code>,参照最近的已定位祖先(外层 <code>.badge-demo</code> 的 <code>position: relative</code>)。
      </p>
    </main>

    <footer style="text-align:center;color:var(--muted);font-size:.9rem;">
      <p>© 2026 布局示例 · 页脚由 <code>grid-template-rows: auto 1fr auto</code> 固定在底部</p>
    </footer>
  </div>

  <!-- 抽屉与遮罩放在页面末尾,避免影响 Grid 布局 -->
  <aside class="drawer" id="drawer" aria-label="侧边栏抽屉">
    <h2 style="font-size:1rem;margin-top:0;">抽屉</h2>
    <p style="color:var(--muted);font-size:.9rem;">
      用 <code>transform: translateX()</code> 移入移出,只触发合成,性能好。
    </p>
    <button class="btn" type="button" id="closeDrawer">关闭</button>
  </aside>
  <button class="mask" id="mask" type="button" aria-label="关闭抽屉"></button>

  <script>
    // 极简交互:真实项目里还应处理 Esc 键、焦点陷阱与 inert
    const drawer = document.getElementById('drawer');
    const mask = document.getElementById('mask');
    const open = () => {
      drawer.classList.add('is-open');
      mask.classList.add('is-open');
      document.getElementById('closeDrawer').focus();   // 把焦点移入抽屉
    };
    const close = () => {
      drawer.classList.remove('is-open');
      mask.classList.remove('is-open');
      document.getElementById('openDrawer').focus();     // 焦点还给触发按钮
    };
    document.getElementById('openDrawer').addEventListener('click', open);
    document.getElementById('closeDrawer').addEventListener('click', close);
    mask.addEventListener('click', close);
    document.addEventListener('keydown', e => { if (e.key === 'Escape') close(); });
  </script>
</body>
</html>

动手验证清单:

  1. 拖动窗口宽度:卡片墙列数在 1/2/3/4 列之间自动变化,没有写任何针对卡片墙的媒体查询。
  2. 把窗口缩到 48rem 以下:侧栏移到主内容下方,特色卡不再跨列——全部来自那一个 @media 块。
  3. 在表格区域内滚动:表头粘在顶部。给 .table-wrap 加上 overflow: hidden 试试——粘性表头会失效(这正是 sticky 失效的经典原因)。
  4. 清空 <main> 里的内容:页脚仍然贴在视口底部(grid-template-rows: auto 1fr auto 在起作用)。
  5. 打开抽屉,注意它是从左侧滑入而不是"跳出来";遮罩淡入;按 <kbd>Esc</kbd> 能关闭。

常见坑

高频错误清单

1. 忘了 viewport meta → 媒体查询全部按 980px 判定,移动端样式一条不生效。

2. z-index 写了没用:它只对定位元素(或 Flex/Grid 子项)有效,而且会被层叠上下文困住。祖先有 transform、opacity < 1、filter 都会创建上下文。

3. absolute 跑到意料之外的位置 → 最近的已定位祖先不是你以为的那个。给目标父元素加 position: relative。

4. sticky 不生效:只写了 position: sticky 没写 top;或祖先有 overflow: hidden/auto;或父容器与它等高无处可粘。

5. display: flex 后子项 width 失效:flex 项的主轴尺寸由 flex-basis/flex 决定,width 只是 flex-basis: auto 时的参考。想要固定宽度用 flex: 0 0 200px。

6. flex 项被内容撑爆:flex 项的 min-width 默认是 auto(不小于内容的最小尺寸),长单词或 pre 会把容器撑破。加 min-width: 0(列方向是 min-height: 0)。

7. align-content 没反应 → 它是给多行用的。只有一行时 flex-wrap 没生效(默认 nowrap),应该用 align-items。

8. flex: 1 与 flex: auto 混用导致宽度不一致 → 前者基准为 0(严格等分),后者基准为内容宽度。

9. margin 与 gap 混用:给 flex/grid 子项加 margin 会造成间距不均。统一用容器上的 gap。

10. 1fr 列被长内容撑开溢出 → 1fr 等价 minmax(auto, 1fr)。改用 minmax(0, 1fr) 或给子项 min-width: 0。

11. auto-fit 与 auto-fill 选错:项目少时 auto-fill 会留一片空白(保留空轨道),auto-fit 会把项目拉满。

12. repeat(auto-fit, minmax(16rem, 1fr)) 在窄屏横向溢出 → 容器比 16rem 还窄时,最小值超出容器。用 minmax(min(16rem, 100%), 1fr)。

13. grid-template-areas 的字符串列数不一致 → 整个声明失效且不报错。每一行的单词数必须相同。

14. 100vh 在手机上溢出 → 地址栏收放导致高度变化。改用 100dvh/100svh。

15. 用 order 或 grid-area 做"逻辑重排" → 只影响视觉,源码/朗读/Tab 顺序不变,会造成键盘用户"焦点乱跳"的无障碍缺陷。规范明确要求只能用于视觉顺序调整。

16. 动画 left/top/width → 触发重排重绘。优先动画 transform 与 opacity。

17. 媒体查询里写 var() → 无效。变量只能在查询块内部重新赋值。

18. 用 vw 做字号但不给上限 → 用户放大字号时文本不跟着变大,违反 WCAG。用 clamp(1rem, 3vw, 2rem)。

练习题

第 1 题(照着做,实操) 用 Grid + Flex 做一个完整的响应式落地页 landing.html,要求:

  • 单文件可运行,不引入任何框架。
  • Grid 定义整页骨架:header 占满宽度,main 与 aside 并排,footer 占满宽度;用 grid-template-areas 命名区域,并在窄屏媒体查询里改成单列。
  • Grid 实现一块卡片墙,使用 repeat(auto-fit, minmax(min(18rem, 100%), 1fr)),并让其中一张卡跨两列。
  • Flex 实现顶部导航栏(左 logo、中菜单、右按钮)与卡片内部布局(标题—描述—按钮贴底)。
  • 用定位实现一个卡片上的角标(position: absolute)与一个可开关的侧边栏抽屉(transform + visibility)。
  • 用 clamp() 做流体标题字号,并说明为什么上下限要用 rem。
  • 页脚在内容不足一屏时贴底。
  • 完成后回答:这个页面里一共创建了几个层叠上下文?分别是哪几个元素、因为什么属性创建的?

第 2 题 下面这段代码为什么"粘性侧栏不生效"?列出所有可能原因,并写出修正后的完整代码。

<div class="page">
  <aside class="sidebar">侧栏</aside>
  <main>很长很长的主内容……</main>
</div>
<style>
  .page { display: flex; overflow: hidden; }
  .sidebar { position: sticky; width: 200px; }
</style>

第 3 题 已知容器宽度 ,gap: 24px,网格定义为 grid-template-columns: 200px 1fr 2fr minmax(0, 1fr)。请:

  1. 算出每一列的实际宽度(写出计算过程)。
  2. 如果容器缩到 ,会发生什么?哪一列会先"扛不住"?
  3. 把 1fr 换成 auto,结果会怎样变化?

第 4 题 解释 flex: 1 与 flex: auto 的区别,并分别给出一个必须用前者的场景和一个必须用后者的场景。然后用这两行代码预测结果:

<div class="row">
  <div class="a" style="flex: 1;">短</div>
  <div class="b" style="flex: 1;">这是一段很长很长的内容</div>
  <div class="c" style="flex: auto;">中等长度内容</div>
</div>
<style>.row { display: flex; width: 900px; gap: 10px; }</style>

(a) .a 与 .b 的宽度是否相等?为什么?

(b) .c 的宽度由什么决定?

(c) 如果 .b 里含一个不会断行的超长 URL,会发生什么?给出两种修法。

第 5 题 用容器查询改写下面这个"媒体查询版"的卡片样式,并说明改写后带来的实际好处(至少两条)。

.card { display: grid; gap: .5rem; }
@media (min-width: 60rem) {
  .card { grid-template-columns: 12rem minmax(0, 1fr); align-items: center; }
}

要求:写出完整的 CSS(含容器声明与 @container 规则),并说明同一个卡片组件分别放进"宽主区"和"窄侧栏"时的表现差异。

FAQ

Q1:display: flex 之后,子元素的 width: 100px 为什么不生效?

因为 flex 项的主轴尺寸不再由 width 决定,而是由 flex-basis(默认 auto,此时才回退看 width)与 flex-grow/flex-shrink 共同决定。当容器有剩余空间且 flex-grow 大于 0 时,项会被拉宽,width 就不再是最终宽度。

正确做法:

  • 想要固定宽度:flex: 0 0 100px(不放大、不缩小、基准 100px)。
  • 想让它占满剩余:flex: 1。
  • 想限制最大宽度:max-width: 100px 仍然有效(max-width 优先于 flex 计算)。

Q2:1fr 和 25% 有什么区别?为什么栅格推荐 fr?

  • 25% 是相对容器宽度的百分比,不算 gap。四个 25% 加上三个 gap 一定溢出。
  • 1fr 分配的是扣除固定轨道与 gap 之后的剩余空间,所以 repeat(4, 1fr) + gap: 1rem 永远刚好铺满,不会溢出。

这就是栅格用 fr 的核心原因:它与 gap 天然协同。只有需要"列宽严格等于容器的某个百分比"(少见)时才用 %。

Q3:Flexbox 和 Grid 能混用吗?会不会有性能问题?

能混用,而且是推荐做法:Grid 搭页面骨架,骨架里的每个格子用 Flex 排内部元素。性能上不必担心——浏览器对这两种布局都有高度优化的实现。真正影响性能的是布局抖动(layout thrashing):在 JS 里交替读写会引起重排的属性(如先读 offsetHeight 再改 width 再读),迫使浏览器反复重新布局。解决办法是批量读、批量写,或使用 requestAnimationFrame。

另外,嵌套层级过深(十几层 flex/grid 容器)会增加布局计算量,但实践中更常见的问题是可读性下降,而不是性能。

Q4:z-index: 9999 还是被盖住,最快的排查方法是什么?

三步:

  1. 确认元素是定位元素(或 Flex/Grid 子项)。非定位元素的 z-index 会被忽略。
  2. 在 DevTools 里从该元素向上逐层检查,找出最近的层叠上下文创建者:看它有没有 position + z-index、opacity < 1、transform、filter、isolation、will-change、contain。
  3. 比较的是两边的层叠上下文,不是两个 z-index 数字。如果被盖住的元素所在上下文整体低于对方上下文,它的 9999 就没用。

根治办法:定义一套 --z-* 刻度(下拉 100、粘性栏 200、遮罩 900、抽屉 1000、弹窗 1100、提示 1200)并用 isolation: isolate 主动划边界,而不是靠更大的数字。

Q5:响应式到底该用媒体查询还是容器查询?

按"组件是否需要在不同宽度的容器里表现不同"来判断:

  • 页面级布局(整页单列/双列切换、导航栏折叠)→ 用媒体查询,因为它关心的确实是视口。
  • 可复用组件(卡片、列表项、表格)→ 用容器查询。这样同一个组件放进侧栏就是紧凑版,放进主区就是宽敞版,不需要为每种位置写额外的类名。
  • 两者可以共存:外层用媒体查询切换整页布局,内层组件用容器查询自适应自己的容器。

使用容器查询前请查 <https://caniuse.com/container-queries> 确认目标浏览器支持情况,并为不支持的浏览器保留可用的默认样式。

相关笔记

  • 前端-02-CSS基础 —— 本篇的前置:选择器、特异性、盒模型与单位决定了布局属性的计算基础。
  • 前端-01-HTML基础 —— 布局的语义前提:header/nav/main/aside/footer 写对了,Grid 的区域命名才能一一对应。
  • 前端-04-浏览器与HTTP —— 布局如何被计算与绘制:渲染流程、重排(reflow)与重绘(repaint)的代价。
  • 前端-09-前端工程化与调试 —— 用 DevTools 的布局面板与性能面板定位布局问题,以及动画性能优化。

参考来源

  • MDN 中文:flex 布局的基本概念(主轴与交叉轴、容器与项目属性的官方讲解)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Flexible_box_layout/Basic_concepts>
  • MDN 中文:网格布局的基本概念(网格线、轨道、区域、fr 与显式/隐式网格)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Grid_layout/Basic_concepts>
  • MDN 中文:position(五种定位值的包含块规则与文档流行为)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Reference/Properties/position>
  • MDN 中文:CSS 定位布局(定位与层叠次序的完整指南)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Positioned_layout>
  • MDN 中文:z-index(层叠上下文的创建条件与层叠顺序)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Reference/Properties/z-index>
  • MDN 中文:掌握外边距折叠(折叠的三种情形与阻止方法)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Box_model/Margin_collapsing>
  • MDN 中文:使用媒体查询(语法、范围写法、逻辑运算符与断点策略)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Media_queries/Using>
  • MDN 中文:CSS 容器查询(container-type、@container 与组件级响应式)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/Guides/Containment/Container_queries>
  • MDN 中文:居中一个元素(Flex / Grid / 定位三种居中方案的官方对照)—— <https://developer.mozilla.org/zh-CN/docs/Web/CSS/How_to/Layout_cookbook/Center_an_element>
  • W3C:CSS Flexible Box Layout Module Level 1(Flexbox 规范:术语、flex 简写展开与布局算法)—— <https://www.w3.org/TR/css-flexbox-1/>
  • W3C:CSS Grid Layout Module Level 1(Grid 规范:轨道尺寸、auto-fit/auto-fill、命名区域与放置算法)—— <https://www.w3.org/TR/css-grid-1/>
  • W3C:CSS Positioned Layout Module Level 3(定位、包含块与层叠顺序的规范定义)—— <https://www.w3.org/TR/css-position-3/>
  • caniuse:容器查询支持情况速查 —— <https://caniuse.com/container-queries>