CSS-Präprozessor

Was ist ein CSS-Präprozessor? Im Allgemeinen haben sie eine Reihe ihrer eigenen DSL (Domain Specific Language) basierend auf CSS erweitert, um Probleme zu lösen, die für uns beim Schreiben von CSS schwer zu lösen sind:

• Die Syntax ist nicht leistungsstark genug. B. die Unfähigkeit, das Schreiben zu verschachteln. Dies führt dazu, dass in der modularen Entwicklung viele wiederholte Selektoren geschrieben werden müssen.
• verfügt nicht über Variablen und einen angemessenen Stilwiederverwendungsmechanismus, sodass logisch verwandte Attributwerte wiederholt ausgegeben werden müssen die Form von Literalen, was die Wartung erschwert.

Es kommt auf die Abstraktionsfähigkeit an. Dies bestimmt also das Hauptziel des CSS-Präprozessors: den in CSS fehlenden Mechanismus zur Wiederverwendung von Stilebenen bereitzustellen, redundanten Code zu reduzieren und die Wartbarkeit von Stilcode zu verbessern. Das ist nicht das i-Tüpfelchen, sondern eine rechtzeitige Hilfe.

Der CSS-Präprozessor ist jedoch kein Allheilmittel. Der Vorteil von CSS besteht darin, dass er jederzeit und überall einfach zu verwenden und zu debuggen ist. Das Hinzufügen des vorkompilierten CSS-Schritts fügt unserem Entwicklungsworkflow eine weitere Verknüpfung hinzu und macht das Debuggen schwieriger. Das größere Problem besteht darin, dass die Vorkompilierung leicht zum Missbrauch von Nachkommenselektoren führen kann. Achten Sie daher bei der Verwendung von CSS-Präprozessoren darauf, solche Probleme zu vermeiden.

Sass-Variablen, die mit $ beginnen, geraten weniger wahrscheinlich in Konflikt mit der CSS-Standardsyntax. Variablen in Less beginnen mit @. Obwohl es leicht zu Konflikten mit der neuen Syntax nachfolgender Spezifikationsaktualisierungen kommen kann, ist das Problem theoretisch nicht groß, solange die CSS-Spezifikation keine Regeln wie @a: b einführt. Darüber hinaus wird bei der Formulierung der Spezifikationen auf viele bestehende Implementierungen zurückgegriffen.

Die variablen Mechanismen von Sass und Less ähneln denen von JS auf Blockebene. Werte können innerhalb des Gültigkeitsbereichs neu zugewiesen werden, ohne dass dies Auswirkungen auf die Außenwelt hat globale Zuordnung. SASS und SCSS sind nur zwei Syntaxstile. SCSS ist näher an der CSS-Syntax und lässt sich bequemer im Frontend schreiben. Es gibt keinen offensichtlichen Unterschied zwischen den am häufigsten verwendeten Teilen von Less und Sass. Machen Sie sich also keine allzu großen Gedanken darüber, welchen Sie verwenden möchten, sondern wählen Sie einfach einen aus. Was das Unternehmen angeht, bleiben Sie einfach dabei. Wenn es keine größeren Probleme gibt, denken Sie nicht über einen Wechsel nach.

Dateiaufteilung

Die Seiten werden immer komplexer und die zu ladenden CSS-Dateien werden immer größer Für uns ist es schwierig, die großen Dateien aufzuteilen. Herkömmliche CSS-Dateiaufteilungslösungen sind im Wesentlichen CSS-native @import-Anweisungen oder das Laden mehrerer CSS-Dateien in HTML. Diese Lösungen können die Leistungsanforderungen normalerweise nicht erfüllen.

CSS-Präprozessor erweitert die Funktionen der @import-Direktive, um die geteilten Dateien während des Kompilierungsprozesses wieder zu einer großen Datei zusammenzuführen. Dies löst einerseits das Problem der umständlichen Wartung großer Dateien und andererseits auch das Leistungsproblem beim Laden einer Reihe kleiner Dateien.

Modularisierung

