PHP Doku:: Erstellt ein Array - function.array.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenArraysArray Funktionenarray

Ein Service von Reinhard Neidl - Webprogrammierung.

Array Funktionen

<<array_walk

arsort>>

array

(PHP 4, PHP 5)

arrayErstellt ein Array

Beschreibung

array array ([ mixed $... ] )

Erstellt ein Array. Um mehr darüber zu erfahren, was ein Array ist, lesen Sie den Abschnitt zum Array-Typ.

Parameter-Liste

...

Die Syntax "Index => Werte", durch Kommas getrennt, definiert Index und Werte. Index kann vom Typ String oder numerisch sein. Wird der Index weggelassen, erstellt die Funktion automatisch einen numerischen Index, der bei 0 beginnt. Ist der Index als Integer-Wert angegeben, wird der nächste generierte Index der größte Integer Index + 1. Beachten Sie, dass wenn zwei identische Indexe definiert sind, der letzte den ersten überschreibt.

Ein hinter dem letzten definierten Arrayeintrag angehängtes Komma ist zwar unüblich, aber dennoch gültige Syntax.

Rückgabewerte

Gibt ein den Parametern entsprechendes Array zurück. Mit dem => Operator können die Parameter indiziert werden. Um mehr darüber zu erfahren, was ein Array ist, lesen Sie den Abschnitt zum Array-Typ.

Beispiele

Das folgende Beispiel zeigt wie man ein zweidimensionales Array erstellt, wie man Schlüssel für assoziative Arrays festlegt, und wie man numerische Indizes in normalen Arrays überspringt und fortsetzt.

Beispiel #1 array()-Beispiel

<?php
$fruits 
= array (
    
"fruits"  => array("a" => "Orange""b" => "Banane""c" => "Apfel"),
    
"numbers" => array(123456),
    
"holes"   => array("erstes"=> "zweites""drittes")
);
?>

Beispiel #2 Automatischer Index mit array()

<?php
$array 
= array(1111,  1=> 1,  => 119=> 13);
print_r($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [0] => 1
    [1] => 1
    [2] => 1
    [3] => 13
    [4] => 1
    [8] => 1
    [9] => 19
)

Beachten Sie, dass Index '3' doppelt definiert ist, und den letzten definierten Wert 13 behält. Index 4 wurde nach dem Index 8 definiert, und der nächste generierte Index (Wert 19) ist 9, da der größte Index 8 war.

Dieses Beispiel erstellt ein auf dem Index 1 basierendes Array.

Beispiel #3 1-basierter Index mit array()

<?php
$erstesquartal 
= array(=> 'Januar''Februar''März');
print_r($erstesquartal);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [1] => Januar
    [2] => Februar
    [3] => März
)

Man kann, ebenso wie in Perl, einen Wert des Arrays innerhalb doppelter Anführungszeichen ansprechen. Jedoch muss man in PHP das Array in geschweifte Klammern einschließen.

Beispiel #4 Auf ein Array innerhalb von doppelten Anführungszeichen zugreifen

<?php

$foo 
= array('bar' => 'baz');
echo 
"Hallo {$foo['bar']}!"// Hallo baz!

?>

Anmerkungen

Hinweis:

array() ist ein Sprahkonstrukt, mit dem man Arrays vorgeben kann und keine reguläre Funktion.

Siehe auch

  • array_pad() - Vergrößert ein Array auf die spezifizierte Länge mit einem Wert
  • list() - Weist Variablen zu, als wären sie ein Array
  • count() - Zählt alle Elemente eines Arrays oder Attribute eines Objekts
  • range() - Erstellt ein Array mit einem Bereich von Elementen
  • foreach
  • The array type


49 BenutzerBeiträge:
- Beiträge aktualisieren...
contact at dot REMOVETHIS dot erikmaas dot com
21.12.2010 10:17
A array_peek function as no excists yet:
<?php
function array_peek($array) {
    return
$array[(count($array)-1)];
}
?>
eugene at ultimatecms dot co dot za
3.03.2010 15:29
This is a useful way to get foreign key variables from a specific sql table.
This function can be used to include all relevant data from all relating tables:

