In the last article, we talked about the following
- Today, we will be discussing the following
- Function Definitions
- Positional and Keyword/Named Parameters
- Arrow Functions in Javascript
Today we will discuss variable's scope in Python and JavaScript. We will discuss the following
- Blocks
- Global Variables
- Local/Block Variables and Accessing them outside a Block
- Global and Local Variables with the same name
Blocks
Python
In Python, blocks are declared using the ":" operator. The code inside the block has to be indented.
def func():
print("This statement is inside a block")
print("This statement is inside a block as well")
print("This statement is outside the above block")
JavaScript
In JavaScript, we can start a block using the "{" operator and end the block using the "}" operator. The code inside the "{" and "}" is inside the block. Although indentation is not necessary, it's a good practice to indent your code. It improves readability
const func = () =>
{
console.log("This statement is inside a block")
console.log("This statement is inside a block as well")
}
console.log("This statement is outside the above block")
Global Variables
Global variables are variables that are declared outside a block
Python
In Python, we can either access the global variable or update the global variable. We can use the variable as it is if we plan to access it. However, if we want to update it, we will need to use the global keyword
global_variable = "I am a global variable"
'''
Accessing Global Variable
'''
def func1():
print(global_variable)
'''
Updating Global Variable
'''
def func2():
global global_variable
global_variable += ".....Updating"
print(global_variable)
JavaScript
Unlike Python, in JavaScript, we can access as well as update the variable as it is, i.e we don't need any extra statements/keywords like global
var global_variable = "I am a global variable"
/*
Accessing Global Variable
*/
func1 = () => {
console.log(global_variable)
}
/*
Updating Global Variable
*/
func2 = () => {
global_variable += ".....Updating"
console.log(global_variable)
}
Local/Block Variables and Accessing them outside a Block
Python
- A local variable declared inside a function CAN NOT be accessed outside the function block
- A local variable declared inside an if/else block or a loop CAN be accessed outside the block
def func():
local_variable = "I am a local variable"
print(local_variable)
func()
print(local_variable)
You'd get the following error
NameError: name 'local_variable' is not defined
Let's try to access a local variable declared inside an if/else block
if True:
local_variable = "I am a local variable"
print(local_variable)
print(local_variable)
The above code snippet doesn't result in any error
JavaScript
JavaScript is similar to Python
- A local variable declared inside a function CAN NOT be accessed outside the function block
- A local variable declared inside an if/else block or a loop CAN be accessed outside the block
func = () =>{
var local_variable = "I am a local variable"
console.log(local_variable)
}
func()
console.log(local_variable)
You'd get the following error
ReferenceError: local_variable is not defined
If we try to access a local variable declared inside an if/else block
if(true){
var local_variable = "I am a local variable"
console.log(local_variable)
}
console.log(local_variable)
The above code snippet will not result in any error
Global and Local Variables with the same name
NOTE: HAVING GLOBAL VARIABLES AND LOCAL VARIABLES WITH THE SAME NAME IS BAD PRACTICE!!! IT CAN LEAD TO UNNECESSARY COMPLICATIONS
Let's look at a few code-snippets.
First, let's take a look at a Python snippet with a function.
string = "Global Variable"
def func():
string = "Local variable"
print(string)
func()
print(string)
Below is the output
Local variable
Global Variable
- We have a global variable called string which has the value Global Variable
- Inside the function, when we are assigning the value "Local variable" to the variable string, we actually create a local variable called string. Therefore, any reference to string inside the block is to the local variable string. Basically, we have temporarily overwritten the global variable
- Outside the block, the local variable string* no longer exists and any reference to string is made to the global variable string**
To avoid creating a local variable inside the function, we could use the global keyword discussed earlier.
Now let's try something similar in JavaScript
var string = "Global Variable"
const func = () => {
string = "Local Variable"
console.log(string)
}
func()
console.log(string)
Below is the output
Local Variable
Local Variable
- We defined a global variable string
- Inside the function, we don't define a new local variable since we don't use the let or var keywords. Therefore inside the function, any reference to variable string is a reference to the global variable. As a result, "Local Variable" is the output
- Since we updated the global variable in the function, the console statement outside the functions also outputs the updated value
Now let's try defining a local variable with the var keyword
var string = "Global Variable"
const func = () => {
var string = "Local Variable"
console.log(string)
}
func()
console.log(string)
Now the functionality is similar to the Python snippet we discussed above. Below is the output
Local Variable
Global Variable