실무에서 자주 접하게 되는 안티 패턴

안티 패턴

 

안티 패턴

안티패턴(Anti-Pattern)이란 소프트웨어 개발, 설계, 또는 문제 해결에서 비효율적이고 해로운 관행을 말합니다. 코드를 작성할 때, 비효율적이거나 비생산적일 수 있는 방식들을 의미합니다. 코드를 작성할 당시에는 문제가 없어보일 수 있지만, 시간이 지나고 요구 사항이 바뀌면 수정이 매우 어려워질 수 있습니다.

잘못된 방식으로 작성된 코드는 실행 속도와 시스템 전체 성능에도 영향을 미칩니다.

 

대표적인 안티 패턴

1. Spaghetti Code (스파게티 코드)

구조가 없는 복잡하고 뒤얽힌 코드. 이해하기 어렵고, 유지보수가 거의 불가능하고 코드 변경 시 예상치 못한 문제 발생이 가능합니다.

예시

function calculate(value) {
  if (value > 10) {
    if (value < 20) {
      for (let i = 0; i < value; i++) {
        if (i % 2 === 0) {
          // 복잡하고 비직관적인 로직
        }
      }
    }
  }
}

 

2. God Object (신 객체)

하나의 객체가 너무 많은 책임을 가지는 설계 방식. 하나의 객체가 모든 데이터를 관리하여 코드가 비효율적으로 작동. 비효율적인 유지보수 방법입니다.

class AppManager {
  constructor() {
    this.user = null;
    this.db = null;
    this.cache = null;
    this.api = null;
  }

  handleAll() {
    // 모든 일을 처리하는 거대한 메서드
  }
}

 

3. Golden Hammer (황금 망치)

하나의 도구(프레임워크, 기술)를 모든 문제에 적용하려는 경향. 문제에 맞지 않는 도구를 사용하면 비효율의 문제가 발생합니다.

예시

// 모든 문제를 Regular Expression으로 해결하려는 경우
const regex = /some-complicated-pattern/;
if (regex.test(input)) {
  // 너무 과도한 정규식 사용
}

 

4. Hardcoding (하드코딩)

값이나 설정을 코드에 직접적으로 하드코딩. 환경이 변경되면 하드코딩된 여러 군데의 코드를 수정해야 합니다. 재사용성과 유지보수성이 낮습니다.

예시

const apiUrl = "http://example.com/api/v1"; // 하드코딩된 URL

 

5. Premature Optimization (조기 최적화)

필요하지 않은 최적화 작업에 너무 많은 시간과 자원을 소비. 복잡성을 증가시키고, 실제 중요한 문제에 집중하지 못하게 됩니다.

예시

function addNumbers(a, b) {
  // 단순한 연산에 과도한 최적화
  return (a | 0) + (b | 0);
}

 

 

 

6. Singleton Overuse (싱글톤 남용)

싱글톤 패턴을 과도하게 사용하여 모든 곳에서 같은 인스턴스를 공유. 테스트하기 어려워지고, 문제상황에 따라 동시성 문제가 발생할 수 있습니다.

예시

class Database {
  static instance;
  static getInstance() {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }
}

 

---

실무에서 자주 발생하는 성능 하락의 안티 패턴

 

위 예시 처럼 가독성과 유지보수성 측면에서 안티패턴도 많지만, 실무에서 자주 발생하는 성능 하락 측면의 안티 패턴도 있습니다.

안티패턴의 종류는 여러 가지가 있지만, 성능적인 면(불필요한 연산, 비효율적 연산)에 초점을 맞춰서 살펴본 유형입니다.

 

유형 1

불필요한 변수 할당

AS/IS

const output = someData
return output;

TO/BE

return someData;

 

유형 2

불필요한 프로퍼티 호출.

조건문에서도 obj.list.get(key) 조건을 따지면서 .list , get() 함수를 룩업해야 하는데, 하나의 변수를 선언하고 다루면 불필요한 프로퍼티 호출을 막을 수 있다. 

AS/IS

if (obj.list.get(key)) {
	const value = obj.list.get(key)
	console.log(value);
}

TO/BE

const data = obj.list.get(key)
if (data) {	
	console.log(data);
}

 

유형 3

arr.length 를 매 인덱스마다 확인하게 됩니다. 만약 변경되지 않은 수라면 변수에 선언해두고 프로퍼티 호출 반복을 막을 수 있습니다.

AS/IS

for (let i = 0; i < arr.length; i++) {
	console.log(arr[i]);
}

 

TO/BE

const length = arr.length; // 프로퍼티 호출을 반복하지 않도록.
for (let i = 0; i < length; i++) { 
	console.log(arr[i]);
}

 

유형 4

분기문 남용. 너무 많은 else if 문은 성능의 문제와 가독성의 문제를 야기시킵니다. switch 문을 활용한다면 Lookup Table 또는 Jump Table 에서 한번에 찾을 수 있습니다. 비슷한 방식으로 Map 을 활용하면 가독성과 else if 를 계속 확인하는 성능 문제를 해결할 수 있습니다.

AS/IS

function getLocalizedErrorMessage(errorCode: number, language: string): string {
  if (language === "en") {
    if (errorCode === 400) {
      return "Bad Request";
    } else if (errorCode === 401) {
      return "Unauthorized";
    } else if (errorCode === 404) {
      return "Not Found";
    } else {
      return "Unknown Error";
    }
  } else if (language === "ko") {
    if (errorCode === 400) {
      return "잘못된 요청";
    } else if (errorCode === 401) {
      return "인증되지 않음";
    } else if (errorCode === 404) {
      return "찾을 수 없음";
    } else {
      return "알 수 없는 오류";
    }
  } else {
    return "Unknown Error"; // 지원되지 않는 언어
  }
}

