原生嵌套规则

原生嵌套规则

CSS原生嵌套规则允许开发者在一个选择器内部编写另一个选择器的样式，这种结构化的编写方式让代码更易于维护和理解。嵌套减少了重复代码，使样式表更加简洁。

基本语法

原生嵌套使用与Sass/Less类似的语法，但直接在原生CSS中实现。基本结构是将子选择器放在父选择器的花括号内：

.parent {
  color: red;
  
  .child {
    font-size: 16px;
  }
}

编译后等同于：

.parent {
  color: red;
}

.parent .child {
  font-size: 16px;
}

嵌套组合器

嵌套支持所有CSS组合器，包括后代、子代、相邻兄弟和通用兄弟选择器：

/* 后代选择器 */
nav {
  ul {
    margin: 0;
  }
}

/* 子代选择器 */
article {
  > p {
    line-height: 1.5;
  }
}

/* 相邻兄弟选择器 */
h2 {
  + p {
    margin-top: 0;
  }
}

/* 通用兄弟选择器 */
h3 {
  ~ p {
    color: #666;
  }
}

&符号的用法

&符号代表父选择器，在需要连接或修改父选择器时特别有用：

.button {
  &-primary {
    background: blue;
  }
  
  &:hover {
    opacity: 0.8;
  }
  
  .dark-theme & {
    color: white;
  }
}

编译结果为：

.button-primary {
  background: blue;
}

.button:hover {
  opacity: 0.8;
}

.dark-theme .button {
  color: white;
}

嵌套媒体查询

媒体查询也可以嵌套在规则内部，使响应式设计更模块化：

.container {
  width: 100%;
  
  @media (min-width: 768px) {
    width: 750px;
  }
  
  @media (min-width: 992px) {
    width: 970px;
  }
}

嵌套@规则

除了媒体查询，其他@规则如@supports、@keyframes等也可以嵌套：

.element {
  @supports (display: grid) {
    display: grid;
  }
  
  animation: fade 2s;
  
  @keyframes fade {
    from { opacity: 0; }
    to { opacity: 1; }
  }
}

嵌套伪类和伪元素

伪类和伪元素的嵌套使代码更加直观：

.list-item {
  padding: 10px;
  
  &:first-child {
    padding-top: 20px;
  }
  
  &:last-child {
    padding-bottom: 20px;
  }
  
  &::before {
    content: "•";
    margin-right: 5px;
  }
}

复杂嵌套示例

结合多种嵌套方式创建复杂结构：

.card {
  border: 1px solid #ddd;
  border-radius: 4px;
  
  &-header {
    padding: 15px;
    border-bottom: 1px solid #eee;
    
    h3 {
      margin: 0;
    }
  }
  
  &-body {
    padding: 15px;
    
    p {
      &:first-of-type {
        margin-top: 0;
      }
      
      &:last-of-type {
        margin-bottom: 0;
      }
    }
  }
  
  @media (min-width: 768px) {
    display: flex;
    
    &-header {
      flex: 0 0 200px;
      border-bottom: none;
      border-right: 1px solid #eee;
    }
  }
}

嵌套中的变量

CSS变量也可以在嵌套结构中使用：

:root {
  --primary-color: #4285f4;
}

.button {
  --button-padding: 10px 15px;
  
  padding: var(--button-padding);
  
  &-primary {
    background: var(--primary-color);
  }
}

嵌套的局限性

虽然嵌套功能强大，但需要注意：

1. 过度嵌套会导致选择器过于具体，影响性能
2. 深层嵌套降低代码可读性
3. 某些复杂选择器可能无法通过嵌套表达

/* 无法直接嵌套表达的选择器 */
a:not(.disabled) {
  color: blue;
}

嵌套与BEM方法论

嵌套可以与BEM等命名方法论结合使用：

.block {
  &__element {
    color: red;
    
    &--modifier {
      font-weight: bold;
    }
  }
}

编译结果为：

.block__element {
  color: red;
}

.block__element--modifier {
  font-weight: bold;
}

浏览器兼容性

截至2023年，原生CSS嵌套已得到现代浏览器支持，但部分旧版本可能需要前缀或polyfill。可以通过@supports检测支持情况：

@supports (selector(&)) {
  /* 支持嵌套的样式 */
}

@supports not (selector(&)) {
  /* 不支持嵌套的备用样式 */
}

性能考虑

