php数组相关操作

php中有很多内置的处理数组的函数,在这里举例出常用的数组函数集合,主要还是要多拿出来敲敲代码,经常用的话等到以后用到的时候不用想就知道该用哪个了

<?php

/**
 * php数组相关操作
 * array_values() 返回数组元素中所有元素的值
 * array_keys() 返回数组元素中所有元素的键
 * in_array() 检查数组中是否存在某个值,即在数组中搜索给定的值
 */
$arr = ['ID'=>1,'姓名'=>'Hello','公司'=>'A公司'];
print_r(array_values($arr)); //返回$arr数组元素中所有的值
echo "<br/>";
print_r(array_keys($arr));//返回$arr数组元素中所有的元素
echo "<br/>";
print_r($arr);//原数组$arr内容不变
echo "<br/>";
//in_array();
//bool in_array(mixed $needle,array $haystack[,bool $strict = FALSE])
//第一个参数needle是规定要在数组中搜索的值,第二个参数haystack是规定要被搜索的数组.如果给定的值needle存在于数组haystack中,则返回位TRUE,如果第三个参数设置为TRUE,函数只有在元素存在于数组中且数据类型与给定值相同时才会返回TRUE;如果没有在数组中找到参数,函数返回FALSE

//in_array()函数的简单实用形式
$os = array('Mac','NT','Irix','Linux');
if(in_array('Irix',$os)){
    echo "Gos Irix\n";
}
if(in_array('mac',$os)){
    echo "Got mac\n";
}
//in_array()严格类型检查例子
$a = array('1.10',12.4,1.13);

//第三个参数为True,所以字符串'12.4'和浮点数12.4类型不同
if(in_array('12.4',$a,true)){
    echo "string 12.4\n";
}
if(in_array(1.13,$a,true)){
    echo "int 1.13\n";
}
//in_array()中还可以用数组当做第一个参数作为查询条件
$b = array(array('1','2'),array('3','4'));
if(in_array(array('1','2'),$b)){
    echo "'1,2' 存在\n";
}

if(in_array(array('5','6'),$b)){
    echo "5,6存在";
}
// 也可以实用array_search()进行检索
// 该函数与in_array()的参数相同,搜索给定的值,存在则返回相应的键名
$lamp = ['Linux','Apache','Mysql','Php'];
echo array_search('Linux',$lamp); //返回1

$c = ['a'=>'8','b'=>8,'c'=>'8'];

echo array_search(8,$c,true);//启用严格模式,输出b


//此外array_key_exists()函数还可以检查给定的键名或索引是否存在于数组中.也可以实用isset()函数完成对数组的键名或索引进行检查,但是isset()对于数组中为NULL的值不会返回true,e而array_keys_exists()会

$search_array = ['first'=>1,'second'=>4];//声明一个关联数组,其中包括两个元素
if(array_key_exists('first',$search_array)){
    echo "<br/>键名为'first'的元素在数组中";
}

$search_array_two = ['first'=>null,'second'=>4];//声明一个关联数组,第一个元素的值为null
$x =  isset($search_array_two['first']);
print_r($x);
$y = array_key_exists('first',$search_array_two);
print_r($y);

//函数array_flip()
//array_flip()函数的作用是交换数组中的键和值,返回一个反转后的数组.如果同一个值出现了多次,则最后一个键名将作为它的值,覆盖前面出现的元素.如果原数组中的值的数据类型不是字符串或整数,函数将报错,该函数只有一个参数

$arr_x = ['1'=>2,'2'=>3,'3'=>6];
$z = array_flip($arr_x);
var_dump($z);

//函数array_reverse()
//该函数的作用是将原数组中的元素顺序翻转,创建新的数组并返回.该数组有两个参数,其原型如下
//array array_reverse(array array [, bool preserver_keys]);
//第一个参数是必选项,接受一个数组作为输入,第二个是可选项,如果指定为true,则元素的键名保持不变,否则键名将丢失.

var_dump(array_reverse($lamp));

/**
 * 统计数组元素的个数和唯一性
 * 1.函数count()
 * 2.函数array_count_values
 * 3.函数array_unique()
 */

