_content/tour/flowcontrol.article - website - Git at Google

 Flow control statements: for, if, else, switch and defer
 Learn how to control the flow of your code with conditionals, loops, switches and defers.

 The Go Authors
 https://golang.org

 * For

 Go has only one looping construct, the `for` loop.

 The basic `for` loop has three components separated by semicolons:

 - the init statement: executed before the first iteration
 - the condition expression: evaluated before every iteration
 - the post statement: executed at the end of every iteration

 The init statement will often be a short variable declaration, and the
 variables declared there are visible only in the scope of the `for`
 statement.

 The loop will stop iterating once the boolean condition evaluates to `false`.

 *Note:* Unlike other languages like C, Java, or JavaScript there are no parentheses
 surrounding the three components of the `for` statement and the braces `{`}` are
 always required.

 .play flowcontrol/for.go

 * For continued

 The init and post statements are optional.

 .play flowcontrol/for-continued.go

 * For is Go's "while"

 At that point you can drop the semicolons: C's `while` is spelled `for` in Go.

 .play flowcontrol/for-is-gos-while.go

 * Forever

 If you omit the loop condition it loops forever, so an infinite loop is compactly expressed.

 .play flowcontrol/forever.go

 * If

 Go's `if` statements are like its `for` loops; the expression need not be
 surrounded by parentheses `(`)` but the braces `{`}` are required.

 .play flowcontrol/if.go

 * If with a short statement

 Like `for`, the `if` statement can start with a short statement to execute before the condition.

 Variables declared by the statement are only in scope until the end of the `if`.

 (Try using `v` in the last `return` statement.)

 .play flowcontrol/if-with-a-short-statement.go

 * If and else

 Variables declared inside an `if` short statement are also available inside any
 of the `else` blocks.

 (Both calls to `pow` return their results before the call to `fmt.Println`
 in `main` begins.)

 .play flowcontrol/if-and-else.go

 * Exercise: Loops and Functions

 As a way to play with functions and loops, let's implement a square root function: given a number x, we want to find the number z for which z² is most nearly x.

 Computers typically compute the square root of x using a loop.
 Starting with some guess z, we can adjust z based on how close z² is to x,
 producing a better guess:

 	z -= (z*z - x) / (2*z)

 Repeating this adjustment makes the guess better and better
 until we reach an answer that is as close to the actual square root as can be.

 Implement this in the `func`Sqrt` provided.
 A decent starting guess for z is 1, no matter what the input.
 To begin with, repeat the calculation 10 times and print each z along the way.
 See how close you get to the answer for various values of x (1, 2, 3, ...)
 and how quickly the guess improves.

 Hint: To declare and initialize a floating point value,
 give it floating point syntax or use a conversion:

 	z := 1.0
 	z := float64(1)

 Next, change the loop condition to stop once the value has stopped
 changing (or only changes by a very small amount).
 See if that's more or fewer than 10 iterations.
 Try other initial guesses for z, like x, or x/2.
 How close are your function's results to the [[/pkg/math/#Sqrt][math.Sqrt]] in the standard library?

 (*Note:* If you are interested in the details of the algorithm, the z² − x above
 is how far away z² is from where it needs to be (x), and the division by 2z is the derivative
 of z², to scale how much we adjust z by how quickly z² is changing.
 This general approach is called [[https://en.wikipedia.org/wiki/Newton%27s_method][Newton's method]].
 It works well for many functions but especially well for square root.)

 .play flowcontrol/exercise-loops-and-functions.go

 * Switch

 A `switch` statement is a shorter way to write a sequence of `if`-`else` statements.
 It runs the first case whose value is equal to the condition expression.

 Go's switch is like the one in C, C++, Java, JavaScript, and PHP,
 except that Go only runs the selected case, not all the cases that follow.
 In effect, the `break` statement that is needed at the end of each case in those
 languages is provided automatically in Go.
 Another important difference is that Go's switch cases need not
 be constants, and the values involved need not be integers.

 .play flowcontrol/switch.go

 * Switch evaluation order

 Switch cases evaluate cases from top to bottom, stopping when a case succeeds.

 (For example,

 	switch i {
 	case 0:
 	case f():
 	}

 does not call `f` if `i==0`.)

 #appengine: *Note:* Time in the Go playground always appears to start at
 #appengine: 2009-11-10 23:00:00 UTC, a value whose significance is left as an
 #appengine: exercise for the reader.

 .play flowcontrol/switch-evaluation-order.go

 * Switch with no condition

 Switch without a condition is the same as `switch`true`.

 This construct can be a clean way to write long if-then-else chains.

 .play flowcontrol/switch-with-no-condition.go

 * Defer

 A defer statement defers the execution of a function until the surrounding
 function returns.

 The deferred call's arguments are evaluated immediately, but the function call
 is not executed until the surrounding function returns.

 .play flowcontrol/defer.go

 * Stacking defers

 Deferred function calls are pushed onto a stack. When a function returns, its
 deferred calls are executed in last-in-first-out order.

 To learn more about defer statements read this
 [[/blog/defer-panic-and-recover][blog post]].

 .play flowcontrol/defer-multi.go

 * Congratulations!

 You finished this lesson!

 You can go back to the list of [[/tour/list][modules]] to find what to learn next, or continue with the [[javascript:click('.next-page')][next lesson]].
	Flow control statements: for, if, else, switch and defer
	Learn how to control the flow of your code with conditionals, loops, switches and defers.

	The Go Authors
	https://golang.org

	* For

	Go has only one looping construct, the `for` loop.

	The basic `for` loop has three components separated by semicolons:

	- the init statement: executed before the first iteration
	- the condition expression: evaluated before every iteration
	- the post statement: executed at the end of every iteration

	The init statement will often be a short variable declaration, and the
	variables declared there are visible only in the scope of the `for`
	statement.

	The loop will stop iterating once the boolean condition evaluates to `false`.

	Note: Unlike other languages like C, Java, or JavaScript there are no parentheses
	surrounding the three components of the `for` statement and the braces `{`}` are
	always required.

	.play flowcontrol/for.go

	* For continued

	The init and post statements are optional.

	.play flowcontrol/for-continued.go

	* For is Go's "while"

	At that point you can drop the semicolons: C's `while` is spelled `for` in Go.

	.play flowcontrol/for-is-gos-while.go

	* Forever

	If you omit the loop condition it loops forever, so an infinite loop is compactly expressed.

	.play flowcontrol/forever.go

	* If

	Go's `if` statements are like its `for` loops; the expression need not be
	surrounded by parentheses `(`)` but the braces `{`}` are required.

	.play flowcontrol/if.go

	* If with a short statement

	Like `for`, the `if` statement can start with a short statement to execute before the condition.

	Variables declared by the statement are only in scope until the end of the `if`.

	(Try using `v` in the last `return` statement.)

	.play flowcontrol/if-with-a-short-statement.go

	* If and else

	Variables declared inside an `if` short statement are also available inside any
	of the `else` blocks.

	(Both calls to `pow` return their results before the call to `fmt.Println`
	in `main` begins.)

	.play flowcontrol/if-and-else.go

	* Exercise: Loops and Functions

	As a way to play with functions and loops, let's implement a square root function: given a number x, we want to find the number z for which z² is most nearly x.

	Computers typically compute the square root of x using a loop.
	Starting with some guess z, we can adjust z based on how close z² is to x,
	producing a better guess:

	z -= (zz - x) / (2z)

	Repeating this adjustment makes the guess better and better
	until we reach an answer that is as close to the actual square root as can be.

	Implement this in the `func`Sqrt` provided.
	A decent starting guess for z is 1, no matter what the input.
	To begin with, repeat the calculation 10 times and print each z along the way.
	See how close you get to the answer for various values of x (1, 2, 3, ...)
	and how quickly the guess improves.

	Hint: To declare and initialize a floating point value,
	give it floating point syntax or use a conversion:

	z := 1.0
	z := float64(1)

	Next, change the loop condition to stop once the value has stopped
	changing (or only changes by a very small amount).
	See if that's more or fewer than 10 iterations.
	Try other initial guesses for z, like x, or x/2.
	How close are your function's results to the [[/pkg/math/#Sqrt][math.Sqrt]] in the standard library?

	(Note: If you are interested in the details of the algorithm, the z² − x above
	is how far away z² is from where it needs to be (x), and the division by 2z is the derivative
	of z², to scale how much we adjust z by how quickly z² is changing.
	This general approach is called [[https://en.wikipedia.org/wiki/Newton%27s_method][Newton's method]].
	It works well for many functions but especially well for square root.)

	.play flowcontrol/exercise-loops-and-functions.go

	* Switch

	A `switch` statement is a shorter way to write a sequence of `if`-`else` statements.
	It runs the first case whose value is equal to the condition expression.

	Go's switch is like the one in C, C++, Java, JavaScript, and PHP,
	except that Go only runs the selected case, not all the cases that follow.
	In effect, the `break` statement that is needed at the end of each case in those
	languages is provided automatically in Go.
	Another important difference is that Go's switch cases need not
	be constants, and the values involved need not be integers.

	.play flowcontrol/switch.go

	* Switch evaluation order

	Switch cases evaluate cases from top to bottom, stopping when a case succeeds.

	(For example,

	switch i {
	case 0:
	case f():
	}

	does not call `f` if `i==0`.)

	#appengine: Note: Time in the Go playground always appears to start at
	#appengine: 2009-11-10 23:00:00 UTC, a value whose significance is left as an
	#appengine: exercise for the reader.

	.play flowcontrol/switch-evaluation-order.go

	* Switch with no condition

	Switch without a condition is the same as `switch`true`.

	This construct can be a clean way to write long if-then-else chains.

	.play flowcontrol/switch-with-no-condition.go

	* Defer

	A defer statement defers the execution of a function until the surrounding
	function returns.

	The deferred call's arguments are evaluated immediately, but the function call
	is not executed until the surrounding function returns.

	.play flowcontrol/defer.go

	* Stacking defers

	Deferred function calls are pushed onto a stack. When a function returns, its
	deferred calls are executed in last-in-first-out order.

	To learn more about defer statements read this
	[[/blog/defer-panic-and-recover][blog post]].

	.play flowcontrol/defer-multi.go

	* Congratulations!

	You finished this lesson!

	You can go back to the list of [[/tour/list][modules]] to find what to learn next, or continue with the [[javascript:click('.next-page')][next lesson]].