PHP array_is_list() 函数详解

<?php
// 标准的列表（从0开始的连续整数键名）
$list1 = ['苹果', '香蕉', '橙子'];
echo "数组1: ";
print_r($list1);
echo "是否为列表: " . (array_is_list($list1) ? '是' : '否') . "\n\n";

// 空数组也是列表
$emptyArray = [];
echo "空数组: ";
print_r($emptyArray);
echo "是否为列表: " . (array_is_list($emptyArray) ? '是' : '否') . "\n\n";

// 关联数组（不是列表）
$assocArray = ['name' => '张三', 'age' => 25];
echo "关联数组: ";
print_r($assocArray);
echo "是否为列表: " . (array_is_list($assocArray) ? '是' : '否') . "\n\n";

// 键名不连续（不是列表）
$gappedArray = [0 => 'A', 2 => 'C', 1 => 'B'];
echo "键名不连续的数组: ";
print_r($gappedArray);
echo "是否为列表: " . (array_is_list($gappedArray) ? '是' : '否') . "\n\n";

// 键名不是从0开始（不是列表）
$notZeroBased = [1 => 'A', 2 => 'B', 3 => 'C'];
echo "不是从0开始的数组: ";
print_r($notZeroBased);
echo "是否为列表: " . (array_is_list($notZeroBased) ? '是' : '否') . "\n\n";

// 混合键名（不是列表）
$mixedKeys = [0 => 'A', 'key' => 'B', 1 => 'C'];
echo "混合键名数组: ";
print_r($mixedKeys);
echo "是否为列表: " . (array_is_list($mixedKeys) ? '是' : '否') . "\n";
?>

<?php
// 列表数组 - JSON编码为数组
$listArray = ['苹果', '香蕉', '橙子'];
echo "列表数组: ";
print_r($listArray);
echo "是否为列表: " . (array_is_list($listArray) ? '是' : '否') . "\n";
echo "JSON编码: " . json_encode($listArray) . "\n\n";

// 非列表数组 - JSON编码为对象
$nonListArray = [0 => '苹果', 2 => '橙子'];
echo "非列表数组: ";
print_r($nonListArray);
echo "是否为列表: " . (array_is_list($nonListArray) ? '是' : '否') . "\n";
echo "JSON编码: " . json_encode($nonListArray) . "\n\n";

// 关联数组 - JSON编码为对象
$assocArray = ['first' => '苹果', 'second' => '香蕉'];
echo "关联数组: ";
print_r($assocArray);
echo "是否为列表: " . (array_is_list($assocArray) ? '是' : '否') . "\n";
echo "JSON编码: " . json_encode($assocArray) . "\n\n";

// 在实际应用中，确保数据在API响应中保持正确的结构非常重要
function api_response($data) {
    // 检查数据结构，确保JSON编码符合预期
    if (array_is_list($data)) {
        echo "返回数组结构\n";
    } else {
        echo "返回对象结构\n";
    }

    return json_encode($data, JSON_PRETTY_PRINT);
}

echo "API响应示例:\n";
echo api_response($listArray) . "\n";
?>

<?php
// API数据处理类
class ApiDataValidator {
    /**
     * 验证数据是否为预期的列表结构
     */
    public static function validateListStructure($data, $fieldName = '数据') {
        if (!is_array($data)) {
            throw new InvalidArgumentException("{$fieldName} 必须是数组");
        }

        if (!array_is_list($data)) {
            throw new InvalidArgumentException("{$fieldName} 必须是列表结构（从0开始的连续整数键名）");
        }

        return true;
    }

    /**
     * 标准化数据为列表结构
     */
    public static function normalizeToList($data) {
        if (array_is_list($data)) {
            return $data; // 已经是列表，直接返回
        }

        // 如果不是列表，尝试转换为列表
        $values = array_values($data);

        // 检查转换后的结果是否为列表
        if (!array_is_list($values)) {
            throw new RuntimeException("无法将数据标准化为列表结构");
        }

        return $values;
    }

