2.2.2 크고 작은지 비교하기 (>, <, >=, <=) - 크기와 순서를 판단하는 비교 도구

📘 2.2.2 크고 작은지 비교하기 (>, <, >=, <=) - 크기와 순서를 판단하는 비교 도구

지난 시간 우리가 함께 걸어온 길에서, 두 값이 똑같은지 확인하는 도구로 정확한 일치를 판단하는 방법을 배웠습니다. 이제 우리 앞에는 새로운 질문이 놓여 있어요. "어떤 것이 더 큰가?" "어떤 것이 더 작은가?"

생각해보세요. 우리 일상에서 얼마나 자주 크기를 비교하며 살아가는지를요. 아침에 일어나서 어제보다 기온이 높은지 낮은지 확인하고, 아이들이 키가 자랐는지 재어보고, 시험 점수가 목표에 도달했는지 살펴보죠. 이런 모든 순간들이 바로 크기 비교의 순간들입니다.

오늘 만날 크기 비교 도구들은 이런 일상의 모든 비교 상황을 프로그래밍으로 자연스럽게 풀어낼 수 있게 도와줄 친구들입니다. 마치 공정한 저울이 정확하게 무게를 재듯이, 이 도구들은 값들의 크기와 순서를 정확하게 판단해줍니다.

🧠 새로운 단어들과 친해지기

크기 비교의 세계로 들어가며 만날 새로운 단어들을 부드럽게 익혀보겠습니다.

단어	따뜻한 설명
크기 비교 도구들	두 값의 크기나 순서를 정중하게 비교하는 도구들을 포괄하는 말입니다.
더 큰지 확인 (>)	왼쪽 값이 오른쪽 값보다 큰지 확인하는 단호한 도구입니다.
더 작은지 확인 (<)	왼쪽 값이 오른쪽 값보다 작은지 확인하는 세심한 도구입니다.
크거나 같은지 확인 (>=)	왼쪽 값이 오른쪽 값보다 크거나 같은지 확인하는 관대한 도구입니다.
작거나 같은지 확인 (<=)	왼쪽 값이 오른쪽 값보다 작거나 같은지 확인하는 포용적인 도구입니다.

이 크기 비교 도구들은 마치 "누가 더 큰가?"를 판단하는 공정한 심판과 같습니다. 두 값을 정중하게 받아서 크기를 비교하고, 그 결과를 언제나 true(맞습니다) 또는 false(틀립니다)로 정확하게 알려줍니다.

✨ 크기 비교 도구가 뭔지 알아보기

크기 비교 도구들은 순서와 크기의 세계를 다루는 소중한 도구들입니다. 각각의 도구는 서로 다른 비교 기준을 가지고 있어서, 상황에 맞게 적절한 것을 선택해야 해요.

더 큰지 확인하는 도구 (>)는 "왼쪽이 오른쪽보다 클 때"만 true를 건네줍니다. 예를 들어 15 > 10은 true이지만, 10 > 10은 false예요. 완전히 커야만 인정하는 엄격한 비교입니다.

더 작은지 확인하는 도구 (<)는 그 다정한 반대로 "왼쪽이 오른쪽보다 작을 때"만 true를 건네줍니다. 5 < 8은 true이지만, 8 < 8은 false예요.

크거나 같은지 확인하는 도구 (>=)와 작거나 같은지 확인하는 도구 (<=)는 조금 더 관대합니다. 크거나 같은지 확인하는 도구는 "크거나 같으면" true이고, 작거나 같은지 확인하는 도구는 "작거나 같으면" true예요. 그래서 10 >= 10과 10 <= 10 모두 true가 됩니다.

이런 미묘한 차이가 실제 프로그래밍에서는 매우 중요해요. 나이 제한이 "18세 이상"이라면 18세도 포함되지만, "18세를 넘어야"라면 19세부터 포함되거든요.

일상의 이야기: 우리 동네 도서관의 책 정리

이 크기 비교 도구를 더 친근하게 이해하기 위해 '우리 동네 도서관의 책 정리' 이야기를 들어보실래요?

우리 동네 도서관에서는 정기적으로 책 높이 재기 행사가 열립니다. 네 명의 친절한 사서 선생님이 각자 다른 기준으로 책을 분류하고 있어요.

"더 높은가?" 선생님 (>)은 정확함을 추구하는 분입니다. 두 권의 책이 오면 "왼쪽 책이 오른쪽 책보다 확실히 높아야만 통과!"라고 말씀하세요. 만약 높이가 같다면? "같은 것은 더 높은 것이 아니에요"라고 정중하게 말씀하십니다. 25cm와 20cm 책이 비교되면 25cm가 통과하지만, 20cm와 20cm가 비교되면 둘 다 통과하지 못해요.

"더 낮은가?" 선생님 (<)은 겸손함을 중시하는 분입니다. "왼쪽 책이 오른쪽 책보다 확실히 낮아야만 통과!"라고 하세요. 15cm와 25cm 책이 비교되면 15cm가 통과하지만, 20cm와 20cm가 비교되면 역시 둘 다 통과하지 못합니다.

"높거나 같은가?" 선생님 (>=)은 포용력이 뛰어난 분입니다. "왼쪽 책이 높거나 같기만 하면 모두 환영!"라고 말씀하세요. 30cm와 25cm 책이 비교되어도 통과, 25cm와 25cm 책이 비교되어도 통과예요. 동등함도 하나의 가치로 인정하는 따뜻한 선생님이죠.