//函数count
//int count(mixed var [,int mode])
//第一个参数是必选的,传入要计数的数组或对象
//第二个参数是可选的,规定函数的模式是否地推地计算多维数组中的数组的元素个数.0为默认值,不检测多维数组,1则检测多维数组.
//
echo count($lamp)."<br/>";

//声明一个二维数组,统计数组中的元素个数
$web = ['lamp'=>['Linux','Apache','Mysql','Php'],'j2ee'=>['Unix','Tomcat','Jsp']];

echo count($web,1)."<br/>";
echo count($web)."<br/>";

//函数array_count_values()
//array_count_values()函数用于统计数组中所有值出现的次数.该函数只有一个值
//array array_count_values(array input)
//参数规定输入一个数组,返回一个数组,其元素的键名是原数组的值,键值是该值在原数组中出现的次数.

$arr_three = ['php','hhh','php'];
$new_array = array_count_values($arr_three);
var_dump($new_array);


//函数array_unique()
//array_unique()函数用于删除数组中重复的值,并返回没有重复值的新数组.
//array array_unique()
//参数需要接收一个数组,当数组中几个元素的值相等时,只保留第一个元素,其他的元素都被删除,并且返回的新数组中键名不变.array_unique()函数先将值作为字符串排序,然后对每个值只保留第一个遇到的键名,接着忽略所欲偶后后面的键名.这并不意味着在 未排序的array中的同一个值的第一个出现的键名会被保留.

$arr_four = ['a'=>'php','b'=>'mysql','c'=>'php'];
$new_array_four = array_unique($arr_four);
var_dump($new_array_four);

/**
 * 使用回调函数处理数组的函数
 * 1.函数array_filter() 该函数用回调函数过滤数组中的元素,返回按用户自定义函数过滤后的新数组
 * 2.函数array_walk() 该函数对数组中的每个元素应用回调函数处理.如果成功则返回true,否则返回false
 * 3.函数array_map() 该函数相比array_walk()函数更加灵活,并且可以处理多个数组.
 */

//array array_filter(array input [,callback callback])

/**
 * 自定义函数myFun,为数组过滤设置条件
 * @param  int $var 数组中的一个元素值
 * @return bool      如果参数能被2整除则返回真
 */
function myFun($var){
    if($var%2==0){
        return true;
    }
}

//声明值为整数序列的数组

$arr_five = ['a'=>1,'b'=>2,'c'=>3,'d'=>4,'f'=>5];
//使用函数array_filter()将自定义函数名以字符串形式传给第二个参数
var_dump(array_filter($arr_five,"myFun"));

//array_walk()
//bool array_wakk(array &array,callback funcaname [, mixed userdata])
//该函数的第一个参数是必选项,要求输入一个被指定的回调函数处理的数组.第二个参数也是必选项,传入用户定义的回调函数,用于操作传入第一个参数的数组.array_walk()函数依次将第一个参数的数组中的每个值传递到这个自定义的函数中.自定义的这个回调函数中应该接收两个参数,依次传入进来元素的值作为第一个参数,键名作为第二个参数.在array_walk()函数中提供可选的第三个参数,也将被作为回调函数的第三个参数接收.
//如果自定义的回调函数需要的参数比给出的多,则每次array_walk()调用回调函数时都会产生一个E_WARNING级的错误.这些警告可以通过在array_walk()函数条用前加上php的语法错误操作符"@"来抑制,或者使用error_reporting()函数.
//如果回调函数需要直接作用于数组中的值,可以将回调函数的第一个参数指定为引用:&$value.

/**
 * 定义一个可以作为回调的函数,名为myFun1
 * @param string $value 一个字符串参数,接收数组的值
 * @param string $key 一个字符串参数,接收数组的键
 */

function myFun1($value,$key){
    echo "The key $key has the value $value <br>";
}

// 定义一个数组$arr_six
$arr_six = ['a'=>'Linux','b'=>'Apache','c'=>'Mysql','d'=>'Php'];
//使用array_walk()函数传入一个数组和一个回调函数
array_walk($arr_six,"myFun1");

// 执行后输入以下结果
/**
 * The key a has the value Linux
 * The key b has the value Apache 
 * The key c has the value Mysql 
 * The key d has the value Php 
 */

