CSS基础知识(一):选择器、优先级、层叠与继承、边框属性及盒模型

文章目录

    • [一、CSS 选择器的匹配机制](#一、CSS 选择器的匹配机制)
      • [1. 后代选择器:空格](#1. 后代选择器:空格)
      • [2. 子元素选择器:大于号 `>`](#2. 子元素选择器:大于号 >)
      • [3. 空格与 `>` 的区别](#3. 空格与 > 的区别)
    • [二、CSS 选择器优先级的计算](#二、CSS 选择器优先级的计算)
      • [1. 为什么 `li a` 是 `(0,0,2)`?](#1. 为什么 li a 是 (0,0,2)?)
      • [2. 为什么 `ul li a` 是 `(0,0,3)`?](#2. 为什么 ul li a 是 (0,0,3)?)
      • [3. 不同类型的选择器怎样累加?](#3. 不同类型的选择器怎样累加?)
      • [4. 三个数字怎样比较大小?](#4. 三个数字怎样比较大小?)
    • [三、实际实验:为什么链接 `222` 显示亮绿色?](#三、实际实验:为什么链接 222 显示亮绿色?)
      • [1. 判断三个选择器是否匹配](#1. 判断三个选择器是否匹配)
      • [2. 计算优先级](#2. 计算优先级)
      • [3. 改变三条 CSS 的书写顺序](#3. 改变三条 CSS 的书写顺序)
    • [四、CSS 属性继承的机制](#四、CSS 属性继承的机制)
      • [1. 继承可以经过多个层级](#1. 继承可以经过多个层级)
      • [2. 为什么 `222` 没有继承紫色?](#2. 为什么 222 没有继承紫色?)
      • [3. 颜色属性的继承不等于所有 CSS 属性都会继承](#3. 颜色属性的继承不等于所有 CSS 属性都会继承)
    • [五、为什么注释掉所有链接颜色后,`222` 仍然是蓝色?](#五、为什么注释掉所有链接颜色后,222 仍然是蓝色?)
      • [1. 浏览器默认样式表](#1. 浏览器默认样式表)
      • [2. 默认样式与继承如何共同作用?](#2. 默认样式与继承如何共同作用?)
      • [3. 怎样强制 `a` 使用父元素颜色?](#3. 怎样强制 a 使用父元素颜色?)
    • [六、CSS 规则的先后顺序什么时候发挥作用?](#六、CSS 规则的先后顺序什么时候发挥作用?)
      • [1. 后写的规则不一定获胜](#1. 后写的规则不一定获胜)
      • [2. `ol > li` 和 `ol li` 同时出现](#2. ol > li 和 ol li 同时出现)
    • [七、CSS 外部、内部、行内样式如何决定优先级?](#七、CSS 外部、内部、行内样式如何决定优先级?)
      • [1. 外部样式表](#1. 外部样式表)
      • [2. 内部样式表](#2. 内部样式表)
      • [3. 行内样式](#3. 行内样式)
      • [4. 为什么实验最终显示红色?](#4. 为什么实验最终显示红色?)
      • [5. 外部样式和内部样式有固定高低吗?](#5. 外部样式和内部样式有固定高低吗?)
      • [6. 为什么不建议把这种机制叫作"就近原则"?](#6. 为什么不建议把这种机制叫作“就近原则”?)
    • [八、CSS 层叠机制与 `!important`](#八、CSS 层叠机制与 !important)
      • [1. 层叠规则的整体关系](#1. 层叠规则的整体关系)
      • [2. `!important` 的作用](#2. !important 的作用)
    • [九、CSS 边框属性 `border` 的基本结构](#九、CSS 边框属性 border 的基本结构)
    • [十、为什么 `border: green solid 400px 400px` 无效?](#十、为什么 border: green solid 400px 400px 无效?)
      • [1. `border` 只能接受一个宽度分量](#1. border 只能接受一个宽度分量)
      • [2. CSS 无效声明怎样处理?](#2. CSS 无效声明怎样处理?)
      • [3. 为什么截图中重新出现彩色边框?](#3. 为什么截图中重新出现彩色边框?)
    • [十一、`border-width` 如何分别设置四个方向?](#十一、border-width 如何分别设置四个方向?)
      • [1. 一个值](#1. 一个值)
      • [2. 两个值](#2. 两个值)
      • [3. 三个值](#3. 三个值)
      • [4. 四个值](#4. 四个值)
      • [5. 怎样正确设置上下 200px、左右 400px?](#5. 怎样正确设置上下 200px、左右 400px?)
    • [十二、`border-style` 和 `border-color` 的方向规则](#十二、border-style 和 border-color 的方向规则)
      • [1. 分别设置四条边的样式](#1. 分别设置四条边的样式)
      • [2. 结合宽度、样式和颜色](#2. 结合宽度、样式和颜色)
    • [十三、同一个 CSS 属性被反复声明时,为什么最终只采用某些值?](#十三、同一个 CSS 属性被反复声明时,为什么最终只采用某些值?)
      • [1. 简写属性与单边属性之间的关系](#1. 简写属性与单边属性之间的关系)
      • [2. `border` 简写属性的覆盖范围更大](#2. border 简写属性的覆盖范围更大)
    • [十四、为什么 400px 绿色边框会产生一大片绿色区域?](#十四、为什么 400px 绿色边框会产生一大片绿色区域?)
      • [1. CSS 盒模型的基本层次](#1. CSS 盒模型的基本层次)
      • [2. 默认 `content-box` 计算规则](#2. 默认 content-box 计算规则)
      • [3. 计算整体宽度](#3. 计算整体宽度)
      • [4. 计算整体高度](#4. 计算整体高度)
      • [5. 为什么中间是白色?](#5. 为什么中间是白色?)
      • [6. 为什么浏览器页面还可能出现滚动条?](#6. 为什么浏览器页面还可能出现滚动条?)
    • [十五、`span` 边框实验与 `div` 的区别](#十五、span 边框实验与 div 的区别)
    • 十六、将整轮实验串起来:浏览器如何确定最终显示结果?
      • [实验 A:`ol li` 与 `ol > li`](#实验 A:ol li 与 ol > li)
      • [实验 B:三个选择器都修饰 `222`](#实验 B:三个选择器都修饰 222)
      • [实验 C:`ol > li` 设置紫色](#实验 C:ol > li 设置紫色)
      • [实验 D:外部、内部、行内颜色冲突](#实验 D:外部、内部、行内颜色冲突)
      • [实验 E:无效的 `border` 声明](#实验 E:无效的 border 声明)
      • [实验 F:合法的 400px 边框](#实验 F:合法的 400px 边框)
    • 十七、复习时的分析方法
      • [1. 如果是颜色不符合预期](#1. 如果是颜色不符合预期)
      • [2. 如果是边框不符合预期](#2. 如果是边框不符合预期)
      • [3. 如果是元素尺寸不符合预期](#3. 如果是元素尺寸不符合预期)

一、CSS 选择器的匹配机制

CSS 选择器用于确定一条样式规则作用于哪些 HTML 元素。浏览器首先根据选择器和 HTML 文档的元素结构判断哪些元素匹配,再决定相应样式声明能否生效。

1. 后代选择器:空格

css 复制代码
ol li {
    color: blue;
}

ol li 是后代选择器,表示匹配处于 ol 元素内部的所有后代 li 元素。

这里的"后代"包括直接子元素,也包括更深层级的元素。

例如:

html 复制代码
<ol>
    <li>苹果</li>
    <li>香蕉</li>
    <li>
        水果分类
        <ul>
            <li>草莓</li>
            <li>葡萄</li>
        </ul>
    </li>
</ol>

其元素层级可以表示为:

复制代码
ol
├── li:苹果
├── li:香蕉
└── li:水果分类
    └── ul
        ├── li:草莓
        └── li:葡萄

在这个结构中,五个 li 都是外层 ol 的后代。

因此,ol li 会匹配全部五个 li。

匹配条件是:目标 li 沿着父元素关系向上查找,能够找到一个 ol 祖先元素。

中间可以隔着其他元素。

2. 子元素选择器:大于号 >

css 复制代码
ol > li {
    color: blue;
}

ol > li 是子元素选择器。

它要求 li 的直接父元素必须是 ol。

在上述 HTML 中,它只匹配:

复制代码
ol
├── li:苹果          ← 匹配
├── li:香蕉          ← 匹配
└── li:水果分类      ← 匹配
    └── ul
        ├── li:草莓  ← 不匹配
        └── li:葡萄  ← 不匹配

草莓、葡萄所在的 li,直接父元素是 ul,因此不会被 ol > li 选中。

3. 空格与 > 的区别

选择器 关系要求 允许中间存在其他元素吗
ol li li 是 ol 的后代 允许
ol > li li 是 ol 的直接子元素 不允许

例如:

css 复制代码
ul li a {
    color: green;
}

要求存在这样的祖先关系:

复制代码
ul
└── ... 
    └── li
        └── ...
            └── a

其中的 ... 表示允许出现其他中间元素。

而:

css 复制代码
ul > li > a {
    color: green;
}

要求每一层都是直接父子关系:

复制代码
ul
└── li
    └── a

需要区分两个问题:

  • 选择器匹配哪些 HTML 元素。
  • 哪些文本最终显示为相应颜色。

即使一个选择器没有匹配某个后代元素,该元素仍然可能因为 CSS 属性继承而呈现相同的样式。

二、CSS 选择器优先级的计算

当多条 CSS 规则同时匹配同一个元素,并且声明了相同的属性时,就可能发生样式冲突。

在其他层叠条件相同的情况下,浏览器需要比较选择器的优先级。

CSS 将普通选择器的优先级表示为三个计数分量:

( A , B , C ) (A,B,C) (A,B,C)

三个位置分别统计不同类型的选择器。

位置 选择器类型 每出现一个的贡献
A ID 选择器,例如 #box (1,0,0)
B 类、属性、伪类,例如 .item (0,1,0)
C 标签、伪元素,例如 li、a (0,0,1)

这里的数字 1,表示每出现一个对应类型的选择器,就在对应位置增加 1 。

这三个位置是独立累加的。

1. 为什么 li a 是 (0,0,2)?

css 复制代码
li a {
    color: red;
}

该选择器包含:

复制代码
li → 标签选择器 → (0,0,1)
a  → 标签选择器 → (0,0,1)

因此:

( 0 , 0 , 1 ) + ( 0 , 0 , 1 ) = ( 0 , 0 , 2 ) (0,0,1)+(0,0,1)=(0,0,2) (0,0,1)+(0,0,1)=(0,0,2)

第一位是 0,因为没有 ID 选择器。

第二位是 0,因为没有类、属性或伪类选择器。

第三位是 2,因为存在两个标签选择器。

2. 为什么 ul li a 是 (0,0,3)?

css 复制代码
ul li a {
    color: green;
}

分别拆解:

复制代码
ul → (0,0,1)
li → (0,0,1)
a  → (0,0,1)

合计:

( 0 , 0 , 3 ) (0,0,3) (0,0,3)

这说明 (0,0,1) 只是单个标签选择器的优先级贡献。

多个标签选择器组合后,第三位可以是 2、3、4,甚至更多。

空格、> 本身不贡献优先级。

例如:

css 复制代码
ol li      /* (0,0,2) */
ol > li    /* (0,0,2) */

两者虽然匹配范围不同,但选择器优先级相同。

3. 不同类型的选择器怎样累加?

假设 HTML 为:

html 复制代码
<ul id="menu">
    <li class="item">
        <a href="#">222</a>
    </li>
</ul>

CSS:

css 复制代码
#menu li.item a {
    color: blue;
}

逐个分析:

组成 类型 优先级贡献
#menu ID (1,0,0)
li 标签 (0,0,1)
.item 类 (0,1,0)
a 标签 (0,0,1)

因此最终优先级是:

( 1 , 1 , 2 ) (1,1,2) (1,1,2)

注意 li.item 同时包含一个标签选择器和一个类选择器,必须分别计数。

4. 三个数字怎样比较大小?

CSS 优先级不是简单把三个数字相加。

比较时按照从左向右的顺序进行:

  1. 比较第一位 A。
  2. A 相同,再比较第二位 B。
  3. A、B 都相同,再比较第三位 C。

例如:

( 1 , 0 , 0 ) > ( 0 , 100 , 100 ) (1,0,0)>(0,100,100) (1,0,0)>(0,100,100)

虽然右边的第二、第三位很大,但左边第一位是 1,因此左边更高。

再例如:

( 0 , 1 , 0 ) > ( 0 , 0 , 10 ) (0,1,0)>(0,0,10) (0,1,0)>(0,0,10)

一个类选择器的优先级高于十个标签选择器组合的优先级。

这里的前提是这些规则确实能够匹配同一个元素,而且在样式来源、重要性、层叠层等更前面的层叠判断中处于相同条件。

三、实际实验:为什么链接 222 显示亮绿色?

实验 HTML:

html 复制代码
<ol>
    <li>苹果</li>
    <li>香蕉</li>
    <li>
        水果分类
        <ul>
            <li>草莓</li>
            <li><a href="#">222</a>葡萄</li>
        </ul>
    </li>
</ol>

CSS:

css 复制代码
li a {
    color: rgb(233, 70, 11);
}

ul a {
    color: #008000;
}

ul li a {
    color: rgb(14, 222, 42);
}

首先确定 222 所在的元素:

复制代码
ol
└── li:水果分类
    └── ul
        └── li
            ├── a:222
            └── 文本:葡萄

1. 判断三个选择器是否匹配

li a:

222 所在的 a 有一个 li 祖先,因此匹配。

ul a:

222 所在的 a 有一个 ul 祖先,因此匹配。

ul li a:

222 所在的 a 同时满足 ul、li、a 所描述的后代关系,因此也匹配。

三个选择器都能对同一个 <a> 元素声明 color。

2. 计算优先级

选择器 优先级 颜色
li a (0,0,2) 橙红色
ul a (0,0,2) 深绿色
ul li a (0,0,3) 亮绿色

由于:

( 0 , 0 , 3 ) > ( 0 , 0 , 2 ) (0,0,3)>(0,0,2) (0,0,3)>(0,0,2)

因此,ul li a 的亮绿色声明获胜。

这就是 222 最终显示亮绿色的原因。

3. 改变三条 CSS 的书写顺序

例如:

css 复制代码
ul li a {
    color: rgb(14, 222, 42);
}

ul a {
    color: #008000;
}

li a {
    color: rgb(233, 70, 11);
}

虽然亮绿色规则写在最前面,但它的选择器优先级仍然更高。

因此 222 继续显示亮绿色。

这说明,不能仅根据哪条 CSS 写得靠后,就认定哪条一定生效。

四、CSS 属性继承的机制

CSS 中,有些属性默认可以从父元素继承给子元素。

color 就是其中一种。

例如:

css 复制代码
<div>
    <span>一段文字</span>
</div>
div {
    color: purple;
}

这里直接设置紫色的元素是 div。

span 没有自身生效的颜色声明,因此其 color 可以继承父元素 div 的计算值。

于是文字也显示紫色。

1. 继承可以经过多个层级

再次看水果列表:

html 复制代码
<ol>
    <li>
        水果分类
        <ul>
            <li>草莓</li>
            <li><a href="#">222</a>葡萄</li>
        </ul>
    </li>
</ol>

当 CSS 为:

css 复制代码
ol > li {
    color: purple;
}

颜色可以沿着元素树传递:

复制代码
ol
└── li:水果分类       ← 直接设置 purple
    └── ul             ← 继承 purple
        └── li         ← 继承 purple
            ├── a
            └── 葡萄   ← 作为 li 中的文本显示紫色

ol > li 没有匹配内层 ul 的 li。

但是内层 li 可以通过继承获得紫色。

所以一个元素最终显示紫色,不代表 ol > li 一定直接选中了它。

2. 为什么 222 没有继承紫色?

假设同时存在:

css 复制代码
ol > li {
    color: purple;
}

ul li a {
    color: rgb(14, 222, 42);
}

这里需要分别分析两个元素:

  • 外层 li:直接获得紫色。
  • a:直接获得亮绿色。

color 的继承发生在当前元素没有适用的直接颜色值时。

由于 a 自身已经有直接生效的 color 声明,因此使用亮绿色。

直接生效的属性值与继承值之间,不需要通过比较两个选择器的优先级来决定谁获胜。

因为:

复制代码
ol > li

匹配的是外层 li。

复制代码
ul li a

匹配的是里面的 a。

两条规则作用于不同元素。

选择器优先级比较主要用于决定同一个元素上相互竞争的声明,而不会把祖先的高优先级声明与后代元素的低优先级声明直接拿来比较。

3. 颜色属性的继承不等于所有 CSS 属性都会继承

不同属性的默认继承行为不同。

例如:

css 复制代码
div {
    color: red;
    border: 10px solid green;
}

子元素通常会继承文字颜色。

但是 border 默认不继承。

因此,不能因为父元素具有绿色边框,就推断子元素也会获得相同边框。

是否默认继承,取决于具体 CSS 属性的定义。

五、为什么注释掉所有链接颜色后,222 仍然是蓝色?

实验:

css 复制代码
ol > li {
    color: purple;
}

/*
li a {
    color: rgb(233, 70, 11);
}

ul a {
    color: #008000;
}

ul li a {
    color: rgb(14, 222, 42);
}
*/

观察结果:

  • 水果分类:紫色。
  • 草莓:紫色。
  • 葡萄:紫色。
  • 222:蓝色。

按照普通 color 继承关系,a 有可能继承父元素的紫色。

但浏览器自身还有默认样式表。

1. 浏览器默认样式表

浏览器为了让没有编写 CSS 的 HTML 也具有基本可读性,会提供一组默认样式。

其中包含链接的默认显示方式。

普通浏览器通常会为未访问链接指定蓝色,为已访问链接指定另一种颜色。

可以用下面的示意规则理解:

css 复制代码
a:link {
    color: blue;
}

a:visited {
    color: purple;
}

这只是概念示意,实际颜色与实现可能因浏览器和用户设置而不同。

2. 默认样式与继承如何共同作用?

在实验中:

复制代码
外层 li
    ↓ purple
内层 ul
    ↓ 继承 purple
内层 li
    ↓ 继承 purple
a 元素
    ↓ 浏览器为链接直接提供默认颜色
最终显示蓝色

即使浏览器默认链接样式的来源优先级低于普通作者样式,它仍然能够使 <a> 显示蓝色。

原因是作者的紫色声明只直接作用于祖先 li,并没有直接作用于这个 <a>。

对于 <a> 本身,浏览器默认链接样式提供了直接的 color 声明。

继承值不会因为祖先选择器优先级较高,就自动覆盖后代元素自己的有效声明。

3. 怎样强制 a 使用父元素颜色?

可以使用:

复制代码
a {
    color: inherit;
}

inherit 是 CSS 的属性值关键字。

它表示将当前元素该属性的值明确设置为父元素对应属性的计算值。

例如:

css 复制代码
ol > li {
    color: purple;
}

a {
    color: inherit;
}

在此前其他自定义链接颜色规则都已移除的条件下,222 所在的 a 会使用父元素的紫色。

需要注意:

css 复制代码
a {
    color: inherit;
}

仍然是一条正常参与 CSS 层叠的声明。

如果页面还有更高优先级的:

css 复制代码
ul li a {
    color: green;
}

那么仅仅添加低优先级的 a { color: inherit; },不足以覆盖该绿色声明。

六、CSS 规则的先后顺序什么时候发挥作用?

选择器优先级相同时,源代码中声明的先后顺序可能决定最终结果。

例如:

css 复制代码
li a {
    color: red;
}

ul a {
    color: green;
}

两个选择器的优先级都是:

( 0 , 0 , 2 ) (0,0,2) (0,0,2)

对于水果列表中的 222,两者都匹配。

如果它们来自相同的样式来源、相同的层叠层,并且其他层叠条件相同,那么后面的绿色声明获胜。

交换位置:

css 复制代码
ul a {
    color: green;
}

li a {
    color: red;
}

此时红色声明位于后面,因此最终显示红色。

1. 后写的规则不一定获胜

例如:

css 复制代码
ul li a {
    color: green;
}

a {
    color: red;
}

两个选择器优先级分别为:

复制代码
ul li a → (0,0,3)
a       → (0,0,1)

由于绿色规则优先级更高,所以红色规则即使写在后面,也不会覆盖绿色。

2. ol > li 和 ol li 同时出现

css 复制代码
ol > li {
    color: purple;
}

ol li {
    color: blue;
}

两个选择器都是:

( 0 , 0 , 2 ) (0,0,2) (0,0,2)

对于外层 ol 直接包含的 li,两条规则都能匹配。

如果其他层叠条件相同,后出现的蓝色声明获胜。

对于嵌套在 ul 中的 li,只有 ol li 能够直接匹配,因此同样会获得蓝色。

这个例子说明:

选择器所描述的元素关系是否更直接,不等于选择器优先级是否更高。

> 与空格的区别在于匹配范围。

七、CSS 外部、内部、行内样式如何决定优先级?

CSS 可以通过多种方式提供样式。

1. 外部样式表

创建 demo.css:

css 复制代码
p {
    color: blue;
}

在 HTML 中引入:

css 复制代码
<link rel="stylesheet" href="demo.css">

外部文件里的 p 是一个标签选择器。

其优先级是:

( 0 , 0 , 1 ) (0,0,1) (0,0,1)

2. 内部样式表

在 HTML 的 <style> 中编写:

css 复制代码
<style>
    p {
        color: #0000ff;
    }
</style>

同样使用标签选择器 p。

其优先级也是:

( 0 , 0 , 1 ) (0,0,1) (0,0,1)

3. 行内样式

在 HTML 元素自身的 style 属性中编写:

html 复制代码
<p style="color: red;">一个文本</p>

这是行内样式声明。

它与普通选择器规则的优先级计算有所区别。

行内样式具有特殊的优先地位。

为了方便学习,通常将普通选择器的三位优先级扩展成四位记法:

复制代码
(行内样式位, ID位, 类位, 标签位)

因此:

样式来源与规则 便于比较的四位表示
外部 p (0,0,0,1)
内部 p (0,0,0,1)
行内 style (1,0,0,0)

这种四位表示是学习用的扩展记法。

严格来说,普通选择器的 Specificity 使用三个分量,行内样式的特殊地位由层叠机制处理。

4. 为什么实验最终显示红色?

完整实验:

html 复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS实验</title>

    <link rel="stylesheet" href="demo.css">

    <style>
        p {
            color: #0000ff;
        }
    </style>
</head>
<body>
    <p style="color: red;">一个文本</p>
</body>
</html>

在 demo.css 中:

css 复制代码
p {
    color: blue;
}

这里的三条颜色声明都属于作者编写的样式。

外部与内部的普通声明都针对 p。

行内样式则直接写在元素上。

在这个没有 !important、特殊层叠层等干扰因素的例子中,行内样式优先于另外两条普通声明。

因此文本最终显示红色。

5. 外部样式和内部样式有固定高低吗?

没有。

例如:

html 复制代码
<link rel="stylesheet" href="demo.css">

<style>
    p {
        color: green;
    }
</style>

外部规则:

css 复制代码
p {
    color: blue;
}

如果两条规则在其他层叠条件中相同,那么后出现的内部绿色声明获胜。

交换顺序:

html 复制代码
<style>
    p {
        color: green;
    }
</style>

<link rel="stylesheet" href="demo.css">

外部蓝色声明位于后面,因此蓝色获胜。

所以,外部 CSS 和内部 CSS 不存在仅因为书写方式不同就固定谁高谁低的规则。

6. 为什么不建议把这种机制叫作"就近原则"?

"就近原则"可能混淆不同的概念:

  • 行内样式具有特殊优先地位。
  • 普通选择器存在优先级。
  • 优先级相同时,书写顺序可能决定结果。
  • 父元素的某些属性可以被后代继承。

这些因素分别由不同的 CSS 机制处理。

如果笼统使用"离元素越近,优先级越高"来解释,就无法正确处理以下情况:

css 复制代码
#box {
    color: blue;
}

p {
    color: red;
}

即使第二条规则写得更靠后,当它们匹配同一个元素、其他层叠条件相同,ID 选择器仍然更优先。

CSS 不按照 HTML 元素距离远近来统一计算样式优先级。

八、CSS 层叠机制与 !important

前面分别研究了选择器优先级、继承、行内样式和书写顺序。

这些机制共同参与 CSS 的最终样式确定。

1. 层叠规则的整体关系

对一个指定元素和属性,浏览器需要判断:

  1. 哪些样式声明能够适用于该元素。
  2. 这些声明是否有效。
  3. 声明的来源、重要性和层叠层如何排序。
  4. 适用声明的选择器优先级如何比较。
  5. 在必要时进一步比较作用域接近程度和源代码顺序。
  6. 如果该元素没有适用的声明,再根据属性是否可继承等规则确定值。

其中,第五项涉及 CSS 的作用域机制,不能直接等同于普通 HTML 父子层级的"就近"。

对于当前的基础实验,主要需要理解的情况是普通作者样式之间的竞争。

2. !important 的作用

例如:

css 复制代码
p {
    color: blue !important;
}
<p style="color: red;">一个文本</p>

在这个例子中:

  • 行内红色是普通声明。
  • 蓝色是作者样式中的 !important 声明。

因此,蓝色可以覆盖普通行内红色。

如果行内样式也写成:

html 复制代码
<p style="color: red !important;">
    一个文本
</p>

在与普通作者样式中的重要声明竞争时,行内红色具有更高的优先地位。

完整 CSS 层叠还涉及用户样式、浏览器样式、层叠层、动画和过渡等机制。

因此不能将 !important 解释成在所有条件下都绝对最高。

本轮已经涉及 !important 的基本效果及其边界,但尚未系统展开整个 CSS Cascade 算法。

九、CSS 边框属性 border 的基本结构

CSS 的 border 用于设置元素边框。

边框通常涉及三个属性维度:

  • 宽度:border-width
  • 样式:border-style
  • 颜色:border-color

例如:

css 复制代码
div {
    border: 10px solid red;
}

这是一条简写声明,能够一次设置四条边的宽度、样式和颜色。

等价于统一设置:

css 复制代码
div {
    border-width: 10px;
    border-style: solid;
    border-color: red;
}

其中:

复制代码
10px  → 边框宽度
solid → 实线样式
red   → 边框颜色

border 中这三个分量通常可以交换书写顺序。

例如:

css 复制代码
border: 10px solid red;
border: red solid 10px;
border: solid red 10px;

都能表达同一组设置。

但每一种分量最多只能提供一个有效值。

十、为什么 border: green solid 400px 400px 无效?

实验代码:

html 复制代码
<div
    class="text1"
    style="border: green solid 400px 400px;"
>
    我是文本1
</div>

原本的意图是:上下左右的边框宽度全部设置为 400px。

但这种写法不符合 border 简写属性的语法。

1. border 只能接受一个宽度分量

正确示例:

css 复制代码
border: green solid 400px;

其中 400px 是唯一的宽度值。

它会统一应用于四条边。

错误示例:

css 复制代码
border: green solid 400px 400px;

出现了两个边框宽度值。

border 不支持使用两个宽度值分别控制上下和左右。

因此,这整条声明无效。

2. CSS 无效声明怎样处理?

对于这种语法无效的 CSS 声明,浏览器会忽略整条声明。

这并不意味着整份 CSS 样式表都失效,也不会导致其他有效声明全部消失。

例如:

css 复制代码
div {
    width: 500px;
    border: red solid 10px;
    height: 100px;
}

即使另有一条无效的边框声明,其他有效样式仍可以参与计算。

3. 为什么截图中重新出现彩色边框?

实验中已经在 <style> 里为 div 指定了有效样式:

css 复制代码
div {
    border: red 10px solid;

    border-width: 2px 5px 10px;

    border-style: solid;
    border-top-style: dotted;
    border-right-style: dashed;
    border-bottom-style: groove;
    border-left-style: double;

    border-color: red green yellow purple;

    width: 500px;
    height: 100px;
}

当行内样式:

css 复制代码
border: green solid 400px 400px;

因为语法错误而被忽略时,原先有效的 div 样式仍然生效。

因此出现四条不同颜色、不同线型的边框。

这也纠正了一个可能产生的误解:

行内样式具有较高的层叠优先地位,并不意味着无效的行内声明也能覆盖其他有效声明。

必须首先是一条有效 CSS 声明,它才有资格参与正常层叠。

十一、border-width 如何分别设置四个方向?

与 border 不同,border-width 可以接受一至四个宽度值。

1. 一个值

css 复制代码
border-width: 10px;

表示:

复制代码
上:10px
右:10px
下:10px
左:10px

2. 两个值

css 复制代码
border-width: 10px 20px;

表示:

复制代码
上:10px
右:20px
下:10px
左:20px

也就是:

复制代码
第一个值 → 上下
第二个值 → 左右

3. 三个值

css 复制代码
border-width: 10px 20px 30px;

表示:

复制代码
上:10px
右:20px
下:30px
左:20px

对应:

复制代码
第一个值 → 上
第二个值 → 左右
第三个值 → 下

4. 四个值

css 复制代码
border-width: 10px 20px 30px 40px;

表示:

复制代码
上:10px
右:20px
下:30px
左:40px

按照顺时针方向:

复制代码
上 → 右 → 下 → 左

可以用下面的完整对照表复习:

值的数量 写法 解释
1 10px 四边
2 10px 20px 上下、左右
3 10px 20px 30px 上、左右、下
4 10px 20px 30px 40px 上、右、下、左

5. 怎样正确设置上下 200px、左右 400px?

可以写成:

css 复制代码
div {
    border-style: solid;
    border-color: green;
    border-width: 200px 400px;
}

也可以先设置统一边框,再覆盖宽度:

css 复制代码
div {
    border: 10px solid green;
    border-width: 200px 400px;
}

第二条声明会调整四条边的宽度,但保留绿色实线这一有效设置。

十二、border-style 和 border-color 的方向规则

border-width 的一至四值规则,也适用于 border-style 和 border-color 这两个四边属性简写。

例如:

css 复制代码
border-color: red green;

表示:

复制代码
上:red
右:green
下:red
左:green

而:

css 复制代码
border-color: red green yellow purple;

表示:

复制代码
上:red
右:green
下:yellow
左:purple

1. 分别设置四条边的样式

实验代码:

css 复制代码
border-style: solid;

border-top-style: dotted;
border-right-style: dashed;
border-bottom-style: groove;
border-left-style: double;

其中:

样式 含义
solid 实线
dotted 点线
dashed 虚线
groove 凹槽效果边框
double 双线

在实验中,最终四条边的样式分别为:

复制代码
上:dotted
右:dashed
下:groove
左:double

2. 结合宽度、样式和颜色

原实验中最后生效的相关规则为:

css 复制代码
border-width: 2px 5px 10px;

border-top-style: dotted;
border-right-style: dashed;
border-bottom-style: groove;
border-left-style: double;

border-color: red green yellow purple;

因此得到:

方向 宽度 样式 颜色
上 2px dotted red
右 5px dashed green
下 10px groove yellow
左 5px double purple

这就是原实验截图中彩色边框的来源。

其中 groove 会产生特定的明暗视觉效果,因此实际显示不一定是单一、纯粹的黄色。

十三、同一个 CSS 属性被反复声明时,为什么最终只采用某些值?

实验中对 border-width 连续写了多条声明:

css 复制代码
border-width: 10px;

border-width: 2px 5px 8px 10px;

border-width: 2px 10px;

border-width: 2px 5px 10px;

这些都是有效的普通声明。

它们属于同一个 CSS 规则块,具有相同的层叠条件。

因此后面的有效声明会覆盖前面相同属性的设置。

最终采用:

css 复制代码
border-width: 2px 5px 10px;

结果是:

复制代码
上:2px
右:5px
下:10px
左:5px

1. 简写属性与单边属性之间的关系

例如:

css 复制代码
div {
    border-width: 10px;
    border-top-width: 2px;
}

先将四边宽度设置为 10px。

再将上边框宽度设置为 2px。

最终:

复制代码
上:2px
右:10px
下:10px
左:10px

如果交换顺序:

css 复制代码
div {
    border-top-width: 2px;
    border-width: 10px;
}

后面的 border-width: 10px 会重新设置全部四条边。

最终四边都是 10px。

2. border 简写属性的覆盖范围更大

例如:

css 复制代码
div {
    border-top-style: dotted;
    border: 10px solid green;
}

后面的 border 不仅会设置宽度与颜色,也会把四边样式设置为 solid。

因此顶部的 dotted 会被覆盖。

反过来:

css 复制代码
div {
    border: 10px solid green;
    border-top-style: dotted;
}

上边框就会改成点线。

这里还需要注意:border 简写会对相关边框子属性进行统一设置或重置。即使某个子属性没有在简写中显式提供值,也不能一概认为它会原样保留此前设置。

这属于 CSS 简写属性的基本覆盖机制。

十四、为什么 400px 绿色边框会产生一大片绿色区域?

将无效的行内声明改成:

html 复制代码
<div style="border: green solid 400px;">
    我是文本1
</div>

此时声明有效。

它相当于:

css 复制代码
border-top: 400px solid green;
border-right: 400px solid green;
border-bottom: 400px solid green;
border-left: 400px solid green;

但是原来的 div 还设置了:

css 复制代码
width: 500px;
height: 100px;

为什么内容区域看起来只有一小块,而整个元素占据非常大的空间?

需要结合 CSS 盒模型理解。

1. CSS 盒模型的基本层次

在标准盒模型中,一个元素可以涉及以下区域:

复制代码
margin(外边距)
└── border(边框)
    └── padding(内边距)
        └── content(内容区域)

其中:

  • content:内容区域。
  • padding:内容与边框之间的内边距。
  • border:围绕内边距及内容区域的边框。
  • margin:边框外部的间距。

实验没有主动设置 padding,因此在普通 div 的默认条件下可以把它视为 0。

2. 默认 content-box 计算规则

普通元素默认使用:

css 复制代码
box-sizing: content-box;

这种模式下,指定的:

css 复制代码
width: 500px;
height: 100px;

控制的是内容区域的宽高。

它不包含边框。

因此,400px 边框要额外加入最终尺寸。

3. 计算整体宽度

内容宽度:

500 p x 500px 500px

左边框:

400 p x 400px 400px

右边框:

400 p x 400px 400px

因此:

400 + 500 + 400 = 1300 p x 400+500+400=1300px 400+500+400=1300px

最终边框盒宽度为:

1300px。

4. 计算整体高度

内容高度:

100 p x 100px 100px

上边框:

400 p x 400px 400px

下边框:

400 p x 400px 400px

因此:

400 + 100 + 400 = 900 p x 400+100+400=900px 400+100+400=900px

最终边框盒高度为:

900px。

这里没有计入外边距。如果存在 margin,还需在计算元素占据的外部空间时另行考虑。

5. 为什么中间是白色?

因为绿色来自边框。

中间的 500px × 100px 内容区域没有设置绿色背景。

在默认透明背景以及页面白色背景的条件下,内容区域看起来就是白色。

所以视觉结构大致是:

复制代码
       上边框:400px
┌──────────────────────────────┐
│                              │
│       大面积绿色边框          │
│                              │
│   ┌──────────────────────┐   │
│左 │    内容区域           │ 右│
│边 │   500px × 100px      │ 边│
│框 └──────────────────────┘ 框│
│                              │
│       大面积绿色边框          │
│                              │
└──────────────────────────────┘
       下边框:400px

这是边框非常厚时的正常盒模型效果。

6. 为什么浏览器页面还可能出现滚动条?

在默认 content-box 下,这个元素的边框盒宽度达到 1300px,高度达到 900px。

如果再考虑前面的其他元素、页面默认边距及可视区域尺寸,整个文档就可能超出浏览器视口。

浏览器于是可能出现水平或垂直滚动条。

滚动条是否出现,需要根据实际视口尺寸、页面布局和 overflow 等条件判断。

十五、span 边框实验与 div 的区别

原实验还包含:

html 复制代码
<span>span111</span>

以及:

css 复制代码
span {
    border: 10px purple solid;
    color: red;
}

结果是 span111 具有红色文字和紫色边框。

这里涉及一个新的相关知识点:

div 默认属于块级布局中的块容器,而普通 span 默认是行内元素。

因此:

  • 普通 div 通常在正常文档流中独占一行,并可以明确设置宽度和高度。
  • 普通 span 通常围绕行内文字参与排版。
  • 对普通非替换行内元素设置边框时,其边框可以绘制出来,但在垂直方向上,它不会像块级盒那样直接决定所在行的行高。

这解释了为什么 span 的紫色边框主要包围文字,而前面的 div 可以形成很大的矩形区域。

这里仅涉及正常文档流中的基本块级与行内表现,尚未展开完整的 CSS 行内格式化上下文。

十六、将整轮实验串起来:浏览器如何确定最终显示结果?

下面按照实际的实验对象逐一整理。

实验 A:ol li 与 ol > li

css 复制代码
ol li {
    color: blue;
}

能够匹配所有层级中具有 ol 祖先的 li。

css 复制代码
ol > li {
    color: blue;
}

只能匹配直接父元素为 ol 的 li。

但是后代仍可能通过继承获得颜色。

所以必须区分"选择器直接匹配"和"最终样式呈现"。

实验 B:三个选择器都修饰 222

css 复制代码
li a {
    color: rgb(233, 70, 11);
}

ul a {
    color: #008000;
}

ul li a {
    color: rgb(14, 222, 42);
}

三个选择器都匹配 222 所在的 <a>。

优先级分别是:

复制代码
li a       (0,0,2)
ul a       (0,0,2)
ul li a    (0,0,3)

最终亮绿色生效。

实验 C:ol > li 设置紫色

css 复制代码
ol > li {
    color: purple;
}

外层 li 获得紫色。

内层 ul、li 可以继承紫色。

但是 <a href="#">222</a> 可能因为浏览器默认链接样式而显示蓝色。

如果给 <a> 直接指定更高优先级的绿色,则会显示绿色。

如果希望 <a> 使用父元素颜色,可以在其他冲突规则得到妥善处理后使用:

css 复制代码
a {
    color: inherit;
}

实验 D:外部、内部、行内颜色冲突

外部:

css 复制代码
p {
    color: blue;
}

内部:

css 复制代码
p {
    color: #0000ff;
}

行内:

html 复制代码
<p style="color: red;">一个文本</p>

在普通作者声明的条件下,行内样式具有特殊优先地位。

最终显示红色。

外部与内部样式本身没有固定高低;在其他条件相同时,最后出现的有效声明获胜。

实验 E:无效的 border 声明

html 复制代码
<div style="border: green solid 400px 400px;">
    我是文本1
</div>

因为 border 简写不能同时接受两个宽度分量,所以声明无效。

浏览器忽略该声明,原来的有效 div 边框规则继续参与层叠。

实验 F:合法的 400px 边框

html 复制代码
<div style="border: green solid 400px;">
    我是文本1
</div>

四边统一设置为 400px。

在:

css 复制代码
width: 500px;
height: 100px;

和默认 box-sizing: content-box 条件下:

复制代码
内容宽度:500px
内容高度:100px

左右边框:各400px
上下边框:各400px

边框盒总宽度:1300px
边框盒总高度:900px

由此形成大面积绿色边框和较小的内容区域。

十七、复习时的分析方法

遇到 CSS 显示结果与预期不一致,可以按照问题类型分别检查。

1. 如果是颜色不符合预期

先确定目标文字实际属于哪个 HTML 元素。

例如:

html 复制代码
<li><a href="#">222</a>葡萄</li>

其中:

复制代码
222 → 属于 a
葡萄 → 属于 li 的文本内容

两者可能采用不同的颜色。

随后检查:

  1. 哪些 CSS 选择器直接匹配目标元素。
  2. 哪些声明有效并且设置了同一个属性。
  3. 样式来源、重要性和层叠条件是否不同。
  4. 普通选择器优先级分别是多少。
  5. 在优先级等条件相同时,声明的先后顺序如何。
  6. 如果没有适用的直接属性值,是否发生继承。
  7. 浏览器默认样式是否为这个元素提供了直接声明。

2. 如果是边框不符合预期

先判断使用的是:

复制代码
border

还是:

复制代码
border-width
border-style
border-color

然后检查:

  1. 当前属性的语法是否允许所写的值。
  2. 一个、两个、三个、四个值分别代表什么方向。
  3. 后面的简写或单边声明是否重新覆盖了某些值。
  4. 语法错误是否导致整条声明被忽略。
  5. 边框宽度是否额外增加了元素的整体尺寸。

3. 如果是元素尺寸不符合预期

需要分别确定:

复制代码
content
padding
border
margin

的实际值,并确认 box-sizing 使用的模式。

在默认 content-box 下:

内容宽度 + 左右 padding + 左右 border \text{内容宽度} + \text{左右 padding} + \text{左右 border} 内容宽度+左右 padding+左右 border

内容高度 + 上下 padding + 上下 border \text{内容高度} + \text{上下 padding} + \text{上下 border} 内容高度+上下 padding+上下 border

margin 位于边框外部,不包含在边框盒尺寸中。

下一篇:

CSS基础知识(二):盒模型、内外边距、外边距折叠与父子元素的布局关系

相关推荐
颜进强19 分钟前
微信小微AI-灰度与命中排查|代码全对、版本已发,为什么同事就是问不中?
前端·ai编程·全栈
verohh27 分钟前
从代码组织到功能抽象:AI 时代的前端工程架构设计
前端
颜进强28 分钟前
微信小微AI-评测|文档质量直接被判 0 分:小微团队评测那些没人告诉你的硬指标
前端·ai编程·全栈
Bacon29 分钟前
给项目做一次"全身 CT":Agent Skills 生态里的代码体检全链路
前端·人工智能·后端
颜进强32 分钟前
微信小微AI-提审与发布|评测过了不等于能上线:四道前置条件,缺一道都白提交
前端·ai编程·全栈
颜进强34 分钟前
微信小微AI-【实战二】从零写一个 skill|卡片死活不出来?这 4 个坑我们全踩了一遍
前端·ai编程·全栈
颜进强37 分钟前
微信小微AI-命中效果调优|在 AI 的「选择题」里,怎么让小微更愿意选中你(系列收官)
前端·ai编程·全栈
颜进强38 分钟前
微信小微AI-【实战四】给 Agent 立人设|一份 AGENTS.md,决定小微是靠谱助手还是满嘴跑火车
前端·ai编程·全栈
颜进强39 分钟前
微信小微AI - 【实战一】工程化落地|Taro 主工程里塞进一套原生 AI 代码,我们这样让它们共存
前端·ai编程·全栈