---
title: "Substituir Condicional Aninhada por Cláusulas de Guarda"
type: "refactoring-technique"
slug: "replace-nested-conditional-with-guard-clauses"
url: "http://localhost:3000/pt-br/replace-nested-conditional-with-guard-clauses.md"
category: "Simplifying Conditional Expressions"
description: "Problema: Você tem um grupo de condicionais aninhadas e é difícil determinar o fluxo normal de execução do código. Solução: Isole todas as verificações especiais e casos de borda em cláusulas separadas e coloque-as antes das verificações principais. Idealmente, você deve ter uma lista “plana” de condicionais, uma após a outra."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Substituir Condicional Aninhada por Cláusulas de Guarda

> Problema: Você tem um grupo de condicionais aninhadas e é difícil determinar o fluxo normal de execução do código. Solução: Isole todas as verificações especiais e casos de borda em cláusulas separadas e coloque-as antes das verificações principais. Idealmente, você deve ter uma lista “plana” de condicionais, uma após a outra.

## Problem

Você tem um grupo de condicionais aninhadas e é difícil determinar o fluxo normal de execução do código.

## Solution

Isole todas as verificações especiais e casos de borda em cláusulas separadas e coloque-as antes das verificações principais. Idealmente, você deve ter uma lista “plana” de condicionais, uma após a outra.

## Why Refactor

Identificar a “condicional do inferno” é bastante fácil. As indentações de cada nível de aninhamento formam uma seta, apontando para a direita na direção da dor e do sofrimento:

if () {
    if () {
        do {
            if () {
                if () {
                    if () {
                        ...
                    }
                }
                ...
            }
            ...
        }
        while ();
        ...
    }
    else {
        ...
    }
}

É difícil descobrir o que cada condicional faz e como, já que o fluxo “normal” de execução do código não é imediatamente óbvio. Essas condicionais indicam uma evolução desordenada, com cada condição adicionada como medida paliativa sem qualquer reflexão sobre a otimização da estrutura geral.

Para simplificar a situação, isole os casos especiais em condições separadas que encerram a execução imediatamente e retornam um valor nulo se as cláusulas de guarda forem verdadeiras. Na prática, sua missão aqui é deixar a estrutura plana.

## How to Refactor

Tente livrar o código de efeitos colaterais—[Separar Consulta de Modificador](/pt-br/separate-query-from-modifier) pode ser útil para esse propósito. Essa solução será necessária para a reorganização descrita abaixo.

1. Isole todas as cláusulas de guarda que levam à chamada de uma exceção ou ao retorno imediato de um valor do método. Coloque essas condições no início do método.
2. Depois que a reorganização estiver concluída e todos os testes passarem com sucesso, veja se você pode usar [Consolidar Expressão Condicional](/pt-br/consolidate-conditional-expression) para cláusulas de guarda que levam às mesmas exceções ou valores retornados.
## Code Examples

### java

```java
// Before
public double getPayAmount() {
  double result;
  if (isDead){
    result = deadAmount();
  }
  else {
    if (isSeparated){
      result = separatedAmount();
    }
    else {
      if (isRetired){
        result = retiredAmount();
      }
      else{
        result = normalPayAmount();
      }
    }
  }
  return result;
}

// After
public double getPayAmount() {
  if (isDead){
    return deadAmount();
  }
  if (isSeparated){
    return separatedAmount();
  }
  if (isRetired){
    return retiredAmount();
  }
  return normalPayAmount();
}
```

### csharp

```csharp
// Before
public double GetPayAmount()
{
  double result;
  
  if (isDead)
  {
    result = DeadAmount();
  }
  else 
  {
    if (isSeparated)
    {
      result = SeparatedAmount();
    }
    else 
    {
      if (isRetired)
      {
        result = RetiredAmount();
      }
      else
      {
        result = NormalPayAmount();
      }
    }
  }
  
  return result;
}

// After
public double GetPayAmount() 
{
  if (isDead)
  {
    return DeadAmount();
  }
  if (isSeparated)
  {
    return SeparatedAmount();
  }
  if (isRetired)
  {
    return RetiredAmount();
  }
  return NormalPayAmount();
}
```

### php

```php
// Before
function getPayAmount() {
  if ($this->isDead) {
    $result = $this->deadAmount();
  } else {
    if ($this->isSeparated) {
      $result = $this->separatedAmount();
    } else {
      if ($this->isRetired) {
        $result = $this->retiredAmount();
      } else {
        $result = $this->normalPayAmount();
      }
    }
  }
  return $result;
}

// After
function getPayAmount() {
  if ($this->isDead) {
    return $this->deadAmount();
  }
  if ($this->isSeparated) {
    return $this->separatedAmount();
  }
  if ($this->isRetired) {
    return $this->retiredAmount();
  }
  return $this->normalPayAmount();
}
```

### python

```python
// Before
def getPayAmount(self):
    if self.isDead:
        result = deadAmount()
    else:
        if self.isSeparated:
            result = separatedAmount()
        else:
            if self.isRetired:
                result = retiredAmount()
            else:
                result = normalPayAmount()
    return result

// After
def getPayAmount(self):
    if self.isDead:
        return deadAmount()
    if self.isSeparated:
        return separatedAmount()
    if self.isRetired:
        return retiredAmount()
    return normalPayAmount()
```

### typescript

```typescript
// Before
getPayAmount(): number {
  let result: number;
  if (isDead){
    result = deadAmount();
  }
  else {
    if (isSeparated){
      result = separatedAmount();
    }
    else {
      if (isRetired){
        result = retiredAmount();
      }
      else{
        result = normalPayAmount();
      }
    }
  }
  return result;
}

// After
getPayAmount(): number {
  if (isDead){
    return deadAmount();
  }
  if (isSeparated){
    return separatedAmount();
  }
  if (isRetired){
    return retiredAmount();
  }
  return normalPayAmount();
}
```