引言

Nuxt 3作为Nuxt框架的最新演进版本，带来了强大而灵活的Vue应用程序构建方法，使用Vue 3、Vite和Nitro等现代工具。随着这些进步，出现了一个既健壮又对开发者友好的新错误处理模型。

在本文中，我们将探索Nuxt 3中错误处理的工作原理，包括内置机制、最佳实践，以及如何实现自定义错误页面和逻辑。

为什么错误处理很重要？

有效的错误处理在任何应用程序中都是至关重要的。它确保：

• 用户体验：当出现问题时，用户能得到有用的提示信息
• 开发效率：开发者能够快速诊断和修复问题
• 安全性：通过防止敏感错误信息泄露来维护安全性
• 应用稳定性：即使在失败条件下，应用程序也能保持良好的用户体验

Nuxt中的错误处理

Nuxt提供了一个内置的组合式函数：useError() 和像 createError() 这样的工具来优雅地管理错误。

使用 createError() 创建自定义错误

createError() 函数帮助您抛出Nuxt能够理解和捕获的自定义错误。

export default defineEventHandler((event) => {
  const authorized = checkAuth(event);
  if (!authorized) {
    throw createError({
      statusCode: 401,
      statusMessage: 'Unauthorized',
    });
  }
});

使用 useError() 访问错误信息

使用 useError() 组合式函数在页面内访问错误详情：

<script setup>
const error = useError();

if (error) {
  console.log(error.statusCode); // 用于日志记录或条件显示
}
</script>

<template>
  <div v-if="error">
    <h1>错误 {{ error.statusCode }}</h1>
    <p>{{ error.message }}</p>
  </div>
</template>

创建自定义错误页面

您可以通过在 layouts 目录中添加 error.vue 文件来创建自定义错误页面：

<template>
  <div class="min-h-screen flex flex-col items-center justify-center">
    <h1 class="text-3xl font-bold text-red-600">错误 {{ error.statusCode }}</h1>
    <p class="text-lg mt-4">{{ error.message }}</p>
    <NuxtLink to="/" class="mt-6 text-blue-500 underline">返回首页</NuxtLink>
  </div>
</template>

<script setup>
const error = useError();
</script>

这个布局将自动为任何未捕获的错误进行渲染。

中间件中的错误处理

中间件函数也可以使用 createError 抛出错误。这些错误将被捕获并重定向到错误布局。

export default defineNuxtRouteMiddleware((to, from) => {
  const isAuthenticated = useAuthStore().loggedIn;
  if (!isAuthenticated && to.path !== '/login') {
    throw createError({
      statusCode: 403,
      statusMessage: '访问被禁止',
    });
  }
});

全局错误处理器

我们还可以通过使用插件来配置全局错误处理器：

export default defineNuxtPlugin((nuxtApp) => {
  nuxtApp.vueApp.config.errorHandler = (error, instance, info) => {
    // 处理错误，例如报告给服务
    console.error('全局错误:', error);
    // 可以发送到错误监控服务如Sentry
  }

  // 也可以使用钩子
  nuxtApp.hook('vue:error', (error, instance, info) => {
    // 处理错误，例如报告给服务
    console.error('Vue错误:', error);
  })
})

错误边界

Nuxt支持使用 <NuxtErrorBoundary> 的错误边界——有助于隔离和从组件特定错误中恢复。

<template>
  <NuxtErrorBoundary>
    <MyComponent />
    <template #error="{ error }">
      <div class="text-red-500">组件错误: {{ error.message }}</div>
    </template>
  </NuxtErrorBoundary>
</template>

当您想要在UI的特定部分进行本地化错误处理时，这很有用。

实际应用场景

1. API错误处理

// composables/useApi.js
export const useApi = () => {
  const handleApiError = (error) => {
    if (error.statusCode === 401) {
      // 重定向到登录页
      navigateTo('/login');
    } else if (error.statusCode === 404) {
      // 显示404页面
      throw createError({
        statusCode: 404,
        statusMessage: '资源未找到'
      });
    } else {
      // 显示通用错误
      throw createError({
        statusCode: 500,
        statusMessage: '服务器内部错误'
      });
    }
  };

  return { handleApiError };
};

2. 表单验证错误

<template>
  <form @submit.prevent="handleSubmit">
    <input v-model="form.email" type="email" />
    <span v-if="errors.email" class="error">{{ errors.email }}</span>
    <button type="submit">提交</button>
  </form>
