Javascript Strict Mode

Definition: What is a Strict Mode in Javascript?

The 'Strict Mode' is a way to opt in to a restricted variant of JavaScript. It intentionally has different semantics from the normal code. Mistakes that make it difficult to keep your JavaScript code bug-free are treated as errors in strict-mode.

Evolution and purpose of Strict Mode in Javascript

Javascript Strict Mode Specifications

Syntax modifications in Javascript Strict Mode

            // Normal Mode
            var x = 5; 
            delete x;
        

            // Strict Mode
            "use strict";
            var x = 5; // Deleting a variable is not allowed
            delete x; // Error 
        

Utilising Javascript Strict Mode

How to Apply Strict Mode in Javascript

        "use strict";
        var x = 3.14;
        

        function strictModeFunction() {
            "use strict";
            var y = 3.14;
        }
        

Preparing your code for Strict Mode in Javascript

• All variable names must be declared with 'var'.
• Octal literals, those numbers that are prefixed with zero (like 014, 07), are not allowed.
• Attempting to delete variables, functions or function arguments will throw an error.
• Writing to a read-only property will also throw an error.

When to Use Strict Mode in Javascript

Identifying appropriate scenarios for Javascript Strict Mode application

Delving Deeper into Javascript Strict Mode

What does Strict Mode do in Javascript?

• Preventing the use of global variable: In JavaScript, if you forget to declare a variable with 'var', it becomes a global variable. The use of strict mode throws an error in such cases, helping to avoid unintentional global variables creation.
• Disallowing duplicate parameter values: In non-strict mode, JavaScript supports functions having parameters with duplicate names. Strict mode disallows this, which eliminates potential confusion and bugs.
• No silent errors: Many JavaScript errors are silently ignored, but strict mode treats these silent errors as real errors, and either throws an error or turns them into exceptions.

Identifying and Understanding changes brought by Strict Mode

Javascript Strict Mode Example

        // This will apply strict mode to the entire script
        "use strict"; 

        var x = 3.14; // This is valid

        y = 3.14; // This will throw an error because y is not declared
        

        function myFunction() {
            // This will apply strict mode only within this function
            "use strict";

            var x = 3.14;  // This is valid

            y = 3.14; // This will throw an error because y is not declared
        }

        myFunction();
      

Demonstrating usage and results of Strict Mode

        function myFunction() {
            "use strict";
            
            alert(this);  // Will alert "undefined"
        }
        
        myFunction();
        

The Benefits of Strict Mode in Javascript

Performance enhancements through Strict Mode

• Variables are promptly and correctly interpreted, improving runtime efficiency.
• 'Silent errors' that might cause performance bottlenecks are thrown, allowing them to be caught and fixed.
• Strict mode disallows certain less optimisable language features, enabling JavaScript engines to run your code more rapidly and efficiently.

Debugging advantages with Javascript Strict Mode

Writing safer and cleaner code with Javascript Strict Mode

• Prevents the accidental creation of global variables by requiring variables to be declared with 'var'.
• Restricts the use of certain keywords that are reserved for future versions of Javascript, safeguarding your code against future changes to the language.
• Blocks the use of potentially confusing syntax, such as duplicate parameter names in function declarations.
• Deters unsafe actions by throwing errors for them, encouraging adherence to safer programming practices.