외부에서 오는 변수들

HTML 폼 (GET과 POST)

폼이 PHP 스크립트로 전달될때, 그 폼안의 정보가 스크립트내에서 자동적으로 유효해진다. 이 정보에 접근할 수 있는 많은 방법이 제공된다. 예를 들면:

Example #1 단순한 HTML 폼

<form action="foo.php" method="post">
    이름:  <input type="text" name="username" /><br />
    메일: <input type="text" name="email" /><br />
    <input type="submit" name="submit" value="전송합니다!" />
</form>

특별한 설정과 개인적인 선호에 의해, HTML 폼으로부터 데이터를 접근할수 있는 많은 방법이 존재한다. 몇가지르 예를 들면:

Example #2 단순한 POST HTML 폼으로 부터 데이터에 접근하기

<?php 
// PHP 4.1.0부터 사용 가능

   echo $_POST['username'];
   echo $_REQUEST['username'];

   import_request_variables('p', 'p_');
   echo $p_username;

// PHP 6부터 사용 불가. PHP 5.0.0부터, 이러한 긴 예약 변수는
// register_long_arrays 지시어로 비활성화 할 수 있습니다.

   echo $HTTP_POST_VARS['username'];

// PHP 지시어 register_globals = on 일 경우에 사용할 수 있습니다.
// PHP 4.2.0부터 기본값은 register_globals = off 입니다.
// 이 방법을 사용하는 것은 권장되지 않습니다.

   echo $username;
?>

GET 폼을 사용하는 것은 적절한 GET 기선언 변수를 대신 사용할때를 제외하면 동일하다. GET은 QUERY_STRING (URL에서 '?'이후의 값)에도 적용이 된다. 따라서, 예를 들면 http://www.example.com/test.php?id=3$_GET['id']으로 접근할수 있는 GET 데이터를 포함한다. 또한 $_REQUESTimport_request_variables()를 참고.

Note:

$_POST$_GET 같은 슈퍼전역 배열은 PHP 4.1.0 이후버전부터 사용되기 시작했다.

전에 설명한대로, PHP 4.2.0 이전에는 register_globals의 기본값이 on이였다. PHP 커뮤니티는 그 디렉티브 값이 off가 되어있다고 가정하고 적절하게 코딩하는 것을 추천하기 때문에 이 디렉티브값에 연연할 필요가 없다.

Note:

