Avoid unnecessary else blocks in Typescript

typescript
Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {

Install this rule for wispbit

Add this rule to wispbit and it will run when you open a pull request

Install this rule for Coderabbit

Copy the configuration below and add it to your repository as .coderabbit.yml in your project root.

reviews:
  path_instructions:
    - path: "*.ts"
      instructions: |
                
        Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
        
        Bad:
        
        ```typescript
        function processValue(value: number): string {
          if (value > 10) {
            return "high"
          } else {
            return "low"
          }
        }
        ```
        
        ```typescript
        function checkItems(items: string[]): void {
          for (const item of items) {
            if (item.length > 5) {
              console.log("Long item:", item)
              continue
            } else {
              console.log("Short item:", item)
            }
          }
        }
        ```
        
        Good:
        
        ```typescript
        function processValue(value: number): string {
          if (value > 10) {
            return "high"
          }
          return "low"
        }
        ```
        
        ```typescript
        function checkItems(items: string[]): void {
          for (const item of items) {
            if (item.length > 5) {
              console.log("Long item:", item)
              continue
            }
            console.log("Short item:", item)
          }
        }
        ```

Install this rule for Greptile

Greptile rules can be added through the web interface. Please see this documentation for details on how to add custom rules and context.

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

File Path Patterns:

*.ts

Install this rule for GitHub Copilot

Copilot instructions can be added through the interface. See the documentation for details on how to create coding guidelines.

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

File Path Patterns:

*.ts

Install this rule for Graphite Diamond

Diamond custom rules can be added through the interface. See the documentation for details on how to create custom rules.

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

File Path Patterns:

*.ts

Use with Cline

Copy the rule below and ask Cline to review your code using this rule

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

Use with OpenAI Codex

Copy the rule below and ask OpenAI Codex to review your code using this rule

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

Use with Cursor

Copy the rule below and ask Cursor to review your code using this rule

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

Use with Claude Code

Copy the rule below and ask Claude Code to review your code using this rule

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```

Install this rule for Windsurf

To set up rules for Windsurf Reviews, please see this documentation 

Avoid unnecessary `else` blocks when the `if` block ends with a return statement, break, continue, or similar control flow statements.
Bad:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  } else {
    return "low"
  }
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    } else {
      console.log("Short item:", item)
    }
  }
}
```
Good:
```typescript
function processValue(value: number): string {
  if (value > 10) {
    return "high"
  }
  return "low"
}
```
```typescript
function checkItems(items: string[]): void {
  for (const item of items) {
    if (item.length > 5) {
      console.log("Long item:", item)
      continue
    }
    console.log("Short item:", item)
  }
}
```