JavaScript性能优化实战（9）：图像与媒体资源优化

引言

在当今视觉驱动的网络环境中，图像和媒体资源往往占据了网页总下载量的60%-80%，因此对图像和媒体资源进行有效优化已成为前端性能提升的关键领域。尽管网络带宽持续提升，但用户对加载速度的期望也在不断提高，特别是在移动设备和网络条件不稳定的场景下。

本文作为JavaScript性能优化实战系列的第九篇，将深入探讨图像与媒体资源优化的各个方面，从现代图像格式选择、响应式图像加载、Canvas和WebGL渲染技巧，到视频流优化以及OffscreenCanvas的应用。我们将结合实际案例，为您提供实用且可立即应用的优化策略，助力提升您的Web应用性能。

现代图像格式选择与性能对比

图像是网页中最常见的资源类型之一，选择合适的图像格式对性能有着决定性影响。

主流图像格式性能对比

现代图像格式深入分析

WebP格式

WebP是由Google开发的图像格式，提供了优异的压缩性能。

// 使用JavaScript检测WebP支持
function checkWebPSupport() {
   
  return new Promise((resolve) => {
   
    const webpImage = new Image();
    webpImage.onload = () => {
    resolve(true); };
    webpImage.onerror = () => {
    resolve(false); };
    webpImage.src = 'data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoBAAEAAgA0JaQAA3AA/vv9UAA=';
  });
}

// 根据浏览器支持提供相应格式
async function provideOptimalImageFormat() {
   
  const isWebPSupported = await checkWebPSupport();
  const imageUrl = isWebPSupported 
    ? 'image.webp' 
    : 'image.jpg';
  document.getElementById('hero-image').src = imageUrl;
}

provideOptimalImageFormat();

AVIF格式

AVIF是基于AV1视频编解码器的图像格式，提供更好的压缩率和质量。

// 检测AVIF支持
function checkAVIFSupport() {
   
  return new Promise((resolve) => {
   
    const avifImage = new Image();
    avifImage.onload = () => {
    resolve(true); };
    avifImage.onerror = () => {
    resolve(false); };
    avifImage.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=';
  });
}

根据场景智能选择格式

基于不同图像类型的特性，我们可以智能选择最佳格式：

// 根据图像内容和浏览器支持选择最佳格式
async function selectOptimalFormat(imageType, needsTransparency) {
   
  const supportsAVIF = await checkAVIFSupport();
  const supportsWebP = await checkWebPSupport();
  
  if (imageType === 'photo') {
   
    if (supportsAVIF) return 'avif';
    if (supportsWebP) return 'webp';
    return 'jpg';
  }
  
  if (imageType === 'graphic') {
   
    if (needsTransparency) {
   
      if (supportsAVIF) return 'avif';
      if (supportsWebP) return 'webp';
      return 'png';
    }
    return 'svg';
  }
  
  if (imageType === 'animation') {
   
    if (supportsWebP) return 'webp';
    return 'gif';
  }
  
  return 'jpg'; // 默认
}

图像转换与优化工具

选择合适的格式后，我们还需要对图像进行进一步的优化：

1. sharp.js: 用于Node.js环境中高性能图像处理
2. imagemin: 广泛使用的图像压缩工具，支持多种格式
3. squoosh.app: Google提供的在线图像优化工具

以下是使用imagemin在构建流程中优化图像的示例：

// webpack.config.js中使用imagemin-webpack-plugin
const ImageminPlugin = require('imagemin-webpack-plugin').default;
const ImageminMozjpeg = require('imagemin-mozjpeg');
const ImageminPngquant = require('imagemin-pngquant');
const ImageminWebp = require('imagemin-webp');

module.exports = {
   
  // ... 其他配置
  plugins: [
    new ImageminPlugin({
   
      test: /\.(jpe?g|png|gif|svg)$/i,
      pngquant: {
   
        quality: '65-80'
      },
      plugins: [
        ImageminMozjpeg({
   
          quality: 75,
          progressive: true
        }),
        ImageminWebp({
    quality: 75 })
      ]
    })
  ]
};

图像格式性能测试与对比

下面展示了不同格式对同一图像的压缩效果对比：

