PHP str_replace() 성능 저하와 메모리 누수 - 대용량 문자열 치환 완벽 해결

개발자라면 한 번쯤 문자열 치환 작업으로 골머리를 앓아본 경험이 있을 것이다. 특히 대용량 파일이나 HTML 템플릿을 다룰 때 str_replace() 함수를 무분별하게 사용하면 메모리가 급증하고 속도가 급격히 떨어진다. 다만 대부분의 개발자들은 이게 함수 자체의 문제인지, 아니면 사용 방식의 문제인지 구분하지 못한 채 단순히 '느리다'고만 느낀다. 이번에는 str_replace()가 정확히 어떻게 동작하는지, 왜 메모리 누수가 발생하는지, 그리고 어떻게 최적화하는지 완벽하게 정리해서 소개하겠다.

str_replace() 함수는 원본 문자열을 건드리지 않고 새로운 문자열을 생성해서 반환한다. PHP의 Copy-on-Write(CoW) 메커니즘 때문에 함수 내부에서는 원본 문자열과 결과 문자열이 동시에 메모리에 존재한다. 즉 100MB 파일을 치환하면, 그 순간 메모리에는 원본 100MB와 결과물 100MB가 동시에 할당된다. 이게 반복되거나 체인 형태로 여러 번 실행되면 메모리 폭발이 일어난다.

더 위험한 건 str_replace()에 배열을 넘길 때다. 많은 개발자들이 한 번에 여러 치환을 하려고 배열을 건넨다. 이 경우 각 치환마다 새로운 문자열이 임시로 생성되었다가 버려지는데, PHP의 가비지 컬렉션이 즉시 이루어지지 않으면 메모리가 쌓인다.

✗ 문제 있는 코드

<?php
$content = file_get_contents('large_file.html'); // 50MB

$search = ['{{name}}', '{{email}}', '{{phone}}'];
$replace = ['John', 'john@example.com', '010-1234-5678'];

// 위험: 각 치환마다 전체 문자열이 복사되고 메모리 누적
$content = str_replace($search, $replace, $content);

echo memory_get_usage() / 1024 / 1024; // 100MB 이상 사용
?>

이 코드는 50MB 파일에 대해 3번의 치환을 수행한다. 내부적으로는 각 단계마다 새로운 50MB 문자열이 생성되고, 일시적으로 메모리에 누적된다.

✓ 올바른 코드 - 정규표현식 + 콜백

<?php
$content = file_get_contents('large_file.html');

$replacements = [
    'name' => 'John',
    'email' => 'john@example.com',
    'phone' => '010-1234-5678'
];

// 한 번의 패스로 모든 치환 수행
$content = preg_replace_callback(
    '/\{\{(\w+)\}\}/',
    function($matches) use (6replacements) {
        return 6replacements[$matches[1]] ?? $matches[0];
    },
    $content
);

echo memory_get_usage() / 1024 / 1024; // 약 60MB 정도
?>

이 방식은 한 번의 패스에서 모든 패턴을 찾아 바꾼다. 메모리 오버헤드가 훨씬 적고, 복잡한 로직도 콜백 함수로 처리할 수 있다.

✗ 전체 파일을 메모리에 로드

<?php
// 100MB 파일을 한 번에 로드하면 메모리 초과 위험
$content = file_get_contents('huge_file.txt');
$content = str_replace('old_text', 'new_text', $content);
file_put_contents('output.txt', $content);
?>

✓ 청크 단위로 스트리밍 처리

<?php
$chunkSize = 8192; // 8KB 단위
$inputHandle = fopen('huge_file.txt', 'r');
$outputHandle = fopen('output.txt', 'w');

$buffer = '';
while (!feof($inputHandle)) {
    $chunk = fread($inputHandle, $chunkSize);
    $buffer .= $chunk;
    
    // 완전한 라인 단위로만 처리
    $lastNewline = strrpos($buffer, "\n");
    if ($lastNewline !== false) {
        $toProcess = substr($buffer, 0, $lastNewline + 1);
        $buffer = substr($buffer, $lastNewline + 1);
        
        $processed = str_replace('old_text', 'new_text', $toProcess);
        fwrite($outputHandle, $processed);
    }
}

// 남은 버퍼 처리
if (!empty($buffer)) {
    $processed = str_replace('old_text', 'new_text', $buffer);
    fwrite($outputHandle, $processed);
}

fclose($inputHandle);
fclose($outputHandle);
?>