/**
 * 定义一个可以作为回调的函数,名称为myFun2
 * @param string $value 一个字符串参数,接收数组的值
 * @param string $key 一个字符串参数,接收数组的键
 * @param string $p 一个字符串参数,接收一个自定义的连接符号字符串
 */

function myFun2($value,$key,$p){
    echo "$key $p $value<br>";
}

//使用array_walk()函数传入三个参数
array_walk($arr_six,"myFun2","has the value");
/**
 * 执行后输出以下结果
 * a has the value Linux
 * b has the value Apache
 * c has the value Mysql
 * d has the value Php
 */

/**
 * 定义一个可以作为回调的函数,名称为myFun3,改变数组元素的值
 * @param string $value 一个引用参数,接收数组变量,请注意&$value传入引用
 * @param string $key 一个字符串参数,接收数组的键
 */

function myFun3(&$value,$key){
    $value = "web";
}

//使用array_walk函数传入两个参数,其中第一个参数为引用
array_walk($arr_six,"myFun3");
var_dump($arr_six);
/**
 * 执行后结果
 * 'a' => string 'web' (length=3)
 * 'b' => string 'web' (length=3)
 * 'c' => string 'web' (length=3)
 * 'd' => string 'web' (length=3)
 */

//array_map()将回调函数作用于给定数组的元素上,返回用户自定义函数作用后的数组.array_map()时任意参数列表函数,回调函数接收的参数数目应该和传递给array_map()函数的数组数目一致
//array array_map(callback callback,array arr1 [,array ..])
//该数组第一个参数是必选项,是用户自定义的回调函数的名称,或者是null.第二个参数也是必选项,输入要处理的数组.也可以接着输入多个数组作为可选参数.

/**
 * 自定义一个函数作为回调的函数,函数名称为myFun4
 * @param string $v 接收数组中每个元素作为参数
 * @return string 返回一个字符串类型的值
 */

function myFun4($v){
    if($v ==="Mysql"){ //如果数组中元素的值恒等于Mysql条件成功
        return "Oracle"; //返回Oracle
    }
    return $v; //不等于Mysql的元素都返回传入的值,即原型返回
}

//声明一个有4个元素的数组$lamp
//之前已经有过声明,直接拿过来用

var_dump(array_map("myFun4",$lamp));
/**
 * 上面的程序执行后输入结果为
 * 0 => string 'Linux' (length=5)
 * 1 => string 'Apache' (length=6)
 * 2 => string 'Oracle' (length=6)
 * 3 => string 'Php' (length=3)
 */

/**
 * 声明一个函数使用多个参数,回调函数接收的参数数目应该和传递给array_map()函数的数组数目一致自定义一个函数需要连个参数,两个数组中的元素依次传入
 * @param mixed $v1 数组中前一个元素的值
 * @param mixed $v2 数组中下一个元素的值
 * @return string 提示字符串
 */

function myFun5($v1,$v2){
    if($v1===$v2){ //如果两个数组中的元素值相同则条件成功
        return 'same'; //返回same,说明两个数组中对应的元素值相同
    }
    return 'different'; //如果两个数组中的对应的元素值不同,返回different
}


$arr_serven = ['Linux','PHP','Mysql'];
$arr_eight = ['Oracle','PHP','Unix'];

var_dump(array_map("myFun5",$arr_serven,$arr_eight));

/**
 * 执行后输出以下结果
 * 0 => string 'different' (length=9)
 * 1 => string 'same' (length=4)
 * 2 => string 'different' (length=9)
 */

//当自定义函数名设置为null时的情况
var_dump(array_map(null,$arr_serven,$arr_eight));
/**
 * 执行后输出以下结果
 * array (size=3)
  0 => 
    array (size=2)
      0 => string 'Linux' (length=5)
      1 => string 'Oracle' (length=6)
  1 => 
    array (size=2)
      0 => string 'PHP' (length=3)
      1 => string 'PHP' (length=3)
  2 => 
    array (size=2)
      0 => string 'Mysql' (length=5)
      1 => string 'Unix' (length=4)
 */