</template>

<script setup>
const form = ref({ email: '' });
const errors = ref({});

const handleSubmit = async () => {
  try {
    await $fetch('/api/submit', {
      method: 'POST',
      body: form.value
    });
  } catch (error) {
    if (error.data?.validationErrors) {
      errors.value = error.data.validationErrors;
    } else {
      throw createError({
        statusCode: 500,
        statusMessage: '提交失败，请稍后重试'
      });
    }
  }
};
</script>

3. 权限控制错误

// middleware/auth.js
export default defineNuxtRouteMiddleware((to) => {
  const { $auth } = useNuxtApp();
  
  if (!$auth.isAuthenticated && to.meta.requiresAuth) {
    throw createError({
      statusCode: 403,
      statusMessage: '您没有权限访问此页面',
      fatal: true
    });
  }
});

错误监控和日志

集成错误监控服务

// plugins/error-monitoring.client.js
export default defineNuxtPlugin((nuxtApp) => {
  // 假设使用Sentry
  if (process.client) {
    nuxtApp.vueApp.config.errorHandler = (error, instance, info) => {
      // 发送到Sentry
      Sentry.captureException(error, {
        extra: {
          componentName: instance?.$options?.name,
          info
        }
      });
    };
  }
});

自定义错误日志

// utils/errorLogger.js
export const logError = (error, context = {}) => {
  const errorLog = {
    timestamp: new Date().toISOString(),
    message: error.message,
    stack: error.stack,
    statusCode: error.statusCode,
    context
  };

  // 开发环境打印到控制台
  if (process.dev) {
    console.error('错误日志:', errorLog);
  }

  // 生产环境发送到服务器
  if (process.prod) {
    $fetch('/api/logs/error', {
      method: 'POST',
      body: errorLog
    });
  }
};

错误页面设计最佳实践

1. 用户友好的错误信息

<template>
  <div class="error-page">
    <div class="error-icon"></div>
    <h1>{{ getErrorTitle() }}</h1>
    <p>{{ getErrorMessage() }}</p>
    <div class="actions">
      <button @click="goBack">返回上页</button>
      <button @click="goHome">返回首页</button>
      <button @click="retry" v-if="canRetry">重试</button>
    </div>
  </div>
</template>

<script setup>
const error = useError();
const router = useRouter();

const getErrorTitle = () => {
  const titles = {
    404: '页面未找到',
    403: '访问被拒绝',
    500: '服务器错误',
    502: '网关错误'
  };
  return titles[error.value?.statusCode] || '发生错误';
};

const getErrorMessage = () => {
  const messages = {
    404: '抱歉，您访问的页面不存在。',
    403: '您没有权限访问此页面。',
    500: '服务器遇到问题，请稍后重试。',
    502: '网关暂时不可用，请稍后重试。'
  };
  return messages[error.value?.statusCode] || '发生了意外错误。';
};

const goBack = () => router.back();
const goHome = () => router.push('/');
const retry = () => window.location.reload();
const canRetry = computed(() => [500, 502].includes(error.value?.statusCode));
</script>

2. 响应式错误页面

.error-page {
  min-height: 100vh;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  text-align: center;
  padding: 2rem;
  
  .error-icon {
    font-size: 4rem;
    margin-bottom: 2rem;
  }
  
  h1 {
    font-size: 2.5rem;
    color: #e53e3e;
    margin-bottom: 1rem;
  }
  
  p {
    font-size: 1.2rem;
    color: #4a5568;
    margin-bottom: 2rem;
    max-width: 500px;
  }
  
  .actions {
    display: flex;
    gap: 1rem;
    flex-wrap: wrap;
    justify-content: center;
    
    button {
      padding: 0.75rem 1.5rem;
      border: none;
      border-radius: 0.5rem;
      cursor: pointer;
      transition: all 0.2s;
      
      &:first-child {
        background: #3182ce;
        color: white;
        
        &:hover {
          background: #2c5aa0;
        }
      }
      
      &:nth-child(2) {
        background: #38a169;
        color: white;
        
        &:hover {
          background: #2f855a;
        }
      }
      
      &:last-child {
        background: #ed8936;
        color: white;
        
        &:hover {
          background: #dd6b20;
        }
      }
    }
  }
}

