함수란?

// 함수 정의
function add(x, y) {
  return x + y;
}
 
// 함수 호출
var result = add(2, 5);
 
console.log(result); // 7

// 함수 선언문
function add(x, y) {
  return x + y;
}
 
// 함수 표현식
var add = function (x, y) {
  return x + y;
};
 
// Function 생성자 함수
var add = new Function('x', 'y', 'return x + y');
 
// 화살표 함수(ES6)
var add = (x, y) => x + y;

function foo() { console.log('foo'); }
 
foo(); // foo
 
(function bar() { console.log('bar'); });
 
bar(); // ReferenceError: bar is not defined

// 익명 함수 표현식
var add = function (x, y) {
  return x + y;
}
 
// 기명 함수 표현식
var add = function foo (x, y) {
  return x + y;
}
 
console.log(add(2,5)); // 7
 
console.log(foo(2,5)); // ReferenceError: foo is not defined

// 함수 참조
console.dir(add); // f add(x, y)
console.dir(sub); // undefined
 
// 함수 호출
console.log(add(2, 5)); // 7
console.log(sub(2, 5)); // TypeError: sub is not a function
 
// 함수 선언문
function add(x, y) {
  return x + y;
};
 
// 함수 표현식
var sub = function (x, y) {
  return x - y;
}

var add = new Function('x', 'y', 'return x + y');
 
console.log(add(2, 5)); // 7

const add = (x, y) => x + y;
console.log(add(2, 5)); // 7

function add(x, y) {
  return x + y;
}
 
console.log(add(2)); // 2 + undfined가 되므로 NaN이 반환된다.
console.log(add('a', 'b')); // 'ab'

function add(x, y) {
  if (typeof x !== 'number' || typeof y !== 'number') {
    // 매개변수를 통해 전달된 인수의 타입이 부적절한 경우 에러를 발생
    throw new TypeError('인수는 모두 숫자 값이어야 한다.');
  }
  return x + y;
}
 
console.log(add(2)); // TypeError: 인수는 모두 숫자 값이어야 한다.
console.log(add('a', 'b')); // TypeError: 인수는 모두 숫자 값이어야 한다.

function add(x, y) {
  console.log(arguments); // Arguments(3) [2, 5, 10, callee: f, Symbol(Symbol.iterator): f]
  return x + y;
}
 
console.log(add(2, 5, 10)); // 7

function add(x, y, z) {
  x = x || 0;
  y = y || 0;
  z = z || 0;
  return x + y + z;
}
 
// ES6에서 도입된 매개변수 기본값 지정
function add(x = 0, y = 0, z = 0) {
  return x + y + z;
}
 
console.log(add(1, 2, 3)); // 6
console.log(add(1, 2)); // 3
console.log(add(1)); // 1
console.log(add()); // 0

// 매개변수 primitive는 원시 값, obj는 객체를 전달 받음
function changeVal(primitive, obj) {
  primitive += 100;
  obj.name = 'kim';
}
 
// 외부 상태
let num = 100;
let person = { name: 'lee' };
 
console.log(num); // 100
console.log(person); // {name: 'lee'}
 
// 원시 값은 값 자체가 복사되어 전달되고 객체는 참조 값이 복사되어 전달된다.
// 원시 값은 재할당이 이뤄지고 객체는 변경 가능한 값이므로 직접 변경
changeVal(num, person);
 
// 원시 값은 원본이 훼손되지 않는다.
console.log(num); // 100
 
// 객체는 원본이 훼손된다. 부수 효과 발생
console.log(person); // {name: 'kim'}

// 익명 즉시 실행 함수
(function() {
   var a = 3;
   var b = 5;
   return a * b;
}());
 
// 기명 즉시 실행 함수
(function foo() {
   var a = 3;
   var b = 5;
   return a * b;
}());
 
foo(); // ReferenceError: foo is not defined
 
function() { // SyntaxError: Function statements require a function name
   var a = 3;
   var b = 5;
   return a * b;
}();
 
function foo () { 
   var a = 3;
   var b = 5;
   return a * b;
}(); // SyntaxError: Unexpected token ')' 
// function foo() {}(); => function foo() {};();

// 일반적인 반복 함수
function coundown(n) {
    for (var i=n; i>0; i--) console.log(i);
}
 
// 재귀 함수
function  countdownRecursive(n) {
    if (n==0) return
    console.log(n)
    countdownRecursive(n-1)
}

function outer() {
  var x = 1;
 
  // 중첩 함수
  function inner() {
    var y = 2;
    // 외부 함수의 변수를 참조할 수 있다.
    console.log(x + y); // 3
  }
 
  inner();
}
 
outer();

// 외부에서 전달받은 f를 n만큼 반복 호출한다
function repeat(n, f) {
  for (var i = 0; i < n; i++) {
    f(i); // i를 전달하면서 f를 호출
  }
}
 
var logAll = function (i) {
  console.log(i);
};
 
// 반복 호출할 함수를 인수로 전달한다.
repeat(5, logAll); // 0 1 2 3 4
 
var logOdds = function (i) {
  if (i % 2) console.log(i);
};
 
// 반복 호출할 함수를 인수로 전달한다.
repeat(5, logOdds); // 1 3

//콜백 함수를 사용한 이벤트 처리
//myButton 버튼을 클릭하면 콜백 함수 실행
document.getElementbyId('myButton').addEventListener('click', function () {
	console.log('button clicked!');
});
 
// 콜백 함수를 사용한 비동기 처리
// 1초 후에 메시지 출력
setTimeout(function () {
	console.log('1초 경과');
});

var count = 0; // 현재 카운트를 나타내는 상태
 
// 순수 함수 increase는 동일한 인수가 전달되면 언제나 동일한 값을 반환한다.
function increase(n) {
  return ++n;
}
 
// 순수 함수가 반환한 결과값을 변수에 재할당해서 상태를 변경
count = increase(count);
console.log(count) // 1
 
count = increase(count);
console.log(count) // 2

var count = 0; // 현재 카운트를 나타내는 상태: increase 함수에 의해 변화한다.
 
// 비순수 함수
function increase() {
  return ++count; // 외부 상태에 의존하며 외부 상태를 변경한다.
}
 
// 비순수 함수는 외부 상태(count)를 변경하므로 상태 변화를 추적하기 어려워진다.
increase();
console.log(count) // 1
 
increase();
console.log(count) // 2