1
// (1) 데이터 결합이 높은 예제=======================
2
function calculateTotalAndTax(price, taxRate) {
3
  const total = price + (price * taxRate);
4
  console.log(`Total: ${total}`);
5
}
6

7
calculateTotalAndTax(100, 0.1); // Total: 110
8

9
👇
10
// (2) 데이터 결합이 낮은 예제========================
11
function calculateTotalAndTax(price, taxRate) {
12
  const total = price + (price * taxRate);
13
  console.log(`Total: ${total}`);
14
}
15

16
const priceValue = 100;
17
const taxRateValue = 0.1;
18

19
calculateTotalAndTax(priceValue, taxRateValue); // Total: 110

1
// 주문 생성 모듈
2
const orderCreator = {
3
  createOrder: (customerName, product, quantity) => {
4
    const order = {
5
      customerName,
6
      product,
7
      quantity,
8
    }
9
    orderProcessor.processOrder(order)
10
  },
11
}
12

13
// 주문 처리 모듈
14
const orderProcessor = {
15
  processOrder: order => {
16
    console.log(`Processing order for ${order.customerName}: ${order.quantity} ${order.product}`)
17
    // 주문 처리 로직
18
  },
19
}
20

21
orderCreator.createOrder('John Doe', 'Widget', 3)

1
// 컨트롤 결합이 있는 예제
2
function validateUser(username, password) {
3
  // 사용자 유효성 검사 로직
4
  if (username === 'admin' && password === 'password') return true
5
  else return false
6
}
7

8
function login(username, password) {
9
  if (validateUser(username, password)) {
10
    console.log('로그인 성공')
11
    // 로그인 후 작업 수행
12
  } else {
13
    console.log('로그인 실패')
14
    // 로그인 실패 시 작업 수행
15
  }
16
}
17

18
login('admin', 'password')

1
// 외부 결합이 있는 예제
2
const database = require('external-database-library')
3

4
function fetchUserData(userId) {
5
  // 외부 데이터베이스에 직접 접근
6
  const userData = database.fetchUser(userId)
7
  return userData
8
}
9

10
const userId = 123
11
const userData = fetchUserData(userId)
12

13
console.log(`User data: ${userData}`)

1
// 공통 결합이 있는 예제
2
// 모듈 1
3
const module1 = {
4
  data: [],
5

6
  addData: function (item) {
7
    this.data.push(item)
8
  },
9
}
10

11
// 모듈 2
12
const module2 = {
13
  processData: function () {
14
    for (const item of module1.data) {
15
      // 모듈 1의 데이터에 의존
16
      console.log(`Processing data: ${item}`)
17
    }
18
  },
19
}
20

21
module1.addData('Item 1')
22
module1.addData('Item 2')
23
module2.processData()

1
// 컨텐츠 결합이 있는 예제
2
// 모듈 1
3
const module1 = {
4
  data: [1, 2, 3],
5

6
  // 모듈 2의 내부 데이터 구조에 직접 접근하여 변경
7
  modifyData: function () {
8
    module2.data.push(4)
9
  },
10
}
11

12
// 모듈 2
13
const module2 = {
14
  data: [4, 5, 6],
15
}
16

17
console.log('Before modification:')
18
console.log('Module 1 data:', module1.data)
19
console.log('Module 2 data:', module2.data)
20

21
// 모듈 1이 모듈 2의 데이터 구조를 변경
22
module1.modifyData()
23

24
console.log('After modification:')
25
console.log('Module 1 data:', module1.data)
26
console.log('Module 2 data:', module2.data)

1
// 기능 응집이 높은 예제
2
// 주문 관리 모듈
3
const orderManager = {
4
  orders: [],
5

6
  // 주문 추가
7
  addOrder: function (customerName, product, quantity) {
8
    const order = {
9
      customerName,
10
      product,
11
      quantity,
12
    }
13
    this.orders.push(order)
14
  },
15

16
  // 주문 목록 출력
17
  printOrders: function () {
18
    console.log('주문 목록:')
19
    for (const order of this.orders) {
20
      console.log(`${order.customerName}: ${order.quantity} ${order.product}`)
21
    }
22
  },
23
}
24

25
// 주문 추가
26
orderManager.addOrder('John Doe', 'Widget', 3)
27
orderManager.addOrder('Alice Smith', 'Gadget', 2)
28

29
// 주문 목록 출력
30
orderManager.printOrders()

1
// 순차 응집이 있는 예제
2
// 주문 처리 모듈
3
const orderProcessor = {
4
  processOrder: function (order) {
5
    console.log(`주문 처리 시작: ${order.orderNumber}`)
6
    this.validateOrder(order)
7
    this.calculateTotal(order)
8
    this.confirmOrder(order)
9
    console.log(`주문 처리 완료: ${order.orderNumber}`)
10
  },
11

12
  validateOrder: function (order) {
13
    console.log(`주문 유효성 검사: ${order.orderNumber}`)
14
    // 주문 유효성 검사 로직
15
  },
16

17
  calculateTotal: function (order) {
18
    console.log(`주문 금액 계산: ${order.orderNumber}`)
19
    // 주문 금액 계산 로직
20
  },
21

22
  confirmOrder: function (order) {
23
    console.log(`주문 확인: ${order.orderNumber}`)
24
    // 주문 확인 로직
25
  },
26
}
27

28
// 주문 데이터
29
const order1 = {
30
  orderNumber: '12345',
31
  // 다른 주문 정보들
32
}
33

34
const order2 = {
35
  orderNumber: '67890',
36
  // 다른 주문 정보들
37
}
38