/**
 * 数组的排序哈数
 * sort() 按由小到大的升序对给定数组的值排序
 * rsort() 对数组的元素按照键值进行由大到小的你想排序
 * usort() 使用用户自定义的毁掉函数对数组排序
 * asort() 对数组进行由小到大的排序并保持索引关系
 * arsort() 对数组进行由大到小的你想排序并保持索引关系
 * uasort() 使用用户自定义的比较回调函数对数组中的值进行排序并保持索引关系
 * ksort() 按照键名对数组进行由小到大的排序,为数组值保留原来的键
 * krsort() 将数组按照由大到小的键逆向排序,为数组值保留原来的键
 * uksort() 使用用户自定义的标记哦啊回调函数对数组的键名进行排序
 * natsort() 用自然顺序算法对给定数组中的元素排序
 * natcasesort() 用不区分大小写的自然书序算法对给定数组中的元素排序
 * array_multisort() 对多个数组或多维数组进行排序
 */


//简单的数组排序函数
//简单的数组排序,是指对一个数组元素的值进行排序,php的sort()和rsort()函数实现了这个功能.这两个函数既可以按数组大小排列也可以按字母顺序排列,并觉有相同的参数列表.
//bool sort(array &array [,int sort_flags])
//bool rsort(array &array [,int sort_flags])
//第一个参数是必须的,指定需要排序的数组.第二个参数是可选的,给出了排序的方式.可以用以下值改变排序的行为
//SORT_REGULAR:默认值,将自动识别数组元素的类型进行排序
//SORT_NUMERIC:用于数字元素的排序
//SORT_STRING:用于字符串元素的排序
//SORT_LOCALE_STRING:根据当期那的locale设置来吧元素当做字符串进行比较

//sort()函数对数组中的元素值按照由小到大的书序进行排序,rsort()函数则按照由大到小的顺序对元素的值进行排序

$arr_nine = [5,8,10,9,1];
sort($arr_nine); //由小到大排序
print_r($arr_nine);
/*
输出结果如下
Array ( [0] => 1 [1] => 5 [2] => 8 [3] => 9 [4] => 10 )
 */

rsort($arr_nine); //由大到小排序
print_r($arr_nine);

/*
输出结果如下
Array ( [0] => 10 [1] => 9 [2] => 8 [3] => 5 [4] => 1 )
 */

//根据键名对数组排序
//当我们使用数组时,经常会根据键名对数组重新排序,ksort()和krsort()函数实现了这个功能.ksort()函数按照键名对数组进行由小到大的排序,krsort()函数与ksort()函数想法,排序后为数组值保留原来的键,使用格式与sort\rsort相同.

$arr_ten = [5=>'five',6=>'six',2=>'tow'];
ksort($arr_ten);
echo "<br>";
print_r($arr_ten);

/*
    执行结果如下
    Array ( [2] => tow [5] => five [6] => six ) 
 */
krsort($arr_ten);
echo "<br>";
print_r($arr_ten);

/*
    执行结果如下
    Array ( [6] => six [5] => five [2] => tow )
 */

//根据元素的值对数组进行排序
// asort()和arsort()函数对数组排序时候将保留原有键名和值的关系
// 重写lamp数组
$lamp = ['l'=>'Linux','a'=>'Apache','m'=>'Mysql','p'=>'Php'];
asort($lamp);
echo "<br>";
print_r($lamp);

/*
    执行结果如下
    Array ( [a] => Apache [l] => Linux [m] => Mysql [p] => Php ) 
 */
arsort($lamp);
echo "<br>";
print_r($lamp);

/*
    执行结果如下
    Array ( [p] => Php [m] => Mysql [l] => Linux [a] => Apache )
 */

//根据"自然排序"法对数组排序

$arr_eleven = ["file1.txt","file11.txt","File2.txt","File22.txt","file.txt"];
natsort($arr_eleven);
echo "<br>";
print_r($arr_eleven);
/*
    执行结果如下
    Array ( [2] => File2.txt [3] => File22.txt [4] => file.txt [0] => file1.txt [1] => file11.txt ) 
 */
natcasesort($arr_eleven);
echo "<br>";
print_r($arr_eleven);

