DOM

DOM은 HTML 문서의 구조화된 표현이다. 웹 페이지의 각 요소는 객체로 표현되며, 이 객체들은 트리 구조를 형성한다. DOM을 통해 자바스크립트는 문서의 구조, 스타일, 콘텐츠를 동적으로 변경할 수 있다.

 

요소 선택

DOM 요소를 조작하기 위해서는 먼저 해당 요소를 선택해야 한다.

자주 사용되는 두 가지 방법으로 getElementById와 querySelector가 있다.

 

getElementById

getElementById 메서드는 문서에서 특정 ID를 가진 요소를 선택한다. ID는 문서 내에서 고유해야 한다.

 

const element = document.getElementById('myElement');
console.log(element); // 해당 ID를 가진 요소를 출력

 

querySelector

querySelector 메서드는 제공된 CSS 선택자에 매칭되는 첫 번째 요소를 반환하며 더 유연하게 요소를 선택할 수 있다.

const element = document.querySelector('.myClass');
console.log(element); // 해당 클래스를 가진 첫 번째 요소를 출력

const anotherElement = document.querySelector('#myElement');
console.log(anotherElement); // 해당 ID를 가진 요소를 출력

 

요소 조작

선택한 요소의 콘텐츠와 스타일을 변경할 수 있다. 

getElementById나 querySelector는 요소를 선택하는 방법에만 차이가 있을 뿐 선택한 요소는 동일한 프로퍼티를 통해 조작할 수 있다.

 

innerHTML 

innerHTML 프로퍼티는 요소의 HTML 콘텐츠를 설정하거나 가져온다. 요소 내부의 HTML 구조를 동적으로 변경할 수 있다.

const element = document.getElementById('myElement');
element.innerHTML = '<p>새로운 콘텐츠</p>';

 

style

style 프로퍼티는 인라인 스타일을 설정한다. 특정 요소의 CSS 스타일을 직접 변경할 때 유용하다.

const element = document.getElementById('myElement');
element.innerHTML = '<p>새로운 콘텐츠</p>';

 

classList

classList 프로퍼티는 요소의 클래스 목록을 조작하는 메서드를 제공한다. 이를 통해 클래스를 추가, 제거, 토글 할 수 있다.

const element = document.getElementById('myElement');
element.classList.add('newClass');
element.classList.remove('oldClass');
element.classList.toggle('activeClass');

 

이벤트 처리

DOM 요소에 이벤트를 처리하기 위해서는 addEventListener 메서드를 사용한다. 

const button = document.getElementById('myButton');
button.addEventListener('click', function() {
    alert('버튼이 클릭되었습니다!');
});

 

HTML 예제

간단한 HTML을 작성하고 요소를 가져와서 조작해 본다.

 

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Element Selection Example</title>
    <style>
        .highlight {
            background-color: yellow;
            color: red;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <div id="content">
        <h1 id="header">Hello!</h1>
        <p class="paragraph">This is a paragraph.</p>
    </div>
    <button id="changeContent">Change Content</button>
    <button id="changeStyle">Change Style</button>
    <button id="toggleClass">Toggle Class</button>
    <script src="script.js"></script>
</body>
</html>

 

script.js

// 요소 선택
const header = document.getElementById('header');
const paragraph = document.querySelector('.paragraph'); // 클래스 선택자를 사용
const changeContentButton = document.getElementById('changeContent');
const changeStyleButton = document.getElementById('changeStyle');
const toggleClassButton = document.getElementById('toggleClass');

// 콘텐츠 변경
changeContentButton.addEventListener('click', function() {
    header.innerHTML = 'Content has been changed!';
    paragraph.innerHTML = 'The paragraph content has been changed!';
});

// 스타일 변경
changeStyleButton.addEventListener('click', function() {
    header.style.color = 'blue';
    paragraph.style.backgroundColor = 'lightgray';
    paragraph.style.padding = '10px';
});

// 클래스 토글
toggleClassButton.addEventListener('click', function() {
    paragraph.classList.toggle('highlight');
});

 

페이지 상태

HTML

 

 

Change Content 버튼을 클릭 시

OnClick Change Content Button

 

Change Style 버튼 클릭 시

OnClick Change Style

 

Toggle Class 버튼 클릭 시

Onclick Toggle Class

 

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #15 비동기 자바스크립트  (0) 2024.07.23
JavaScript #14 ES6+ 문법  (4) 2024.07.23
JavaScript #11 함수  (0) 2024.07.23
JavaScript #10 조건문과 반복문  (1) 2024.07.23
JavaScript #9 데이터 타입  (9) 2024.07.22

객체 (Object)

객체는 자바스크립트에서 데이터를 구조화하고 저장하는 방식 중 하나로 키와 값 쌍의 집합으로 구성된다. 이 키-값 쌍을 통해서 다양한 테이터와 기능을 하나의 단위로 묶어 관리할 수 있다.

 

특징

키-값

키는 문자열 또는 심볼이어야 하며 값은 어떠한 데이터 타입도 가능하다. 만약 키에 숫자를 입력할 경우 자동으로 문자로 변환된다.

 

중첩 가능

객체의 값으로 또 다른 객체를 가질 수 있다. 이를 통해 복잡한 데이터 구조를 표현하는 것이 가능하다.

 

동적 속성 추가/제거

객체는 생성된 이후에도 속성을 동적으로 추가하거나 삭제할 수 있다.

 

생성 방법

1. 객체 리터럴

가장 일반적인 객체 생성 방법으로 중괄호를 사용하여 키-값 쌍을 정의한다.

const person = {
    name: 'Bak',
    age: 25,
    greet: function() {
        console.log('Hello, my name is ' + this.name);
    }
};

 

2. 객체 생성자

new Object() 구문을 사용하여 객체를 생성할 수 있다. 이후 점 표기법 또는 대괄호 표기법을 사용하여 속성을 추가한다.

const person = new Object();
person.name = 'Bak';
person.age = 25;
person.greet = function() {
    console.log('Hello, my name is ' + this.name);
};

 

3. 생성자 함수

특정 구조를 가진 객체를 반복해서 생성할 때 유용하다.

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.greet = function() {
        console.log('Hello, my name is ' + this.name);
    };
}