39
// 주문 처리
40
orderProcessor.processOrder(order1)
41
orderProcessor.processOrder(order2)

1
// 통신 응집이 있는 예제
2

3
// 메시지 전송 모듈
4
const messageSender = {
5
  sendMessage: function (message, recipient) {
6
    console.log(`메시지 전송: "${message}" to ${recipient}`)
7
    // 메시지 전송 로직
8
  },
9
}
10

11
// 로그 모듈
12
const logger = {
13
  logMessage: function (message) {
14
    console.log(`로그: "${message}"`)
15
    // 로그 기록 로직
16
  },
17
}
18

19
// 알림 모듈
20
const notifier = {
21
  sendNotification: function (message, recipient) {
22
    console.log(`알림: "${message}" to ${recipient}`)
23
    // 알림 전송 로직
24
  },
25
}
26

27
// 메시지 전송
28
messageSender.sendMessage('안녕하세요!', 'John Doe')
29

30
// 로그 기록
31
logger.logMessage('사용자가 로그인했습니다.')
32

33
// 알림 전송
34
notifier.sendNotification('새 메시지가 도착했습니다.', 'Alice Smith')

1
// 프로시저 응집이 있는 예제
2
// 주문 처리 모듈
3
function processOrder(order) {
4
  console.log(`주문 처리 시작: ${order.orderNumber}`)
5
  validateOrder(order)
6
  calculateTotal(order)
7
  confirmOrder(order)
8
  console.log(`주문 처리 완료: ${order.orderNumber}`)
9
}
10

11
function validateOrder(order) {
12
  console.log(`주문 유효성 검사: ${order.orderNumber}`)
13
  // 주문 유효성 검사 로직
14
}
15

16
function calculateTotal(order) {
17
  console.log(`주문 금액 계산: ${order.orderNumber}`)
18
  // 주문 금액 계산 로직
19
}
20

21
function confirmOrder(order) {
22
  console.log(`주문 확인: ${order.orderNumber}`)
23
  // 주문 확인 로직
24
}
25

26
// 주문 데이터
27
const order1 = {
28
  orderNumber: '12345',
29
  // 다른 주문 정보들
30
}
31

32
const order2 = {
33
  orderNumber: '67890',
34
  // 다른 주문 정보들
35
}
36

37
// 주문 처리
38
processOrder(order1)
39
processOrder(order2)

1
// 시간 응집이 있는 예제
2

3
// 주문 처리 모듈
4
const orderProcessor = {
5
  processOrder: function (order) {
6
    console.log(`주문 처리 시작: ${order.orderNumber}`)
7
    // 주문 처리 작업
8
    this.logOrderProcessingTime()
9
  },
10

11
  logOrderProcessingTime: function () {
12
    console.log('주문 처리 시간 기록')
13
    // 주문 처리 시간 기록 작업
14
  },
15
}
16

17
// 주문 데이터
18
const order1 = {
19
  orderNumber: '12345',
20
  // 다른 주문 정보들
21
}
22

23
const order2 = {
24
  orderNumber: '67890',
25
  // 다른 주문 정보들
26
}
27

28
// 주문 처리
29
orderProcessor.processOrder(order1)
30
orderProcessor.processOrder(order2)

1
// 논리 응집이 있는 예제
2

3
// 주문 관리 모듈
4
const orderManager = {
5
  orders: [],
6

7
  // 주문 추가
8
  addOrder: function (order) {
9
    this.orders.push(order)
10
  },
11

12
  // 주문 유효성 검사
13
  validateOrder: function (order) {
14
    if (order.quantity > 0 && order.customerName) {
15
      return true
16
    }
17
    return false
18
  },
19

20
  // 주문 처리
21
  processOrder: function (order) {
22
    if (this.validateOrder(order)) {
23
      console.log(`주문 처리: ${order.customerName} 주문`)
24
      // 주문 처리 로직
25
    } else {
26
      console.log('주문 유효성 검사 실패')
27
    }
28
  },
29
}
30

31
// 주문 데이터
32
const order1 = {
33
  customerName: 'John Doe',
34
  quantity: 3,
35
  // 다른 주문 정보들
36
}
37

38
const order2 = {
39
  customerName: 'Alice Smith',
40
  quantity: -1,
41
  // 다른 주문 정보들
42
}
43

44
// 주문 추가 및 처리
45
orderManager.addOrder(order1)
46
orderManager.processOrder(order1)
47

48
orderManager.addOrder(order2)
49
orderManager.processOrder(order2)

1
// 동업 응집이 있는 예제
2
// 주문 관리 모듈
3
const orderManager = {
4
  orders: [],
5

6
  // 주문 추가
7
  addOrder: function (order) {
8
    this.orders.push(order)
9
  },
10

11
  // 사용자 인증
12
  authenticateUser: function (username, password) {
13
    // 사용자 인증 로직
14
  },
15

16
  // 화폐 변환
17
  convertCurrency: function (amount, fromCurrency, toCurrency) {
18
    // 화폐 변환 로직
19
  },
20

21
  // 날씨 정보 가져오기
22
  getWeather: function (city) {
23
    // 날씨 정보 API 호출
24
  },
25
}
26

27
// 주문 데이터
28
const order1 = {
29
  customerName: 'John Doe',
30
  quantity: 3,
31
  // 다른 주문 정보들
32
}
33

34
// 사용자 인증
35
orderManager.authenticateUser('username', 'password')
36

37
// 화폐 변환
38
orderManager.convertCurrency(100, 'USD', 'EUR')
39

40
// 날씨 정보 가져오기
41
orderManager.getWeather('New York')