<?php
function get_string_between($string, $start, $end){
        
$string = " ".$string;
        
$ini = strpos($string,$start);
         if(
$ini == 0
                return
$tbl;
        
$ini += strlen($start);
        
$len = strpos($string,$end,$ini) - $ini;
         return
substr($string,$ini,$len);
}

function
get_foreign_keys($tbl) {
       
$query = query_getrow("SHOW CREATE TABLE ".mysql_escape_string($tbl));

       
$dat = explode('CONSTRAINT',$query[1]);
        foreach(
$dat as $d => $a) {
                if(
strpos($a,"FOREIGN KEY"))
               
$data['keys'][] = array($tbl,get_string_between($a,"` FOREIGN KEY (`","`) REFERENCES"));
        }                      

        foreach(
$dat as $d => $a) {
                if(
strpos($a,"REFERENCE"))
               
$data['references'][] = explode('` (`',get_string_between($a,"REFERENCES `","`) ON"));
        }
        return
$data;
}

//Example code:

       
$data = get_foreign_keys('task_table');
        echo
'<pre>';
       
print_r($data);
        echo
'</pre>';

?>

// $query[1] outputs:

CREATE TABLE `task_table` (
  `task_id` int(64) NOT NULL auto_increment,
  `ticket_id` int(64) NOT NULL,
  `task_type` varchar(64) NOT NULL,
  `comment` text,
  `assigned_to` int(11) default NULL,
  `dependant` int(64) default NULL,
  `resolved` int(1) default NULL,
  PRIMARY KEY  (`task_id`),
  KEY `ticket_id` (`ticket_id`,`dependant`),
  KEY `assigned_to` (`assigned_to`),
  KEY `task_dependant` (`dependant`),
  CONSTRAINT `task_table_ibfk_1` FOREIGN KEY (`ticket_id`) REFERENCES `tickets_table` (`ticket_id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `task_table_ibfk_2` FOREIGN KEY (`assigned_to`) REFERENCES `contact_table` (`contact_id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `task_table_ibfk_3` FOREIGN KEY (`dependant`) REFERENCES `task_table` (`task_id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=latin1

// $data outputs:
Array (
    [keys] => Array
        (
            [0] => Array
                (
                    [0] => task_table
                    [1] => ticket_id
                )

            [1] => Array
                (
                    [0] => task_table
                    [1] => assigned_to
                )

            [2] => Array
                (
                    [0] => task_table
                    [1] => dependant
                )
        )

    [references] => Array
        (
            [0] => Array
                (
                    [0] => tickets_table
                    [1] => ticket_id
                )

            [1] => Array
                (
                    [0] => contact_table
                    [1] => contact_id
                )

            [2] => Array
                (
                    [0] => task_table
                    [1] => task_id
                )
        )
)
mail at leonardomartinez dot com
10.10.2009 22:39
<?php
function array_two_key_swap( $multidimensional_array ) {

   
/*
        Writen by: Leonardo Martinez

        Created: 10-10-2009
        Modified: 10-15-2009

        This function takes a two dimensional array[x][y], swaps the first
        key with the second key so the values can be referenced using array[y][x].

        Example:
                    samplearray['directiory'][0] = "myicons";
                    samplearray['directiory'][1] = "myicons";
                    samplearray['directiory'][2] = "myiconsold";
                    samplearray['directiory'][3] = "myiconsold";

                    samplearray['filename'][0] = "hat.png";
                    samplearray['filename'][1] = "dog.png";
                    samplearray['filename'][2] = "mice.png";
                    samplearray['filename'][3] = "rat.png";

        The above array converts to:

                    newarray[0]['filename']     = "hat.png"
                    newarray[0]['directiory']     = "myicons"
                    newarray[1]['filename']     = "dog.png"
                    newarray[1]['directiory']     = "myicons"
                    newarray[2]['filename']     = "mice.png"
                    newarray[2]['directiory']     = "myiconsold"
                    newarray[3]['filename']     = "rat.png"
                    newarray[3]['directiory']     = "myiconsold"

    */

   
$keys = array_keys( $multidimensional_array );

   
$array_swaped = array();

    foreach(
$multidimensional_array[$keys[0]] as $key_counter => $value1) {

       
$temp_array = array();

        foreach(
$keys as $key) {
           
$temp_array[$key] = $multidimensional_array[$key][$key_counter];
        }

       
$array_swaped[] = $temp_array;
    }

    return
$array_swaped;
}
?>
kamil at navikam dot pl
3.06.2009 12:42
Easy function to unarray an array :-)
It will make $array['something'] => $something.
Usefull for making code more clear.

example of use:
<?
function unarray($row) {
    foreach(
$row as $key => $value) {
        global $
$key;
        $
$key = $value;
    }
}

$sql = mysql_query("SELECT * FROM `pracownicy`");
while (
$row = mysql_fetch_assoc($sql)) {
   
unarray($row);
    echo
$idpracownika.'<br>'; //instead of $row['idpracownika']
}
?>
Marcel dot Glacki at stud dot fh-swf dot de
28.04.2009 0:49
I encountered the following but didn't see it documented/reported anywhere so I'll just mentioned it here.

As written in the manual:
"When index is omitted, an integer index is automatically generated, starting at 0. If index is an integer, next generated index will be the biggest integer index + 1".

This generated index has always the largest integer used as a key so far. So adding $a[5] = 'foo'; after an $a[10] = 'bar'; will not force the next generated index to be 6 but to be 11 as 10 was the highest index encountered until here.

Anyway, the following can happen:
<?php
$max_int
= 2147483647; // Max value for integer on a 32-bit system
$arr = array();

$arr[1] = 'foo'; // New generated index will be 2
$arr[ $max_int ] = 'bar'; // Caution: Next generated index will be -2147483648 due to the integer overflow!
$arr[0] = 'bar'; // The highest value should be 2147483648 but due to the i-overflow it is -2147483648 so current index 0 is larger. The new generated index therefore is 1!
$arr[]  = 'failure'; // Warning: Cannot add element to the array as the next element is already occupied.
?>
alwynlobo at gmail dot com
3.03.2009 20:03
Here's an example on how to create a multi-dimensional array...(without using ArrayObject)

<?php
$characters
= array(array(array(
                array (
name=>"name 1",
                       
occupation=>"Developer",
                       
age=>30,
                       
specialty=>"Java" ),
                array (
name=>"name 2",
                       
occupation=>"Programmer",
                       
age=>24,
                       
specialty=>"C++" ),
                array (
name=>"name 3",
                       
occupation=>"Designer",
                       
age=>63,
                       
specialty=>"Javascript" )))
);

print
$characters[0][0][2][occupation];
?>
jonberglund at gmail dot com
7.07.2008 18:25
The following function (similar to one above) will render an array as a series of HTML select options (i.e. "<option>...</option>"). The problem with the one before is that there was no way to handle <optgroup>, so this function solves that issue.

function arrayToSelect($option, $selected = '', $optgroup = NULL)
{
    $returnStatement = '';

    if ($selected == '') {
        $returnStatement .= '<option value="" selected="selected">Select one...</option>';
    }

    if (isset($optgroup)) {
        foreach ($optgroup as $optgroupKey => $optgroupValue) {
            $returnStatement .= '<optgroup label="' . $optgroupValue . '">';

            foreach ($option[$optgroupKey] as $optionKey => $optionValue) {
                if ($optionKey == $selected) {
                    $returnStatement .= '<option selected="selected" value="' . $optionKey . '">' . $optionValue . '</option>';
                } else {
                    $returnStatement .= '<option value="' . $optionKey . '">' . $optionValue . '</option>';
                }
            }

            $returnStatement .= '</optgroup>';
        }
    } else {
        foreach ($option as $key => $value) {
            if ($key == $selected) {
                $returnStatement .= '<option selected="selected" value="' . $key . '">' . $value . '</option>';
            } else {
                $returnStatement .= '<option value="' . $key . '">' . $value . '</option>';
            }
        }
    }

    return $returnStatement;
}

 So, for example, I needed to render a list of states/provinces for various countries in a select field, and I wanted to use each country name as an <optgroup> label. So, with this function, if only a single array is passed to the function (i.e. "arrayToSelect($stateList)") then it will simply spit out a bunch of "<option>" elements. On the other hand, if two arrays are passed to it, the second array becomes a "key" for translating the first array.

Here's a further example:

$countryList = array(
    'CA'        => 'Canada',
    'US'        => 'United States');

$stateList['CA'] = array(
    'AB'        => 'Alberta',
    'BC'        => 'British Columbia',
    'AB'        => 'Alberta',
    'BC'        => 'British Columbia',
    'MB'        => 'Manitoba',
    'NB'        => 'New Brunswick',
    'NL'        => 'Newfoundland/Labrador',
    'NS'        => 'Nova Scotia',
    'NT'        => 'Northwest Territories',
    'NU'        => 'Nunavut',
    'ON'        => 'Ontario',
    'PE'        => 'Prince Edward Island',
    'QC'        => 'Quebec',
    'SK'        => 'Saskatchewan',
    'YT'        => 'Yukon');

$stateList['US'] = array(
    'AL'        => 'Alabama',
    'AK'        => 'Alaska',
    'AZ'        => 'Arizona',
    'AR'        => 'Arkansas',
    'CA'        => 'California',
    'CO'        => 'Colorado',
    'CT'        => 'Connecticut',
    'DE'        => 'Delaware',
    'DC'        => 'District of Columbia',
    'FL'        => 'Florida',
    'GA'        => 'Georgia',
    'HI'        => 'Hawaii',
    'ID'        => 'Idaho',
    'IL'        => 'Illinois',
    'IN'        => 'Indiana',
    'IA'        => 'Iowa',
    'KS'        => 'Kansas',
    'KY'        => 'Kentucky',
    'LA'        => 'Louisiana',
    'ME'        => 'Maine',
    'MD'        => 'Maryland',
    'MA'        => 'Massachusetts',
    'MI'        => 'Michigan',
    'MN'        => 'Minnesota',
    'MS'        => 'Mississippi',
    'MO'        => 'Missouri',
    'MT'        => 'Montana',
    'NE'        => 'Nebraska',
    'NV'        => 'Nevada',
    'NH'        => 'New Hampshire',
    'NJ'        => 'New Jersey',
    'NM'        => 'New Mexico',
    'NY'        => 'New York',
    'NC'        => 'North Carolina',
    'ND'        => 'North Dakota',
    'OH'        => 'Ohio',
    'OK'        => 'Oklahoma',
    'OR'        => 'Oregon',
    'PA'        => 'Pennsylvania',
    'RI'        => 'Rhode Island',
    'SC'        => 'South Carolina',
    'SD'        => 'South Dakota',
    'TN'        => 'Tennessee',
    'TX'        => 'Texas',
    'UT'        => 'Utah',
    'VT'        => 'Vermont',
    'VA'        => 'Virginia',
    'WA'        => 'Washington',
    'WV'        => 'West Virginia',
    'WI'        => 'Wisconsin',
    'WY'        => 'Wyoming');

...

<select name="state" id="state"><?php echo arrayToSelect($stateList,'',$countryList) ?></select>
<select name="country" id="country"><?php echo arrayToSelect($countryList,'US') ?></select>
sebasg37 at gmail dot com
12.02.2008 20:32
Recursive function similar to print_r for describing anidated arrays in html <ol>. Maybe it's useful for someone.

<?php
function describeAnidatedArray($array)
{
   
$buf = '';
    foreach(
$array as $key => $value)
    {
        if(
is_array($value))
        {
           
$buf .= '<ol>' . describeAnidatedArray($value) . '</ol>';
        }
        else
           
$buf .= "<li>$value</li>";
    }
    return
$buf;
}

// Example:
$array = array("a", "b", "c", array("1", "2", array("A", "B")), array("3", "4"), "d");

echo
describeAnidatedArray($array);
?>

output:

# a
# b
# c

   1. 1
   2. 2
         1. A
         2. B

   1. 3
   2. 4

# d
jon hohle
16.11.2007 14:12
Here are shorter versions of sam barrow's functions. From a PHP perspective these are O(1) (without getting into what's going on in the interpreter), instead of O(n).

<?php
function randomKey(array $array)
{
    return
randomElement(array_keys($array));
}

function
randomElement(array $array)
{
    if (
count($array) === 0)
    {
       
trigger_error('Array is empty.'E_USER_WARNING);
        return
null;
    }

   
$rand = mt_rand(0, count($array) - 1);
   
$array_keys = array_keys($array);
   
    return
$array[$array_keys[$rand]];
}
?>
sam barrow
13.11.2007 19:46
check out these functions - retrieves a random element or key of an array (numeric or string indexes, doesn't matter).

function randomKey(array $array)
    {
        global $mod, $plg, $sec ;
       
        $rand = rand(0, count($array) - 1) ;
       
        $counter = 0 ;
        foreach (array_keys($array) as $key)
            {
                if ($counter++ == $rand)
                    {
                        return $key ;
                    }
            }
           
        trigger_error('Array is empty.', E_USER_WARNING) ;
    }

function randomElement(array $array)
    {
        global $mod, $plg, $sec ;
       
        $rand = rand(0, count($array) - 1) ;
       
        $counter = 0 ;
        foreach ($array as $value)
            {
                if ($counter++ == $rand)
                    {
                        return $value ;
                    }
            }
           
        trigger_error('Array is empty.', E_USER_WARNING) ;
    }
Mike Mackintosh
30.10.2007 6:38
If you need to add an object as an array key, for example an object from Simple XML Parser, you can use the following.

File.XML
<?xml version="1.0" encoding="UTF-8"?>
<Settings type="General">
  <Setting name="SettingName">This This This</Setting>
</Settings>

The script:
<?php
$raw
= $xml =  new SimpleXMLElement('File.XML');
foreach(
$raw->Setting as $A => $B)
{       
   
// Set Array From XML
   
$Setting[(string) $B['name']] = (string)  $B[0];
}
?>
By telling the key to read the object as a string, it will let you set it.

Hope this helps someone out!
Sam Yong - hellclanner [at] live dot com
28.10.2007 2:39
I wanted to put a large range of numbers into an array but it seems to me that the array function don't have that kind of ability for me to put in a range of numbers without having to list down every single number.

Here's my solution:
<?php

function arr_range($r1,$r2){

// the end range is smaller than the start range
// switch around
if($r2 < $r1){
$t = $r1;
$r1 = $r2;
$r2 = $t;
unset(
$t);
}

$return_val = array();
$i = 0;

// for each value of the range
// add the value into the temparory array
for($i = $r1;$i<=$r2;$i++){
$return_val[] = $i;
}

// return the values in array form
return $return_val;
}

// example usages
$values = arr_range(100,6000);
$values = arr_range(1996,2010);
$values = arr_range(50,25); // it works
$values = arr_range(-64,1024);

?>
Christian W.
17.08.2007 11:27
If you already created an associative array you can add a new element by:

<?php
$arr
= array("foo" => 1);
print_r($arr);

$arr["bar"] = 2;
print_r($arr);
?>

Output:
Array
(
    [foo] => 1
)
Array
(
    [foo] => 1
    [bar] => 2
)
admin at baungenjar dot com
15.05.2007 3:11
I wrote the code below to load values from a query, than save them to two variables, code and text. It is used to replace values using str_replace.

The tricky part(for me) was building the two variables from a query.

//grab available classes - table of id numbers and //corresponding titles
$class_values = mysql_query($sql_classes);

// grab avaialable book conditions
$condition_values = mysql_query($sql_conditions);

// build conversion tables
// one for class one for coinditoion

    $condcode = array();
    $condtext = array();           
    $classcode = array();
    $classtext = array();
        $i=0;

  while ($row=mysql_fetch_row($condition_values)){
        //echo $row[0]." ".$row[1];
    $condcode[$i] =$row[0];
    $condtext[$i] =$row[1];    
        $i++;    
  }
    $i=0;
  while ($row=mysql_fetch_row($class_values)){
        //echo $row[0]." ".$row[1];
    $classcode[$i] = $row[0];
    $classtext[$i] = $row[1];       
        ++$i;   
  }

// there is no output, but now four arrays exist .
//there are four becuase theycame from two tables
// now i call

//example:
echo str_replace($classcode,$classtext,1);

//would output
Algebra

//
webmaster at phpemailformprocessor dot com
7.08.2006 6:48
When using an array to create a list of keys and values for a select box generator which will consist of states I found using "NULL" as an index and ""(empty value) as a value to be useful:

<?php

$states
= array(
   
0    => 'Select a State',
   
NULL => '',
   
1    => 'AL - Alabama',
   
2    => 'AK - Alaska',
   
# And so on ...
);

$select = '<select name="state" id="state" size="1">'."\r\n";

foreach(
$states as $key => $value){
   
$select .= "\t".'<option value="'.$key.'">' . $value.'</option>'."\r\n";
}

$select .= '</select>';

echo
$select;

?>

 This will print out:

<select name="state" id="state" size="1">
    <option value="0">Select a State</option>
    <option value=""></option>
    <option value="1">AL - Alabama</option>
    <option value="2">AK - Alaska</option>
    # And so on ...

</select>

Now a user has a blank value to select if they later decide to not provide their address in the form. The first two options will return TRUE when checked against the php function - EMPTY() after the form is submitted when processing the form
Craig at frostycoolslug dot com
25.07.2006 13:39
Just a helpful note, when creating arrays, avoid doing:

<?php
  $var
[key] = "value";
?>

PHP will look for a constant called 'key' before it will treat it as a string, thus slowing down execution (I've seen files with thousands of these and PHP taking over a second to execute).

Always concider switching on E_NOTICE before releasing any PHP, it'll help avoid making simple mistakes.
jupiter at nospam dot com
2.06.2006 12:33
<?php

// changes any combination of multiarray elements and subarrays
// into a consistent 2nd level multiarray, tries to preserves keys
function changeMultiarrayStructure($multiarray, $asc = 1) {
  if (
$asc == 1) {  // use first subarrays for new keys of arrays
   
$multiarraykeys = array_reverse($multiarray, true);
  } else { 
// use the last array keys
   
$multiarraykeys = $multiarray// use last subarray keys
 
// end array reordering
 
$newarraykeys = array();  // establish array
 
foreach ($multiarraykeys as $arrayvalue) {  // build new array keys
   
if (is_array($arrayvalue)) {  // is subarray an array
     
$newarraykeys = array_keys($arrayvalue) + $newarraykeys;
    } 
// if count(prevsubarray)>count(currentarray), extras survive
 
// end key building loop
 
foreach ($multiarray as $newsubarraykey => $arrayvalue) {
    if (
is_array($arrayvalue)) {  // multiarray element is an array
     
$i = 0// start counter for subarray key
     
foreach ($arrayvalue as $subarrayvalue) {  // access subarray
       
$newmultiarray[$newarraykeys[$i]][$newsubarraykey] = $subarrayvalue;
       
$i++;  // increase counter
     
// end subarray loop
   
} else {  // multiarray element is a value
     
foreach ($newarraykeys as $newarraykey) {  // new subarray keys
       
$newmultiarray[$newarraykey][$newsubarraykey] = $arrayvalue;
      } 
// end loop for array variables
   
// end conditional
 
// end new multiarray building loop
 
return $newmultiarray;
}

// will change
$old = array('a'=>1,'b'=>array('e'=>2,'f'=>3),'c'=>array('g'=>4),'d'=>5);
// to
$new = array('e'=>array('a'=>1,'b'=>2,'c'=>4,'d'=>5),
 
'f'=>array('a'=>1,'b'=>3,'d'=>5));

// note: if $asc parameter isn't default, last subarray keys used

?>

The new key/value assignment pattern is clearer with bigger arrays.
I use this to manipulate input/output data from my db. Enjoy.
bill at carneyco dot com
3.02.2006 5:42
I wanted to be able to control the flow of data in a loop instead of just building tables with it or having to write 500 select statements for single line items. This is what I came up with thanks to the help of my PHP brother in FL. Hope someone else gets some use out it.
<?

//set array variable
$results = array();

//talk to the db
$query = "SELECT * FROM yourtable";
$result = mysql_query($query) or die(mysql_error());

//count the rows and fields
$totalRows = mysql_num_rows($result);
$totalFields = mysql_num_fields($result);

//start the loop
for ( $i = 0; $i < $totalRows; ++$i ) {

//make it 2 dim in case you change your order
 
$results[$i] = mysql_fetch_array($result);

//call data at will controlling the loop with the array
echo $results[your_row_id]['your_field_name']; }

//print the entire array to see what lives where
print_r($results);  ?>
php
7.01.2006 12:30
This function converts chunks of a string in an array:

function array_str($str, $len) {
  $newstr = '';
  for($i = 0; $i < strlen($str); $i++) {
    $newstr .= substr($str, $i, $len);
  }
  return $newstr;
}

use it as:

$str = "abcdefghilmn";
echo "<table width=\"100%\">\n";
foreach(array_str($str, 4) as $chunk) {
  echo "<tr><td>".$chunk."</td></tr>\n";
}
echo "</table>";

this prints:

------
abcd
------
efgh
------
ilmn
------

It don't use regular expressions. Please add this function to php :)
James
24.11.2005 10:04
re: m.izydorski 29-May-2005 07:17

The reason the code snippet below is "very slow" is because the backtick (`) is a shell call delimiter, not a string delimiter. Every element of the array would be executed as a shell call and the result stored as array elements.

<?
// Very slow:
$my_array = array(`sign`, `cat01`, `cat02`, ... , `cat40`,`terra01`, `terra02`, ... , `terra50`);
?>

See the backtick operator page for more information:
http://uk2.php.net/manual/en/language.operators.execution.php
matthiasDELETETHIS at ansorgs dot de
31.05.2005 23:52
How to use array() to create an array of references rather than of copies? (Especially needed when dealing with objects.) I played around somewhat and found a solution: place & before the parameters of array() that shall be references. My PHP version is 4.3.10.

Demonstration:

<?php
$ref1
= 'unchanged';
$ref2 = & $ref1;

$array_of_copies = array($ref1, $ref2);
print_r($array_of_copies); // prints: Array ( [0] => unchanged [1] => unchanged )
$array_of_copies[0] = 'changed'; // $ref1 = 'changed'; is not equivalent, as it was _copied_ to the array
print_r($array_of_copies); // prints: Array ( [0] => changed [1] => unchanged )

$array_of_refs = array(& $ref1, & $ref2); // the difference: place & before arguments
print_r($array_of_refs); // prints: Array ( [0] => unchanged [1] => unchanged )
$array_of_refs[0] = 'changed'; // $ref1 = 'changed'; is equivalent as $array_of_refs[0] references $ref1
print_r($array_of_refs, true); // prints: Array ( [0] => changed [1] => changed )
?>
m dot izydorski at anti_spa_m dot rubikon dot pl
29.05.2005 21:17
Ad. rdude's comment

Additionally, there is a performance loss while one are using ` marks instead ' when creating an array:

<?
//Very slow:
$my_array = array(`sign`, `cat01`, `cat02`, ... , `cat40`,`terra01`, `terra02`, ... , `terra50`);

//Much faster:
$my_array = array('sign', 'cat01', 'cat02', ... , 'cat40', 'terra01', 'terra02', ... , 'terra50');
?>

There is no reason to use ` marks (as I know), but this is a default question mark used in query output in phpMyAdmin. If you copy-paste phpMyAdmin query display, you can encounter serious performance problem.
aissatya at yahoo dot com
16.05.2005 22:48
<?php

$foo
= array('bar' => 'baz');
echo
"Hello {$foo['bar']}!"; // Hello baz!

?>
<?php
$firstquarter
= array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>
<?php
$fruits
= array (
  
"fruits"  => array("a" => "orange", "b" => "banana", "c" => "apple"),
  
"numbers" => array(1, 2, 3, 4, 5, 6),
  
"holes"  => array("first", 5 => "second", "third")
);
?>
brian at blueeye dot us
22.04.2005 2:34
If you need, for some reason, to create variable Multi-Dimensional Arrays, here's a quick function that will allow you to have any number of sub elements without knowing how many elements there will be ahead of time. Note that this will overwrite an existing array value of the same path.

<?php
// set_element(array path, mixed value)
function set_element(&$path, $data) {
    return (
$key = array_pop($path)) ? set_element($path, array($key=>$data)) : $data;
}
?>

For example:

<?php
echo "<pre>";
$path = array('base', 'category', 'subcategory', 'item');
$array = set_element($path, 'item_value');
print_r($array);
echo
"</pre>";
?>

Will display:
Array
(
    [base] => Array
        (
            [category] => Array
                (
                    [subcategory] => Array
                        (
                            [item] => item_value
                        )
                )
        )
)
mortoray at ecircle-ag dot com
18.02.2005 14:35
Be careful if you need to use mixed types with a key of 0 in an array, as several distinct forms end up being the same key:

$a = array();
$a[null] = 1;
$a[0] = 2;
$a['0'] = 3;
$a["0"] = 4;
$a[false] = 5;
$a[0.0] = 6;
$a[''] = 7;
$a[] = 8;

print_r( $a );

This will print out only 3 values: 6, 7, 8.
rdude at fuzzelish dot com
17.02.2005 22:35
If you are creating an array with a large number of static items, you will find serious performance differences between using the array() function and the $array[] construct. For example:
<?
 
// Slower method
 
$my_array = array(1, 2, 3, 500);
 
 
// Faster method
 
$my_array[] = 1;
 
$my_array[] = 2;
 
$my_array[] = 3;
 

 $my_array
[] = 500;
?>
michael dot bommarito at gmail dot com
15.01.2005 16:14
Just in case anyone else was looking for some help writing an LU decomposition function, here's a simple example. 

N.B. All arrays are assumed to begin with index 1, not 0.  This is not hard to change, but make sure you specify array(1=>...), not just array(...).

Furthermore, this function is optimized to only consider variable elements of the matrices.  As $L will be a lower triangular matrix, there is no need to compute the elements of either the diagonal or the upper triangle; likewise with $U.

This function also does not check to verify that the input matrix is non-singular.

/*
 * LU Decomposition
 * @param $A initial matrix (1...m x 1...n)
 * @param $L lower triangular matrix, passed by reference
 * @param $U upper triangular matrix, passed by reference
*/
function LUDecompose($A, &$L, &$U) {
    $m = sizeof($A);
    $n = sizeof($A[1]);

    for ( $i = 1; $i <= $m; $i++ ) {
        $U[$i][$i] = $A[$i][$i];
       
        for ( $j = $i + 1; $j <= $m; $j++ ) {
            $L[$j][$i] = $A[$j][$i] / $U[$i][$i];
            $U[$i][$j] = $A[$i][$j];
        }
        for ( $j = $i + 1; $j <= $m; $j++ ) {
            for ( $k = $i + 1; $k <= $m; $k++ ) {
                $A[$j][$k] = $A[$j][$k] - ($L[$j][$i] * $U[$i][$k]);
            }
        }
    }

    return;
}
phpm at nreynolds dot me dot uk
11.01.2005 17:24
This helper function creates a multi-dimensional array. For example, creating a three dimensional array measuring 10x20x30: <?php $my_array = multi_dim(10, 20, 30); ?>

<?php

function multi_dim()
{   
   
$fill_value = null;
   
    for (
$arg_index = func_num_args() - 1; $arg_index >= 0; $arg_index--) {
       
$dim_size = func_get_arg($arg_index);
       
$fill_value = array_fill(0, $dim_size, $fill_value);
    }
   
    return
$fill_value;
}

?>
stephen[AT]brooksie-net[DOT]co[DOT]uk
17.12.2004 13:57
I think I may have found a simpler, slightly more logical route to solving the previous problem. I came across this solution when retreving data from MySql which in most cases was for individual bits of data, but also needed to reference a set of sub data from a second table.

<?php

// -------------------------------------------------------
// Function: db_get_data()
// Desc: Build array of data from mysql table and sub table(s)
// PreCondition: None
// Returns: Array of rows / sub rows from db,
// -------------------------------------------------------

function db_get_data()
{
   
$ar_sub = array();

   
   
/* [ .... code for connecting and querying DB .... ] */

    // Retireve from first table
   
$row = mysql_fetch_row($result);
       
   
// Get first two fields       
   
$ar_details['item0'] = $row ['field0'];
   
$ar_details['item1'] = $row ['field1'];

   
// Using result from query on sub table
    // for each sub row, 'push' data on sub array
   
while($row_sub = mysql_fetch_array($result_sub))
    {
       
array_push($ar_sub, $row_sub['sub_field']);
    }

   
// Add sub array as element of parent array
   
$ar_details['item3'] = $ar_sub;

    return
$ar_details;
}

// -------------------------------------------------------
// Retrieving array data
// -------------------------------------------------------

// Call function
$arr_details = db_get_data()

// Output Data
echo $ar_details['item1'];
echo
$ar_details['item2'];

// For each record in sub array....
for($i=0; $i<count($ar_details['item3']); $i++)
{
    echo
$ar_details['item3'][$i];
}

?>

For extra sub tables the process can be repeated by adding more sub arrays, and each sub array can hold as much data as you like. Therefore allowing you to build an ever expanding tree as required. If you have the option I would recommend using nested classes though :)
baZz
17.10.2003 0:27
Chek this out!!!. Suppose that you want to create an array like the following:
<?php
  $arr1
= (
   
0 => array ("customer"=>"Client 1","Item a"),
   
1 => array ("customer"=>"Client 2","Item b")
  );
?>
Seems prety easy, but what if you want to generate it dinamically woops!!!.  Imagine that you have a file with thousands of lines and each line is a purchase order from diferent clients:
<?php
/*function to add elements*/
function addArray(&$array, $id, $var)
{
   
$tempArray = array( $var => $id);
   
$array = array_merge ($array, $tempArray);
}
/*The same as above but the element is an array*/
function addArrayArr(&$array, $var, &$array1)
{
   
$tempArray = array($var => $array1);
   
$array = array_merge ($array, $tempArray);
}
/*labels of our array or heders of the file*/
$keyarr = array("customer","item");
/*info that may you read from a file line 1 and 2*/
$valarr0 = array("Client 1","Item a");
$valarr1 = array("Client 2","Item b");

$numofrows = 2;/*In our case is just two lines*/
$tmpArray = array();
for(
$i = 0; $i < $numofrows; $i++){
 
$tmp = "valarr$i";
 
$tmpvar = ${$tmp};/*Using var of vars tricky tricky*/
 
foreach( $keyarr as $key=>$value){    
   
addArray($tmparr,$tmpvar[$key],$value);
  }
 
addArrayArr($finalarr,$i,$tmparr);
}
/*voila all it's perfectly ordered on finalarr*/

/*Here we just print the info but you can insert it into a database*/
echo "Customer: ".$finalarr[0]["customer"]."<br>";
echo
"Item: ".$finalarr[0]["item"]."<br>";
echo
"Customer: ".$finalarr[1]["customer"]."<br>";
echo
"Item: ".$finalarr[1]["item"]."<br>";         
?>

The lines above should print something like:
Customer: Client 1
Item: Item a
Customer: Client 2
Item: Item b
I hope someone find this useful.
TCross1 at hotmail dot com
3.09.2003 9:38
here is the sort of "textbook" way to output the contents of an array which avoids using foreach() and allows you to index & iterate through the array as you see fit:

<?php

$arrayName
= array("apples", "bananas", "oranges", "pears");
$arrayLength = count($arrayName);

for (
$i = 0; $i < $arrayLength; $i++){
    echo
"arrayName at[" . $i . "] is: [" .$arrayName[$i] . "]<br>\n";
}

?>

enjoy!

-tim
darthjarkon at hotmail dot com
9.07.2003 20:09
I found a slightly better way to create large 2d arrays:

<?php
// this will simply output a 2d array-- it isn't very robust but it
//suits my needs here
function display_all($array){
    echo
"<table><tr>";
    foreach(
$array as $spot){
    echo
"<td align='center' width= '20'>";
    foreach(
$spot as $spotdeux){
    echo
"<br>".$spotdeux;
    }
    }
    echo
"</tr> </table>";       
}
//this actually creates the array and puts the value 0 in all
// locations.  the $xax and $yax can be upped or
//downed to create a larger or smaller array
function creater_array(){
   
$ar=Array();
   
$xax=5;
   
$yax=5;
   
$i=1;
    for (
$y=0; $y<$yax; $y++)
    {
   
array_push($ar,array());
    for (
$x=0; $x<$xax; $x++)
    {
   
array_push($ar[$y],"0");
    }
    }
return
$ar;
}   

$b = creater_array();
display_all($b);
?>

10.05.2003 12:53
Similarly to a comment by stlawson at sbcglobal dot net on this page:
http://www.php.net/basic-syntax.instruction-separation

It is usually advisable to define your arrays like this:
$array = array(
     'foo',
     'bar',
);

Note the comma after the last element - this is perfectly legal. Moreover,
it's best to add that last comma so that when you add new elements to the
array, you don't have to worry about adding a comma after what used to be
the last element.

<?php
$array
= array(
    
'foo',
    
'bar',
    
'baz',
);
?>
marcel at labor-club dot de
25.02.2003 4:58
i tried to find a way to create BIG multidimensional-arrays. but the notes below only show the usage of it, or the creation of small arrays like $matrix=array('birne', 'apfel', 'beere');

for an online game, i use a big array (50x80) elements.
it's no fun, to write the declaration of it in the ordinary way.

here's my solution, to create an 2d-array, filled for example with raising numbers.

<?php
$matrix
=array();
$sx=30;
$sy=40;
$i=1;
for (
$y=0; $y<$sy; $y++)
{
   
array_push($matrix,array());
    for (
$x=0; $x<$sx; $x++)
    {
       
array_push($matrix[$y],array());
       
$matrix[$x][$y]=$i;
       
$i++;
    }
}
?>

if there is a better way, plz send an email. i always want to learn more php!
grubby_d at yahoo dot com
6.12.2002 19:58
About NULL as an array index.

An interesting thing with arrays is that you can use NULL as an index. I am trying it out with drop down list which will be used to update a database. Its not that good of an idea but it made me find the solution. For the database example you want to use the index "NULL" with quotes.

Say you have table person which has a foreign key reference to companies. BUT you want to allow the user to not specify a company as well. So you have determined that the database reference allows NULLs.

So you make a SELECT control with the lookup values as:

<OPTION value=(comp_id)>comp_name</OPTION>

using a while loop to print out the values.

Then you want the option to select NONE of the options. If you use something like -1 or 0 to represent this "blank" option you have to handle that in your php. Instead add this to your array: myarray("NULL") = "-none-" and you will get a field like this:

<OPTION value=NULL>-none-</OPTION>

Now every value from your SELECT control will be valid for the database and wont cause a foreign key references violation. it doesnt guarantee the data is coming from your trusty SELECT box so you still may want to check anyway.

Some interesting things about using the real NULL value as an array index:

<?php
$myarray
= array(1, 2, 3);

echo
count($myarray) . "<BR>"// 3
$myarray[NULL] = "the null value";
echo
count($myarray) . "<BR>"// 4

if (array_key_exists(NULL, $myarray)
{ echo
"this code will never be reached";}
?>

This will return FALSE and will generate this warning:

Warning: Wrong datatype for first argument in call to array_key_exists
MadLogic at Paradise dot net dot nz
31.10.2002 23:39
Heres a simple yet intelligent way of setting an array, grabbing the values from the array using a loop.

<?php
$ary
= array("1"=>'One','Two',"3"=>'Three');
$a = '0'; $b = count($ary);
while (
$a <= $b) {
 
$pr = $ary[$a];
  print
"$pr<br>";
 
$a++;
}
?>
mads at __nospam__westermann dot dk
23.10.2002 16:39
In PHP 4.2.3 (and maybe earlier versions) arrays with numeric indexes may be initialized to start at a specific index and then automatically increment the index. This will save you having to write the index in front of every element for arrays that are not zero-based.

The code:

<?php
                  $a
= array
        (
           
21    => 1,
           
2,
           
3,
        );
    print
'<pre>';
   
print_r($a);
    print
'</pre>';
?>

will print:

<?php
Array
(
    [
21] => 1
   
[22] => 2
   
[23] => 3
)
?>
John
18.07.2002 20:48
Be careful not to create an array on top of an already existing variable:

<?php
$name
= "John";
$name['last'] = "Doe";
?>

$name becomes "Dohn" since 'last' evaluates to the 0th position of $name.
Same is true for multi-arrays.
Markus dot Elfring at web dot de
31.05.2002 0:04
It seems to me that the use of brackets with multidimensional arrays is not described here.

But the following examples work:

<?php
$value
= $point['x']['y'];
$message[1][2][3] = 'Greetings';
?>
jay at ezlasvegas dot net
21.04.2002 1:21
If you want to create an array of a set size and you have PHP4, use
array_pad(array(), $SIZE, $INITIAL_VALUE); This can be handy if you wish
to initialize a bunch of variables at once:

list($Var1, $Var2, etc) = array_pad(array(), $NUMBER_OF_VARS,
$INITIAL_VALUE);

Jay Walker
Las Vegas Hotel Associate
http://www.ezlasvegas.net
jjm152 at hotmail dot com
11.03.2002 3:22
The easiest way to "list" the values of either a normal 1 list array or a multi dimensional array is to use a foreach() clause.

Example for 1 dim array:

<?php
   $arr
= array( 1, 2, 3, 4, 5 );
   foreach (
$arr as $val ) {
       echo
"Value: $Val\n";
      }
?>

For multi dim array:

<?php
     $arr
= array( 1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four, 5 => 'five');
      foreach ( $arr as $key => $value ) {
       echo "Key: $key, Value: $value\n";
      }
?>

This is quite possibly the easiest way i'
ve found to iterate through an array.
tobiasquinteiro at ig dot com dot br
29.01.2002 21:25
<?
       
// This is a small script that shows how to use an multiple array
       
for($x = 0;$x < 10;$x++){
                for(
$y = 0;$y < 10;$y++){
                       
$mat[$x][$y] = "$x,$y";
                }
        }

        for(
$x = 0;$x < count($mat);$x++){
                for(
$y = 0;$y < count($mat[$x]);$y++){
                        echo   
"mat[$x][$y]: " .
                               
$mat[$x][$y] . " ";
                }
                echo
"\n";
        }
?>
deepak_pradhan at yahoo dot com
16.09.2001 2:16
I have seen that most of the time we get confused with Mult-Dimensional arrays.
I found print_r to be very helpful here.

Say the defined array is:
$a = array(1,2,array("A","B"));

print_r ($a);
Should give result like this:
Array ( [0] => 1 [1] => 2 [2] => Array ( [0] => A [1] => B ) )
We can see here that:
$a is an array, $a[0]=1, $a[1]=2 and $a[2]=array it self with two elements.


thx
dp
joshua dot e at usa dot net
24.05.2001 20:12
Here's a cool tip for working with associative arrays-
Here's what I was trying to accomplish:

I wanted to hit a DB, and load the results into an associative array, since I only had key/value pairs returned. I loaded them into an array, because I wanted to manipulate the data further after the DB select, but I didn't want to hit the DB more than necessary.

Here's how I did it:

<?php
//assume db connectivity
//load it all into the associative array
$sql = "SELECT key,value FROM table";
$result = mysql_query($sql);
while(
$row = mysql_fetch_row($result)) {
$myArray[$row[0]] = $row[1];
}
//now we expand it
while(list($key,$value) = each($myArray)) {
echo
"$key : $value";
}
?>

I found this to be super efficient, and extremely cool.
slicky at newshelix dot com
20.03.2001 22:57
Notice that you can also add arrays to other arrays with the $array[] "operator" while the dimension doesn't matter.

Here's an example:
$x[w][x] = $y[y][z];
this will give you a 4dimensional assosiative array.
$x[][] = $y[][];
this will give you a 4dimensional non assosiative array.

So let me come to the point. This get interessting for shortening things up. For instance:

<?php
       
foreach ($lines as $line){
            if(!
trim($line)) continue;
           
$tds[] = explode("$delimiter",$line);
        }
?>
jasonr at argia dot net
28.11.2000 2:01
Arrays are never removed from memory, however there is an internal pointer that always points to the "next" array item. After you interate through an array, this will need to be reset back to the first element if you want to access it in a loop again.
see the Reset function at
http://www.php.net/manual/function.reset.php if you are confused.
rubein at earthlink dot net
26.09.2000 20:07
Multidimensional arrays are actually single-dimensional arrays nested inside other single-dimensional arrays.

$array[0] refers to element 0 of $array
$array[0][2] refers to element 2 of element 0 of $array.

If an array was initialized like this:

$array[0] = "foo";
$array[1][0] = "bar";
$array[1][1] = "baz";
$array[1][2] = "bam";

then:
is_array($array) = TRUE
is_array($array[0]) = FALSE
is_array($array[1]) = TRUE
count($array) = 2 (elements 0 and 1)
count($array[1] = 3 (elements 0 thru 2)

This can be really useful if you want to return a list of arrays that were stored in a file or something:

$array[0] = unserialize($somedata);
$array[1] = unserialize($someotherdata);

if $somedata["foo"] = 42 before it was serialized previously, you'd now have this:
$array[0]["foo"] = 42
php-manual at improbable dot org
2.04.2000 12:17
If you want to create an array of a set size and you have PHP4, use array_pad(array(), $SIZE, $INITIAL_VALUE); This can be handy if you wish to initialize a bunch of variables at once:

list($Var1, $Var2, etc) = array_pad(array(), $NUMBER_OF_VARS, $INITIAL_VALUE);
baghera at mindspring dot com
12.10.1999 23:54
Every array has an "internal pointer". When you create an array, the internal pointer is automatically set to point at the first member. You can print the current location of the pointer:

$bob= current($myarrayname);
echo "$bob";

You can advance the pointer to the next spot using next($myarrayname).

To see a particular member of an array, set a $variable= $myarrayname[2] where "2" is the number of the member you want to use.

When assigning members to an array, the members are numbered beginning with 0, rather than 1.



PHP Powered Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)