const alice = new Person('Bak', 25);

 

4. 클래스(ES6 이후)

클래스를 사용하면 객체 지향 프로그래밍의 패턴을 쉽게 구현할 수 있다.

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    greet() {
        console.log('Hello, my name is ' + this.name);
    }
}

const alice = new Person('Alice', 25);

 

객체 사용법 

const game = {
    company: 'Bethesda',
    title: 'Fallout',
    year: 1997
};

// 속성 접근
console.log(game.company); // 'Bethesda'
console.log(game['title']); // 'Fallout'

// 속성 수정
game.year = 2008;
console.log(game.year); // 2008

// 속성 추가
game.series = 'Fallout : New Vegas';
console.log(game.series); // 'Fallout : New Vegas'

// 속성 삭제
delete company.title;
console.log(company.title); // undefined

 

배열 (Array)

배열은 자바스크립트에서 여러 개의 데이터를 순차적으로 저장할 수 있는 자료구조이다. 동일한 타입 또는 서로 다른 타입의 데이터를 모두 저장할 수 있으며 각 데이터는 인덱스로 접근할 수 있다.

 

특징

인덱스 기반

배열의 각 요소는 0부터 시작하는 인덱스를 통해 접근할 수 있다.

 

동적 크기

자바스크립트의 배열은 동적 크기를 가지며, 요소를 추가하거나 제거할 수 있다.

 

다양한 데이터 타입

배열의 요소는 숫자, 문자열, 객체, 다른 배열 등 어떤 데이터 타입도 될 수 있다.

 

배열 생성 방법

1. 배열 리터럴 

가장 일반적인 배열 생성 방법으로 대괄호를 사용하여 배열 요소를 정의한다.

const numbers = [1, 2, 3, 4, 5];
const mixedArray = [1, 'two', {three: 3}, [4, 5]];

 

2. 배열 생성자

new Array() 구문을 사용하여 배열을 생성할 수 있다.

const numbers = new Array(1, 2, 3, 4, 5);
const emptyArray = new Array(10); // 길이가 10인 빈 배열 생성

 

배열 사용법

const fruits = ['apple', 'banana', 'cherry'];

// 요소 접근
console.log(fruits[0]); // 'apple'
console.log(fruits[1]); // 'banana'

// 요소 수정
fruits[1] = 'blueberry';
console.log(fruits[1]); // 'blueberry'

 

인덱스로 배열의 요소에 접근하여 사용할 수 있다.

 

 

배열 메서드

자바스크립트 배열은 다양한 메서드를 통해 요소를 추가, 제거, 탐색, 변형할 수 있다.

 

1. push

push 메서드는 배열의 끝에 하나 이상의 요소를 추가하고 배열의 새로운 길이를 반환한다.

const fruits = ['apple', 'banana'];
let len = fruits.push('orange');
console.log(len); // 3
console.log(fruits); // ['apple', 'banana', 'orange']

.

2. pop

pop 메서드는 배열의 마지막 요소를 제거하고 그 요소를 반환한다.

const fruits = ['apple', 'banana', 'orange'];
const lastFruit = fruits.pop();
console.log(fruits); // ['apple', 'banana']
console.log(lastFruit); // 'orange'

 

push & pop 사용 예제

const fruits = ['apple', 'banana'];

// push: 배열 끝에 요소 추가
fruits.push('cherry');
console.log(fruits); // ['apple', 'banana', 'cherry']

// pop: 배열 끝의 요소 제거
const lastFruit = fruits.pop();
console.log(fruits); // ['apple', 'banana']
console.log(lastFruit); // 'cherry'

 

3. map

map 메서드는 배열 내의 모든 요소에 대해 제공된 함수를 호출한 결과로 새로운 배열을 생성한다.

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8, 10]
const numbers = [1, 2, 3, 4, 5];
const squared = numbers.map(num => num * num);
console.log(squared); // [1, 4, 9, 16, 25]

 

4. filter

filter 메서드는 주어진 함수의 테스트를 통과하는 모든 요소를 모아 새로운 배열로 반환한다.

const numbers = [1, 2, 3, 4, 5];
const evens = numbers.filter(num => num % 2 === 0);
console.log(evens); // [2, 4]

 

5. reduce

reduce 메서드는 배열의 각 요소에 대해 주어진 reducer 함수를 실행하여 단일 값을 반환한다.

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // 15

 

reduce는 배열의 각 요소를 순회하며, 콜백 함수의 결과를 누산 하여 단일 값을 생성한다. 여기서 

(acc, curr) => acc + curr는 콜백함수로 두 개의 주요 인수를 받는다.

 

acc : 이전 콜백에서 반환된 값으로 이전 인덱스까지 누산 된 값

curr : 현재 순회 중인 인덱스의 요소

 

(콜백함수), 0 : 0이 초기값으로 이 값을 시작으로 요소의 값들이 누산 되기 시작한다.

 

