introduction
Habitual comparison and analogy learning are related operations that everyone will habitually act when mastering new skills. There is a detail that everyone is very curious about for a more interesting programming language like Go.
In fact, Go only supports self-increase/decrease afterwards. Today, I will study why with you.
grammar
Basic Go self-increasing, very simple. See the code directly:
a := 1 a++ (a)
Output result:
2
If the result of the answer is wrong, it is recommended to turn the syntax right. Let’s take a look at a few other examples to match the results you expected to run.
Example 1, the code is as follows:
func main() {
a := 1
b := a++
(b)
}Output result:
# command-line-arguments
./:9:8: syntax error: unexpected ++ at end of statement
Example 2, the code is as follows:
func main() {
a := 1
++a
(a)
}Output result:
# command-line-arguments
./:9:2: syntax error: unexpected ++, expecting }
You will find that these two examples are normal in other common languages. But it actually runs in Go?
reason
Go in design:
- There is no operation statement that supports the prefix self-increase and self-decrease, that is, ++a is not allowed.
- Operators ++ and -- can only be used as one statement and cannot be assigned to other variables as expressions.
Refer to the following example:
- In a statement, ++ is OK.
- ++ is not allowed in assignment =.
Then why don’t it support it? In essence, Go designers are trying to make the code more readable and do not need to worry about the order of evaluation.
From a program perspective, the operation results are the same as the prefix or the suffix. But once introduced, it will increase the possibility of programmers making mistakes, and people will often confuse them, and occasionally someone will make interview questions to test candidates.
Obviously, prefixes and assignments are not supported. ++ and -- can only be used as a statement to improve readability in Go code, which is of great significance to simplify.
Summarize
In this article today, we explored and discussed the details of ++ and -- in Go grammar design. In fact, a++, or --a, or a more complex mixed expression, can only confuse later friends during interviews or writing.
It cannot bring too much profit on the road to Go engineering, so it is naturally taken away.
Have you ever tried to be confused by all kinds of strange prefixes, suffixes, and mixes?
The above is the detailed explanation of the principle of why Go does not support prefix autoincrement operators. For more information about Go's not supporting prefix autoincrement operators, please pay attention to my other related articles!