HTML5系列（11）-- Web 无障碍开发指南

前端技术探索系列：HTML5 Web 无障碍开发指南

致读者：构建人人可用的网络 ??

前端开发者们，

今天我们将深入探讨 Web 无障碍开发，学习如何创建一个真正包容、人人可用的网站。让我们一起为更多用户提供更好的网络体验。

ARIA 角色与属性 ??

基础 ARIA 实现

<!-- 导航菜单示例 -->
<nav role="navigation" aria-label="主导航">
    <ul role="menubar">
        <li role="none">
            <a role="menuitem" 
               href="/" 
               aria-current="page">
                首页
            </a>
        </li>
        <li role="none">
            <button role="menuitem"
                    aria-haspopup="true"
                    aria-expanded="false"
                    aria-controls="submenu-1">
                产品
            </button>
            <ul id="submenu-1" 
                role="menu" 
                aria-hidden="true">
                <li role="none">
                    <a role="menuitem" href="/products/new">
                        最新产品
                    </a>
                </li>
            </ul>
        </li>
    </ul>
</nav>

动态内容管理

class AccessibleComponent {
    constructor(element) {
        this.element = element;
        this.setupKeyboardNavigation();
    }

    // 设置键盘导航
    setupKeyboardNavigation() {
        this.element.addEventListener('keydown', (e) => {
            switch(e.key) {
                case 'Enter':
                case ' ':
                    this.activate(e);
                    break;
                case 'ArrowDown':
                    this.navigateNext(e);
                    break;
                case 'ArrowUp':
                    this.navigatePrevious(e);
                    break;
                case 'Escape':
                    this.close(e);
                    break;
            }
        });
    }

    // 更新 ARIA 状态
    updateARIAState(element, state, value) {
        element.setAttribute(`aria-${state}`, value);
        
        // 通知屏幕阅读器
        this.announceChange(`${state} 已更改为 ${value}`);
    }

    // 向屏幕阅读器通知变化
    announceChange(message) {
        const announcement = document.createElement('div');
        announcement.setAttribute('aria-live', 'polite');
        announcement.setAttribute('class', 'sr-only');
        announcement.textContent = message;
        
        document.body.appendChild(announcement);
        setTimeout(() => announcement.remove(), 1000);
    }
}

语义化增强 ??

表单无障碍实现

<form role="form" aria-label="注册表单">
    <div class="form-group">
        <label for="username" id="username-label">
            用户名
            <span class="required" aria-hidden="true">*</span>
        </label>
        <input type="text"
               id="username"
               name="username"
               required
               aria-required="true"
               aria-labelledby="username-label"
               aria-describedby="username-help"
               aria-invalid="false">
        <div id="username-help" class="help-text">
            请输入3-20个字符的用户名
        </div>
    </div>

    <div class="form-group">
        <label for="password">密码</label>
        <div class="password-input">
            <input type="password"
                   id="password"
                   name="password"
                   aria-label="密码"
                   aria-describedby="password-requirements">
            <button type="button"
                    aria-label="显示密码"
                    aria-pressed="false"
                    onclick="togglePassword()">
                ???
            </button>
        </div>
        <div id="password-requirements" class="help-text">
            密码必须包含字母和数字，长度至少8位
        </div>
    </div>
</form>

表单验证与反馈

class AccessibleForm {
    constructor(formElement) {
        this.form = formElement;
        this.setupValidation();
    }

    setupValidation() {
        this.form.addEventListener('submit', this.handleSubmit.bind(this));
        this.form.addEventListener('input', this.handleInput.bind(this));
    }

    handleInput(e) {
        const field = e.target;
        const isValid = field.checkValidity();
        
        field.setAttribute('aria-invalid', !isValid);
        
        if (!isValid) {
            this.showError(field);
        } else {
            this.clearError(field);
        }
    }

    showError(field) {
        const errorId = `${field.id}-error`;
        let errorElement = document.getElementById(errorId);
        
        if (!errorElement) {
            errorElement = document.createElement('div');
            errorElement.id = errorId;
            errorElement.className = 'error-message';
            errorElement.setAttribute('role', 'alert');
            field.parentNode.appendChild(errorElement);
        }
        
        errorElement.textContent = field.validationMessage;
        field.setAttribute('aria-describedby', 
            `${field.getAttribute('aria-describedby') || ''} ${errorId}`.trim());
    }

