[Javascript] 타입 변환 (Type coercion)

유동균·2022년 12월 5일
JavaScript
0

JavaScript

목록 보기
5/13
post-thumbnail

1. 타입 변환 (Type coercion)

자바스크립트의 모든 값은 타입이 있다.

  • 값의 타입은 다른 타입으로 개발자에 의해 의도적으로 변환할 수 있고,

    이를 명시적 타입 변환 (Explicit coercion) 또는 타입 캐스팅 (Type casting)이라 한다.

let a = 10;

// 명시적 타입 변환
let str = a.toString();		// 숫자를 문자로 변환한다.
console.log(typeof str);	// string
  • 자바스크립트 엔진에 의해 암묵적으로 자동 변환될 수 있다.

    이를 암묵적 타입 변환(Implicit coercion) 또는 타입 강제 변환(Type coercion)이라 한다.

let a = 10;

// 암묵적 타입 변환
// 숫자 타입 a의 값을 바탕으로 새로운 문자열 타입의 값을 생성해 표현식을 평가한다.
let str = a + '';

console.log(typeof str);	// string

// 다만 변수 a의 값이 변경되진 않는다.
console.log(a);	// 10

명시적, 암묵적 타입 변환 모두 타입의 기존 값을 직접 변경하는것은 아니다.

암묵적 타입 변환은 변수를 재할당해서 변경하는 것이 아니라 자바스크립트 엔진이 표현식을 에러 없이 평가하기 위해 기존 값을 바탕으로 새로운 타입의 값을 만들어 단 한번 사용하고 버린다.

명시적 타입 변환은 개발자가 직접 코드 작성을 통해 나타나지만, 암묵적 타입 변환은 자바스크립트 엔진에 의해 즉, 드러나지 않게 타입이 자동으로 변환되기 때문에 자신이 작성한 코드에서 암묵적 타입 변환이 발생하는지, 발생한다면 어떤 타입의 어떤 값으로 변환되는지, 그리고 타입 변환된 값으로 표현식은 어떻게 평가될 것인지 예측 가능해야 한다. 만약 예측하지 못하거나 예측한 내용이 결과와 일치하지 않는다면 버그를 생산할 가능성이 높아진다.

2. 암묵적 타입 변환

자바스크립트 엔진은 표현식을 평가할 때 문맥,
즉 컨텍스트(Context)에 고려하여 암묵적 타입 변환을 실행한다.

// 표현식이 모두 문자열 타입이여야 하는 컨텍스트
'10' + 2		// '102'

// 표현식이 모두 숫자 타입이여야 하는 컨텍스트
5 * '10'		// 50

// 표현식이 모두 불리언 타입이여야 하는 컨텍스트
!0				// true

이처럼 표현식을 평가할 때 컨텍스트에 부합하지 않는다면, 자바스크립트는 에러를 발생시키지 않도록 암묵적 타입 변환을 통해 표현식을 평가한다.
암묵적 타입 변환이 발생하면 문자열, 숫자, 불리언과 같은 원식 타입 중 하나로 자동 변환한다.

2.1. 문자열 타입으로 변환

1 + '2'	// '12'

위 예제에서 + 연산자는 피연산자 중 하나 이상의 문자열이 존재하므로 문자열 연결 연산자로 동작한다.
문자열 연결 연산자의 역할은 문자열 값을 만드는 것이기 때문에 연결 연산자의 피연산자는 컨텍스트 상 문자열 타입이여야한다.

자바스크립트 엔진은 문자열 연결 연산자 표현식을 평가하기 위해 문자열 연결 연산자의 피연산자 중에서 문자열 타입이 아닌 피연산자를 문자열 타입으로 암묵적 타입 변환 한다.

console.log(`1 + 1 = ${1 + 1}`);	// '1 + 1 = 2'

