AI代码审查实战：如何用Claude和GPT-4提升代码质量和团队效率

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

传统代码审查的痛点:
  问题:
    - 时间成本高（审查1小时代码需要30分钟）
    - 审查者疲劳导致漏检
    - 审查质量不一致
    - 知识盲区（新技术不熟悉）
    - 团队协作瓶颈
    - 轮值审查占用开发时间

AI辅助代码审查的优势:
  优势:
    - 秒级响应（3-10秒完成初步审查）
    - 一致性（始终执行相同标准）
    - 全天候可用（24/7在线）
    - 广泛知识（覆盖所有语言和框架）
    - 减轻人工负担（只需确认AI结果）
    - 持续学习（模型不断更新）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// AI擅长识别的问题类型

const aiReviewCapabilities = {
  // ✅ 代码规范
  styleIssues: [
    '命名规范',
    '代码格式',
    '注释规范',
    '文件组织'
  ],

  // ✅ 潜在Bug
  potentialBugs: [
    '空指针引用',
    '内存泄漏',
    '并发问题',
    '边界条件',
    '类型错误'
  ],

  // ✅ 性能问题
  performance: [
    '循环优化',
    '内存使用',
    '数据库查询',
    '缓存策略'
  ],

  // ✅ 安全问题
  security: [
    'SQL注入',
    'XSS漏洞',
    '敏感数据暴露',
    '认证授权'
  ],

  // ✅ 架构设计
  architecture: [
    '设计模式应用',
    '代码重复',
    '耦合度',
    '可测试性'
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 安装Claude CLI
npm install -g @anthropic-ai/claude-code

# 配置API密钥
export ANTHROPIC_API_KEY="your-api-key"

# 初始化项目
cd your-project
claude

# Claude会自动：
# 1. 扫描项目结构
# 2. 理解代码上下文
# 3. 准备审查环境

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 安装Husky
npm install -D husky

# 配置pre-commit hook
npx husky-init

# .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

# AI代码审查
echo "🤖 AI正在审查代码..."
claude review --staged --output=claude-review.txt

# 如果AI发现问题，暂停提交
if [ -s claude-review.txt ]; then
  echo "⚠️  AI发现问题，请查看 claude-review.txt"
  exit 1
fi

# 同时运行传统linter
npm run lint

# 创建commit-msg hook
cat > .husky/commit-msg <<'EOF'
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

# AI审查commit信息
claude review-commit-msg "$1" --output=commit-msg-review.txt
EOF

chmod +x .husky/commit-msg

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# .github/workflows/ai-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # 获取完整历史

      - name: 安装Claude CLI
        run: npm install -g @anthropic-ai/claude-code

      - name: AI代码审查
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # 审查变更的文件
          CHANGED_FILES=$(git diff --name-only origin/main...HEAD)

          claude review \
            --files="$CHANGED_FILES" \
            --output=review-result.md \
            --format=markdown

      - name: 发布审查结果
        uses: actions/github-script@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review-result.md', 'utf8');

            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// review-strategy.ts

enum ReviewLayer {
  // 第一层：快速扫描（5秒）
  QUICK_SCAN = 'quick-scan',

  // 第二层：深度分析（30秒）
  DEEP_ANALYSIS = 'deep-analysis',

  // 第三层：综合评估（1分钟）
  COMPREHENSIVE = 'comprehensive'
}

interface ReviewConfig {
  layer: ReviewLayer
  focus: string[]  // 关注的审查点
  threshold: number  // 问题严重程度阈值
}

// PR分级审查
const prSizeCategories = {
  small: { maxFiles: 5, maxChanges: 100 },
  medium: { maxFiles: 20, maxChanges: 500 },
  large: { maxFiles: 50, maxChanges: 2000 },
  xlarge: { maxFiles: Infinity, maxChanges: Infinity }
}

function getReviewStrategy(prStats: PRStats): ReviewConfig {
  const category = Object.entries(prSizeCategories)
    .find(([_, limits]) =>
      prStats.files <= limits.maxFiles &&
      prStats.changes <= limits.maxChanges
    )?.[0] || 'xlarge'

  const strategies = {
    small: {
      layer: ReviewLayer.COMPREHENSIVE,
      focus: ['all', 'security', 'performance', 'style'],
      threshold: 0  // 所有问题都要看
    },
    medium: {
      layer: ReviewLayer.DEEP_ANALYSIS,
      focus: ['security', 'logic', 'performance'],
      threshold: 2  // 只关注严重问题
    },
    large: {
      layer: ReviewLayer.QUICK_SCAN,
      focus: ['security', 'critical-bugs'],
      threshold: 3  // 只看关键问题
    },
    xlarge: {
      layer: ReviewLayer.QUICK_SCAN,
      focus: ['security'],
      threshold: 4  // 只看安全漏洞
    }
  }

  return strategies[category]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// review-workflow.ts

interface ReviewWorkflow {
  // 1. 初步审查（AI）
  initialReview(diff: string): Promise<AIReviewResult>

  // 2. 人工确认（开发者）
  humanConfirmation(
    aiResult: AIReviewResult,
    developer: User
  ): Promise<ConfirmedIssues>

  // 3. 修复验证
  verifyFixes(
    issues: ConfirmedIssues[],
    newDiff: string
  ): Promise<VerificationResult>

  // 4. 最终批准
  finalApproval(result: VerificationResult): Promise<boolean>
}

class AIReviewWorkflow implements ReviewWorkflow {
  async initialReview(diff: string): Promise<AIReviewResult> {
    // 调用Claude API
    const response = await anthropic.messages.create({
      model: "claude-3-opus-20040229",
      max_tokens: 4096,
      messages: [{
        role: "user",
        content: `请审查以下代码变更，重点关注：\n
1. 安全漏洞\n
2. 逻辑错误\n
3. 性能问题\n
4. 代码规范\n
5. 潜在的边界条件问题\n\n代码差异：\n${diff}`
      }]
    })

    // 解析AI响应
    const issues = this.parseAIResponse(response.content[0].text)

    return {
      total: issues.length,
      critical: issues.filter(i => i.severity === 'critical'),
      warning: issues.filter(i => i.severity === 'warning'),
      info: issues.filter(i => i.severity === 'info'),
      raw: issues
    }
  }

  async humanConfirmation(
    aiResult: AIReviewResult,
    developer: User
  ): Promise<ConfirmedIssues> {
    // 为每个问题创建确认checkbox
    const confirmedIssues: ConfirmedIssue[] = []

    for (const issue of aiResult.raw) {
      const shouldFix = await developer.prompt({
        message: issue.description,
        options: [
          { label: '修复', value: 'fix', detail: issue.suggestion },
          { label: '忽略', value: 'ignore', detail: issue.reason },
          { label: '延后', value: 'later', detail: '创建技术债务' }
        ]
      })

      if (shouldFix === 'fix') {
        confirmedIssues.push({
          issue,
          assignedTo: developer.id,
          estimatedTime: issue.estimatedFixTime
        })
      }
    }

    return confirmedIssues
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// quality-metrics.ts

interface QualityMetrics {
  // 代码复杂度
  complexity: {
    cyclomaticComplexity: number    // 圈复杂度 < 10
    cognitiveComplexity: number     // 认知复杂度 < 15
    nestingDepth: number           // 嵌套深度 < 4
  }

  // 测试覆盖
  testing: {
    unitTestCoverage: number      // 单元测试 > 80%
    integrationCoverage: number    // 集成测试 > 60%
    e2eCoverage: number            // E2E覆盖关键流程
  }

  // 文档完整性
  documentation: {
    hasAPI: boolean               // API文档
    hasREADME: boolean            // README
    hasComments: number          // 代码注释率 > 10%
  }

  // 安全性
  security: {
    hasVulnerabilities: boolean  // 已知漏洞
    hasSensitiveData: boolean    // 硬编码密钥
    hasSQLInjection: boolean     // SQL注入风险
  }

  // 性能
  performance: {
    hasOptimization: boolean     // 性能优化点
    hasMemoryLeak: boolean        // 内存泄漏风险
    hasNPlusOne: boolean         // N+1查询
  }
}

// AI审查评分
function calculateQualityScore(
  metrics: QualityMetrics,
  aiReview: AIReviewResult
): number {
  let score = 100

  // 扣分规则
  if (metrics.complexity.cyclomaticComplexity > 10) {
    score -= 10
  }

  if (metrics.testing.unitTestCoverage < 80) {
    score -= 20
  }

  if (aiReview.critical > 0) {
    score -= 30 * aiReview.critical.length
  }

  if (metrics.security.hasVulnerabilities) {
    score -= 50
  }

  return Math.max(0, score)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# AI代码审查Checklist

## 安全审查 ✅
- [ ] 无SQL注入风险
- [ ] 无XSS漏洞
- [ ] 无敏感数据暴露
- [ ] 正确的认证和授权
- [ ] 输入验证完整
- [ ] 输出编码正确

## 功能审查 ✅
- [ ] 逻辑正确性
- [ ] 边界条件处理
- [ ] 错误处理完善
- [ ] 日志记录适当
- [ ] 异常捕获完整

## 性能审查 ✅
- [ ] 无明显性能问题
- [ ] 数据库查询优化
- [ ] 缓存策略合理
- [ ] 无内存泄漏风险
- [ ] 资源释放及时

## 可维护性审查 ✅
- [ ] 命名清晰规范
- [ ] 代码结构合理
- [ ] 注释充分准确
- [ ] 模块职责单一
- [ ] 耦合度适中

## 测试审查 ✅
- [ ] 单元测试充分
- [ ] 边界条件覆盖
- [ ] 集成测试完整
- [ ] 测试可维护

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// ❌ 有问题的代码
import { executeQuery } from './db'

export async function getUserById(id: string) {
  const query = `SELECT * FROM users WHERE id = '${id}'`
  // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  // AI警告：SQL注入风险！

  return await executeQuery(query)
}

// AI审查反馈
const aiReview = {
  issue: 'SQL Injection Vulnerability',
  severity: 'critical',
  description: '直接拼接SQL查询字符串存在SQL注入风险',
  location: 'src/services/user.ts:15',
  suggestion: `使用参数化查询替代字符串拼接：

改进方案：
\`\`\`typescript
import { executeQuery } from './db'

export async function getUserById(id: string) {
  const query = 'SELECT * FROM users WHERE id = $1'
  return await executeQuery(query, [id])
}
\`\`\`

参考：OWASP SQL Injection Prevention Cheat Sheet`
}

// ✅ 修复后的代码
import { executeQuery } from './db'

export async function getUserById(id: string) {
  const query = 'SELECT * FROM users WHERE id = $1'
  return await executeQuery(query, [id])
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// ❌ N+1查询问题
export class PostService {
  async getPostsWithAuthor(postIds: string[]) {
    const posts = []

    for (const id of postIds) {
      const post = await db.post.findUnique({
        where: { id }
      })

      // AI警告：N+1查询！
      const author = await db.user.findUnique({
        where: { id: post.authorId }
      })

      posts.push({ ...post, author })
    }

    return posts
  }
}

// AI审查反馈
const aiReview = {
  issue: 'N+1 Query Performance Problem',
  severity: 'warning',
  description: '在循环中执行数据库查询导致N+1问题',
  suggestion: `使用include或batch query优化：

\`\`\`typescript
export class PostService {
  async getPostsWithAuthor(postIds: string[]) {
    const posts = await db.post.findMany({
      where: {
        id: { in: postIds }
      },
      include: {
        author: true  // 关联查询，一次获取
      }
    })

    return posts
  }
}
\`\`\`

性能提升：
- 原方案：N次文章查询 + N次作者查询 = 2N次查询
- 优化后：1次关联查询
`
}

// ✅ 优化后的代码
export class PostService {
  async getPostsWithAuthor(postIds: string[]) {
    const posts = await db.post.findMany({
      where: {
        id: { in: postIds }
      },
      include: {
        author: true
      }
    })

    return posts
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// ❌ 代码风格不一致
export class UserService{
  private _userRepo:UserRepository;
  constructor(repo:UserRepository){this._userRepo=repo}

  async GetUser(userid:string){return await this._userRepo.find(userid)}

  async update(user:User){
    this._userRepo.save(user)
  }
}

// AI审查反馈
const aiReview = {
  issue: 'Code Style Inconsistency',
  severity: 'info',
  description: '命名和格式不符合团队规范',
  suggestions: [
    '1. 类名使用PascalCase：UserService（正确）',
    '2. 方法名使用camelCase：getUser、updateUser',
    '3. 私有成员使用_前缀：_userRepo（正确）',
    '4. 添加适当的空格和缩进',
    '5. 添加访问修饰符（public/private）'
  ],
  automatedFix: `
export class UserService {
  private _userRepo: UserRepository;

  constructor(repo: UserRepository) {
    this._userRepo = repo;
  }

  async getUser(userId: string) {
    return await this._userRepo.find(userId);
  }

  async update(user: User) {
    this._userRepo.save(user);
  }
}
`
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// team-roles.ts

enum ReviewRole {
  // AI：初步审查者
  AI_REVIEWER = 'ai-reviewer',

  // 开发者：确认和修复
  DEVELOPER = 'developer',

  // 技术Lead：复杂问题决策
  TECH_LEAD = 'tech-lead',

  // 安全专家：安全问题审查
  SECURITY_EXPERT = 'security-expert'
}

interface ReviewTask {
  id: string
  prNumber: number
  assignee: ReviewRole
  status: 'pending' | 'in_progress' | 'completed'
  deadline: Date
}

class ReviewOrchestrator {
  private tasks: Map<string, ReviewTask> = new Map()

  assignReview(prNumber: number, prStats: PRStats) {
    // 任务1：AI初步审查
    this.createTask({
      id: `${prNumber}-ai-review`,
      prNumber,
      assignee: ReviewRole.AI_REVIEWER,
      status: 'in_progress',
      deadline: new Date(Date.now() + 5 * 60 * 1000) // 5分钟
    })

    // 任务2：开发者确认（在AI完成后）
    this.createTask({
      id: `${prNumber}-dev-confirm`,
      prNumber,
      assignee: ReviewRole.DEVELOPER,
      status: 'pending',
      dependsOn: `${prNumber}-ai-review`,
      deadline: new Date(Date.now() + 30 * 60 * 1000) // 30分钟
    })

    // 任务3：技术Lead审查（大型PR）
    if (prStats.changes > 500) {
      this.createTask({
        id: `${prNumber}-lead-review`,
        prNumber,
        assignee: ReviewRole.TECH_LEAD,
        status: 'pending',
        dependsOn: `${prNumber}-dev-confirm`
      })
    }
  }

  private createTask(task: ReviewTask) {
    this.tasks.set(task.id, task)
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// review-metrics.ts

interface ReviewMetrics {
  // 效率指标
  efficiency: {
    averageReviewTime: number      // 平均审查时间
    reviewBacklog: number          // 待审查PR数
    aiAccuracy: number             // AI审查准确率
  }

  // 质量指标
  quality: {
    bugDetectionRate: number       // Bug检出率
    falsePositiveRate: number      // 误报率
    escapedBugs: number            // 遗漏Bug数
  }

  // 团队指标
  team: {
    participationRate: number      // 参与率
    satisfaction: number          // 满意度
    reviewVelocity: number        // 审查速度
  }
}

// 收集指标
class MetricsCollector {
  async collectMetrics(): Promise<ReviewMetrics> {
    return {
      efficiency: {
        averageReviewTime: await this.calculateAverageReviewTime(),
        reviewBacklog: await this.getReviewBacklog(),
        aiAccuracy: await this.calculateAIAccuracy()
      },
      quality: {
        bugDetectionRate: await this.calculateBugDetectionRate(),
        falsePositiveRate: await this.calculateFalsePositiveRate(),
        escapedBugs: await this.countEscapedBugs()
      },
      team: {
        participationRate: await this.calculateParticipationRate(),
        satisfaction: await this.calculateSatisfaction(),
        reviewVelocity: await this.calculateReviewVelocity()
      }
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// 优秀的AI审查Prompt
const OPTIMAL_PROMPT = `
你是一位经验丰富的代码审查专家。请审查以下代码变更：

## 审查重点
1. **安全性**：SQL注入、XSS、认证授权
2. **正确性**：逻辑错误、边界条件、异常处理
3. **性能**：算法复杂度、资源使用、并发安全
4. **可维护性**：代码规范、注释文档、模块设计

## 代码差异
\`\`\`diff
${diff}
\`\`\`

## 输出格式
请以JSON格式输出审查结果：
\`\`\`json
{
  "summary": "简要总结",
  "issues": [
    {
      "severity": "critical|warning|info",
      "category": "security|performance|style|logic",
      "file": "文件路径",
      "line": 行号,
      "description": "问题描述",
      "suggestion": "改进建议",
      "code": "示例代码"
    }
  ]
}
\`\`\`

## 注意事项
- 只关注真正的问题，避免吹毛求疵
- 提供具体的改进建议
- 考虑代码的上下文和业务场景
- 区分must-fix和nice-to-have
`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// ai-review-filter.ts

interface AIFilter {
  // 过滤规则
  filterRules: FilterRule[]

  // 应用过滤器
  apply(review: AIReview): FilteredReview
}

class AIFilterImpl implements AIFilter {
  filterRules = [
    // 规则1：忽略自动生成的文件
    {
      condition: (issue: Issue) =>
        issue.file.includes('node_modules/') ||
        issue.file.includes('.next/') ||
        issue.file.endsWith('.generated.ts'),
      action: 'ignore',
      reason: '自动生成的文件不需要审查'
    },

    // 规则2：降低测试文件的规范要求
    {
      condition: (issue: Issue) =>
        issue.file.includes('.test.') ||
        issue.file.includes('.spec.'),
      action: 'downgrade',
      from: 'warning',
      to: 'info',
      reason: '测试文件的代码规范要求可以适当降低'
    },

    // 规则3：忽略TODO和FIXME
    {
      condition: (issue: Issue) =>
        issue.description.includes('TODO') ||
        issue.description.includes('FIXME'),
      action: 'ignore',
      reason: 'TODO和FIXME是已知的改进点'
    },

    // 规则4：忽略第三方库
    {
      condition: (issue: Issue) =>
        issue.file.includes('vendor/') ||
        issue.file.includes('lib/external'),
      action: 'ignore',
      reason: '第三方库不需要审查'
    }
  ]

  apply(review: AIReview): FilteredReview {
    const filtered = review.raw.filter(issue => {
      for (const rule of this.filterRules) {
        if (rule.condition(issue)) {
          return false  // 过滤掉
        }
      }
      return true
    })

    return {
      ...review,
      raw: filtered,
      filteredCount: review.raw.length - filtered.length
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// feedback-loop.ts

interface AIFeedback {
  reviewId: string
  humanDecision: 'accept' | 'reject' | 'modify'
  issueId: string
  reason: string
}

class FeedbackCollector {
  private feedbacks: AIFeedback[] = []

  collect(feedback: AIFeedback) {
    this.feedbacks.push(feedback)

    // 定期分析反馈
    if (this.feedbacks.length >= 100) {
      this.analyzeAndImprove()
    }
  }

  private async analyzeAndImprove() {
    // 统计误报率
    const falsePositives = this.feedbacks.filter(
      f => f.humanDecision === 'reject'
    ).length

    const total = this.feedbacks.length
    const falsePositiveRate = falsePositives / total

    if (falsePositiveRate > 0.3) {
      // 误报率过高，调整AI审查阈值
      await this.adjustThreshold('increase')
    }

    // 生成报告
    const report = {
      totalReviews: total,
      falsePositiveRate,
      commonFalsePositives: this.getCommonFalsePositives(),
      recommendations: this.generateRecommendations()
    }

    // 发送给团队
    await this.sendReport(report)

    // 清空缓存
    this.feedbacks = []
  }
}