使用Sass符号（&；）选择器寻址特定的父级

我有以下简单的SCS：

.selector1,
.selector2 {
    /*Some properties*/

    &[disabled] {
        /*More properties*/
    }
}

然而，我想做的是分别处理父项，最好的解决方案是简单地声明规则不嵌套，如下所示

.selector1,
.selector2 {
    /*Some properties*/
}

.selector1[disabled] {
    /*Properties*/
}

.selector2[disabled] {
    /*Different properties*/
}

---

在使用&selector时，是否有方法区分父选择器，以便我可以嵌套与第一个示例类似的规则？

您不能，但可以使用根目录下的

属性得出类似的结果。但是，正如您所意识到的，将规则声明为非嵌套规则更为简洁

.selector1,
.selector2 {
    /*Some properties*/

    &[disabled] {
     /*Some properties*/

     @at-root .selector1[disabled] {
       /*Different properties*/
     }
   }
}

输出将是：

.selector1,
.selector2 {
  /*Some properties*/
}

.selector1[disabled],
.selector2[disabled] {
  /*Some properties*/
}

.selector1[disabled] {
  /*Different properties*/
}

例如：
您不能，但可以使用根目录下的
属性得出类似的结果。但是，正如您所意识到的，将规则声明为非嵌套规则更为简洁

.selector1,
.selector2 {
    /*Some properties*/

    &[disabled] {
     /*Some properties*/

     @at-root .selector1[disabled] {
       /*Different properties*/
     }
   }
}

输出将是：

.selector1,
.selector2 {
  /*Some properties*/
}

.selector1[disabled],
.selector2[disabled] {
  /*Some properties*/
}

.selector1[disabled] {
  /*Different properties*/
}

例如：
您不能，但可以使用根目录下的
属性得出类似的结果。但是，正如您所意识到的，将规则声明为非嵌套规则更为简洁

.selector1,
.selector2 {
    /*Some properties*/

    &[disabled] {
     /*Some properties*/

     @at-root .selector1[disabled] {
       /*Different properties*/
     }
   }
}

输出将是：

.selector1,
.selector2 {
  /*Some properties*/
}

.selector1[disabled],
.selector2[disabled] {
  /*Some properties*/
}

.selector1[disabled] {
  /*Different properties*/
}

例如：
您不能，但可以使用根目录下的
属性得出类似的结果。但是，正如您所意识到的，将规则声明为非嵌套规则更为简洁

.selector1,
.selector2 {
    /*Some properties*/

    &[disabled] {
     /*Some properties*/

     @at-root .selector1[disabled] {
       /*Different properties*/
     }
   }
}

输出将是：

.selector1,
.selector2 {
  /*Some properties*/
}

.selector1[disabled],
.selector2[disabled] {
  /*Some properties*/
}

.selector1[disabled] {
  /*Different properties*/
}

例如：
使用可能有某种方法可以做到这一点，但这需要花费大量的精力/代码，因此完全不嵌套会更有效

对于您的特定示例，扩展是一个选项：

%foo {
    /* stuff */
}

.one {
    @extend %foo;

    &[disabled] {
        /* different stuff */
    }
}

.two {
    @extend %foo;

    &[disabled] {
        /* other stuff */
    }
}

可能有一些方法可以使用来实现这一点，但这将涉及到大量的工作/代码，因此完全不嵌套将更有效

对于您的特定示例，扩展是一个选项：

%foo {
    /* stuff */
}

.one {
    @extend %foo;

    &[disabled] {
        /* different stuff */
    }
}

.two {
    @extend %foo;

    &[disabled] {
        /* other stuff */
    }
}

可能有一些方法可以使用来实现这一点，但这将涉及到大量的工作/代码，因此完全不嵌套将更有效

对于您的特定示例，扩展是一个选项：

%foo {
    /* stuff */
}

.one {
    @extend %foo;

    &[disabled] {
        /* different stuff */
    }
}

.two {
    @extend %foo;

    &[disabled] {
        /* other stuff */
    }
}

可能有一些方法可以使用来实现这一点，但这将涉及到大量的工作/代码，因此完全不嵌套将更有效

对于您的特定示例，扩展是一个选项：

%foo {
    /* stuff */
}

.one {
    @extend %foo;

    &[disabled] {
        /* different stuff */
    }
}

.two {
    @extend %foo;

    &[disabled] {
        /* other stuff */
    }
}