recursal/MDN huggingface dataset:
증가 연산자(++)
==========

**증가(`++`) 연산자** 는 피연산자를 증가(1을 더함)시키고 연산자의 위치에 따라 증가하기 전이나 후의 값을 반환합니다.

시도해보기
-----

구문
--


```js
x++
++x
```

설명
--

만약 피연산자 뒤에 연산자를 붙여서 사용한다면 (예를 들어 `x++`) 증가 연산자는 수를 증가시키고 증가하기 전 값을 반환합니다.

만약 피연산자 앞에 연산자를 붙여서 사용한다면(예를 들어 `++x`) 증가 연산자는 수를 증가시키고 증가 후 값을 반환합니다.

증가 연산자는 참조인 피연산자 변수 및 객체 속성, 다시말해 유효한 할당 대상에만 적용할 수 있습니다. `++x` 자체는 참조가 아닌 값으로 평가되기 때문에 여러 증가 연산자를 연속적으로 사용할 수 없습니다.


```js
++(++x); // SyntaxError: Invalid left-hand side expression in prefix operation
```

예제
--

### 후위 증가


```js
let x = 3;
const y = x++;

// x = 4
// y = 3
```

### 전위 증가


```js
let x = 3;
const y = ++x;

// x = 4
// y = 4
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-increment-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* 더하기 연산자
* 빼기 연산자
* 나누기 연산자
* 곱하기 연산자
* 나머지 연산자
* 거듭제곱 연산자
* 감소 연산자
* 단항 부정 연산자
* 단항 더하기 연산자
void
====

**`void` 연산자**는 주어진 표현식을 평가하고 `undefined`를 반환합니다.

시도해보기
-----

구문
--


```js
void expression;
```

설명
--

`void`는 값을 생성하는 표현식을 평가해서 `undefined`를 반환합니다.

오직 `undefined` 원시값을 얻기 위해 `void 0` 또는 `void(0)`처럼 사용하는 경우도 볼 수 있습니다. 이런 경우 전역 `undefined`를 대신 사용해도 됩니다.

`void` 연산자의 우선순위도 유념해야 합니다. 그룹 연산자(괄호)를 사용하면 `void` 연산자를 사용한 식의 평가 과정을 더 명확하게 보일 수 있습니다.


```js
void 2 == "2"; // undefined == '2', false
void (2 == "2"); // void true, undefined
```

IIFE
----

즉시 실행 함수 표현식(IIFE)을 사용할 때 `void`를 사용하면 `function` 키워드를 선언문이 아니라 표현식처럼 간주하도록 강제할 수 있습니다.


```js
void (function iife() {
  var bar = function () {};
  var baz = function () {};
  var foo = function () {
    bar();
    baz();
  };
  var biz = function () {};

  foo();
  biz();
})();
```

JavaScript URI
--------------

`javascript:`로 시작하는 URI를 지원하는 브라우저에서는, URI에 있는 코드의 평가 결과가 `undefined`가 아니라면 페이지의 콘텐츠를 반환 값으로 대체합니다. `void` 연산자를 사용하면 `undefined`를 반환할 수 있습니다. 다음 예제를 확인하세요.


```html
<a href="javascript:void(0);">클릭해도 아무 일도 없음</a>
<a href="javascript:void(document.body.style.backgroundColor='green');">
  클릭하면 배경색이 녹색으로
