javascript cheatsheet

    
JavaScript 기능들을 정리한 치트시트를 제공합니다. 이 치트시트는 데이터 구조와 알고리즘을 구현하는 데 필요한 기본적인 구문과 기능을 포함하고 있습니다.

## JavaScript Coding Cheat Sheet

### 1. **기본 문법**

#### 변수 선언
```javascript
let variable = value;   // 변수 선언 (변경 가능)
const constant = value; // 상수 선언 (변경 불가)
```

#### 함수 선언
```javascript
// 함수 선언식
function functionName(params) {
  // 함수 내용
}

// 함수 표현식
const functionName = function(params) {
  // 함수 내용
};

// 화살표 함수
const functionName = (params) => {
  // 함수 내용
};
```

### 2. **기본 데이터 구조**

#### 배열 (Array)
```javascript
let arr = [1, 2, 3];

// 배열 길이
console.log(arr.length);

// 배열 요소 접근
console.log(arr[0]);

// 배열의 끝에 추가
arr.push(4);

// 배열의 끝에서 제거
arr.pop();

// 배열의 앞에 추가
arr.unshift(0);

// 배열의 앞에서 제거
arr.shift();
```

#### 객체 (Object)
```javascript
let obj = {
  key1: 'value1',
  key2: 'value2'
};

// 속성 접근
console.log(obj.key1);

// 속성 추가 또는 변경
obj.key3 = 'value3';

// 속성 제거
delete obj.key2;
```

### 3. **반복문 및 조건문**

#### 반복문
```javascript
// for 반복문
for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

// for...of 반복문 (배열)
for (let element of arr) {
  console.log(element);
}

// for...in 반복문 (객체)
for (let key in obj) {
  console.log(key, obj[key]);
}

// while 반복문
let i = 0;
while (i < arr.length) {
  console.log(arr[i]);
  i++;
}
```

#### 조건문
```javascript
if (condition) {
  // 조건이 참일 때
} else if (anotherCondition) {
  // 또 다른 조건이 참일 때
} else {
  // 조건이 거짓일 때
}

// 삼항 연산자
let result = condition ? '참' : '거짓';
```

### 4. **유용한 배열 메서드**

#### 고차 함수
```javascript
// forEach: 배열의 각 요소에 대해 실행
arr.forEach((value) => console.log(value));

// map: 배열의 각 요소에 대해 함수를 적용한 결과로 새 배열 생성
let newArr = arr.map((value) => value * 2);

// filter: 조건을 만족하는 요소로만 새 배열 생성
let filteredArr = arr.filter((value) => value > 2);

// reduce: 배열을 하나의 값으로 줄임
let sum = arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
```

### 5. **기타 유용한 기능**

#### 문자열 조작
```javascript
let str = "Hello, World!";

// 문자열 길이
console.log(str.length);

// 문자열 자르기
console.log(str.substring(0, 5));

// 문자열 분할
let arr = str.split(", ");

// 문자열 포함 여부
console.log(str.includes("World"));

// 대소문자 변환
console.log(str.toUpperCase());
console.log(str.toLowerCase());
```

#### 정렬
```javascript
let numbers = [3, 1, 4, 1, 5, 9];
numbers.sort((a, b) => a - b); // 오름차순
numbers.sort((a, b) => b - a); // 내림차순
```

#### Set (중복 없는 값의 집합)
```javascript
let set = new Set([1, 2, 3, 3]);
set.add(4);
set.delete(2);
console.log(set.has(3));
console.log(set.size);
```

#### Map (키-값 쌍의 집합)
```javascript
let map = new Map();
map.set('key1', 'value1');
map.set('key2', 'value2');
console.log(map.get('key1'));
map.delete('key2');
console.log(map.has('key2'));
console.log(map.size);
```

### 6. **비동기 프로그래밍**

#### Promise
```javascript
let promise = new Promise((resolve, reject) => {
  // 비동기 작업 수행
  if (success) resolve(result);
  else reject(error);
});

promise
  .then(result => console.log(result))
  .catch(error => console.log(error));
```

#### Async/Await
```javascript
async function asyncFunction() {
  try {
    let result = await someAsyncFunction();
    console.log(result);
  } catch (error) {
    console.log(error);
  }
}
```