"낮거나 같은가?" 선생님 (<=)도 마찬가지로 포용적입니다. "왼쪽 책이 낮거나 같기만 하면 모두 소중해요!"라고 하세요. 18cm와 28cm 책이 비교되어도 통과, 22cm와 22cm 책이 비교되어도 통과예요.

이 네 선생님 덕분에 도서관에서는 나이별 책장 배치, 키에 맞는 책 추천, 도서 등급 분류 등 다양한 상황에서 정확한 비교를 할 수 있게 되었답니다.

🎯 왜 크기 비교 도구를 배워야 할까요?

이 크기 비교 도구들이 우리에게 왜 소중할까요? 실생활과 프로그래밍에서 활용되는 따뜻한 이유들이 있습니다.

첫 번째는 자격 조건 확인하기입니다. 놀이기구 탑승을 위한 최소 키, 영화 관람을 위한 나이 제한, 시험 합격을 위한 최소 점수 등을 확인할 때 꼭 필요해요. 두 번째는 등급 및 범위 나누기입니다. 성적에 따른 학점 부여, 나이에 따른 요금 차등, 소득에 따른 세금 구간 등을 정확히 분류할 수 있어요.

세 번째는 한도 및 제한 관리하기입니다. 은행 계좌 잔고 확인, 상품 재고 수량 체크, 할인 쿠폰 사용 조건 등을 관리할 때 활용해요. 네 번째는 순서 및 정렬하기입니다. 이름 순서로 정렬하거나, 점수 순으로 순위를 매기거나, 날짜 순으로 배열할 때 사용됩니다.

마지막으로 안전 구간 확인하기입니다. 온도가 안전 범위 내에 있는지, 속도가 제한 속도 이하인지, 혈압이 정상 범위인지 등을 모니터링할 때 매우 중요한 역할을 합니다.

⚙️ 기본 사용법 배우기

이 도구들의 기본 사용법은 매우 자연스럽습니다.

// 기본 크기 비교 작업
let result1 = 값1 > 값2;     // 값1이 값2보다 큰가?
let result2 = 값1 < 값2;     // 값1이 값2보다 작은가?
let result3 = 값1 >= 값2;    // 값1이 값2보다 크거나 같은가?
let result4 = 값1 <= 값2;    // 값1이 값2보다 작거나 같은가?

자주 사용하는 패턴들:

// 나이 확인
let ageCheck = myAge >= 18;    // 18세 이상인지 확인

// 점수 확인  
let passCheck = score >= 60;   // 60점 이상인지 확인

// 예산 확인
let budgetCheck = price <= budget;  // 예산 이내인지 확인

🧪 직접 해보면서 배우기

이제 실제 예시를 통해서 크기 비교 도구의 사용법을 차근차근 알아보겠습니다.

🔹 첫 번째 예시: 네 가지 크기 비교 도구 완전 정복하기

첫 번째 예시에서는 모든 크기 비교 도구를 체계적으로 사용해보면서 각각의 특징을 명확히 이해해보겠습니다.

// 학생들의 시험 점수를 비교해보자.
console.log("=== 시험 점수 비교 시스템 ===");

let myScore = 88;           // 내 점수를 담는 상자
let friendScore = 82;       // 친구 점수를 담는 상자
let passScore = 60;         // 합격 점수를 담는 상자
let excellentScore = 90;    // 우수 점수를 담는 상자

console.log("내 점수: " + myScore + "점");
console.log("친구 점수: " + friendScore + "점");
console.log("합격 기준: " + passScore + "점");
console.log("우수 기준: " + excellentScore + "점");

// 더 큰지 확인하는 도구 (>) 사용해보기
let isBetterThanFriend = myScore > friendScore;  // 내가 친구보다 점수가 더 높은지 확인하는 상자
console.log("\n> (더 큰지) 도구 테스트:");
console.log("내가 친구보다 점수가 높나요? " + isBetterThanFriend);  // true (88 > 82)

let isExcellent = myScore > excellentScore;      // 우수 기준보다 더 높은지 확인하는 상자
console.log("우수 기준을 넘었나요? " + isExcellent);              // false (88 > 90)

// 더 작은지 확인하는 도구 (<) 사용해보기
let isWorseThanFriend = myScore < friendScore;   // 내가 친구보다 점수가 더 낮은지 확인하는 상자
console.log("\n< (더 작은지) 도구 테스트:");
console.log("내가 친구보다 점수가 낮나요? " + isWorseThanFriend);  // false (88 < 82)

let needsImprovement = myScore < excellentScore; // 우수 기준에 못 미치는지 확인하는 상자
console.log("우수 기준에 못 미치나요? " + needsImprovement);        // true (88 < 90)

// 크거나 같은지 확인하는 도구 (>=) 사용해보기
let hasPassedExam = myScore >= passScore;        // 시험에 합격했는지 확인하는 상자
console.log("\n>= (크거나 같은지) 도구 테스트:");
console.log("시험에 합격했나요? " + hasPassedExam);               // true (88 >= 60)

let isTopStudent = myScore >= excellentScore;    // 우수 학생인지 확인하는 상자
console.log("우수 학생인가요? " + isTopStudent);                  // false (88 >= 90)