</a>
```


**참고**: `javascript:` 의사 프로토콜보다 이벤트 처리기와 같은 대체재 사용을 권장합니다.

새지 않는 화살표 함수
------------

Arrow functions introduce a short-hand braceless syntax that returns an expression. This can cause unintended side effects by returning the result of a function call that previously returned nothing. To be safe, when the return value of a function is not intended to be used, it can be passed to the void operator to ensure that (for example) changing APIs do not cause arrow functions' behaviors to change.


```js
button.onclick = () => void doSomething();
```


This ensures the return value of `doSomething` changing from `undefined` to `true` will not change the behavior of this code.

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-void-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* `undefined`
감소 연산자 (--)
===========

**감소(`--`) 연산자** 는 피연산자를 감소(1을 뺌)시키고 연산자의 위치에 따라 감소하기 전이나 후의 값을 반환합니다.

시도해보기
-----

구문
--


```js
x--
--x
```

설명
--

만약 피연산자 뒤에 연산자를 붙여서 사용한다면 (예를 들어 `x--`) 감소 연산자는 수를 감소시키고 감소하기 전 값을 반환합니다.

만약 피연산자 앞에 연산자를 붙여서 사용한다면(예를 들어 `--x`) 감소 연산자는 수를 감소시키고 감소 후 값을 반환합니다.

 감소 연산자는 참조인 피연산자(변수 및 객체 속성, 다시 말해 유효한
 할당 대상에만 적용할 수 있습니다.
 `--x` 자체는 참조가 아닌 값으로 평가되기 때문에 여러 감소 연산자를 연속적으로 사용할 수 없습니다.


```js
--(--x); // SyntaxError: Invalid left-hand side expression in prefix operation
```

예제
--

### 후위 감소


```js
let x = 3;
const y = x--;
// x = 2
// y = 3
```

### 전위 감소


```js
let x = 3;
const y = --x;
// x = 2
// y = 2
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-decrement-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* 더하기 연산자
* 빼기 연산자
* 나누기 연산자
* 곱하기 연산자
* 나머지 연산자
* 거듭제곱 연산자
* 증가 연산자
* 단항 부정 연산자
* 단항 더하기 연산자
그룹 연산자
======

**그룹 연산자 `()`** 는 표현식 내에서 평가의 우선순위를 제어합니다.

시도해보기
-----

구문
--


```js
     ( )
```

설명
--

그룹 연산자는 표현식이나 중첩 표현식 주위를 감싸는 한 쌍의 괄호로 이루어진 연산자로, 감싸인 식이 더 높은 우선순위를 갖도록 일반적인 연산자 우선순위를 재정의합니다. 이름 그대로, 그룹 연산자는 괄호 안의 내용을 묶습니다.

예제
--

다음 예제에서는 곱셈과 나눗셈 이후 덧셈과 뺄셈을 사용하는 일반적인 연산 순서를 그룹 연산자를 사용해 바꿉니다.


```js
var a = 1;
var b = 2;
var c = 3;

// 기본 우선순위
a + b \* c; // 7
// 이것과 같음
a + (b \* c); // 7

// 더하기를 곱하기보다 먼저 하도록
// 우선순위 변경
(a + b) \* c; // 9

// 이것과 같음
a \* c + b \* c; // 9
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-grouping-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* 연산자 우선순위
* `delete` (en-US)
* `typeof`
할당 연산자 (=)
==========

**할당(`=`)** 연산자는 변수에 값을 대입하는 데 사용됩니다. 할당 연산은 할당된 값으로 평가됩니다. 할당 연산자를
 연결하여 사용하면 단일 값을 여러 변수에 할당할 수 있습니다.

시도해보기
-----

구문
--


```js
x = y
```

예제
--

### 간단한 대입과 연결하여 사용


```js
let x = 5;
let y = 10;
let z = 25;

x = y; // x 는 10입니다.
x = y = z; // x, y, z 는 모두 25입니다.
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* JavaScript 가이드에서 할당 연산자
* 구조 분해 할당
조건 (삼항) 연산자
===========

**조건 (삼항) 연산자**는 JavaScript에서 세 개의 피연산자를 받는 유일한 연산자입니다. 앞에서부터 조건문, 물음표(`?`), 조건문이 참(truthy)일 경우 실행할 표현식, 콜론(`:`), 조건문이 거짓(falsy)일 경우 실행할 표현식이 배치됩니다. 해당 연산자는 `if...else`문의 대체재로 빈번히 사용됩니다.

