<div id="readability-page-1" class="page"><div><ul>
<li>자바스크립트에서 데이터 타입에는 아래와 같이 <strong>원시형</strong>과 <strong>참조형</strong>으로 나뉩니다.</li>
<li>자바스크립트 메모리 구조는 <strong>스택 메모리(정적 할당, 변수, 원시형 데이터 저장)</strong>와 <strong>힙 메모리(동적 할당, 참조형 데이터, 저장)</strong> 영역으로 나뉘어 있습니다.</li>
</ul>
<h2 id="원시형primitive-type">원시형(Primitive Type)</h2>
<p>객체를 제외한 모든 타입은 <strong>원시 값(불변 값)으로 값을 그대로 할당</strong>합니다.</p>
<ul>
<li>boolen</li>
<li>null</li>
<li>undefined</li>
<li>number</li>
<li>string</li>
<li>symbol (ES6)</li>
</ul>
<p>아래와 같이 <code>newName</code>에 <code>name</code>을 할당하고 다시 <code>"jennie"</code>로 값을 재할당 한 후 <code>name</code>과 <code>newName</code>을 확인해 보면 데이터의 불변성(newName의 값을 재할당 해도 name의 값이 변하지 않음)을 확인할 수 있습니다.</p>
<pre><code><span>let</span> name <span>=</span> <span>"sara"</span><span>;</span>
<span>let</span> newName <span>=</span> name<span>;</span>
newName <span>=</span> <span>"jennie"</span><span>;</span>

console<span>.</span><span>log</span><span>(</span>name<span>,</span> newName<span>)</span><span>;</span> <span>// sara, jennie</span></code></pre>
<p>이렇게 값이 변하지 않는 것 이 당연해 보이지만 그 이유는 아래와 같습니다.</p>
<p>1. 메모리(<code>1002</code>)에 식별자 <code>name</code>을 저장합니다.</p>















<table><thead><tr><th>...</th><th>1002</th><th>...</th></tr></thead><tbody><tr><td>&nbsp;</td><td>이름: name   값:&nbsp;</td><td>&nbsp;</td></tr></tbody></table>
<p>2. <code>"sara"</code>를 비어있는 다른 메모리(<code>5003</code>) 공간에 저장합니다.</p>















<table><thead><tr><th>...</th><th>1002</th><th>...</th></tr></thead><tbody><tr><td>&nbsp;</td><td>이름: name   값:&nbsp;</td><td>&nbsp;</td></tr></tbody></table>















<table><thead><tr><th>...</th><th>5003</th><th>..</th></tr></thead><tbody><tr><td>&nbsp;</td><td>"sara"</td><td>&nbsp;</td></tr></tbody></table>
<p>3. <code>name</code>과 <code>newName</code> 은 같은 string 타입의 <code>"sara"</code>를 저장한 메모리(<code>5003</code>) 주소를 참조하게 됩니다.</p>















<table><thead><tr><th>...</th><th>1002</th><th>1003</th></tr></thead><tbody><tr><td>&nbsp;</td><td>이름: name   값: @5003</td><td>이름: newName   값: @5003</td></tr></tbody></table>















<table><thead><tr><th>...</th><th>5003</th><th>..</th></tr></thead><tbody><tr><td>&nbsp;</td><td>"sara"</td><td>&nbsp;</td></tr></tbody></table>
<p>4. <code>newName</code>에 <code>"jennie"</code>를 재할당 하면 string 타입의 <code>"jennie"</code>를 메모리(<code>5004</code>)에 저장하고 <code>newName</code>은 해당 주소(<code>5004</code>)를 참조합니다.</p>















<table><thead><tr><th>...</th><th>1002</th><th>1003</th></tr></thead><tbody><tr><td>&nbsp;</td><td>이름: name   값: @5003</td><td>이름: newName   값: @5004</td></tr></tbody></table>















<table><thead><tr><th>...</th><th>5003</th><th>5004</th></tr></thead><tbody><tr><td>&nbsp;</td><td>"sara"</td><td>"jennie"</td></tr></tbody></table>
<p>이와 같이 원시형에서는 데이터를 변경할 때 <strong>가리키는 주소를 직접 바꿔놓게</strong> 되기 때문에 <strong>불변성을 유지</strong>할 수 있습니다.</p>
<h2 id="참조형reference-type">참조형(Reference Type)</h2>
<p>객체 타입의 데이터로 값이 저장된 <strong>주소 값을 참조</strong>합니다.</p>
<ul>
<li>Object</li>
<li>Array</li>
<li>Function</li>
<li>RegExp(정규 표현식)</li>
<li>Set (ES6)</li>
<li>Map (ES6)</li>
</ul>
<p>같은 주소 값을 참조한다는 것은 <strong>얕은 복사(shallow copy)</strong>를 확인하면 이해할 수 있습니다.</p>
<p>아래와 같이 obj2.b 값을 재할당했을 때 obj.b의 값도 변경된 경우를 얕은 복사라고 합니다.</p>
<pre><code><span>const</span> obj <span>=</span> <span>{</span>
  a<span>:</span> <span>1</span><span>,</span>
  b<span>:</span> <span>2</span><span>,</span>
<span>}</span><span>;</span>

<span>const</span> obj2 <span>=</span> obj<span>;</span>

obj2<span>.</span>b <span>=</span> <span>3</span><span>;</span>

console<span>.</span><span>log</span><span>(</span>obj<span>,</span> obj2<span>)</span><span>;</span> <span>// {a: 1, b: 3}, {a: 1, b: 3}</span></code></pre>
<p>이렇게 obj의 값이 같이 변경된 이유는 아래와 같습니다.</p>
<p>1. <code>obj</code>를 메모리(<code>1002</code>)에 선언합니다.</p>















