FREELessons: 65Length: 7.1 hours

• Overview
• Transcript

# 2.7 Strict Mode

Strict mode is a useful execution mode for JavaScript that can prevent many errors and should always be used. In this lesson we’ll learn all about it.

Syntax

• use strict;

## 11.Conclusion1 lesson, 00:43

### 2.7 Strict Mode

Hi folks. In this lesson, we are going to learn about what strict mode is, and why you must almost always use it. Strict mode is a slightly different mode of JavaScript execution, which is stricter than regular or non strict code. And it effects how some features of the language are used. Non strict JavaScript is often referred to as sloppy mode. Strict mode was introduced a long time ago to improve some of JavaScript's downsides. These days, strict mode should almost always be used, and in some cases will be enforced automatically, like when using ES modules, which we'll come back and look at much later in the course. It's recommended to always use strict mode because all modern browsers support it and because it causes some silent errors to actually throw an error. It also prevents global variables from being created if we accidentally forget to use var, let or const when declaring a variable. And it has a host of other benefits, also. So to use it, we just need to add the string 'use strict' as the first line inside either a function or a file. It's recommended to use it inside a function, because there can be problems if we concatenate strict and non strict files together. And concatenating JavaScript files together is a very common part of most JavaScript's build processes. Generally, it's easy to use strict mode inside a function because generally, all of a code inside a file will be wrapped inside an immediately invoked function. Aside from maybe some licensing information in the comment at the top of the file, or when we're using AS modules, generally, all the script files that we'll create will wrap all of their code inside a function, like this. So now all of the code that we add to this file, qhich will be added inside the function, will be run in strict mode. This type of function is known as an immediately invoked function expression, or IFFE for short. So strict mode does a number of things for us. First of all, it throws errors when we try to override certain globals instead of just failing silently, like it would do in sloppy mode. The built-in read-only Globals are none, undefined and infinity. Usually, if we try to write these it's because of an error in our code. So an error message is much more useful to us than a silent failure. In this case we see an error message saying that we can not assign to the read only property NAN, which is a property of the global object window. In non strict mode, it just comment out the Uscript directed. Let's get back to the browser again. This time we don't see the error message. However, trying to overwrite NaN will have failed. So NaN still has the value, N-a-N, which is a special value, trying to overwrite the value with a string didn't work, but we didn't see an error message. So that's one of the most important benefits of using strict mode. It throws errors instead of failing silently. Strict mode also prevents the use of the with operator, and that's why we didn't cover it earlier when we looked operators. Additionally, strict mode adds some new reserved words to the language. And these are package, protected, implements, interface, private, and static. As I said, strict mode was introduced a very long time ago, but it was only recently that some of these new reserved words became useable, like private and static. These are used with JavaScript classes, which we will come back and look at later in the course. So in this lesson, we've learned about what strict mode is, and why we should always use it when applicable. In the next lesson, we're going to look at one of the most fundamental aspects of JavaScript, the function. Thanks for watching.

Back to the top