시도해보기
-----

구문
--


```js
condition ? exprIfTrue : exprIfFalse;
```

### 매개변수

`condition`

조건문으로 사용되는 표현식

`exprIfTrue`

`condition`이 truthy한 값으로 평가될 경우 실행되는 표현식 (`true`와 같거나, `true`로 치환될 수 있는 값)

`exprIfFalse`

`condition`이 falsy한 값으로 평가될 경우 실행되는 표현식 (`false`와 같거나, `false`로 치환될 수 있는 값)

설명
--

`false` 이외의 falsy한 표현식에는 `null`, `NaN`, `0`, 비어있는 문자열 (`""`), 그리고 `undefined`가 있습니다. `condition`이 이 중 하나일 경우 조건 연산자의 결괏값은 `exprIfFalse` 표현식을 실행한 결괏값입니다.

예제
--

### 간단한 예제


```js
var age = 26;
var beverage = age >= 21 ? "Beer" : "Juice";
console.log(beverage); // "Beer"
```

### null 값 처리하기

`null`일 수 있는 값을 처리할 때 흔히 사용됩니다:


```js
let greeting = (person) => {
  let name = person ? person.name : `stranger`;
  return `Howdy, ${name}`;
};

console.log(greeting({ name: `Alice` })); // "Howdy, Alice"
console.log(greeting(null)); // "Howdy, stranger"
```

### 연결된 조건문 처리하기

조건 연산자는 아래와 같이 연결해 사용할 수 있습니다. 이는 연결된 `if … else if … else if … else`와 유사합니다.


```js
function example(…) {
    return condition1 ? value1
         : condition2 ? value2
         : condition3 ? value3
         : value4;
}
```


위 코드는 아래의 연결된 `if … else`와 동등합니다.


```js
function example(…) {
    if (condition1) { return value1; }
    else if (condition2) { return value2; }
    else if (condition3) { return value3; }
    else { return value4; }
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-conditional-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* if statement
비트 AND 할당 연산 (&=)
=================

**비트 AND 할당 (`&=`)** 연산자는 두 피연산자의 이진 표현을 사용하고, 피연산자에 대한 AND 비트 연산 수행 결과를 변수에 할당합니다.

시도해보기
-----

구문
--


```js
x &= y // x = x & y
```

예제
--

### 비트 AND 할당 연산 사용하기


```js
let a = 5;
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
a &= 2; // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* JS의 할당 연산자 안내서
* AND 비트 연산자
new.target
==========

**`new.target`** 속성(property)은 함수 또는 생성자가 new 연산자를 사용하여 호출됐는지를 감지할 수 있습니다. new 연산자로 인스턴스화된 생성자 및 함수에서, `new.target`은 생성자 또는 함수 참조를 반환합니다. 일반 함수 호출에서는, `new.target`은 `undefined`입니다.

시도해보기
-----

구문
--


```js
new.target;
```

설명
--

`new.target` 구문은 키워드 "`new`", 점 및 속성명 "`target`"으로 구성됩니다. 보통 "`new.`"은 속성 접근을 위한 문맥(context)으로 제공하지만 여기서 "`new.`"은 정말 객체가 아닙니다. 그러나, 생성자 호출에서 `new.target`은 `new`에 의해 호출된 생성자를 가리키고 그래서 "`new.`"은 가상 문맥이 됩니다.

`new.target` 속성은 모든 함수가 이용할 수 있는 메타 속성입니다. 화살표 함수에서, `new.target`은 둘러싸는 함수의 `new.target`을 말합니다.

예
-

### 함수 호출에서 new.target

일반 함수 호출(생성자 함수 호출과는 반대로)에서, `new.target`은 `undefined`입니다. 이는 함수가 생성자로서 new로 호출된 경우를 감지할 수 있습니다.


