(PHP 4, PHP 5, PHP 7, PHP 8)
array — 创建数组
values语法 "index => values"，用逗号分隔，定义索引和值。索引可以是字符串或整数类型。省略索引时，会自动生成整数索引，从 0 开始。如果索引是整数，下一个生成的索引将是最大的整数索引 + 1。请注意，如果定义了两个相同的索引，最后一个会覆盖第一个。
在最后一个定义的数组条目之后有一个尾随逗号，虽然不常见，但它是一个有效的语法。
返回参数的数组。可以使用=>运算符为参数指定索引。有关数组的更多信息，请阅读有关数组类型的部分。
以下示例演示了如何创建二维数组，如何为关联数组指定键，以及如何在普通数组中跳过和继续数字索引。
示例 #1 array() 示例
<?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")
);
?>
示例 #2 使用 array() 自动索引
<?php
$array = array(1, 1, 1, 1, 1, 8 => 1, 4 => 1, 19, 3 => 13);
print_r($array);
?>上面的示例将输出
Array
(
[0] => 1
[1] => 1
[2] => 1
[3] => 13
[4] => 1
[8] => 1
[9] => 19
)
请注意，索引 '3' 被定义了两次，并保留了它的最终值 13。索引 4 在索引 8 之后定义，下一个生成的索引（值 19）是 9，因为最大的索引是 8。
此示例创建了一个从 1 开始的数组。
示例 #3 使用 array() 从 1 开始的索引
<?php
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>上面的示例将输出
Array
(
[1] => January
[2] => February
[3] => March
)
与 Perl 一样，您可以在双引号中访问数组中的值。但是，在 PHP 中，您需要将数组放在花括号中。
示例 #4 在双引号中访问数组
<?php
$foo = array('bar' => 'baz');
echo "Hello {$foo['bar']}!"; // Hello baz!
?>
注意:
array() 是用于表示文字数组的语言结构，而不是常规函数。
从 PHP 5.4.x 开始，您现在可以使用“简短语法数组”，从而无需使用此函数。
示例 #1 “简短语法数组”
<?php
$a = [1, 2, 3, 4];
print_r($a);
?>
上面的示例将输出
数组
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
)
示例 #2 “简短语法关联数组”
<?php
$a = ['one' => 1, 'two' => 2, 'three' => 3, 'four' => 4];
print_r($a);
?>
上面的示例将输出
数组
(
[one] => 1
[two] => 2
[three] => 3
[four] => 4
)我遇到了以下情况，但在任何地方都没有看到它被记录或报告，所以我只是在这里提一下。
如手册中所述
"省略索引时，会自动生成整数索引，从 0 开始。如果索引是整数，下一个生成的索引将是最大的整数索引 + 1"。
此生成的索引始终是迄今为止用作键的最大整数。因此，在 $a[10] = 'bar'; 之后添加 $a[5] = 'foo'; 不会强制下一个生成的索引为 6，而是为 11，因为 10 是迄今为止遇到的最高索引。
无论如何，可能会发生以下情况
<?php
$max_int = 2147483647; // 32 位系统上整型的最大值
$arr = array();
$arr[1] = 'foo'; // 新生成的索引将是 2
$arr[ $max_int ] = 'bar'; // 注意：由于整数溢出，下一个生成的索引将是 -2147483648！
$arr[0] = 'bar'; // 最高值应该是 2147483648，但由于溢出，它是 -2147483648，所以当前索引 0 较大。因此，新生成的索引为 1！
$arr[] = 'failure'; // 警告：无法向数组添加元素，因为下一个元素已被占用。
?>以下是 Sam Barrow 函数的简化版本。从 PHP 的角度来看，这些函数是 O(1)（不考虑解释器内部情况），而不是 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]];
}
?><?php
// 将任何组合的多维数组元素和子数组
// 转换为一致的二级多维数组，并尝试保留键
function changeMultiarrayStructure($multiarray, $asc = 1) {
if ($asc == 1) { // 使用第一个子数组作为新数组的键
$multiarraykeys = array_reverse($multiarray, true);
} else { // 使用最后一个数组的键
$multiarraykeys = $multiarray; // 使用最后一个子数组的键
} // 数组重新排序结束
$newarraykeys = array(); // 创建数组
foreach ($multiarraykeys as $arrayvalue) { // 构建新数组的键
if (is_array($arrayvalue)) { // 子数组是否为数组
$newarraykeys = array_keys($arrayvalue) + $newarraykeys;
} // 如果 count(上一个子数组) > count(当前数组)，多余的部分保留
} // 键构建循环结束
foreach ($multiarray as $newsubarraykey => $arrayvalue) {
if (is_array($arrayvalue)) { // 多维数组元素是否为数组
$i = 0; // 子数组键的计数器开始
foreach ($arrayvalue as $subarrayvalue) { // 访问子数组
$newmultiarray[$newarraykeys[$i]][$newsubarraykey] = $subarrayvalue;
$i++; // 计数器增加
} // 子数组循环结束
} else { // 多维数组元素为值
foreach ($newarraykeys as $newarraykey) { // 新的子数组键
$newmultiarray[$newarraykey][$newsubarraykey] = $arrayvalue;
} // 数组变量循环结束
} // 条件结束
} // 新多维数组构建循环结束
return $newmultiarray;
}
// 将更改
$old = array('a'=>1,'b'=>array('e'=>2,'f'=>3),'c'=>array('g'=>4),'d'=>5);
// 到
$new = array('e'=>array('a'=>1,'b'=>2,'c'=>4,'d'=>5),
'f'=>array('a'=>1,'b'=>3,'d'=>5));
// 注意：如果 $asc 参数不是默认值，则使用最后一个子数组的键
?>
对于更大的数组，新的键值赋值模式更清晰。
我使用它来处理来自数据库的输入/输出数据。请享用。以下函数（类似于上面的函数）将把数组渲染为一系列 HTML select 选项（即 "<option>...</option>"）。之前函数的问题是无法处理 <optgroup>，所以这个函数解决了这个问题。
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;
}
例如，我需要在 select 字段中渲染各个国家/地区的州/省列表，并且我想使用每个国家/地区名称作为 <optgroup> 标签。因此，使用此函数，如果只向函数传递单个数组（即 "arrayToSelect($stateList)"），则它将简单地输出一堆 "<option>" 元素。另一方面，如果向它传递两个数组，则第二个数组将成为第一个数组的 "键" 用于翻译。
以下是一个更进一步的示例
$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>如果您需要将对象作为数组键添加，例如来自 Simple XML Parser 的对象，您可以使用以下方法。
File.XML
<?xml version="1.0" encoding="UTF-8"?>
<Settings type="General">
<Setting name="SettingName">This This This</Setting>
</Settings>
脚本
<?php
$raw = $xml = new SimpleXMLElement('File.XML');
foreach($raw->Setting as $A => $B)
{
// 从 XML 设置数组
$Setting[(string) $B['name']] = (string) $B[0];
}
?>
通过告诉键将对象读取为字符串，它将允许您设置它。
希望这对某人有所帮助！如果您出于某种原因需要创建变量多维数组，以下是一个快速函数，它允许您拥有任意数量的子元素，而无需事先知道有多少元素。请注意，这将覆盖相同路径的现有数组值。
<?php
// set_element(array path, mixed value)
function set_element(&$path, $data) {
return ($key = array_pop($path)) ? set_element($path, array($key=>$data)) : $data;
}
?>
例如
<?php
echo "<pre>";
$path = array('base', 'category', 'subcategory', 'item');
$array = set_element($path, 'item_value');
print_r($array);
echo "</pre>";
?>
将显示
数组
(
[base] => Array
(
[category] => Array
(
[subcategory] => Array
(
[item] => item_value
)
)
)
)一个“快速且肮脏”的类，用于通过给定的路径获取多维数组的偏移量（抱歉，没有注释）。
<?php
class ArrayAsPathException extends Exception {}
class ArrayAsPath {
protected
$data = array(),
$separator = '.';
public function __construct (array $data = array()) {
$this->data = $data;
}
public function set ($value, $path = null) {
if (!isset($path)) {
$this->data = $value;
}
$separator = $this->separator;
$pathtoken = strtok($path, $separator);
$code = '';
$pices = '[\''.$pathtoken.'\']';
while ($pathtoken !== false) {
if (($pathtoken = strtok($separator)) !== false) {
$code .= 'if (!isset($this->data'.$pices.')) $this->data'.$pices.' = array(); ';
$pices .= '[\''.$pathtoken.'\']';
} else {
$code .= 'return $this->data'.$pices.' = $value;';
}
}
return eval($code);
}
public function get ($path = '', $default = null) {
$result = $this->data;
$separator = $this->separator;
$pathtoken = strtok($path, $separator);
while ($pathtoken !== false) {
if (!isset($result[$pathtoken]) || is_string($result)) {
if (isset($default)) {
return $default;
}
throw new ArrayAsPathException ('Can\'t find "'.$pathtoken.'" in "'.$path.'"');
}
$result = $result[$pathtoken];
$pathtoken = strtok($separator);
}
return $result ? $result : $default;
}
public function has ($path) {
$result = $this->data;
$separator = $this->separator;
$pathtoken = strtok($path, $separator);
while ($pathtoken !== false) {
if (!isset($result[$pathtoken]) || is_string($result)) {
return false;
}
$result = $result[$pathtoken];
$pathtoken = strtok($separator);
}
return true;
}
public function setSepatator ($separator) {
$this->separator = $separator;
}
public function getSeparator ($separator) {
return $this->separator;
}
}
?>
代码
<?php
$params = new ArrayAsPath;
$params->set(array(
'foo' => array(
'bar' => array(
'item' => 'Value'
)
)
));
try {
$params->set('test', 'foo.bar.far.new');
printf(
'Array:<pre>%s</pre>
foo.bar.item:<pre>%s</pre>
foo.bar.far:<pre>%s</pre>
foo.bar.far.new<pre>%s</pre>',
var_export($params->get(), true),
var_export($params->get('foo.bar.item'), true),
var_export($params->get('foo.bar.far'), true),
var_export($params->get('foo.bar.far.new'), true)
);
} catch (ArrayAsPathException $e) {
echo 'Oops! It seems that something is wrong. '.$e->getMessage();
}
?>
将显示
数组
array (
'foo' =>
array (
'bar' =>
array (
'item' => 'Value',
'far' =>
array (
'new' => 'test',
),
),
),
)
foo.bar.item
'Value'
foo.bar.far
array (
'new' => 'test',
)
foo.bar.far.new
'test'请注意，您也可以使用 $array[] "运算符" 将数组添加到其他数组中，而维度无关紧要。
以下是一个例子
$x[w][x] = $y[y][z];
这将为您提供一个 4 维的关联数组。
$x[][] = $y[][];
这将为您提供一个 4 维的非关联数组。
所以，让我直奔主题。这对于缩短代码很有用。例如
<?php
foreach ($lines as $line){
if(!trim($line)) continue;
$tds[] = explode("$delimiter",$line);
}
?>数组可以执行代码。
我在 php 7.4（xampp 版本）上尝试了这个。
<?php
[
$msg='HI GUYS !'
,print ($msg)
,(function()use ($msg){
print 'here is php';
})()
,print ' I`m just an array ,alive one'
];
?>使用 foreach() 语句，可以最轻松地 "列出" 一维数组或多维数组的值。
一维数组的示例
<?php
$arr = array( 1, 2, 3, 4, 5 );
foreach ( $arr as $val ) {
echo "Value: $Val\n";
}
?>
多维数组
<?php
$arr = array( 1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four, 5 => 'five');
foreach ( $arr as $key => $value ) {
echo "Key: $key, Value: $value\n";
}
?>
这可能是我找到的遍历数组最简单的方法。多维数组实际上是嵌套在其他一维数组中的一个一维数组。
$array[0] 指的是 $array 的元素 0
$array[0][2] 指的是 $array 的元素 0 的元素 2。
如果数组这样初始化
$array[0] = "foo";
$array[1][0] = "bar";
$array[1][1] = "baz";
$array[1][2] = "bam";
那么
is_array($array) = TRUE
is_array($array[0]) = FALSE
is_array($array[1]) = TRUE
count($array) = 2（元素 0 和 1）
count($array[1] = 3（元素 0 到 2）
如果您想要返回存储在文件或其他地方的一系列数组，这将非常有用。
$array[0] = unserialize($somedata);
$array[1] = unserialize($someotherdata);
如果在之前序列化之前，$somedata["foo"] = 42，那么您现在将拥有：
$array[0]["foo"] = 42此函数将字符串的块转换为数组。
function array_str($str, $len) {
$newstr = '';
for($i = 0; $i < strlen($str); $i++) {
$newstr .= substr($str, $i, $len);
}
return $newstr;
}
使用方式如下
$str = "abcdefghilmn";
echo "<table width=\"100%\">\n";
foreach(array_str($str, 4) as $chunk) {
echo "<tr><td>".$chunk."</td></tr>\n";
}
echo "</table>";
这将打印
------
abcd
------
efgh
------
ilmn
------
它不使用正则表达式。请将此函数添加到 php 中 :)在初始化期间，php 将每个值解析为表达式。可以声明变量、进行计算，甚至可以操作 "当前" 数组。
<?php
$arr['A'] = [
&$arr, // 循环引用
'key' => 'val',
$arr['B'] = [ // 声明数组，插入键，然后是值
'a' => 'b',
],
ucfirst(strtolower('SOME TEXT')),
true ? 'TRUE' : 'FALSE', // 评估表达式
$x = 3, // 声明变量
$x *= 3, // 执行计算
];
var_dump($arr);
// 输出
/*
array(2) {
'B' => array(1) {
'a' => string(1) "b"
}
'A' => array(7) {
[0] => array(2) {
'B' => array(1) {
...
}
'A' => &array
}
'key' => string(3) "val"
[1] => array(1) {
'a' => string(1) "b"
}
[2] => string(9) "Some text"
[3] => string(4) "TRUE"
[4] => int(3)
[5] => int(9)
}
}
*/
?>我希望能够控制循环中的数据流，而不仅仅是构建表格，或者为单行项目编写 500 个 select 语句。感谢佛罗里达州的 PHP 兄弟的帮助，我得出了以下方法。希望其他人也能从中获益。
<?
// 设置数组变量
$results = array();
// 与数据库通信
$query = "SELECT * FROM yourtable";
$result = mysql_query($query) or die(mysql_error());
// 统计行数和字段数
$totalRows = mysql_num_rows($result);
$totalFields = mysql_num_fields($result);
// 开始循环
for ( $i = 0; $i < $totalRows; ++$i ) {
// 如果您更改顺序，请将其设为二维
$results[$i] = mysql_fetch_array($result);
// 根据需要调用数据，使用数组控制循环
echo $results[your_row_id]['your_field_name']; }
// 打印整个数组，查看每个元素的位置
print_r($results); ?>与本页 stlawson at sbcglobal dot net 的评论类似
https://php.net/basic-syntax.instruction-separation
通常建议您像这样定义数组
$array = array(
'foo',
'bar',
);
请注意最后一个元素后面的逗号 - 这是完全合法的。此外，
最好添加最后一个逗号，这样当您向数组中添加新元素时，
就不必担心在原来最后一个元素后面添加逗号。
<?php
$array = array(
'foo',
'bar',
'baz',
);
?>如果您要创建一个包含大量静态项目的数组，您会发现使用 array() 函数和 $array[] 结构之间存在严重的性能差异。例如
<?
// 较慢的方法
$my_array = array(1, 2, 3, ? 500);
// 较快的方法
$my_array[] = 1;
$my_array[] = 2;
$my_array[] = 3;
?
$my_array[] = 500;
?>如果您想创建一个特定大小的数组，并且使用的是 PHP4，请使用
array_pad(array(), $SIZE, $INITIAL_VALUE); 如果您想
同时初始化一堆变量，这将非常方便。
list($Var1, $Var2, etc) = array_pad(array(), $NUMBER_OF_VARS,
$INITIAL_VALUE);
Jay Walker
拉斯维加斯酒店助理
http://www.ezlasvegas.net当使用数组创建下拉菜单生成器的键值列表（其中将包含各个州）时，我发现将 "NULL" 作为索引，""（空值）作为值非常有用。
<?php
$states = array(
0 => 'Select a State',
NULL => '',
1 => 'AL - Alabama',
2 => 'AK - Alaska',
# 等等 ...
);
$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;
?>
这将打印：
<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>
# 等等 ...
</select>
现在，用户可以选择一个空值，如果他们后来决定不在表格中提供他们的地址。在表单提交并处理表单后，使用 php 函数 - EMPTY() 检查前两个选项时，将返回 TRUE。这里有一个简单但巧妙的设置数组、使用循环获取数组值的方法。
<?php
$ary = array("1"=>'One','Two',"3"=>'Three');
$a = '0'; $b = count($ary);
while ($a <= $b) {
$pr = $ary[$a];
print "$pr<br>";
$a++;
}
?>如果需要在一个数组中使用混合类型，并且键值为 0，请小心，因为几种不同的形式最终会变成同一个键
$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 );
这将只输出 3 个值：6、7、8。一些棘手的函数；
<?php
function is_array_assoc($arr) {
if (is_array($arr)) {
foreach ($arr as $k => $v) {
if (is_string($k) || (is_int($k) && $k < 0)) {
return 1;
}
}
return 0;
}
return -1;
}
function is_array_multi($arr) {
return is_array($arr)
? (count($arr) != count($arr, COUNT_RECURSIVE) ? 1 : 0)
: -1;
}
$arr[] = array("foo", "bar", 1.09);
$arr[] = array("red", "yellow", 1 => "foo");
$arr[] = array("red", "yellow", -1 => "foo");
$arr[] = array("x" => array("red", "yellow"), "y" => array("one", "two"));
$arr[] = array();
$arr[] = "s";
foreach ($arr as $a) {
echo is_array_assoc($a) ."\n";
}
echo "\n";
foreach ($arr as $a) {
echo is_array_multi($a) ."\n";
}
?>
0
0
1
1
0
-1
0
0
0
1
0
-1
<?php
function array_count($arr) {
$r = 0;
foreach ($arr as $k => $v) {
if (is_array($v)) {
$r++;
}
}
return $r;
}
function array_count_all($arr, $r = 0) {
foreach ($arr as $k => $v) {
if (is_array($v)) {
$r = array_count_all($v, $r);
$r++;
}
}
return $r;
}
$a = array("foo", "bar", 1.09, array(1,2,3), array("a" => "aaa"));
echo array_count($a); // 2
$a = array(
"foo", "bar", 1.09,
"x" => array(1,2,3),
array("a" => "aaa", "b" => array(), "c" => array(""), "d" => array("")),
"e" => array(""),
"z" => array(""),
"q" => array("", array()),
"w" => array("lorem", 1 => "impsum", 18, "dolor", array("last as 11th array"))
);
echo array_count_all($a); // 11
?><?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")
);
?>这是一个从特定 SQL 表中获取外键变量的有用方法。
此函数可用于包含所有相关表中的所有相关数据
<?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;
}
//示例代码：
$data = get_foreign_keys('task_table');
echo '<pre>';
print_r($data);
echo '</pre>';
?>
// $query[1] 输出
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 输出
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
)
)
)以下代码由 [email protected] 提供
$var_name='var';
$var=array(0,1,2,3,4);
echo $$var_name[2];
// 输出空值，而不是 2。
// 在 PHP 7.01 及更高版本中，输出 2
注意
在 PHP 7.01 及更高版本中，输出 2。其他版本会抛出提示错误。<?
// 这是一个展示如何使用多维数组的小脚本
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";
}
?>看看这个！！！假设你想创建一个像下面这样的数组
<?php
$arr1 = (
0 => array ("customer"=>"Client 1","Item a"),
1 => array ("customer"=>"Client 2","Item b")
);
?>
看起来很简单，但如果你想动态生成它，那就有点麻烦了！！！想象一下，你有一个包含数千行的文件，每行都是来自不同客户的采购订单。
<?php
/*添加元素的函数*/
function addArray(&$array, $id, $var)
{
$tempArray = array( $var => $id);
$array = array_merge ($array, $tempArray);
}
/*与上面相同，但元素是一个数组*/
function addArrayArr(&$array, $var, &$array1)
{
$tempArray = array($var => $array1);
$array = array_merge ($array, $tempArray);
}
/*数组的标签或文件的标题*/
$keyarr = array("customer","item");
/*可能从文件读取的信息，第 1 行和第 2 行*/
$valarr0 = array("Client 1","Item a");
$valarr1 = array("Client 2","Item b");
$numofrows = 2;/*在我们的例子中，只有两行*/
$tmpArray = array();
for($i = 0; $i < $numofrows; $i++){
$tmp = "valarr$i";
$tmpvar = ${$tmp};/*使用变量的变量，很巧妙*/
foreach( $keyarr as $key=>$value){
addArray($tmparr,$tmpvar[$key],$value);
}
addArrayArr($finalarr,$i,$tmparr);
} /*瞧，所有信息都完美地排列在 finalarr 中*/
/*这里我们只是打印信息，但你可以将其插入数据库*/
echo "Customer: ".$finalarr[0]["customer"]."<br>";
echo "Item: ".$finalarr[0]["item"]."<br>";
echo "Customer: ".$finalarr[1]["customer"]."<br>";
echo "Item: ".$finalarr[1]["item"]."<br>";
?>
上面的代码应该输出类似以下内容
Customer: Client 1
Item: Item a
Customer: Client 2
Item: Item b
希望有人觉得这有用。我试图找到一种方法来创建大型多维数组。但下面的注释只展示了它的使用方法，或创建像 $matrix=array('birne', 'apfel', 'beere'); 这样的小型数组。
对于一个在线游戏，我使用了一个大型数组（50x80）个元素。
用普通的方式写它的声明一点也不有趣。
这是我的解决方案，用于创建一个用递增数字填充的二维数组。
<?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++;
}
}
?>
如果有更好的方法，请发邮件给我。我总是想学习更多关于 PHP 的知识！在 PHP 4.2.3（以及可能更早的版本）中，具有数字索引的数组可以初始化为从特定索引开始，然后自动递增索引。这样您就可以省去为非零基数组的每个元素编写索引的麻烦。
代码
<?php
$a = array
(
21 => 1,
2,
3,
);
print '<pre>';
print_r($a);
print '</pre>';
?>
将打印
<?php
Array
(
[21] => 1
[22] => 2
[23] => 3
)
?>如何使用 array() 创建一个引用数组而不是副本数组？（尤其是在处理对象时需要这样做）。我尝试了一些方法并找到了一个解决方案：在 array() 的参数前加上 &，这些参数将作为引用传递。我的 PHP 版本是 4.3.10。
演示
<?php
$ref1 = 'unchanged';
$ref2 = & $ref1;
$array_of_copies = array($ref1, $ref2);
print_r($array_of_copies); // 打印：Array ( [0] => unchanged [1] => unchanged )
$array_of_copies[0] = 'changed'; // $ref1 = 'changed'; 不等效，因为它被 _复制_ 到数组中
print_r($array_of_copies); // 打印：Array ( [0] => changed [1] => unchanged )
$array_of_refs = array(& $ref1, & $ref2); // 区别在于：在参数前加上 &
print_r($array_of_refs); // 打印：Array ( [0] => unchanged [1] => unchanged )
$array_of_refs[0] = 'changed'; // $ref1 = 'changed'; 等效，因为 $array_of_refs[0] 引用了 $ref1
print_r($array_of_refs, true); // 打印：Array ( [0] => changed [1] => changed )
?>这里有一种输出数组内容的“教科书式”方法，它避免了使用 foreach()，并且允许您根据需要索引和遍历数组。
<?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";
}
?>
享受！
-tim考虑
文件 inc1.php
-------------
<?php
return 'key';
file inc2.php
-------------
<?php
return 'value';
Test:
<?php
$a = [
include 'inc1.php' => include 'inc2.php'
];
var_dump($a);
/* 它有效！！！
array(1) {
'key' =>
string(5) "value"
}
*/轻松的函数，用于解构数组 :-)
它将把 $array['something'] => $something。
有助于使代码更清晰。
使用示例
<?
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>'; // 而不是 $row['idpracownika']
}
?>以下是一些关于使用关联数组的实用技巧 -
我试图实现的目标
我想访问一个数据库，并将结果加载到一个关联数组中，因为我只返回了键值对。我将它们加载到数组中，因为我想在数据库选择之后进一步操作数据，但我不想过多地访问数据库。
以下是我使用的方法
<?php
// 假设数据库连接
// 将所有内容加载到关联数组中
$sql = "SELECT key,value FROM table";
$result = mysql_query($sql);
while($row = mysql_fetch_row($result)) {
$myArray[$row[0]] = $row[1];
}
// 现在我们进行扩展
while(list($key,$value) = each($myArray)) {
echo "$key : $value";
}
?>
我发现这非常高效，而且非常酷。以下代码
$var_name='var';
$var=array(0,1,2,3,4);
echo $$var_name[2];
没有打印任何内容，而是打印了 2。类似于 print_r 的递归函数，用于在 html <ol> 中描述嵌套数组。可能对某些人有用。
<?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;
}
// 示例：
$array = array("a", "b", "c", array("1", "2", array("A", "B")), array("3", "4"), "d");
echo describeAnidatedArray($array);
?>
输出
# a
# b
# c
1. 1
2. 2
1. A
2. B
1. 3
2. 4
# d小心不要在已存在的变量之上创建数组
<?php
$name = "John";
$name['last'] = "Doe";
?>
$name 将变为 "Dohn"，因为 'last' 评估为 $name 的第 0 位。
多维数组也是如此。此辅助函数创建一个多维数组。例如，创建一个 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;
}
?>