연산자 식의 피연산자(피연산자도 표현식) 만이 암묵적 타입 변환의 대상이 되는것은 아니다.
위 예제에서 템플릿 리터럴의 문자열 인터폴레이션(String Interpolation)은 표현식의 결과를 문자열타입으로 암묵적 타입 변환한다.

자바스크립트 엔진은 문자열 타입이 아닌 값을 문자열 타입으로 암묵적 타입 변환을 수행할 때 아래와 같이 동작한다.

// 숫자 타입
0 + ''              // "0"
-0 + ''             // "0"
1 + ''              // "1"
-1 + ''             // "-1"
NaN + ''            // "NaN"
Infinity + ''       // "Infinity"
-Infinity + ''      // "-Infinity"

// 불리언 타입
true + ''           // "true"
false + ''          // "false"

// null 타입
null + ''           // "null"

// undefined 타입
undefined + ''      // "undefined"

// 심볼 타입
(Symbol()) + ''     // TypeError: Cannot convert a Symbol value to a string

// 객체 타입
({}) + ''           // "[object Object]"
Math + ''           // "[object Math]"
[] + ''             // ""
[10, 20] + ''       // "10,20"
(function(){}) + '' // "function(){}"
Array + ''          // "function Array() { [native code] }"

2.2. 숫자 타입으로 변환

1 - '1'		// 0
1 * '10'	// 10
2 / 'one'	// NaN

위 예제의 연산자는 모두 산술 연산자이고 산술 연산자의 역할은 숫자 값을 만드는 것이다. 따라서 산술 연산사즤 피연산자는 컨텍스트 상 숫자 타입이여야 한다.

자바스크립트 엔진은 산술 연산자 표현식을 평가하기 위해 산술 연산자의 피연산자 중에서 숫자 타입이 아닌 피연산자를 숫자 타입으로 암묵적 타입 변환한다.
이때 피연산자를 숫자 타입으로 변환할 수 없는 경우 NaN 반환

피연산자를 숫자 타입으로 변환해야 할 컨텍스트는 산술 연산자 뿐만이 아니다.

'123' > 0	// true

비교 연산자의 역할은 불리언 값을 만드는 것이다. 비교 연산자는 피연산자들의 크기를 비교하므로 컨텍스트 상 숫자 타입이여야 한다.

자바스크립트 엔진은 숫자 타입이 아닌 값을 숫자 타입으로 암묵적 타입 변환을 수행할 때 아래와 같이 동작한다.
+ 단항 연산자는 피연산자가 숫자 타입의 값이 아니면 숫자 타입의 값으로 암묵적 타입 변환

// 문자열 타입
+''             // 0
+'0'            // 0
+'1'            // 1
+'string'       // NaN

// 불리언 타입
+true           // 1
+false          // 0

// null 타입
+null           // 0

// undefined 타입
+undefined      // NaN

// 심볼 타입
+Symbol()       // TypeError: Cannot convert a Symbol value to a number

// 객체 타입
+{}             // NaN
+[]             // 0
+[10, 20]       // NaN
+(function(){}) // NaN
// 빈 문자열, 빈 배열, null, false는 0으로 true는 1로 변환
// 객체와 빈 배열이 아닌 배열, undefined는 변환되지 않아 NaN

2.3. 불리언 타입으로 변환

if ('')    console.log('1');
if (true)  console.log('2');	// 2
if (0)     console.log('3');
if ('str') console.log('4');	// 4
if (null)  console.log('5');

자바스크립트 엔진은 불리언 타입이 아닌 값을
Truthy 값(참으로 인식할 값), Falsy 값(거짓으로 인식할 값) 으로 구분한다.

Falsy 값

  • false
  • undefined
  • null
  • 0, -0
  • NaN
  • 빈 문자열

    이외의 불리언 값으로 평가되어야 할 컨텍스트에서 모두 Truthy 값이다.

3. 명시적 타입 변환

3.1. 문자열 타입으로 변환

  1. String 생성자 함수를 new 연산자 없이 호출하는 방법
  2. Object.prototupe.toString 메소드를 사용하는 방법
  3. 문자열 연결 연산자를 사용하는 방법