关键发现：对于典型的图像内容，WebP比JPEG减少约50%的文件大小，而AVIF比WebP再减少约50%。这直接转化为加载时间的显著改善。

响应式图像加载与懒加载实现

在不同设备和网络条件下，我们需要为用户提供最适合其环境的图像资源，这就是响应式图像加载的核心思想。

响应式图像技术

使用srcset和sizes属性

HTML5提供了强大的响应式图像属性：

<img 
  src="small.jpg" 
  srcset="small.jpg 400w, medium.jpg 800w, large.jpg 1600w" 
  sizes="(max-width: 600px) 400px, (max-width: 1200px) 800px, 1600px"
  alt="响应式图像示例">

这告诉浏览器：

• 在窄屏设备(600px以下)上使用small.jpg (400px宽)
• 在中等宽度设备(600px-1200px)上使用medium.jpg (800px宽)
• 在宽屏设备(1200px以上)上使用large.jpg (1600px宽)

使用picture元素实现格式和分辨率响应

<picture>
  <source 
    media="(min-width: 1200px)" 
    srcset="large.avif" 
    type="image/avif">
  <source 
    media="(min-width: 1200px)" 
    srcset="large.webp" 
    type="image/webp">
  <source 
    media="(min-width: 1200px)" 
    srcset="large.jpg">
  <source 
    media="(min-width: 600px)" 
    srcset="medium.avif" 
    type="image/avif">
  <source 
    media="(min-width: 600px)" 
    srcset="medium.webp" 
    type="image/webp">
  <source 
    media="(min-width: 600px)" 
    srcset="medium.jpg">
  <source 
    srcset="small.avif" 
    type="image/avif">
  <source 
    srcset="small.webp" 
    type="image/webp">
  <img src="small.jpg" alt="响应式图像示例">
</picture>

这个例子不仅根据屏幕宽度提供不同尺寸的图像，还根据浏览器支持提供不同的格式。

图像懒加载实现

图像懒加载是一种延迟加载视口外图像的技术，可以显著提升页面初始加载性能。

使用原生懒加载

现代浏览器支持原生的懒加载属性：

<img src="image.jpg" loading="lazy" alt="懒加载图像">

使用Intersection Observer API实现高级懒加载

// 自定义懒加载实现
function setupLazyLoading() {
   
  const images = document.querySelectorAll('.lazy-image');
  
  if ('IntersectionObserver' in window) {
   
    const imageObserver = new IntersectionObserver((entries) => {
   
      entries.forEach(entry => {
   
        if (entry.isIntersecting) {
   
          const image = entry.target;
          const src = image.dataset.src;
          const srcset = image.dataset.srcset;
          
          if (src) image.src = src;
          if (srcset) image.srcset = srcset;
          
          image.classList.remove('lazy-image');
          imageObserver.unobserve(image);
        }
      });
    });
    
    images.forEach(image => imageObserver.observe(image));
  } else {
   
    // 回退方案，使用滚动事件监听
    let lazyloadThrottleTimeout;
    
    function lazyload() {
   
      if (lazyloadThrottleTimeout) {
   
        clearTimeout(lazyloadThrottleTimeout);
      }
      
      lazyloadThrottleTimeout = setTimeout(() => {
   
        const scrollTop = window.pageYOffset;
        
        images.forEach(image => {
   
          if (image.offsetTop < window.innerHeight + scrollTop) {
   
            if (image.dataset.src) image.src = image.dataset.src;
            if (image.dataset.srcset) image.srcset = image.dataset.srcset;
            image.classList.remove('lazy-image');
          }
        });
        
        if (images.length === 0) {
   
          document.removeEventListener('scroll', lazyload);
          window.removeEventListener('resize', lazyload);
          window.removeEventListener('orientationChange', lazyload);
        }
      }, 20);
    }
    
    document.addEventListener('scroll', lazyload);
    window.addEventListener('resize', lazyload);
    window.addEventListener('orientationChange', lazyload);
  }
}

document.addEventListener('DOMContentLoaded', setupLazyLoading);

渐进式加载与图像模糊预览

渐进式加载可以先显示低质量的图像，然后逐步加载高质量版本：

