Scope
Tags: javascript, scope
Published: 2022-07-19 14:29:08

- 
          This post is mainly about scope in vanilla JavaScript and different ways it can be used to our advantage. There are a lot of ways to look at scope to try and better understand it, my brain always goes to the analogy that if your app is a car then scope is the various compartments within the vehicle. Global scope is the interior of your car, from there you can open your hood and trunk but you do so with a “function” because you are in global scope. Your trunk is like block chain only accessible within itself (unless your rear seats fold down to give access to the trunk like naming a variable var within a block but for my example I am not referencing a car like that or naming a variable var within my block) you can pack as much as you want into your trunk but if you want access to it inside your interior you will have to pull it out of the trunk and put it into global. Your engine compartment is like function scope it is also self contained but there are many systems working with each other and handing down info to child subsystems to allow everything to work.  


## Global Scope

- 
          Global scope can be used pretty safely within smaller app but as your app builds in size declaring variables within a global scope can lead to lots of debugging and headaches later down the line. It is best practice if you can to declare variables within the scope of where they will be used to avoid over writing their value or accessing the wrong variable with a function. Back to my example from above if you think about the inside of your car while you are sitting in the drivers seat you have access to the whole car you can reach over and open your glove box you can use your hood and trunk release and it is all within an arms reach which is really nice. You can not however pull something out of your engine compartment or from your trunk from the drivers seat, but you can affect those compartments from your drivers seat. 


```


//example 1

const varible1= "Hello world"

function showInConsoleLog(){
 console.log(varible1)
}

showInConsoleLog()

excepted return in console
console Hello World


//example 2 

const firstNumber = 2
const secondNumber = 4

function addNumberTogether(){
const numbersAddedTogether = (firstNumber + secondNumber)
console.log(numbersAddedTogether)
}

addNumberTogether()

excepted return in console
console 6


//example 3

const firstNumber = 2
const secondNumber = 4

function addNumberTogether(){
const numbersAddedTogether = (firstNumber + secondNumber)
}

/* 
This will not show up in console even though the function is invoked and the numbers are added together.
vvv The value of numbersAddedTogether is not declared Globally, so it cannot be seen by the console.log() which is in global scope. 
*/
 
console.log(numbersAddedTogether)

addNumberTogether()

excepted return in console
ReferenceError: numbersAddedTogether is not defined
}

```


## Block Scope

- 
          Block scope and function scope are closely related but do have some differences. Function scope can be passed an argument when invoked and then can use the invoked argument within its scope. Block scope will cut off anything from the outside being able to access what is between the curly braces, it is useful if you have specific variables you only want to access within the block scope or to have two variables with the same name with different values available to the app depending on how the code resolves. This is again not true if your variable is declared with var instead of let or const. Block scope is useful for creating Block statements, which allows your code to use and or resolve multiple statements in places where javascript excepts only one statement. An example of that is if statements and for statements where we can name a variable to be referenced for a check, but not have access to that variable outside of that statement. Example 3 in global scope shows off block scope, as well as the example below    


```


//example 1

function increaseNumber() {
  for (let x = 0; x < 5; x++) {
    console.log(x)
  } 
}
increaseNumber()

excepted return in console
console 0
console 1
console 2
console 3
console 4


//example 2

function increaseNumber() {
  for (let x = 0; x < 5; x++) {
  } 

/*
This will not show up in console even though x is being increased and the code does know that, 
vvv x is not defined in within scope of the console log so it can not reference it vvv
*/
   console.log(x)
}
increaseNumber()

excepted return in console
ReferenceError: x is not defined

```
 

## Function Scope

- 
         Function scope is a little bit more tricky then global and block scope. Function scope back to my analogy is like your cars engine compartment. Think of your dashboard it gives you a read out of what is happening inside your engine compartment, this is similar to returning in a function declared in global scope. It is allowing the results of the function to be viewed from outside the function, but that doesn’t mean you have access to the sensors interior variables only its result.  There is more info though from the engine compartment that you do not have access to from your dash, this is similar to a function declared within a function you can not directly see the results on your dash. Even though that info might be critical to making sure your car is working it does not need to be viewed by you(Global scope). Now lets talk about your gas pedal, its a function that is declared in global scope but can effect the engine. This is similar to using the argument passed into a function to use variables declared within a function scope with that global function. When the function is invoked within another scope is can access the data within that scope if it is passed the data as the argument while invoking. To put this back to the analogy when you push you gas pedal you are telling your car you want to go faster, it then takes that function and passes it to the engine. The engine will then decide by running that function with some other data as the argument if that is possible to do. So your function(gas pedal) actually has access to data that is well within another function scope(engine compartment) as long as when the function (gas pedal) is invoked within another function scope (engine compartment) it is passed the data as an argument. There are some issue with this analogy if you really break it down but hopefully this brief overview helped someone understand scope a little better.



```


//example 1

function getNameFromFunctionScope(name){
    console.log(name)
}
  
function createFirstNameToRetrieve(){
   const firstName = 'John'
   
   const middleName = firstName + ' Paper'
       
   const lastName =middleName + ' Smith'
         
   getNameFromFunctionScope(lastName)
          
}
  
createFirstNameToRetrieve()

excepted return in console 
console John Paper Smith

/*
^^^ In this example even though the console.log() is in a separate scope lastName is available to it because, ^^^
it is invoked within the scope of lastName with lastName as an argument.
That argument is referenced as a parameter in the function and then console logged 
*/


//example 2

function getNameFromFunctionScope(name){
    console.log(name)
}
  
  function createFirstNameToRetrieve(){
    const firstName = 'John'
   
       const middleName = firstName + ' Paper'
       
         const lastName =middleName + ' Smith'
         
         getNameFromFunctionScope(middleName)
       
     
  }
  
createFirstNameToRetrieve()

excepted return in console 
console John Paper 

/* 
Similar to the above example. This is to show that even though the function creates a full name 
we can access the variables separately, if we use that varible as the parameter when we invoke our function.
*/
 
   

  
```