Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m

Next lesson playing in 5 seconds

Cancel
  • 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;

1.Introduction
2 lessons, 07:42

1.1
Introduction
02:12

1.2
Setup
05:30

2.Language Fundamentals
8 lessons, 1:00:53

2.1
Variables
06:33

2.2
Data Types
11:28

2.3
Arithmetic, Assignment, and Comparison Operators
10:24

2.4
Unary, Logical, Comma, and Spread Operators
09:02

2.5
Operator Precedence
03:50

2.6
Reserved Words
04:17

2.7
Strict Mode
04:34

2.8
Functions
10:45

3.Data Structures
5 lessons, 22:52

3.1
Arrays
04:29

3.2
Objects
04:30

3.3
Sets
04:57

3.4
Maps
04:21

3.5
Weak Maps and Weak Sets
04:35

4.Controlling Program Execution
7 lessons, 37:06

4.1
Conditionals
07:49

4.2
Switch Statements
04:41

4.3
The For Loop
06:39

4.4
The `for .. in` Loop
05:17

4.5
The `for .. of` Loop
04:02

4.6
Iterators
05:03

4.7
While Loops
03:35

5.Using JavaScript
13 lessons, 1:44:36

5.1
Working With Strings
09:32

5.2
Template Literals
05:46

5.3
Working With Numbers
06:57

5.4
Working With Arrays
12:53

5.5
Iterating and Transforming Arrays
07:33

5.6
Working With the Object Type
13:55

5.7
Object Literal Extensions
06:45

5.8
Working With Object Instances
06:45

5.9
Getters and Setters
05:00

5.10
Custom Objects
11:28

5.11
The `Math` API
04:54

5.12
Working With Dates and Times
08:10

5.13
The `Array` Constructor
04:58

6.Functions
8 lessons, 56:07

6.1
The `this` Object
06:15

6.2
Working With Functions
10:11

6.3
Scope
07:37

6.4
Arrow Functions
06:59

6.5
Generator Functions
08:13

6.6
Closures
05:00

6.7
Prototypes
06:26

6.8
Default and Rest Parameters
05:26

7.Miscellaneous
6 lessons, 52:39

7.1
Destructuring Assignments
08:09

7.2
AJAX
08:30

7.3
Regular Expressions
10:51

7.4
More About Regular Expressions
08:38

7.5
Classes
06:48

7.6
ES Modules
09:43

8.Working With the DOM
6 lessons, 37:39

8.1
Selecting HTML Elements
05:02

8.2
Manipulating HTML Elements
07:40

8.3
DOM Traversal
05:25

8.4
Adding and Removing Elements
04:45

8.5
Creating Elements and Other Nodes
04:39

8.6
DOM Events
10:08

9.Web APIs
4 lessons, 17:41

9.1
The Selector API
03:03

9.2
Geolocation
05:29

9.3
Web Storage
05:24

9.4
Web Workers
03:45

10.Asynchronous JavaScript
5 lessons, 26:23

10.1
Promises
09:52

10.2
Promise Chaining
05:11

10.3
The async Keyword
03:21

10.4
The await Keyword
04:04

10.5
More About async and await
03:55

11.Conclusion
1 lesson, 00:43

11.1
Conclusion
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