// 实现LQIP (Low Quality Image Placeholder)技术
function setupProgressiveImages() {
   
  const progressiveImages = document.querySelectorAll('.progressive-image-container');
  
  progressiveImages.forEach(container => {
   
    const thumbnail = container.querySelector('.thumbnail');
    const fullImage = new Image();
    
    fullImage.src = container.dataset.src;
    fullImage.className = 'full-image';
    
    fullImage.onload = () => {
   
      container.appendChild(fullImage);
      container.classList.add('image-loaded');
    };
  });
}

配合CSS实现平滑过渡：

.progressive-image-container {
   
  position: relative;
  overflow: hidden;
}

.thumbnail {
   
  width: 100%;
  filter: blur(10px);
  transform: scale(1.05);
  transition: all 0.3s ease-in-out;
}

.full-image {
   
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  opacity: 0;
  transition: opacity 0.3s ease-in-out;
}

.image-loaded .thumbnail {
   
  filter: blur(0);
}

.image-loaded .full-image {
   
  opacity: 1;
}

响应式图像CDN与自适应服务

对于大型应用，可以使用专业的图像CDN服务自动优化图像：

<!-- 使用图像CDN (以Cloudinary为例) -->
<img 
  src="https://res.cloudinary.com/demo/image/upload/w_auto,c_scale,f_auto,q_auto/sample.jpg" 
  alt="CDN优化的响应式图像">

这种服务可以：

• 自动选择最佳格式 (f_auto)
• 根据设备提供合适尺寸 (w_auto)
• 优化压缩质量 (q_auto)
• 应用智能裁剪 (c_scale)

响应式图像加载性能测试

以下是在不同场景下响应式图像技术的性能改进对比：

真实案例：某电商网站应用上述技术后，首页加载时间从原来的4.2秒降至1.5秒，页面跳出率下降了18%，页面转化率提升了12%。

Canvas性能优化与渲染技巧

Canvas作为HTML5引入的强大绘图API，能够处理复杂的2D图形渲染，但在处理大量图形元素或高频率更新时，性能问题也随之而来。以下我们将探讨Canvas性能优化的关键技术和实战经验。

Canvas基础性能优化

1. 调整Canvas尺寸

Canvas的实际渲染尺寸（通过width和height属性设置）与显示尺寸（通过CSS设置）是分开的。当这两者不一致时，浏览器需要进行缩放，这会消耗额外的性能：

// 不推荐：通过CSS调整Canvas大小
canvas.style.width = '500px';
canvas.style.height = '300px';

// 推荐：通过属性设置实际渲染尺寸
canvas.width = 500;
canvas.height = 300;

// 在高分辨率屏幕上，可以考虑使用更高的渲染尺寸配合CSS缩放以提高清晰度
if (window.devicePixelRatio > 1) {
   
  const scale = window.devicePixelRatio;
  
  // 增加实际渲染尺寸
  canvas.width = 500 * scale;
  canvas.height = 300 * scale;
  
  // 使用CSS保持显示尺寸不变
  canvas.style.width = '500px';
  canvas.style.height = '300px';
  
  // 缩放绘图上下文以匹配
  const ctx = canvas.getContext('2d');
  ctx.scale(scale, scale);
}

2. 避免Canvas状态改变

每次改变绘图上下文的状态（如颜色、线宽、阴影等）都会产生一定的性能开销。可以通过最小化状态改变和批量处理相同状态的绘制操作来优化：

// 不推荐：频繁改变状态
function drawShapes(ctx) {
   
  for (let i = 0; i < shapes.length; i++) {
   
    ctx.fillStyle = shapes[i].color;
    ctx.fillRect(shapes[i].x, shapes[i].y, shapes[i].width, shapes[i].height);
  }
}

// 推荐：按状态分组绘制
function drawShapesOptimized(ctx) {
   
  // 按颜色分组
  const shapesByColor = {
   };
  for (let i = 0; i < shapes.length; i++) {
   
    const color = shapes[i].color;
    if (!shapesByColor[color]) {
   
      shapesByColor[color] = [];
    }
    shapesByColor[color].push(shapes[i]);
  }
  
  // 每种颜色只设置一次fillStyle
  for (const color in shapesByColor) {
   
    ctx.fillStyle = color;
    for (const shape of shapesByColor[color]) {
   
      ctx.fillRect(shape.x, shape.y, shape.width, shape.height);
    }
  }
}

