์ฐ๋ฆฐ ์ด๋ป๊ฒ โabcโ์ toUpperCase๋ฅผ ์ฌ์ฉํ ์ ์์๊น?

๐ ์๋ฌธ์
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ ์ค ๋ฌธ์์ด โabcโ๋ฅผ ๋๋ฌธ์๋ก ๋ณํํ๋ ํจ์ toUpperCase๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
์ฌ์ฉ๋ง ํ๋ค๊ฐ ๊ฐ์๊ธฐ ๋ฌธ๋ ์๋ฌธ์ด ๋ค์๋ค.
โabcโ ๋ฐ์ดํฐ ํ์ ์ ๋น์ฐํ๊ฒ๋ ๊ฐ์ฒด๋ ์๋๊ณ ๋ฌธ์์ด์ธ๋ฐ, ์ด๋ป๊ฒ toUpperCase๋ผ๋ ๋ฉ์๋๋ฅผ ๊ฐ์ง ์ ์๋ ๊ฑฐ์ง?
console.log(typeof "abc") // string
๐ ์โฆ ์์๊ฐ์ ๊ฐ์ฒด์ฒ๋ผ ๋ค๋ฃฐ ์ ์๋ค๊ณ ?
์๋ฐ์คํฌ๋ฆฝํธ์์ ๊ฐ์ฒด๋ ๋ค๋ฅธ ์ธ์ด์์ ๋ถ๋ฅด๋ ํด๋์ค์ ๊ฐ์ด ๋ค์ํ ๊ฐ๊ณผ ๋ฉ์๋๋ฅผ ์์งํ์ํฌ ์ ์๊ฒํ๋ ๋ฐ์ดํฐ ํ์ ์ด๋ค.
๋ค์ํ ์ข ๋ฅ์ ๊ฐ์ ํ๋กํผํฐ๋ก ๊ฐ์ง ์ ์๊ณ , ๋ด๋ถ์ ๋ฉ์๋๋ฅผ ์ถ๊ฐํด ๊ฐ์ฒด ์์ฒด๋ฅผ ๋ค๋ฃฐ ์ ์๋ค..
const ๋๋ค๋ฌธ์ = new Object();
๋๋ค๋ฌธ์.value = "abc";
๋๋ค๋ฌธ์.toUpperCase = function (){
// value๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊พธ๋ ์๊ณ ๋ฆฌ์ฆ ...
return this.value
}
ํ์ง๋ง ์์ํ (์ฌ๊ธฐ์ ๊ฐ๋ฆฌํค๋ ๋ฌธ์์ด)์ ๊ฐ์ฒด ํํ๊ฐ ์๋๊ธฐ์ ๊ฐ์ฒด๋ฅผ ๋ค๋ฃจ๋ ๋ฉ์๋๋ฅผ ๊ตฌํํ ์ ์์ด,
๊ตฌํํ๋ ค๋ ๋ก์ง์ ์ธ๋ถ์ ์์ํด์ผ ํ๋ค๋ ํ๊ณ๊ฐ ์์๊ณ ,
๊ทธ๋์ ์๋ฐ์คํฌ๋ฆฝํธ ์ฐฝ๋ฆฝ์๋ ๋ค์๊ณผ ๊ฐ์ด ์์๊ฐ์ ๊ฐ์ฒด๋ก ๋ค๋ฃฐ ์ ์๋ ์ฅ์น๋ฅผ ์ถ๊ฐํ๊ฒ ๋๋ค.
1. ์์๊ฐ์ ์ ์ธํ๋ค.
2. ์๋ฐ์คํฌ๋ฆฝํธ๊ฐ ์์๊ฐ์ ๋ฉ์๋(์ง๊ธ ์์ ์์ toUpperCase)์ ์ ๊ทผํ๋ ค๋ ์๋๋ฅผ ํ์ฉํ๋ค.
3.1. toUpperCase()๊ฐ ํธ์ถ๋ ๋ฐํ์์์ ๋ด๋ถ์ ์ผ๋ก toUpperCase๋ฅผ ๊ฐ์ง Object wrapper ๊ฐ์ฒด ์์ฑ
3.2. toUpperCase ๋ฉ์๋ ์คํ
3.3. ์คํ ํ ๊ฒฐ๊ด๊ฐ ๋ฐํ
3.4. ๊ณผ์ a์์ ์์ฑํ ๊ฐ์ฒด ํ๊ดด
3.5. ๋ฐํ๋ ๊ฒฐ๊ด๊ฐ๋ง ์์กด.
์ ์ฅ์น๋ค๋ก ์ธํด ์์ํ์ ์๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋๋ค. ๊ณ ๋ฏผ ํด๊ฒฐ ๋ ๋ ๋
๐ ์๋์น ์์ Object wrapper์ ์์ฑ?
์๋ฐ์คํฌ๋ฆฝํธ๋ ์์๊ฐ์ ๋ฉ์๋๋ฅผ ์ ๊ทผํ๋ ค๋ ์๋๋ฅผ ํ์ฉํ๋ค.
'use strict';
let name = "์ก๊ฐ"
name.sayHi = function(){console.log('hi')}
console.log(name.sayHi) // undefined
๋ฐ๋ผ์ ์ ์์์ ๊ฐ์ด ์์์ ๋ฌธ์์ด name์ sayHi๋ผ๋ ํจ์๋ฅผ ํ๋กํผํฐ๋ก ์ถ๊ฐํ๋ ค ํ๋ค๋ฉด, ๋ค์์ ๊ณผ์ ์ ๊ฑฐ์น๊ฒ ๋๋ค.
- ์์๊ฐ name์ sayHi๋ผ๋ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด์ Wrapper Object๊ฐ ์์ฑ
- sayHi๋ฅผ ๋ฉ์๋๋ฅผ ๊ฐ์ง Wrapper Object๊ฐ ๋ฐ๋ก ์ญ์ ๋จ
- sayHi ๋ฉ์๋๋ฅผ ๋ค์ ์ฐพ์ ์ ์์ด undefined ์ถ๋ ฅ
์์ ๊ฐ์ ์ด์๋ฅผ ์ฌ์ ์ ๋ฐฉ์งํ๊ธฐ ์ํด strict mode๋ฅผ ํ์ฑํ์ํฌ ์ ์๋ค. ๊ทธ๋ ๊ฒ ๋๋ฉด Wrapper Object๊ฐ ์์ฑ๋์ง๋ง, readonly์ธ ๊ฐ์ฒด์ sayHi๋ผ๋ ๋ฉ์๋๋ฅผ ์ถ๊ฐํ๋ ค๋ ์๋๊ฐ ์ฌ์ ์ ์ฐจ๋จ๋์ด ์๋ฌ๋ฅผ ๋ณด์ฌ์ฃผ๊ฒ ๋๋ค.
๐ ํ์ฅ ๊ณต๋ถ: ์๊ธธ ์ ์๋ ๋ฌธ์ ์ ๋ํ ๊ณ ๋ฏผ
์ ๊ฐ๋ ๊ณผ ์ฐ๊ฒฐ ์ง์ด ๋ฌธ์์ด ๊ฐ์ฒด์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด ์ ์ธ ๊ณผ์ ์ ๋ด๋ณด์.
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ๊ทธ ์์ฒด๋ก string ํ์ ์ ๊ฐ๊ณ , ์์ฑ์๋ฅผ ํตํด ์์ฑํ ๋ฌธ์์ด ๊ฐ์ฒด๋ object ํ์ ์ ๊ฐ๋๋ค.
console.log(typeof "abc") // string
console.log(typeof new String("abc")) // object
์๋์ ์ผ๋ก ๋ง๋ welcome ํจ์๋ฅผ ๋ฉ์๋๋ก ๊ฐ์ง ๋ฌธ์์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ , ์ด ๋ฌธ์์ด ๊ฐ์ฒด์ prototype์ welcome ํจ์๋ก ์ค์ ํ๋ ์์์ด๋ค. ์ด๋ toUpperCase()๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ฅผ ์์ํด ๋ณด์.
let name = new String("song kang")
String.prototype.welcome = function(){
console.log(this + " ์
๋๋ค") // song kang ์
๋๋ค
}
name.welcome()
์์ฑํ name ๊ฐ์ฒด์ toUpperCase()๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด, toUpperCase ๋ฉ์๋๊ฐ ๋ฐํํ ๊ฒฐ๊ณผ๊ฐ๋ง์ด ์์กด๋๊ณ ๋๋จธ์ง ๊ฐ์ฒด๋ ํ๊ดด๋๋ค. ์ด ๊ฐ์ ์ค๋ฒ๋ผ์ด๋ฉ ์ํจ๋ค๋ฉด ๋ฌธ์์ด๋ก ํ๋ณํ์ด ์ผ์ด๋๋ฉฐ ์ด์ ์ ๋ง๋ welcome ํจ์๋ ์ฌ๋ผ์ง๊ฒ ๋๋ค!
console.log(typeof name) // object
console.log(typeof name.toUpperCase()) // string
๋ฌผ๋ก ์ด๋ฐ ์๋๋ฆฌ์ค๋ฅผ ๋น๋ฒํ ๋ง์ฃผํ๊ฒ ๋ ๊ฒ์ด๋ผ ์์ํ์ง ์์ง๋ง... ์ด ํ๋ณํ์ ๋ง์ ์ ์๋ ๋ฐฉ๋ฒ์ ๋ํด ๊ณ ๋ฏผํด๋ณด๊ณ ์ถ์๋ค.
๐ ํ์ฅ ๊ณต๋ถ: ์ด๋ป๊ฒ ํด๊ฒฐํ ์ ์์๊น?
- Object freeze๋ก ๊ฐ์ฒด ๋๊ฒฐ โ
๊ฐ์ฒด๋ฅผ ๋๊ฒฐ์ํค๋ Object.freeze() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์์ฑ์ด ์ถ๊ฐ๋๊ณ ์ ๊ฑฐ๋๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ์ ๋ถ๋ณ์ฑ์ ์ ์งํ๋ค๊ณ ์๊ณ ์๋ค.
ํ์ง๋ง ์ด ๊ฒฝ์ฐ์์ ๊ฐ์ฒด์ ํํ๋ฅผ ๋ณํํ๋ ๊ฒ์ด ์๋ ํ์
์ด ์บ์คํ
๋๋ ๊ฒ์ด๊ธฐ์ ์ ์ฉ์ด ๋ถ๊ฐํ๋ค.
- ๋ฉ์๋ Overriding โ
์ฐ๋ฆฌ๋ ์์ฑ์ 'ํจ์' (๋๋ new ์ฐ์ฐ์)๋ฅผ ํตํด ๋ง๋ ๊ฐ์ฒด๋ ์์ฑ์ ํจ์์ ํ๋กํ ํ์ ์ ๋ณด๋ฅผ ์ฌ์ฉํด Prototype์ ์ค์ ํ ์ ์๋ค.
์ด ํน์ฑ์ ํ์ฉํด, ํ๋ณํ์ด ์ผ์ด๋๋ ๊ฒฝ์ฐ๋ฅผ ์ ์ด์ ๋ฐฉ์งํ๋ ์ฐจ์์์ String ์ธ์คํด์ค์ ์ถ๊ฐํ๋ ค๋ ๋ฉ์๋๋ฅผ prototype ์ ์ ์ ์ฌ์ด์ค ์ ์๋ค. ์ฌ๊ธฐ์ toUpperCase๋ String ๊ฐ์ฒด์ property๊ฐ์ ํฌํจ๋ ๋ฉ์๋์ด๋ค.
String.prototype.toUpperCase()
์๋ฐ์คํฌ๋ฆฝํธ Class ๋ฌธ๋ฒ์ด ๋ฑ์ฅํ ์ด๋๋ก Prototype์ ๊ฑฐ์ ์ฌ์ฉ๋์ง ์๋๋ค๊ณ ํ์ง๋ง, ํด๋์ค ๊ฐ๋ ์ ๋์ ํ์์ ๋,
String์ด๋ผ๋ ํด๋์ค๊ฐ ๊ฐ์ง toUpperCase ๋ฉ์๋๋ฅผ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋๋ก Overriding ํ ์ ์์ง ์์๊น?๋ผ๋ ์๊ฐ์ด ๋ค์๋ค.
toUpperCase ํจ์๋ฅผ ์ฌ์ ์ ํ์ง ์๊ณ ์์ผ ๊ฒฐ๊ด๊ฐ์ ๋ฐ๊ฟ ์ ์๊ธฐ์, ์ฐจ์ ์ฑ ์ผ๋ก toUpperCase ๋ฉ์๋๊ฐ ๋ฐํํ๋ ๊ฒฐ๊ณผ๊ฐ์ ์๋ก์ด String ์์ฑ์์ ๋ด์ ๋ฐํํ๋ค๋ฉด, ๋ชจ๋ String์ prototype ๋ฉ์๋๋ฅผ ์์๋ฐ์ ๋ฌธ์์ด ๊ฐ์ฒด๋ฅผ ๋ฐํํ ์ ์๊ฒ ๋ค๊ณ ์๊ฐํ๋ค.
const x = new String("hello")
String.prototype.welcome = function(){
console.log(this + " ์
๋๋ค")
}
String.prototype._toUpperCase = function(){ // ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ์ปค์คํ
toUpperCase ํจ์
const newStr = String.prototype.toUpperCase()
return new String(newStr)
}
console.log(x._toUpperCase())
console.log(typeof x)
console.log(typeof x._toUpperCase())
๐ ๋๋ ์
๋ง๋ก ์ธํ ๊ฒฐ๊ณผ๋ฅผ ํ์๊ฐ ์ฑ ์์ง๋ฏ, ๊ฐ๋ฐ์๋ก์ ๋ฐ์ํ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ๊ณ ์ฝ๋๋ฅผ ์ง๋ ๊ฒ์ด ์ค์ํ๋ค๊ณ ์๊ฐํ๋ค. ์ด๋ฅผ ์ํด ๋จ์ํ ๋ชจ๋ ๊ฒฐ๊ณผ๋ฅผ โ๋ง๋ฒโ์ด ์๋ โ๊ณผํโ์ผ๋ก ๋ฐ๋ผ๋ณด๋ ์๊ฐ์ ๊ฐ๋ ๊ฒ ์ค์ํ๋ค๋ ์๊ฐ์ด ๋ค์๋ค.
์ฐธ๊ณ ์๋ฃ:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase
https://developer.mozilla.org/ko/docs/Web/JavaScript/Memory_Management
https://ko.javascript.info/function-prototype
https://ko.javascript.info/primitives-methods