```js
function Foo() {
  if (!new.target) throw "Foo() must be called with new";
  console.log("Foo instantiated with new");
}

Foo(); // throws "Foo() must be called with new"
new Foo(); // logs "Foo instantiated with new"
```

### 생성자에서 new.target

클래스 생성자에서, `new.target`은 `new`에 의해 직접 호출된 생성자를 가리킵니다. 이는 그 생성자가 부모 클래스에 있고 자식 생성자로부터 위임받은 경우도 그 경우입니다.


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

var a = new A(); // logs "A"
var b = new B(); // logs "B"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* 함수
* 클래스
* `new`
* `this`
거듭제곱 (\*\*)
===========

 거듭제곱 연산자(`**`)는 왼쪽 피연산자를 밑, 오른쪽 피연산자를 지수로 한 값을 구합니다.
 `BigInt`도 피연산자로 받을 수 있다는 점을 제외하면 `Math.pow()`와 같습니다.

시도해보기
-----

구문
--


```js
x \*\* y;
```

설명
--

거듭제곱 연산자는 우측 결합성을 가집니다. 따라서 `a ** b ** c`는 `a ** (b ** c)`와 같습니다.

 PHP, Python 등 거듭제곱 연산자(`**`)를 포함하는 언어의 대부분은 거듭제곱 연산자가 단항 연산자(단항
 `+`, `-` 등)보다 높은 우선순위를 가집니다. 그러나 Bash처럼 단항 연산자가 더 높은 우선순위를
 가지는 예외의 언어도 있습니다.

 반면 JavaScript에서는 모호한 거듭제곱 표현식을 작성하는 것이 불가능합니다. 단항
 연산자(`+/-/~/!/delete/void/typeof`)를 밑 피연산자의 바로 앞에 사용할 수 없으며, 사용하려고 하면
 `SyntaxError`가 발생합니다.


```js
-2 \*\* 2;
// Bash에서는 4, 다른 언어에서는 -4
// 모호한 식이므로 JavaScript에서 유효하지 않음

-(2 \*\* 2);
// JavaScript에서 -4, 저자의 의도가 명확함
```


 참고로 어떤 언어에선 캐럿 기호 `^`를 거듭제곱에 사용하지만, JavaScript에서 캐럿은
 비트 XOR 연산자 (en-US)에서
 사용합니다.

예제
--

### 기본 거듭제곱


```js
2 \*\* 3; // 8
3 \*\* 2; // 9
3 \*\* 2.5; // 15.588457268119896
10 \*\* -1; // 0.1
NaN \*\* 2; // NaN
```

### 연관성


```js
2 \*\* 3 \*\* 2; // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### 단항 연산자와 사용하기

거듭제곱 결과의 부호를 반전하려면,


```js
-(2 \*\* 2); // -4
```


거듭제곱 표현식의 밑에 음수를 제공하려면,


```js
(-2) \*\* 2; // 4
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-exp-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* 더하기 연산자
* 빼기 연산자
* 나누기 연산자
* 곱하기 연산자
* 나머지 연산자
* 증가 연산자
* 감소 연산자
* 단항 부정 연산자
* 단항 플러스 연산자
논리적 NOT (!)
===========

**논리적 NOT (`!`)** (논리적 보수, 부정) 연산자는 참을 거짓으로 만들고, 반대로 거짓을 참으로 만듭니다. 일반적으로 불리언 (논리적) 값과 함께 사용됩니다. 불리언이 아닌 값들과 함께 사용된다면, 단일 피연산자가 `true`로 변환될 수 있으면 `false`를 반환하고, 그렇지 않으면 `true`를 반환합니다.

시도해보기
-----

구문
--


```js
!x
```

설명
--

 단일 피연산자가 `true`로 변환될 수 있으면 `false`를 반환합니다.
 그렇지 않으면, `true`를 반환합니다.

만약 어떤 값이 `true`로 변환 가능하다면, 그 값은 소위 참 같은 값입니다. 만약 어떤 값이 `false`로 변환 가능하다면, 그 값은 소위 거짓 같은 값 이라고 합니다.