3. 使用多层Canvas分离更新频率不同的元素

当场景中包含静态和动态元素时，可以使用多个重叠的Canvas层，将不同更新频率的元素放在不同的层上：

<div class="canvas-container">
  <canvas id="background-layer" class="canvas-layer"></canvas>
  <canvas id="middle-layer" class="canvas-layer"></canvas>
  <canvas id="foreground-layer" class="canvas-layer"></canvas>
</div>

.canvas-container {
   
  position: relative;
  width: 800px;
  height: 600px;
}

.canvas-layer {
   
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
}

// 初始化各层
const bgLayer = document.getElementById('background-layer');
const midLayer = document.getElementById('middle-layer');
const fgLayer = document.getElementById('foreground-layer');

// 各层上下文
const bgCtx = bgLayer.getContext('2d');
const midCtx = midLayer.getContext('2d');
const fgCtx = fgLayer.getContext('2d');

// 背景层（很少更新）
function drawBackground() {
   
  // 绘制复杂但静态的背景
  // ...
}

// 中间层（偶尔更新）
function drawMiddleLayer() {
   
  // 绘制偶尔变化的元素
  // ...
}

// 前景层（频繁更新）
function drawForeground() {
   
  // 清除前一帧
  fgCtx.clearRect(0, 0, fgLayer.width, fgLayer.height);
  
  // 绘制快速变化的元素
  // ...
}

// 初始绘制
drawBackground();
drawMiddleLayer();

// 动画循环只更新前景层
function animate() {
   
  drawForeground();
  requestAnimationFrame(animate);
}
animate();

// 当需要时才更新中间层
function updateMiddleLayerWhenNeeded() {
   
  midCtx.clearRect(0, 0, midLayer.width, midLayer.height);
  drawMiddleLayer();
}

高级Canvas渲染优化

1. 离屏渲染与缓存

对于复杂但不经常变化的图形，可以先绘制到离屏Canvas，然后将结果作为图像绘制到主Canvas上：

// 创建离屏Canvas
const offscreenCanvas = document.createElement('canvas');
offscreenCanvas.width = 200;
offscreenCanvas.height = 200;
const offCtx = offscreenCanvas.getContext('2d');

// 在离屏Canvas上绘制复杂图形（只需执行一次）
function drawComplexShape(ctx) {
   
  // 绘制复杂形状...
  ctx.beginPath();
  for (let i = 0; i < 1000; i++) {
   
    const angle = (i / 1000) * Math.PI * 2;
    const x = 100 + Math.cos(angle) * (50 + Math.sin(i/50) * 20);
    const y = 100 + Math.sin(angle) * (50 + Math.cos(i/50) * 20);
    
    if (i === 0) {
   
      ctx.moveTo(x, y);
    } else {
   
      ctx.lineTo(x, y);
    }
  }
  ctx.fillStyle = 'rgba(0, 128, 255, 0.5)';
  ctx.fill();
  ctx.strokeStyle = 'blue';
  ctx.lineWidth = 2;
  ctx.stroke();
}

// 绘制到离屏Canvas
drawComplexShape(offCtx);

// 主绘制循环中复用离屏Canvas内容
function mainRenderLoop() {
   
  const mainCtx = document.getElementById('main-canvas').getContext('2d');
  mainCtx.clearRect(0, 0, mainCanvas.width, mainCanvas.height);
  
  // 绘制多个复杂形状的实例（使用缓存的图像）
  for (let i = 0; i < 20; i++) {
   
    mainCtx.drawImage(
      offscreenCanvas, 
      Math.random() * 600, 
      Math.random() * 400
    );
  }
  
  requestAnimationFrame(mainRenderLoop);
}

2. 避免阴影和半透明

Canvas中的阴影和半透明操作是性能密集型的，可以通过预渲染或减少使用来优化：

// 不推荐：直接使用阴影
ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';
ctx.shadowBlur = 10;
ctx.shadowOffsetX = 5;
ctx.shadowOffsetY = 5;
ctx.fillRect(50, 50