### 7. **배열 조작 및 변환**

#### 배열 슬라이스 (Slice)
```javascript
let arr = [1, 2, 3, 4, 5];
let slicedArr = arr.slice(1, 3); // [2, 3]
// 원본 배열은 변경되지 않음
```

#### 배열 스플라이스 (Splice)
```javascript
let arr = [1, 2, 3, 4, 5];
let splicedArr = arr.splice(1, 2); // [2, 3]
// 원본 배열에서 해당 부분이 제거됨
// arr은 이제 [1, 4, 5]
```

#### 배열 결합 (Concat)
```javascript
let arr1 = [1, 2];
let arr2 = [3, 4];
let mergedArr = arr1.concat(arr2); // [1, 2, 3, 4]
```

#### 배열 찾기 (Find, FindIndex)
```javascript
let arr = [1, 2, 3, 4, 5];
let foundElement = arr.find(element => element > 3); // 4
let foundIndex = arr.findIndex(element => element > 3); // 3
```

#### 배열 포함 여부 검사 (Includes)
```javascript
let arr = [1, 2, 3];
console.log(arr.includes(2)); // true
console.log(arr.includes(4)); // false
```

#### 배열의 모든 요소가 조건을 만족하는지 검사 (Every)
```javascript
let arr = [1, 2, 3];
console.log(arr.every(element => element > 0)); // true
console.log(arr.every(element => element > 2)); // false
```

#### 배열 중 하나라도 조건을 만족하는지 검사 (Some)
```javascript
let arr = [1, 2, 3];
console.log(arr.some(element => element > 2)); // true
console.log(arr.some(element => element > 3)); // false
```

### 8. **문자열 조작**

#### 문자열 검색 (IndexOf, LastIndexOf)
```javascript
let str = "hello world";
console.log(str.indexOf("o")); // 4
console.log(str.lastIndexOf("o")); // 7
```

#### 문자열 대체 (Replace)
```javascript
let str = "hello world";
let newStr = str.replace("world", "JavaScript"); // "hello JavaScript"
```

#### 문자열 양 끝의 공백 제거 (Trim)
```javascript
let str = "   hello world   ";
console.log(str.trim()); // "hello world"
```

#### 부분 문자열 추출 (Substring, Substr)
```javascript
let str = "JavaScript";
console.log(str.substring(1, 4)); // "ava"
console.log(str.substr(1, 4));    // "avaS"
```

### 9. **객체 조작**

#### 객체 키, 값, 엔트리 (Keys, Values, Entries)
```javascript
let obj = { a: 1, b: 2, c: 3 };
console.log(Object.keys(obj));   // ["a", "b", "c"]
console.log(Object.values(obj)); // [1, 2, 3]
console.log(Object.entries(obj));// [["a", 1], ["b", 2], ["c", 3]]
```

#### 객체 복사 (Object Assign, Spread Operator)
```javascript
let obj1 = { a: 1, b: 2 };
let obj2 = { c: 3 };

// Object.assign
let mergedObj = Object.assign({}, obj1, obj2); // { a: 1, b: 2, c: 3 }

// Spread operator
let spreadObj = { ...obj1, ...obj2 }; // { a: 1, b: 2, c: 3 }
```

### 10. **수학 함수**

#### 기본 수학 함수
```javascript
console.log(Math.abs(-7.25)); // 7.25
console.log(Math.ceil(4.2));  // 5
console.log(Math.floor(4.7)); // 4
console.log(Math.round(4.5)); // 5
console.log(Math.max(1, 2, 3)); // 3
console.log(Math.min(1, 2, 3)); // 1
console.log(Math.pow(2, 3));    // 8
console.log(Math.sqrt(16));     // 4
```

#### 랜덤 숫자 생성
```javascript
// 0 이상 1 미만의 부동 소수점 난수
console.log(Math.random()); 

// 1부터 10까지의 정수 난수
console.log(Math.floor(Math.random() * 10) + 1);
```

### 11. **시간 및 날짜**