거짓으로 변환될 수 있는 표현식의 예시는 다음과 같습니다.

* `null`;
* `NaN`;
* `0`;
* 빈 문자열 (`""` or `''` or ````);
* `undefined`.

`!` 연산자는 불리언 값이 아닌 피연산자와 함께 사용할 수 있지만, 반환값이 항상 원시형 불리언으로 변환될 수 있기 때문에 여전히 불리언 연산자로 간주할 수 있습니다. 명시적으로 반환값을 (또는 일반적으로 어떤 표현식을) 대응하는 불리언 값으로 변환하기 위해서는 이중 NOT 연산자 (`!!`) 또는 `Boolean` 생성자를 사용하시기 바랍니다.

예제
--

### NOT 사용하기

다음 코드는 `!`(논리적 NOT) 연산자의 예제를 보여줍니다.


```js
!true; // !t 는 false를 반환합니다
!false; // !f 는 true를 반환합니다
!""; // !f 는 true를 반환합니다
!"Cat"; // !t 는 false를 반환합니다
```

### 이중 NOT (`!!`)

 NOT 연산자를 연속으로 2개 사용해서 명시적으로 어떤 값을 그에 대응하는 원시형 불리언으로 변환하도록 강제할 수 있습니다.
 변환은 값의 "참 같음" 또는 "거짓 같음"에 기반합니다(참 같은 값과 거짓 같은 값을 참고하세요).

`Boolean` 함수를 통해서도 똑같은 변환을 수행할 수 있습니다.


```js
!!true; // !!truthy는 true를 반환합니다.
!!{}; // !!truthy는 true를 반환합니다. 임의의 object는 참 같은 객체입니다.
!!new Boolean(false); // .valueOf()에서 false값을 가지는 불리언 객체도요!
!!false; // !!falsy는 false를 반환합니다.
!!""; // !!falsy는 false를 반환합니다.
!!Boolean(false); // !!falsy는 false를 반환합니다.
```

### NOT 사이에서의 변환

**불리언**울 포함하는 다음 연산


```js
!!bCondition
```


는 항상 아래와 같습니다.


```js
bCondition
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-logical-not-operator |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* `Boolean`
* Truthy
* Falsy
부등 연산자(!=)
==========

부등 연산자(!=)는 두 피연산자가 같지 않은지 확인하여 불리언 결과를 반환합니다. 엄격한 부등 연산자와는 달리 다른 유형의 피연산자를 암묵적으로 변환하고 비교합니다.

시도해보기
-----

구문
--


```js
x != y;
```

설명
--

부등식 연산자는 피연산자가 같지 않은지 여부를 확인합니다. 동등 연산자의 부정이므로 다음 두 줄은 항상 같은 결과를 제공합니다.


```js
x != y;

!(x == y);
```


비교 알고리즘에 대한 자세한 내용은 동등 연산자 페이지를 참조하십시오.

동등 연산자와 마찬가지로 부등 연산자도 다른 유형의 피연산자를 변환하여 비교합니다.


```js
3 != "3"; // false
```


이를 방지하고 다른 유형이 다른 것으로 간주되게 하려면 엄격한 불일치 연산자 (en-US)를 사용해야 합니다.


```js
3 !== "3"; // true
```

예제
--

### 타입 변환이 없는 비교


```js
1 != 2; // true
"hello" != "hola"; // true

1 != 1; // false
"hello" != "hello"; // false
```

### 타입 변환이 있는 비교


```js
"1" != 1; // false
1 != "1"; // false
0 != false; // false
0 != null; // true
0 != undefined; // true
0 != !!null; // false, look at Logical NOT operator
0 != !!undefined; // false, look at Logical NOT operator
null != undefined; // false

const number1 = new Number(3);
const number2 = new Number(3);
number1 != 3; // false
number1 != number2; // true
```

### 객체의 비교


```js
const object1 = { key: "value" };
const object2 = { key: "value" };

