• Web Components详解-Shadow DOM样式控制

    前言

    本文继续Web Components系列文章，介绍一下Shadow DOM的样式及选择器。

    Shadow DOM的样式与外界是隔离的，即自定义元素的样式只会影响到Shadow DOM内部，不会影响到外部的页面元素，这点在之前有说到过。那么有什么办法可以在Shadow DOM中使用全局样式？样式选择器又有什么异同呢？请跟着本篇文章一起探究

    :host伪类

    作为伪类使用

    :host一般在Shadow DOM中使用，代指宿主标签（自定义标签）使用它可以在Shadow DOM内部为自定义元素定义样式，host伪类的语法是：:host { /* 样式规则 */ }，例如

    1. <body>
    2.     <host-element>host-element>
    3.  
    4.     <script>
    5.         class HostElement extends HTMLElement {
    6.             constructor() {
    7.                 super()
    8.                 this.attachShadow({ mode: "open" })
    9.                 this.shadowRoot.textContent = "host-element"
    10.                 this.addStyle()
    11.             }
    12.             addStyle() {
    13.                 const styleEle = document.createElement("style");
    14.                 // 加点样式
    15.                 styleEle.textContent = `
    16.             :host {
    17.                 font-size:20px;
    18.                 color:lightblue;
    19.                 border: 1px solid black;
    20.             }`
    21.                 this.shadowRoot.appendChild(styleEle)
    22.             }
    23.         }
    24.         customElements.define("host-element", HostElement)
    25.     script>
    26. body>

    作为选择器使用

    除了使用:host伪类外，:host还提供了selector的选择器使用方式，用于过滤某个条件下的宿主标签，比如我们选择属性为isHost的标签、class为isHost的标签以及id为isHost的标签并分别设置不同的样式进行区分

    1. <body>
    2.     <host-element>host-element>
    3.     <host-element isHost>host-element>
    4.     <host-element class="isHost">host-element>
    5.     <host-element id="isHost">host-element>
    6.     <script>
    7.         class HostElement extends HTMLElement {
    8.             constructor() {
    9.                 super()
    10.                 this.attachShadow({ mode: "open" })
    11.                 this.shadowRoot.textContent = "host-element"
    12.                 this.addStyle()
    13.             }
    14.             addStyle() {
    15.                 const styleEle = document.createElement("style");
    16.                 // 加点样式
    17.                 styleEle.textContent = `
    18.             :host {
    19.                 font-size:20px;
    20.                 color:lightcoral;
    21.                 border: 1px solid black;
    22.             }
    23.             :host([isHost]) {
    24.                 background:lightgreen;
    25.             }
    26.             :host(.isHost) {
    27.                 background:lightblue;
    28.             }
    29.             :host(#isHost) {
    30.                 background:green;
    31.             }`
    32.                 this.shadowRoot.appendChild(styleEle)
    33.             }
    34.         }
    35.         customElements.define("host-element", HostElement)
    36.     script>
    37. body>

    效果如下

     

    ::part伪元素

    ::part伪元素选择器是Shadow DOM中的选择器之一，它可以为自定义元素内部的特定部分（一般是子元素）定义样式，结合上面的伪类选择器host我们可以使用它选择当前宿主标签下的某个部分的子元素，并设置该部分独有的样式，思考下面的代码：

    1. <body>
    2.     <part-element>part-element>
    3.     <script>
    4.         class PartElement extends HTMLElement {
    5.             constructor() {
    6.                 super()
    7.                 this.attachShadow({ mode: "open" })
    8.                 this.addStyle()
    9.                 this.addTreeElems()
    10.             }
    11.             addTreeElems() {
    12.                 this.shadowRoot.innerHTML += `
    13.                     
      part1
    14.                     
      part2
    15.                     
      part3
      `
    16.             }
    17.             addStyle() {
    18.                 const styleEle = document.createElement("style");
    19.                 // 加点样式
    20.                 styleEle.textContent = `
    21.             :host {
    22.                 font-size:20px;
    23.                 display:flex;
    24.                 justify-content: space-evenly;
    25.                 border: 1px solid black;
    26.             }
    27.             :host::part(part1) {
    28.                 color: lightcoral;
    29.             }
    30.             :host::part(part2) {
    31.                 color: lightblue;
    32.             }
    33.             :host::part(part3) {
    34.                 background: lightgreen;
    35.             }`
    36.                 this.shadowRoot.appendChild(styleEle)
    37.             }
    38.         }
    39.         customElements.define("part-element", PartElement)
    40.     script>
    41. body>

    我们将div分成3个part（tips：part用法和class相似，一个part属性可以设置多个值，使用空格隔开），分别为三者设置不同的样式，在css中同样针对不同part设置了不同的样式，效果如下

    ::slotted伪元素

    使用::slotted可以对Shadow DOM中的绑定了插槽的元素设置样式，并且它只能给外层元素设置样式，无法选择到子元素，参考下面的代码

    1. html>
    2. <html lang="en">
    3.  
    4. <head>
    5.     <meta charset="UTF-8">
    6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
    7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8.     <title>ShadowDOMtitle>
    9. head>
    10.  
    11. <body>
    12.     <slotted-element>
    13.         <header slot="header">headerheader>
    14.         <main class="main" slot="content">
    15.             <span>contentspan>
    16.         main>
    17.         <footer slot="footer">footerfooter>
    18.     slotted-element>
    19.     <div id="slots">
    20.         <slot name="header">slot>
    21.         <slot name="content">slot>
    22.         <slot name="footer">slot>
    23.     div>
    24.     <script>
    25.         class SlottedElement extends HTMLElement {
    26.             constructor() {
    27.                 super()
    28.                 this.attachShadow({ mode: "open" })
    29.                 this.addStyle()
    30.                 this.shadowRoot.appendChild(slots)
    31.             }
    32.             addStyle() {
    33.                 const styleEle = document.createElement("style");
    34.                 // 加点样式
    35.                 styleEle.textContent = `
    36.                 #slots{
    37.                     /* 根标签 */
    38.                     background: lightblue;
    39.                 }
    40.                 ::slotted(header) {
    41.                     /* 标签选择器 */
    42.                     background: lightcoral;
    43.                 }
    44.                 ::slotted(.main) {
    45.                     /* 类选择器 */
    46.                     color: lightcoral;
    47.                 }
    48.                 ::slotted(.main) span{
    49.                     /* 无效的选择器，只能选择插槽元素，选不到子元素 */
    50.                     color: red;
    51.                 }
    52.                 ::slotted([slot="footer"]) {
    53.                     /* 属性选择器 */
    54.                     background: lightcoral;
    55.                     color: lightseagreen;
    56.                 }
    57.                 `
    58.                 this.shadowRoot.appendChild(styleEle)
    59.             }
    60.         }
    61.         customElements.define("slotted-element", SlottedElement)
    62.     script>
    63. body>
    64.  
    65. html>

    效果如下：

     

    :host-context伪类

    host-context表示宿主外部祖先节点满足某个选择器时生效对应样式，比如下面代码：

    1. html>
    2. <html lang="en">
    3.  
    4. <head>
    5.     <meta charset="UTF-8">
    6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
    7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8.     <title>ShadowDOMtitle>
    9. head>
    10.  
    11. <body>
    12.     <div>
    13.         <host-element>host-element>
    14.     div>
    15.     <div isHost>
    16.         <host-element>host-element>
    17.     div>
    18.     <div class="isHost">
    19.         <host-element>host-element>
    20.     div>
    21.     <div id="isHost">
    22.         <host-element>host-element>
    23.     div>
    24.  
    25.     <script>
    26.         class HostElement extends HTMLElement {
    27.             constructor() {
    28.                 super()
    29.                 this.attachShadow({ mode: "open" })
    30.                 this.shadowRoot.textContent = "host-element"
    31.                 this.addStyle()
    32.             }
    33.             addStyle() {
    34.                 const styleEle = document.createElement("style");
    35.                 // 加点样式
    36.                 styleEle.textContent = `
    37.             :host-context(div) {
    38.                 font-size:20px;
    39.                 color:lightcoral;
    40.                 border: 1px solid black;
    41.             }
    42.             :host-context([isHost]) {
    43.                 background:lightgreen;
    44.             }
    45.             :host-context(.isHost) {
    46.                 background:lightblue;
    47.             }
    48.             :host-context(#isHost) {
    49.                 background:green;
    50.             }`
    51.                 this.shadowRoot.appendChild(styleEle)
    52.             }
    53.         }
    54.         customElements.define("host-element", HostElement)
    55.     script>
    56. body>
    57.  
    58. html>

    上面的代码中，我们分别对div标签，isHost属性，类名为isHost，id为isHost这四类选择器生效时其子标签展示出不同的的样式效果做了一个示例，效果如下

    样式变量

    在影子DOM中使用全局样式可以通过CSS的样式变量的形式来实现，在CSS样式变量的文章中，我们探讨了CSS样式var关键字的用法，我们可以在全局定义变量，然后在阴影DOM中使用对应变量的方式实现全局样式的引用：

    1. html>
    2. <html lang="en">
    3.  
    4. <head>
    5.     <meta charset="UTF-8">
    6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
    7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8.     <title>ShadowDOMtitle>
    9.     <style>
    10.         /* 可以在shadowDom中使用 */
    11.         [theme="theme1"] {
    12.             --primary-color: lightblue;
    13.             --primary-font-size: 20px;
    14.         }
    15.  
    16.         /* 只能作用于自定义标签上 */
    17.         variable-element {
    18.             background: lightcoral;
    19.         }
    20.     style>
    21. head>
    22.  
    23. <body theme="theme1">
    24.     <div>
    25.         <variable-element>variable-element>
    26.     div>
    27.     <script>
    28.         class VariableElement extends HTMLElement {
    29.             constructor() {
    30.                 super()
    31.                 this.attachShadow({ mode: "open" })
    32.                 this.shadowRoot.textContent = "variable-element"
    33.                 this.addStyle()
    34.                 this.addElem()
    35.             }
    36.             addElem() {
    37.                 const divEle = document.createElement("div")
    38.                 divEle.textContent = "divEle"
    39.                 this.shadowRoot.appendChild(divEle)
    40.             }
    41.             addStyle() {
    42.                 const styleEle = document.createElement("style");
    43.                 // 加点样式
    44.                 styleEle.textContent = `
    45.             :host {
    46.                 color: var(--primary-color);
    47.                 font-size: var(--primary-font-size);
    48.             }
    49.             `
    50.                 this.shadowRoot.appendChild(styleEle)
    51.             }
    52.         }
    53.         customElements.define("variable-element", VariableElement)
    54.     script>
    55. body>
    56.  
    57. html>

    总结

    本文介绍了在Web Components中使用Shadow DOM的样式及选择器的相关知识点，其中:host伪类用于在Shadow DOM内部为自定义元素定义样式；::part伪元素选择器可以为Shadow DOM内部的特定部分（一般是子元素）定义样式；::slotted伪元素选择器用于选择插槽中的元素；:host-context(selector)则是用于选择满足特定选择器条件的宿主外部祖先节点，并为宿主标签设置样式；最后是全局样式的使用途径：CSS变量。

    以上就是文章的全部内容了，如果觉得文章不错的话，还望三连支持一下！谢谢~

    相关代码：

    myCode: 基于js的一些小案例或者项目 - Gitee.com

    参考文章：

    给 Shadow DOM 添加样式

  • 相关阅读:
    【LeetCode每日一题合集】2023.10.9-2023.10.15（贪心&⭐位运算的应用：只出现一次的数字）
    SSM 线上知识竞赛系统-计算机毕设 附源码 27170
    java计算机毕业设计ssm+vue社区公益服务平台
    PLC和SCADA有什么区别？
    【小程序项目开发 -- 京东商城】uni-app 商品分类页面（下）
    HTML+CSS项目案例
    61：第五章：开发admin管理服务：14：开发【友情链接列表查询，接口】；（核心是：理解MongoDB，查询数据的逻辑）
    .NET Redis限制接口请求频率 滑动窗口算法
    RSA:基于小加密指数的攻击方式与思维技巧
    3dmax渲染内存不足，这样解决！
  • 原文地址：https://blog.csdn.net/time_____/article/details/132093289