// 1. String 생성자 함수를 new 연산자 없이 호출하는 방법
// 숫자 타입 => 문자열 타입
console.log(String(1));        // "1"
console.log(String(NaN));      // "NaN"
console.log(String(Infinity)); // "Infinity"
// 불리언 타입 => 문자열 타입
console.log(String(true));     // "true"
console.log(String(false));    // "false"

// 2. Object.prototype.toString 메소드를 사용하는 방법
// 숫자 타입 => 문자열 타입
console.log((1).toString());        // "1"
console.log((NaN).toString());      // "NaN"
console.log((Infinity).toString()); // "Infinity"
// 불리언 타입 => 문자열 타입
console.log((true).toString());     // "true"
console.log((false).toString());    // "false"

// 3. 문자열 연결 연산자를 이용하는 방법
// 숫자 타입 => 문자열 타입
console.log(1 + '');        // "1"
console.log(NaN + '');      // "NaN"
console.log(Infinity + ''); // "Infinity"
// 불리언 타입 => 문자열 타입
console.log(true + '');     // "true"
console.log(false + '');    // "false"

3.2. 숫자 타입으로 변환

  1. Number 생성자 함수를 new 연산자 없이 호출하는 방법
  2. ParsenInt, ParsenFloat 함수를 사용하는 방법(문자열만 변환 가능)
  3. 단항 연결 연산자를 사용하는 방법
  4. 산술 연산자를 사용하는 방법
// 1. Number 생성자 함수를 new 연산자 없이 호출하는 방법
// 문자열 타입 => 숫자 타입
console.log(Number('0'));     // 0
console.log(Number('-1'));    // -1
console.log(Number('10.53')); // 10.53
// 불리언 타입 => 숫자 타입
console.log(Number(true));    // 1
console.log(Number(false));   // 0

// 2. parseInt, parseFloat 함수를 사용하는 방법(문자열만 변환 가능)
// 문자열 타입 => 숫자 타입
console.log(parseInt('0'));       // 0
console.log(parseInt('-1'));      // -1
console.log(parseFloat('10.53')); // 10.53

// 3. + 단항 연결 연산자를 이용하는 방법
// 문자열 타입 => 숫자 타입
console.log(+'0');     // 0
console.log(+'-1');    // -1
console.log(+'10.53'); // 10.53
// 불리언 타입 => 숫자 타입
console.log(+true);    // 1
console.log(+false);   // 0

// 4. * 산술 연산자를 이용하는 방법
// 문자열 타입 => 숫자 타입
console.log('0' * 1);     // 0
console.log('-1' * 1);    // -1
console.log('10.53' * 1); // 10.53
// 불리언 타입 => 숫자 타입
console.log(true * 1);    // 1
console.log(false * 1);   // 0

3.3. 불리언 타입으로 변환

  1. Boolean 생성자 함수를 new 연산자 없이 호출하는 방법
  2. ! 부정 논리 연산자를 두번 사용하는 방법
// 1. Boolean 생성자 함수를 new 연산자 없이 호출하는 방법
// 문자열 타입 => 불리언 타입
console.log(Boolean('x'));       // true
console.log(Boolean(''));        // false
console.log(Boolean('false'));   // true
// 숫자 타입 => 불리언 타입
console.log(Boolean(0));         // false
console.log(Boolean(1));         // true
console.log(Boolean(NaN));       // false
console.log(Boolean(Infinity));  // true
// null 타입 => 불리언 타입
console.log(Boolean(null));      // false
// undefined 타입 => 불리언 타 입
console.log(Boolean(undefined)); // false
// 객체 타입 => 불리언 타입
console.log(Boolean({}));        // true
console.log(Boolean([]));        // true