    /**
     * 处理API请求数据
     */
    public static function processApiData($inputData) {
        $result = [
            'success' => true,
            'errors' => [],
            'normalized_data' => null
        ];

        try {
            // 验证输入数据
            self::validateListStructure($inputData, '输入数据');
            $result['normalized_data'] = $inputData;

        } catch (InvalidArgumentException $e) {
            // 如果不是列表，尝试标准化
            $result['success'] = false;
            $result['errors'][] = $e->getMessage();

            try {
                $result['normalized_data'] = self::normalizeToList($inputData);
                $result['success'] = true;
                $result['errors'] = [];
                $result['message'] = '数据已自动标准化为列表结构';
            } catch (RuntimeException $e2) {
                $result['errors'][] = $e2->getMessage();
            }
        }

        return $result;
    }
}

// 测试各种数据情况
$testCases = [
    '标准列表' => ['苹果', '香蕉', '橙子'],
    '空列表' => [],
    '关联数组' => ['a' => '苹果', 'b' => '香蕉'],
    '非连续索引' => [0 => '苹果', 2 => '橙子'],
    '非零起始' => [1 => '香蕉', 2 => '橙子'],
    '混合键名' => [0 => '苹果', 'fruit' => '香蕉', 1 => '橙子']
];

foreach ($testCases as $caseName => $testData) {
    echo "=== {$caseName} ===\n";
    echo "原始数据: ";
    print_r($testData);

    $result = ApiDataValidator::processApiData($testData);
    echo "处理结果:\n";
    print_r($result);
    echo "\n";
}

// 实际API使用示例
function handle_user_list_api($userIds) {
    try {
        ApiDataValidator::validateListStructure($userIds, '用户ID列表');

        // 如果是列表，继续处理
        echo "用户ID列表验证通过，开始处理...\n";

        // 模拟数据库查询
        $users = [];
        foreach ($userIds as $index => $userId) {
            $users[$index] = [
                'id' => $userId,
                'name' => "用户{$userId}",
                'position' => $index
            ];
        }

        return [
            'success' => true,
            'data' => $users,
            'count' => count($users)
        ];

    } catch (InvalidArgumentException $e) {
        return [
            'success' => false,
            'error' => $e->getMessage(),
            'suggestion' => '请提供从0开始的连续整数索引数组'
        ];
    }
}

// 测试API处理
echo "=== API处理测试 ===\n";
$validUserIds = [101, 102, 103, 104];
$invalidUserIds = ['user1' => 101, 'user2' => 102];

$result1 = handle_user_list_api($validUserIds);
echo "有效数据结果:\n";
print_r($result1);

$result2 = handle_user_list_api($invalidUserIds);
echo "无效数据结果:\n";
print_r($result2);
?>

<?php
// 数据迁移工具类
class DataMigration {
    /**
     * 确保数据在系统间迁移时保持列表结构
     */
    public static function migrateListData($sourceData, $options = []) {
        $defaultOptions = [
            'strict_validation' => false,
            'auto_normalize' => true,
            'preserve_keys' => false
        ];

        $options = array_merge($defaultOptions, $options);

        $migrationResult = [
            'source_type' => array_is_list($sourceData) ? 'list' : 'non_list',
            'normalized' => false,
            'data' => $sourceData,
            'warnings' => []
        ];

        // 严格验证模式
        if ($options['strict_validation'] && !array_is_list($sourceData)) {
            throw new RuntimeException('源数据不是列表结构，迁移中止');
        }

        // 自动标准化
        if ($options['auto_normalize'] && !array_is_list($sourceData)) {
            if ($options['preserve_keys']) {
                $migrationResult['warnings'][] = '在保留键名的情况下无法标准化为列表';
            } else {
                $migrationResult['data'] = array_values($sourceData);
                $migrationResult['normalized'] = true;
                $migrationResult['warnings'][] = '数据已自动标准化为列表结构';
            }
        }

        // 最终验证
        if (!array_is_list($migrationResult['data'])) {
            $migrationResult['warnings'][] = '最终数据不是列表结构，可能在JSON编码时变为对象';
        }

        return $migrationResult;
    }