Die Idee der Dateisegmentierung noch einen Schritt weiter zu führen heißt „Modularisierung“. Nachdem eine große CSS-Datei sinnvoll aufgeteilt wurde, sollte die Beziehung zwischen den resultierenden kleinen Dateien eine Baumstruktur sein.

Der Wurzelknoten des Baums wird im Allgemeinen als „Eintragsdatei“ bezeichnet, und die anderen Knoten des Baums werden im Allgemeinen als „Moduldateien“ bezeichnet. Eintragsdateien hängen normalerweise von mehreren Moduldateien ab, und jede Moduldatei kann auch von anderen Terminalmodulen abhängen und so den gesamten Baum bilden.

Das Folgende ist ein einfaches Beispiel:

entry.less
 ├─ base.less
 │   ├─ normalize.less
 │   └─ reset.less
 ├─ layout.less
 │   ├─ header.less
 │   │   └─ nav.less
 │   └─ footer.less
 ├─ section-foo.less
 ├─ section-bar.less
 └─ ...复制代码

Eintragsdatei entry.less Die erforderlichen Module werden während der Kompilierung eingeführt, ein Eintrag.css wird generiert und dann von der Seite referenziert.

Wenn Sie andere Programmiersprachen mit einem Modulmechanismus verwendet haben, sollten Sie bereits ein tiefes Verständnis dafür haben. Modularisierung ist eine sehr gute Möglichkeit, Code zu organisieren und ein wichtiges Mittel für Entwickler, Code zu entwerfen Struktur. Module können Code-Layering, Wiederverwendung und Abhängigkeitsmanagement klar implementieren, sodass der CSS-Entwicklungsprozess den Komfort moderner Programmentwicklung genießen kann.

Selektorverschachtelung

Selektorverschachtelung ist eine Code-Organisationsmethode innerhalb einer Datei, die es einer Reihe verwandter Regeln ermöglicht, eine hierarchische Beziehung darzustellen.

Variablen

Bevor die Änderung eintritt, sind alle Eigenschaftswerte in CSS „magische Zahlen“. Sie wissen nicht, woher dieser Wert kommt und was er bedeutet. Nachdem wir Variablen haben, können wir diesen „magischen Zahlen“ Namen geben, um das Gedächtnis, das Lesen und das Verstehen zu erleichtern.

Als nächstes werden wir feststellen, dass Variablen eine einfache und effektive Abstraktionsmethode sind, die solche Duplikate vermeiden und Ihren Code trockener machen kann, wenn ein bestimmter Wert an mehreren Stellen verwendet wird.

Variablen erleichtern Entwicklern die Vereinheitlichung des visuellen Stils der Website und erleichtern auch Anforderungen wie „Skin-Änderung“.

Operation

Nur ​​Variablen zu haben reicht nicht aus, wir brauchen auch Operationen. Wenn Variablen Werte sinnvoll machen, können Operationen Werte mit Werten verknüpfen. Die Werte einiger Attribute stehen tatsächlich in engem Zusammenhang mit den Werten anderer Attribute. Die CSS-Syntax kann diese Beziehung in der Vorverarbeitungssprache nicht ausdrücken.

Zum Beispiel müssen wir dafür sorgen, dass ein Container höchstens drei Zeilen Text anzeigt. Früher haben wir das normalerweise so geschrieben:

.wrapper {	overflow-y: hidden;	line-height: 1.5;	max-height: 4.5em;  /* = 1.5 x 3 */}复制代码

大家可以发现，我们只能用注释来表达 max-height 的值是怎么来的，而且注释中 3 这样的值也是幻数，还需要进一步解释。未来当行高或行数发生变化的时候，max-height 的值和注释中的算式也需要同步更新，维护起来很不方便。

接下来我们用预处理语言来改良一下：

.wrapper
	$max-lines = 3
	$line-height = 1.5

	overflow-y: hidden
	line-height: $line-height
	max-height: unit($line-height * $max-lines, 'em')复制代码

乍一看，代码行数似乎变多了，但代码的意图却更加清楚了——不需要任何注释就把整件事情说清楚了。在后期维护时，只要修改那两个变量就可以了。