// 작거나 같은지 확인하는 도구 (<=) 사용해보기
let isInNormalRange = myScore <= 100;            // 유효한 점수 범위인지 확인하는 상자
console.log("\n<= (작거나 같은지) 도구 테스트:");
console.log("유효한 점수 범위인가요? " + isInNormalRange);        // true (88 <= 100)

let needsMoreStudy = myScore <= passScore;       // 더 공부가 필요한지 확인하는 상자
console.log("더 공부가 필요한가요? " + needsMoreStudy);           // false (88 <= 60)

// 친구와의 점수 차이 분석
let scoreDifference = myScore - friendScore;  // 점수 차이를 계산하는 상자
console.log("\n=== 점수 차이 분석 ===");
console.log("점수 차이: " + scoreDifference + "점");

let isBetter = myScore > friendScore;         // 내가 더 높은지 확인하는 상자
let isWorse = myScore < friendScore;          // 친구가 더 높은지 확인하는 상자
let isSame = myScore === friendScore;         // 같은지 확인하는 상자

console.log("내가 더 잘했나요? " + isBetter);    // true
console.log("친구가 더 잘했나요? " + isWorse);   // false
console.log("동점인가요? " + isSame);            // false

이 과정을 차근차근 따라가보면, 먼저 비교할 기준이 되는 여러 점수들을 설정합니다. 그다음 각 크기 비교 도구를 하나씩 사용해보면서 어떤 결과가 나오는지 확인하죠. 특히 더 큰지 확인(>)과 크거나 같은지 확인(>=)의 차이, 더 작은지 확인(<)과 작거나 같은지 확인(<=)의 차이를 명확히 구분할 수 있도록 다양한 상황을 테스트해봅니다.

🔹 두 번째 예시: 나이와 키 기준으로 자격 검증하기

두 번째 예시에서는 실생활에서 자주 마주치는 나이와 키 제한을 크기 비교 도구로 자연스럽게 처리하는 방법을 알아보겠습니다.

// 놀이공원 방문객 정보를 확인해보자.
console.log("=== 🎢 놀이공원 입장 확인 ===");

let visitorAge = 16;        // 방문객 나이를 담는 상자
let visitorHeight = 150;    // 방문객 키를 담는 상자 (cm)

console.log("방문객 정보:");
console.log("나이: " + visitorAge + "세");
console.log("키: " + visitorHeight + "cm");

// 연령대별 분류
console.log("\n=== 연령대 분류 ===");

let childAge = 12;          // 어린이 기준 나이를 담는 상자
let adultAge = 18;          // 성인 기준 나이를 담는 상자
let seniorAge = 65;         // 경로우대 기준 나이를 담는 상자

let isChild = visitorAge < childAge;              // 어린이인지 확인하는 상자
let isAboveChild = visitorAge >= childAge;        // 어린이 이상인지 확인하는 상자
let isBelowAdult = visitorAge < adultAge;         // 성인 미만인지 확인하는 상자
let isAdult = visitorAge >= adultAge;             // 성인 이상인지 확인하는 상자
let isBelowSenior = visitorAge < seniorAge;       // 경로우대 미만인지 확인하는 상자
let isSenior = visitorAge >= seniorAge;           // 경로우대 대상인지 확인하는 상자

console.log("어린이인가요? (12세 미만) " + isChild);        // false (16 < 12)
console.log("어린이 이상인가요? (12세 이상) " + isAboveChild); // true (16 >= 12)
console.log("성인 미만인가요? (18세 미만) " + isBelowAdult);  // true (16 < 18)
console.log("성인인가요? (18세 이상) " + isAdult);          // false (16 >= 18)
console.log("경로우대 미만인가요? (65세 미만) " + isBelowSenior); // true (16 < 65)
console.log("경로우대인가요? (65세 이상) " + isSenior);      // false (16 >= 65)

// 16세는 어린이 이상이면서 성인 미만이므로 청소년이에요
console.log("\n결론: 청소년입니다! (어린이 이상 + 성인 미만)");

// 놀이기구별 탑승 자격 확인
console.log("\n=== 🎠 놀이기구 탑승 자격 ===");

// 롤러코스터 (최소 나이 14세, 최소 키 140cm)
let rollerCoasterMinAge = 14;       // 롤러코스터 최소 나이를 담는 상자
let rollerCoasterMinHeight = 140;   // 롤러코스터 최소 키를 담는 상자

console.log("🎢 롤러코스터 조건:");
console.log("- 최소 나이: " + rollerCoasterMinAge + "세");
console.log("- 최소 키: " + rollerCoasterMinHeight + "cm");

let ageOkForRoller = visitorAge >= rollerCoasterMinAge;      // 나이 조건 확인하는 상자
let heightOkForRoller = visitorHeight >= rollerCoasterMinHeight;  // 키 조건 확인하는 상자

console.log("나이 조건 만족? " + ageOkForRoller);     // true (16 >= 14)
console.log("키 조건 만족? " + heightOkForRoller);    // true (150 >= 140)

// 범퍼카 (최소 나이 8세, 키 제한 없음)
let bumperCarMinAge = 8;            // 범퍼카 최소 나이를 담는 상자

console.log("\n🚗 범퍼카 조건:");
console.log("- 최소 나이: " + bumperCarMinAge + "세");
console.log("- 키 제한: 없음");

let ageOkForBumper = visitorAge >= bumperCarMinAge;  // 나이 조건 확인하는 상자
console.log("나이 조건 만족? " + ageOkForBumper);    // true (16 >= 8)