object1 != object2; // true
object2 != object2; // false
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-equality-operators |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

관련 문서
-----

* Equality
operator
* Strict
equality operator (en-US)
* Strict
inequality operator (en-US)
Logical OR (||)
===============

**논리적 OR (`||`)** (논리적 분리) 연산자는 피연산자 중 하나 이상이 참인 경우에만 참입니다. 일반적으로 불리언(논리적) 값과 함께 사용되며, 이 경우에는 불리언 값을 반환합니다. 그러나 `||` 연산자는 실제로 지정된 피연산자 중 하나의 값을 반환하므로, 이 연산자를 불리언이 아닌 값과 함께 사용하면 불리언이 아닌 값이 반환됩니다.

시도해보기
-----

문법
--


```js
x || y
```

구문
--

만약 `x`를 `true`로 반환할 수 있으면 `x`를 반환하고, 그렇지 않으면 `y`를 반환합니다.

값을 `true`로 변환할 수 있는 경우, 해당 값은 소위 truthy하다고 할 수 있습니다. 값을 `false`로 변환할 수 있으면, 해당 값을 falsy하다고 할 수 있습니다.

false로 변환할 수 있는 표현식의 예는 다음과 같습니다.

* `null`;
* `NaN`;
* `0`;
* 빈 문자열 (`""` 또는 `''` 또는 ````);
* `undefined`.

`||` 연산자는 불리언 값이 아닌 피연산자와 함께 사용할 수 있지만, 반환 값은 항상 불리언 원시 값으로 변환할 수 있으므로 불리언 연산자로 간주할 수 있습니다. 반환 값(또는 일반적으로 모든 표현식)을 해당 불리언 값으로 명시적으로 변환하려면 이중 [NOT operator] 또는 `Boolean` 생성자를 사용합니다.

### 단락 평가

논리적 OR 표현식은 왼쪽에서 오른쪽으로 평가되며, 다음 규칙을 사용하여 "단락" 평가가 가능한지 테스트합니다.

`(some truthy expression) || expr`은 참 같은 값(truthy) 표현식으로 단락 평가됩니다.

단락은 위의 `expr` 부분이 **평가되지 않으므로** 이로 인한 부작용이 발생하지 않음을 의미합니다. (예: `expr`이 함수 호출인 경우 호출이 수행되지 않음) 이는 첫 번째 피연산자를 평가한 후에 피연산자 값이 이미 결정되었기 때문에 발생합니다. 아래 예제를 참조하세요.


```js
function A() {
  console.log("called A");
  return false;
}
function B() {
  console.log("called B");
  return true;
}

console.log(B() || A());
// 함수 호출로 인해 "called B"를 콘솔에 출력합니다.
// 그런 다음 true(연산자의 결과 값)를 기록합니다.
```

### 연산자 우선순위

다음 표현식은 동일해 보일 수 있지만, `&&` 연산자가 `||` 연산자보다 먼저 실행되기 때문에 동일하지 않습니다. (연산자 우선순위를 참조).


```js
true || false && false; // &&이 먼저 실행되어 true를 반환합니다.
(true || false) && false; // 그룹화가 가장 우선순위가 높으므로, false를 반환합니다.
```

예제
--

### OR 사용하기

다음 코드는 `||` (논리적 OR) 연산자의 예를 보여줍니다.


```js
true || true; // t || t returns true
false || true; // f || t returns true
true || false; // t || f returns true
false || 3 === 4; // f || f returns false
"Cat" || "Dog"; // t || t returns "Cat"
false || "Cat"; // f || t returns "Cat"
"Cat" || false; // t || f returns "Cat"
"" || false; // f || f returns false
false || ""; // f || f returns ""
false || varObject; // f || object returns varObject
```


