How Can I Avoid Type Assertions Inside Go's Type Switch Branches?

Eliminating Type Assertions within Type Switch Branches

In Go, type switches provide a convenient means of branching execution based on the type of a value. However, type assertions within these branches can become repetitive and cumbersome.

Type Assertion Avoidance

To avoid unnecessary type assertions, you can assign the result of the type switch to a typed variable:

switch question := question.(type) {
case interfaces.ComputedQuestion:
    handleComputedQuestion(question, symbols)
case interfaces.InputQuestion:
    handleInputQuestion(question, symbols)
}

In this example, the type switch assigns the value of question to the variable question, which is automatically typed according to the branch that executes. This eliminates the need for explicit type assertions within the branches.

Example

Consider the following code:

switch question.(type) {
case interfaces.ComputedQuestion:
    handleComputedQuestion(question.(interfaces.ComputedQuestion), symbols)
case interfaces.InputQuestion:
    handleInputQuestion(question.(interfaces.InputQuestion), symbols)
}

Replacing the type assertions with variable assignments yields the following equivalent code:

switch question := question.(type) {
case interfaces.ComputedQuestion:
    handleComputedQuestion(question, symbols)
case interfaces.InputQuestion:
    handleInputQuestion(question, symbols)
}

By adopting this approach, you can streamline your code and improve its readability without sacrificing functionality.

The above is the detailed content of How Can I Avoid Type Assertions Inside Go's Type Switch Branches?. For more information, please follow other related articles on the PHP Chinese website!