이 방식은 어떤 크기의 파일이든 메모리 사용량을 일정하게 유지한다. 각 청크는 메모리에서 처리되고 즉시 버려진다.

많은 개발자가 간단한 템플릿 변수 치환에 str_replace()를 사용한다. 하지만 성능을 고려하면 다르게 구현해야 한다.

✗ 나쁜 예

<?php
class SimpleTemplate {
    public function render($template, $data) {
        $search = [];
        $replace = [];
        
        foreach ($data as $key => $value) {
            $search[] = '{{' . $key . '}}';
            $replace[] = $value;
        }
        
        // 배열이 클수록 메모리 폭발
        return str_replace($search, $replace, $template);
    }
}
?>

✓ 좋은 예 - 정규표현식 사용

<?php
class EfficientTemplate {
    private $data;
    
    public function render($template, $data) {
        $this->data = $data;
        
        // 한 번의 패스로 처리
        return preg_replace_callback(
            '/\{\{([a-zA-Z_][a-zA-Z0-9_.]*)\}\}/',
            [$this, 'replaceVariable'],
            $template
        );
    }
    
    private function replaceVariable($matches) {
        $key = $matches[1];
        
        // 점 표기법 지원 (예: user.name)
        if (strpos($key, '.') !== false) {
            $keys = explode('.', $key);
            $value = $this->data;
            
            foreach ($keys as $k) {
                if (is_array($value) && isset($value[$k])) {
                    $value = $value[$k];
                } else {
                    return $matches[0]; // 원래 형식 유지
                }
            }
            return $value;
        }
        
        return $this->data[$key] ?? $matches[0];
    }
}

$tpl = new EfficientTemplate();
$result = $tpl->render(
    'Hello {{user.name}}, your email is {{user.email}}',
    ['user' => ['name' => 'Alice', 'email' => 'alice@example.com']]
);
?>

이 구현은 배열 크기와 무관하게 한 번의 패스만 수행하고, 점 표기법으로 중첩된 데이터도 처리한다.

✗ 잘못된 것

<?php
// UTF-8 멀티바이트 문자가 포함되면 예기치 않은 결과 발생
$text = '한국어 텍스트';
$result = str_replace('글', '말', $text);
?>

✓ 올바른 것

<?php
// mb_* 함수 사용 또는 preg_replace 사용
$text = '한국어 텍스트';

// 방법 1: mb_str_replace (PHP 8.4+)
$result = mb_str_replace('글', '말', $text);

// 방법 2: preg_replace (모든 버전)
$result = preg_replace('/글/u', '말', $text);
?>

✗ 대소문자를 구분하지 않으려고 했는데 실패

<?php
$text = 'Hello HELLO hello';
$result = str_replace('hello', 'goodbye', $text);
// 결과: 'Hello HELLO goodbye' (소문자만 변경)
?>

✓ 올바른 것

<?php
$text = 'Hello HELLO hello';

// 방법 1: 정규표현식 i 플래그
$result = preg_replace('/hello/i', 'goodbye', $text);

// 방법 2: 수동 변환 후 치환
$lower = strtolower($text);
$result = str_replace('hello', 'goodbye', $lower);

// 결과: 'goodbye goodbye goodbye'
?>

✗ 위험한 코드

<?php
// A를 B로, B를 A로 치환하면 무한 루프 가능
$text = 'AAA';
$text = str_replace('A', 'B', $text); // 'BBB'
$text = str_replace('B', 'A', $text); // 'AAA' (원점 복귀)
?>

✓ 한 번에 처리

<?php
$text = 'AAA';
$search = ['A', 'B'];
$replace = ['B', 'A'];
$text = str_replace($search, $replace, $text); // 'BBB' (한 번에 처리)
?>

str_replace()는 편리하지만, 무분별하게 사용하면 메모리 낭비와 성능 저하를 초래한다. 배열을 인자로 넘길 때는 각 치환마다 문자열이 복사되는 점을 기억하고, 대용량 파일은 스트리밍으로 처리하며, 복잡한 패턴은 정규표현식을 활용해야 한다. 작은 최적화가 모여서 전체 애플리케이션의 응답 속도와 서버 자원 사용률을 크게 개선한다. 이 글의 스트리밍 처리 부분과 preg_replace_callback() 예제를 참고해서 프로젝트에 맞는 방식을 적용하면, 대규모 데이터를 다룰 때도 안정적인 성능을 유지할 수 있을 것이다.