**참고:** 이 연산자를 사용하여 일부 변수에 기본값을 제공하는 경우, 거짓 같은 값(falsy)은 사용되지 않으므로 주의해야 합니다.
 `null` 또는 `undefined`만 필터링해야 하는 경우, 널 병합 연산자를 사용하는 것이 좋습니다.


### 불리언에 대한 변환 규칙

#### AND를 OR로 변환하기

**불리언**을 포함하는 아래 연산은


```js
bCondition1 && bCondition2
```


항상 아래와 같습니다.


```js
!(!bCondition1 || !bCondition2)
```


#### OR을 AND로 변환하기

**불리언**을 포함하는 아래의 연산은


```js
bCondition1 || bCondition2
```


항상 아래와 같습니다.


```js
!(!bCondition1 && !bCondition2)
```

### 중첩된 괄호 제거

논리적 표현식은 왼쪽에서 오른쪽으로 평가되기 때문에 특정 규칙을 따르는 경우 복잡한 식에서 괄호를 제거할 수 있습니다.

**불리언**을 포함하는 다음 복합적인 연산은


```js
bCondition1 && (bCondition2 || bCondition3)
```


언제나 다음과 같습니다.


```js
!(!bCondition1 || !bCondition2 && !bCondition3)
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-LogicalORExpression |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* Nullish coalescing operator (`??`)
* `Boolean`
* Truthy
* Falsy
yield\*
=======

**`yield*` 표현식**은 다른 `generator` 또는 이터러블(iterable) 객체에 yield를 위임할 때 사용됩니다.

시도해보기
-----

구문
--


```js
yield\* [[expression]];
```


`expression`

이터러블(iterable) 객체를 반환하는 표현식.

설명
--

yield\* 표현은 피연산자를 반복하고 반환되는 값을 yield합니다.

yield\* 표현 자체의 값은 반복자(iterator)가 종료될 때 반환되는 값입니다. (i.e., done이 true일 때)

예제
--

### 다른 생성기(generator)에 위임하기

다음 코드는, next() 호출을 통해 g1()으로부터 yield 되는 값을 g2()에서 yield 되는 것처럼 만듭니다.


```js
function\* g1() {
  yield 2;
  yield 3;
  yield 4;
}

function\* g2() {
  yield 1;
  yield\* g1();
  yield 5;
}

var iterator = g2();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### 다른 이터러블(iterable) 객체

생성기 객체 말고도, yield\*는 다른 반복 가능한 객체도 yield 할 수 있습니다. e.g. 배열, 문자열 또는 arguments 객체


```js
function\* g3() {
  yield\* [1, 2];
  yield\* "34";
  yield\* Array.from(arguments);
}

var iterator = g3(5, 6);

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: "3", done: false }
console.log(iterator.next()); // { value: "4", done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: 6, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### `yield*` 표현 자체의 값

`yield*` 는 구문이 아닌 표현입니다. 따라서 값으로 평가됩니다.


```js
function\* g4() {
  yield\* [1, 2, 3];
  return "foo";
}

var result;

function\* g5() {
  result = yield\* g4();
}

var iterator = g5();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true },
// g4() 는 여기서 { value: "foo", done: true }를 반환합니다

console.log(result); // "foo"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* The Iterator protocol (en-US)
* `function*`
* `function* expression`
* `yield`
in 연산자
======

**`in` 연산자**는 명시된 속성이 명시된 객체에 존재하면 `true`를 반환합니다.

구문
--


```js
속성 in 객체명;
```

### 인자

`속성`

속성의 이름이나 배열의 인덱스를 뜻하는 문자열 또는 수 값입니다.

`객체명`

객체의 이름입니다.

설명
--

다음 예제들은 `in` 연산자의 용도를 보여 줍니다.


