배열에서 중복된 요소를 제거할 때 가장 먼저 떠오르는 함수가 array_unique()다. 그런데 예상과 다르게 중복 값이 남아있거나, 숫자와 문자가 뒤섞여 있을 때 갑자기 작동을 멈춘다. 대부분의 개발자는 단순히 함수를 호출하고 결과를 받아들이지만, 실제로는 array_unique()의 동작 방식과 타입 비교 규칙을 정확히 이해하지 못한 채 넘어간다.

이번에는 array_unique()가 정확히 뭔지, 왜 예상대로 작동하지 않는지, 그리고 어떻게 올바르게 사용하는지 완벽하게 정리해서 소개하겠다.

 

array_unique() 기초 이해하기

array_unique()는 배열에서 중복된 값을 제거하는 함수다. 단순해 보이지만 내부적으로는 여러 세부 사항이 숨어있다.

기본 동작 원리: 첫 번째로 나타난 요소는 유지하고, 그 이후에 나타나는 같은 값은 삭제한다. 중요한 점은 배열의 키(key)를 보존한다는 것이다. 인덱스 배열이든 연관 배열이든 원래 위치의 키 정보가 살아남는다.

기본 타입 비교: array_unique()는 느슨한 타입 비교(loose comparison)를 사용한다. 즉, "1"(문자열)과 1(정수)을 같은 것으로 본다. 이 점이 많은 버그를 만든다.

 

타입 비교 옵션 완벽 정리

array_unique()의 두 번째 인자인 $flags는 비교 방식을 결정한다. 여기서 많은 개발자가 실수한다.

옵션 의미 동작
SORT_REGULAR(기본값) 느슨한 비교 1 == "1" (같음)
SORT_NUMERIC 숫자 비교 모든 값을 숫자로 변환 후 비교
SORT_STRING 문자열 비교 모든 값을 문자열로 변환 후 비교

 

실전 예제와 버그 해결

예제 1: 숫자와 문자가 섞여 있을 때

<?php
$arr = [1, "1", 2, "2", 3];

// ✗ 잘못된 코드: SORT_REGULAR로 비교하면 1과 "1"을 같은 것으로 봄
$result = array_unique($arr);
var_dump($result);
// 결과: array(3) { [0]=> int(1) [2]=> int(2) [4]=> int(3) }
// 문제: "1"과 "2"가 사라짐 (실제로는 다른 타입이지만 무시됨)

// ✓ 올바른 코드: SORT_STRING으로 명시해서 문자열만 비교
$result = array_unique($arr, SORT_STRING);
var_dump($result);
// 결과: array(5) { [0]=> int(1) [1]=> string(1) "1" [2]=> int(2) [3]=> string(1) "2" [4]=> int(3) }
// 타입이 다르므로 모두 유지됨
?>

첫 번째 경우, array_unique()는 1과 "1"을 같은 값으로 판단해서 "1"을 삭제했다. 하지만 SORT_STRING을 사용하면 타입까지 고려해서 다른 값으로 본다.

예제 2: 순환 소수와 정수 비교

<?php
$arr = [0, "0", "0.0", false, null, ""];

// ✗ 잘못된 코드: SORT_REGULAR에서 PHP의 느슨한 비교 규칙 적용
$result = array_unique($arr);
var_dump($result);
// 결과: array(1) { [0]=> int(0) }
// 문제: 0, "0", "0.0", false, null, "" 모두 같은 것으로 판단됨!

// ✓ 올바른 코드: SORT_STRING으로 엄격히 비교
$result = array_unique($arr, SORT_STRING);
var_dump($result);
// 결과: array(6) { [0]=> int(0) [1]=> string(1) "0" [2]=> string(3) "0.0" [3]=> bool(false) [4]=> NULL [5]=> string(0) "" }
// 모든 값이 다른 것으로 취급됨
?>

PHP의 느슨한 타입 비교는 0, false, null, 빈 문자열을 모두 "같은 것"으로 본다. 이 문제는 SORT_STRING으로도 완벽하게 해결되지 않는다. false와 null은 여전히 타입이 다르므로 남지만, "0"과 "0.0"은 문자열이므로 구분된다.

예제 3: 배열의 키 보존과 정렬 순서

<?php
$arr = [
    'name' => 'Alice',
    'email' => 'alice@example.com',
    'backup_name' => 'Alice',
    'backup_email' => 'alice@example.com'
];

// ✗ 잘못된 코드: 키는 보존되지만 순서가 뒤바뀔 수 있음
$result = array_unique($arr);
var_dump($result);
// 결과: array(2) { ['name']=> string(5) "Alice" ['email']=> string(18) "alice@example.com" }
// 'backup_name'과 'backup_email'이 삭제되고, 키는 유지됨