// 회전목마 (어린이 전용: 최대 나이 12세, 최대 키 130cm)
let carouselMaxAge = 12;            // 회전목마 최대 나이를 담는 상자
let carouselMaxHeight = 130;        // 회전목마 최대 키를 담는 상자

console.log("\n🎠 회전목마 조건:");
console.log("- 최대 나이: " + carouselMaxAge + "세 (어린이 전용)");
console.log("- 최대 키: " + carouselMaxHeight + "cm");

let ageOkForCarousel = visitorAge <= carouselMaxAge;        // 나이 조건 확인하는 상자
let heightOkForCarousel = visitorHeight <= carouselMaxHeight;  // 키 조건 확인하는 상자

console.log("나이 조건 만족? " + ageOkForCarousel);     // false (16 <= 12)
console.log("키 조건 만족? " + heightOkForCarousel);    // false (150 <= 130)

// 안전 점검
console.log("\n=== ⚠️ 안전 점검 ===");

let emergencyExitHeight = 100;     // 비상구 이용 최소 키를 담는 상자
let maxSafeAge = 80;               // 안전 권장 최대 나이를 담는 상자

let canUseExit = visitorHeight >= emergencyExitHeight;  // 비상구 이용 가능 여부를 확인하는 상자
let isSafeAge = visitorAge <= maxSafeAge;               // 안전 권장 나이 여부를 확인하는 상자

console.log("비상구 이용 가능? " + canUseExit);  // true (150 >= 100)
console.log("안전 권장 나이? " + isSafeAge);     // true (16 <= 80)

이 예시는 크기 비교 도구가 실제 시설에서 어떻게 따뜻하게 활용되는지 보여줍니다. 개별 조건들을 하나씩 확인하여 정교한 자격 검증을 할 수 있다는 것을 확인할 수 있어요. 또한 최솟값뿐만 아니라 최댓값도 함께 고려하여 안전하고 적절한 서비스를 제공하는 방법도 배울 수 있습니다.

🔹 세 번째 예시: 쇼핑과 점수 평가에서의 활용

세 번째 예시에서는 숫자뿐만 아니라 다양한 상황에서 크기 비교 도구의 활용법을 자연스럽게 경험해보겠습니다.

// 온라인 쇼핑몰의 상품 정보를 확인해보자.
console.log("=== 🛒 쇼핑몰 상품 확인 ===");

// 고객 정보
let customerAge = 25;               // 고객 나이를 담는 상자
let customerBudget = 150000;        // 고객 예산을 담는 상자 (원)

// 상품 정보
let productPrice = 89000;           // 상품 가격을 담는 상자
let productRating = 4.2;            // 상품 평점을 담는 상자 (5점 만점)
let productStock = 15;              // 상품 재고 수량을 담는 상자
let minOrderAge = 19;               // 상품 최소 주문 나이를 담는 상자 (성인 상품)

console.log("고객 정보:");
console.log("나이: " + customerAge + "세");
console.log("예산: " + customerBudget + "원");

console.log("\n상품 정보:");
console.log("가격: " + productPrice + "원");
console.log("평점: " + productRating + "점");
console.log("재고: " + productStock + "개");

// 구매 자격 검증
console.log("\n=== 구매 자격 검증 ===");

// 나이 제한 확인
let ageQualified = customerAge >= minOrderAge;  // 최소 주문 나이 이상인지 확인하는 상자
console.log("나이 조건 확인:");
console.log("최소 주문 나이: " + minOrderAge + "세");
console.log("나이 조건 만족? " + ageQualified);  // true (25 >= 19)

// 예산 확인
let budgetEnough = customerBudget >= productPrice;  // 예산이 상품 가격 이상인지 확인하는 상자
console.log("\n예산 조건 확인:");
console.log("예산이 충분한가요? " + budgetEnough);  // true (150000 >= 89000)

let remainingBudget = customerBudget - productPrice;  // 남은 예산을 계산하는 상자
console.log("남은 예산: " + remainingBudget + "원");

// 재고 확인
let stockAvailable = productStock > 0;  // 재고가 0보다 많은지 확인하는 상자
console.log("\n재고 조건 확인:");
console.log("재고가 있나요? " + stockAvailable);  // true (15 > 0)

// 상품 평점 평가
console.log("\n=== 상품 평점 평가 ===");

let isHighRating = productRating >= 4.5;     // 고평점인지 확인하는 상자 (4.5점 이상)
let isGoodRating = productRating >= 4.0;     // 좋은 평점인지 확인하는 상자 (4.0점 이상)
let isOkRating = productRating >= 3.5;       // 괜찮은 평점인지 확인하는 상자 (3.5점 이상)
let isPoorRating = productRating < 3.5;      // 낮은 평점인지 확인하는 상자 (3.5점 미만)

console.log("고평점 상품인가요? (4.5점 이상) " + isHighRating);  // false (4.2 >= 4.5)
console.log("좋은 평점인가요? (4.0점 이상) " + isGoodRating);    // true (4.2 >= 4.0)
console.log("괜찮은 평점인가요? (3.5점 이상) " + isOkRating);    // true (4.2 >= 3.5)
console.log("낮은 평점인가요? (3.5점 미만) " + isPoorRating);    // false (4.2 < 3.5)

// 재고 관리 알림
console.log("\n=== 재고 관리 알림 ===");