<table><thead><tr><th>...</th><th>1002</th><th>1003</th></tr></thead><tbody><tr><td>&nbsp;</td><td>이름: obj   값: @5002</td><td>이름: obj2   값: @1002</td></tr></tbody></table>
<p>2. 메모리 구조 공간 하나에는 값이 하나씩밖에 못 들어가기 때문에 메모리(<code>7103~</code>) 공간을 확보합니다.</p>

















<table><thead><tr><th>5002</th><th>&nbsp;5003</th><th>5004</th><th>5005</th></tr></thead><tbody><tr><td>@7103~</td><td>1</td><td>2</td><td>3</td></tr></tbody></table>
<p>확보한 공간 메모리(<code>7103 ~</code>)에 프로퍼티(<code>5003</code>, <code>5004</code>)를 하나씩 할당합니다.</p>















<table><thead><tr><th>7103</th><th>7104</th><th>...</th></tr></thead><tbody><tr><td>이름: a   값: @5003</td><td>이름: b   값: @5004 -&gt; @5005(3으로 재할당)</td><td>&nbsp;</td></tr></tbody></table>
<p>3. <code>obj2</code>에 <code>obj</code>를 할당했으므로 <code>obj</code>는 <code>1002</code>를 참조합니다.</p>
<p>4. <code>obj2.b</code> 에 <code>3</code>으로 재할당(<code>5005</code>) 하는 경우 <code>obj</code>와 <code>obj2</code>는 같은 메모리(<code>5002</code>) 주소 값을 참조합니다.</p>
<p>이와 같이 얕은 복사는 <code>obj2</code>는 새로운 객체를 만든 것이 아니라 <code>obj</code>와 <strong>같은 주소 값을 참조</strong>하므로 <code>obj2.b</code>를 변경했지만 <code>obj</code>도 같이 변하는 것을 확인할 수 있습니다.</p>
<p>참고 - 코어 자바스크립트</p></div></div>

760kry.log

자바스크립트에서 데이터 타입에는 아래와 같이 원시형과 참조형으로 나뉩니다.
자바스크립트 메모리 구조는 스택 메모리(정적 할당, 변수, 원시형 데이터 저장)와 힙 메모리(동적 할당, 참조형 데이터, 저장) 영역으로 나뉘어 있습니다.
원시형(Primitive Type)
객체를 제외한 모든 타입은 원시 값(불변 값)으로 값을 그대로 할당합니다.
boolen
null
undefined
number
string
symbol (ES6)
아래와 같이 newName에 name을 할당하고 다시 "jennie"로 값을 재할당 한 후 name과 newName을 확인해 보면 데이터의 불변성(newName의 값을 재할당 해도 name의 값이 변하지 않음)을 확인할 수 있습니다.
let name = "sara";
let newName = name;
newName = "jennie";
console.log(name, newName); // sara, jennie
이렇게 값이 변하지 않는 것 이 당연해 보이지만 그 이유는 아래와 같습니다.
1. 메모리(1002)에 식별자 name을 저장합니다.
...
1002
...
이름: name   값:
2. "sara"를 비어있는 다른 메모리(5003) 공간에 저장합니다.
...
1002
...
이름: name   값:
...
5003
..
"sara"
3. name과 newName 은 같은 string 타입의 "sara"를 저장한 메모리(5003) 주소를 참조하게 됩니다.
...
1002
1003
이름: name   값: @5003
이름: newName   값: @5003
...
5003
..
"sara"
4. newName에 "jennie"를 재할당 하면 string 타입의 "jennie"를 메모리(5004)에 저장하고 newName은 해당 주소(5004)를 참조합니다.
...
1002
1003
이름: name   값: @5003
이름: newName   값: @5004
...
5003
5004
"sara"
"jennie"
이와 같이 원시형에서는 데이터를 변경할 때 가리키는 주소를 직접 바꿔놓게 되기 때문에 불변성을 유지할 수 있습니다.
참조형(Reference Type)
객체 타입의 데이터로 값이 저장된 주소 값을 참조합니다.
Object
Array
Function
RegExp(정규 표현식)
Set (ES6)
Map (ES6)
같은 주소 값을 참조한다는 것은 얕은 복사(shallow copy)를 확인하면 이해할 수 있습니다.
아래와 같이 obj2.b 값을 재할당했을 때 obj.b의 값도 변경된 경우를 얕은 복사라고 합니다.
const obj = {
  a: 1,
  b: 2,
};
const obj2 = obj;
obj2.b = 3;
console.log(obj, obj2); // {a: 1, b: 3}, {a: 1, b: 3}
이렇게 obj의 값이 같이 변경된 이유는 아래와 같습니다.
1. obj를 메모리(1002)에 선언합니다.
...
1002
1003
이름: obj   값: @5002
이름: obj2   값: @1002
2. 메모리 구조 공간 하나에는 값이 하나씩밖에 못 들어가기 때문에 메모리(7103~) 공간을 확보합니다.
5002
5003
5004
5005
@7103~
1
2
3
확보한 공간 메모리(7103 ~)에 프로퍼티(5003, 5004)를 하나씩 할당합니다.
7103
7104
...
이름: a   값: @5003
이름: b   값: @5004 -> @5005(3으로 재할당)
3. obj2에 obj를 할당했으므로 obj는 1002를 참조합니다.
4. obj2.b 에 3으로 재할당(5005) 하는 경우 obj와 obj2는 같은 메모리(5002) 주소 값을 참조합니다.
이와 같이 얕은 복사는 obj2는 새로운 객체를 만든 것이 아니라 obj와 같은 주소 값을 참조하므로 obj2.b를 변경했지만 obj도 같이 변하는 것을 확인할 수 있습니다.
참고 - 코어 자바스크립트

JS 데이터 타입(원시형 vs 참조형)

댓글