    clearError(field) {
        const errorId = `${field.id}-error`;
        const errorElement = document.getElementById(errorId);
        
        if (errorElement) {
            errorElement.remove();
            const describedBy = field.getAttribute('aria-describedby')
                .replace(errorId, '').trim();
            if (describedBy) {
                field.setAttribute('aria-describedby', describedBy);
            } else {
                field.removeAttribute('aria-describedby');
            }
        }
    }
}

辅助技术支持 ??

颜色对比度检查

class ColorContrastChecker {
    constructor() {
        this.minimumRatio = 4.5; // WCAG AA 标准
    }

    // 计算相对亮度
    calculateLuminance(r, g, b) {
        const [rs, gs, bs] = [r, g, b].map(c => {
            c = c / 255;
            return c <= 0.03928
                ? c / 12.92
                : Math.pow((c + 0.055) / 1.055, 2.4);
        });
        return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
    }

    // 计算对比度
    calculateContrastRatio(color1, color2) {
        const l1 = this.calculateLuminance(...this.parseColor(color1));
        const l2 = this.calculateLuminance(...this.parseColor(color2));
        
        const lighter = Math.max(l1, l2);
        const darker = Math.min(l1, l2);
        
        return (lighter + 0.05) / (darker + 0.05);
    }

    // 解析颜色值
    parseColor(color) {
        const hex = color.replace('#', '');
        return [
            parseInt(hex.substr(0, 2), 16),
            parseInt(hex.substr(2, 2), 16),
            parseInt(hex.substr(4, 2), 16)
        ];
    }

    // 检查对比度是否符合标准
    isContrastValid(color1, color2) {
        const ratio = this.calculateContrastRatio(color1, color2);
        return {
            ratio,
            passes: ratio >= this.minimumRatio,
            level: ratio >= 7 ? 'AAA' : ratio >= 4.5 ? 'AA' : 'Fail'
        };
    }
}

字体可读性增强

/* 基础可读性样式 */
:root {
    --min-font-size: 16px;
    --line-height-ratio: 1.5;
    --paragraph-spacing: 1.5rem;
}

body {
    font-family: system-ui, -apple-system, sans-serif;
    font-size: var(--min-font-size);
    line-height: var(--line-height-ratio);
    text-rendering: optimizeLegibility;
}

/* 响应式字体大小 */
@media screen and (min-width: 320px) {
    body {
        font-size: calc(var(--min-font-size) + 0.5vw);
    }
}

/* 提高可读性的文本间距 */
p {
    margin-bottom: var(--paragraph-spacing);
    max-width: 70ch; /* 最佳阅读宽度 */
}

/* 链接可访问性 */
a {
    text-decoration: underline;
    text-underline-offset: 0.2em;
    color: #0066cc;
}

a:hover, a:focus {
    text-decoration-thickness: 0.125em;
    outline: 2px solid currentColor;
    outline-offset: 2px;
}

/* 焦点样式 */
:focus {
    outline: 3px solid #4A90E2;
    outline-offset: 2px;
}

/* 隐藏元素但保持可访问性 */
.sr-only {
    position: absolute;
    width: 1px;
    height: 1px;
    padding: 0;
    margin: -1px;
    overflow: hidden;
    clip: rect(0, 0, 0, 0);
    border: 0;
}

实践项目：无障碍审计工具 ??

审计工具实现

class AccessibilityAuditor {
    constructor() {
        this.issues = [];
    }

    // 运行完整审计
    async audit() {
        this.issues = [];
        
        // 检查图片替代文本
        this.checkImages();
        
        // 检查表单标签
        this.checkForms();
        
        // 检查标题层级
        this.checkHeadings();
        
        // 检查颜色对比度
        await this.checkColorContrast();
        
        // 检查键盘可访问性
        this.checkKeyboardAccess();
        
        return this.generateReport();
    }