#### 현재 날짜와 시간
```javascript
let now = new Date();
console.log(now);

// 특정 날짜와 시간
let specificDate = new Date('2020-01-01T00:00:00Z');
console.log(specificDate);

// 날짜 정보 추출
console.log(now.getFullYear());  // 연도
console.log(now.getMonth() + 1); // 월 (0부터 시작하므로 +1)
console.log(now.getDate());      // 일
console.log(now.getHours());     // 시
console.log(now.getMinutes());   // 분
console.log(now.getSeconds());   // 초
```

### 12. **비트 연산자**
JavaScript에서는 비트 연산자를 사용해 비트 단위 조작이 가능합니다.
```javascript
let a = 5; // 0101
let b = 3; // 0011

console.log(a & b); // 1  (AND)
console.log(a | b); // 7  (OR)
console.log(a ^ b); // 6  (XOR)
console.log(~a);    // -6 (NOT)
console.log(a << 1);// 10 (Left shift)
console.log(a >> 1);// 2  (Right shift)
```

### 13. **클래스와 객체지향 프로그래밍**

#### 클래스 선언 및 인스턴스 생성
```javascript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  // 메서드 정의
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// 인스턴스 생성
const person1 = new Person('John', 30);
person1.greet(); // Hello, my name is John and I am 30 years old.
```

#### 상속과 메서드 오버라이딩
```javascript
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Rex');
dog.speak(); // Rex barks.
```

### 14. **모듈화**

#### 모듈 내보내기 (Export)
```javascript
// 변수와 함수를 모듈로 내보내기
export const PI = 3.14;

export function add(x, y) {
  return x + y;
}
```

#### 모듈 가져오기 (Import)
```javascript
// 모듈 가져오기
import { PI, add } from './math.js';

console.log(PI); // 3.14
console.log(add(2, 3)); // 5

// 모든 모듈 가져오기
import * as math from './math.js';

console.log(math.PI); // 3.14
console.log(math.add(2, 3)); // 5
```

### 15. **Error Handling (오류 처리)**

#### try...catch 문
```javascript
try {
  // 오류가 발생할 가능성이 있는 코드
  let result = riskyFunction();
} catch (error) {
  // 오류가 발생했을 때 실행할 코드
  console.error('An error occurred:', error);
} finally {
  // 오류 발생 여부와 관계없이 항상 실행되는 코드
  console.log('Execution completed.');
}
```

#### 사용자 정의 오류
```javascript
class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

try {
  throw new CustomError('This is a custom error message.');
} catch (error) {
  console.error(error.name); // CustomError
  console.error(error.message); // This is a custom error message.
}
```

### 16. **비동기 처리 및 AJAX**

#### Fetch API
```javascript
// 데이터 가져오기
fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// 데이터 보내기
fetch('https://api.example.com/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ key: 'value' }),
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
```

### 17. **기타 유용한 함수 및 메서드**

#### SetTimeout과 SetInterval
```javascript
// 일정 시간 후 함수 실행 (1초 후)
setTimeout(() => {
  console.log('This message is delayed by 1 second.');
}, 1000);

// 일정 시간 간격으로 함수 실행 (1초 간격)
const intervalId = setInterval(() => {
  console.log('This message is logged every 1 second.');
}, 1000);

// 타이머 중지
clearInterval(intervalId);
```

#### JSON 처리
```javascript
// 객체를 JSON 문자열로 변환
const obj = { name: 'John', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"John","age":30}'

// JSON 문자열을 객체로 변환
const json = '{"name":"John","age":30}';
const parsedObj = JSON.parse(json);
console.log(parsedObj); // { name: 'John', age: 30 }
```

#### Object Destructuring (객체 구조 분해)
```javascript
const person = { name: 'Alice', age: 25 };
const { name, age } = person;
console.log(name); // Alice
console.log(age); // 25

// 기본값 할당
const { name: firstName, height = 170 } = person;
console.log(firstName); // Alice
console.log(height); // 170 (기본값)
```

#### 배열 구조 분해
```javascript
const arr = [1, 2, 3];
const [first, second, third] = arr;
console.log(first); // 1
console.log(second); // 2
console.log(third); // 3

// 기본값 할당
const [a, b, c = 5] = [10, 20];
console.log(a); // 10
console.log(b); // 20
console.log(c); // 5 (기본값)
```

### 18. **고급 주제 및 추가 기능**