/*
    执行结果如下
    Array ( [4] => file.txt [0] => file1.txt [2] => File2.txt [1] => file11.txt [3] => File22.txt )
 */

//根据用户自定的规则对数组排序
//php提供了可以通过创建用户自己的比较函数作为回调函数的数组排序函数,包括usort(),uasort(),uksort()等函数.他们的使用格式一样,并具有相同的参数列表,却别在于对键还是值得排列需求.
//bool usort( array &array,callback cmp _function)
//bool uasort( array &array,callback cmp _function)
//bool uksort( array &array,callback cmp _function)
//这三个函数将用户自定义的比较函数对一个数组的值进行排序.如果要排序的数组需要一种不寻常的标准进行排序,那么应该使用这几个函数.在自定义的回调函数中,需要两个参数,分别依次传入数组中连续的两个元素.比较函数必须在第一个参数被认为小于、等于或大于第二个参数时分别返回一个小于、等于或大于零的整数.在下面的例子中就根据数组中元素的长度对数组进行排序,最短的项放在最前面.

$lamp = ['Linux','Apache','Mysql','PHP'];
//使用usort()函数传入用户自定义的回调函数进行数组排序

/**
 * 自定义的函数作为回调用函数提供给usort()函数使用,声明排序规则
 * @param mixed $one 函数中前一个元素的值
 * @param mixed $two 数组中挨着的下一个元素值
 */

function sortByLen($one,$two){
    //如果两个参数长度相等返回0,在数组中的位置不变
    if(strlen($one) == strlen($two)){
        return 0;
    }else{
        return (strlen($one) > strlen($two)) ? 1 : -1;
    }
}
usort($lamp,"sortByLen");
echo "<br>";
print_r($lamp);

/*
    输出结果如下
    Array ( [0] => PHP [1] => Linux [2] => Mysql [3] => Apache )
 */


//多维数组的排序
//arrray_multsort()函数对多个数组或多维数组进行排序,或者根据某一维或多维对多维数组进行排序.
//bool array_multisort(array ar1 [,mixed arg[,mixed ...[,array ..]]])

$data = [
    ['id'=>1,'soft'=>'Linux','rating'=>'3'],
    ['id'=>2,'soft'=>'Apache','rating'=>1],
    ['id'=>3,'soft'=>'Mysql','rating'=>4],
    ['id'=>4,'soft'=>'PHP','rating'=>2],
];

//使用foreach遍历创建两个数组$soft和$rating,作为array_multsort的参数
foreach ($data as $key => $value) {
    $soft[$key] = $value['soft'];
    $rating[$key] = $value['rating'];
}

array_multisort($rating,$soft,$data);
echo "<br>---------------------<br>";
print_r($data);

/*
    结果如下
    Array ( [0] => Array ( [id] => 2 [soft] => Apache [rating] => 1 ) [1] => Array ( [id] => 4 [soft] => PHP [rating] => 2 ) [2] => Array ( [id] => 1 [soft] => Linux [rating] => 3 ) [3] => Array ( [id] => 3 [soft] => Mysql [rating] => 4 ) )
 */


/**
 * 拆分,合并,分解和接合数组
 * 1.函数array_slice()
 * 2.函数array_splice()
 * 3.函数array_combine()
 * 4.函数array_merge()
 * 5.函数array_intersect()
 * 6.函数array_diff()
 */

//1.函数array_slice()
//该函数的作用是在数组中根据条件取出一段值并返回.如果有字符串键,则所返回的数组将保留键名.
//array array_silce( array array,int offset [,int length[,bool preserve_keys]])
//第一个参数array是必选项,调用时输入要处理的数组.第二个参数offset也是必需的参数,需要传入一个数值,规定取出元素的开始位置.如果是正数,则从前往后开始取;如果是负值,则从后向前选取offset绝对值数目的元素.第三个参数是可选的,也需要传入一个数值,规定返回数组的长度.如果是负数,则从后向前选取该值绝对值数目的元素;如果未设置该值,则返回所有元素.第四个参数也是可选的,需要一个布尔类型的值.如果为true值,则所返回的数组将保留键名;设置为false值,也是默认值,将重新设置索引键值.

