07-PHP中的数组与数据结构

最新推荐文章于 2024-06-02 23:17:16 发布

暗虫皇

最新推荐文章于 2024-06-02 23:17:16 发布

阅读量479

点赞数

分类专栏： PHP基础知识文章标签： PHP 基础数组数据结构

本文链接：https://blog.csdn.net/qq_34789042/article/details/87177729

版权

PHP基础知识专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

数组

数组

学习目标

数组的作用
数组的声明
数组的遍历
超全局数组
关于数组的函数
数据结构和算法

声明

一个数组存的是多个内容，数组中的内容叫做“元素”
每个元素都是由键和值组成的 key/value key是下标
通过 key 使用 value
- 下标有两种类型：一种是整数(索引数组)，一种是字符串(关联数组)
[] 来操作下标，也可以使用 {} 进行互换，建议使用 [] 来指定下标
数组的自动增长下标，默认是从0开始的，自动增长的都是出现过的最大值加1
关联数组的字符串下标，不会影响索引下标的排列规则
使用array()函数声明数组，默认是索引的下标，是从0开始
使用 => 符号指定下标
php5.4以后，可以像其他语言一样声明数组了$arr=[1,2,3,5]

<?php
$arr[0]=1;
$arr[1]=2;
$arr[2]=3;

$arr1['one']=1;
$arr1['two']=2;
$arr1['three']=3;
print_r($arr);

$arr=array("php","this");

数组的删除

unset(): 允许删除数组中的某个键，但不会重建索引。需要用 array_values() 重新建立索引。

多维维数组

二维数组就是数组的数组

$arr=[1,2,3,4,5];
$arr1=[1,3,5,7];
$arr2=['a','b','c','d'];
$earr=[$arr,$arr1,$arr2];

多维数组就是数组和数组之间的嵌套

数组的遍历

使用for语句循环遍历数组

注意：需要保证一定要是下标连续的索引数组

优点

效率很高，就是数组的访问方式，只不过是通过循环去取值
count(数组) 获取数组的长度，是数组的实际元素的个数

不足

数组下标不一定是连续的
关联数组for不能遍历出值

<?php
$arr = array('aa','bb','cc','dd');
for($i=0;$i<count($arr);$i++){
    echo $arr[$i]+'<br>';
}
?>
//优化
<?php
$arr = array('aa','bb','cc','dd');
//把获取数组长度的方法拿出来
$nums = count($arr);
for($i=0;$i<$nums;$i++){
    echo $arr[$i]+'<br>';
}
?>

使用foreach语句遍历数组

语法： foreach(数组 as 自定义变量)

数组有多少元素，foreach就循环多少次
foreach 会将数组中的元素，在每次循环中，依次将元素的值给自定义的变量，在每次循环中用到这个变量，即用到了当前的数组中的元素

<?php
$arr = array('aa','bb','cc','dd');
foreach($arr as $value){
    echo $value+"<br>";
}
?>

语法：foreach(数组 as 下标变量 => 值变量)

可以取到下标