    /**
     * 批量迁移数据
     */
    public static function batchMigrate($dataSets) {
        $results = [];

        foreach ($dataSets as $setName => $data) {
            try {
                $results[$setName] = self::migrateListData($data, [
                    'auto_normalize' => true,
                    'preserve_keys' => false
                ]);
            } catch (Exception $e) {
                $results[$setName] = [
                    'error' => $e->getMessage(),
                    'data' => $data
                ];
            }
        }

        return $results;
    }
}

// 测试数据迁移
$testDataSets = [
    '用户列表' => ['张三', '李四', '王五'],
    '产品数组' => [0 => '手机', 1 => '电脑', 2 => '平板'],
    '价格表' => ['price_a' => 100, 'price_b' => 200],
    '不连续索引' => [0 => 'A', 2 => 'C'],
    '混合数据' => [0 => '第一项', 'key' => '关联项', 1 => '第二项']
];

echo "=== 数据迁移测试 ===\n";
$migrationResults = DataMigration::batchMigrate($testDataSets);

foreach ($migrationResults as $setName => $result) {
    echo "--- {$setName} ---\n";

    if (isset($result['error'])) {
        echo "错误: {$result['error']}\n";
    } else {
        echo "源类型: {$result['source_type']}\n";
        echo "是否标准化: " . ($result['normalized'] ? '是' : '否') . "\n";

        if (!empty($result['warnings'])) {
            echo "警告:\n";
            foreach ($result['warnings'] as $warning) {
                echo "  - {$warning}\n";
            }
        }

        echo "最终数据: ";
        print_r($result['data']);
    }
    echo "\n";
}

// 数据库结果处理示例
class DatabaseResultProcessor {
    /**
     * 处理数据库查询结果，确保返回列表结构
     */
    public static function processQueryResult($result, $expectList = true) {
        $processed = [
            'is_list' => array_is_list($result),
            'item_count' => count($result),
            'data' => $result
        ];

        // 如果期望列表但不是列表，进行转换
        if ($expectList && !$processed['is_list']) {
            $processed['data'] = array_values($result);
            $processed['is_list'] = array_is_list($processed['data']);
            $processed['normalized'] = true;
        }

        return $processed;
    }

    /**
     * 处理分页数据
     */
    public static function processPaginatedData($data, $page, $perPage) {
        $result = self::processQueryResult($data);

        $paginationInfo = [
            'current_page' => $page,
            'per_page' => $perPage,
            'total_items' => $result['item_count'],
            'total_pages' => ceil($result['item_count'] / $perPage),
            'is_list' => $result['is_list']
        ];

        return [
            'pagination' => $paginationInfo,
            'data' => $result['data']
        ];
    }
}

// 模拟数据库查询结果
$dbResults = [
    'numeric_keys' => [0 => ['id' => 1, 'name' => '产品A'], 1 => ['id' => 2, 'name' => '产品B']],
    'string_keys' => ['first' => ['id' => 1, 'name' => '用户A'], 'second' => ['id' => 2, 'name' => '用户B']],
    'mixed_keys' => [0 => ['id' => 1, 'name' => '订单A'], 'latest' => ['id' => 2, 'name' => '订单B']]
];

echo "=== 数据库结果处理 ===\n";
foreach ($dbResults as $resultType => $data) {
    echo "--- {$resultType} ---\n";
    $processed = DatabaseResultProcessor::processQueryResult($data, true);
    echo "处理结果:\n";
    print_r($processed);
    echo "\n";
}

// 分页数据示例
$pagedData = [
    0 => ['id' => 1, 'title' => '文章1'],
    1 => ['id' => 2, 'title' => '文章2'],
    2 => ['id' => 3, 'title' => '文章3']
];

$paginated = DatabaseResultProcessor::processPaginatedData($pagedData, 1, 2);
echo "分页数据结果:\n";
print_r($paginated);
?>

