eslint/docs/rules/strict.md

   1 # require or disallow strict mode directives (strict)
   2
   3 A strict mode directive is a `"use strict"` literal at the beginning of a script or function body. It enables strict mode semantics.
   4
   5 When a directive occurs in global scope, strict mode applies to the entire script:
   6
   7 ```js
   8 "use strict";
   9
  10 // strict mode
  11
  12 function foo() {
  13     // strict mode
  14 }
  15 ```
  16
  17 When a directive occurs at the beginning of a function body, strict mode applies only to that function, including all contained functions:
  18
  19 ```js
  20 function foo() {
  21     "use strict";
  22     // strict mode
  23 }
  24
  25 function foo2() {
  26     // not strict mode
  27 };
  28
  29 (function() {
  30     "use strict";
  31     function bar() {
  32         // strict mode
  33     }
  34 }());
  35 ```
  36
  37 In the **CommonJS** module system, a hidden function wraps each module and limits the scope of a "global" strict mode directive.
  38
  39 In **ECMAScript** modules, which always have strict mode semantics, the directives are unnecessary.
  40
  41 ## Rule Details
  42
  43 This rule requires or disallows strict mode directives.
  44
  45 This rule disallows strict mode directives, no matter which option is specified, if ESLint configuration specifies either of the following as [parser options](/docs/user-guide/configuring/language-options.md#specifying-parser-options):
  46
  47 * `"sourceType": "module"` that is, files are **ECMAScript** modules
  48 * `"impliedStrict": true` property in the `ecmaFeatures` object
  49
  50 This rule disallows strict mode directives, no matter which option is specified, in functions with non-simple parameter lists (for example, parameter lists with default parameter values) because that is a syntax error in **ECMAScript 2016** and later. See the examples of the [function](#function) option.
  51
  52 This rule does not apply to class static blocks, no matter which option is specified, because class static blocks do not have directives. Therefore, a `"use strict"` statement in a class static block is not a directive, and will be reported by the [no-unused-expressions](no-unused-expressions.md) rule.
  53
  54 The `--fix` option on the command line does not insert new `"use strict"` statements, but only removes unneeded statements.
  55
  56 ## Options
  57
  58 This rule has a string option:
  59
  60 * `"safe"` (default) corresponds either of the following options:
  61     * `"global"` if ESLint considers a file to be a **CommonJS** module
  62     * `"function"` otherwise
  63 * `"global"` requires one strict mode directive in the global scope (and disallows any other strict mode directives)
  64 * `"function"` requires one strict mode directive in each top-level function declaration or expression (and disallows any other strict mode directives)
  65 * `"never"` disallows strict mode directives
  66
  67 ### safe
  68
  69 The `"safe"` option corresponds to the `"global"` option if ESLint considers a file to be a **Node.js** or **CommonJS** module because the configuration specifies either of the following:
  70
  71 * `node` or `commonjs` [environments](/docs/user-guide/configuring/language-options.md#specifying-environments)
  72 * `"globalReturn": true` property in the `ecmaFeatures` object of [parser options](/docs/user-guide/configuring/language-options.md#specifying-parser-options)
  73
  74 Otherwise the `"safe"` option corresponds to the `"function"` option. Note that if `"globalReturn": false` is explicitly specified in the configuration, the `"safe"` option will correspond to the `"function"` option regardless of the specified environment.
  75
  76 ### global
  77
  78 Examples of **incorrect** code for this rule with the `"global"` option:
  79
  80 ```js
  81 /*eslint strict: ["error", "global"]*/
  82
  83 function foo() {
  84 }
  85 ```
  86
  87 ```js
  88 /*eslint strict: ["error", "global"]*/
  89
  90 function foo() {
  91     "use strict";
  92 }
  93 ```
  94
  95 ```js
  96 /*eslint strict: ["error", "global"]*/
  97
  98 "use strict";
  99
 100 function foo() {
 101     "use strict";
 102 }
 103 ```
 104
 105 Examples of **correct** code for this rule with the `"global"` option:
 106
 107 ```js
 108 /*eslint strict: ["error", "global"]*/
 109
 110 "use strict";
 111
 112 function foo() {
 113 }
 114 ```
 115
 116 ### function
 117
 118 This option ensures that all function bodies are strict mode code, while global code is not. Particularly if a build step concatenates multiple scripts, a strict mode directive in global code of one script could unintentionally enable strict mode in another script that was not intended to be strict code.
 119
 120 Examples of **incorrect** code for this rule with the `"function"` option:
 121
 122 ```js
 123 /*eslint strict: ["error", "function"]*/
 124
 125 "use strict";
 126
 127 function foo() {
 128 }
 129 ```
 130
 131 ```js
 132 /*eslint strict: ["error", "function"]*/
 133
 134 function foo() {
 135 }
 136
 137 (function() {
 138     function bar() {
 139         "use strict";
 140     }
 141 }());
 142 ```
 143
 144 ```js
 145 /*eslint strict: ["error", "function"]*/
 146 /*eslint-env es6*/
 147
 148 // Illegal "use strict" directive in function with non-simple parameter list.
 149 // This is a syntax error since ES2016.
 150 function foo(a = 1) {
 151     "use strict";
 152 }
 153
 154 // We cannot write "use strict" directive in this function.
 155 // So we have to wrap this function with a function with "use strict" directive.
 156 function foo(a = 1) {
 157 }
 158 ```
 159
 160 Examples of **correct** code for this rule with the `"function"` option:
 161
 162 ```js
 163 /*eslint strict: ["error", "function"]*/
 164
 165 function foo() {
 166     "use strict";
 167 }
 168
 169 (function() {
 170     "use strict";
 171
 172     function bar() {
 173     }
 174
 175     function baz(a = 1) {
 176     }
 177 }());
 178
 179 var foo = (function() {
 180     "use strict";
 181
 182     return function foo(a = 1) {
 183     };
 184 }());
 185 ```
 186
 187 ### never
 188
 189 Examples of **incorrect** code for this rule with the `"never"` option:
 190
 191 ```js
 192 /*eslint strict: ["error", "never"]*/
 193
 194 "use strict";
 195
 196 function foo() {
 197 }
 198 ```
 199
 200 ```js
 201 /*eslint strict: ["error", "never"]*/
 202
 203 function foo() {
 204     "use strict";
 205 }
 206 ```
 207
 208 Examples of **correct** code for this rule with the `"never"` option:
 209
 210 ```js
 211 /*eslint strict: ["error", "never"]*/
 212
 213 function foo() {
 214 }
 215 ```
 216
 217 ### earlier default (removed)
 218
 219 (removed) The default option (that is, no string option specified) for this rule was **removed** in ESLint v1.0. The `"function"` option is most similar to the removed option.
 220
 221 This option ensures that all functions are executed in strict mode. A strict mode directive must be present in global code or in every top-level function declaration or expression. It does not concern itself with unnecessary strict mode directives in nested functions that are already strict, nor with multiple strict mode directives at the same level.
 222
 223 Examples of **incorrect** code for this rule with the earlier default option which has been removed:
 224
 225 ```js
 226 // "strict": "error"
 227
 228 function foo() {
 229 }
 230 ```
 231
 232 ```js
 233 // "strict": "error"
 234
 235 (function() {
 236     function bar() {
 237         "use strict";
 238     }
 239 }());
 240 ```
 241
 242 Examples of **correct** code for this rule with the earlier default option which has been removed:
 243
 244 ```js
 245 // "strict": "error"
 246
 247 "use strict";
 248
 249 function foo() {
 250 }
 251 ```
 252
 253 ```js
 254 // "strict": "error"
 255
 256 function foo() {
 257     "use strict";
 258 }
 259 ```
 260
 261 ```js
 262 // "strict": "error"
 263
 264 (function() {
 265     "use strict";
 266     function bar() {
 267         "use strict";
 268     }
 269 }());
 270 ```
 271
 272 ## When Not To Use It
 273
 274 In a codebase that has both strict and non-strict code, either turn this rule off, or [selectively disable it](/docs/user-guide/configuring/rules.md#disabling-rules) where necessary. For example, functions referencing `arguments.callee` are invalid in strict mode. A [full list of strict mode differences](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode/Transitioning_to_strict_mode#Differences_from_non-strict_to_strict) is available on MDN.