ELOQUENT 자바스크립트 : 3장

Functions play a crucial role in programming. Advantages :

• Larger programs can be structured using functions.
• Names can be associated with subprograms.
• Different subprograms to perform different to execute different parts of code.
• Reduced repetition.

To begin with, functions are declared using a function keyword.
They may or may not take a parameter depending on the type of calculations they are going to be used for. The body of a function starts and ends with parentheses. Some functions have a return statement, some don't.

const square = function(x) {  //function declaration
return x * x;
};

console.log(square(12));

//Result → 144

const createVoice = function() {
console.log("Hahahahaha!");
};


createVoice();
//Result → Hahahahaha!

In JavaScript there are two types of scope:

• Local scope -> These are the variables declared within a JavaScript function. Local variables have Function scope i.e they can only be accessed from within the function.

function myFunction() {
  var carName = "Volvo";
}

• Global scope -> These are the variables declared outside a function. A global variable has global scope i.e all scripts and functions on a web page can access it.

var carName = "Volvo";
function myFunction() {
}

Variables created without a declaration keyword (var, let, or const) are always global, even if they are created inside a function.

JavaScript can have nested scope as well. Blocks and functions
can be created inside other blocks and functions, producing multiple degrees of locality. All functions have access to the global scope. Nested functions have access to the scope "above" them.

const hummus = function(factor) {
const ingredient = function(amount, unit, name) {
let ingredientAmount = amount * factor;
if (ingredientAmount > 1) {
unit += "s";
}
console.log(`${ingredientAmount} ${unit} ${name}`);
};
ingredient(1, "can", "chickpeas");
ingredient(0.25, "cup", "tahini");
ingredient(0.25, "cup", "lemon juice");
ingredient(1, "clove", "garlic");
ingredient(2, "tablespoon", "olive oil");
ingredient(0.5, "teaspoon", "cumin");
};


//The code inside the ingredient function can see the factor binding 
from the outer function. But its local bindings, such as unit 
or ingredientAmount, are not visible in the 
outer function.

In JS, the order of function declaration and function call does not matter. Function declarations are not part of the regular top-to-bottom flow of control. They are conceptually moved to the top of their scope and can be used by all the code in that scope.

console.log("The future says:", future());
function future() {
return "You'll never have flying cars";
}


// result -> The future says you'll Never have flying cars