<?php
// 配置文件验证类
class ConfigValidator {
    /**
     * 验证配置文件中的数组结构
     */
    public static function validateConfig($config, $rules) {
        $errors = [];
        $warnings = [];

        foreach ($rules as $key => $rule) {
            if (!array_key_exists($key, $config)) {
                if ($rule['required'] ?? false) {
                    $errors[] = "缺少必需的配置项: {$key}";
                }
                continue;
            }

            $value = $config[$key];

            // 检查数组类型规则
            if (isset($rule['array_type'])) {
                if ($rule['array_type'] === 'list' && !array_is_list($value)) {
                    $errors[] = "配置项 {$key} 必须是列表结构";
                } elseif ($rule['array_type'] === 'assoc' && array_is_list($value)) {
                    $warnings[] = "配置项 {$key} 是列表结构，但期望关联数组";
                }
            }

            // 检查最小/最大长度
            if (is_array($value)) {
                if (isset($rule['min_length']) && count($value) < $rule['min_length']) {
                    $errors[] = "配置项 {$key} 至少需要 {$rule['min_length']} 个元素";
                }
                if (isset($rule['max_length']) && count($value) > $rule['max_length']) {
                    $warnings[] = "配置项 {$key} 超过最大长度 {$rule['max_length']}";
                }
            }
        }

        return [
            'valid' => empty($errors),
            'errors' => $errors,
            'warnings' => $warnings
        ];
    }
}

// 配置文件示例
$appConfig = [
    'allowed_file_types' => ['jpg', 'png', 'gif'], // 应该是列表
    'user_roles' => ['admin' => '管理员', 'user' => '用户'], // 应该是关联数组
    'default_settings' => ['theme' => 'dark', 'language' => 'zh-CN'], // 应该是关联数组
    'feature_flags' => [true, false, true], // 应该是列表
    'api_endpoints' => [0 => '/api/v1/users', 2 => '/api/v1/products'] // 有问题的列表
];

// 验证规则
$validationRules = [
    'allowed_file_types' => [
        'required' => true,
        'array_type' => 'list',
        'min_length' => 1
    ],
    'user_roles' => [
        'required' => true,
        'array_type' => 'assoc'
    ],
    'default_settings' => [
        'required' => false,
        'array_type' => 'assoc'
    ],
    'feature_flags' => [
        'required' => true,
        'array_type' => 'list',
        'max_length' => 10
    ],
    'api_endpoints' => [
        'required' => true,
        'array_type' => 'list'
    ]
];

echo "=== 配置文件验证 ===\n";
echo "配置文件:\n";
print_r($appConfig);

$validationResult = ConfigValidator::validateConfig($appConfig, $validationRules);

echo "验证结果:\n";
echo "是否有效: " . ($validationResult['valid'] ? '是' : '否') . "\n";

if (!empty($validationResult['errors'])) {
    echo "错误:\n";
    foreach ($validationResult['errors'] as $error) {
        echo "  - {$error}\n";
    }
}

if (!empty($validationResult['warnings'])) {
    echo "警告:\n";
    foreach ($validationResult['warnings'] as $warning) {
        echo "  - {$warning}\n";
    }
}

// 表单数据处理
class FormDataProcessor {
    /**
     * 处理多值表单字段（如复选框）
     */
    public static function processMultiValueField($fieldName, $formData) {
        $value = $formData[$fieldName] ?? null;

        if ($value === null) {
            return [];
        }

        // 如果是字符串，尝试分割
        if (is_string($value)) {
            $value = explode(',', $value);
        }

        // 确保结果是列表
        if (!array_is_list($value)) {
            $value = array_values($value);
        }

        return $value;
    }