// ✓ 올바른 코드: 필요시 array_keys()로 키 목록 확인
$result = array_unique($arr);
$keys = array_keys($result);
var_dump($keys);
// 결과: array(2) { [0]=> string(4) "name" [1]=> string(5) "email" }
// 원래 키가 명확하게 보존됨
?>

array_unique()는 첫 번째로 나타난 키를 유지한다. "Alice"의 첫 번째 키는 'name'이므로 'backup_name'은 삭제되고 'name'이 남는다.

 

주의사항과 흔한 실수

✗ 실수 1: array_unique() 후 array_values() 없이 for 루프

<?php
$arr = [1, 2, 2, 3, 3, 3];
$unique = array_unique($arr);

// 위험: 키 갭이 생김
foreach ($unique as $index => $value) {
    echo $index . ': ' . $value . PHP_EOL;
}
// 출력: 0: 1 / 1: 2 / 3: 3 (인덱스 2가 없음)

// 반복 처리할 때는 array_values()로 인덱스 리셋
$unique = array_values(array_unique($arr));
foreach ($unique as $index => $value) {
    echo $index . ': ' . $value . PHP_EOL;
}
// 출력: 0: 1 / 1: 2 / 2: 3 (연속된 인덱스)
?>

✗ 실수 2: array_unique()는 중첩 배열(다차원)을 지원하지 않음

<?php
$arr = [
    ['id' => 1, 'name' => 'Alice'],
    ['id' => 2, 'name' => 'Bob'],
    ['id' => 1, 'name' => 'Alice']
];

// ✗ 잘못된 코드: 다차원 배열에는 작동하지 않음
$result = array_unique($arr);
var_dump($result);
// 결과: array(3) { [0]=> array(2) {...} [1]=> array(2) {...} [2]=> array(2) {...} }
// 아무것도 제거되지 않음

// ✓ 올바른 코드: JSON 직렬화로 비교
$result = array_unique(array_map('json_encode', $arr));
$result = array_map('json_decode', $result, [true]);
var_dump($result);
// 중복된 배열이 제거됨
?>

✗ 실수 3: 객체 배열에서 array_unique() 사용

<?php
class User {
    public function __construct(public int $id, public string $name) {}
}

$users = [
    new User(1, 'Alice'),
    new User(2, 'Bob'),
    new User(1, 'Alice')
];

// ✗ 잘못된 코드: 객체는 같은 내용이어도 다른 인스턴스로 간주됨
$result = array_unique($users);
var_dump(count($result));
// 결과: 3 (중복이 제거되지 않음)

// ✓ 올바른 코드: array_filter()로 직접 비교
$unique = [];
foreach ($users as $user) {
    $found = false;
    foreach ($unique as $existing) {
        if ($existing->id === $user->id && $existing->name === $user->name) {
            $found = true;
            break;
        }
    }
    if (!$found) {
        $unique[] = $user;
    }
}
var_dump(count($unique));
// 결과: 2 (중복이 제거됨)
?>

 

성능 최적화와 대안

array_unique()는 O(n log n) 시간 복잡도를 가진다. 대용량 배열에서는 느릴 수 있다.

빠른 대안: array_flip() + array_flip()

<?php
// 문자열/숫자 배열 전용
$arr = ['apple', 'banana', 'apple', 'cherry', 'banana'];

// array_unique() 사용
$start = microtime(true);
for ($i = 0; $i < 10000; $i++) {
    $result = array_unique($arr);
}
$time1 = microtime(true) - $start;

// array_flip() 두 번 사용 (더 빠름)
$start = microtime(true);
for ($i = 0; $i < 10000; $i++) {
    $result = array_flip(array_flip($arr));
}
$time2 = microtime(true) - $start;

echo "array_unique(): " . $time1 . "초\n";
echo "array_flip(): " . $time2 . "초\n";
// array_flip()이 약 1.5~2배 더 빠름
?>

array_flip()은 키와 값을 바꾸는데, 같은 값은 마지막 것만 남는다. 두 번 적용하면 중복을 제거하고 원래 형태로 돌아온다. 단, 정수형 키만 사용할 수 있다는 제한이 있다.

 

핵심 정리

array_unique()는 간단해 보이지만 타입 비교와 키 보존이라는 두 가지 중요한 특성이 있다. SORT_REGULAR(기본값)에서는 1과 "1"을 같은 것으로 보고, 0과 false도 구분하지 않는다. 연관 배열에서는 키가 보존되므로 순서가 뒤바뀔 수 있고, 다차원 배열이나 객체 배열에서는 작동하지 않는다.

이 함수를 올바르게 사용하려면 먼저 자신의 데이터가 어떤 타입인지, 타입 비교가 필요한지 명확히 하고, array_values()로 인덱스를 리셋해야 하는 상황인지 판단해야 한다. 대용량 배열에서는 array_flip()이 더 빠를 수 있다는 점도 기억해두자. 작은 최적화와 정확한 이해가 모여서 안정적인 데이터 처리를 만든다.