<?php
$arr = array('one'=>aa','bb','cc','dd');
foreach($arr as $k=>$value){
    echo "{$k} =======> {$value}+"<br>";
}
?>

联合使用list()、each()、和while循环遍历数组

`list()` 函数

list()函数但这个函数和其他函数用法不同

作用：将数组中的元素转为变量使用

等号左边使用list()函数，等号右边只能是一个数组
数组中有几个元素，再list()中就有几个参数，而且参数必须是变量（新声明的自定义变量），不能是值
只能将索引数组（下标是连续），转为变量，是按下标0开始找的
可以在list()参数中，通过空项选择性的接受数组中的元素

例子

<?php
list($a,,$c)=['1','2','3'];
echo $a;
echo $b;
echo $c;

$str = "123_456";
list($name,$pro) = explode('_',$str);
echo $name;
echo $pro;

`each()` 函数

each() 只是一个函数，参数就是一个数组作为参数，返回的值，也是一个数组

作用：

返回的值是一个数组，数组固定有4个元素，而且下标也是固定的 1(值) value(值) 0(下标) key(下标)
each() 只处理当前的元素将当前的元素（默认当前元素是第一个元素，指针指向第一个）转为数组信息，处理完后，指针指向下一个元素移动
如果指针已经在结束位置了，如果再使用each()获取元素，返回false

例子

$arr = ['one' => "1", "s", "h"];

echo 'pre';

$one = each($arr);
print_r($one);

$one = each($arr);
print_r($one);

echo '</pre>';

####　使用组合方式遍历数组

使用 list(),each(),while 遍历数组

通过这种方式遍历的数组只能遍历一次，但可以通过重设指针的方式重新遍历 reset()

例子

<?php
$arr = ['one' => 'key', 'php', 'java', 'four'];
while(list($key,$val) = each($arr){
    echo "{$key}   =>   {$val} <br>";
}

reset($arr);
while(list($key,$val) = each($arr){
    echo "{$key}   =>   {$val} <br>";
}
?>

使用数组内部指针控制函数遍历数组

移动数组指针

next($arr) : 指针移动到下一个
prev($arr) : 指针移动到上一个
end($arr) : 指针移动到最后一个
reset($arr) : 指针移动到第一个
key($arr) : 获取当前指针指向元素的下标
current($arr) : 获取当前指针指向元素的值

超全局数组

超全局数组（变量），在PHP的脚本中，已经声明完的变量，你可以直接去使用即可！变量的名字已经规定好了

$_SERVER : 服务器变量
$_ENU : 环境变量
$_GET : HTTP GET变量
$_POST : HTTP POST变量
$_REQUEST : request变量
$_FILES : HTTP文件上传变量
$_COOKIE : HTTP Cookies
$_SESSION : Session变量
$GLOBALS : Global变量

数组（关联数组），就和你自己声明的数组是一样的操作方式
全局，在任何函数内部都可以直接使用
每个预定义的数组都有自己独特的能力

例子

<?php
//数组
foreach($_SERVER as $k => $v){
    echo "{$k}   =>   {$v}\n";
}

//全局
$arr = ['123','111'];
function demo(){
    global $arr;
    echo $arr[0]."和".$arr[1];
}
demo();

//

`$_SERVER` 服务器变量

<?php

function getIp(){
    if(!empty($_SERVER['HTTP_CLIENT_IP']){
        return $_SERVER['HTTP_CLIENT_IP'];
    }else if(!empty($_SERVER['HTTP_X_FORWARDED_FOR']){
        return $_SERVER['HTTP_X_FORWARDED_FOR'];
    }else if(!empty($_SERVER['REMDTE_ADDR']){
        return $_SERVER['HTTP_X_FORWARDED_FOR'];
    }else{
        return "未知IP";
    }
}

数组的相关处理函数

数组的键/值操作函数
统计数组元素的个数与唯一性
使用回调函数处理数组的函数
数组的排序函数
拆分、合并、分解与结合数组
数组与数据结构
其他有用的数组处理函数

数组的键值操作函数

array_values 返回数组中所有的值

//格式
//array array_values(array input)

$a = array('name' => '张三', 'age' => 20, 'sex' => '男');
$values = array_values($a);
var_dump($values);
//返回：array(3){[0]=>string(4)"张三"  [1]=>int(20)  [2]=>string(2)"男"}

array_keys 返回数组中所有的键名

//格式
//array array_keys(array input[,mixed search_value [,bool strict]])
//如果 search_value 有值，则只返回该值得键名，
//strict 为是否强制匹配 search_value 类型，默认值为 false

$a = array("name"=>"张三","age"=>20,"sex"=>"男");
$keys = array_keys($a);
//返回：array(3) { [0]=> string(4) "name" [1]=> string(3) "age" [2]=> string(3) "sex" }

in_array 检查数组中是否存在某个值，存在返回true

//格式
//bool in_array(mixed value, array 目标数组, bool strict)
//strict 为是否强制匹配 search_value 类型，默认值为 false

$a = array("name"=>"张三","age"=>20,"sex"=>"男",array('a','b'));
if(in_array("张三",$a)){
    echo " ‘张三’在\$a数组中";   //”张三“在$a数组中
}
if(in_array(array('a','b'),$a){
    echo "数组存在";
}
//返回：‘张三’在$a数组中

array_search 在数组中搜索指定的值，如果成功则返回相应的键名

注意：
如果搜索的值在数组中出现不值一次，则返回第一个匹配的值

用法和 in_array 一样，只不过返回的是键名

array_key_exists 检查给定的键名或索引是否存在于数组中

格式

bool array_key_exists(mixed $key, array $search)

例子

$a = array("name"=>"张三","age"=>20,"sex"=>"男",array('a','b'));
if(array_key_exists("name",$a)){
    echo " 存在";   
}else{
    echo "不存在";
}

对比: isset()

//当数组中键名对应的值为NULL时 isset() 不会返回ture, 而 array_key_exists() 会
$search_array = array('first' => null, 'second' => 5);

//return false
isset($search_array['first']);

//return true
array_key_exists('first',$search_array);

array_flip 交换数组中的键和值

注意

数组下标是不能重复的，但值是可以重复的，在交换以后重复的值对应的键名，后面的会覆盖前面的
这个函数只能处理值是字符串和整形的数组

格式

array array_flip(array trans)

例子

$a = array("name"=>"张三","age"=>20,"sex"=>"男");  
$b = array_flip($a);
foreach($b as $k=>$v){
    echo "$k=>$v   ";  // 张三=>name 20=>age 男=>sex 
}

array_reverse 返回一个元素顺序相反的数组

格式

array array_reverse(array array,[,bool preserve_keys])

例子

//如果 preserver_keys 为 true 则保留原来的键名 默认为 true

$a = array("name"=>"张三","age"=>20,"sex"=>"男");  
$b = array_reverse($a);
foreach($b as $k=>$v){
   echo “$k=>$v   ”;  // sex=>男 age=>20 name=>张三 
}

统计数组元素的个数与唯一性的函数

count 统计数组中的单元数目或对象中的属性个数

注意

单元数目通常是 array ,任何其他类型的都只有一个单元，

格式

int count(mixed $var [,int $mode]);

例子

$a = array(
    array("name"=>"张三","age"=>20,"sex"=>"男"),
    array("name"=>"李四","age"=>20,"sex"=>"男"),
);

//统计元素个数
echo count($a);

//递归统计数组个数 8个 本身两个+6个递归出来的
echo count($a,1);

array_count_values 统计数组中所有的值出现的次数

格式

array array_count_values(array $input);

例子

$a = array("张三",20,20,20,"男","男","男");  
print_r(array_count_values($a));

array_unique 移除数组中重复的值

格式

array array_unique(array $array);

例子

$a = array("张三",20,20,20,"男","男","男");  
print_r(array_unique($a));

使用回调函数处理数组的函数

array_filter() 使用回调函数过滤数组中的单元

格式

array array_filter(array $input, [, callback $callback]);

例子

$arr = array(1,2,3,4,5,false,5,7,9,0,-1,-2,-3,null);

//过滤判定为 false 的值
var_dump(array_filter($arr));

//过滤负数
var_dump(array_filter($arr,"myFun");
function myFun($value){
    if($value >= 0){
        return true;
    }else{
        return false;
    }
}

//过滤2的倍数
var_dump(array_filter($arr,function($value){
    return !($value%2==0);
}));

array_walk 对数组中所有的元素应用函数

格式

bool array_walk(&$arr,callback $callback [, mixed $userdata]);

$calback可以有三个参数，第一个参数为数组的值，第二个参数为数组的键，第三个参数是 array_walk 函数的点三个参数

例子

$arr = array(1,2,3,4,5);
$arr1 = array("name"=>"张三","age"=>20,"sex"=>"男");
//处理数组的值
array_walk($arr,"myFun");
function myFun(&$value){
    $value = $value*$value;
}

//处理数组下标
array_walk($arr1,function(&$value, $key){
    $value = $key.$value;
});

//函数的第三个参数
array_walk($arr1,function(&$value, $key, $str){
    $value = $value.$key.$str;
},'123');

array_map 将回调函数作用到给定数组的单元上

格式

array array_map(callback $callback, array arr1 [,array ....]);

$callback 的参数是后面数组的元素，后面有多少个数组，它就有多少个参数

例子

$arr = [1,2,3,4,5];
$arr1 = ['a','b','c','d'];
$arr2 = ['one','two','three'];

function myFun($v,$v1,$v2){
    echo "$v ---- $v1 ---- $v2";
}
array_map("myFun",$arr,$arr1,$arr2);

//把数组合并为二维数组
array_map(null,$arr,$arr1,$arr2);

//输出
array(
    [1,'a','one'],
    [2,'b','two'],
    [3,'c','three'],
    [4,'d',null],
    [5,null,null]
);

数组的排序算法

冒泡排序

重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

<?php
	$arr = [0,1,2,3,4,5,6,7,8,9];
	$len = count($arr);
	//$len-1 最后一个元素不用排序
	for($i=0;$i<$len-1;$i++){
		//已经排好的数字不用再次排序了
		for($j=0;$j<$len-$i-1;$j++){
			if($arr[$j]<$arr[$j+1]){
				$temp = $arr[$j];
				$arr[$j] = $arr[$j+1];
				$arr[$j+1] = $temp;
			}
			echo "$arr[$j] ";
		}
		print_r($arr);
		echo "<br>";
	}

二分法排序

<?php
	$arr = [0,1,10,3,4,5,6,7,8,9];
	function qsort($arr){
		if(!is_array($arr) || empty($arr)){
			return array();
		}
		$len = count($arr);
		if($len <= 1){
			return $arr;
		}
		$key[0] = $arr[0];
		$left = array();
		$right = array();
		for($i=1;$i<$len;$i++){
			if($arr[$i] > $key[0]){
				$right[] = $arr[$i];
			}else{
				$left[] = $arr[$i];
			}
		}
		$left = qsort($left);
		$right = qsort($right);
		//右序遍历，从大到小
		return array_merge($right,$key,$left);
	}
	print_r(qsort($arr));

数组的排序函数

sort – 对数组排序（升序）
rsort – 对数组逆向排序（降序）
ksort – 对数组按照键名排序
krsort – 对数组按照键名逆向排序
asort – 对数组排序并保持索引关系（关联数组排序）
arsort – 对数组进行逆向排序并保持索引关系
natsort – 用“自然排序”算法对数组排序
natcasesort – 用“自然排序”算法对数组进行不区分大小写字母的排序
usort – 使用用户自定义的比较函数对数组中的值进行排序
uasort – 使用用户自定义的比较函数对数组中的值进行排序并保持索引关系
uksort – 使用用户自定义的比较函数对数组中的键名进行排序
array_multisort – 对多个数组或多维数组进行排序

`array_multisort` 可以用来一次对多个数组进行排序，或者根据某一维或多维对多维数组进行排序。

通过对之前的数组进行排序，进而影响之后的数组

通过对第一数组排序影响之后的数组
第一个数组中有相同的数据的话，通过第二个数组的内容进行排序

格式

array_multisort ( array &$array1 [, mixed $array1_sort_order = SORT_ASC [, mixed $array1_sort_flags = SORT_REGULAR [, mixed $... ]]] ) : bool

array1 : 要排序的array
array1_sort_order : 之前array参数要排序的顺序。
    SORT_ASC : 按照升序排序（默认）
    SORT_DESC : 按照降序排序
array1_sort_flags :　排序类型标识
    SORT_REGULAR-将项目按照通常方法比较(不修改类型)(默认)
    SORT_NUMERIC-按照数字大小比较
    SORT_STRING-按照字符串比较
    SORT_LOCALE_STRING-根据本地化设置按照字符串比较
    SORT_NATURAL-以字符串“自然排序”
    SORT_FLAG_CASE-可以组合 (按位或 OR) SORT_STRING 或者 SORT_NATURAL 大小写不敏感的方式排序字符串
... 更多组，像上面那样组合的参数

一维数组排序

<?php
	$arr1 = [1,3,5,7,10,2,4];
	$arr2 = ['a','b','z','d','y','A','i'];
	
	array_multisort($arr1,SORT_DESC,$arr2);
	
	print_r($arr1);
	print_r($arr2);
?>

二位数组排序
把二维数组中的一列数据提取出来，这样就可以让函数在排序那一列数据的时候来把二维数组排序

<?php
	$arr = [
		['sex'=>0,'name'=>'asdlf','age'=>20],
		['sex'=>1,'name'=>'a阿斯顿','age'=>60],
		['sex'=>1,'name'=>'对策','age'=>30],
		['sex'=>1,'name'=>'速度','age'=>80],
		['sex'=>0,'name'=>'等风','age'=>90]
	];
	$arr1 = [];
	foreach($arr as $v){
		$arr1[] = $v['age'];
	}
	array_multisort($arr1,SORT_DESC,$arr);
	
	print_r($arr1);
	print_r($arr);

拆分、合并、分解与结合数组函数

`array_slice` 从数组中取出一段

格式

array array_slice(array $arr,int $offset [,int $length [,bool $preserve_keys]]);

返回根据 $offset 和 $length 参数所指定的 array 数组中的一段序列

offset :如果 offset 非负，则序列将从 array 中的此偏移量开始(偏移量从0开始)，如果offset 为负，则序列将从 array 中距离末端这么远的地方开始

length :如果给出了 length 且为正 则序列中将具有这么多的单元 如果给出了 length 且为负 则序列将终止在距离数组末端这么远的地方 如果省略 则序列将从 offset 开始一直到 array 的末端

preserver_keys :false 重置数组的键，true 不重置数组的键，默认为false，只重置 int 类型的键值

例子

<?php
	$a = ['a','b','a'=>'c','d','b'];
	
	$arr = array_slice($a,1);
	var_dump($arr);
	echo '<br/>';
	
	$arr = array_slice($a,1,-1,true);
	var_dump($arr);
	echo '<br/>';

	$arr = array_slice($a,1,-1,true);
	var_dump($arr);
	echo '<br/>';
	
输出：
array(4) { [0]=> string(1) "b" ["a"]=> string(1) "c" [1]=> string(1) "d" [2]=> string(1) "b" } 
array(3) { [1]=> string(1) "b" ["a"]=> string(1) "c" [2]=> string(1) "d" } 
array(3) { [1]=> string(1) "b" ["a"]=> string(1) "c" [2]=> string(1) "d" }

`array_splice()` 把数组的一部分去掉并用其它值取代

语法

array array_splice(array &$arr, int $offset [,int $length [array $replacement]]);

用法和 array_slice() 一样

把 arr 数组中由 offset 和 length 指定的单元去掉，如果提供了 replacement 参数 则用它数组中的单元取代， 返回一个包含有被移除单元的数组，注意，input 中的数字键名不被保留

例子

<?php
	$a = ['a','b','a'=>'c','d','b'];
	$b = ['asdf','sdfsd','edev','asdfsdf'];
	$arr = array_splice($a,1,2,$b);
	var_dump($arr);
	echo '<br/>';
	var_dump($a);
	
输出：
array(2) { [0]=> string(1) "b" ["a"]=> string(1) "c" } 
array(7) { [0]=> string(1) "a" [1]=> string(4) "asdf" [2]=> string(5) "sdfsd" [3]=> string(4) "edev" [4]=> string(7) "asdfsdf" [5]=> string(1) "d" [6]=> string(1) "b" }

`array_combine` 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值

语法

array array_combine(array keys, array values);

注意：如果两个数组的单元数不同或者数组为空时返回 false

例子

<?php
	$a = ['a','b','c','d','b'];
	$b = ['asdf','sdfsd','edev','asdfsdf','asdf'];
	$c = ['asdf','sdfsd','edev','asdfsdf'];
	$arr = array_combine($a,$b);
	var_dump($arr);
	echo '<br/>';
	$arr = array_combine($a,$c);
	var_dump($arr);
	
输出：
array(4) { ["a"]=> string(4) "asdf" ["b"]=> string(4) "asdf" ["c"]=> string(4) "edev" ["d"]=> string(7) "asdfsdf" } 

Warning: array_combine(): Both parameters should have an equal number of elements in F:\www\Test\error\index.php on line 8
bool(false)

`+` 合并数组

注意： 下标相同会覆盖，是前面的覆盖后面的

例子

<?php
	$a = ['a','b','c','d'];
	$b = ['asdf','sdfsd','edev','asdfsdf','asdf'];
	$c = ['asdf','sdfsd','edev','asdfsdf'];
	
	$d = $a+$b+$c;
	var_dump($d);
	
输出：
array(5) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" [4]=> string(4) "asdf" }

`array_merge()` 合并一个或多个数组

语法

array array_merge(array $array1 [,array $array2 ...])

将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面，返回作为结果的数组

如果数组中有相同的字符串键名，则后面的值覆盖前面的值，如果包含数字键名，后面的值会附加到后面

如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引

合并数组并重新索引

<?php
	$a = ['a','b',6=>'c','d'];
	$b = ['asdf','sdfsd',8=>'edev','asdfsdf','asdf'];
	$c = ['asdf','sdfsd','edev','asdfsdf'];
	
	
	$d = array_merge($a,$b);
	var_dump(array_merge($a));
	echo('<br/>');
	var_dump($d);
	
输出：
array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" } 
array(9) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" [4]=> string(4) "asdf" [5]=> string(5) "sdfsd" [6]=> string(4) "edev" [7]=> string(7) "asdfsdf" [8]=> string(4) "asdf" }

`array_intersect()` 计算数组的交集

语法

array array_intersect(array $array1 [,array $array2 ...])

返回一个数组，该数组包含了所有在数组 array1 中出现，也同时在其他参数数组中出现的值

注意：键名保持不变

例子

<?php
	$a = ['a','b',6=>'c','d'];
	$c = ['b','sdfsd','d','asdfsdf'];
	
	
	$d = array_intersect($a,$c);
	var_dump($d);
	
输出：
array(2) { [1]=> string(1) "b" [7]=> string(1) "d" }

`array_diff()` 计算数组的差集

语法

array array_diff(array $array1 [,array $array2 ...])

返回一个数组，该数组包含了所有在数组 array1 中，但不在任何其他参数数组中的值

注意：键名保持不变

例子

<?php
	$a = ['a','b',6=>'c','d'];
	$b = ['asdf','sdfsd',8=>'edev','asdfsdf','asdf'];
	$c = ['b','sdfsd','d','asdfsdf'];
	
	
	$d = array_diff($a,$c);
	var_dump($d);

输出：
array(2) { [0]=> string(1) "a" [6]=> string(1) "c" }

数组与数据结构

模拟桟

<?php
	//栈结构模拟
	$zhan = array();
	
	//压入栈
	array_push($zhan,'1');
	array_push($zhan,'2');
	array_push($zhan,'3');
	array_push($zhan,'4');
	array_push($zhan,'5');
	array_push($zhan,'a','b','c','d');
	
	//弹出桟
	echo array_pop($zhan).'<br/>';
	echo array_pop($zhan).'<br/>';
	echo array_pop($zhan).'<br/>';
	echo array_pop($zhan).'<br/>';
	echo array_pop($zhan).'<br/>';
	echo array_pop($zhan).'<br/>';
	print_r($zhan);
	
输出：
d
c
b
a
5
4
Array ( [0] => 1 [1] => 2 [2] => 3 )

另一种方法

<?php
	//桟结构模拟
	$dl = array();
	
	array_unshift($dl,'1');
	array_unshift($dl,'2');
	array_unshift($dl,'3');
	array_unshift($dl,'4');
	array_unshift($dl,'5');
	array_unshift($dl,'a');
	print_r($dl);
	echo "<br/>";
	
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';

输出：
Array ( [0] => a [1] => 5 [2] => 4 [3] => 3 [4] => 2 [5] => 1 ) 
a
5
4
3

模拟队列

<?php
	//队列结构模拟
	$dl = array();
	
	array_unshift($dl,'1');
	array_unshift($dl,'2');
	array_unshift($dl,'3');
	array_unshift($dl,'4');
	array_unshift($dl,'5');
	array_unshift($dl,'a');
	print_r($dl);
	echo "<br/>";
	
	echo array_pop($dl).'<br/>';
	echo array_pop($dl).'<br/>';
	echo array_pop($dl).'<br/>';
	echo array_pop($dl).'<br/>';

输出：
Array ( [0] => a [1] => 5 [2] => 4 [3] => 3 [4] => 2 [5] => 1 ) 
1
2
3
4

另一种方法

<?php
	//队列结构模拟
	$dl = array();
	
	array_push($dl,'1');
	array_push($dl,'2');
	array_push($dl,'3');
	array_push($dl,'4');
	array_push($dl,'5');
	array_push($dl,'a');
	print_r($dl);
	echo "<br/>";
	
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';
	echo array_shift($dl).'<br/>';

输出：
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => a ) 
1
2
3
4

其他的函数

`array_rand()` 从数组中随机取出一个或多个单元

语法

array_rand(array $input [,int $num_req]);

随机返回一个或多个数组单元， num_req 指明了想取出多少个单元，如果没有指定，默认为1

如果只取出一个，返回一个随机单元的键名，否则返回包含随机键名的数组

例子

<?php
	$a = ['a','b',3,'c',5,6];
	
	$b = array_rand($a,1);
	var_dump($b);
	$b = array_rand($a,3);
	
输出：
int(1) 
array(3) { [0]=> int(2) [1]=> int(3) [2]=> int(4) }

`shuffle()` 将数组打乱

语法

bool shuffle(array &$array)

此函数将打乱数组顺序，并删除键名，重新赋值

例子

<?php
	$a = ['a','a'=>'b',3,'c',5,6];
	
	$b = shuffle($a);
	var_dump($a);
	
输出：
array(6) { [0]=> string(1) "b" [1]=> int(6) [2]=> int(5) [3]=> string(1) "c" [4]=> string(1) "a" [5]=> int(3) }

`array_sum` 计算数组中所有值的和

语法

number array_sum(array $array)

将数组中所有值的和以整数或浮点数的结构返回

例子

<?php
	$a = ['a','a'=>'b',3,'c',5,6];
	
	$b = array_sum($a);
	var_dump($b);
	
输出：
int(14)

`range()` 建立一个包含知道范围单元的数组

语法

array range(mixed $low,mixed $high [,number $step])

返回数组中从 low 到 high 的单元，包括他们本身，如果 low > high，序列将从 high 到 low

如果给出了 step 的值，它将被作为单元之间的步进值，默认为1

例子

<?php
	$a = range(1,10);
	var_dump($a);
	echo "<br/>";
	$b = range(1,10,2);
	var_dump($b);

输出：
array(10) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9) [9]=> int(10) } 
array(5) { [0]=> int(1) [1]=> int(3) [2]=> int(5) [3]=> int(7) [4]=> int(9) }

`array_fill()` 用给定的值填充数组

语法

array array_fill(int $start_index, int $num, mixed $value)

用value的值将一个数组填充 num 个条目，键名有 start_index 参数指定的开始。

例子

<?php
	$a = array_fill(5,10,'a');
	var_dump($a);

输出：
array(10) { [5]=> string(1) "a" [6]=> string(1) "a" [7]=> string(1) "a" [8]=> string(1) "a" [9]=> string(1) "a" [10]=> string(1) "a" [11]=> string(1) "a" [12]=> string(1) "a" [13]=> string(1) "a" [14]=> string(1) "a" }

暗虫皇

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
07-PHP中的数组与数据结构

文章目录数组学习目标声明数组的删除多维维数组数组的遍历使用for语句循环遍历数组使用foreach语句遍历数组联合使用list()、each()、和while循环遍历数组`list()` 函数`each()` 函数使用数组内部指针控制函数遍历数组超全局数组`$_SERVER` 服务器变量数组的相关处理函数数组的键值操作函数统计数组元素的个数与唯一性的函数使用回调函数处理数组的函数数组的排序算法数组...
复制链接

扫一扫