공식 문법은 다음과 같다.

arr.reduce(callback(accumulator, currentValue, currentIndex, array), initialValue)

 

실제 필요한 인수들이 다양한 방식으로 표기가 가능한데 그 이유는 자바스크립트의 함수 인수 처리 방식 때문이다.

 

자바스크립트에서는 함수가 호출될 때 정의된 인수보다 더 많은 인수가 전달되면 무식하고, 더 적은 인수가 전달되면 undefined로 처리한다.

 

따라서 reduce 메서드에서 필요한 인수만이 알아서 사용된다.

 

따라서 생략형 콜백에서는 첫 번째와 두 번째 인수만 사용하며 두 값을 합한 결과만 리턴하기로 한다.

 

이 과정이 반복되면서 전체 요소의 합산이 되는 것이다.

 

모든 인수를 적용해서 호출하면 다음과 같다.

const numbers = [1, 2, 3, 4, 5];

const sum = numbers.reduce((accumulator, currentValue, currentIndex, array) => {
    console.log('Accumulator:', accumulator);
    console.log('Current Value:', currentValue);
    console.log('Current Index:', currentIndex);
    console.log('Array:', array);
    return accumulator + currentValue;
}, 0);

console.log('Sum:', sum); // Sum: 15

 

인수 (accumulator, currentValue, currentIndex, array) => {콜백 함수} : 요소의 누산 값을 반환

auccumulator : 누산값

currentVlaue : 현재 요소값

currnetIndex : 현재 인덱스

array : 참조 배열

 

 

 

728x90
반응형

함수

함수는 자바스크립트에서 재사용 가능한 코드 블록이자 일종의 객체이다. 따라서 속성도 가질 수 있으며 그 속성의 값이 변수라면 property, 함수라면  method가 된다.

 

함수는 선언, 호출, 매개변수, 반환값으로 구성된다.

 

함수 선언

// 선언
function greet(name) { // name : 매개변수
    return `Hello, ${name}!`; // 반환값
}
console.log(greet('Alice')); // "Hello, Alice!" // 호출

 

함수 표현식

함수 선언과 달리 변수에 할당되는 방식으로 정의되는 함수이다.

let greet = function(name) {
    return `Hello, ${name}!`;
};
console.log(greet('Bob')); // "Hello, Bob!"

 

let greet : let 변수로 greet라는 이름의 변수를 선언한다.

function(name)  : 매개변수 name을 받는 함수를 정의한다.

{ return ~ } : 함수의 본문으로 'Hello, ${name}!'을 반환한다. 템플릿 리터럴을 사용하여 매개변수 name의 값을 포함한 문자열로 반환한다.

 

화살표 함수

ES6부터 도입된 것으로 함수를 간결하게 표현하는 문법이다.

let greet = (name) => `Hello, ${name}!`;
console.log(greet('Charlie')); // "Hello, Charlie!"

 

함수 키워드와 이름이 생략되고 전달받을 매개변수만 괄호 안에 표기한다.

함수의 본문을 작성하는 중괄호와 반환 키워드가 생략되고 본문을 바로 표기할 수 있다.

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #14 ES6+ 문법  (4) 2024.07.23
JavaScript #13 DOM(Document Object Model)  (0) 2024.07.23
JavaScript #10 조건문과 반복문  (1) 2024.07.23
JavaScript #9 데이터 타입  (9) 2024.07.22
JavaScript #8 클로저(Closure)  (0) 2024.07.22

조건문 (Conditional Statements)

조건문은 특정 조건에 따라 코드 블록을 실행하거나 건너뛰는 방식으로 동작한다.

 

if, else if, else 

let x = 10;

if (x > 5) {
    console.log("x는 5보다 크다.");
} else if (x === 5) {
    console.log("x는 5이다.");
} else {
    console.log("x는 5보다 작다.");
}

 

switch

하나의 변수를 다양한 값과 비교하여 코드 블록을 실행한다.

let day = 3;
let dayName;

switch (day) {
    case 0:
        dayName = 'Sunday';
        break;
    case 1:
        dayName = 'Monday';
        break;
    case 2:
        dayName = 'Tuesday';
        break;
    case 3:
        dayName = 'Wednesday';
        break;
    case 4:
        dayName = 'Thursday';
        break;
    case 5:
        dayName = 'Friday';
        break;
    case 6:
        dayName = 'Saturday';
        break;
    default:
        dayName = 'Invalid day';
}

console.log(dayName); // "Wednesday"

 

break는 해당 조건에 해당하면 더 이상 다음 조건을 확인하지 않고 조건문을 종료시키는 기능을 한다.

case는 순서대로 모든 케이스를 확인하기 때문에 break가 없다면 swich의 모든 조건을 확인한다.

반복문 (Loops)

반복문은 특정 코드 블록을 여러 번 실행하는 데 사용된다. 

 

for

일반적인 반복문이다.

for (let i = 0; i < 5; i++) {
    console.log(i); // 0, 1, 2, 3, 4
}

 

 

while

조건이 참인 동안 코드 블록을 반복한다.

let i = 0;
while (i < 5) {
    console.log(i); // 0, 1, 2, 3, 4
    i++;
}

 

do-while

코드 블록을 최소 한 번 실행하고, 그 후 조건이 참인 동안 반복한다.

let i = 0;
do {
    console.log(i); // 0, 1, 2, 3, 4
    i++;
} while (i < 5);

 

break

break는 반복문을 종료시키는 기능을 한다.

