


文章目录
-
- [一、进一步认识 CSS 盒模型](#一、进一步认识 CSS 盒模型)
-
- [1. content:内容区域](#1. content:内容区域)
- [2. padding:内边距](#2. padding:内边距)
- [3. border:边框](#3. border:边框)
- [4. margin:外边距](#4. margin:外边距)
- 二、盒模型中的四种盒子
-
- 实际尺寸计算
-
- [content box](#content box)
- [padding box](#padding box)
- [border box](#border box)
- [margin box](#margin box)
- [三、padding 和 margin 的简写属性与覆盖关系](#三、padding 和 margin 的简写属性与覆盖关系)
-
- [1. padding 的逐步覆盖过程](#1. padding 的逐步覆盖过程)
- [2. margin 的逐步覆盖过程](#2. margin 的逐步覆盖过程)
- [3. 最终生效的属性值](#3. 最终生效的属性值)
- [四、为什么 margin-top 为 0px,两个元素之间仍然存在距离?](#四、为什么 margin-top 为 0px,两个元素之间仍然存在距离?)
-
- [1. 两个元素分别具有独立的盒模型](#1. 两个元素分别具有独立的盒模型)
- [2. 两个不同元素的 margin 之间没有选择器优先级冲突](#2. 两个不同元素的 margin 之间没有选择器优先级冲突)
- [五、外边距折叠(Margin Collapse)](#五、外边距折叠(Margin Collapse))
-
- [1. 为什么两个外边距不一定直接相加?](#1. 为什么两个外边距不一定直接相加?)
- [2. 外边距折叠会修改元素原本的属性值吗?](#2. 外边距折叠会修改元素原本的属性值吗?)
- 六、外边距折叠的具体计算规则
-
- [1. 外边距均为非负数](#1. 外边距均为非负数)
- [2. 同时存在正外边距与负外边距](#2. 同时存在正外边距与负外边距)
- [3. 外边距全部为负数](#3. 外边距全部为负数)
- 七、如何通过代码实验验证外边距折叠?
- [八、为什么 padding 不会发生外边距折叠现象?](#八、为什么 padding 不会发生外边距折叠现象?)
- 九、外边距折叠的适用条件与边界
-
- [1. 普通文档流中的相邻块级元素](#1. 普通文档流中的相邻块级元素)
- [2. 水平方向的外边距](#2. 水平方向的外边距)
- [3. Flex 布局](#3. Flex 布局)
- [4. Grid 布局](#4. Grid 布局)
- [5. 父子元素之间](#5. 父子元素之间)
- [十、行内 style 属性如何同时设置多个 CSS 样式?](#十、行内 style 属性如何同时设置多个 CSS 样式?)
-
- [1. 正确的书写方式](#1. 正确的书写方式)
- [2. 为什么原来的代码没有成功设置宽度和边框?](#2. 为什么原来的代码没有成功设置宽度和边框?)
- [3. 为什么浏览器显示 1520 × 200?](#3. 为什么浏览器显示 1520 × 200?)
- [4. 行内样式可以换行编写](#4. 行内样式可以换行编写)
- [5. 行内样式与内部样式的关系](#5. 行内样式与内部样式的关系)
- [十一、HTML 元素之间的父子关系与盒模型嵌套](#十一、HTML 元素之间的父子关系与盒模型嵌套)
-
- [1. 父元素的 content 区域是否等于子元素的 margin box?](#1. 父元素的 content 区域是否等于子元素的 margin box?)
- [2. 父元素内部的布局空间与子元素完整区域](#2. 父元素内部的布局空间与子元素完整区域)
- [十二、通过 html、head、body 和 div 观察多层盒模型](#十二、通过 html、head、body 和 div 观察多层盒模型)
-
- [1. HTML 文档的元素结构](#1. HTML 文档的元素结构)
- [2. 不同颜色边框所对应的元素](#2. 不同颜色边框所对应的元素)
- [3. 为什么 head 元素也能够显示出来?](#3. 为什么 head 元素也能够显示出来?)
- [4. div 最终采用的是哪组 margin?](#4. div 最终采用的是哪组 margin?)
- [十三、父元素的 content 区域一定能够容纳全部子元素吗?](#十三、父元素的 content 区域一定能够容纳全部子元素吗?)
- [十四、重新建立对 CSS 元素整体空间关系的认识](#十四、重新建立对 CSS 元素整体空间关系的认识)
-
- [1. 关于元素自身的整体区域](#1. 关于元素自身的整体区域)
- [2. 关于父元素与子元素的关系](#2. 关于父元素与子元素的关系)
- [十五、区分 CSS 中三个不同层次的机制](#十五、区分 CSS 中三个不同层次的机制)
-
- [第一层:HTML 结构与选择器匹配](#第一层:HTML 结构与选择器匹配)
- [第二层:CSS 层叠与属性值确定](#第二层:CSS 层叠与属性值确定)
- [第三层:CSS 布局与空间计算](#第三层:CSS 布局与空间计算)
一、进一步认识 CSS 盒模型
HTML 元素在浏览器中进行布局时,通常会生成相应的 CSS 盒子。
一个普通的 CSS 盒子,从内到外可以划分为四个区域:
- content:内容区域
- padding:内边距
- border:边框
- margin:外边距
这四个区域之间的关系可以表示为:
1. content:内容区域
内容区域是元素内部用于承载文本、子元素等内容的布局区域。
例如:
html
<div>我是一个div</div>
其中的文字就在 div 的内容区域中进行布局。
在默认的 box-sizing: content-box 模式下:
css
div {
width: 500px;
height: 100px;
}
设置的 width 和 height 指内容区域的宽度和高度,并不包含 padding、border 和 margin。
2. padding:内边距
padding 位于内容区域与边框之间,用于控制内容与边框之间的距离。
例如:
css
div {
padding: 30px 50px;
}
表示:
上内边距:30px
右内边距:50px
下内边距:30px
左内边距:50px
设置内边距后,内容与边框之间就会产生相应的内部空间。
3. border:边框
border 位于 padding 的外部,围绕元素的内容区域和内边距区域。
例如:
css
div {
border: 10px solid red;
}
表示四个方向的边框均为宽度 10px 的红色实线。
4. margin:外边距
margin 位于边框的外部,用于参与元素外部的空间布局。
例如:
css
div {
margin: 30px;
}
表示元素的四个方向均设置了 30px 的外边距。
需要注意,元素自身的外边距属性值与该元素和其他元素之间最终形成的实际距离不是同一个概念。
在某些布局条件下,多个元素的外边距可能发生折叠。
二、盒模型中的四种盒子
除了将盒模型划分为四个区域外,还可以根据不同的外部边界,将其划分为四种盒子。
| 盒子名称 | 包含的区域 |
|---|---|
| content box(内容盒) | content |
| padding box(内边距盒) | content + padding |
| border box(边框盒) | content + padding + border |
| margin box(外边距盒) | content + padding + border + margin |
这里需要区分 padding 区域与 padding box。
padding 仅指内边距本身,而 padding box 包含内容区域和内边距区域。
同理,margin 仅指外边距,margin box 则以外边距的外缘作为整个盒子的边界。
实际尺寸计算
假设 CSS 如下:
css
div {
width: 500px;
height: 100px;
padding: 30px 50px;
border: 10px solid red;
margin: 30px;
}
在默认 box-sizing: content-box 的条件下:
content box
宽度:500px
高度:100px
padding box
宽度:500 + 50 + 50 = 600px
高度:100 + 30 + 30 = 160px
border box
宽度:600 + 10 + 10 = 620px
高度:160 + 10 + 10 = 180px
margin box
宽度:620 + 30 + 30 = 680px
高度:180 + 30 + 30 = 240px
因此,这四种盒子的尺寸分别为:
| 盒子 | 宽度 | 高度 |
|---|---|---|
| content box | 500px | 100px |
| padding box | 600px | 160px |
| border box | 620px | 180px |
| margin box | 680px | 240px |
通过这组计算可以理解,同一个元素的不同盒子具有不同的尺寸。
但是,margin box 的尺寸并不一定等于元素在页面布局中独立占据的空间,因为相邻元素的外边距可能发生折叠,多个外边距可能共同形成一段空间。
三、padding 和 margin 的简写属性与覆盖关系
在实际练习中,编写了如下 CSS:
css
div {
width: 500px;
height: 100px;
border: red solid 10px;
padding: 10px;
padding-left: 20px;
padding: 30px 50px;
margin: 10px;
margin-top: 0px;
}
这里需要结合此前学习的 CSS 层叠规则,分析每一条声明的作用,以及最终实际生效的属性值。
1. padding 的逐步覆盖过程
第一条声明:
css
padding: 10px;
将四个方向的内边距都设置为 10px。
第二条声明:
css
padding-left: 20px;
单独将左内边距修改为 20px。
此时:
上:10px
右:10px
下:10px
左:20px
第三条声明:
css
padding: 30px 50px;
重新设置全部四个方向的内边距。
最终:
上:30px
右:50px
下:30px
左:50px
此前的 padding-left: 20px 也被后面的简写声明覆盖。
因为 padding 作为简写属性,可以同时设置四个方向对应的子属性。
2. margin 的逐步覆盖过程
第一条声明:
css
margin: 10px;
设置四个方向的外边距均为 10px。
第二条声明:
css
margin-top: 0px;
只修改上外边距。
因此最终为:
上:0px
右:10px
下:10px
左:10px
3. 最终生效的属性值
| 方向 | padding | border | margin |
|---|---|---|---|
| 上 | 30px | 10px | 0px |
| 右 | 50px | 10px | 10px |
| 下 | 30px | 10px | 10px |
| 左 | 50px | 10px | 10px |
这些属性值可以通过浏览器开发者工具中的盒模型示意图查看。
例如:
四、为什么 margin-top 为 0px,两个元素之间仍然存在距离?
这是本轮盒模型实验中的一个核心疑问。
HTML:
html
<div class="font32">我是一个div,class为font32</div>
<div class="font32">我是一个div,class为font32</div>
<div><a href="#">我是一个div</a></div>
<span>span111</span>
CSS:
css
div {
width: 500px;
height: 100px;
border: 10px solid red;
padding: 30px 50px;
margin: 10px;
margin-top: 0px;
}
实际观察到:
- 第二个
div的margin-top在开发者工具中显示为 0px。 - 但是第一个
div和第二个div之间仍然存在 10px 左右的间距。
这是否说明第二个 div 的 margin-top: 0px 没有成功实现?
1. 两个元素分别具有独立的盒模型
第一个 div 具有:
css
margin-bottom: 10px;
第二个 div 具有:
css
margin-top: 0px;
它们之间的空间关系如下:
margin-top: 0px 只表示第二个元素自身的上外边距为 0px。
它不能取消第一个元素的下外边距,也不要求两个元素必须紧贴在一起。
因此:
- 第一个元素的
margin-bottom: 10px已经生效。 - 第二个元素的
margin-top: 0px也已经生效。 - 两个元素的边框之间仍然存在 10px 的距离。
2. 两个不同元素的 margin 之间没有选择器优先级冲突
此前学习的 CSS 选择器优先级,主要用于解决同一个元素、同一个属性上的多个样式声明之间的竞争。
例如:
css
div {
margin-top: 10px;
margin-top: 0px;
}
这里两条声明作用于同一个元素的同一个属性,因此需要按照层叠规则确定最终值。
但是:
html
<div style="margin-bottom: 10px;">第一个div</div>
<div style="margin-top: 0px;">第二个div</div>
这里的两个属性属于不同元素。
它们可以同时生效,不需要判断哪个元素的 CSS 选择器优先级更高。
浏览器需要另外通过布局规则,确定这两个元素之间的实际距离。
这就涉及 CSS 的外边距折叠机制。
五、外边距折叠(Margin Collapse)
外边距折叠,也称为外边距合并,是 CSS 正常流布局中的一种空间计算机制。
在普通文档流中,当相邻块级元素的垂直外边距满足折叠条件时,这些外边距可以合并成一个外边距。
1. 为什么两个外边距不一定直接相加?
例如:
html
<div style="margin-bottom: 10px;">
第一个div
</div>
<div style="margin-top: 20px;">
第二个div
</div>
如果两个外边距分别占据独立空间,那么两个元素之间的距离应为:
10px + 20px = 30px
但在发生外边距折叠的情况下,两个非负外边距合并后取最大值:
max(10px, 20px) = 20px
因此实际间距为 20px。
可以通过以下示意图区分两种布局情况:
这里的"重合"是帮助理解两个外边距共同参与间距计算的空间示意。
2. 外边距折叠会修改元素原本的属性值吗?
不会。
例如:
css
margin-bottom: 10px;
仍然是第一个元素自身的下外边距。
css
margin-top: 20px;
仍然是第二个元素自身的上外边距。
即使最终间距是 20px,也不意味着浏览器把第一个元素的 margin-bottom 修改成了 20px,或者删除了其中一个元素的外边距声明。
外边距折叠发生在布局过程中,用于确定多个外边距共同形成的实际空间。
因此,需要区分:
元素自身的 CSS 属性值
↓
浏览器根据布局规则进行计算
↓
元素之间最终形成的实际距离
六、外边距折叠的具体计算规则
1. 外边距均为非负数
当多个参与折叠的外边距都为非负数时,取其中的最大值。
例如:
| 上方元素的 margin-bottom | 下方元素的 margin-top | 折叠结果 |
|---|---|---|
| 10px | 0px | 10px |
| 10px | 10px | 10px |
| 10px | 20px | 20px |
| 30px | 20px | 30px |
| 0px | 0px | 0px |
因此:
折叠后的间距 = max(参与折叠的非负外边距)
2. 同时存在正外边距与负外边距
CSS 的 margin 允许设置负值。
当参与折叠的外边距同时存在正数和负数时,将最大的正外边距与最小的负外边距相加。
例如:
20px 和 -10px
折叠结果:20 + (-10) = 10px
再例如:
20px 和 -30px
折叠结果:20 + (-30) = -10px
如果最终结果是负数,元素之间可能发生进一步的靠近,甚至出现边框盒重叠。
3. 外边距全部为负数
取其中最小的负数。
例如:
-10px 和 -20px
折叠结果:-20px
可以用以下表格复习:
| 外边距 A | 外边距 B | 折叠结果 |
|---|---|---|
| 10px | 20px | 20px |
| 20px | -10px | 10px |
| 20px | -30px | -10px |
| -10px | -20px | -20px |
以上计算均以这些外边距确实满足折叠条件为前提。
七、如何通过代码实验验证外边距折叠?
最初的实验中:
第一个 div 的 margin-bottom:10px
第二个 div 的 margin-top:0px
如果发生折叠:
max(10, 0) = 10px
如果不发生折叠:
10 + 0 = 10px
两种计算方式都会得到相同的结果。
所以,仅凭观察到 10px 的间距,并不能单独验证外边距折叠是否发生。
可以修改实验,让两种机制产生不同结果。
实验一:相同的正外边距
html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Margin Collapse</title>
<style>
div {
width: 300px;
height: 100px;
border: 5px solid red;
margin: 10px;
}
</style>
</head>
<body>
<div>第一个div</div>
<div>第二个div</div>
</body>
</html>
两个相邻 div 分别提供 10px 的垂直外边距。
普通文档流中发生折叠时,预期实际间距为:
max(10, 10) = 10px
而不会直接相加成为 20px。
实验二:不同的正外边距
html
<div style="
height: 100px;
border: 5px solid red;
margin-bottom: 10px;
">
第一个div
</div>
<div style="
height: 100px;
border: 5px solid red;
margin-top: 30px;
">
第二个div
</div>
发生折叠时,预期结果为:
max(10, 30) = 30px
如果在这两个独立外边距之间不存在折叠或其他额外布局影响,则间距为:
10 + 30 = 40px
通过这种对照实验,可以更加明显地观察折叠与不折叠的区别。
以上两个扩展实验是用于进一步验证机制的示例,并非已经取得的新浏览器运行结果。
八、为什么 padding 不会发生外边距折叠现象?
padding 与 margin 在盒模型中承担不同职责。
padding 位于元素边框内部,属于每个盒子自身的内部空间。
margin 位于元素边框外部,参与元素之间的空间布局。
例如:
css
div {
padding: 30px;
border: 10px solid red;
margin: 10px;
}
两个相邻 div 的空间关系为:
两个元素分别拥有自己的内容区域、内边距和边框。
它们的 padding 不会因为彼此相邻而折叠。
所以,在原来的实验中,每个 div 的上下 30px、左右 50px 的内边距都能够独立存在。
九、外边距折叠的适用条件与边界
外边距折叠并不是所有 CSS 布局中的统一规则。
1. 普通文档流中的相邻块级元素
在普通的块级布局中,相邻块级元素的垂直外边距满足条件时可以发生折叠。
例如:
<div>第一个div</div>
<div>第二个div</div>
即使两个 div 都具有独立的 border 和 padding,也不会仅仅因为存在这些内部区域,就阻止两个兄弟元素之间的外边距折叠。
2. 水平方向的外边距
普通水平方向的:
margin-left
margin-right
不会发生上述垂直外边距折叠。
因此不能把垂直外边距的最大值计算规则直接套用到水平方向。
3. Flex 布局
在 Flex 布局中,flex 子项之间的外边距不会发生折叠。
例如:
css
.parent {
display: flex;
flex-direction: column;
}
即使子元素在垂直方向排列,flex 子项之间也不会采用普通块级元素的外边距折叠规则。
4. Grid 布局
Grid 布局中的 grid 子项之间同样不会发生外边距折叠。
5. 父子元素之间
满足特定条件时,父元素与子元素的垂直外边距也可能发生折叠。
但父子元素之间的折叠条件与相邻兄弟元素之间的情况有所区别。
本轮主要研究了相邻块级元素之间的折叠机制。父子元素折叠的完整条件、特殊布局格式化上下文等机制尚未系统展开。
十、行内 style 属性如何同时设置多个 CSS 样式?
HTML 元素可以通过行内 style 属性直接设置 CSS 样式。
例如:
html
<p style="color: red;">
一个文本
</p>
如果需要同时设置多个 CSS 属性,需要将这些声明写在同一个 style 属性值中。
1. 正确的书写方式
html
<div style="height: 200px; width: 300px; border: 10px solid red;">
一个div
</div>
这里:
style
是 HTML 属性的名称。
双引号内部的整体文本是这个 HTML 属性的值。
其中包含三条独立的 CSS 声明:
css
height: 200px;
width: 300px;
border: 10px solid red;
每条 CSS 声明的基本结构为:
属性名: 属性值;
多条声明之间通过分号进行分隔。
2. 为什么原来的代码没有成功设置宽度和边框?
错误写法类似于:
html
<div style="height: 200px";"width: 300px";"soild";"red";>
一个div
</div>
主要存在以下问题。
首先:
css
style="height: 200px"
后面的双引号已经结束了 style 属性值。
因此,写在后面的 width: 300px 并不属于该 style 属性。
其次:
solid
red
只是 CSS 属性值的组成部分,不能直接作为两条独立的 CSS 声明。
它们需要与相应的属性名建立关系。
例如:
css
border-style: solid;
border-color: red;
或者使用简写:
css
border: 10px solid red;
最后,soild 是错误拼写,正确的实线边框样式值为:
solid
3. 为什么浏览器显示 1520 × 200?
原实验的开发者工具中显示内容区域约为:
1520 × 200
其中,高度 200px 来源于成功读取的:
css
height: 200px;
但是宽度没有通过行内样式成功设置。
普通 div 默认具有:
css
display: block;
当宽度保持 auto 时,在当前普通块级布局条件下,元素的宽度通常会根据父容器可用的水平空间进行计算。
因此它可以占据远大于 300px 的宽度。
这也解释了为什么原实验中高度设置成功了,但宽度与边框都没有按照预期生效。
4. 行内样式可以换行编写
当 CSS 属性较多时,可以在同一对引号内换行:
html
<div style="
height: 200px;
width: 300px;
border: 10px solid red;
padding: 30px 50px;
margin: 10px;
color: blue;
">
一个div
</div>
这种写法依然是合法的 HTML 行内样式。
5. 行内样式与内部样式的关系
行内样式:
html
<div style="
width: 300px;
height: 200px;
">
一个div
</div>
内部样式:
html
<style>
div {
width: 300px;
height: 200px;
}
</style>
两种方式内部的 CSS 声明语法相同。
但是,行内样式已经通过 HTML 元素自身的 style 属性确定了具体作用对象,因此不需要再使用 CSS 选择器,也不需要使用大括号包裹声明。
十一、HTML 元素之间的父子关系与盒模型嵌套
HTML 文档中的元素可以形成父子层级关系。
例如:
html
<div class="parent">
<div class="child">我是子元素</div>
</div>
对应的元素结构为:
div.parent
└── div.child
父元素和子元素都可以生成自己的 CSS 盒子。
因此,每个盒子分别拥有:
content
padding
border
margin
当子元素在父元素的正常文档流中进行布局时,通常以父元素的 content 区域作为相应的布局空间。
可以通过以下嵌套关系理解:
父元素 margin
└── 父元素 border
└── 父元素 padding
└── 父元素 content
│
├── 子元素 margin
│ └── 子元素 border
│ └── 子元素 padding
│ └── 子元素 content
│
└── 其他内容或剩余空间

这时,子元素虽然位于父元素内部,但仍然具有独立的盒模型。
1. 父元素的 content 区域是否等于子元素的 margin box?
不能直接将两者画上等号。
父元素的 content 区域可能用于布局多个子元素,也可能包含普通文本及其他内容。
例如:
html
<div class="parent">
一段文本
<div class="child1">第一个子元素</div>
<div class="child2">第二个子元素</div>
</div>
父元素的内容区域是多个内容对象共同进行布局的空间。
它不一定恰好等于任何一个子元素的完整盒模型区域。
即使父元素只有一个子元素,也可能因为父元素具有明确的宽高,而留有额外空白空间。
2. 父元素内部的布局空间与子元素完整区域
在普通文档流、外边距没有发生跨边界折叠、子元素也没有发生溢出的情况下,可以直观地理解为:
父元素 content
┌────────────────────────────┐
│ │
│ 子元素 margin box │
│ ┌────────────────────┐ │
│ │ │ │
│ │ 子元素完整盒子 │ │
│ │ │ │
│ └────────────────────┘ │
│ │
│ 剩余布局空间 │
│ │
└────────────────────────────┘
父元素的 content 可以包含子元素的完整外边距盒,但"包含"并不代表两个区域的大小完全相等。
此外,父元素的 content 也不一定能将子元素的所有区域限制在内部。
十二、通过 html、head、body 和 div 观察多层盒模型
本轮进行了一个特殊的 HTML 页面实验,分别为 html、head、body 和 div 设置不同颜色的边框,以观察元素之间的空间层级关系。
原实验代码:
html
<!DOCTYPE html>
<html lang="en" style="
border: blue solid 20px;
margin: 40px;
padding: 60px;
">
<head style="
display: block;
border: black 30px solid;
margin: 20px;
padding: 30px;
width: 50px;
height: 80px;
">
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, initial-scale=1.0">
<title>Document</title>
<style>
div {
width: 500px;
height: 100px;
border: red solid 10px;
padding: 10px;
padding-left: 20px;
padding: 30px 50px;
margin: 10px;
margin-top: 0px;
margin: 20px auto;
margin: 30px;
}
</style>
</head>
<body style="
padding: 100px;
margin: 200px;
border: 50px solid green;
">
<div class="font32">我是一个div,class为font32</div>
<div class="font32">我是一个div,class为font32</div>
<div><a href="#">我是一个div</a></div>
<span>span111</span>
</body>
</html>
1. HTML 文档的元素结构
上述 HTML 的元素树为:
html
├── head
│ ├── meta
│ ├── meta
│ ├── title
│ └── style
│
└── body
├── div
├── div
├── div
│ └── a
└── span
其中:
html是 HTML 文档的根元素。head和body都是html的直接子元素。- 三个
div和一个span都是body的直接子元素。 a是第三个div的子元素,同时也是body和html的后代元素。
这也可以与之前学习过的直接子元素选择器和后代选择器建立联系。
2. 不同颜色边框所对应的元素
| 元素 | 边框颜色 | 边框宽度 |
|---|---|---|
| html | 蓝色 | 20px |
| head | 黑色 | 30px |
| body | 绿色 | 50px |
| div | 红色 | 10px |
通过不同颜色的边框,可以在页面中区分多个元素分别对应的边框盒。
其空间关系大致可以表示为:
这个示意图仅用于观察元素的嵌套关系,并不表示各区域的真实比例或要求所有元素必然完全位于父元素的边界以内。
3. 为什么 head 元素也能够显示出来?
通常情况下,HTML 的 head 元素不会生成可见的布局盒子。
它主要用于包含网页元数据、标题、样式及其他文档配置信息。
本实验主动为 head 设置:
css
display: block;
因此 head 生成了块级盒子。
再结合:
css
border: black 30px solid;
margin: 20px;
padding: 30px;
width: 50px;
height: 80px;
就能够在页面中看到一个具有黑色边框的区域。
这是一种用于观察 CSS 盒模型的特殊实验写法。
通常网页开发不需要为了显示页面内容而主动将 head 设置成可见块级元素。
4. div 最终采用的是哪组 margin?
实验中写了多次外边距声明:
css
margin: 10px;
margin-top: 0px;
margin: 20px auto;
margin: 30px;
这些声明位于同一个规则块中,具有相同的层叠条件。
最后一条:
css
margin: 30px;
重新设置了四个方向的外边距。
因此,最终结果为:
css
margin-top: 30px
margin-right: 30px
margin-bottom: 30px
margin-left: 30px
此前的 margin-top: 0px 和 margin: 20px auto 都被覆盖了。
结合最终生效的其他声明:
css
div {
width: 500px;
height: 100px;
border: 10px solid red;
padding: 30px 50px;
margin: 30px;
}
在默认 content-box 下,该 div 的边框盒为 620px × 180px,外边距盒为 680px × 240px。
十三、父元素的 content 区域一定能够容纳全部子元素吗?
父元素具有自己的尺寸设置,子元素也具有自己的尺寸设置。
两者共同参与浏览器的布局计算,但子元素不一定能够完全放入父元素的 content 区域。
例如:
html
<div style="
width: 300px;
height: 100px;
border: 5px solid green;
">
<div style="
width: 400px;
height: 50px;
border: 5px solid red;
">
子元素
</div>
</div>
父元素的内容宽度为:
300px
子元素的内容宽度为:
400px
子元素还具有左右各 5px 的边框。
因此子元素的边框盒宽度为:
5 + 400 + 5 = 410px
子元素的边框盒已经超过父元素的内容宽度。
空间关系可以表示为:

这涉及 CSS 的溢出(Overflow)现象。
在默认的:
css
overflow: visible;
以及当前普通块级布局条件下,子元素可以超出父元素的区域并继续显示。
父元素明确设置的宽度也不会仅仅因为子元素更宽,就必然自动增大来容纳它。
需要区分父元素具有明确尺寸与采用自动尺寸的情况,具体结果还要受到布局方式等其他条件的影响。
本轮只研究了子元素可以超出父元素这一基本机制,尚未完整学习 overflow 的各个属性值及其布局行为。
十四、重新建立对 CSS 元素整体空间关系的认识
学习过程中,曾形成以下直观理解:
每一个元素的整体区域是包括最外层 margin 的整块区域,每个元素的最内层区域就是它的子标签的整块区域。
这一理解需要从盒模型与父子元素布局两个角度分别完善。
1. 关于元素自身的整体区域
对于一个普通 CSS 盒子,从内到外可以划分为:
content → padding → border → margin
如果以最外层外边距的边界来确定整个盒子的范围,这个盒子称为 margin box。
但是,margin box 不一定等于元素在页面中独立占据的布局空间。
例如,两个相邻块级元素的 margin 可能发生折叠,因此两个元素的外边距不一定分别占用互不重合的空间。
另外,HTML 元素与 CSS 布局盒子也并非在所有情况下都严格一一对应。例如默认隐藏的 head 通常不生成可见布局盒子。
2. 关于父元素与子元素的关系
父元素的 content 区域通常为正常文档流中的子元素提供布局空间。
子元素本身又具有独立的 CSS 盒模型。
但父元素的 content 与子元素的 margin box 不一定大小相同,也不保证子元素始终完全位于父元素的 content 区域内。
可能存在:
- 父元素具有多个子元素。
- 父元素包含普通文本。
- 父元素内部存在额外空白空间。
- 父子元素之间发生外边距折叠。
- 子元素的尺寸超过父元素可用的内容空间,产生溢出。
因此,可以将最终的理解表述为:
普通 CSS 盒子具有从 content 到 margin 的四层空间结构。父元素的内容区域通常为子元素提供布局空间,而子元素具有各自独立的盒模型。父子元素之间的实际空间关系,需要结合各自的尺寸、外边距以及具体布局机制确定。
十五、区分 CSS 中三个不同层次的机制
通过本轮及此前的 CSS 实验,可以进一步区分三个相互关联但各自独立的机制。
第一层:HTML 结构与选择器匹配
例如:
body > div
用于确定规则匹配哪些 HTML 元素。
它解决的是样式作用对象的问题。
第二层:CSS 层叠与属性值确定
例如:
css
div {
margin: 10px;
margin-top: 0px;
}
CSS 层叠机制确定最终采用哪些属性值。
得到:
css
margin-top: 0px
margin-right: 10px
margin-bottom: 10px
margin-left: 10px
它解决的是每个元素具体采用什么样式的问题。
第三层:CSS 布局与空间计算
浏览器根据各个元素的属性值和相应的布局规则,对盒子的尺寸、位置和空间关系进行计算。
其中可能涉及:
- 内容区域的宽高计算。
- 内边距和边框对盒子尺寸的影响。
- 相邻元素之间的外边距折叠。
- 父子元素之间的空间关系。
- 子元素超出父元素时的溢出行为。
因此,完整关系可以表示为:
HTML 元素结构
↓
CSS 选择器匹配
↓
CSS 层叠与属性值确定
↓
CSS 盒模型与布局计算
↓
元素的实际尺寸、位置及空间关系
↓
浏览器的最终显示
例如,即使已经确定两个元素分别具有 10px 和 20px 的垂直外边距,仍然需要通过具体布局规则,判断最终间距应为 20px 还是在简单不折叠条件下的 30px。
这也是为什么单独掌握 CSS 选择器优先级,还不足以解释页面中的所有视觉现象。