嵌套生成的CSS选择器与手写选择器性能相同，但需注意：

1. 避免超过3层的深层嵌套
2. 减少不必要的嵌套层级
3. 对于高频交互元素，保持选择器简洁

/* 不推荐 */
.page {
  .content {
    .widget {
      .title {
        /* 四层嵌套 */
      }
    }
  }
}

/* 推荐 */
.page-content-widget-title {
  /* 单一类名 */
}

嵌套与CSS预处理器的区别

原生嵌套与Sass/Less等预处理器的嵌套主要区别在于：

1. 原生嵌套是浏览器直接解析，不需要编译
2. 语法上有细微差别，如必须使用&表示父选择器
3. 某些高级预处理功能可能不支持

/* Sass中可以省略& */
.menu {
  item { /* 在原生CSS中无效 */
    color: red;
  }
}

/* 原生CSS必须写为 */
.menu {
  & item {
    color: red;
  }
}

实际应用场景

嵌套特别适合以下场景：

1. 组件化开发中的样式封装
2. 需要明确父子关系的UI结构
3. 需要频繁使用父选择器变体的情况

/* 组件示例 */
.alert {
  padding: 15px;
  border-radius: 4px;
  
  &-success {
    background: #dff0d8;
    border: 1px solid #d6e9c6;
  }
  
  &-danger {
    background: #f2dede;
    border: 1px solid #ebccd1;
  }
  
  &-close {
    float: right;
    cursor: pointer;
  }
}

嵌套与CSS作用域

嵌套可以模拟某种程度的样式作用域，但不是真正的样式隔离：

.tabs {
  .tab {
    /* 只影响.tabs内的.tab */
  }
}

/* 不同于 */
.tab {
  /* 影响所有.tab元素 */
}

嵌套与CSS自定义属性

嵌套结构中CSS变量具有继承特性：

.component {
  --text-color: #333;
  
  .child {
    color: var(--text-color);
    
    &.dark {
      --text-color: #fff;
    }
  }
}

调试嵌套样式

浏览器开发者工具已支持直接显示嵌套结构，调试时可以：

1. 查看生成的最终选择器
2. 检查嵌套层级是否正确
3. 验证特异性计算

/* 调试示例 */
.widget {
  .title {
    /* 在开发者工具中会显示为.widget .title */
  }
}

嵌套与CSS模块化

嵌套促进了CSS的模块化编写方式，每个组件可以包含自己的完整样式结构：

/* 用户卡片模块 */
.user-card {
  display: flex;
  
  &-avatar {
    width: 50px;
    height: 50px;
    border-radius: 50%;
  }
  
  &-info {
    margin-left: 15px;
    
    &-name {
      font-weight: bold;
    }
    
    &-title {
      color: #666;
    }
  }
}

嵌套与现有代码迁移

将现有CSS迁移到嵌套语法时建议：

1. 逐步重构，不要一次性全部修改
2. 保持选择器特异性不变
3. 注意嵌套后生成的最终选择器是否与原来一致

/* 原始CSS */
.sidebar .menu li.active > a {}

/* 嵌套版本 */
.sidebar {
  .menu {
    li {
      &.active {
        > a {}
      }
    }
  }
}

嵌套与CSS框架

使用CSS框架时，嵌套可以更好地封装覆盖样式：

.bootstrap-overrides {
  .btn {
    border-radius: 0;
    
    &.btn-primary {
      background: var(--brand-color);
    }
  }
}

嵌套与CSS-in-JS比较

相比CSS-in-JS解决方案，原生嵌套：

1. 不需要JavaScript运行时
2. 性能更好
3. 但缺乏真正的样式隔离和动态能力

/* 原生嵌套 */
.component {
  .item {
    color: red;
  }
}

/* CSS-in-JS等效 */
const styles = {
  item: {
    color: 'red'
  }
}

嵌套最佳实践

1. 限制嵌套深度（建议不超过3层）
2. 使用有意义的命名
3. 避免过度依赖嵌套创建特异性
4. 结合CSS自定义属性使用
5. 为复杂组件保留平面结构选项

/* 推荐做法 */
.modal {
  &-header, &-body, &-footer {
    padding: 15px;
  }
  
  &-header {
    border-bottom: 1px solid #eee;
  }
}

/* 不推荐 */
.modal {
  .modal-header {
    .modal-header-inner {
      .modal-header-title {
        /* 嵌套过深 */
      }
    }
  }
}