for (let i = 0; i < 10; i++) {
    if (i === 5) {
        break;
    }
    console.log(i); // 0, 1, 2, 3, 4
}

 

continue

continue 문은 현재 반복을 종료하고 다음 반복으로 넘어간다.

for (let i = 0; i < 10; i++) {
    if (i === 5) {
        continue;
    }
    console.log(i); // 0, 1, 2, 3, 4, 6, 7, 8, 9
}

 

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #13 DOM(Document Object Model)  (0) 2024.07.23
JavaScript #11 함수  (0) 2024.07.23
JavaScript #9 데이터 타입  (9) 2024.07.22
JavaScript #8 클로저(Closure)  (0) 2024.07.22
JavaScript #7 var 변수에 대해서  (0) 2024.07.22

기본 데이터 타입

숫자(Number) 

정수 및 부동 소수점 숫자를 포함한다.

let integer = 42;
let float = 3.14;

 

숫자 조작

산술 연산자를 사용해 숫자를 조작할 수 있다.

let sum = 10 + 5; // 15
let difference = 10 - 5; // 5
let product = 10 * 5; // 50
let quotient = 10 / 5; // 2
let remainder = 10 % 5; // 0

 

문자열(String)

텍스트 데이터를 나타낸다.

let singleQuoteString = 'Hello, world!';
let doubleQuoteString = "Hello, world!";
let templateString = `Hello, ${name}!`;

 

문자열 조작

연결 연산자를 사용해 문자열을 조작할 수 있다.

let greeting = 'Hello' + ' ' + 'world'; // "Hello world"

 

템플릿 리터럴

let name = 'Alice';
let message = `Hello, ${name}!`; // "Hello, Alice!"

 

불리언(Boolean)

참 또는 거짓 값을 가진다.

let isTrue = true;
let isFalse = false;

 

값과 조건 판단

let isAdult = true;
if (isAdult) {
    console.log('You are an adult.');
} else {
    console.log('You are not an adult.');
}

 

null

값이 비어 있음을 나타낸다.

let emptyValue = null;

 

undefiend

값이 정의되지 않았음을 나타낸다.

let undefinedValue;

 

null과 undefined의 차이

null : 명시적으로 값이 없음을 나타내기 위해 사용된다.

undefined : 변수가 선언되었지만 값이 할당되지 않았을 때의 초기 상태를 나타낸다.

 

let a = null;
let b;

console.log(a); // null
console.log(b); // undefined

 

객체(Object)

키-밸류 쌍의 집합, 배열도 객체의 일종이다.

let person = {
    name: 'John',
    age: 30
};
let array = [1, 2, 3];

 

객체와 배열의 초기화 및 조작

객체 초기화

let car = {
    make: 'Toyota',
    model: 'Camry',
    year: 2020
};

 

배열 초기화

let numbers = [1, 2, 3, 4, 5];

 

객체 속성 접근 및 조작

console.log(car.make); // "Toyota"
car.year = 2021;
console.log(car.year); // 2021

 

데이터 타입 확인

typeof 연산자를 사용하여 데이터 타입을 확인할 수 있다.

console.log(typeof 42); // "number"
console.log(typeof 'Hello'); // "string"
console.log(typeof true); // "boolean"
console.log(typeof null); // "object" (자바스크립트의 역사적 이유로)
console.log(typeof undefined); // "undefined"
console.log(typeof {name: 'John'}); // "object"

 

데이터 타입 간의 변환

자바스크립트에서는 데이터 타입 간의 변환이 자주 발생한다. 이를 명시적 변환과 암시적 변환으로 나눌 수 있다.

 

명시적 변환(Explicit Conversion)

숫자로 변환 

Number(), parseInt(), parseFloat()

let str = "123";
let num = Number(str); // 123
let int = parseInt("123.45"); // 123
let float = parseFloat("123.45"); // 123.45

 

문자열로 변환

String()

let num = 123;
let str = String(num); // "123"

 

불리언으로 변환

Boolean()

let str = "";
let bool = Boolean(str); // false

 

암시적 변환(Implicit Conversion)

숫자와 문자열의 연산에서 발생

let result = 123 + "456"; // "123456" (숫자가 문자열로 변환됨)

 

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #11 함수  (0) 2024.07.23
JavaScript #10 조건문과 반복문  (1) 2024.07.23
JavaScript #8 클로저(Closure)  (0) 2024.07.22
JavaScript #7 var 변수에 대해서  (0) 2024.07.22
JavaScript #6 호이스팅(Hoisting)  (0) 2024.07.21

클로저

클로저는 자바스크립트의 중요한 개념 중 하나로 함수와 그 함수가 선언된 렉시컬 환경(Lexical Environment)의 조합을 의미한다. 클로저는 함수가 선언될 때 그 함수의 스코프에 있는 변수들을 기억하고, 함수가 호출될 때에도 그 변수를 참조할 수 있게 한다.

 

렉시컬 환경(Lexical Environment)

자바스크립트의 실행 컨텍스트에서 변수와 함수 선언의 스코프를 관리하는 내부 구조를 의미한다. 렉시컬 환경은 코드가 작성된 위치에 따라 스코프를 결정하는데, 이는 코드가 실행될 때가 아니라 작성될 때의 구조에 따라 스코프가 결정된다는 점이 중요하다.

 

렉시컬 환경의 구성 요소

렉시컬 환경은 두 가지 구성 요소로 이루어져 있다.

 

1. 환경 레코드(Environment Record)

현재 스코프에서 정의된 모든 변수와 함수 선언을 저장한다.

 