let stockHigh = productStock >= 50;           // 충분한 재고인지 확인하는 상자 (50개 이상)
let stockNormal = productStock >= 20;         // 적정 재고인지 확인하는 상자 (20개 이상)
let stockLow = productStock >= 10;            // 재고 부족 주의인지 확인하는 상자 (10개 이상)
let stockVeryLow = productStock > 0;          // 재고가 있긴 한지 확인하는 상자 (0보다 큼)
let stockCritical = productStock < 10;        // 재고 부족 임계인지 확인하는 상자 (10개 미만)
let stockOut = productStock === 0;            // 재고 소진인지 확인하는 상자

console.log("충분한 재고? (50개 이상) " + stockHigh);       // false (15 >= 50)
console.log("적정 재고? (20개 이상) " + stockNormal);       // false (15 >= 20)
console.log("재고 부족 주의? (10개 이상) " + stockLow);     // true (15 >= 10)
console.log("재고가 있긴 한가요? (0보다 큼) " + stockVeryLow); // true (15 > 0)
console.log("재고 부족 임계? (10개 미만) " + stockCritical); // false (15 < 10)
console.log("재고 소진? " + stockOut);                     // false (15 === 0)

// 할인 혜택 확인
console.log("\n=== 할인 혜택 확인 ===");

let vipBudget = 200000;               // VIP 고객 기준 예산을 담는 상자
let premiumBudget = 100000;           // 프리미엄 고객 기준 예산을 담는 상자

let isVipCustomer = customerBudget >= vipBudget;       // VIP 고객인지 확인하는 상자
let isPremiumCustomer = customerBudget >= premiumBudget;  // 프리미엄 고객인지 확인하는 상자
let isRegularCustomer = customerBudget < premiumBudget;   // 일반 고객인지 확인하는 상자

console.log("VIP 고객인가요? (20만원 이상) " + isVipCustomer);      // false (150000 >= 200000)
console.log("프리미엄 고객인가요? (10만원 이상) " + isPremiumCustomer); // true (150000 >= 100000)
console.log("일반 고객인가요? (10만원 미만) " + isRegularCustomer);    // false (150000 < 100000)

// 학생 점수 등급 확인
console.log("\n=== 학생 점수 등급 확인 ===");

let testScore = 78;                   // 시험 점수를 담는 상자

let gradeA = testScore >= 90;         // A등급인지 확인하는 상자 (90점 이상)
let gradeB = testScore >= 80;         // B등급인지 확인하는 상자 (80점 이상)
let gradeC = testScore >= 70;         // C등급인지 확인하는 상자 (70점 이상)
let gradeD = testScore >= 60;         // D등급인지 확인하는 상자 (60점 이상)
let gradeF = testScore < 60;          // F등급인지 확인하는 상자 (60점 미만)

console.log("시험 점수: " + testScore + "점");
console.log("A등급인가요? (90점 이상) " + gradeA);  // false (78 >= 90)
console.log("B등급인가요? (80점 이상) " + gradeB);  // false (78 >= 80)
console.log("C등급인가요? (70점 이상) " + gradeC);  // true (78 >= 70)
console.log("D등급인가요? (60점 이상) " + gradeD);  // true (78 >= 60)
console.log("F등급인가요? (60점 미만) " + gradeF);  // false (78 < 60)

이 예시는 크기 비교 도구의 실제 활용도를 보여주는 다양한 시스템입니다. 쇼핑몰에서 사용되는 자격 검증, 평점 평가, 재고 관리, 고객 등급 분류 등의 기능들이 모두 크기 비교 도구를 기반으로 만들어진다는 것을 확인할 수 있어요. 또한 학교에서 사용되는 점수 등급 시스템도 크기 비교로 구현할 수 있음을 보여줍니다.

🔄 크기 비교 도구 사용하는 순서 정리하기

지금까지 함께 걸어온 크기 비교 도구 사용 과정을 자연스럽게 정리해보겠습니다.

첫 번째 단계는 비교 목적 명확하게 하기입니다. 무엇을 비교하고 싶은지, 어떤 조건을 확인하고 싶은지를 분명히 해야 해요. 두 번째는 적절한 도구 선택하기입니다. 완전히 커야 하는지(>), 크거나 같아도 되는지(>=), 작아야 하는지(<), 작거나 같아도 되는지(<=)를 정확히 구분해야 해요.

세 번째는 비교 수행하기입니다. 선택한 도구를 사용하여 실제 비교를 수행하고 결과를 변수에 저장해요. 네 번째는 결과 해석하기입니다. true 또는 false 결과가 실제 상황에서 무엇을 의미하는지 정확히 이해해야 해요.

마지막으로 결과 활용하기입니다. 비교 결과를 바탕으로 적절한 후속 조치를 계획하거나, 사용자에게 의미있는 피드백을 제공하는 거죠.

🧚‍♀️ 이야기로 다시 배우기: 공정한 심판의 학교

지금까지 배운 내용을 하나의 따뜻한 이야기로 다시 정리해볼까요?

우리 동네 끝자락에 공정한 심판의 학교라는 곳이 있었습니다. 이 학교에서는 모든 비교와 판정을 네 명의 전문 선생님이 담당하고 있었어요.