值得一提的是，这种写法还带来另一个好处。$line-height 这个变量可以是 .wrapper 自己定义的局部变量（比如上面那段代码），也可以从更上层的作用域获取：

$line-height = 1.5  // 全局统一行高

body
	line-height: $line-height

.wrapper
	$max-lines = 3

	max-height: unit($line-height * $max-lines, 'em')
	overflow-y: hidden复制代码

这意味着 .wrapper 可以向祖先继承行高，而不需要为这个“只显示三行”的需求把自己的行高写死。有了运算，我们就有能力表达属性与属性之间的关联，它令我们的代码更加灵活、更加 DRY。

函数

把常用的运算操作抽象出来，我们就得到了函数。

开发者可以自定义函数，预处理器自己也内置了大量的函数。最常用的内置函数应该就是颜色的运算函数了吧！有了它们，我们甚至都不需要打开 Photoshop 来调色，就可以得到某个颜色的同色系变种了。

举个例子，我们要给一个按钮添加鼠标悬停效果，而最简单的悬停效果就是让按钮的颜色加深一些。我们写出的 CSS 代码可能是这样的：

.button {	background-color: #ff4466;
}.button:hover {	background-color: #f57900;
}复制代码

我相信即使是最资深的视觉设计师，也很难分清 #ff4466 和 #f57900 这两种颜色到底有什么关联。而如果我们的代码是用预处理语言来写的，那事情就直观多了：

.button
	$color = #ff9833

	background-color: $color
	&:hover
		background-color: darken($color, 20%)复制代码

此外，预处理器的函数往往还支持默认参数、具名实参、arguments 对象等高级功能，内部还可以设置条件分支，可以满足复杂的逻辑需求。

Mixin

Mixin 是 CSS 预处理器提供的又一项实用功能。Mixin 的形态和用法跟函数十分类似——先定义，然后在需要的地方调用，在调用时可以接受参数。它与函数的不同之处在于，函数用于产生一个值，而 Mixin 的作用是产生一段 CSS 代码。

Mixin 可以产生多条 CSS 规则，也可以只产生一些 CSS 声明。

一般来说，Mixin 可以把 CSS 文件中类似的代码块抽象出来，并给它一个直观的名字。比如 CSS 框架可以把一些常用的代码片断包装为 mixin 备用，在内部按需调用，或暴露给使用者在业务层调用。

举个例子，我们经常会用到 clearfix 来闭合浮动。在原生 CSS 中，如果要避免 clearfix 代码的重复，往往只能先定义好一个 .clearfix 类，然后在 HTML 中挂载到需要的元素身上：

/* 为 clearfix 定义一个类 */
.clearfix {...}
.clearfix::after {...}复制代码

<!-- 挂载到这两个元素身上 --><p class="info clearfix">...</p>...<footer class="clearfix">...</footer>复制代码

把表现层的实现暴露到了结构层，是不是很不爽？而在预处理器中，我们还可以选择另一种重用方式：

// 为 clearfix 定义一个 mixin
clearfix()
    ...
    &::after
        ...

// 在需要的元素身上调用
.info
    clearfix()

footer
    clearfix()复制代码

工程化

CSS 预处理语言无法直接运行于浏览器环境，这意味着我们编写的源码需要编译为 CSS 代码之后才能用于网页。这似乎是一个门槛，需要我们付出“额外”的成本。

但在目前的大环境下，大多数项目的前端开发流程已经包含了构建环节，比如选择任何一个脚本模块化方案都是需要在部署时走一道打包程序的。所以对大多数团队来说，这个门槛其实已经跨过去一大半了。

而一旦接受了这种设定，我们还可以享受到“额外”的福利。在给 CSS 的开发加入编译环节的同时，还可以顺道加入其它构建环节，比如代码校验、代码压缩、代码后处理等等。

“代码后处理”是指 PostCSS 平台上各类插件所提供的功能，光是 Autoprefixer 这一项就已经值回票价了。我们再也不需要在 CSS 代码中手工添加浏览器前缀了，直接使用标准写法，剩下的事情让工具搞定吧！

推荐教程：《CSS教程》

Das obige ist der detaillierte Inhalt vonCSS-Präprozessor. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!