2. 외부 렉시컬 환경 참조(Outer Lexical Environment Reference)

외부 스코프에 대한 참조를 가진다. 이는 중첩된 함수에 내부 함수가 외부 함수의 변수에 접근할 수 있게 한다.

 

렉시컬 환경의 동작

function outerFunction() {
  let outerVariable = "I am an outer variable";

  function innerFunction() {
    let innerVariable = "I am an inner variable";
    console.log(outerVariable); // "I am an outer variable"
    console.log(innerVariable); // "I am an inner variable"
  }

  return innerFunction;
}

const closureFunction = outerFunction();
closureFunction();

 

outerFunction 실행 시

환경 레코드 : { outerVariable: "I am an outer variable" }

외부 렉시컬 환경 참조 : 전역 환경

 

innerFunction 실행 시

환경 레코드 : { innerVariable : "I am an inner variable" }

외부 렉시컬 환경 참조 : outerFunction의 렉시컬 환경

 

렉시컬 환경의 예제

let globalVariable = "I am a global variable";

function exampleFunction() {
  let localVariable = "I am a local variable";

  function innerFunction() {
    console.log(globalVariable); // "I am a global variable"
    console.log(localVariable); // "I am a local variable"
  }

  innerFunction();
}

exampleFunction();

 

전역 렉시컬 환경

환경 레코드 : { globalVariable : "I am a global variable" }

외부 렉시컬 환경 참조 : 없음

 

exampleFunction 실행 시 

환경 레코드 : { localVariable : "I am a local variable" }

외부 렉시컬 환경 참조 : 전역 환경

 

innerFunction 실행 시 

환경 레코드 : 비어 있음 (현재 함수에서 변수를 선언하지 않음)

외부 렉시컬 환경 참조 : exampleFunction의 렉시컬 환경

 

렉시컬 환경은 자바스크립트의 변수와 함수 스코프를 관리하는 내부 구조로 코드가 작성된 위치에 따라 스코프가 결정된다. 렉시컬 환경은 환경 레코드와 외부 렉시컬 환경 참조로 구성되어 있으며 이를 통해 함수가 선언된 위치의 변수에 접근할 수 있다. 클로저는 이러한 렉시컬 환경을 활용하여 함수가 실행된 이후에도 외부 변수에 접근할 수 있게 하는 개념이다.

 

 

클로저의 동작 원리

클로저는 함수가 정의된 시점의 외부 스코프의 변수에 접근할 수 있는 기능을 제공하는 함수이다. 

즉, 클로저는 함수가 생성될 때 외부 환경의 변수를 캡처하여 함수가 실행될 때에도 그 변수에 접근할 수 있게 한다.

 

자바스크립트에서 함수는 선언될 때마다 자신이 선언된 환경을 기억한다. 이 환경은 함수가 생성된 시점의 스코프와 변수를 포함하며 클로저는 함수가 실행된 이후에도 해당 환경을 유지하므로, 함수가 반환된 이후에도 그 환경에 접근할 수 있다.

 

function outerFunction() {
  let outerVariable = "I am an outer variable";

  function innerFunction() {
    console.log(outerVariable); // "I am an outer variable"
  }

  return innerFunction;
}

const closureFunction = outerFunction();
closureFunction(); // "I am an outer variable"

 

innerFunction은 outerFunction 내부에서 선언되었으며 outerFunction의 스코프에 접근할 수 있다. outerFunction이 반환된 이후에도 innerFunction은 outerVariable에 접근할 수 있으며 이 경우 innerFunction은 클로저를 형성한다.

 

클로저의 주요 특징

함수가 생성될 때의 스코프를 기억

함수가 정의된 위치의 외부 변수를 기억하고, 함수가 호출될 때 해당 변수에 접근할 수 있다.

 

은닉화(Encapsulation)

클로저를 사용하여 함수 외부에서 접근할 수 없는 프라이빗 변수를 만들 수 있다.

 

고차 함수

클로저는 함수를 반환하거나 함수의 인수로 함수를 받을 수 있는 '고차 함수'와 함께 자주 사용된다.

 

프라이빗 변수(Private Variable)

변수를 캡슐화하여 외부에서 변수에 직접 접근할 수 없도록 만드는 패턴이다.

예제 1)