대선생님 "더 큰가" (>)는 완벽함을 추구하는 분이었습니다. 그는 왼쪽 학생이 오른쪽 학생보다 확실히 클 때만 승리를 인정했어요. "같은 것은 승부가 아닙니다"라는 것이 그의 철학이었죠. 85점과 80점이 경기를 했을 때는 85점의 승리를 선언했지만, 80점과 80점이 경기를 했을 때는 "무승부는 특별함이 아닙니다"며 둘 다 특별하지 않다고 판정했어요.

부선생님 "더 작은가" (<)는 겸손함을 소중히 여기는 분이었습니다. 왼쪽 학생이 오른쪽 학생보다 확실히 작을 때만 승리를 인정했어요. 70점과 90점의 경기에서는 70점의 승리를 선언했지만, 역시 같은 경우에는 특별함을 인정하지 않았어요.

관대한 선생님 "크거나 같은가" (>=)는 포용력이 뛰어났습니다. "성과는 결과가 중요하지, 과정에서 동등함이어도 충분히 소중합니다!"라고 생각했어요. 95점과 88점의 경기에서도 승리, 90점과 90점의 경기에서도 승리를 선언했어요. 같은 것도 하나의 성과로 인정하는 너그러운 성격이었죠.

친절한 선생님 "작거나 같은가" (<=)도 마찬가지로 관대했습니다. 75점과 89점의 경기에서도 승리, 86점과 86점의 경기에서도 승리를 인정했어요.

어느 날, 학교에 큰 문제가 생겼어요. 시험 합격 기준을 확인해야 하는데, "60점 이상"인지 "60점을 넘어야"인지 헷갈린다는 것이었어요.

이때 네 선생님이 나서서 따뜻하게 설명했어요.

"60점을 넘어야"라면 대선생님 "더 큰가"의 영역입니다. 60점은 아쉽게 통과하지 못하고 61점부터 통과예요.

"60점 이상"이라면 관대한 선생님 "크거나 같은가"의 영역입니다. 60점도 소중하게 통과하고 61점도 통과예요.

이렇게 네 선생님의 명확한 기준 덕분에 학교의 모든 비교와 판정이 정확하고 공정하게 이루어질 수 있었답니다. 시험 성적 등급, 체육대회 기록 측정, 학용품 예산 관리 등 모든 것이 선생님들의 정확한 판정으로 원활하게 운영되었어요.

그리고 학생들도 선생님들의 특성을 잘 알게 되어, 상황에 맞는 적절한 선생님을 찾아가서 공정한 판정을 받을 수 있게 되었답니다.

🧠 자주 하는 실수와 주의할 점

크기 비교 도구를 사용할 때 흔히 발생하는 실수들을 살펴보고, 어떻게 조심할 수 있는지 알아보겠습니다.

❌ 실수 1: 크거나 같은지(>=)와 더 큰지(>)를 헷갈려서 경계값 처리 실수

let age = 18;               // 나이를 담는 상자
let adultAge = 18;          // 성인 기준 나이를 담는 상자

// 잘못된 조건: 18세도 성인인데 제외돼요
let wrongCheck = age > adultAge;        // 18 > 18 → false
console.log("성인 여부 (잘못된 확인): " + wrongCheck);  // false (18세인데 성인이 아니라고 나옴!)

// 올바른 조건: 18세 이상
let correctCheck = age >= adultAge;     // 18 >= 18 → true
console.log("성인 여부 (올바른 확인): " + correctCheck);  // true

이런 실수가 발생하는 이유는 "이상"과 "넘어야"의 차이를 제대로 이해하지 못해서입니다. 18세 이상이라면 18세도 포함되므로 >=를 사용해야 해요.

❌ 실수 2: 문자열과 숫자 비교 시 예상치 못한 결과

let userInput = "9";         // 사용자 입력을 담는 상자 (문자열)
let minimumValue = 10;       // 최소값을 담는 상자 (숫자)

// 문자열과 숫자 비교는 예상치 못한 결과가 나올 수 있어요
let comparison = userInput > minimumValue;    // "9" > 10 (문자열 비교)
console.log("비교 결과: " + comparison);  // 예상과 다른 결과 가능

// 해결책: 나중에 배울 내용이에요!
console.log("지금은 같은 종류끼리만 비교해주세요!");
console.log("문자열끼리 또는 숫자끼리만 비교하는 것이 안전해요.");

문자열과 숫자를 비교할 때는 예상치 못한 결과가 나올 수 있어요. 지금은 같은 종류끼리만 비교하는 것이 안전합니다.

❌ 실수 3: 비교 결과를 잘못 이해하기

let score1 = 80;            // 첫 번째 점수를 담는 상자
let score2 = 90;            // 두 번째 점수를 담는 상자

let comparison = score1 > score2;  // 80 > 90 비교
console.log("80이 90보다 큰가요? " + comparison);  // false

// 잘못된 이해: false가 나왔으니까 에러가 발생했다고 생각
// 올바른 이해: false는 "80이 90보다 크지 않다"는 정확한 결과예요!

let correctComparison = score2 > score1;  // 90 > 80 비교
console.log("90이 80보다 큰가요? " + correctComparison);  // true

비교 결과로 나오는 true와 false는 에러가 아니라 정확한 답입니다. false가 나왔다고 해서 잘못된 것이 아니라, 조건이 맞지 않는다는 올바른 결과를 알려주는 거예요.

💭 연습 문제를 시작하기 전에