$lamp = array('Linux','Apache','Mysql','PHP');
echo "<br>---------------<br>";
print_r(array_slice($lamp, 1,2));
/*
    输出后结果
    Array ( [0] => Apache [1] => Mysql )
 */
echo "<br>---------------<br>";
print_r(array_slice($lamp, -2,1));
/*
    输出后结果
    Array ( [0] => Mysql )
 */

//最后一个参数设置为为true,保留原有的键值返回
echo "<br>---------------<br>";
print_r(array_slice($lamp,1,2,true));
/*
    执行后结果
    Array ( [1] => Apache [2] => Mysql )
 */

//2.array_splice();
//选择数组中额一系列元素,但不返回,而是删除它们并用其他值代替.如果提供了第四个参数,则之前选中的那些元素将被第四个参数指定的数值取代,最后生成的数组将会返回
//array array_splice(array &input,int offset [,int length[,array replacement]]);
//第一个参数array为必选项,规定要处理的书.第二个参数offset也是必选项,调用时传入数值.如果offset为正数,则从出入数组中该值指定的偏移量开始移除;如果offset为负,则从输入数组末尾倒数该值指定的偏移量开始移除.第三个参数length是可选的,也需要一个数值.如果省略该参数,则移除数组中从offset到结尾的所有部分;如果指定了length并且为正值,则移除length个元素;如果指定了length且为负值,则移除从offet到数组末尾倒数length为止中间的所有的元素.第四个参数array也会可选的,被移除的元素由此数组中的元素替代.如果没有移除任何值,则此数组中的元素将插入到指定位置.
$input = ['Linux','Apache','Mysql','PHP'];
//原数组中的第二个元素后到数组结尾都被删除
array_splice($input, 2);
echo "<br>--------<br>";
print_r($input);
/*
    输出后结果如下
    Array ( [0] => Linux [1] => Apache )
 */
$input = ['Linux','Apache','Mysql','PHP'];
//从第二个开始移除知道数组末尾倒数第一个为止中间所有的元素
array_splice($input,1,-1);
echo "<br>--------<br>";
print_r($input);

/*
    输出后结果如下
    Array ( [0] => Linux [1] => PHP )
 */

$input = ['Linux','Apache','Mysql','PHP'];

//从第二个元素到数组结尾都被第四个参数替代
array_splice($input,1,count($input),'web');
echo "<br>--------<br>";
print_r($input);
/*
    输出结果如下
    Array ( [0] => Linux [1] => web )
 */

$input = ['Linux','Apache','Mysql','PHP'];
//最后一个元素被第四个参数数组替代
array_splice($input,-1,1,array("web","www"));
echo "<br>--------<br>";
print_r($input);
/*
    运行后结果
    Array ( [0] => Linux [1] => Apache [2] => Mysql [3] => web [4] => www )S
 */

//函数array_combine()
//该函数的作用是通过合并两个数组来创建一个新数组.其中的一个数组为键名,另一个数组的值为键值.如果其中一个数组为空,或者两个数组的元素个数不同,则该函数返回false
//array array_combine(array keys,array values)
//该函数有两个参数,且都是必选项,两个参数必须有相同数目的元素.


$a1 = ["OS","WebServer","DateaBase","Language"];
$a2 = ["Linux","Apache","Mysql","PHP"];
echo "<br>------<br>";
print_r(array_combine($a1,$a2));
/*
    输出后结果如下
    Array ( [OS] => Linux [WebServer] => Apache [DateaBase] => Mysql [Language] => PHP )
 */

//函数array_merge
//该函数的作用是把一个或多个数组合并为一个数组。如果键名有重复,则该键的键值为最后一个键名对应的值(后面的覆盖前面的).如果数组是数组索引的,则该键名将返回带有整数键名的新数组,其键名以0开始进行重新索引.
//array array_merge(array array1, [,array array2[,array ...]]);
//该函数的第一个参数是必选项,需要传入一个数组.可以有多个可选参数,但必须都是数组类型的数据.返回将多个数组合并后的新数组.
$a1 = ['a'=>'Linux','b'=>'Apache'];
$a2 = ['c'=>'Mysql','d'=>'PHP'];
echo "<br>";
print_r(array_merge($a1,$a2));