    /**
     * 验证表单数组字段
     */
    public static function validateArrayField($fieldName, $formData, $rules) {
        $value = $formData[$fieldName] ?? null;
        $errors = [];

        if ($rules['required'] && ($value === null || (is_array($value) && empty($value)))) {
            $errors[] = "{$fieldName} 是必填字段";
            return [false, $errors, []];
        }

        if (!is_array($value)) {
            $errors[] = "{$fieldName} 必须是数组";
            return [false, $errors, []];
        }

        // 检查数组类型
        if ($rules['array_type'] === 'list' && !array_is_list($value)) {
            $errors[] = "{$fieldName} 必须是列表格式";
        }

        // 检查元素数量
        if (isset($rules['min_count']) && count($value) < $rules['min_count']) {
            $errors[] = "{$fieldName} 至少需要 {$rules['min_count']} 个选项";
        }

        if (isset($rules['max_count']) && count($value) > $rules['max_count']) {
            $errors[] = "{$fieldName} 最多允许 {$rules['max_count']} 个选项";
        }

        $valid = empty($errors);
        return [$valid, $errors, $value];
    }
}

// 模拟表单数据
$formData = [
    'interests' => ['编程', '阅读', '运动'], // 多选兴趣
    'user_ids' => '101,102,103', // 逗号分隔的字符串
    'settings' => ['theme' => 'dark', 'notifications' => true], // 关联数组
    'tags' => [0 => 'PHP', 2 => 'JavaScript'] // 不连续的列表
];

echo "\n=== 表单数据处理 ===\n";
echo "原始表单数据:\n";
print_r($formData);

// 处理多值字段
$interests = FormDataProcessor::processMultiValueField('interests', $formData);
$userIds = FormDataProcessor::processMultiValueField('user_ids', $formData);

echo "处理后的兴趣: ";
print_r($interests);
echo "处理后的用户ID: ";
print_r($userIds);

// 验证表单字段
$validationRules = [
    'interests' => [
        'required' => true,
        'array_type' => 'list',
        'min_count' => 1,
        'max_count' => 5
    ],
    'tags' => [
        'required' => false,
        'array_type' => 'list'
    ]
];

foreach (['interests', 'tags'] as $field) {
    echo "验证字段: {$field}\n";
    list($valid, $errors, $value) = FormDataProcessor::validateArrayField($field, $formData, $validationRules[$field]);

    echo "是否有效: " . ($valid ? '是' : '否') . "\n";
    if (!empty($errors)) {
        echo "错误: " . implode(', ', $errors) . "\n";
    }
    echo "值: ";
    print_r($value);
    echo "\n";
}
?>

<?php
/**
 * array_is_list() 的兼容性实现
 * 用于 PHP 8.1 以下的版本
 */
if (!function_exists('array_is_list')) {
    function array_is_list(array $array) {
        if (empty($array)) {
            return true;
        }

        // 方法1: 检查键名是否为从0开始的连续整数
        $expectedKey = 0;
        foreach ($array as $key => $value) {
            if ($key !== $expectedKey++) {
                return false;
            }
        }

        return true;

        // 方法2: 使用 array_keys() 比较（性能稍差但更直观）
        // return array_keys($array) === range(0, count($array) - 1);
    }
}

/**
 * 增强的列表检查函数，提供更多选项
 */
function array_is_list_enhanced($array, $options = []) {
    $defaultOptions = [
        'allow_empty' => true,
        'strict_index_check' => true,
        'min_length' => 0,
        'max_length' => null
    ];

    $options = array_merge($defaultOptions, $options);

    // 基本检查
    if (!is_array($array)) {
        return false;
    }

    if (empty($array)) {
        return $options['allow_empty'];
    }

    // 使用原生的 array_is_list 或兼容实现
    if (!array_is_list($array)) {
        return false;
    }

    // 检查长度限制
    $length = count($array);
    if ($length < $options['min_length']) {
        return false;
    }

    if ($options['max_length'] !== null && $length > $options['max_length']) {
        return false;
    }

    return true;
}

// 测试兼容性函数
$testArrays = [
    '标准列表' => ['a', 'b', 'c'],
    '空数组' => [],
    '关联数组' => ['x' => 'a', 'y' => 'b'],
    '非连续' => [0 => 'a', 2 => 'c'],
    '非零开始' => [1 => 'a', 2 => 'b']
];

