Global scope in Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is global scope in JavaScript?

Global scope means a variable or function is accessible from anywhere in the code, no matter where it is used.

beginner

Where are variables declared outside any function or block stored?

They are stored in the global scope and can be accessed anywhere in the program.

intermediate

What happens if you declare a variable without let, const, or var inside a function?

It becomes a global variable, which can cause bugs because it is accessible everywhere.

beginner

How can you avoid polluting the global scope?

Use let, const, or var inside functions or blocks to keep variables local.

intermediate

What is the global object in browsers and how is it related to global scope?

In browsers, the global object is window. Variables in global scope become properties of window.

Where can you access a variable declared in the global scope?

A Only inside the block where it was declared

B Only inside the function where it was declared

C Anywhere in the code

D Nowhere, it is private

Variables declared in the global scope are accessible anywhere in the program.

What happens if you forget to use let, const, or var when declaring a variable inside a function?

A It becomes a global variable

B It causes a syntax error

C It becomes a block-scoped variable

D It is deleted immediately

Without declaration keywords, the variable is created in the global scope, which can cause bugs.

Which object represents the global scope in a browser environment?

A navigator

B document

C console

D window

The window object is the global object in browsers, holding global variables and functions.

How can you keep variables from polluting the global scope?

A Declare them inside functions or blocks using <code>let</code> or <code>const</code>

B Declare them without any keyword

C Declare them only at the top of the file

D Use global variables everywhere

Using let or const inside functions or blocks keeps variables local and avoids global pollution.

Which of these is true about global scope?

A Global scope variables are private to functions

B Variables in global scope can be accessed anywhere

C Global scope variables disappear after a function ends

D Global scope only exists inside blocks

Global scope variables are accessible from any part of the code.

Explain what global scope means in JavaScript and why it can be risky to use too many global variables.

Think about how variables can be seen everywhere and how that might cause problems.

Describe how to avoid polluting the global scope when writing JavaScript code.

Focus on how to keep variables limited to where they are needed.

Practice

1. What does it mean when a variable is in the global scope in JavaScript?

easy

A. The variable can be accessed anywhere in the code.

B. The variable can only be used inside a function.

C. The variable is hidden from all parts of the code.

D. The variable is deleted after a function finishes.

Solution

1. Step 1: Understand global scope meaning

   Global scope means a variable is declared outside any function and is accessible everywhere in the code.

2. Step 2: Compare options with definition

   Only The variable can be accessed anywhere in the code. correctly states that the variable can be accessed anywhere.

3. Final Answer:

   The variable can be accessed anywhere in the code. -> Option A

4. Quick Check:

   Global scope = accessible everywhere [OK]

Hint: Global variables are outside functions, accessible everywhere [OK]

Common Mistakes:

• Thinking global variables are only inside functions
• Confusing global with local scope
• Believing global variables disappear after function ends

2. Which of the following is the correct way to declare a global variable in JavaScript?

easy

A. Inside a function using let

B. Outside any function using var

C. Inside a block using const

D. Inside a function using const

Solution

1. Step 1: Identify where to declare global variables

   Global variables must be declared outside any function or block.

2. Step 2: Check declaration keywords

   Using var outside functions creates a global variable. Options A, B, and D declare inside functions or blocks, so they are not global.

3. Final Answer:

   Outside any function using var -> Option B

4. Quick Check:

   Global variable = declared outside functions [OK]

Hint: Declare global variables outside functions with var [OK]

Common Mistakes:

• Declaring variables inside functions and expecting global scope
• Using let or const inside blocks thinking they are global
• Confusing block scope with global scope

3. What will be the output of this code?

var x = 10;
function show() {
  console.log(x);
}
show();

medium

A. 10

B. undefined

C. ReferenceError

D. null

Solution

1. Step 1: Identify variable scope

   Variable x is declared globally with var and has value 10.

2. Step 2: Check function access

   The function show logs x. Since x is global, it is accessible inside the function.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Global variable accessed inside function = 10 [OK]

Hint: Global variables are accessible inside functions [OK]

Common Mistakes:

• Expecting undefined because variable is outside function
• Thinking console.log will cause ReferenceError
• Confusing local and global scope

4. Find the error in this code related to global scope:

function test() {
  var a = 5;
}
console.log(a);

medium

A. No error, prints 5

B. TypeError: a is undefined

C. ReferenceError: a is not defined

D. SyntaxError: var inside function

Solution

1. Step 1: Check variable scope

   Variable a is declared inside function test with var, so it is local to that function.

2. Step 2: Access variable outside function

   Trying to log a outside the function causes a ReferenceError because a is not in global scope.

3. Final Answer:

   ReferenceError: a is not defined -> Option C

4. Quick Check:

   Local variable accessed globally = ReferenceError [OK]

Hint: Variables inside functions are not global [OK]

Common Mistakes:

• Assuming var inside function is global
• Expecting output 5 instead of error
• Confusing ReferenceError with SyntaxError

5. You want to create a global counter variable that increases every time a function runs. Which code correctly uses global scope to do this?

hard

A. let counter = 0;
function count() {
let counter = 0;
counter++;
console.log(counter);
}

B. function count() {
var counter = 0;
counter++;
console.log(counter);
}

C. function count() {
let counter = 0;
counter++;
console.log(counter);
}

D. var counter = 0;
function count() {
counter++;
console.log(counter);
}

Solution

1. Step 1: Identify global variable declaration

   var counter = 0;
   function count() {
     counter++;
     console.log(counter);
   }

   declares counter outside the function, making it global and accessible inside the function.

2. Step 2: Check counter increment behavior

   Inside count, counter++ increases the global variable, so the count persists across calls.

3. Final Answer:

   var counter = 0; function count() { counter++; console.log(counter); } -> Option D

4. Quick Check:

   Global counter increments inside function =

   var counter = 0;
   function count() {
     counter++;
     console.log(counter);
   }

   [OK]

Hint: Declare counter outside function to keep it global [OK]

Common Mistakes:

• Declaring counter inside function resets it each call
• Using let inside function hides global variable
• Expecting local counter to remember previous value