function createCounter() {
  let count = 0;

  return {
    increment: function() {
      count++;
      console.log(count);
    },
    decrement: function() {
      count--;
      console.log(count);
    },
    getCount: function() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment(); // 1
counter.increment(); // 2
counter.decrement(); // 1
console.log(counter.getCount()); // 1

 

count 변수는 createCounter 함수 내에 선언되어 있으며, createCounter 함수 외부에서도 직접 접근할 수 없으며, increment, decrement, getCount 메서드만이 count 변수에 접근할 수 있다.

 

예제 2)

function factory_game(title) {
  return
   {
   
    get_title : function () {
      return title;
    },
    
    set_title : function(_title) {
      title = _title 
    }
  }
}


factorty_game 함수는 내부에 get_title, set_title 두 개의 내부 함수를 가지고 있다.


외부함수의 인수 title은 함수 안에서 지역변수로 사용되며 첫 번째 속성인 get_title 메서드가 반환하는 title은 인수의 값이 된다.

 

set_title은 매개변수로 _title을 가지며 이 매개변수를 가지고 title = _title로 저장하여 외부함수의 인수가 title이 된다.

 

elder_scroll = factory_movie('The Elder Scrolls V: Skyrim');
fallout = factory_movie('Fallout: New Vegas');

console.log(elder_scroll.get_title());
// 'The Elder Scrolls V: Skyrim' 출력
console.log(fallout.get_title());
// 'Fallout: New Vegas' 출력

 

 

부분 적용 함수(Partial Application)

클로저를 사용하여 함수의 일부 인수를 고정한 새로운 함수를 생성할 수 있으며, 이는 함수의 재사용성을 높이고, 코드의 간결성을 유지하는 데 유용하다.

 

function multiply(a) {
  return function(b) {
    return a * b;
  };
}

const double = multiply(2);
console.log(double(5)); // 10

const triple = multiply(3);
console.log(triple(5)); // 15

 

주의사항

메모리 관리

클로저는 함수가 참조하는 변수들을 계속 유지하므로, 과도하게 사용하면 메모리 누수가 발생할 수 있다. 불필요한 클로저 사용을 피하고 필요하지 않은 참조는 명시적으로 제거하는 것이 좋다.

 

성능

클로저를 사용할 때는 성능에 주의가 필요하다. 특히 큰 데이터 구조를 포함하는 클로저는 메모리 사용량을 증가시킬 수 있다.

 

중첩 함수와 클로저

function makeCounter() {
  let count = 0;

  return function() {
    count++;
    return count;
  };
}

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

 

위 렉시컬 환경은 다음과 같이 동작한다.

 

makeCounter 실행 시

환경 레코드 : { count : 0 }

외부 렉시컬 환경 참조 : 전역 환경

 

반환된 함수(클로저) 실행 시

환경 레코드 : 비어 있음

외부 렉시컬 환경 참조 : makeCounter의 렉시컬 환경 

 


 

클로저는 자바스크립트의 강력한 기능 중 하나로 함수가 선언된 렉시컬 환경을 기억하고, 함수가 호출될 때에도 그 환경에 접근할 수 있게 한다. 이를 통해 변수 은닉화, 부분 적용 함수, 콜백 함수 등 다양한 활용이 가능하다.

 

클로저의 주의사항을 유념하여 적절히 사용하면 코드의 재사용성과 유지보성을 높일 수 있다.

728x90
반응형

var

앞에서 정리한 내용을 바탕으로 생각해 보면 var 변수보다는 let, const 변수를 사용하는 것이 의도치 않은 문제가 발생할 경우를 줄일 수 있을 것으로 보인다.

 

그럼에도 var 변수는 왜 존재하고 사용되는지 정리한다.

 

역사적 이유

자바스크립트의 초기 버전에는 let, const 키워드가 없었고 var 만이 유일하게 변수를 선언하는 방법이였다.

 

이후에 let, const 가 도입되면서 변수 선언에 더 나은 방법이 제공되었지만 기존의 코드를 유지보수하거나 과거의 자바스크립트 버전과 호환성을 유지하기 위해 여전히 var가 사용되는 경우가 있다.

 

레거시 코드

많은 기존의 자바스크립트 코드베이스가 var를 사용하여 작성되었다. 이 코드를 유지보수하거나 확장할 때 기존의 스타일을 유지하기 위해 var를 계속 사용하기도 한다.

 

또한 오래된 자바스크립트 엔진이나 환경에서는 let, cosnt를 지원하지 않을 수 있기 때문에 그런 환경에서 코드를 실행하기 위해서는 var를 사용할 수밖에 없다.

 

호환성

모든 자바스크립트 환경에서 var는 지원되기 때문에 가장 광범위한 호환성을 보장할 수 있다. 예로 들어서 아주 오래된 브라우저나 자바스크립트 엔진에서도 var를 사용할 수 있다.

 

정리

기존의 코드베이스의 작업이나 아주 오래된 엔진 환경에서 실행을 하기 위함이라면 var를 사용하는 건 어쩔 수 없는 선택이지만 최신 자바스크립트 코드 작성 시에는 가능하면 var보다는 let이나 const를 사용하는 것이 안정성과 예측가능성을 높이기 때문에 권장된다.

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #9 데이터 타입  (9) 2024.07.22
JavaScript #8 클로저(Closure)  (0) 2024.07.22
JavaScript #6 호이스팅(Hoisting)  (0) 2024.07.21
JavaScript #5 유효 범위, 스코프(Scope)  (0) 2024.07.21
JavaScript #4 변수  (1) 2024.07.21

호이스팅

변수나 함수 선언들이 포함된 범위 상단으로 끌어올려지는 동작을 말한다.

이는 코드의 실제 실행 순서와는 다르게 해석되어 변수와 함수의 선언만 끌어올려지고 초기화는 끌어올려지지 않는다는 점에서 의미를 가진다.

 

변수 호이스팅

변수의 선언은 호이스팅 되지만, 변수 초기화는 호이스팅 되지 않는다. 이는 변수 선언이 코드의 최상단으로 이동된 것처럼 동작하지만 초기화는 원래 위치에 남아 있음을 의미한다.

 

실제 코드

console.log(a); // undefined
var a = 10;
console.log(a); // 10

 

자바스크립트 엔진에 의해 해석된 코드

var a;
console.log(a); // undefined
a = 10;
console.log(a); // 10

 

a 변수의 선언만 끌어올려지고 초기화는 원래 위치에 남아있게 된다.

 

let, const 키워드의 경우 선언된 변수는 호이스팅 되지만 var와 달리 초기화 전에 해당 변수에 접근하면 '일시적 사각지대(TDZ, Temporal Dead Zone)'으로 인해서 ReferenceError가 발생한다. 

 

함수 호이스팅

함수 선언은 변수 선언과 다르게, 함수의 정의 전체가 호이스팅 된다. 이는 함수가 코드에서 선언된 위치와 상관없이 호출될 수 있음을 의미한다.

 

작성된 함수 코드

greet(); // "Hello, World!"

function greet() {
  console.log("Hello, World!");
}

 

실행되는 엔진의 해석

function greet() {
  console.log("Hello, World!");
}

greet(); // "Hello, World!"

 

함수 표현식 호이스팅

함수 표현식은 변수 선언과 유사하게 동작하여 함수 선언과는 다르게 함수의 정의가 호이스팅 되지 않는다.

 

함수 표현식 코드

sayHello(); // TypeError: sayHello is not a function

var sayHello = function() {
  console.log("Hello!");
};

 

실행되는 엔진의 해석

var sayHello;

sayHello(); // TypeError: sayHello is not a function

sayHello = function() {
  console.log("Hello!");
};

 

sayHello 변수의 선언만 호이스팅 되어 상단으로 간다. 초기화는 원래 위치에 남아있어 sayHello가 함수로 초기화되기 전에 호출하기 때문에 TypeError가 발생한다.

 

호이스팅 동작 원리

자바스크립트의 실행 콘텍스트가 생성되는 과정에서 발생한다. 

1. 생성 단계 : 변수와 함수 선언이 메모리에 저장되고 변수는 undefined로 초기화된다.

2. 실행 단계 : 코드를 순차적으로 실행하면서 변수에 값이 할당되고, 함수호출이 이루어진다.

 

작성된 코드

console.log(a); // undefined
foo();          // "foo called"
console.log(bar); // undefined
// bar(); // TypeError: bar is not a function

var a = 10;

function foo() {
  console.log("foo called");
}

var bar = function() {
  console.log("bar called");
};

console.log(a);  // 10
foo();           // "foo called"
bar();           // "bar called"

 

실행되는 엔진의 해석

 

var a;
var bar;

function foo() {
  console.log("foo called");
}

console.log(a);  // undefined
foo();           // "foo called"
console.log(bar); // undefined
// bar(); // TypeError: bar is not a function

a = 10;
bar = function() {
  console.log("bar called");
};

console.log(a);  // 10
foo();           // "foo called"
bar();           // "bar called"

 

따라서 의도하지 않은 문제가 발생하는 것을 막기 위해서는 호이스팅이 동작하는 방식에 대한 이해가 반드시 필요하다. 

 

호이스팅으로 인한 문제를 예방하기 위해서 let, const 변수를 사용하는 것이 권장되는 방식이며 var 사용 시 코드의 순서에 유의할 필요가 있다.

728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #8 클로저(Closure)  (0) 2024.07.22
JavaScript #7 var 변수에 대해서  (0) 2024.07.22
JavaScript #5 유효 범위, 스코프(Scope)  (0) 2024.07.21
JavaScript #4 변수  (1) 2024.07.21
JavaScript #3 연산자  (1) 2024.07.21

스코프는 변수나 함수가 유효한 범위를 정의한다.

함수 스코프

함수 내부에서 선언된 변수의 유효 범위를 의미한다. 

var 키워드로 선언된 변수는 함수 스코프를 가진다는 의미는 변수가 함수 내 어디서든 접근 가능하지만 함수 외부에서 접근할 수 없음을 의미한다.

 

function Func() {
  var funcScopeVar = "I am inside a function";
  console.log(funcScopeVar); // "I am inside a function"
}

Func();
// console.log(funcScopeVar); // ReferenceError: functionScopedVariable is not defined

 

Func 함수 내에서 선언된 var 변수 funcScopeVar는 함수 내부에서만 접근이 유효하고 함수 외부에서 접근할 때는 ReferenceError가 발생한다.

 

블록 스코프

블록 스코프는 중괄호 {}로 묶인 코드 블록 내부에서 선언된 변수의 유효 범위를 의미한다.

let과 const 키워드로 선언된 변수는 블록 스코프를 가진다. 이는 변수가 블록 내부에서만 접근 가능하며 블록 외부에서는 접근할 수 없음을 의미한다.

 

if (true) {
  let blockScopedVariable = "I am inside a block";
  const anotherBlockScopedVariable = "I am also inside a block";
  console.log(blockScopedVariable);   // "I am inside a block"
  console.log(anotherBlockScopedVariable); // "I am also inside a block"
}

// console.log(blockScopedVariable);   // ReferenceError: blockScopedVariable is not defined
// console.log(anotherBlockScopedVariable); // ReferenceError: anotherBlockScopedVariable is not defined

 

조건문의 중괄호 내에서 선언된 let과 const 변수들은 내부에서만 유효하며 블록 외부인 중괄호 바깥에서 접근 시 ReferenceError가 발생한다.

 

var의 경우 조건문의 중괄호 내에서 선언되어도 외부에서 접근이 유요하다.

if (true) {
  var variable = "I am a var variable";
}

console.log(variable); // "I am a var variable"

 

호이스팅

var, let, const로 선언된 변수는 모두 호이스팅 되지만 let, const로 선언된 변수는 TDZ로 인해 초기화 전에 접근이 불가능하게 된다.

 

 

전역 스코프

변수를 전역 스코프에서 선언할 때 각 키워드의 동작에는 차이가 있다. 

전역 스코프에서 변수의 선언은 코드 전체에서 접근 가능한 범위를 의미하며 변수 선언 방식에 따라 전역 객체에 미치는 영향이 다르게 된다.

 

var

전역 변수로 선언된 var 변수는 전역 객체의 속성이 되며 같은 이름의 변수를 여러 번 선언할 수 있다.

var globalVar = "I am a global var";
console.log(window.globalVar); // "I am a global var"

var globalVar = "I am a redefined global var";
console.log(window.globalVar); // "I am a redefined global var"

 

같은 이름의 변수를 여러 번 선언이 가능하다는 점은 코드가 복잡해질수록 중복된 이름을 사용하여 의도하지 않게 값을 변경하는 등의 문제를 발생시킬 수 있다.

 

또한 전역 객체의 속성이 되기 때문에 전역 네임스페이스 오염을 발생시켜 다른 스크립트나 라이브러리와 충돌할 위험이 있다.

 

var globalVar = "I am global";
console.log(window.globalVar); // "I am global"

 

let, const

let, const로 선언된 전역 변수는 전역 객체의 속성이 되지 않으며 같은 이름의 변수를 같은 스코프에서 두 번 선언할 수 없다.

 

여기서 같은 스코프란 전역 스코프로 다른 함수, 블록 스코프에서는 해당 이름을 사용할 수 있다. 이 경우 해당 스코프 내에서 선언된 변수로만 접근이 가능해지므로 전역에 존재하는 동일한 이름의 다른 변수는 접근할 수 없다.

 

let globalLet = "I am a global let";

function func() {
  let globalLet = "I am a local let";
  console.log(globalLet); // "I am a local let"
}

func();
console.log(globalLet); // "I am a global let"
728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #7 var 변수에 대해서  (0) 2024.07.22
JavaScript #6 호이스팅(Hoisting)  (0) 2024.07.21
JavaScript #4 변수  (1) 2024.07.21
JavaScript #3 연산자  (1) 2024.07.21
JavaScript #2 표현식  (0) 2024.07.21

변수

자바스크립트에서 변수를 선언할 때 사용하는 키워드에는 var, let, const가 있다.

각 키워드는 변수의 스코프와 재할당 가능성, 호이스팅 방식에서 차이가 있다.

 

var

함수 스코프

var로 선언된 변수는 함수 스코프를 가지며 함수 내에서 선언된 변수는 함수 전체에서 접근할 수 있다.

 

호이스팅

var로 선언된 변수는 호이스팅 되며 선언이 코드의 최상단으로 끌어올려지고 초기화는 선언한 위치에서 이루어진다.

 

변수 재선언 가능

같은 스코프 내에서 여러 번 선언할 수 있다. 이때 이전 값은 덮어씌워지게 된다.

 

전역 객체에 속성으로 추가

전역 스코프에서 선언된 var변수는 전역 객체의 속성이 된다. (global 또는 window)

 

console.log(x); // undefined (호이스팅)
var x = 5;
console.log(x); // 5

if (true) {
  var y = 10;
}
console.log(y); // 10 (블록 스코프가 아님)

function foo() {
  var z = 20;
  console.log(z); // 20
}
foo();
// console.log(z); // ReferenceError: z is not defined (함수 스코프)

 

let 

블록스코프

let으로 선언된 변수는 블록 스코프를 가지고 블록 내에서만 접근할 수 있다.

 

호이스팅

let으로 선언된 변수는 호이스팅 되지만 선언하기 전에는 사용할 수 없으며 이를 '일시적 사각지대(TDZ, Temporal Dead Zone)'이라고 한다.

 

변수 재선언 불가

같은 스코프 내에서 두 번 선언할 수 없다.

// console.log(a); // ReferenceError: Cannot access 'a' before initialization (TDZ)
let a = 5;
console.log(a); // 5

if (true) {
  let b = 10;
  console.log(b); // 10
}
// console.log(b); // ReferenceError: b is not defined (블록 스코프)

let c = 15;
// let c = 20; // SyntaxError: Identifier 'c' has already been declared (재선언 불가)

 

const

블록스코프

const로 선언된 변수는 블록 스코프를 가진다.

 

호이스팅

const로 선언된 변수는 호이스팅 되지만, 선언하기 전에는 사용할 수 없다. TDZ에 영향을 받는다.

 

변수 재선언 불가

같은 스코프 내에서 두 번 선언할 수 없다.

 

상수

const로 선언된 변수는 초기화 후에 값을 변경할 수 없지만 객체나 배열의 속성은 변경할 수 있다.

 

// console.log(d); // ReferenceError: Cannot access 'd' before initialization (TDZ)
const d = 5;
console.log(d); // 5

if (true) {
  const e = 10;
  console.log(e); // 10
}
// console.log(e); // ReferenceError: e is not defined (블록 스코프)

const f = 15;
// const f = 20; // SyntaxError: Identifier 'f' has already been declared (재선언 불가)

// f = 25; // TypeError: Assignment to constant variable. (값 변경 불가)

const obj = { key: "value" };
obj.key = "new value"; // 객체의 속성은 변경 가능
console.log(obj.key); // "new value"

const arr = [1, 2, 3];
arr.push(4); // 배열의 요소는 추가 가능
console.log(arr); // [1, 2, 3, 4]
728x90
반응형

'Program Language > JavaScript' 카테고리의 다른 글

JavaScript #6 호이스팅(Hoisting)  (0) 2024.07.21
JavaScript #5 유효 범위, 스코프(Scope)  (0) 2024.07.21
JavaScript #3 연산자  (1) 2024.07.21
JavaScript #2 표현식  (0) 2024.07.21
JavaScript #1 개요  (0) 2024.07.21

+ Recent posts