diff --git a/CNAME b/CNAME new file mode 100644 index 0000000..6ea5a6e --- /dev/null +++ b/CNAME @@ -0,0 +1 @@ +www.7zmonkey.tech \ No newline at end of file diff --git a/archives/2022/05/index.html b/archives/2022/05/index.html new file mode 100644 index 0000000..e3dfb77 --- /dev/null +++ b/archives/2022/05/index.html @@ -0,0 +1 @@ +
我们将通过闭包实现一个配置信息的管理,首先我们写一个简单的闭包代码:
1 | const createConfig = (() { |
但是我们要实现一个单例模式,就要在再次返回instance
前做判断,如果没有 instance
要对他进行赋值。
1 | const createConfig = (() => { |
这样就是一个简单的单例模式的代码。
我们不知想要一个简单的单例模式,也想要一个可以设置删除的单例模式,我就的config 就不应该是一个简单的配置对象,而是一个对象其中包含简单的配置对象。
1 | const createConfig = (() => { |
将 对象
{6: 46, 8: 23, 14: 5, 10: 3}
按照值的顺序排列。
由于做开始他说的一个数组,说这个题的时候我以为是类数组对象,结果是是如上的对象,排序嘛,(不考虑时间复杂度和空间复杂度的话)基本上没什么难度, 但是一直有一个疑惑在脑中,Object 不是无序的吗?
本文主要探讨不同的 Object 定义方式(或者说声明方式)是否影响”Object 顺序“,”Object 顺序“是什么样的,以及常见处理”Object顺序“的方式。
首先再次之前我的认为是”对象是无序的,数组是有序的,如果处理对象的顺序的话,还是使用数组对象[{key, value}]
的方式“ 。
在 ECMA-262_3rd_edition_december_1999 中有提到:
4.3.3 Object
An object is a member of the type Object. It is an unordered collection of properties each of which contains a primitive value, object, or function. A function stored in a property of an object is called a method.
也就是在 ES3 中是 Objiect 是乱序的,但是在 ES6 中逐渐开始在 Object 的中开始添加 Object 部分放的顺序之说。
不同浏览器在处理 for...in
时的解析顺序时不同的,在 Chrome 和 Opera 中遵循的是 ECMA-262 第五版本规范,而在 Firefox 和 Safari遵循的是 ECMA-262 第三版本规范。
在通常情况下,如果要处理对象的排序,我建议使用数组处理,也就是将对象处理为 [{ key, value }]
这样的的数组形式,按照数组排序,因为我还是觉得对象是无序的,尽管他是按照一定的顺序排序的,但为了避免在不同的浏览器中的排序不同还是将他作为数组处理比较好。
个人需需要将 Obsidian 的 markdown 文档放置在一个私有仓库,将 Hexo Template 放置在共有仓库,github pages 也放在另一个仓库,当然 Hexo Template 可以和 Github Pages 放在相同的仓库中,如果Hexo Template也需要分离的话在将其分离。
静态博客框架仓库和部署仓库分离的好处是如果更换静态博客框架例如Gatsby,VuePress的话,可以不需要修改部署仓库只需要新建新的静态博客框架仓库,调整Obsidian 仓库的 Actions 就可以。
分离的坏处就是需要有一个额外的仓库管理静态博客框架,当然个人觉得好处大于坏处。
在 Obsidian 仓库,和 Hexo 仓库分别设置了两个 Actions,Obsidian 的仓库 Actions 是主 Actions,Hexo 的 Actions 只是为了触发主 Actions。
也可以将主 Actions 放在 Hexo 上,甚至应该放到静态博客框架仓库里面,如果要更换静态博客框架,肯定需要重新修改主 Actions ,而且是大幅修改,而 Obsidian Actions 只需要修改触发的主 Actions 就可以,减少了不必要的 Obsidian 仓库的变动,如果没有仓库洁癖这些问题都是小问题。
本网站的部署 Actions 整体思路大致如下( Local 代表本地仓库):
sequenceDiagramparticipant Local as Localparticipant Obsidian as Obsidianparticipant Hexo as Hexo Templateparticipant Github as Github Pagesopt 推送 Obsidian 触发 Local->>Obsidian:推送 Obsidian->>Obsidian: 触发endopt 推送 Hexo template 触发 Local->>Hexo: 推送 par Hexo Actions Hexo->>Obsidian: 触发 endendpar Obsidian ActionsHexo->>Obsidian: 拉取Obsidian->>Obsidian:生成静态文件Obsidian->>Github:推送end]]>
!important>内联样式>ID选择器>类选择器>类型选择器
相信很多人对CSS优先级的理解也是这样的,但是一篇文章(CSS选择器的优先级(精讲版) (biancheng.net))上面书写了关于CSS 选择器优先级的计算规则的内容,使我开始对CSS优先级进行重新研究。
根据W3C给出关于选择器特异性(specificity,国内一般称优先级)的解释,选择器分为ABC三个等级,其中A为ID选择器,B包括类选择器、属性选择器和伪类,C包括类型选择器和伪元素,当然还存在一个通用选择器,但是通用选择器一般忽略。
等级 | 包含选择器 |
---|---|
A | 计算选择器中 ID 选择器的数量 |
B | 计算选择器中类选择器、属性选择器和伪类的数量 |
C | 计算选择器中类型选择器和伪元素的数量 |
优先级的计算,从A级开始到C级结束,如果到C级是两个选择器的优先级还是相等的那么有限选择靠后的选择器。
CSS选择器允许重复出现简单选择器,并且简单选择器的重复出现会增加优先级。
1 | .class.class{ |
也就是说如上代码中第一个选择器重复出现了.class
选择器,第二个选择器只出现了一个.class
选择器,这两种写法都是正确的,并且第一个选择器.class.class
的优先级大于第二个选择器.class
,所以结果是背景颜色将呈现红色。
选择器 | 优先级 (A, B, C) |
---|---|
.class.class | (0, 2, 0) |
.class | (0, 1, 0) |
在低版本CSS中可能简单重复选择器会被忽略,如在ie8中重复id或被忽略,在ie5中重复的class或被忽略。
拒绝IE,从我做起!
一些伪类和其他选择器中存在一些特殊的选择器,因此单独定义了这些特殊选择器的特异性。
:is()
、:not()
、:has()
的优先级是选择器列表中最具有复杂性的选择器的优先级取代。:nth-child()
、:nth-last-child()
的优先级是伪类本身的优先级(计为一个伪类选择器,也就是计为B),再加上选择器列表中最具复杂性的选择器的优先级。:where()
伪类的优先级被零代替,也就是没有优先级,再优先级计算中不做数。选择器 | 优先级 (A, B, C) |
---|---|
.class | (0, 1, 0) |
#Red | (1, 0, 0) |
.container :is(.container>#Red, .container>.class) | (1, 2, 0) |
.container #Red.class:nth-child(1) | (1, 3, 0) |
:is(.container>.class.class) | (0, 3, 0) |
#Red:is(.container>.class) | (1, 2, 0) |
.container div:nth-child(1) | (0, 2, 1) |
:is(#Red.class) | (1, 1, 0) |
#Red.class | (1, 1, 0) |
#Red.class:nth-child(1) | (1, 2, 0) |
#Red#Red | (2, 0, 0) |
在一些其他文档中将讲A、B、C分别比作100,10,1 进行求和,是不准确的,如果按照这样做那么10个class是不是相当于一个id,显然不是。
在CSS Level 1、Selectors Level 3中也有这样的描述。
在主流浏览器中高等级高于低等级是即使ABC求和相同也不会优先使用后声明的CSS。
造成这样的原因是权重的进制是并不是十进制,CSS 权重进制在 IE6 为 256,后来扩大到了 65536,现代浏览器则采用更大的数量。也可以理解选择器的权值不能进位,或者理解为选择器权值ABC单独计算比较。
!important
MDN指出“使用 !important
是一个坏习惯,应该尽量避免”,并给出了使用!important
的情况:
!important
!important
!important
!important
以及替代 !important
的方法:
推荐阅读优先级 - CSS(层叠样式表) | MDN (mozilla.org),了解更多!important
的使用意见。
CSS 优先规则1: 最近的祖先样式比其他祖先样式优先级高。
CSS 优先规则2: “直接样式”比”祖先样式”优先级高。
CSS 优先规则3: 优先级关系:内联样式 > ID 选择器 > 类选择器 = 属性选择器 = 伪类选择器 > 标签选择器 = 伪元素选择器。
CSS 优先规则4: 计算选择符中 ID 选择器的个数(a),计算选择符中类选择器、属性选择器以及伪类选择器的个数之和(b),计算选择符中标签选择器和伪元素选择器的个数之和(c)。按 a、b、c 的顺序依次比较大小,大的则优先级高,相等则比较下一个。若最后两个的选择符中 a、b、c 都相等,则按照”就近原则”来判断。
CSS 优先规则5: 属性后插有 !important 的属性拥有最高优先级。若同时插有 !important,则再利用规则 3、4 判断优先级。
注意: 文档树中元素的接近度(Proximity of elements)对优先级没有影响。
${div.textContent.substring(0, 100)}...
`; + } + return result; + }, + empty: data => { + return `我们将通过闭包实现一个配置信息的管理,首先我们写一个简单的闭包代码:
1 | const createConfig = (() { |
但是我们要实现一个单例模式,就要在再次返回instance
前做判断,如果没有 instance
要对他进行赋值。
1 | const createConfig = (() => { |
这样就是一个简单的单例模式的代码。
我们不知想要一个简单的单例模式,也想要一个可以设置删除的单例模式,我就的config 就不应该是一个简单的配置对象,而是一个对象其中包含简单的配置对象。
1 | const createConfig = (() => { |
将 对象
{6: 46, 8: 23, 14: 5, 10: 3}
按照值的顺序排列。
由于做开始他说的一个数组,说这个题的时候我以为是类数组对象,结果是是如上的对象,排序嘛,(不考虑时间复杂度和空间复杂度的话)基本上没什么难度, 但是一直有一个疑惑在脑中,Object 不是无序的吗?
本文主要探讨不同的 Object 定义方式(或者说声明方式)是否影响”Object 顺序“,”Object 顺序“是什么样的,以及常见处理”Object顺序“的方式。
首先再次之前我的认为是”对象是无序的,数组是有序的,如果处理对象的顺序的话,还是使用数组对象[{key, value}]
的方式“ 。
在 ECMA-262_3rd_edition_december_1999 中有提到:
4.3.3 Object
An object is a member of the type Object. It is an unordered collection of properties each of which contains a primitive value, object, or function. A function stored in a property of an object is called a method.
也就是在 ES3 中是 Objiect 是乱序的,但是在 ES6 中逐渐开始在 Object 的中开始添加 Object 部分放的顺序之说。
不同浏览器在处理 for...in
时的解析顺序时不同的,在 Chrome 和 Opera 中遵循的是 ECMA-262 第五版本规范,而在 Firefox 和 Safari遵循的是 ECMA-262 第三版本规范。
在通常情况下,如果要处理对象的排序,我建议使用数组处理,也就是将对象处理为 [{ key, value }]
这样的的数组形式,按照数组排序,因为我还是觉得对象是无序的,尽管他是按照一定的顺序排序的,但为了避免在不同的浏览器中的排序不同还是将他作为数组处理比较好。
个人需需要将 Obsidian 的 markdown 文档放置在一个私有仓库,将 Hexo Template 放置在共有仓库,github pages 也放在另一个仓库,当然 Hexo Template 可以和 Github Pages 放在相同的仓库中,如果Hexo Template也需要分离的话在将其分离。
静态博客框架仓库和部署仓库分离的好处是如果更换静态博客框架例如Gatsby,VuePress的话,可以不需要修改部署仓库只需要新建新的静态博客框架仓库,调整Obsidian 仓库的 Actions 就可以。
分离的坏处就是需要有一个额外的仓库管理静态博客框架,当然个人觉得好处大于坏处。
在 Obsidian 仓库,和 Hexo 仓库分别设置了两个 Actions,Obsidian 的仓库 Actions 是主 Actions,Hexo 的 Actions 只是为了触发主 Actions。
也可以将主 Actions 放在 Hexo 上,甚至应该放到静态博客框架仓库里面,如果要更换静态博客框架,肯定需要重新修改主 Actions ,而且是大幅修改,而 Obsidian Actions 只需要修改触发的主 Actions 就可以,减少了不必要的 Obsidian 仓库的变动,如果没有仓库洁癖这些问题都是小问题。
本网站的部署 Actions 整体思路大致如下( Local 代表本地仓库):
sequenceDiagramparticipant Local as Localparticipant Obsidian as Obsidianparticipant Hexo as Hexo Templateparticipant Github as Github Pagesopt 推送 Obsidian 触发 Local->>Obsidian:推送 Obsidian->>Obsidian: 触发endopt 推送 Hexo template 触发 Local->>Hexo: 推送 par Hexo Actions Hexo->>Obsidian: 触发 endendpar Obsidian ActionsHexo->>Obsidian: 拉取Obsidian->>Obsidian:生成静态文件Obsidian->>Github:推送end]]>
!important>内联样式>ID选择器>类选择器>类型选择器
相信很多人对CSS优先级的理解也是这样的,但是一篇文章(CSS选择器的优先级(精讲版) (biancheng.net))上面书写了关于CSS 选择器优先级的计算规则的内容,使我开始对CSS优先级进行重新研究。
根据W3C给出关于选择器特异性(specificity,国内一般称优先级)的解释,选择器分为ABC三个等级,其中A为ID选择器,B包括类选择器、属性选择器和伪类,C包括类型选择器和伪元素,当然还存在一个通用选择器,但是通用选择器一般忽略。
等级 | 包含选择器 |
---|---|
A | 计算选择器中 ID 选择器的数量 |
B | 计算选择器中类选择器、属性选择器和伪类的数量 |
C | 计算选择器中类型选择器和伪元素的数量 |
优先级的计算,从A级开始到C级结束,如果到C级是两个选择器的优先级还是相等的那么有限选择靠后的选择器。
CSS选择器允许重复出现简单选择器,并且简单选择器的重复出现会增加优先级。
1 | .class.class{ |
也就是说如上代码中第一个选择器重复出现了.class
选择器,第二个选择器只出现了一个.class
选择器,这两种写法都是正确的,并且第一个选择器.class.class
的优先级大于第二个选择器.class
,所以结果是背景颜色将呈现红色。
选择器 | 优先级 (A, B, C) |
---|---|
.class.class | (0, 2, 0) |
.class | (0, 1, 0) |
在低版本CSS中可能简单重复选择器会被忽略,如在ie8中重复id或被忽略,在ie5中重复的class或被忽略。
拒绝IE,从我做起!
一些伪类和其他选择器中存在一些特殊的选择器,因此单独定义了这些特殊选择器的特异性。
:is()
、:not()
、:has()
的优先级是选择器列表中最具有复杂性的选择器的优先级取代。:nth-child()
、:nth-last-child()
的优先级是伪类本身的优先级(计为一个伪类选择器,也就是计为B),再加上选择器列表中最具复杂性的选择器的优先级。:where()
伪类的优先级被零代替,也就是没有优先级,再优先级计算中不做数。选择器 | 优先级 (A, B, C) |
---|---|
.class | (0, 1, 0) |
#Red | (1, 0, 0) |
.container :is(.container>#Red, .container>.class) | (1, 2, 0) |
.container #Red.class:nth-child(1) | (1, 3, 0) |
:is(.container>.class.class) | (0, 3, 0) |
#Red:is(.container>.class) | (1, 2, 0) |
.container div:nth-child(1) | (0, 2, 1) |
:is(#Red.class) | (1, 1, 0) |
#Red.class | (1, 1, 0) |
#Red.class:nth-child(1) | (1, 2, 0) |
#Red#Red | (2, 0, 0) |
在一些其他文档中将讲A、B、C分别比作100,10,1 进行求和,是不准确的,如果按照这样做那么10个class是不是相当于一个id,显然不是。
在CSS Level 1、Selectors Level 3中也有这样的描述。
在主流浏览器中高等级高于低等级是即使ABC求和相同也不会优先使用后声明的CSS。
造成这样的原因是权重的进制是并不是十进制,CSS 权重进制在 IE6 为 256,后来扩大到了 65536,现代浏览器则采用更大的数量。也可以理解选择器的权值不能进位,或者理解为选择器权值ABC单独计算比较。
!important
MDN指出“使用 !important
是一个坏习惯,应该尽量避免”,并给出了使用!important
的情况:
!important
!important
!important
!important
以及替代 !important
的方法:
推荐阅读优先级 - CSS(层叠样式表) | MDN (mozilla.org),了解更多!important
的使用意见。
CSS 优先规则1: 最近的祖先样式比其他祖先样式优先级高。
CSS 优先规则2: “直接样式”比”祖先样式”优先级高。
CSS 优先规则3: 优先级关系:内联样式 > ID 选择器 > 类选择器 = 属性选择器 = 伪类选择器 > 标签选择器 = 伪元素选择器。
CSS 优先规则4: 计算选择符中 ID 选择器的个数(a),计算选择符中类选择器、属性选择器以及伪类选择器的个数之和(b),计算选择符中标签选择器和伪元素选择器的个数之和(c)。按 a、b、c 的顺序依次比较大小,大的则优先级高,相等则比较下一个。若最后两个的选择符中 a、b、c 都相等,则按照”就近原则”来判断。
CSS 优先规则5: 属性后插有 !important 的属性拥有最高优先级。若同时插有 !important,则再利用规则 3、4 判断优先级。
注意: 文档树中元素的接近度(Proximity of elements)对优先级没有影响。
我们将通过闭包实现一个配置信息的管理,首先我们写一个简单的闭包代码:
1 | const createConfig = (() { |
但是我们要实现一个单例模式,就要在再次返回instance
前做判断,如果没有 instance
要对他进行赋值。
1 | const createConfig = (() => { |
这样就是一个简单的单例模式的代码。
我们不知想要一个简单的单例模式,也想要一个可以设置删除的单例模式,我就的config 就不应该是一个简单的配置对象,而是一个对象其中包含简单的配置对象。
1 | const createConfig = (() => { |
将 对象
{6: 46, 8: 23, 14: 5, 10: 3}
按照值的顺序排列。
由于做开始他说的一个数组,说这个题的时候我以为是类数组对象,结果是是如上的对象,排序嘛,(不考虑时间复杂度和空间复杂度的话)基本上没什么难度, 但是一直有一个疑惑在脑中,Object 不是无序的吗?
本文主要探讨不同的 Object 定义方式(或者说声明方式)是否影响”Object 顺序“,”Object 顺序“是什么样的,以及常见处理”Object顺序“的方式。
首先再次之前我的认为是”对象是无序的,数组是有序的,如果处理对象的顺序的话,还是使用数组对象[{key, value}]
的方式“ 。
在 ECMA-262_3rd_edition_december_1999 中有提到:
4.3.3 Object
An object is a member of the type Object. It is an unordered collection of properties each of which contains a primitive value, object, or function. A function stored in a property of an object is called a method.
也就是在 ES3 中是 Objiect 是乱序的,但是在 ES6 中逐渐开始在 Object 的中开始添加 Object 部分放的顺序之说。
不同浏览器在处理 for...in
时的解析顺序时不同的,在 Chrome 和 Opera 中遵循的是 ECMA-262 第五版本规范,而在 Firefox 和 Safari遵循的是 ECMA-262 第三版本规范。
在通常情况下,如果要处理对象的排序,我建议使用数组处理,也就是将对象处理为 [{ key, value }]
这样的的数组形式,按照数组排序,因为我还是觉得对象是无序的,尽管他是按照一定的顺序排序的,但为了避免在不同的浏览器中的排序不同还是将他作为数组处理比较好。
个人需需要将 Obsidian 的 markdown 文档放置在一个私有仓库,将 Hexo Template 放置在共有仓库,github pages 也放在另一个仓库,当然 Hexo Template 可以和 Github Pages 放在相同的仓库中,如果Hexo Template也需要分离的话在将其分离。
静态博客框架仓库和部署仓库分离的好处是如果更换静态博客框架例如Gatsby,VuePress的话,可以不需要修改部署仓库只需要新建新的静态博客框架仓库,调整Obsidian 仓库的 Actions 就可以。
分离的坏处就是需要有一个额外的仓库管理静态博客框架,当然个人觉得好处大于坏处。
在 Obsidian 仓库,和 Hexo 仓库分别设置了两个 Actions,Obsidian 的仓库 Actions 是主 Actions,Hexo 的 Actions 只是为了触发主 Actions。
也可以将主 Actions 放在 Hexo 上,甚至应该放到静态博客框架仓库里面,如果要更换静态博客框架,肯定需要重新修改主 Actions ,而且是大幅修改,而 Obsidian Actions 只需要修改触发的主 Actions 就可以,减少了不必要的 Obsidian 仓库的变动,如果没有仓库洁癖这些问题都是小问题。
本网站的部署 Actions 整体思路大致如下( Local 代表本地仓库):
sequenceDiagramparticipant Local as Localparticipant Obsidian as Obsidianparticipant Hexo as Hexo Templateparticipant Github as Github Pagesopt 推送 Obsidian 触发 Local->>Obsidian:推送 Obsidian->>Obsidian: 触发endopt 推送 Hexo template 触发 Local->>Hexo: 推送 par Hexo Actions Hexo->>Obsidian: 触发 endendpar Obsidian ActionsHexo->>Obsidian: 拉取Obsidian->>Obsidian:生成静态文件Obsidian->>Github:推送end]]>
!important>内联样式>ID选择器>类选择器>类型选择器
相信很多人对CSS优先级的理解也是这样的,但是一篇文章(CSS选择器的优先级(精讲版) (biancheng.net))上面书写了关于CSS 选择器优先级的计算规则的内容,使我开始对CSS优先级进行重新研究。
根据W3C给出关于选择器特异性(specificity,国内一般称优先级)的解释,选择器分为ABC三个等级,其中A为ID选择器,B包括类选择器、属性选择器和伪类,C包括类型选择器和伪元素,当然还存在一个通用选择器,但是通用选择器一般忽略。
等级 | 包含选择器 |
---|---|
A | 计算选择器中 ID 选择器的数量 |
B | 计算选择器中类选择器、属性选择器和伪类的数量 |
C | 计算选择器中类型选择器和伪元素的数量 |
优先级的计算,从A级开始到C级结束,如果到C级是两个选择器的优先级还是相等的那么有限选择靠后的选择器。
CSS选择器允许重复出现简单选择器,并且简单选择器的重复出现会增加优先级。
1 | .class.class{ |
也就是说如上代码中第一个选择器重复出现了.class
选择器,第二个选择器只出现了一个.class
选择器,这两种写法都是正确的,并且第一个选择器.class.class
的优先级大于第二个选择器.class
,所以结果是背景颜色将呈现红色。
选择器 | 优先级 (A, B, C) |
---|---|
.class.class | (0, 2, 0) |
.class | (0, 1, 0) |
在低版本CSS中可能简单重复选择器会被忽略,如在ie8中重复id或被忽略,在ie5中重复的class或被忽略。
拒绝IE,从我做起!
一些伪类和其他选择器中存在一些特殊的选择器,因此单独定义了这些特殊选择器的特异性。
:is()
、:not()
、:has()
的优先级是选择器列表中最具有复杂性的选择器的优先级取代。:nth-child()
、:nth-last-child()
的优先级是伪类本身的优先级(计为一个伪类选择器,也就是计为B),再加上选择器列表中最具复杂性的选择器的优先级。:where()
伪类的优先级被零代替,也就是没有优先级,再优先级计算中不做数。选择器 | 优先级 (A, B, C) |
---|---|
.class | (0, 1, 0) |
#Red | (1, 0, 0) |
.container :is(.container>#Red, .container>.class) | (1, 2, 0) |
.container #Red.class:nth-child(1) | (1, 3, 0) |
:is(.container>.class.class) | (0, 3, 0) |
#Red:is(.container>.class) | (1, 2, 0) |
.container div:nth-child(1) | (0, 2, 1) |
:is(#Red.class) | (1, 1, 0) |
#Red.class | (1, 1, 0) |
#Red.class:nth-child(1) | (1, 2, 0) |
#Red#Red | (2, 0, 0) |
在一些其他文档中将讲A、B、C分别比作100,10,1 进行求和,是不准确的,如果按照这样做那么10个class是不是相当于一个id,显然不是。
在CSS Level 1、Selectors Level 3中也有这样的描述。
在主流浏览器中高等级高于低等级是即使ABC求和相同也不会优先使用后声明的CSS。
造成这样的原因是权重的进制是并不是十进制,CSS 权重进制在 IE6 为 256,后来扩大到了 65536,现代浏览器则采用更大的数量。也可以理解选择器的权值不能进位,或者理解为选择器权值ABC单独计算比较。
!important
MDN指出“使用 !important
是一个坏习惯,应该尽量避免”,并给出了使用!important
的情况:
!important
!important
!important
!important
以及替代 !important
的方法:
推荐阅读优先级 - CSS(层叠样式表) | MDN (mozilla.org),了解更多!important
的使用意见。
CSS 优先规则1: 最近的祖先样式比其他祖先样式优先级高。
CSS 优先规则2: “直接样式”比”祖先样式”优先级高。
CSS 优先规则3: 优先级关系:内联样式 > ID 选择器 > 类选择器 = 属性选择器 = 伪类选择器 > 标签选择器 = 伪元素选择器。
CSS 优先规则4: 计算选择符中 ID 选择器的个数(a),计算选择符中类选择器、属性选择器以及伪类选择器的个数之和(b),计算选择符中标签选择器和伪元素选择器的个数之和(c)。按 a、b、c 的顺序依次比较大小,大的则优先级高,相等则比较下一个。若最后两个的选择符中 a、b、c 都相等,则按照”就近原则”来判断。
CSS 优先规则5: 属性后插有 !important 的属性拥有最高优先级。若同时插有 !important,则再利用规则 3、4 判断优先级。
注意: 文档树中元素的接近度(Proximity of elements)对优先级没有影响。