#### 이터레이터와 제너레이터
- **이터레이터(Iterator)**는 `next()` 메서드를 가지고 있어 순차적으로 값을 반환합니다.
- **제너레이터(Generator)** 함수는 이터레이터를 생성하는 함수로, `function*` 문법을 사용합니다.

```javascript
// 제너레이터 함수
function* generatorFunction() {
  yield 1;
  yield 2;
  yield 3;
}

const iterator = generatorFunction();
console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
```

#### 심볼 (Symbols)
- **심볼**은 객체의 고유한 속성 키를 만들 때 사용됩니다.

```javascript
const symbol1 = Symbol('description');
const symbol2 = Symbol('description');

console.log(symbol1 === symbol2); // false

const obj = {
  [symbol1]: 'value'
};

console.log(obj[symbol1]); // 'value'
```

#### 맵 객체 (WeakMap)와 집합 객체 (WeakSet)
- **WeakMap**은 객체를 키로 가지는 맵이며, 가비지 컬렉션의 대상이 됩니다.
- **WeakSet**은 객체를 원소로 가지는 집합이며, 객체가 가비지 컬렉션의 대상이 될 수 있습니다.

```javascript
let obj = { key: 'value' };
const weakMap = new WeakMap();
weakMap.set(obj, 'metadata');

const weakSet = new WeakSet();
weakSet.add(obj);
```

#### Proxy와 Reflect
- **Proxy** 객체는 다른 객체의 기본 작업(속성 접근, 할당 등)을 가로챕니다.
- **Reflect** 객체는 프로퍼티를 다루는 메서드들을 포함하고 있습니다.

```javascript
const target = { message1: 'hello', message2: 'everyone' };

const handler = {
  get: function(obj, prop) {
    return prop in obj ? obj[prop] : 'default';
  }
};

const proxy = new Proxy(target, handler);
console.log(proxy.message1); // 'hello'
console.log(proxy.message3); // 'default'
```

### 19. **기타 고급 주제**

#### ES6+ 최신 기능
- JavaScript ES6(ECMAScript 2015) 이후의 최신 기능들은 코드 작성 시 효율성을 높이고, 복잡한 구조를 간결하게 표현하는 데 유용합니다.

```javascript
// 비구조화 할당 (Destructuring Assignment)
const { prop1, prop2 } = { prop1: 'value1', prop2: 'value2' };
console.log(prop1); // 'value1'

// 나머지 매개변수(Rest Parameter) 및 전개 연산자(Spread Operator)
const numbers = [1, 2, 3];
const newNumbers = [...numbers, 4, 5]; // [1, 2, 3, 4, 5]

function sum(...args) {
  return args.reduce((acc, curr) => acc + curr, 0);
}
console.log(sum(1, 2, 3, 4)); // 10
```

### 20. **비동기 제어 흐름**

#### Promise.all 및 Promise.race
- **Promise.all**은 모든 프라미스가 해결될 때까지 기다리고, 그 결과를 배열로 반환합니다.
- **Promise.race**는 가장 빨리 완료된 프라미스의 결과를 반환합니다.

```javascript
const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve) => setTimeout(resolve, 100, 'foo'));
const promise3 = 42;

Promise.all([promise1, promise2, promise3]).then(values => {
  console.log(values); // [3, "foo", 42]
});

Promise.race([promise1, promise2, promise3]).then(value => {
  console.log(value); // 3
});
```


### 21. **테스트와 디버깅**

#### 콘솔 메서드
JavaScript는 여러 가지 콘솔 메서드를 제공하여 디버깅을 쉽게 할 수 있습니다.
```javascript
console.log('Log message');    // 일반 로그
console.error('Error message'); // 오류 메시지
console.warn('Warning message'); // 경고 메시지
console.table([{a:1, b:2}, {a:3, b:4}]); // 표 형태로 객체 배열 출력
console.time('timer');         // 타이머 시작
// 코드 실행
console.timeEnd('timer');      // 타이머 종료 및 시간 출력
```

#### 디버깅 도구
- **Debugger**: 디버거에 의해 중단점을 설정합니다.
  ```javascript
  function debugExample() {
    let x = 10;
    debugger; // 이 줄에서 실행이 중단됩니다.
    x += 20;
    return x;
  }
  ```

