๐Ÿ“œ ๋ชฉ์ฐจ

์•Œ๊ณ ๋ฆฌ์ฆ˜

์Šคํ‚ฌํŠธ๋ฆฌ

NestJS

Jest / TDD

Generic / Utility Type

์•Œ๊ณ ๋ฆฌ์ฆ˜


๐Ÿ’ญ ์Šคํ‚ฌํŠธ๋ฆฌ

// ์„ ํ–‰ ์Šคํ‚ฌ์ด๋ž€ ์–ด๋–ค ์Šคํ‚ฌ์„ ๋ฐฐ์šฐ๊ธฐ ์ „์— ๋จผ์ € ๋ฐฐ์›Œ์•ผ ํ•˜๋Š” ์Šคํ‚ฌ์„ ๋œปํ•ฉ๋‹ˆ๋‹ค.
// ์˜ˆ๋ฅผ ๋“ค์–ด ์„ ํ–‰ ์Šคํ‚ฌ ์ˆœ์„œ๊ฐ€ ์ŠคํŒŒํฌ โ†’ ๋ผ์ดํŠธ๋‹ ๋ณผํŠธ โ†’ ์ฌ๋”์ผ๋•Œ, 
// ์ฌ๋”๋ฅผ ๋ฐฐ์šฐ๋ ค๋ฉด ๋จผ์ € ๋ผ์ดํŠธ๋‹ ๋ณผํŠธ๋ฅผ ๋ฐฐ์›Œ์•ผ ํ•˜๊ณ , ๋ผ์ดํŠธ๋‹ ๋ณผํŠธ๋ฅผ ๋ฐฐ์šฐ๋ ค๋ฉด ๋จผ์ € ์ŠคํŒŒํฌ๋ฅผ ๋ฐฐ์›Œ์•ผ ํ•ฉ๋‹ˆ๋‹ค.

// ์œ„ ์ˆœ์„œ์— ์—†๋Š” ๋‹ค๋ฅธ ์Šคํ‚ฌ(ํž๋ง ๋“ฑ)์€ ์ˆœ์„œ์— ์ƒ๊ด€์—†์ด ๋ฐฐ์šธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 
// ๋”ฐ๋ผ์„œ ์ŠคํŒŒํฌ โ†’ ํž๋ง โ†’ ๋ผ์ดํŠธ๋‹ ๋ณผํŠธ โ†’ ์ฌ๋”์™€ ๊ฐ™์€ ์Šคํ‚ฌํŠธ๋ฆฌ๋Š” ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, 
// ์ฌ๋” โ†’ ์ŠคํŒŒํฌ๋‚˜ ๋ผ์ดํŠธ๋‹ ๋ณผํŠธ โ†’ ์ŠคํŒŒํฌ โ†’ ํž๋ง โ†’ ์ฌ๋”์™€ ๊ฐ™์€ ์Šคํ‚ฌํŠธ๋ฆฌ๋Š” ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

// ์„ ํ–‰ ์Šคํ‚ฌ ์ˆœ์„œ skill๊ณผ ์œ ์ €๋“ค์ด ๋งŒ๋“  ์Šคํ‚ฌํŠธ๋ฆฌ1๋ฅผ ๋‹ด์€ ๋ฐฐ์—ด skill_trees๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, 
// ๊ฐ€๋Šฅํ•œ ์Šคํ‚ฌํŠธ๋ฆฌ ๊ฐœ์ˆ˜๋ฅผ return ํ•˜๋Š” solution ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.