이제 우리는 작은 연습 문제들을 통해 오늘 배운 내용을 직접 경험해보려 합니다. 연습 문제란, 마치 정원에서 새로 배운 원예 기법을 직접 꽃에 적용해보는 것과 같습니다. 처음에는 조심스럽고 어색할 수 있지만, 한 번 한 번 정성껏 해보다 보면 어느새 자연스러운 솜씨가 됩니다.

우리가 지금까지 함께 걸어온 길을 생각해보세요. 크기 비교 도구의 작동 원리를 이해하고, 각 도구의 미묘한 차이점을 알아보았습니다. 이제 그 지식을 손끝으로 직접 확인해볼 시간입니다.

✏️ 직접 해보기 - 쉬운 연습 문제들

이제 배운 내용을 연습 문제를 통해서 차근차근 익혀보겠습니다.

Ex1) 다양한 나이 조건을 확인해보자

// 다양한 나이 조건을 확인해보자.
let myAge = 16;             // 내 나이를 담는 상자
let adultAge = 18;          // 성인 기준 나이를 담는 상자
let seniorAge = 65;         // 경로우대 기준 나이를 담는 상자

// 성인 여부 확인
let isAdult = myAge >= adultAge;  // 성인인지 확인하는 상자
console.log("성인인가요? " + isAdult);        // false (16 >= 18 → false)

// 미성년자 여부 확인
let isMinor = myAge < adultAge;   // 미성년자인지 확인하는 상자
console.log("미성년자인가요? " + isMinor);     // true (16 < 18 → true)

// 경로우대 대상 여부 확인
let isSenior = myAge >= seniorAge;  // 경로우대 대상인지 확인하는 상자
console.log("경로우대 대상인가요? " + isSenior); // false (16 >= 65 → false)

// 중고등학생 연령대 확인
let isAboveMiddleSchool = myAge >= 13;        // 13세 이상인지 확인하는 상자
let isUnderAdult = myAge < 18;                // 18세 미만인지 확인하는 상자
console.log("13세 이상인가요? " + isAboveMiddleSchool);  // true (16 >= 13)
console.log("18세 미만인가요? " + isUnderAdult);         // true (16 < 18)
// 둘 다 true이므로 중고등학생 연령대예요!

Ex2) 상품 가격과 예산을 비교해보자

// 상품 가격과 예산을 비교해보자.
let productPrice = 45000;    // 상품 가격을 담는 상자
let myBudget = 50000;        // 내 예산을 담는 상자
let minimumBudget = 30000;   // 최소 예산을 담는 상자

console.log("상품 가격: " + productPrice + "원");
console.log("내 예산: " + myBudget + "원");

// 구매 가능 여부 확인
let canAfford = productPrice <= myBudget;    // 상품 가격이 예산 이하인지 확인하는 상자
console.log("구매 가능한가요? " + canAfford);  // true (45000 <= 50000)

let isTooExpensive = productPrice > myBudget;  // 상품 가격이 예산을 초과하는지 확인하는 상자
console.log("예산 초과인가요? " + isTooExpensive);  // false (45000 > 50000)

// 남은 돈 계산
let remainingMoney = myBudget - productPrice;  // 남은 돈을 계산하는 상자
console.log("남은 돈: " + remainingMoney + "원");

// 적정 가격 범위 확인
let isAboveMinimum = productPrice >= minimumBudget;  // 최소 예산 이상인지 확인하는 상자
let isBelowMaximum = productPrice <= myBudget;       // 최대 예산 이하인지 확인하는 상자

console.log("최소 예산 이상인가요? " + isAboveMinimum);  // true (45000 >= 30000)
console.log("최대 예산 이하인가요? " + isBelowMaximum);  // true (45000 <= 50000)

Ex3) 시험 점수 등급을 확인해보자

// 시험 점수에 따른 등급을 확인해보자.
let examScore = 87;         // 시험 점수를 담는 상자

console.log("시험 점수: " + examScore + "점");

// 각 등급 기준 확인
let isA = examScore >= 90;   // A등급인지 확인하는 상자 (90점 이상)
let isB = examScore >= 80;   // B등급인지 확인하는 상자 (80점 이상)
let isC = examScore >= 70;   // C등급인지 확인하는 상자 (70점 이상)
let isD = examScore >= 60;   // D등급인지 확인하는 상자 (60점 이상)
let isF = examScore < 60;    // F등급인지 확인하는 상자 (60점 미만)

console.log("A등급인가요? (90점 이상) " + isA);  // false (87 >= 90)
console.log("B등급인가요? (80점 이상) " + isB);  // true (87 >= 80)
console.log("C등급인가요? (70점 이상) " + isC);  // true (87 >= 70)
console.log("D등급인가요? (60점 이상) " + isD);  // true (87 >= 60)
console.log("F등급인가요? (60점 미만) " + isF);  // false (87 < 60)

// 합격 여부 확인
let isPassed = examScore >= 60;  // 합격인지 확인하는 상자 (60점 이상)
let isFailed = examScore < 60;   // 불합격인지 확인하는 상자 (60점 미만)

console.log("합격인가요? " + isPassed);  // true (87 >= 60)
console.log("불합격인가요? " + isFailed);  // false (87 < 60)

🤔 조금 더 어려운 문제로 실력 확인하기

기본 연습을 마쳤다면, 이제 조금 더 깊이 있는 문제들을 통해서 크기 비교 도구에 대한 이해를 확인해보겠습니다.

Q1. 다음 비교의 결과를 예측해보세요.