### 22. **동기화 객체와 멀티스레딩**

#### 웹 워커 (Web Workers)
웹 워커는 웹 애플리케이션이 별도의 스레드에서 스크립트를 실행할 수 있게 해줍니다.
```javascript
// 워커 생성
const worker = new Worker('worker.js');

// 메시지 전송
worker.postMessage('Hello, Worker!');

// 메시지 수신
worker.onmessage = function(event) {
  console.log(event.data);
};

// 워커 종료
worker.terminate();
```

### 23. **DOM 조작 및 이벤트 처리**

#### DOM 선택 및 조작
```javascript
// 요소 선택
const element = document.getElementById('myId');
const elements = document.querySelectorAll('.myClass');

// 속성 조작
element.setAttribute('data-example', 'value');
element.classList.add('new-class');

// 내용 조작
element.textContent = 'Hello World';
element.innerHTML = '<span>New Content</span>';
```

#### 이벤트 처리
```javascript
// 이벤트 리스너 추가
element.addEventListener('click', () => {
  console.log('Element clicked!');
});

// 이벤트 제거
element.removeEventListener('click', handler);

// 이벤트 전파 막기
element.addEventListener('click', (event) => {
  event.stopPropagation(); // 이벤트 전파 막기
  event.preventDefault();  // 기본 동작 방지
});
```

### 24. **고급 객체 조작**

#### 프로토타입 체인과 클래스
```javascript
// 생성자 함수와 프로토타입
function Person(name) {
  this.name = name;
}

Person.prototype.greet = function() {
  console.log(`Hello, my name is ${this.name}`);
};

const alice = new Person('Alice');
alice.greet(); // Hello, my name is Alice

// ES6 클래스와 상속
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Rex');
dog.speak(); // Rex barks.
```

#### 객체 프로퍼티 설정자와 접근자
```javascript
const obj = {
  _a: 0,
  get a() {
    return this._a;
  },
  set a(value) {
    if (value > 0) {
      this._a = value;
    }
  }
};

obj.a = 10;  // 설정자 호출
console.log(obj.a); // 접근자 호출, 10
```

### 25. **기타 고급 개념**

#### 타이머 함수
```javascript
// setTimeout: 일정 시간 후에 함수 실행
setTimeout(() => {
  console.log('This message is displayed after 2 seconds');
}, 2000);

// setInterval: 일정 간격으로 함수 실행
const intervalId = setInterval(() => {
  console.log('This message is displayed every 1 second');
}, 1000);

// 타이머 중지
clearInterval(intervalId);
```

#### 이벤트 루프와 비동기 작업
- **이벤트 루프**는 JavaScript의 비동기 동작을 관리하는 메커니즘입니다. 비동기 작업은 이벤트 큐에 추가되고, 이벤트 루프는 이 큐에서 작업을 하나씩 가져와 실행합니다.

### 26. **타입 검사 및 변환**

#### 기본 타입 검사
```javascript
console.log(typeof 'string'); // "string"
console.log(typeof 42);       // "number"
console.log(typeof true);     // "boolean"
console.log(typeof {});       // "object"
console.log(typeof undefined);// "undefined"
console.log(typeof null);     // "object" (특이 케이스)
console.log(Array.isArray([])); // true (배열 여부 검사)
```

#### 명시적 타입 변환
```javascript
// 숫자를 문자열로
let num = 123;
let str = num.toString();

// 문자열을 숫자로
let strNum = '123';
let intNum = parseInt(strNum, 10);
let floatNum = parseFloat(strNum);
```

#### 암시적 타입 변환
```javascript
console.log('5' + 2); // "52" (문자열로 변환)
console.log('5' * 2); // 10  (숫자로 변환)
```


### 27. **패턴과 설계 원칙**

#### 모듈 패턴
- 모듈 패턴은 코드의 전역 네임스페이스 오염을 피하기 위해 클로저를 사용해 코드를 캡슐화하는 패턴입니다.
```javascript
const myModule = (function() {
  let privateVariable = 'private';

  function privateMethod() {
    console.log(privateVariable);
  }

  return {
    publicMethod: function() {
      privateMethod();
    }
  };
})();

myModule.publicMethod(); // "private"
```