    // 检查图片替代文本
    checkImages() {
        const images = document.querySelectorAll('img');
        images.forEach(img => {
            if (!img.hasAttribute('alt')) {
                this.addIssue('error', 'missing-alt', 
                    '图片缺少替代文本', img);
            }
        });
    }

    // 检查表单标签
    checkForms() {
        const inputs = document.querySelectorAll('input, select, textarea');
        inputs.forEach(input => {
            if (!input.id || !document.querySelector(`label[for="${input.id}"]`)) {
                this.addIssue('error', 'missing-label',
                    '表单控件缺少关联标签', input);
            }
        });
    }

    // 检查标题层级
    checkHeadings() {
        const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
        let lastLevel = 0;
        
        headings.forEach(heading => {
            const currentLevel = parseInt(heading.tagName[1]);
            if (currentLevel - lastLevel > 1) {
                this.addIssue('warning', 'heading-skip',
                    '标题层级跳过', heading);
            }
            lastLevel = currentLevel;
        });
    }

    // 检查颜色对比度
    async checkColorContrast() {
        const contrastChecker = new ColorContrastChecker();
        const elements = document.querySelectorAll('*');
        
        elements.forEach(element => {
            const style = window.getComputedStyle(element);
            const backgroundColor = style.backgroundColor;
            const color = style.color;
            
            const contrast = contrastChecker.isContrastValid(
                backgroundColor, color
            );
            
            if (!contrast.passes) {
                this.addIssue('warning', 'low-contrast',
                    '颜色对比度不足', element);
            }
        });
    }

    // 检查键盘可访问性
    checkKeyboardAccess() {
        const interactive = document.querySelectorAll('a, button, input, select, textarea');
        interactive.forEach(element => {
            if (window.getComputedStyle(element).display === 'none' ||
                element.offsetParent === null) {
                return;
            }
            
            const tabIndex = element.tabIndex;
            if (tabIndex < 0) {
                this.addIssue('warning', 'keyboard-trap',
                    '元素不可通过键盘访问', element);
            }
        });
    }

    // 添加问题
    addIssue(severity, code, message, element) {
        this.issues.push({
            severity,
            code,
            message,
            element: element.outerHTML,
            location: this.getElementPath(element)
        });
    }

    // 获取元素路径
    getElementPath(element) {
        let path = [];
        while (element.parentElement) {
            let selector = element.tagName.toLowerCase();
            if (element.id) {
                selector += `#${element.id}`;
            }
            path.unshift(selector);
            element = element.parentElement;
        }
        return path.join(' > ');
    }

    // 生成报告
    generateReport() {
        return {
            timestamp: new Date().toISOString(),
            totalIssues: this.issues.length,
            issues: this.issues,
            summary: this.generateSummary()
        };
    }

    // 生成摘要
    generateSummary() {
        const counts = {
            error: 0,
            warning: 0
        };
        
        this.issues.forEach(issue => {
            counts[issue.severity]++;
        });
        
        return {
            errors: counts.error,
            warnings: counts.warning,
            score: this.calculateScore(counts)
        };
    }

    // 计算无障碍得分
    calculateScore(counts) {
        const total = counts.error + counts.warning;
        if (total === 0) return 100;
        
        const score = 100 - (counts.error * 5 + counts.warning * 2);
        return Math.max(0, Math.min(100, score));
    }
}

使用示例

// 初始化审计工具
const auditor = new AccessibilityAuditor();

// 运行审计
async function runAudit() {
    const results = await auditor.audit();
    displayResults(results);
}

// 显示结果
function displayResults(results) {
    const container = document.getElementById('audit-results');
    container.innerHTML = `
        <div class="audit-summary">
            <h2>无障碍审计结果</h2>
            <p>得分: ${results.summary.score}</p>
            <p>错误: ${results.summary.errors}</p>
            <p>警告: ${results.summary.warnings}</p>
        </div>
        
        <div class="audit-issues">
            ${results.issues.map(issue => `
                <div class="issue ${issue.severity}">
                    <h3>${issue.message}</h3>
                    <code>${issue.location}</code>
                    <pre><code>${issue.element}</code></pre>
                </div>
            `).join('')}
        </div>
    `;
}

// 运行审计
runAudit();