251 lines
5.5 KiB
Markdown
251 lines
5.5 KiB
Markdown
# **Ruby에서 예외 처리와 디버깅**
|
|
|
|
프로그램을 개발할 때 **예외 처리(Exception Handling)** 는 필수적인 요소다. 오류를 제대로 처리하지 않으면 프로그램이 예상치 못한 방식으로 종료되거나, 심각한 버그가 발생할 수 있다. 또한 **디버깅(Debugging)** 기법을 활용하면 문제를 쉽게 찾아낼 수 있다. 이번 글에서는 **예외 처리 기법과 디버깅 방법**을 소개한다.
|
|
|
|
---
|
|
|
|
## **1. 예외(Exception)란?**
|
|
|
|
예외(Exception)는 프로그램 실행 중 발생하는 오류이다. Ruby에서는 예외가 발생하면 프로그램이 즉시 종료되지만, 적절한 예외 처리를 통해 오류를 방지할 수 있다.
|
|
|
|
### **예외 발생 예시**
|
|
|
|
```ruby
|
|
puts 10 / 0 # ZeroDivisionError 발생
|
|
```
|
|
|
|
```ruby
|
|
array = [1, 2, 3]
|
|
puts array[10] # IndexError 발생
|
|
```
|
|
|
|
위 코드들은 실행 중 오류가 발생하며, 프로그램이 강제 종료된다. 이를 방지하기 위해 **begin-rescue 문**을 사용한다.
|
|
|
|
---
|
|
|
|
## **2. 예외 처리 (`begin-rescue`)**
|
|
|
|
Ruby에서는 `begin-rescue` 블록을 사용해 예외를 처리할 수 있다.
|
|
|
|
```ruby
|
|
begin
|
|
puts 10 / 0
|
|
rescue ZeroDivisionError
|
|
puts "0으로 나눌 수 없습니다!"
|
|
end
|
|
```
|
|
|
|
출력:
|
|
```
|
|
0으로 나눌 수 없습니다!
|
|
```
|
|
|
|
### **여러 개의 예외 처리**
|
|
|
|
여러 종류의 예외를 처리하려면 `rescue`를 여러 개 사용할 수 있다.
|
|
|
|
```ruby
|
|
begin
|
|
array = [1, 2, 3]
|
|
puts array[10] # IndexError 발생
|
|
rescue ZeroDivisionError
|
|
puts "0으로 나눌 수 없습니다!"
|
|
rescue IndexError
|
|
puts "잘못된 인덱스 접근입니다!"
|
|
end
|
|
```
|
|
|
|
출력:
|
|
```
|
|
잘못된 인덱스 접근입니다!
|
|
```
|
|
|
|
### **모든 예외 처리 (`rescue StandardError`)**
|
|
|
|
모든 예외를 처리하려면 `rescue StandardError`를 사용한다.
|
|
|
|
```ruby
|
|
begin
|
|
puts 10 / 0
|
|
rescue StandardError => e
|
|
puts "예외 발생: #{e.message}"
|
|
end
|
|
```
|
|
|
|
출력:
|
|
```
|
|
예외 발생: divided by 0
|
|
```
|
|
|
|
### **예외 발생 여부와 관계없이 실행 (`ensure`)**
|
|
|
|
`ensure` 블록을 사용하면 **예외 발생 여부와 관계없이** 반드시 실행해야 하는 코드를 넣을 수 있다.
|
|
|
|
```ruby
|
|
begin
|
|
file = File.open("example.txt", "r")
|
|
puts file.read
|
|
rescue Errno::ENOENT
|
|
puts "파일을 찾을 수 없습니다!"
|
|
ensure
|
|
file.close if file # 파일이 열려 있다면 닫기
|
|
end
|
|
```
|
|
|
|
---
|
|
|
|
## **3. 예외 강제 발생 (`raise`)**
|
|
|
|
`raise` 문을 사용하면 강제로 예외를 발생시킬 수 있다.
|
|
|
|
```ruby
|
|
def divide(a, b)
|
|
raise ArgumentError, "0으로 나눌 수 없습니다!" if b == 0
|
|
a / b
|
|
end
|
|
|
|
begin
|
|
puts divide(10, 0)
|
|
rescue ArgumentError => e
|
|
puts "오류 발생: #{e.message}"
|
|
end
|
|
```
|
|
|
|
출력:
|
|
```
|
|
오류 발생: 0으로 나눌 수 없습니다!
|
|
```
|
|
|
|
---
|
|
|
|
## **4. 사용자 정의 예외 클래스**
|
|
|
|
Ruby에서는 예외 클래스를 직접 정의할 수도 있다.
|
|
|
|
```ruby
|
|
class CustomError < StandardError; end
|
|
|
|
def check_value(value)
|
|
raise CustomError, "값이 너무 큽니다!" if value > 100
|
|
end
|
|
|
|
begin
|
|
check_value(200)
|
|
rescue CustomError => e
|
|
puts "사용자 정의 예외 발생: #{e.message}"
|
|
end
|
|
```
|
|
|
|
출력:
|
|
```
|
|
사용자 정의 예외 발생: 값이 너무 큽니다!
|
|
```
|
|
|
|
---
|
|
|
|
## **5. 디버깅 기법**
|
|
|
|
디버깅(Debugging)은 프로그램의 오류를 찾아 수정하는 과정이다. Ruby에서 디버깅하는 방법을 알아보자.
|
|
|
|
### **5.1. `puts`와 `p`로 값 출력**
|
|
|
|
가장 간단한 방법은 `puts` 또는 `p`를 사용해 변수 값을 확인하는 것이다.
|
|
|
|
```ruby
|
|
name = "홍길동"
|
|
puts "이름: #{name}"
|
|
p name # `p`는 데이터 타입까지 출력해 줌
|
|
```
|
|
|
|
---
|
|
|
|
### **5.2. `irb`(Interactive Ruby) 사용**
|
|
|
|
Ruby의 대화형 콘솔 `irb`를 활용하면 코드를 실행하며 디버깅할 수 있다.
|
|
|
|
```sh
|
|
$ irb
|
|
irb(main):001:0> 10 / 2
|
|
=> 5
|
|
irb(main):002:0> "hello".upcase
|
|
=> "HELLO"
|
|
```
|
|
|
|
---
|
|
|
|
### **5.3. `binding.irb`로 중간 디버깅**
|
|
|
|
`binding.irb`를 코드 중간에 넣으면 특정 지점에서 실행을 멈추고 `irb`에서 값을 확인할 수 있다.
|
|
|
|
```ruby
|
|
require "irb"
|
|
|
|
def debug_example
|
|
x = 10
|
|
y = 20
|
|
binding.irb # 여기서 실행이 멈추고 irb에서 값을 확인할 수 있음
|
|
z = x + y
|
|
puts z
|
|
end
|
|
|
|
debug_example
|
|
```
|
|
|
|
---
|
|
|
|
### **5.4. `debug` 라이브러리 사용**
|
|
|
|
Ruby 3.1부터 `debug` 라이브러리를 기본으로 제공하며, 이를 이용하면 강력한 디버깅이 가능하다.
|
|
|
|
#### **설치 및 실행 방법**
|
|
|
|
1. `debug` 라이브러리 설치 (`Ruby 3.1 이상에서는 기본 제공`)
|
|
|
|
```sh
|
|
gem install debug
|
|
```
|
|
|
|
2. 코드에 `require "debug"` 추가
|
|
|
|
```ruby
|
|
require "debug"
|
|
|
|
def test_method
|
|
x = 5
|
|
y = 10
|
|
debugger # 여기서 실행이 멈춤
|
|
z = x + y
|
|
puts z
|
|
end
|
|
|
|
test_method
|
|
```
|
|
|
|
3. 프로그램 실행 시 디버깅 모드가 활성화됨
|
|
|
|
```sh
|
|
(rdbg) p x
|
|
5
|
|
(rdbg) next
|
|
(rdbg) continue
|
|
```
|
|
|
|
---
|
|
|
|
## **6. 마무리**
|
|
|
|
이번 글에서는 **Ruby에서 예외 처리와 디버깅 기법**을 살펴보았다.
|
|
|
|
### **📌 예외 처리 정리**
|
|
- `begin-rescue` → 예외 처리
|
|
- `ensure` → 예외 발생 여부와 관계없이 실행
|
|
- `raise` → 강제 예외 발생
|
|
- 사용자 정의 예외 → `class CustomError < StandardError`
|
|
|
|
### **📌 디버깅 기법 정리**
|
|
- `puts`, `p` → 변수 값 출력
|
|
- `irb` → 대화형 실행
|
|
- `binding.irb` → 특정 지점에서 멈추고 값 확인
|
|
- `debugger` → 정식 디버깅 툴 사용 (`debug` 라이브러리)
|
|
|
|
이제 예외를 안전하게 처리하고, 버그를 효과적으로 찾아 수정할 수 있다! |