@media (max-width: 768px) {
  .error-page {
    h1 {
      font-size: 2rem;
    }
    
    p {
      font-size: 1rem;
    }
    
    .actions {
      flex-direction: column;
      width: 100%;
      max-width: 300px;
    }
  }
}

高级错误处理技巧

1. 错误恢复机制

// composables/useErrorRecovery.js
export const useErrorRecovery = () => {
  const retryCount = ref(0);
  const maxRetries = 3;
  
  const retryOperation = async (operation, delay = 1000) => {
    try {
      return await operation();
    } catch (error) {
      if (retryCount.value < maxRetries) {
        retryCount.value++;
        await new Promise(resolve => setTimeout(resolve, delay * retryCount.value));
        return retryOperation(operation, delay);
      } else {
        throw error;
      }
    }
  };
  
  return { retryOperation, retryCount };
};

2. 优雅降级

<template>
  <div>
    <NuxtErrorBoundary>
      <template #default>
        <HeavyComponent />
      </template>
      <template #error="{ error }">
        <LightweightFallback :error="error" />
      </template>
    </NuxtErrorBoundary>
  </div>
</template>

3. 错误分类和处理

// utils/errorClassifier.js
export class ErrorClassifier {
  static classify(error) {
    if (error.statusCode >= 500) {
      return 'server';
    } else if (error.statusCode >= 400) {
      return 'client';
    } else if (error.name === 'NetworkError') {
      return 'network';
    } else {
      return 'unknown';
    }
  }
  
  static shouldRetry(error) {
    const type = this.classify(error);
    return type === 'server' || type === 'network';
  }
  
  static getRetryDelay(error, attempt) {
    const baseDelay = 1000;
    return baseDelay * Math.pow(2, attempt - 1); // 指数退避
  }
}

性能考虑

1. 错误边界性能优化

<template>
  <Suspense>
    <template #default>
      <AsyncComponent />
    </template>
    <template #fallback>
      <LoadingSpinner />
    </template>
  </Suspense>
</template>

2. 错误日志性能

// 使用防抖来避免过多的错误日志
import { debounce } from 'lodash-es';

const debouncedErrorLog = debounce((error) => {
  logError(error);
}, 1000);

export const useErrorLogger = () => {
  const logError = (error) => {
    debouncedErrorLog(error);
  };
  
  return { logError };
};

测试错误处理

1. 单元测试

// tests/error-handling.test.js
import { describe, it, expect, vi } from 'vitest';
import { createError } from 'nuxt/app';

describe('错误处理', () => {
  it('应该创建正确的错误对象', () => {
    const error = createError({
      statusCode: 404,
      statusMessage: '页面未找到'
    });
    
    expect(error.statusCode).toBe(404);
    expect(error.statusMessage).toBe('页面未找到');
  });
  
  it('应该处理API错误', async () => {
    const mockFetch = vi.fn().mockRejectedValue({
      statusCode: 500,
      message: '服务器错误'
    });
    
    try {
      await mockFetch('/api/test');
    } catch (error) {
      expect(error.statusCode).toBe(500);
    }
  });
});

2. 集成测试

// tests/integration/error-pages.test.js
import { describe, it, expect } from '@nuxt/test-utils';

describe('错误页面', () => {
  it('应该显示404页面', async () => {
    const { $fetch } = await $fetch('/non-existent-page');
    expect($fetch.status).toBe(404);
  });
  
  it('应该显示自定义错误信息', async () => {
    const { $fetch } = await $fetch('/api/error');
    expect($fetch.data.message).toContain('自定义错误');
  });
});

总结

Nuxt使错误处理成为一流功能，为开发者提供了直观的工具来管理客户端和服务器的异常。通过 createError、useError、自定义错误布局和错误边界，您可以构建能够优雅处理故障的弹性应用程序。

关键要点：

1. 使用内置工具：充分利用 useError() 和 createError() 组合式函数
2. 创建用户友好的错误页面：设计清晰、有用的错误信息
3. 实现错误监控：集成错误跟踪服务来监控生产环境
4. 使用错误边界：隔离组件错误，防止整个应用崩溃
5. 优雅降级：为关键功能提供备用方案
6. 测试错误处理：确保错误处理逻辑按预期工作

通过遵循这些最佳实践，您可以构建更加健壮和用户友好的Nuxt应用程序。