/*
    输出后结果
    Array ( [a] => Linux [b] => Apache [c] => Mysql [d] => PHP ) 
 */
$a = ['3'=>'Mysql','4'=>'PHP'];
//仅使用一个数组则键名从0开始重新索引
echo "<br>";
print_r(array_merge($a));
/*
    输出后结果
    Array ( [0] => Mysql [1] => PHP )
 */

//函数array_intersect()
//该函数的作用是计算数组的交集.返回结果数组中包含了所有在被比较数组中,也同时出现在所有其他参数的数组中的值,键名保留不变,仅有值用于比较.
//array array_intersect(array array1,array array2[,array ...]);
//该函数的第一个参数是必选项,传入与其他数组进行比较的第一个数组.第二个参数也是必选项,传入与第一个数组进行比较的数组.可以有多个可选参数作为与第一个数组进行比较的数组.
$a1 = ['Linux','Apache','Mysql','PHP'];
$a2 = ['Linux','Tomcat','Mysql','JSP'];
echo "<br>";
print_r(array_intersect($a1,$a2));

/*
    执行结果如下
    Array ( [0] => Linux [2] => Mysql )
 */

//函数array_diff()
//该函数的作用是返回两个数组的差集数组.该数组包括了所有在被比较的数组中,但是不在任何其他参数数组中的元素值.再返回的数组中,键名保持不变
//该函数的第一个参数是必选项,传入与其他数组进行比较的第一个数组.第二个参数也是必选项,传入与第一个数组进行比较的数组.第三个参数以后都是可选项,可用一个或任意多个数组与第一个数组进行比较.
echo "<br>";
print_r(array_diff($a1,$a2));
/*
    执行结果如下
    Array ( [1] => Apache [3] => PHP )
 */

//使用数组实现堆栈 堆栈是数据结构的一种实现形式,是一种使用非常广泛的存储数据的容器.在堆栈这种容器中,最后压入的数据(进栈)将会被最先弹出(出栈).即在数据存储时采用"先进后出"的数据结构.在PHP中,将数组当做一个栈,使用array_push()和array_pop()两个系统函数即可完成数据的进栈和出栈操作.
//array_push()函数向第一个参数的数组尾部添加一个或多个元素(入栈),然后返回新数组的长度.该函数等于多次调用$array[] = $value.
//int array_push(array &array,mixed var [,mixed ...]);
//该函数的第一个参数是必选的,作为栈容器的一个数组.第二个参数也是必选的,是在第一个参数的数组尾部添加一个数据.还可以有多个可选参数,都可以添加到第一个参数的数组的尾部,即入栈.但要注意,即使数组中有字符串键名,添加的元素也始终是数字键.
$lamp = ['Web'];
array_push($lamp,"Linux");
echo "<br>";
print_r($lamp);
/*
    输出后结果如下
    Array ( [0] => Web [1] => Linux )
 */
//再连续压入三个数据到数组的尾部,栈中的元素长度变为5个
array_push($lamp,"Apache","Mysql","PHP");
echo "<br>";
print_r($lamp);

/*
    输出后结果如下
    Array ( [0] => Web [1] => Linux [2] => Apache [3] => Mysql [4] => PHP )
 */

//array_pop()函数删除数组中的最后一个元素,即将数组的最后一个元素弹出(出栈),并将数值的长度减1,如果数组为空(或者不是数组)将会返回null
//array array_pop(array &array);
//该函数只有一个参数,即作为栈的数组,返回弹出的数组中最后一个元素的值.
echo array_pop($lamp);
echo "<br>";
print_r($lamp);
/*
    输出后结果如下
    PHP
    Array ( [0] => Web [1] => Linux [2] => Apache [3] => Mysql )
 */

