PHP json_decode 深入解析：从请求体中获取字符串数组的正确姿势

var jsonArray = ["String1", "String2"];
await newFile(JSON.stringify(jsonArray)); // 发送 "[\"String1\",\"String2\"]"

$requestData = json_decode($request->getContent(), true);
$this->logger->info("File request data is ", [ $requestData ]);

File request data is  ["[\"String1\",\"String2\"]"]

$jsonString = '["Test", "Test2"]';
$array = json_decode($jsonString, true);
var_dump($array);
/* 输出：
array(2) {
  [0]=>
  string(4) "Test"
  [1]=>
  string(5) "Test2"
}
*/

"[\"[\"String1\",\"String2\"]\"]"

// 假设 $request->getContent() 返回的是类似于 "[\"[\"String1\",\"String2\"]\"]" 的JSON字符串
$requestData = json_decode($request->getContent(), true);

// 此时 $requestData 的结构是 array(0 => "[\"String1\",\"String2\"]")
$this->logger->info("第一次解码后的数据: ", [ $requestData ]);

// 检查数据类型，确保它是我们期望的格式
if (is_array($requestData) && count($requestData) > 0 && is_string($requestData[0])) {
    // 提取出内部的JSON字符串
    $innerJsonString = $requestData[0];

    // 对内部的JSON字符串进行第二次解码
    $finalArray = json_decode($innerJsonString, true);

    // 检查第二次解码是否成功
    if (json_last_error() === JSON_ERROR_NONE) {
        $this->logger->info("最终解码的字符串数组: ", [ $finalArray ]);
        // 此时 $finalArray 将是 ['String1', 'String2']
    } else {
        $this->logger->error("第二次JSON解码失败: " . json_last_error_msg());
    }
} else {
    $this->logger->error("请求数据格式不符合预期，无法进行二次解码。", [$requestData]);
}

// 假设这是我们想要发送的字符串数组
var dataToSend = ["String1", "String2"];

// 通常情况下，我们只需要进行一次 JSON.stringify
// 如果你的框架或HTTP客户端自动处理了Content-Type: application/json，
// 并且直接发送了原始的JSON字符串，那么下面的 newFile 可能会直接接收字符串
// 但如果你的 newFile 方法内部又对数据进行了封装，则可能出现双重编码
// 示例中我们直接发送字符串化的结果
var jsonPayload = JSON.stringify(dataToSend); // 结果: "[\"String1\",\"String2\"]"

// 假设 newFile 是一个发送HTTP请求的函数
// 如果 newFile 内部又对 jsonPayload 进行了 JSON.stringify，则会导致双重编码
// 例如：await newFile(JSON.stringify(jsonPayload)); // 结果: "\"[\"String1\",\"String2\"]\""
// 甚至：await newFile(JSON.stringify([jsonPayload])); // 结果: "[\"[\"String1\",\"String2\"]\"]" (与问题现象一致)
// 在本例中，我们假设 newFile 接收的是 "[\"String1\",\"String2\"]"
// 但为了复现问题，我们假设它最终导致了 "[\"[\"String1\",\"String2\"]\"]" 被发送
async function newFile(payload) {
    const response = await fetch('/api/process-array', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        // 为了模拟问题中的双重编码现象，我们假设这里发送的是一个包含字符串化JSON的数组
        // 实际应用中应避免此操作，直接发送 jsonPayload 即可
        body: JSON.stringify([payload]) // 模拟发送 "[\"[\"String1\",\"String2\"]\"]"
    });
    const result = await response.json();
    console.log(result);
}

newFile(jsonPayload);

<?php

// 假设这是你的Logger接口或类
interface LoggerInterface {
    public function info(string $message, array $context = []);
    public function error(string $message, array $context = []);
}

// 模拟一个简单的Logger实现
class SimpleLogger implements LoggerInterface {
    public function info(string $message, array $context = []) {
        echo "INFO: " . $message . json_encode($context) . "\n";
    }
    public function error(string $message, array $context = []) {
        echo "ERROR: " . $message . json_encode($context) . "\n";
    }
}

// 模拟一个请求对象，getContent() 方法返回原始请求体
class Request {
    private $content;

    public function __construct(string $content) {
        $this->content = $content;
    }

    public function getContent(): string {
        return $this->content;
    }
}

// 模拟控制器处理逻辑
class MyController {
    private LoggerInterface $logger;

    public function __construct(LoggerInterface $logger) {
        $this->logger = $logger;
    }

    public function processArray(Request $request) {
        // 第一次解码：将外部的JSON结构解码
        // 假设 $request->getContent() 返回的是 "[\"[\"String1\",\"String2\"]\"]"
        $requestData = json_decode($request->getContent(), true);

        // 第一次解码后的数据可能看起来像这样：
        // array(1) {
        //   [0]=>
        //   string(20) "[\"String1\",\"String2\"]"
        // }
        $this->logger->info("第一次解码后的数据", [ $requestData ]);

        // 检查并进行第二次解码
        if (is_array($requestData) && !empty($requestData) && is_string($requestData[0])) {
            $innerJsonString = $requestData[0];
            $finalArray = json_decode($innerJsonString, true);

            if (json_last_error() === JSON_ERROR_NONE) {
                $this->logger->info("成功解码的字符串数组", [ $finalArray ]);
                // 此时 $finalArray 将是 ['String1', 'String2']
                // 你现在可以对 $finalArray 进行迭代或其他操作
                // 比如：foreach ($finalArray as $item) { echo $item . "\n"; }
            } else {
                $this->logger->error("第二次JSON解码失败: " . json_last_error_msg());
            }
        } else {
            $this->logger->error("请求数据格式不符合预期，无法进行二次解码。", [$requestData]);
        }
    }
}

// ---------------- 运行示例 ----------------
$logger = new SimpleLogger();
$controller = new MyController($logger);

// 模拟前端发送的数据，这里是导致问题的双重编码形式
$mockRequestContent = '["[\"String1\",\"String2\"]"]'; // 这是一个包含JSON字符串的JSON字符串
$request = new Request($mockRequestContent);

$controller->processArray($request);

// ---------------- 另一个正确的例子 ----------------
echo "\n--- 正确的单次编码请求 ---\n";
$mockCorrectRequestContent = '["StringA","StringB"]'; // 这是一个标准的JSON字符串数组
$correctRequest = new Request($mockCorrectRequestContent);
$controller->processArray($correctRequest); // 这个例子会触发 else 分支，因为 $requestData[0] 不是一个JSON字符串
// 对于这种标准情况，我们只需要一次 json_decode
echo "\n--- 针对标准单次编码请求的直接处理 ---\n";
$singleDecodedData = json_decode($mockCorrectRequestContent, true);
$logger->info("标准请求的直接解码", [$singleDecodedData]);

?>

INFO: 第一次解码后的数据[["[\"String1\",\"String2\"]"]]
INFO: 成功解码的字符串数组[["String1","String2"]]

--- 正确的单次编码请求 ---
INFO: 第一次解码后的数据[["StringA","StringB"]]
ERROR: 请求数据格式不符合预期，无法进行二次解码。[[["StringA","StringB"]]]

--- 针对标准单次编码请求的直接处理 ---
INFO: 标准请求的直接解码[["StringA","StringB"]]

// 如果前端只发送 "[\"String1\",\"String2\"]"
$finalArray = json_decode($request->getContent(), true);
if (json_last_error() === JSON_ERROR_NONE) {
    $this->logger->info("直接解码的字符串数组", [ $finalArray ]);
} else {
    $this->logger->error("JSON解码失败: " . json_last_error_msg());
}