// 2. ! 부정 논리 연산자를 두번 사용하는 방법
// 문자열 타입 => 불리언 타입
console.log(!!'x');       // true
console.log(!!'');        // false
console.log(!!'false');   // true
// 숫자 타입 => 불리언 타입
console.log(!!0);         // false
console.log(!!1);         // true
console.log(!!NaN);       // false
console.log(!!Infinity);  // true
// null 타입 => 불리언 타입
console.log(!!null);      // false
// undefined 타입 => 불리언 타입
console.log(!!undefined); // false
// 객체 타입 => 불리언 타입
console.log(!!{});        // true
console.log(!![]);        // true

4. 단축 평가 (Short-Circuit evaluation)

'Son' && 'Kane'	// 'Kane'

논리곱 연산자 && 는 두개의 피연산자가 모두 true 일 때 true 를 반환한다.

  1. 첫번째 피연산자 'Son'은 Truthy 값이므로 true 로 평가된다.
    하지만 이 시점까지는 위 표현식을 평가할 수 없고, 두번째 피연산자까지 평가해야 표현식을 평가할 수 있다.
  2. 두번째 피연산자 'Kane' 은 Truthy 값이므로 true 로 평가된다.
    이때 두개의 피연산자가 모두 true 로 평가되었으므로 논리곱 연산의 결과를 결정한 것은 두번째 피연산자 'Kane'이다.
  3. 논리곱 연산자 &&는 논리 연산의 결과를 결정한 두번째 피연산자의 평가 결과 즉, 문자열 ‘Kane’를 그대로 반환한다.
'Son' || 'Kane'	// 'Son'

논리합 연산자 || 는 두개의 피연산자 중 하나만 true 여도 true 를 반환한다.

  1. 첫번째 피연산자 'Son'은 Truthy 값이므로 true 로 평가된다.
    하지만 이 시점에 두번째 피연산자까지 평가해 보지 않아도 위표현식을 평가할 수 있다.
  2. 논리합 연산자 || 는 논리 연산의 결과를 결정한 첫번째 피연산자의 평가 결과 즉, 문자열 ‘Son’를 그대로 반환한다.

논리곱 연산자 &&와 논리합 연산자 ||는 이와 같이 논리 평가를 결정한 피연산자의 평가 결과를 그대로 반환한다.
이를 단축 평가라고 한다.

단축 평가는 아래의 규칙을 따른다.

단축 평가 표현식평가 결과
true || anythingtrue
false || anythinganything
true && anythinganything
false && anythingfalse
// 논리합(||) 연산자
'Son' || 'Kane'  // 'Son'
false || 'Kane'  // 'Kane'
'Son' || false  // 'Son'

// 논리곱(&&) 연산자
'Son' && 'Kane'  // Kane
false && 'Kane'  // false
'Son' && false  // false

단축 평가의 사용 예

  • 객체가 null인지 확인하고 프로퍼티를 참조할 때
let El = null;
console.log(El.value);	// error
console.log(El && El.value); // null

만약 객체가 null 인 경우, 객체의 프로퍼티를 참조하면 타입 에러가 발생하지만,
단축 평가를 사용하면 에러를 발생시키지 않는다.

  • 함수의 인수를 초기화할 때
function stringLength(str) {
	str = str || '';
  	return str.length;
}
stringLength();			// 0
stringLength('Hello');	// 2

함수를 호출할 때 인자를 전달하지 않으면 매개변수는 undefined 를 갖게 되지만,
단축 평가를 사용하여 매개변수의 기본값을 설정하면 에러를 방지할 수 있다.

참고 문헌

PoiemaWeb: 웹 프로그래밍 튜토리얼 https://poiemaweb.com
모던 JavaScript 튜토리얼 https://ko.javascript.info
벨로퍼트와 함께하는 모던 자바스크립트 https://learnjs.vlpt.us
MDN https://developer.mozilla.org/ko/

profile
유동균
이전 포스트

[Javascript] 제어문 (Control Flow)

다음 포스트

[Javascript] 객체 (Object)

0개의 댓글