TO/BE

const localizedErrorMessages: Map<string, Map<number, string>> = {
  en: {
    400: "Bad Request",
    401: "Unauthorized",
    404: "Not Found",
  },
  ko: {
    400: "잘못된 요청",
    401: "인증되지 않음",
    404: "찾을 수 없음",
  },
};

function getLocalizedErrorMessage(errorCode: number, language: string): string {
  return localizedErrorMessages[language]?.[errorCode] ?? "Unknown Error";
}

 

유형 5

불필요한 인스턴스 생성.

execute({}); 에서 불필요하게 {}를 생성하고 있습니다. 인스턴스는 heap 영역에 로드되고, GC 에 처리됩니다. GC 활동 자체도 오버헤드를 발생시키기 때문에 불필요한 인스턴스를 되도록 생성하지 않는 게 좋습니다.

 

AS/IS

interface IStateRequest {
	info_list?: InfoListType[];
}

// ----

const state_program = ProgramBuilder.create<IStateRequest, void>(
    IStateProgram,
    execution_context
);

const { group_data } = state_program.execute({});

TO/BE

type RequestType = IStateRequest | undefined;

const { group_data } = state_program.execute(); // 유니온타입을 활용하여, 불필요한 객체인스턴스 생성 방지

 

유형 6

불필요한 인스턴스 생성.

let resultItemJson: any = {}; 에서 선언만 해도 되는데, 불필요한 빈 객체를 할당하고 있습니다.

또한 else 에서도 불필요한 인스턴스를 계속 생성하고 있습니다.

AS/IS

let resultItemJson: any = {};
if (state.attribute_set_sid) {
    resultItemJson = JSON.parse(state.result_item_json);
} else {
    resultItemJson = {
        option_one: '0',
        option_two: '0',
        option_three: '0',
        sequence_one: '1',
        sequence_two: '2',
        sequence_three: '3',
    };
}

TO/BE

const default_result = { // 싱글톤 객체
    option_one: '0',
    option_two: '0',
    option_three: '0',
    sequence_one: '1',
    sequence_two: '2',
    sequence_three: '3',
};

let resultItemJson: any; // 변수 선언만
if (state.attribute_set_sid) {
    resultItemJson = JSON.parse(state.result_item_json);
} else {
    resultItemJson = default_result; // 싱글톤 객체 재활용 (외부 수정 방지를 위해 Object.freeze 고려 가능)
}

 

유형 7

부적절한 자료 구조 활용.

전자의 경우 배열을 통해 원하는 값을 찾는 방법입니다. 이는 O(N) 의 시간복잡도를 갖습니다. 만약 Set 자료구조를 활용하게 된다면 해시 함수를 통해 더욱 빠르게 원하는 값을 탐색할 수 있습니다.

AS/IS

function isAllowed(value: string): boolean {
  const allowedValues = ["apple", "banana", "cherry", "date", "elderberry"];
  return allowedValues.includes(value);
}

TO/BE

const allowedValues = new Set(["apple", "banana", "cherry", "date", "elderberry"]);

function isAllowed(value: string): boolean {  
  return allowedValues.has(value);
}

 

유형 8

부적절한 함수 사용.

forEach 함수는 내부적으로 Iterator 객체를 반환 받아 반복문을 돌리게 됩니다. Iterator 인스턴스를 만드는 것부터 오버헤드를 발생시킵니다. forEach는 배열의 각 요소마다 콜백 함수를 호출합니다. 함수 호출에는 스택 프레임 생성 및 해제 등의 오버헤드가 있으므로 for보다 느릴 수 있습니다.

map 함수를 사용하면 일반적인 반복문을 사용하면서 배열에 직접적으로 push 하고 배열을 반환해줍니다. 이는 forEach 를 활용하는 것보다 성능면에서 효율적입니다.

AS/IS

 

const { source_list } = example_program.execute(request);
const result_list = [];

source_list.forEach((source) => {
        result_list.push({
            tenant_sid: source.com_code,
            name: source.nm,
        });
});

TO/BE

const { source_list } = example_program.execute(request);
const result_list = source_list.map((source) => {
        return {
            tenant_sid: source.com_code,
            name: source.nm,
        }
});

 

유형 9

비효율적인 문자열 결합.

문자열을 결합할 때 + 연산자를 활용하게 되면 StringBuilder 를 활용하여 연산하는 것보다 더 높은 오버헤드와 메모리를 사용하게 됩니다. 

AS/IS

for (let j = 1; j <= 70; j++) {
    console.log("column" + j);
}

TO/BE

for (let j = 1; j <= 70; j++) {
    console.log(`column${j}`);
}

 

---

안티패턴을 피하는 방법

1. SOLID 원칙 준수
   • 객체 지향 설계 원칙(SOLID)을 따르면, 코드 유지보수성과 재사용성이 높아지고 안티패턴을 피할 수 있습니다.
2. 코드 리뷰
   • 팀원들과 코드 리뷰를 통해 설계나 구현 상의 문제점을 사전에 발견.
3. 테스트 작성
   • 코드가 특정 상황에서 예상대로 동작하는지 확인하며 안티패턴 발생 방지.
4. 기술 이해 심화
   • 사용하는 기술의 장단점을 깊이 이해하고 적절히 적용.
5. 유연성 확보
   • 하드코딩 대신 환경 변수, 설정 파일 등을 사용하여 유연성을 유지.