```js
// 배열
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees; // true를 반환합니다.
3 in
  trees(
    // true를 반환합니다.
    1 + 2,
  ) in
  trees; // true를 반환합니다. 연산자 우선 순위에 의하여 이 구문의 괄호는 없어도 됩니다.
6 in trees; // false를 반환합니다.
"bay" in trees; // false를 반환합니다. 당신은 배열의 내용이 아닌, 인덱스 값을 명시하여야 합니다.
"length" in trees; // true를 반환합니다. length는 Array(배열) 객체의 속성입니다.

// 미리 정의된 객체
"PI" in Math; // true를 반환합니다.
"P" + "I" in Math; // true를 반환합니다.

// 사용자가 정의한 객체
var myCar = {
  company: "Lamborghini",
  model: "Lamborghini Veneno Roadster",
  year: 2014,
};
"company" in myCar; // true를 반환합니다.
"model" in myCar; // true를 반환합니다.
```


당신은 반드시 `in` 연산자의 오른쪽에 객체를 명시하여야 합니다. 예컨대 당신은 `String` 생성자로 만들어진 문자열을 명시할 수 있지만 문자열 리터럴은 명시할 수 없습니다.


```js
var color1 = new String("green");
"length" in color1; // true를 반환합니다.

var color2 = "coral";
"length" in color2; // color2는 String 객체가 아니기에 오류를 냅니다.
```

### 제거되었거나 정의되지 않은 속성에 대하여 `in` 연산자 사용하기

`in` 연산자는 `delete` (en-US) 연산자로 제거된 속성에 대하여 `false`를 반환합니다.


```js
var myCar = {
  company: "Lamborghini",
  model: "Lamborghini Veneno Roadster",
  year: 2014,
};
delete myCar.company;
"company" in myCar; // false를 반환합니다.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
3 in trees; // false를 반환합니다.
```


만약 당신이 속성을 `undefined`로 설정하였는데 그것을 제거하지 않으면, `in` 연산자는 그 속성에 대하여 `true`를 반환합니다.


```js
var myCar = {
  company: "Lamborghini",
  model: "Lamborghini Veneno Roadster",
  year: 2014,
};
myCar.company = undefined;
"company" in myCar; // true를 반환합니다.
```



```js
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
3 in trees; // true를 반환합니다.
```

### 상속된 속성

`in` 연산자는 프로토타입 체인에 의하여 접근할 수 있는 속성에 대하여 `true`를 반환합니다.


```js
"toString" in {}; // true를 반환합니다.
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

관련 문서
-----

* `delete` (en-US)
* `Object.prototype.hasOwnProperty()` (en-US)
* `Reflect.has()`
* 속성의, 소유와 셀 수 있는 성질 (en-US)
AND 비트연산(&)
===========

AND 비트 연산자(`&`)는 두 개의 피연산자의 각 자리마다 대응하는 비트가 모두 `1`일 경우 `1`을 반환합니다.

시도해보기
-----

구문
--


```js
a & b;
```

설명
--

피연산자는 32비트 정수로 변환되며 일련의 비트(0과 1)로 표현됩니다. 32비트 이상인 숫자는 최상위 비트가 삭제됩니다. 예를 들어 32비트 이상인 다음 정수는 32비트 정수로 변환됩니다.


```js
Before: 11100110111110100000000000000110000000000001;
After: 10100000000000000110000000000001;
```


첫 번째 피연산자의 각 비트는 두 번째 피연산자의 해당 비트(*첫 번째 비트* 와 *첫 번째 비트*, *두 번째 비트* 와 *두 번째 비트* 등등)와 쌍을 이룹니다.

연산자가 각 비트의 쌍에 적용되며, 결과는 완성된 비트 연산된 값입니다.

AND 연산에 대한 진리표는 다음과 같습니다:

| a | b | a AND b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |


```js
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
```


어떤 수 `x`에 `0`을 AND 비트 연산한 결과는 `0`가 됩니다.

예제
--

### AND 비트 연산 사용하기


```js
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
5 & 2; // 0
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseANDExpression |

브라우저 호환성
--------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

같이 보기
-----

* JS의 비트 연산 가이드
* 비트 AND 할당연산자