#### 싱글턴 패턴
- 싱글턴 패턴은 특정 클래스의 인스턴스가 하나만 존재하도록 보장합니다.
```javascript
const Singleton = (function() {
  let instance;

  function createInstance() {
    return new Object('I am the instance');
  }

  return {
    getInstance: function() {
      if (!instance) {
        instance = createInstance();
      }
      return instance;
    }
  };
})();

const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2); // true
```

### 28. **고급 타입 변환**

#### 강제 변환 (Coercion)
- JavaScript는 특정 상황에서 자동으로 타입을 변환합니다. 이를 **강제 변환**이라고 합니다.

```javascript
console.log('' == 0);      // true, 빈 문자열은 숫자 0으로 변환
console.log(false == 0);   // true, false는 숫자 0으로 변환
console.log('5' == 5);     // true, 문자열 '5'는 숫자 5로 변환

// 느슨한 비교(==)와 엄격한 비교(===)의 차이
console.log('5' === 5);    // false, 엄격한 비교는 타입 변환하지 않음
```

### 29. **이벤트 루프와 비동기 처리 심화**

#### 마이크로태스크와 매크로태스크
- **마이크로태스크**(Microtask): Promise 콜백, async/await. 이벤트 루프의 각 단계 끝에서 처리됩니다.
- **매크로태스크**(Macrotask): setTimeout, setInterval 등. 이벤트 루프의 매 사이클 시작 시 처리됩니다.

```javascript
console.log('start');

setTimeout(() => {
  console.log('setTimeout');
}, 0);

Promise.resolve().then(() => {
  console.log('promise');
});

console.log('end');

// 출력 순서: start, end, promise, setTimeout
```

### 30. **동적 코드 실행**

#### eval
- `eval` 함수는 문자열로 된 JavaScript 코드를 실행합니다. 보안 문제와 디버깅 어려움 때문에 사용을 피해야 합니다.
```javascript
const code = 'console.log("Dynamic Code Execution")';
eval(code); // "Dynamic Code Execution"
```

### 31. **템플릿 리터럴**

- 템플릿 리터럴을 사용하면 다중 줄 문자열과 표현식 삽입이 가능합니다.
```javascript
const name = 'Alice';
const greeting = `Hello, ${name}!`; // "Hello, Alice!"

const multiLine = `This is a
multiline string.`; // 줄바꿈이 포함된 문자열
```

### 32. **비구조화 할당과 기본값**

- 객체와 배열의 비구조화 할당 시 기본값을 설정할 수 있습니다.
```javascript
const { a = 10, b = 20 } = { a: 5 };
console.log(a); // 5
console.log(b); // 20

const [x = 1, y = 2] = [10];
console.log(x); // 10
console.log(y); // 2
```

### 33. **프록시와 반사**

- 프록시는 객체의 기본 작업(속성 읽기, 쓰기 등)을 가로챌 수 있습니다. 반사는 이 가로챔을 반영합니다.
```javascript
const handler = {
  get: function(target, prop, receiver) {
    if (prop in target) {
      return target[prop];
    } else {
      return `No such property: ${prop}`;
    }
  }
};

const proxy = new Proxy({}, handler);
proxy.a = 1;
console.log(proxy.a); // 1
console.log(proxy.b); // "No such property: b"
```

### 34. **정규 표현식**

- 정규 표현식은 문자열에서 패턴을 검색하거나 추출하는 데 사용됩니다.
```javascript
const regex = /hello/i; // 대소문자 구분 없음
console.log(regex.test('Hello world')); // true

const str = 'The quick brown fox';
const result = str.match(/\b\w{4}\b/g); // 네 글자 단어
console.log(result); // ["quick", "brown"]
```

### 35. **객체의 프로토타입 체인**

- 모든 객체는 프로토타입 객체를 가리키며, 프로토타입 체인을 통해 상속을 구현합니다.
```javascript
function Animal() {}
Animal.prototype.speak = function() {
  console.log('Animal speaks');
};

const dog = new Animal();
dog.speak(); // "Animal speaks"
console.log(dog.__proto__ === Animal.prototype); // true
```