//使用数组实现队列
//array_shift()函数实现删除数组中的第一个元素,并返回被删除元素的值
//mixed array_shift(array &array)
//该函数和array_pop()一样,都是只有一个必选参数,其参数可以实现队列的数组.将数组中第一个单元移出并作为结果返回,并将数组的长度减1,还将所有其他元素向前移动一位.所有的数字键名改为从0开始计数,字符串元素键名保持不变.如果数组为空(或者不是数组),则返回null
$lamp = ['a'=>'Linux','b'=>'Apache','c'=>'Mysql','d'=>'PHP'];
echo "<br>";
echo array_shift($lamp);
echo "<br>";
print_r($lamp);
/*
    输出后结果如下
    Linux
    Array ( [b] => Apache [c] => Mysql [d] => PHP )
 */

//带有数字键的索引数组
$lamp = [0=>'Linux',1=>'Apache',2=>'Mysql',3=>'PHP'];
echo "<br>";
echo array_shift($lamp);
echo "<br>";
print_r($lamp);
/*
    输出后结果如下
    Linux
    Array ( [0] => Apache [1] => Mysql [2] => PHP )
 */

//在php中还可以使用array_unshift()函数在队列数组的开头插入一个或多个元素,该函数执行成功将返回插入元素的个数,使用array_push()是一样的

/**
 * 其他有用的数组处理函数
 * 1.函数array_rand()
 * 2.函数shuffle()
 * 3.函数array_sum()
 * 4.函数range
 */

//array_rand()
//该函数从数组中随机选出一个或多个元素并返回.
//mixed array_rand(array input [,int num_req])
//第一个参数为必选项,它接收一个数组作为输入数组,从这个数组中随机选出一个或多个元素.第二个参数是一个可选的参数,指明了用户想取出多少个元素.如果没有指定,则默认从数组中取出一个元素.如果只取出一个,array_rand()函数返回一个随机元素的键名,否则就返回一个包含随机键名的数组.这样就可以随机从数组中取出键名和值
$lamp = ['a'=>'Linux','b'=>'Mysql','c'=>'Mysql','d'=>'PHP'];
echo "-------------<br>";
echo $lamp[array_rand($lamp)];
/*
    输出后结果
    PHP
 */
$key = array_rand($lamp,2);
echo "<br>";
echo $lamp[$key[0]];
echo "<br>";
echo $lamp[$key[1]];
/*
    输出后结果
    Linux
    PHP
 */

//shuffle()
//该函数吧数组中的元素按随机顺序重新排列,即将数组中的顺序打乱,若成功则返回true否则返回false.这也是一个随机化的过程.shuffle()函数的使用非常容易,只需要一个数组作为惨呼,没执行一次则返回不同的数组,
$lamp = ['a'=>'Linux','b'=>'Mysql','c'=>'Mysql','d'=>'PHP'];
shuffle($lamp);
echo "<br>";
print_r($lamp);
/*
    执行后结果如下
    Array ( [0] => Mysql [1] => PHP [2] => Mysql [3] => Linux )
 */

//函数array_sum()
//该函数返回数组中所有的值的综合.该函数也非常容易使用,只需要传入一个数组作为必选参数即可.如果所有制都是整数,则返回一个整数值;如果其中有一个或多个值都是浮点数,则返回浮点数
$a = [0=>'5',1=>'15',2=>'25'];
//使用array_sum()函数返回数组中元素的总和
echo "<br>";
echo array_sum($a);
/*
    输出后结果为
    45
 */

//range()
//该函数创建并返回一个包含指定范围的元素的数组.该函数需要三个参数
//array range(mixed first,mixed second,[,number step]);
//第一个参数为first必选项,规定数组元素的最小值.第二个参数second也是必选项,规定数组元素的最大值.第三个参数step是可选的,规定元素之间的步进制,默认是1.该函数创建一个数组,包含从first到second(包含first和second)之前的整数或字符.如果second比first小,则返回反序的数组
$number = range(0,5);
echo "--------------<br>";
print_r($number);
/*
    执行结果如下
    Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 ) 
 */
$number = range(0,50,10); //使用range()函数声明元素值为0-50的数组,每个元素之间的步长为10
echo "<br>";
print_r($number);
/*
    执行结果如下
    Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 ) 
 */
$letter = range("a","d");
echo "<br>";
print_r($letter);
/*
    执行结果如下
    Array ( [0] => a [1] => b [2] => c [3] => d )
 */

发表评论

发表评论

*

沙发空缺中,还不快抢~