让 PHP 停止替换 '.' $_GET 或 $_POST 数组中的字符？

Question

如果我通过 $_GET 传递名称中带有 . 的 PHP 变量，PHP 会自动将它们替换为 _ 字符。例如：

<?php
echo "url is ".$_SERVER['REQUEST_URI']."<p>";
echo "x.y is ".$_GET['x.y'].".<p>";
echo "x_y is ".$_GET['x_y'].".<p>";

... 输出以下内容：

url is /SpShipTool/php/testGetUrl.php?x.y=a.b
x.y is .
x_y is a.b.

...我的问题是：有没有任何方法可以阻止这种情况？无法为我的生活弄清楚我做了什么值得这个

我运行的 PHP 版本是 5.2.4-2ubuntu5.3。

Answer 1

以下是 PHP.net 对其原因的解释：

传入变量名中的点

通常，PHP 不会更改 变量名 传递到脚本中。然而，它 应该注意的是点（句号， 句号）不是一个有效的字符 PHP 变量名。由于这个原因， 看看吧：

<?php
$varname.ext;  /* invalid variable name */
?>

现在，什么 解析器看到的是一个名为的变量 $varname，后跟字符串 连接运算符，后跟 裸字符串（即不带引号的字符串 不匹配任何已知密钥或 保留字）'ext'。显然，这 没有达到预期的结果。

因此，重要的是 注意 PHP 会自动 替换传入变量中的任何点 带下划线的名称。

来自http://ca.php.net/variables.external。

另外，根据this comment，这些其他字符被转换为下划线：

PHP 转换为 _（下划线）的字段名称字符的完整列表如下（不仅仅是点）：