let a = 15;              // a 상자에 15를 넣기
let b = 20;              // b 상자에 20을 넣기
let result = a >= b;
console.log(result);

정답: false

해설: 15는 20보다 작으므로, "15가 20보다 크거나 같다"는 조건은 거짓입니다.

Q2. 다음 중 true가 되는 조건을 모두 고르세요.

let score = 85;          // score 상자에 85를 넣기

A) score > 90
B) score < 80
C) score >= 85
D) score <= 70
E) score <= 100

정답: C와 E

해설:

• C) 85 >= 85 → true (85는 85와 같으므로)
• E) 85 <= 100 → true (85는 100보다 작으므로)

Q3. 놀이기구 탑승 조건을 확인해보세요.

let age = 12;            // 나이 12세
let height = 135;        // 키 135cm

// 롤러코스터: 14세 이상, 140cm 이상
let canRideRoller = age >= 14;     // 나이 조건
let heightOkRoller = height >= 140; // 키 조건

console.log("롤러코스터 나이 조건:", canRideRoller);    // false
console.log("롤러코스터 키 조건:", heightOkRoller);     // false

해설: 12세는 14세 미만이고, 135cm는 140cm 미만이므로 둘 다 조건을 만족하지 않습니다.

지금까지 크기 비교 도구의 모든 특성과 활용법을 차근차근 알아보았습니다. 이 네 개의 간단한 기호들이 우리 일상의 수많은 비교와 판단을 프로그래밍으로 구현할 수 있게 해준다는 것이 정말 놀랍지 않나요? 앞으로 더 복잡한 프로그램을 만들 때, 오늘 배운 크기 비교 도구들이 핵심적인 역할을 하게 될 거예요!

✅ 학습 완료 체크리스트

이번 시간에 배운 내용들을 모두 이해했는지 확인해보세요!

학습 내용	이해했나요?
2.2.2의 기본 개념	✅
기본 사용법과 문법	✅
주요 특징과 차이점	✅
자주 하는 실수들	✅
실전 예제 이해	✅

🎯 추가 연습 문제들

조금 더 연습하고 싶은 분들을 위한 추가 문제들입니다!

추가 문제 1. 기본 관계 연산자를 사용해서 나이를 비교해보세요.

let myAge = 15;
let adultAge = 18;
let seniorAge = 65;

// 성인인지 확인
let isAdult = myAge >= adultAge;
console.log("성인인가요?", isAdult);         // false

// 미성년자인지 확인
let isMinor = myAge < adultAge;
console.log("미성년자인가요?", isMinor);      // true

// 경로우대 대상인지 확인
let isSenior = myAge >= seniorAge;
console.log("경로우대 대상인가요?", isSenior); // false

추가 문제 2. 점수에 따른 등급을 확인해보세요.

let examScore = 78;

console.log("시험 점수:", examScore + "점");

let gradeA = examScore >= 90;    // A등급 (90점 이상)
let gradeB = examScore >= 80;    // B등급 (80점 이상)
let gradeC = examScore >= 70;    // C등급 (70점 이상)
let gradeD = examScore >= 60;    // D등급 (60점 이상)
let gradeF = examScore < 60;     // F등급 (60점 미만)

console.log("A등급인가요?", gradeA);  // false
console.log("B등급인가요?", gradeB);  // false
console.log("C등급인가요?", gradeC);  // true
console.log("D등급인가요?", gradeD);  // true
console.log("F등급인가요?", gradeF);  // false

🔄 단계별 진행 과정 정리

지금까지 배운 내용을 단계별로 다시 한번 정리해보겠습니다.

1단계 과정: 1) 비교할 값들 준비 → 2) 각 관계 연산자로 조건 확인 → 3) true/false 결과를 변수에 저장 → 4) console.log로 결과 해석 → 5) 여러 조건을 개별적으로 확인

2단계 과정: 1) 나이 기준값들과 방문자 나이 설정 → 2) 각 조건을 관계 연산자로 개별 확인 → 3) 개별 조건들을 각각 검사 → 4) 각 시설별 이용 가능 여부 개별 확인 → 5) 안전 기준 확인

3단계 과정: 1) 다양한 비교 상황 설정 (가격, 점수, 평점) → 2) 각 상황에 적합한 관계 연산자 선택 → 3) 개별 조건 검사로 세밀한 분류 → 4) 등급별, 범위별 개별 확인 → 5) 종합적 결과 정리

📂 마무리 정보

오늘 배운 2.2.2 내용이 여러분의 자바스크립트 지식 상자에 잘 저장되었나요? 다음 시간에는 더 재미있는 내용으로 만나요!

기억할 점: 오늘 배운 내용을 꼭 연습해보시고, 궁금한 점이 있으면 언제든 다시 돌아와서 읽어보세요.

🚀 더 체계적인 JavaScript 학습을 원하신다면?

이 포스팅에서 다룬 내용을 실제로 실습해보세요!
무료 JavaScript 학습 플랫폼에서 단계별 학습과 실시간 코드 실행을 통해
더욱 효과적이고 재미있게 학습하실 수 있습니다.

📝 실시간 코드 실행 📊 학습 진도 관리 👥 체계적 커리큘럼

📚 171개 체계적 학습레슨 · 📋 855개 4지선다 연습문제 · 🆓 완전 무료 · ⚡ 즉시 시작

💻 무료로 학습하러 가기

---