-
Notifications
You must be signed in to change notification settings - Fork 22.5k
/
index.md
145 lines (106 loc) · 4.2 KB
/
index.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
---
title: break
slug: Web/JavaScript/Reference/Statements/break
page-type: javascript-statement
browser-compat: javascript.statements.break
---
{{jsSidebar("Statements")}}
The **`break`** statement terminates the current loop or {{jsxref("Statements/switch", "switch")}} statement and transfers program control to the statement following the terminated statement. It can also be used to jump past a [labeled statement](/en-US/docs/Web/JavaScript/Reference/Statements/label) when used within that labeled statement.
{{EmbedInteractiveExample("pages/js/statement-break.html")}}
## Syntax
```js-nolint
break;
break label;
```
- `label` {{optional_inline}}
- : Identifier associated with the label of the statement to break to. If the `break` statement is not nested within a loop or {{jsxref("Statements/switch", "switch")}}, then the label identifier is required.
## Description
When `break;` is encountered, the program breaks out of the innermost `switch` or [looping](/en-US/docs/Web/JavaScript/Reference/Statements#iterations) statement and continues executing the next statement after that.
When `break label;` is encountered, the program breaks out of the statement labeled with `label` and continues executing the next statement after that. The `break` statement needs to be nested within the referenced label. The labeled statement can be any statement (commonly a {{jsxref("Statements/block", "block", "", 1)}} statement); it does not have to be another loop statement.
A `break` statement, with or without a following label, cannot be used at the top level of a script, module, function's body, or [static initialization block](/en-US/docs/Web/JavaScript/Reference/Classes/Static_initialization_blocks), even when the function or class is further contained within a loop.
## Examples
### break in while loop
The following function has a `break` statement that terminates the {{jsxref("Statements/while", "while")}} loop when `i` is 3, and then returns the value `3 * x`.
```js
function testBreak(x) {
let i = 0;
while (i < 6) {
if (i === 3) {
break;
}
i += 1;
}
return i * x;
}
```
### break in switch statements
The following code has a `break` statement that terminates the {{jsxref("Statements/switch", "switch")}} statement when a case is matched and the corresponding code has run.
```js
const food = "sushi";
switch (food) {
case "sushi":
console.log("Sushi is originally from Japan.");
break;
case "pizza":
console.log("Pizza is originally from Italy.");
break;
default:
console.log("I have never heard of that dish.");
break;
}
```
### break in labeled blocks
The following code uses `break` statements with labeled blocks. By using `break outerBlock`, control is transferred to the end of the block statement marked as `outerBlock`.
```js
outerBlock: {
innerBlock: {
console.log("1");
break outerBlock; // breaks out of both innerBlock and outerBlock
console.log(":-("); // skipped
}
console.log("2"); // skipped
}
```
### Unsyntactic break statements
A `break` statement must be nested within any label it references. The following code also uses `break` statements with labeled blocks, but generates a syntax error because its `break` statement references `block2` but it's not nested within `block2`.
```js-nolint example-bad
block1: {
console.log("1");
break block2; // SyntaxError: label not found
}
block2: {
console.log("2");
}
```
Syntax errors are also generated in the following code examples which use `break` statements within functions that are nested within a loop, or labeled block that the `break` statements are intended to break out of.
```js-nolint example-bad
function testBreak(x) {
let i = 0;
while (i < 6) {
if (i === 3) {
(() => {
break;
})();
}
i += 1;
}
return i * x;
}
testBreak(1); // SyntaxError: Illegal break statement
```
```js-nolint example-bad
block1: {
console.log("1");
(() => {
break block1; // SyntaxError: Undefined label 'block1'
})();
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{jsxref("Statements/continue", "continue")}}
- {{jsxref("Statements/label", "label", "", 1)}}
- {{jsxref("Statements/switch", "switch")}}