magic_quotes_gpc 설정 디렉티브는 Get, Post, Cookie 값에 영향을 준다. 이 값이 켜져있으면, 그 값(It's "PHP!")은 자동적으로 (It\'s \"PHP!\")이 될것이다. 이 회피는 DB 입력을 위해 필요하다. 또한 addslashes(), stripslashes()magic_quotes_sybase를 참고한다.

PHP는 폼 변수가 쓰이는 환경안의 배열도 이해한다. (관련 faq를 참고) 예를 들면, 관련 변수를 함께 그룹화하거나, 다중 select 입력으로부터 값을 끄집어내기위해 이 기능을 사용할수 있다. 예로써, 자신에게 폼을 post하고 그 데이터를 출력해보자:

Example #3 좀더 복잡해진 폼 변수들

<?php
if ($_POST) {
    echo 
'<pre>';
    echo 
htmlspecialchars(print_r($_POSTtrue));
    echo 
'</pre>';
}
?>
<form action="" method="post">
    이름: <input type="text" name="personal[name]" /><br />
    메일: <input type="text" name="personal[email]" /><br />
    맥주: <br />
    <select multiple name="beer[]">
        <option value="warthog">Warthog</option>
        <option value="guinness">Guinness</option>
        <option value="stuttgarter">Stuttgarter Schwabenbräu</option>
    </select><br />
    <input type="hidden" name="action" value="submitted" />
    <input type="submit" value="전송합니다!" />
</form>

변수명으로 IMAGE SUBMIT

form을 전달할때, 표준적인 submit 버튼 태그 대신 다음과 같이 image 태그를 사용할수 있다.

<input type="image" src="image.gif" name="sub" />

유저가 image의 어느곳에서 클릭하더라도 수행 폼은 두가지 추가적인 변수를 서버로 전송할것이다. sub_x와 sub_y. 이 변수는 image안에서 유저가 클릭하는 좌표를 갖는다. 실제로 브라우저에 의해 보내지는 변수명은 밑줄(_)이 아니라 마침표(.)를 포함한다. 그러나 PHP는 자동으로 마침표를 밑줄로 변환한다.

HTTP 쿠키

PHP는 » Netscape's Spec에 의해 정의된 HTTP 쿠키를 투명하게 지원한다. 쿠키는 원격 브라우저안에 데이터를 저장하는 메카니즘이고 따라서 복귀하는 유저를 추적하거나 식별하게 해준다. setcookie() 함수를 사용하여 쿠키를 설정할수 있다. 쿠키는 HTTP 헤더의 일부분이고, 그래서 SetCookie함수는 브라우저에 출력이 생기기전에 호출되어야 한다. 이 제약은 header() 함수에도 같이 적용된다. 쿠키 데이터는 적절한 쿠키 데이터 배열에 존재하게 된다. $_COOKIE, $HTTP_COOKIE_VARS는 물론 $_REQUEST 배열에 존재한다. 더 자세한 정보와 예제를 보기 위해 setcookie() 매뉴얼 페이지를 참고.

단일 쿠키 변수에 여러값을 지정하려한다면, 배열로 그 값을 지정할수 있다. 예를 들면:

<?php
  setcookie
("MyCookie[foo]"'Testing 1'time()+3600);
  
setcookie("MyCookie[bar]"'Testing 2'time()+3600);
?>

위 예제코드는 MyCookie가 스크립트내에서 단일 배열이 될지라도 두개의 분리된 쿠키를 생성할수 있다. 여러값을 갖는 단일 쿠키를 설정하려면, 첫번째로 그 값에 serialize()explode()를 사용할것을 고려하도록 한다.

쿠키는 경로나 도메인이 다르지 않으면 브라우저안에서 같은 이름을 갖는 이전 쿠키를 교체한다는 것에 주의해야 한다. 따라서, 쇼핑 카트 애플리케이션을 위해서는 카운터를 유지하고 이 카운터를 전달하기를 원할것이다.

Example #4 setcookie()예제 코드

<?php
if (isset($_COOKIE['count'])) {
    
$count $_COOKIE['count'] + 1;
} else {
    
$count++;
}
setcookie('count'$counttime()+3600);
setcookie("Cart[$count]"$itemtime()+3600);
?>

유입되는 변수명에 존재하는 점(dot)

표준적으로, PHP는 스크립트내로 변수를 전달할때 변수명을 변경하지 않는다. 하지만, 점(마침표, full stop)은 PHP 변수명안에서 유효한 문자가 될수 없다는것에 주의해야 할것이다. 이에 유의하여 다음 코드를 보자:

<?php
$varname
.ext;  /* invalid variable name */
?>
현재, 해석기가 보게되는 것은 $varname이라는 변수와 그 뒤에 문자열 결합 연산자, 그 뒤에 벌거벗은 문자열(barestring) 'ext'이다. (즉, 따옴표로 둘러싸지 않은 문자열은 key나 예약된 단어와 일치하지 않음) 확실하게 이 결과는 원치 않은것이다.

이러한 이유로, PHP는 유입되는 변수명안의 점(.)을 밑줄(_)로 변경한다는것을 명심해야 한다.

변수 타입 결정하기

PHP는 변수 타입을 결정하고 변수를(보통) 필요한 타입으로 변환하기 때문에, 어느 시간에 변수가 무슨 타입인지 알수가 없다. PHP는 변수가 무슨 타입인지 확인할수 있는 몇가지 함수를 제공한다. 그 함수들은 다음과 같다: gettype(), is_array(), is_float(), is_int(), is_object(), is_string(). 타입 챕터를 참고.

add a note add a note

User Contributed Notes 30 notes

up
29
Anonymous
11 years ago
The full list of field-name characters that PHP converts to _ (underscore) is the following (not just dot):
chr(32) ( ) (space)
chr(46) (.) (dot)
chr(91) ([) (open square bracket)
chr(128) - chr(159) (various)

PHP irreversibly modifies field names containing these characters in an attempt to maintain compatibility with the deprecated register_globals feature.
up
8
yasuo_ohgaki at hotmail dot com
18 years ago
Important:  Pay attention to the following security concerns when handling user submitted  data :

http://www.php.net/manual/en/security.registerglobals.php
http://www.php.net/manual/en/security.variables.php
up
10
krydprz at iit dot edu
14 years ago
This post is with regards to handling forms that have more than one submit button.

Suppose we have an HTML form with a submit button specified like this:

<input type="submit" value="Delete" name="action_button">

Normally the 'value' attribute of the HTML 'input' tag (in this case "Delete") that creates the submit button can be accessed in PHP after post like this:

<?php
$_POST
['action_button'];
?>

We of course use the 'name' of the button as an index into the $_POST array.

This works fine, except when we want to pass more information with the click of this particular button.

Imagine a scenario where you're dealing with user management in some administrative interface.  You are presented with a list of user names queried from a database and wish to add a "Delete" and "Modify" button next to each of the names in the list.  Naturally the 'value' of our buttons in the HTML form that we want to display will be "Delete" and "Modify" since that's what we want to appear on the buttons' faceplates.

Both buttons (Modify and Delete) will be named "action_button" since that's what we want to index the $_POST array with.  In other words, the 'name' of the buttons along cannot carry any uniquely identifying information if we want to process them systematically after submit. Since these buttons will exist for every user in the list, we need some further way to distinguish them, so that we know for which user one of the buttons has been pressed.

Using arrays is the way to go.  Assuming that we know the unique numerical identifier of each user, such as their primary key from the database, and we DON'T wish to protect that number from the public, we can make the 'action_button' into an array and use the user's unique numerical identifier as a key in this array.

Our HTML code to display the buttons will become:

<input type="submit" value="Delete" name="action_button[0000000002]">
<input type="submit" value="Modify" name="action_button[0000000002]">

The 0000000002 is of course the unique numerical identifier for this particular user.

Then when we handle this form in PHP we need to do the following to extract both the 'value' of the button ("Delete" or "Modify") and the unique numerical identifier of the user we wish to affect (0000000002 in this case). The following will print either "Modify" or "Delete", as well as the unique number of the user:

<?php
$submitted_array
= array_keys($_POST['action_button']);
echo (
$_POST['action_button'][$submitted_array[0]] . " " . $submitted_array[0]);
?>

$submitted_array[0] carries the 0000000002.
When we index that into the $_POST['action_button'], like we did above, we will extract the string that was used as 'value' in the HTML code 'input' tag that created this button.

If we wish to protect the unique numerical identifier, we must use some other uniquely identifying attribute of each user. Possibly that attribute should be encrypted when output into the form for greater security.

Enjoy!
up
6
tmk-php at infeline dot org
14 years ago
To handle forms with or without [] you can do something like this:

<?php
   
function repairPost($data) {
       
// combine rawpost and $_POST ($data) to rebuild broken arrays in $_POST
       
$rawpost = "&".file_get_contents("php://input");
        while(list(
$key,$value)= each($data)) {
           
$pos = preg_match_all("/&".$key."=([^&]*)/i",$rawpost, $regs, PREG_PATTERN_ORDER);       
            if((!
is_array($value)) && ($pos > 1)) {
               
$qform[$key] = array();
                for(
$i = 0; $i < $pos; $i++) {
                   
$qform[$key][$i] = urldecode($regs[1][$i]);
                }
            } else {
               
$qform[$key] = $value;
            }
        }
        return
$qform;
    }

   
// --- MAIN

   
$_POST = repairPost($_POST);
?>

The function will check every field in the $_POST with the raw post data and rebuild the arrays that got lost.
up
5
Anonymous
5 years ago
From HTML 5.1 Draft:
http://www.w3.org/html/wg/drafts/html/master/forms.html#naming-form-controls:-the-name-attribute

The name content attribute gives the name of the form control, as used in form submission and in the form element's elements object. If the attribute is specified, its value must not be the empty string.
Any non-empty value for name is allowed.

So use the format like this <select multiple name="beer[]"> is still in the HTML 5 standard.
up
4
lennynyktyk at yahoo dot com
15 years ago
When dealing with multiple select boxes and the name=some_name[] so that PHP will understand that is needs to interpet the input as an array an not as a single value. If you want to access this in Javascript you should assign an id attribute to the select box as well as the name attribute. Then proceed to use the id attribute in Javascript to reference the select box and the name attribute to reference the select box in PHP.
Example

<select multiple id="select_id" name="select_name[]">
....

</select>

<?PHP
   
echo $select_name[0];
?>

<script language="javascript">
  document.forms[0].select_id.options[0].selected = true;
</script>

I hope you get the idea
up
3
walf
8 years ago
WARNING! replacement of spaces and dots does not occur in array keys.

E.g. If you have
<input name="a. b[x. y]" value="foo" />

var_dump($_POST);
gives
array(1) {
  ["a__b"]=>
  array(1) {
    ["x. y"]=>
    string(3) "foo"
  }
}
up
3
Anonymous
16 years ago
"...the dot (period, full stop) is not a valid character in a PHP variable name."

That's not completely correct, consider this example:
$GLOBALS['foo.bar'] = 'baz';
echo ${'foo.bar'};
This will output baz as expected.
up
2
vb at bertola dot eu dot org
16 years ago
For what I understand, since PHP 4.3 it is possible to access the content of a POST request (or other methods as well) as an input stream named php://input, example:

readfile("php://input");  
[to display it]

or

$fp = fopen("php://input", "r");   
[to open it and then do whatever you want]

This is very useful to access the content of POST requests which actually have a content (and not just variable-value couples, which appear in $_POST).

This substitutes the old $HTTP_RAW_POST_DATA variable available in some of the previous 4.x versions. It is available for other upload methods different from POST too, but it is not available for POSTs with multipart/form-data content type, since the file upload handler has already taken care of the content in that case.
up
1
anisgazis at gmail dot com
10 months ago
Dots , spaces and [  in variable names are converted to underscores. For example 
<input name="a.b" /> becomes $_REQUEST["a_b"].
<input name="a b" /> becomes $_REQUEST["a_b"].
<input name="a[b" /> becomes $_REQUEST["a_b"].
<input name="a]b" /> becomes $_REQUEST["a]b"].
<input name="a-b" /> becomes $_REQUEST["a-b"].
<input name="a/b" /> becomes $_REQUEST["a/b"].
<input name="a\b" /> becomes $_REQUEST["a\b"].
<input name="a,b" /> becomes $_REQUEST["a,b"].
up
0
t.montg AT gmail DOT com
12 years ago
For anyone else having trouble figuring out how to access values in a SELECT element from a POST or GET form, you can't set the "id" attribute to the same thing as your "name" attribute.  i.e. don't do this:

<?php
 
//Not so good
 
<select multiple="multiple" id="selectElem" name="selectElem[]">
     <
option value="ham">Ham</option>
     <
option value="cheese">Cheese</option>
     <
option value="hamcheese">Ham and Cheese</option>
  </
select>
?>

If you do the above, the variable $_POST['selectElem'] will not be set.  Instead, either change the id or name attribute so that they are dissimilar.  i.e. do this:

<?php
 
//So good (notice the new "id" value)
 
<select multiple="multiple" id="selectElemId" name="selectElem[]">
     <
option value="ham">Ham</option>
     <
option value="cheese">Cheese</option>
     <
option value="hamcheese">Ham and Cheese</option>
  </
select>
?>

Then you can access the value(s) of the SELECT element through the array $_POST['selectElem'][] or $_GET['selectElem'][].  It took me quite some time to figure out the problem.
up
-1
a at b dot c dot de
17 years ago
As far as whether or not "[]" in name attributes goes, The HTML4.01 specification only requires that it be a case-insensitive CDATA token, which can quite happily include "[]". Leading and trailing whitespace may be trimmed and shouldn't be used.

It is the id= attribute which is restricted, to a case-sensitive NAME token (not to be confused with a name= attribute).
up
-3
jlratwil at yahoo dot com
14 years ago
To get multiple selected (with "multiple" ) lists in <select> tag, make sure that the "name" attribute is added to braces, like this:

<select multiple="multiple" name="users[]">
     <option value="foo">Foo</option>
     <option value="bar">Bar</option>
</select>

When submitted to PHP file (assume that you have a complete form) it will return an array of strings. Otherwise, it will just return the last element of the <select> tag you selected.
up
-4
vierubino dot r3m0oFdisB1T at gmail dot com
12 years ago
When you are using checkboxes to submit multiple choices, there is no need to use the complex method further down the page where you assign a unique name to each checkbox.

Instead, just name each checkbox as the same array, e.g.:

<input type="checkbox" name="items[]" value="foo" />
<input type="checkbox" name="items[]" value="bar" />
<input type="checkbox" name="items[]" value="baz" />

This way your $_POST["items"] variable will return as an array containing all and only the checkboxes that were clicked on.
up
-4
kevinrlat nospam dot ccs dot neu dot edu
16 years ago
if you use an array of checkboxes to submit info to a database or what have you, be careful of the case when no boxes are checked.  for example:

<form method="post">
<input type="checkbox" name="checkstuff[]" value="0">
<input type="checkbox" name="checkstuff[]" value="1">
<input type="checkbox" name="checkstuff[]" value="2">

. . .

</form>

if these are submitted and none are checked, the $_POST['checkstuff'] variable will not contain an empty array, but a NULL value.  this bothered me when trying to implode() the values of my checkboxes to insert into a database, i got a warning saying the 2nd argument was the wrong type. 

hope this helps!
-kevin
up
-4
carl_steinhilber at NOSPAMmentor dot com
17 years ago
A group of identically-named checkbox form elements returning an array is a pretty standard feature of HTML forms. It would seem that, if the only way to get it to work is a non-HTML-standard-compliant workaround, it's a problem with PHP.

Since the array is passed in the header in a post, or the URL in a get, it's the PHP interpretation of those values that's failing.
up
-5
Murat TASARSU
14 years ago
if you want your multiple select returned variable in comma seperated form you can use this. hope that helps. regards...

$myvariable
   Array ( [0] => one [1] => two [2] => three )
turns into
   one,two,three

<?php
$myvariable
="";
$myseperator="";
foreach (
$_POST["myvariable"] as $v) {
if (!isset(
$nofirstcomma)) $nofirstcomma=0; else $myseperator=",";
$myvariable = $myvariable.$myseperator.$v;
}
echo
$myvariable;
?>
up
-5
un shift at yahoo dot com
16 years ago
This function takes a recurring form item from php://input and loads it into an array - useful for javascript/dom incompatibility with form_input_item[] names for checkboxes, multiple selects, etc.  The fread maxes out at 100k on this one.  I guess a more portable option would be pulling in ini_get('post_max_size') and converting it to an integer.

<?php
function multi_post_item($input_item_name) {
    
$array_output = array();
    
$in_handle = fopen("php://input", "r");
    
$raw_input_items = split("&", urldecode(fread($in_handle, 100000)));
     foreach (
$raw_input_items as $input_item) {
           
// split this item into name/value pair
           
$item = split("=", $input_item);
           
// form item name
           
$item_name = $item[0];
           
// form item value
           
$item_value = $item[1];
            if (
$item_name == $input_item_name) {
                   
$array_output[] = $item_value;
            }
     }
     return
$array_output;
}
?>
up
-1
fabian dot picone at gmail dot com
1 year ago
"That will create two separate cookies although MyCookie will now be a single array in your script. If you want to set just one cookie with multiple values, consider using serialize() or explode() on the value first."

explode should be implode in this sentence.
up
-5
tim at timpauly dot com
14 years ago
This code module can be added to every form using require_once().
It will process any and all form data, prepending each variable with
a unique identifier (so you know which method was used to get the data).

My coding could be neater, but this sure makes processing forms much easier!

<?php
// -----------------------------------------------------------------
// Basic Data PHP module. This module captures all GET, POST
// and COOKIE data and processes it into variables.
// Coded April, 2005 by Timothy J. Pauly
// -----------------------------------------------------------------
//
// coo_ is prepended to each cookie variable
// get_ is prepended to each GET variable
// pos_ is prepended to each POST variable
// ses_ is prepended to each SESSION variable
// ser_ is prepended to each SERVER variable

session_start(); // initialize session data
$ArrayList = array("_POST", "_GET", "_SESSION", "_COOKIE", "_SERVER"); // create an array of the autoglobal arrays
// we want to process

foreach($ArrayList as $gblArray) // process each array in the array list
{
  
$prefx = strtolower(substr($gblArray,1,3))."_"; // derive the prepend string
// from the autoglobal type name
  
$tmpArray = $$gblArray;
  
$keys = array_keys($tmpArray); // extract the keys from the array being processed
  
foreach($keys as $key) // process each key
   
{
      
   
$arcnt = count($tmpArray[$key]);
   
    if (
$arcnt > 1) // Break down passed arrays and
// process each element seperately
   
{
     
$lcount = 0;
      foreach (
$tmpArray[$key] as $dval)
        {
          
$prkey = $prefx.$key; // create a new key string
// with the prepend string added
          
$prdata['$prkey'] = $dval; // this step could be eliminated
          
${$prkey}[$lcount] = $prdata['$prkey']; //create new key and insert the data
          
$lcount++;
        }
     
        } else {
// process passed single variables
       
               
$prkey = $prefx.$key; // create a new key string
// with the prepend string added
               
$prdata['$prkey'] = $tmpArray[$key]; // insert the data from
// the old array into the new one
               
$$prkey = $prdata['$prkey']; // create the newly named
// (prepended) key pair using variable variables :-)
              
               
              
}
    }
}

// -------------------------------------------------------------
?>
up
-7
POSTer
10 years ago
Here's a simple function to give you an uncorrupted version of $_POST:

<?php
// Function to fix up PHP's messing up POST input containing dots, etc.
function getRealPOST() {
   
$pairs = explode("&", file_get_contents("php://input"));
   
$vars = array();
    foreach (
$pairs as $pair) {
       
$nv = explode("=", $pair);
       
$name = urldecode($nv[0]);
       
$value = urldecode($nv[1]);
       
$vars[$name] = $value;
    }
    return
$vars;
}
?>
up
-6
ch1902uk at hotmail dot com
13 years ago
Regarding image input buttons, above where it says:

"When the user clicks somewhere on the image, the accompanying form will be transmitted to the server with two *additional* variables, sub_x and sub_y. These contain the coordinates of the user click within the image."

This is the case with Firefox (and probably other standards browsers), however my experience with Internet Explorer is that when image inputs are clicked, they only submit the location of the click on the button and *not* the name of the input.

So if you have a form to move/delete entries like this

entry[]  [delete_0] [up_0] [down_0]
entry[]   [delete_1] [up_1] [down_1]
entry[]   [delete_2] [up_2] [down_2]

Then submitting the form in firefox will give you post variables such as

<?php
   $_POST
['delete_2'];   // "Delete" - button value
  
$_POST['delete_2_x'];   // 23 - x coord
  
$_POST['delete_2_y'];   // 3 - y coord
?>

In IE you only get

<?php
   $_POST
['delete_2_x'];   // 23 - x coord
  
$_POST['delete_2_y'];   // 3 - y coord
?>

So if you are checking for what button was clicked do something like this

<?php
  
for ($i = 0; $i < count($_POST['entry']); $i++)
   {
      if (isset(
$_POST['delete_' . $i . '_x']))
      {
        
// do delete
     
}
   }
?>
up
-2
Sadik_quake2003 at mail dot ru
2 years ago
<form method="post">
    <select name="selecter">
        <option>one</option>
        <option>two</option>
        <option>three</option>
    </select><br />
    <input type="submit" value="send" />
</form>

<?=$_POST["selecter"];?>

If we change first option, that result will be: one (important: not null !)
up
-4
keli at kmdsz dot ro
16 years ago
image type inputs apparently return their "value" argument from Mozilla, but not from IEXplorer... :(

example:

<input type="image" name="sb" value="first" src="first.jpg">

using a mozilla will give you
  $sb="first" AND $sb_x, $sb_y ... whereas from IE there's just no $sb. :(

[this in short form, as I'm still using trackvars :) ]
up
-5
hjncom at hjncom dot net
17 years ago
I think '[' and ']' are valid characters for name attributes.

http://www.w3.org/TR/html401/interact/forms.html#h-17.4
-> InputType of 'name' attribute is 'CDATA'(not 'NAME' type)

http://www.w3.org/TR/html401/types.html#h-6.2
-> about CDATA('name' attribute is not 'NAME' type!)
...CDATA is a sequence of characters from the document character set and may include character entities...

http://www.w3.org/TR/html401/sgml/entities.html
--> about Character entity references in HTML 4
([ - &#91, ] - &#93)
up
-8
darren at sullivan dot net
15 years ago
This function is a simple solution for getting the array of selectes from a checkbox list or a dropdown list out of the Querry String. I took an example posted earlier and simplified it.

<?php
function multi_post_item($repeatedString) {
   
// Gets the specified array of multiple selects and/or
    // checkboxes from the Query String
   
$ArrayOfItems = array();
   
$raw_input_items = split("&", $_SERVER["QUERY_STRING"]);
    foreach (
$raw_input_items as $input_item) {
       
$itemPair = split("=", $input_item);
        if (
$itemPair[0] == $repeatedString) {
           
$ArrayOfItems[] = $itemPair[1];
        }
    }
    return
$ArrayOfItems;
}
?>

Use the name of the field as the agrument. Example:

<?php
$Order
= $_GET['Order'];
$Name = $_GET['Name'];
$States = multi_post_item('States');
$Products = multi_post_item('Products');
?>

Be sure to check for NULL if there are no selections or boxes checked.
up
-7
mattij at nitro fi no at no dot no
15 years ago
If you try to refer or pass HTML-form data which has arrays with javascript remember that you should point to that array like this

<script type="text/javascript">
    window.opener.document.forms[0]["to[where][we][point]"];
</script>
up
-10
arjini at mac dot com
15 years ago
When dealing with form inputs named_like_this[5] and javascript, instead of trying to get PHP to do something fancy as mentioned below, just try this on the javascript side of things:

<form name="myForm">

<script>
my_fancy_input_name = 'array_of_things[1]';
/* now just refer to it like this in the dom tree

document[myForm][my_fancy_input_name].value

etc*/
</script>

<input type="text" name="array_of_things[1]" value="1"/>
</form>

No fancy PHP, in fact, you shouldn't need to change your PHP at all.
up
-8
jim at jamesdavis dot it
15 years ago
How to pass a numerically indexed array.
This is the part inside the form. Notice that the name is not 'english[$r]' which you would normally write, but 'english[]'. PHP adds the index when it receives the post and it starts at 0.

<?php

for ($r=0; $r <= count($english)-1; $r++){
         echo
"<TEXTAREA NAME='english[]'>".$english[$r]."</TEXTAREA>";       
         
}
?>
<?php

And this will get it out at the other end
function retrieve_english(){
    for (
$r=0; $r <= count($_POST['english'])-1; $r++){
        echo
$_POST['english'][$r]."<BR>";
    }
}
?>

Keys are useful but so are numerical indices!
Cheers everyone
up
-13
Sadik_quake2003 at mail dot ru
2 years ago
<form method="post">
    <select name="list">
        <option>one</option>
        <option>two</option>
        <option>three</option>
    </select><br />
    <input type="submit" value="send" />
</form>

<?=$_POST["list"];?>

If we change first option, that result will be: one (important: not null !)
To Top