PHP usort 自定义排序：确保未匹配项置于末尾的正确实践

usort($itemsToSort, function($a, $b) use ($sortOrder){
   $valA = array_search($a[0], $sortOrder);
   $valB = array_search($b[0], $sortOrder);

   if ($valA === false) // 如果 $a 未找到
      return -1;        // 错误：这会让 $a 排在 $b 之前，而不是末尾
   if ($valB === false) // 如果 $b 未找到
      return 0;         // 错误：这会让 $a 和 $b 视为相等，未找到的 $b 不会被推到末尾

   if ($valA > $valB)
      return 1;
   if ($valA < $valB)
      return -1;
   return 0;
});

<?php

$itemsToSort = [
    ['item_c', 'data_c'],
    ['item_a', 'data_a'],
    ['item_x', 'data_x'], // 不在 $sortOrder 中
    ['item_b', 'data_b'],
    ['item_y', 'data_y'], // 不在 $sortOrder 中
    ['item_d', 'data_d'],
    ['item_z', 'data_z'], // 不在 $sortOrder 中
];

$sortOrder = ['item_a', 'item_b', 'item_c', 'item_d'];

echo "原始数组:\n";
print_r($itemsToSort);

usort($itemsToSort, function($a, $b) use ($sortOrder) {
    // 获取元素在 $sortOrder 中的位置，如果不存在则为 false
    $posA = array_search($a[0], $sortOrder);
    $posB = array_search($b[0], $sortOrder);

    // 判断元素是否在 $sortOrder 中找到
    $foundA = ($posA !== false);
    $foundB = ($posB !== false);

    // 情况1: $a 和 $b 都匹配 (在 $sortOrder 中找到)
    if ($foundA && $foundB) {
        // 根据它们在 $sortOrder 中的位置进行比较
        // PHP 7+ 可以使用 <=> 飞船操作符
        return $posA <=> $posB;
        /*
        // 对于 PHP < 7 的版本，需要手动实现
        if ($posA > $posB) return 1;
        if ($posA < $posB) return -1;
        return 0;
        */
    }
    // 情况2: 只有 $a 匹配，而 $b 不匹配
    elseif ($foundA) {
        // $a 应该排在 $b 之前（因为 $a 匹配，$b 不匹配）
        return -1;
    }
    // 情况3: 只有 $b 匹配，而 $a 不匹配
    elseif ($foundB) {
        // $b 应该排在 $a 之前（这意味着 $a 应该排在 $b 之后）
        return 1;
    }
    // 情况4: $a 和 $b 都不匹配
    else {
        // 它们都是未匹配项，对于本需求，它们的相对顺序不重要，保持原序即可
        // 如果需要对这些未匹配项内部进行排序（例如按字母顺序），可以在这里添加额外逻辑
        // return strcmp($a[0], $b[0]); // 示例：按第一个子元素字符串比较
        return 0;
    }
});

echo "\n排序后的数组:\n";
print_r($itemsToSort);

?>

原始数组:
Array
(
    [0] => Array
        (
            [0] => item_c
            [1] => data_c
        )

    [1] => Array
        (
            [0] => item_a
            [1] => data_a
        )

    [2] => Array
        (
            [0] => item_x
            [1] => data_x
        )

    [3] => Array
        (
            [0] => item_b
            [1] => data_b
        )

    [4] => Array
        (
            [0] => item_y
            [1] => data_y
        )

    [5] => Array
        (
            [0] => item_d
            [1] => data_d
        )

    [6] => Array
        (
            [0] => item_z
            [1] => data_z
        )

)

排序后的数组:
Array
(
    [0] => Array
        (
            [0] => item_a
            [1] => data_a
        )

    [1] => Array
        (
            [0] => item_b
            [1] => data_b
        )

    [2] => Array
        (
            [0] => item_c
            [1] => data_c
        )

    [3] => Array
        (
            [0] => item_d
            [1] => data_d
        )

    [4] => Array
        (
            [0] => item_x
            [1] => data_x
        )

    [5] => Array
        (
            [0] => item_y
            [1] => data_y
        )

    [6] => Array
        (
            [0] => item_z
            [1] => data_z
        )

)