当前位置：首页 > article >正文

CSS系列（14）--后处理器详解

article 2025/1/19 20:36:20

前端技术探索系列：CSS 后处理器详解 🔧

致读者：探索 CSS 工程化的未来 👋

前端开发者们，

今天我们将深入探讨 CSS 后处理器，特别是 PostCSS 的使用及其生态系统。

PostCSS 基础 🚀

配置与使用

// postcss.config.js
module.exports = {
    plugins: [
        require('autoprefixer'),
        require('postcss-preset-env'),
        require('cssnano')
    ]
}

基础语法转换

/* 输入 CSS */
.example {
    display: grid;
    transition: all .5s;
    user-select: none;
    background: #9a9;
}

/* PostCSS 处理后 */
.example {
    display: -ms-grid;
    display: grid;
    -webkit-transition: all .5s;
    transition: all .5s;
    -webkit-user-select: none;
       -moz-user-select: none;
        -ms-user-select: none;
            user-select: none;
    background: #99aa99;
}

常用插件详解 🎯

Autoprefixer

/* 使用现代CSS */
.flex-container {
    display: flex;
    justify-content: space-between;
    align-items: center;
}

/* Autoprefixer 处理后 */
.flex-container {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-pack: justify;
        -ms-flex-pack: justify;
            justify-content: space-between;
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;
}

PostCSS Preset Env

/* 使用未来语法 */
.container {
    /* 自定义属性集 */
    @custom-media --viewport-medium (width <= 50rem);
    
    /* 嵌套规则 */
    & .content {
        /* 自定义属性 */
        --main-color: #12345678;
        color: var(--main-color);
        
        /* 计算函数 */
        width: calc(100% - 20px);
    }
}

@media (--viewport-medium) {
    .container {
        padding: 0 20px;
    }
}

CSS Modules

/* styles.module.css */
.button {
    background: blue;
    color: white;
}

.button:hover {
    background: darkblue;
}

/* 组合样式 */
.primaryButton {
    composes: button;
    font-weight: bold;
}

自定义插件开发 🛠️

// 自定义 PostCSS 插件
const postcss = require('postcss');

class PostCSSProcessor {
    constructor(options = {}) {
        this.options = {
            prefix: 'app-',
            important: false,
            ...options
        };
    }

    createPlugin() {
        return postcss.plugin('postcss-custom-processor', (opts = {}) => {
            const options = { ...this.options, ...opts };

            return (root, result) => {
                // 处理每个规则
                root.walkRules(rule => {
                    this.processRule(rule, options);
                });

                // 处理每个声明
                root.walkDecls(decl => {
                    this.processDeclaration(decl, options);
                });

                // 处理每个@规则
                root.walkAtRules(atRule => {
                    this.processAtRule(atRule, options);
                });
            };
        });
    }

    processRule(rule, options) {
        // 添加前缀
        if (options.prefix && !rule.selector.startsWith('.'+options.prefix)) {
            rule.selector = '.' + options.prefix + rule.selector.slice(1);
        }
    }

    processDeclaration(decl, options) {
        // 添加 !important
        if (options.important && !decl.important) {
            decl.important = true;
        }

        // 处理特殊属性
        if (decl.prop.startsWith('--')) {
            this.processCustomProperty(decl);
        }
    }

    processAtRule(atRule, options) {
        // 处理媒体查询
        if (atRule.name === 'media') {
            this.processMediaQuery(atRule);
        }
    }

    processCustomProperty(decl) {
        // 处理自定义属性
        const value = decl.value;
        if (value.includes('calc')) {
            // 处理计算表达式
            decl.value = this.processCalc(value);
        }
    }

    processMediaQuery(atRule) {
        // 处理媒体查询
        const params = atRule.params;
        if (params.includes('--')) {
            // 处理自定义媒体查询
            atRule.params = this.processCustomMedia(params);
        }
    }

    processCalc(value) {
        // 处理计算表达式
        return value.replace(/calc\((.*?)\)/g, (match, expression) => {
            try {
                return this.evaluateExpression(expression);
            } catch (e) {
                return match;
            }
        });
    }

    processCustomMedia(params) {
        // 处理自定义媒体查询
        return params.replace(/--[\w-]+/g, (match) => {
            return this.getCustomMediaValue(match);
        });
    }

    evaluateExpression(expression) {
        // 安全的表达式计算
        const sanitized = expression
            .replace(/[^0-9+\-*/\s.()]/g, '')
            .replace(/\s+/g, ' ');
        return eval(sanitized);
    }

    getCustomMediaValue(name) {
        // 获取自定义媒体查询值
        const customMedia = {
            '--small': '(max-width: 30em)',
            '--medium': '(max-width: 50em)',
            '--large': '(max-width: 70em)'
        };
        return customMedia[name] || name;
    }
}

工程化实践 💡

1. 构建配置

// webpack.config.js
module.exports = {
    module: {
        rules: [
            {
                test: /\.css$/,
                use: [
                    'style-loader',
                    {
                        loader: 'css-loader',
                        options: {
                            modules: true,
                            importLoaders: 1
                        }
                    },
                    'postcss-loader'
                ]
            }
        ]
    }
};

2. 性能优化

// postcss.config.js
module.exports = {
    plugins: [
        require('autoprefixer'),
        require('postcss-preset-env')({
            stage: 3,
            features: {
                'nesting-rules': true
            }
        }),
        require('cssnano')({
            preset: ['default', {
                discardComments: {
                    removeAll: true
                },
                normalizeWhitespace: false
            }]
        })
    ]
};

3. 开发工具集成

// stylelint.config.js
module.exports = {
    extends: ['stylelint-config-standard'],
    plugins: ['stylelint-scss'],
    rules: {
        'at-rule-no-unknown': null,
        'scss/at-rule-no-unknown': true
    }
};