// ์Šคํ‚ฌ์€ ์•ŒํŒŒ๋ฒณ ๋Œ€๋ฌธ์ž๋กœ ํ‘œ๊ธฐํ•˜๋ฉฐ, ๋ชจ๋“  ๋ฌธ์ž์—ด์€ ์•ŒํŒŒ๋ฒณ ๋Œ€๋ฌธ์ž๋กœ๋งŒ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.
// ์Šคํ‚ฌ ์ˆœ์„œ์™€ ์Šคํ‚ฌํŠธ๋ฆฌ๋Š” ๋ฌธ์ž์—ด๋กœ ํ‘œ๊ธฐํ•ฉ๋‹ˆ๋‹ค.
// ์˜ˆ๋ฅผ ๋“ค์–ด, C โ†’ B โ†’ D ๋ผ๋ฉด "CBD"๋กœ ํ‘œ๊ธฐํ•ฉ๋‹ˆ๋‹ค
// ์„ ํ–‰ ์Šคํ‚ฌ ์ˆœ์„œ skill์˜ ๊ธธ์ด๋Š” 1 ์ด์ƒ 26 ์ดํ•˜์ด๋ฉฐ, ์Šคํ‚ฌ์€ ์ค‘๋ณตํ•ด ์ฃผ์–ด์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
// skill_trees๋Š” ๊ธธ์ด 1 ์ด์ƒ 20 ์ดํ•˜์ธ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค.
// skill_trees์˜ ์›์†Œ๋Š” ์Šคํ‚ฌ์„ ๋‚˜ํƒ€๋‚ด๋Š” ๋ฌธ์ž์—ด์ž…๋‹ˆ๋‹ค.
// skill_trees์˜ ์›์†Œ๋Š” ๊ธธ์ด๊ฐ€ 2 ์ด์ƒ 26 ์ดํ•˜์ธ ๋ฌธ์ž์—ด์ด๋ฉฐ, ์Šคํ‚ฌ์ด ์ค‘๋ณตํ•ด ์ฃผ์–ด์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

function solution(skill, skill_trees) {
    let answer = 0
    
    for(let i = 0 ; i <skill_trees.length; i++ ){
        let filter =""
        for(let l = 0; l < skill_trees[i].length; l++){
            if( skill.includes(skill_trees[i][l]) ) {
                filter += skill_trees[i][l]   
            }
        }
				// ์„ ํ–‰ ์Šคํ‚ฌํŠธ๋ฆฌ ์กฐ๊ฑด์ด ํ•˜๋‚˜๋„ ์„ฑ๋ฆฝํ•˜์ง€ ์•Š๋Š” ์Šคํ‚ฌํŠธ๋ฆฌ์ผ ๋•Œ,
        // ๋ฌด์กฐ๊ฑด ๊ฐ€๋Šฅํ•œ ์Šคํ‚ฌํŠธ๋ฆฌ๋ฅผ ๋งŒ๋“ค์–ด์ฃผ๊ธฐ ์œ„ํ•ด, skill ๋ฐ์ดํ„ฐ๋ฅผ ํ• ๋‹นํ•œ๋‹ค.
        if( filter === "") filter = skill
        if ( skill.includes( filter ) ) {
            if( skill.indexOf( filter[0] ) === 0 ){
                // ๊ฐ€๋Šฅํ•œ ์Šคํ‚ฌํŠธ๋ฆฌ๋‹ค~
                answer++
            }
        }
    }
    return answer
}

// reduce() ์‚ฌ์šฉํ•œ ํ’€์ด
function solution(skill, skill_trees) {
    return skill_trees.reduce( ( acc,cur ) => {
        const filter = cur.split("").filter( str => {
            return skill.includes( str )
        }).join("")
        
        return acc += ( skill.includes( filter ) && 
                     skill.indexOf( filter[0]) === 0 ||
                     filter === "" ) ? 1: 0 
    }, 0)
}

NestJS


1. Jest / TDD

<aside> ๐Ÿค” ์™œ ํ…Œ์ŠคํŠธ์ฝ”๋“œ๋ฅผ ์จ์•ผ ํ•˜๋Š”๋ฐ? ๋ชฐ๋ผ ๋”ด์ง“ํ•˜๋Š๋ผ ๋ชป๋“ค์—ˆ์–ด

</aside>

๐Ÿ’ปย  ์‹ค์Šต - Jest ์‹ค์Šต

// 1. ํ•œ ๊ฐœ ํ…Œ์ŠคํŠธ ํ•˜๊ธฐ 
it("๋”ํ•˜๊ธฐ ํ…Œ์ŠคํŠธ", () => {
    const a = 1
    const b = 2
    
    expect(a+b).toBe(3)
})

// 2. ์—ฌ๋Ÿฌ๊ฐœ ๋ฌถ์Œ์œผ๋กœ ํ…Œ์ŠคํŠธํ•˜๊ธฐ
describe("๋‚˜์˜ ํ…Œ์ŠคํŠธ ๊ทธ๋ฃน", () => {
    it("๋”ํ•˜๊ธฐ ํ…Œ์ŠคํŠธ", () => {
        const a = 1
        const b = 2
        
        expect(a+b).toBe(3)
    })

    it("๊ณฑํ•˜๊ธฐ ํ…Œ์ŠคํŠธ", () => {
        const a = 1
        const b = 2
        
        expect(a*b).toBe(2)
    })
})