• chr(32) ( )（空格）
• chr(46) (.)（点）
• chr(91) ([)（左方括号）
• chr(128) - chr(159)（各种）

所以看起来你被它困住了，所以你必须使用dawnerd's suggestion 将脚本中的下划线转换回点（不过我只使用str_replace。）

Answer 2

很久以来回答的问题，但实际上有更好的答案（或解决方法）。 PHP 让你在raw input stream，所以你可以做这样的事情：

$query_string = file_get_contents('php://input');

这将为您提供查询字符串格式的 $_POST 数组，它们应该是句点。

然后你可以根据需要解析它（根据POSTer's comment）

<?php
// Function to fix up PHP's messing up input containing dots, etc.
// `$source` can be either 'POST' or 'GET'
function getRealInput($source) {
    $pairs = explode("&", $source == 'POST' ? file_get_contents("php://input") : $_SERVER['QUERY_STRING']);
    $vars = array();
    foreach ($pairs as $pair) {
        $nv = explode("=", $pair);
        $name = urldecode($nv[0]);
        $value = urldecode($nv[1]);
        $vars[$name] = $value;
    }
    return $vars;
}

// Wrapper functions specifically for GET and POST:
function getRealGET() { return getRealInput('GET'); }
function getRealPOST() { return getRealInput('POST'); }
?>

对于同时包含“.”的 OpenID 参数非常有用和'_'，每个都有一定的含义！

Answer 3

在上面的评论中突出显示 Johan 的实际答案 - 我只是将我的整个帖子包装在一个顶级数组中，它完全绕过了这个问题，不需要繁重的处理。

以你做的形式

<input name="data[database.username]">  
<input name="data[database.password]">  
<input name="data[something.else.really.deep]">  

而不是

<input name="database.username"> 
<input name="database.password"> 
<input name="something.else.really.deep">  

在 post 处理程序中，打开它：

$posdata = $_POST['data'];

对我来说，这是一个两行更改，因为我的视图完全是模板化的。

仅供参考。我在字段名称中使用点来编辑分组数据树。

Answer 4

您想要一个符合标准并适用于深度数组（例如：?param[2][5]=10）的解决方案吗？

要修复此问题的所有可能来源，您可以在 PHP 代码的最顶部应用：

$_GET    = fix( $_SERVER['QUERY_STRING'] );
$_POST   = fix( file_get_contents('php://input') );
$_COOKIE = fix( $_SERVER['HTTP_COOKIE'] );

这个函数的工作是我在 2013 年暑假期间提出的一个好主意。不要被一个简单的正则表达式气馁，它只是抓取所有查询名称，对它们进行编码（因此保留点），然后使用普通的parse_str() 函数。

function fix($source) {
    $source = preg_replace_callback(
        '/(^|(?<=&))[^=[&]+/',
        function($key) { return bin2hex(urldecode($key[0])); },
        $source
    );

    parse_str($source, $post);
    
    $result = array();
    foreach ($post as $key => $val) {
        $result[hex2bin($key)] = $val;
    }
    return $result;
}

p.s.：如果您在项目中使用此解决方案，请在功能上注明@author Rok Kralj。

Answer 5

发生这种情况是因为句点是变量名称中的无效字符，reason 在 PHP 的实现中非常深入，因此（目前）还没有简单的修复方法。

与此同时，您可以通过以下方式解决此问题：

1. 通过php://input 获取POST 数据或$_SERVER['QUERY_STRING'] 获取原始查询数据
2. 使用转换函数。

下面的转换函数（PHP >= 5.4）将每个键值对的名称编码为十六进制表示，然后执行常规的parse_str()；完成后，它将十六进制名称恢复为原始形式：

function parse_qs($data)
{
    $data = preg_replace_callback('/(?:^|(?<=&))[^=[]+/', function($match) {
        return bin2hex(urldecode($match[0]));
    }, $data);

    parse_str($data, $values);

    return array_combine(array_map('hex2bin', array_keys($values)), $values);
}

// work with the raw query string
$data = parse_qs($_SERVER['QUERY_STRING']);

或者：

// handle posted data (this only works with application/x-www-form-urlencoded)
$data = parse_qs(file_get_contents('php://input'));

Answer 6

这种方法是 Rok Kralj 的改进版本，但进行了一些调整以提高效率（避免对未受影响的键进行不必要的回调、编码和解码）并正确处理数组键。

gist with tests 可用，欢迎在这里或那里提供任何反馈或建议。

public function fix(&$target, $source, $keep = false) {                        
    if (!$source) {                                                            
        return;                                                                
    }                                                                          
    $keys = array();                                                           

    $source = preg_replace_callback(                                           
        '/                                                                     
        # Match at start of string or &                                        
        (?:^|(?<=&))                                                           
        # Exclude cases where the period is in brackets, e.g. foo[bar.blarg]
        [^=&\[]*                                                               
        # Affected cases: periods and spaces                                   
        (?:\.|%20)                                                             
        # Keep matching until assignment, next variable, end of string or   
        # start of an array                                                    
        [^=&\[]*                                                               
        /x',                                                                   
        function ($key) use (&$keys) {                                         
            $keys[] = $key = base64_encode(urldecode($key[0]));                
            return urlencode($key);                                            
        },                                                                     
    $source                                                                    
    );                                                                         

    if (!$keep) {                                                              
        $target = array();                                                     
    }                                                                          

    parse_str($source, $data);                                                 
    foreach ($data as $key => $val) {                                          
        // Only unprocess encoded keys                                      
        if (!in_array($key, $keys)) {                                          
            $target[$key] = $val;                                              
            continue;                                                          
        }                                                                      

        $key = base64_decode($key);                                            
        $target[$key] = $val;                                                  

        if ($keep) {                                                           
            // Keep a copy in the underscore key version                       
            $key = preg_replace('/(\.| )/', '_', $key);                        
            $target[$key] = $val;                                              
        }                                                                      
    }                                                                          
}                                                                              

Answer 7

发生这种情况的原因是 PHP 的旧 register_globals 功能。这 。字符不是变量名中的有效字符，因此 PHP 将其转换为下划线以确保兼容性。

简而言之，在 URL 变量中添加句点并不是一个好习惯。

Answer 8

如果寻找 any 方式来字面意思让 PHP 停止替换 '.' $_GET 或 $_POST 数组中的字符，那么一种方法是修改 PHP 的源代码（在这种情况下相对简单）。

警告：修改 PHP C 源代码是一个高级选项！

另请参阅PHP bug report，它建议进行相同的修改。

要探索，您需要：

• 下载PHP's C source code
• 禁用. 替换检查
• ./configure、make 并部署您自定义的 PHP 构建

源代码更改本身是微不足道的，只需更新one half of one line 中的main/php_variables.c：

....
/* ensure that we don't have spaces or dots in the variable name (not binary safe) */
for (p = var; *p; p++) {
    if (*p == ' ' /*|| *p == '.'*/) {
        *p='_';
....

注意：与原来的|| *p == '.'相比已被注释掉

---

示例输出：

给定一个 QUERY_STRING a.a[]=bb&a.a[]=BB&c%20c=dd， 运行 <?php print_r($_GET); 现在会产生：

大批 ( [a.a] => 数组 ( [0] => bb [1] => BB ) [c_c] => dd )

注意事项：

• 此补丁仅解决原始问题（它停止替换点，而不是空格）。
• 在此补丁上运行将比脚本级解决方案更快，但那些纯 .php 的答案通常仍然是可取的（因为它们避免更改 PHP 本身）。
• 理论上，这里可以使用 polyfill 方法，并且可以组合方法 - 使用 parse_str() 测试 C 级更改并（如果不可用）回退到较慢的方法。

Answer 9

我对这个问题的解决方案是快速而肮脏的，但我仍然喜欢它。我只是想发布在表单上检查的文件名列表。我使用base64_encode 对标记中的文件名进行编码，然后在使用它们之前使用base64_decode 对其进行解码。

Answer 10

在查看了 Rok 的解决方案后，我想出了一个版本，它解决了我在下面的答案、上面的 crb 和 Rok 的解决方案中的限制。见my improved version。

---

@crb 的回答 above 是一个好的开始，但有几个问题。

• 它会重新处理所有内容，这太过分了；只有那些有“。”的字段在名称中需要重新处理。
• 它无法像原生 PHP 处理那样处理数组，例如对于像“foo.bar[]”这样的键。

下面的解决方案现在解决了这两个问题（请注意，它自最初发布以来已更新）。在我的测试中，这比我上面的答案快了大约 50%，但不会处理数据具有相同键（或提取相同的键，例如 foo.bar 和 foo_bar 都被提取为 foo_bar）的情况。

<?php

public function fix2(&$target, $source, $keep = false) {                       
    if (!$source) {                                                            
        return;                                                                
    }                                                                          
    preg_match_all(                                                            
        '/                                                                     
        # Match at start of string or &                                        
        (?:^|(?<=&))                                                           
        # Exclude cases where the period is in brackets, e.g. foo[bar.blarg]
        [^=&\[]*                                                               
        # Affected cases: periods and spaces                                   
        (?:\.|%20)                                                             
        # Keep matching until assignment, next variable, end of string or   
        # start of an array                                                    
        [^=&\[]*                                                               
        /x',                                                                   
        $source,                                                               
        $matches                                                               
    );                                                                         

    foreach (current($matches) as $key) {                                      
        $key    = urldecode($key);                                             
        $badKey = preg_replace('/(\.| )/', '_', $key);                         

        if (isset($target[$badKey])) {                                         
            // Duplicate values may have already unset this                    
            $target[$key] = $target[$badKey];                                  

            if (!$keep) {                                                      
                unset($target[$badKey]);                                       
            }                                                                  
        }                                                                      
    }                                                                          
}                                                                              

Answer 11

好吧，我在下面包含的函数“getRealPostArray()”不是一个很好的解决方案，但它可以处理数组并支持两个名称：“alpha_beta”和“alpha.beta”：

  <input type='text' value='First-.' name='alpha.beta[a.b][]' /><br>
  <input type='text' value='Second-.' name='alpha.beta[a.b][]' /><br>
  <input type='text' value='First-_' name='alpha_beta[a.b][]' /><br>
  <input type='text' value='Second-_' name='alpha_beta[a.b][]' /><br>

而 var_dump($_POST) 产生：

  'alpha_beta' => 
    array (size=1)
      'a.b' => 
        array (size=4)
          0 => string 'First-.' (length=7)
          1 => string 'Second-.' (length=8)
          2 => string 'First-_' (length=7)
          3 => string 'Second-_' (length=8)

var_dump(getRealPostArray()) 产生：

  'alpha.beta' => 
    array (size=1)
      'a.b' => 
        array (size=2)
          0 => string 'First-.' (length=7)
          1 => string 'Second-.' (length=8)
  'alpha_beta' => 
    array (size=1)
      'a.b' => 
        array (size=2)
          0 => string 'First-_' (length=7)
          1 => string 'Second-_' (length=8)

功能，物有所值：

function getRealPostArray() {
  if ($_SERVER['REQUEST_METHOD'] !== 'POST') {#Nothing to do
      return null;
  }
  $neverANamePart = '~#~'; #Any arbitrary string never expected in a 'name'
  $postdata = file_get_contents("php://input");
  $post = [];
  $rebuiltpairs = [];
  $postraws = explode('&', $postdata);
  foreach ($postraws as $postraw) { #Each is a string like: 'xxxx=yyyy'
    $keyvalpair = explode('=',$postraw);
    if (empty($keyvalpair[1])) {
      $keyvalpair[1] = '';
    }
    $pos = strpos($keyvalpair[0],'%5B');
    if ($pos !== false) {
      $str1 = substr($keyvalpair[0], 0, $pos);
      $str2 = substr($keyvalpair[0], $pos);
      $str1 = str_replace('.',$neverANamePart,$str1);
      $keyvalpair[0] = $str1.$str2;
    } else {
      $keyvalpair[0] = str_replace('.',$neverANamePart,$keyvalpair[0]);
    }
    $rebuiltpair = implode('=',$keyvalpair);
    $rebuiltpairs[]=$rebuiltpair;
  }
  $rebuiltpostdata = implode('&',$rebuiltpairs);
  parse_str($rebuiltpostdata, $post);
  $fixedpost = [];
  foreach ($post as $key => $val) {
    $fixedpost[str_replace($neverANamePart,'.',$key)] = $val;
  }
  return $fixedpost;
}

Answer 12

使用 crb's 我想重新创建整个 $_POST 数组，但请记住，您仍然必须确保在客户端和服务器上都正确编码和解码。了解字符何时真正无效和真正有效非常重要。此外，人们应该仍然并始终在将客户端数据与任何数据库命令毫无例外地一起使用之前转义客户端数据。

<?php
unset($_POST);
$_POST = array();
$p0 = explode('&',file_get_contents('php://input'));
foreach ($p0 as $key => $value)
{
 $p1 = explode('=',$value);
 $_POST[$p1[0]] = $p1[1];
 //OR...
 //$_POST[urldecode($p1[0])] = urldecode($p1[1]);
}
print_r($_POST);
?>

我建议仅将其仅用于个别情况，顺便说一下，我不确定将其放在主头文件顶部的负面影响。

Answer 13

我当前的解决方案（基于上一个主题回复）：

function parseQueryString($data)
{
    $data = rawurldecode($data);   
    $pattern = '/(?:^|(?<=&))[^=&\[]*[^=&\[]*/';       
    $data = preg_replace_callback($pattern, function ($match){
        return bin2hex(urldecode($match[0]));
    }, $data);
    parse_str($data, $values);

    return array_combine(array_map('hex2bin', array_keys($values)), $values);
}

$_GET = parseQueryString($_SERVER['QUERY_STRING']);