echo "=== 兼容性函数测试 ===\n";
foreach ($testArrays as $name => $array) {
    $isList = array_is_list($array);
    $isListEnhanced = array_is_list_enhanced($array, ['min_length' => 1]);

    echo "{$name}: " . (json_encode($array)) . "\n";
    echo "  array_is_list: " . ($isList ? 'true' : 'false') . "\n";
    echo "  enhanced (min_length=1): " . ($isListEnhanced ? 'true' : 'false') . "\n\n";
}

// 性能比较
function benchmark_list_functions() {
    $testArray = range(0, 1000);
    $iterations = 1000;

    // 测试兼容性实现
    $start = microtime(true);
    for ($i = 0; $i < $iterations; $i++) {
        $result = array_is_list($testArray);
    }
    $time1 = microtime(true) - $start;

    // 测试 array_keys 方法
    $start = microtime(true);
    for ($i = 0; $i < $iterations; $i++) {
        $result = array_keys($testArray) === range(0, count($testArray) - 1);
    }
    $time2 = microtime(true) - $start;

    echo "性能比较 ({$iterations} 次迭代):\n";
    echo "兼容性实现: " . round($time1, 4) . " 秒\n";
    echo "array_keys 方法: " . round($time2, 4) . " 秒\n";
}

benchmark_list_functions();

// 实际应用中的兼容性处理
class ListCompatibility {
    /**
     * 安全地检查数组是否为列表，自动处理版本兼容性
     */
    public static function safeIsList($array, $normalizeIfFalse = false) {
        if (!is_array($array)) {
            if ($normalizeIfFalse) {
                return [$array]; // 将非数组转换为单元素列表
            }
            return false;
        }

        $isList = array_is_list($array);

        if (!$isList && $normalizeIfFalse) {
            // 尝试标准化为列表
            return array_values($array);
        }

        return $isList;
    }

    /**
     * 确保数据在跨版本环境中保持列表结构
     */
    public static function ensureListStructure($data, $context = 'unknown') {
        $result = self::safeIsList($data, true);

        if (is_array($result) && array_is_list($result)) {
            return [
                'success' => true,
                'data' => $result,
                'normalized' => $result !== $data,
                'context' => $context
            ];
        }

        return [
            'success' => false,
            'data' => $data,
            'error' => '无法将数据转换为列表结构',
            'context' => $context
        ];
    }
}

// 测试兼容性处理
echo "\n=== 兼容性处理测试 ===\n";
$testData = [
    '字符串' => 'hello',
    '列表' => [1, 2, 3],
    '关联数组' => ['a' => 1, 'b' => 2],
    '非连续' => [0 => 'x', 2 => 'z']
];

foreach ($testData as $type => $data) {
    $result = ListCompatibility::ensureListStructure($data, $type);
    echo "类型: {$type}\n";
    echo "结果: " . ($result['success'] ? '成功' : '失败') . "\n";

    if ($result['success']) {
        echo "是否标准化: " . ($result['normalized'] ? '是' : '否') . "\n";
        echo "最终数据: ";
        print_r($result['data']);
    } else {
        echo "错误: {$result['error']}\n";
    }
    echo "\n";
}
?>

<?php
/**
 * 数组工具类 - 专门处理列表相关操作
 */
class ArrayListUtils {
    /**
     * 深度检查多维数组是否全部为列表
     */
    public static function isListRecursive($array) {
        if (!is_array($array)) {
            return false;
        }

        if (!array_is_list($array)) {
            return false;
        }

        foreach ($array as $item) {
            if (is_array($item) && !self::isListRecursive($item)) {
                return false;
            }
        }

        return true;
    }

    /**
     * 将数组强制转换为列表结构
     */
    public static function toList($array, $preserveNumericKeys = false) {
        if (!is_array($array)) {
            return [$array];
        }

        if (array_is_list($array)) {
            return $array;
        }

        if ($preserveNumericKeys) {
            // 只保留数字键，重新索引
            $numericKeys = array_filter(array_keys($array), 'is_numeric');
            $result = [];
            foreach ($numericKeys as $key) {
                $result[] = $array[$key];
            }
            return $result;
        }

        return array_values($array);
    }

    /**
     * 检查并修复数组结构
     */
    public static function validateAndFixList($array, $options = []) {
        $defaultOptions = [
            'auto_fix' => true,
            'throw_errors' => false,
            'max_depth' => 5
        ];
        $options = array_merge($defaultOptions, $options);

        $result = [
            'original' => $array,
            'is_list' => array_is_list($array),
            'fixed' => null,
            'errors' => [],
            'warnings' => []
        ];

        if (!$result['is_list']) {
            if ($options['auto_fix']) {
                $result['fixed'] = self::toList($array);
                $result['warnings'][] = '数组已自动转换为列表结构';

                // 验证修复后的结果
                if (!array_is_list($result['fixed'])) {
                    $result['errors'][] = '自动修复失败';
                }
            } else {
                $result['errors'][] = '数组不是列表结构';
            }
        }

        if ($options['throw_errors'] && !empty($result['errors'])) {
            throw new RuntimeException(implode(', ', $result['errors']));
        }

        return $result;
    }

    /**
     * 批量处理数组列表
     */
    public static function processArrayList($data, $processor, $options = []) {
        if (!array_is_list($data)) {
            $data = self::toList($data);
        }

        $result = [];
        foreach ($data as $index => $item) {
            try {
                $result[$index] = $processor($item, $index);
            } catch (Exception $e) {
                if ($options['continue_on_error'] ?? false) {
                    $result[$index] = ['error' => $e->getMessage()];
                    continue;
                }
                throw $e;
            }
        }

        return $result;
    }
}

// 测试工具函数
echo "=== 数组列表工具函数测试 ===\n";

// 测试数据
$testData = [
    'simple_list' => [1, 2, 3],
    'nested_lists' => [[1, 2], [3, 4], [5, 6]],
    'mixed_structure' => ['a' => 1, 'b' => 2, 'c' => 3],
    'complex_nested' => [
        ['id' => 1, 'values' => [10, 20]],
        ['id' => 2, 'values' => [30, 40]]
    ]
];

foreach ($testData as $name => $data) {
    echo "--- {$name} ---\n";

    // 基本检查
    $isList = array_is_list($data);
    echo "是否为列表: " . ($isList ? '是' : '否') . "\n";

    // 递归检查
    $isListRecursive = ArrayListUtils::isListRecursive($data);
    echo "递归检查: " . ($isListRecursive ? '是' : '否') . "\n";

    // 验证和修复
    $validation = ArrayListUtils::validateAndFixList($data, ['auto_fix' => true]);
    echo "验证结果:\n";
    print_r($validation);
    echo "\n";
}

// 实际应用示例：数据处理管道
function create_data_pipeline($data) {
    // 步骤1: 确保列表结构
    $validated = ArrayListUtils::validateAndFixList($data, ['auto_fix' => true]);

    if (!empty($validated['errors'])) {
        throw new RuntimeException('数据格式验证失败: ' . implode(', ', $validated['errors']));
    }

    $processedData = $validated['fixed'] ?? $validated['original'];

    // 步骤2: 处理数据
    $result = ArrayListUtils::processArrayList($processedData, function($item, $index) {
        // 模拟数据处理
        if (is_array($item)) {
            return array_map(function($value) {
                return is_numeric($value) ? $value * 2 : strtoupper($value);
            }, $item);
        }

        return is_numeric($item) ? $item * 2 : strtoupper($item);
    }, ['continue_on_error' => true]);

    return [
        'input_data' => $data,
        'processed_data' => $result,
        'was_fixed' => $validated['fixed'] !== null,
        'processing_errors' => array_filter($result, function($item) {
            return is_array($item) && isset($item['error']);
        })
    ];
}

// 测试数据处理管道
echo "=== 数据处理管道测试 ===\n";
$pipelineInput = ['apple', 'banana', 'orange'];
$pipelineResult = create_data_pipeline($pipelineInput);

echo "输入数据: ";
print_r($pipelineResult['input_data']);
echo "处理结果: ";
print_r($pipelineResult['processed_data']);
echo "是否修复过: " . ($pipelineResult['was_fixed'] ? '是' : '否') . "\n";
?>