php数组

<?php 
   
// 数组函数讲解

//count
//array_key_exists  检查给定的键名或索引是否存在于数组中
//array_flip        交换数组中的键和值
//in_array          检查数组中是否存在某个值
//range             建立一个包含指定范围单元的数组 
// shuffle          打乱数组
// array_unique     移除数组中重复的值
// array_reverse    返回一个单元顺序相反的数组 
/* array_push       将一个或多个单元压入数组的末尾 还不如用 $array[] =（入栈） 
array_pop   	          将数组最后一个单元弹出（出栈）
array_shift 	          将数组开头的单元移出数组 
array_unshift 	          在数组开头插入一个或多个单元 所有的数值键名将修改为从零开始重新计数，
                                                     所有的文字键名保持不变。 
                                                     返回 array 数组新的单元数目。 
*/
//sort              对数组排序
//asort             对数组进行排序并保持索引关系
//ksort             对数组按照键名排序
// array_values     返回数组中所有的值
// natsort —        用“自然排序”算法对数组排序
// natcasesort  —   用“自然排序”算法对数组进行不区分大小写字母的排序
// uasort —         使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
// usort            使用用户自定义的比较函数对数组中的值进行排序


// array_multisort — 对多个数组或多维数组进行排序
// array_slice —    从数组中取出一段
// array_splice — 把数组中的一部分去掉并用其它值取代
// array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
// array_merge —    合并一个或多个数组如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。
//                  然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。 

//                 如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引
// array_intersect — 计算数组的交集
// array_diff — 计算数组的差集
// array_rand — 从数组中随机取出一个或多个单元
// array_sum — 计算数组中所有值的和
// array array_keys ( array $input [, mixed $search_value [, bool $strict ]]
// 如果指定了可选参数  search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回。
// 自 PHP 5 起，可以用  trict 参数来进行全等比较（===）。

// array_search —        在数组中搜索给定的值，如果成功则返回相应的键名
// array_count_values    统计数组中所有的值出现的次数
// array_filter —        用回调函数过滤数组中的单元
// array_walk            对数组中的每个成员应用用户函数(一般情况用户函数接受两个参数如用户函数有第三个参数可以用第三个函数传递)
// array_map —          将回调函数作用到给定数组的单元上array_map() 返回一个数组，该数组包含了 arr1 中的所有单元经过 callback 作用过之后的单元。
//                      callback 接受的参数数目应该和传递给 array_map() 函数的数组数目一致。 


/*
 count 函数
作用:计算数组的单元个数[或对象的属性个数]

注:count函数的参数,可以是数组,也可以是"非数组"
返回值分3种情况讨论
1: 数组/对象, 返回数组的单元个数/对象的属性个数
2: NULL ,返回0
3: 非数组,也非NULL,通通返回1
4.第二个参数代表是否递归计算多维数组的个数。
*/


$arr = array('a','b','c','d');
echo count($arr),'<br />'; // 4

$arr = array('a','b','c',array('d','e')); // 6
echo count($arr,true).'<br/>';

/* array_key_exists 与isset区别
array_key_exists 是对数组键的一个检查。
isset当值为null是返回false
*/
$search_array = array('first' => null, 'second' => 4);
// returns false
var_dump(isset($search_array['first']));

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

// array_flip
// 交换键值, 即值做键,键做值

$arr = array(0=>'a',1=>'b',2=>'b',3=>'c');
print_r($arr);
print_r(array_flip($arr));  //当后面键名重复，后面会覆盖前面的

//写一个函数判断某个值在不在数组中
function inarr($arr,$val){
    $find=false;
    foreach ($arr as $v){
    	if($val===$v){
    		$find=true;
    	}
    	return $find;
    }
}
$val='a';
var_dump(inarr($arr, $val));
//也可以用in_array
var_dump(in_array($val,$arr));

//range() : 生成一个指定范围的数组
$arr = range(1,10,2);  //第三个参数是步长
print_r($arr);
echo array_sum($arr);
// shuffle打乱数组
if(shuffle($arr)) {
	echo '打乱成功';
	print_r($arr);  // 数组本身被打乱了,因为shuffle函数,是引用传值
}

//写一个函数去重复的值
$arr = array('a','b','a','c','d','e','f','f','f');
function uni($arr){
	$temp=array();
	foreach ($arr as $v){
		if(!in_array($v, $temp)){
			$temp[]=$v;
		}else{
			continue;
		}
	}
	return $temp;
}

print_r(uni($arr));

//用系统函数
print_r(array_unique($arr));

$arr = array('a'=>'春','b'=>'夏','c'=>'秋','d'=>'冬');
print_r(array_reverse($arr)); //此时,对于索引数组,索引没调过来,只调换的值
print_r(array_reverse($arr),true);   //索引也调换了

/* 队列,就像人排队来新人,站队伍的后面  先进先出*/
// 栈: 就像从枪口上子弹，后进先出
/* 数组完全可以达到队列和栈的效果
需要用到以下几个函数
array_push
array_pop
array_shift
array_unshift */
/**
 从后往前读数组,读出来的单元,追加到一个备用数组里
 **/
$arr = array('a'=>'春','b'=>'夏','c'=>'秋','d'=>'冬');
function rev2($arr) {
	$rev = array();
	while(count($arr)) {
		$v = array_pop($arr); //弹出
		array_push($rev,$v);  //最加
	}
	return $rev;
}
//用数组知识完成下题
//把 '1234567'转换成'1,234,567'

function formatstr($str){
	$bak=array();
	$arr=str_split($str);   //1,2,3,4,5,6,7
	$i=0;
	while(!!$cnt=count($arr)){
	    array_unshift($bak, array_pop($arr));  //将$arr数组末尾弹出加入到$bak数组中
	    $i++;
	    if($i%3==0&&$cnt!=1){   //$cnt!=1防止出现第一个字符就是，号
	    	array_push($arr, ',');
	    }
	   
	}
	return implode($bak);
}
$str = '1234567';
print_r(formatstr($str));
echo '<br />'; // 1,234,567
// 用系统函数

print_r(number_format($str));


//array_key 第三个参数匹配第二个参数类型要相同
$lamp = array("a"=>"Linux","b"=>"Apache","c"=>"MySQL","d"=>"PHP" );
print_r( array_keys($lamp) );          //输出：Array ( [0] => a [1] => b [2] => c )
print_r( array_keys($lamp,"Apache") ); //使用第二个可选参数输出：Array ( [0] => b)

$a = array(10, 20, 30, "10");          //声明一个数组，其中元素的值有整数10和字符串”10”
print_r( array_keys($a,"10",false) );  //使用第三个参数 (false)输出：Array ( [0] => 0 [1] => 3 )

$a = array(10, 20, 30, "10");          //声明一个数组，其中元素的值有整数10和字符串”10”
print_r( array_keys($a,"10",true) );   //使用第三个参数 (true)输出：Array ( [0] => 3)

$array = array( 1, "php", 1, "mysql", "php" );  //声明一个带有重复值的数组
$newArray = array_count_values( $array );    	//统计数组$array中所有值出现的次数
print_r( $newArray );                     		//输出：Array([1] => 2 [php] => 2 [mysql] => 1)


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

$array = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
print_r(array_filter($array,'myFun'));
/* 过滤后的结果输出Array ( [b] => 2 [d] => 4 )  */


/**
 定义一个可以作为回调的函数，名称为myfun1
 @param	string	$value	一个字符串参数，接收数组的值
 @param	string	$key		一个字符串参数，接收数组的键
 */
function myfun1( $value, $key ) {     //函数要两个参数
	echo "The key $key has the value $value<br>";
}
//定义一个数组$lamp
$lamp = array( "a"=>"Linux", "b"=>"Apache", "c"=>"Mysql", "d"=>"PHP" );
array_walk($lamp, 'myfun1');   
print_r($lamp);

/**
 定义一个可以作为回调的函数，名称为myfun2
 @param	string	$value	一个字符串参数，接收数组的值
 @param	string	$key		一个字符串参数，接收数组的键
 @param	string	$p		一个字符串参数，接收一个自定义的连接符号字符串
 */
function myfun2( $value, $key, $p)  {
	echo "$key $p $value <br>";
}

//使用array_walk函数传入三个参数
array_walk( $lamp, "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( $lamp,"myfun3" );

	print_r( $lamp );          //输出：Array ( [a] => Web [b] => Web [c] => Web [d] => Web )

	function myfun4($v) {
		if ($v === "MySQL") {   				//如果数组中元素的值恒等于MySQL条件成功
			return "Oracle";    				//返回Oracle
		}
		return $v;             					//不等于MySQL的元素都返回传入的值，即原型返回
	}
	
	//声明一个有4个元素的数组$lamp
	$lamp = array( "Linux", "Apache", "MySQL", "PHP" );
	
	//使用array_map()函数传入一个函数名和一个数组参数
	print_r( array_map( "myfun4", $lamp ) );
	
	/*上面程序执行后输出Array ( [0] => Linux [1] => Apache [2] => Oracle [3] => PHP ) */	
	/**
	 声明一个函数使用多个参数, 回调函数接受的参数数目应该和传递给array_map()函数的数组数目一致
	 自定义一个函数需要两个参数，两个数组中的元素依次传入
	 @param	mixed	$v1	数组中前一个元素的值
	 @param	mixed	$v2	数组中下一个元素的值
	 @return	string		提示字符串
	*/
	function myfun5( $v1, $v2 ) {
		if ($v1 === $v2) {          			//如果两个数组中的元素值相同则条件成功
			return "same";        				//返回same, 说明两个数组中对应的元素值相同
		}
		return "different";         			//如果两个数组中对应的元素值不同，返回different
	}
	
	$a1 = array("Linux", "PHP", "MySQL");   	//声明数组$a1,有三个元素
	$a2 = array("Unix", "PHP", "Oracle");     	//数组$a第二个元素值和$a中第二个元素的值相同
	
	print_r( array_map( "myfun5", $a1, $a2) );  //使用array_map()函数传入多个数组
	
	/*上面程序执行后输出：Array ( [0] => different [1] => same [2] => different ) */
	
	//当自定义函数名设置为 null 时的情况
	$a1 = array("Linux", "Apache");         	//声明一个数组$a1, 有两个元素
	$a2 = array("MySQL", "PHP");         		//声明另一个数组$a2,也有两个元素
	
	print_r( array_map( null, $a1, $a2) );      //通过第一个参数设置为NULL，构造一个数组的数组
	
	/*   上面程序执行后输出：Array (
	 [0] => Array ( [0] => Linux [1] => MySQL )
			[1] => Array ( [0] => Apache [1] => PHP ) )
	*/
	
	$input = array( "Linux", "Apache", "MySQL", "PHP" );
	//原数组中的第二个元素后到数组结尾都被删除
	array_splice($input, 2);
	print_r($input);           				//输出：Array ( [0] => Linux [1] => Apache )
	
	$input = array("Linux", "Apache", "MySQL", "PHP");
	//从第二个开始移除直到数组末尾倒数第1个为止中间所有的元素
	array_splice($input, 1, -1);
	print_r($input);           				//输出：Array ( [0] => Linux [1] => PHP )

	
	
	$a1 = array( "OS", "WebServer", "DataBase", "Language" ); //声明第一个数组作为参数1
	$a2 = array( "Linux", "Apache", "MySQL", "PHP");          //声明第二个数组作为参数2
	
	print_r( array_combine( $a1, $a2 ) );                     //使用arrray_combine()将两个数组合并
	
	/* 输出：Array ( [OS] => Linux [WebServer] => Apache [DataBase] => MySQL [Language] => PHP ) */
	
	
	
	$a1 = array( "a"=>"Linux", "b"=>"Apache" );
	$a2 = array( "c"=>"MySQL", "b"=>"PHP" );	
	print_r( array_merge( $a1, $a2 ) ); //输出： Array ( [a] => Linux [b] => PHP [c] => MySQL )
	
	//仅使用一个数组参数则键名以0开始进行重新索引
	$a = array( 3=>"PHP", 4=>"MySQL" );
	
	print_r( array_merge( $a ) ); 		//输出：Array ( [0] => PHP [1] => MySQL )
	
	
	
	$lamp = array( "a"=>"Linux", "b"=>"Apache", "c"=>"MySQL", "d"=>"PHP" );
	echo array_rand( $lamp,1 );            	//随机从数组$lamp中取1个元素的键值，例如b
	echo $lamp[array_rand($lamp)]."<br>"; 	//通过随机的一个元素的键值获取数组中一个元素的值
	
	$key = array_rand( $lamp,2 );           //随机从数组$lamp中取2个元素的键值赋给数组$key
	
	echo $lamp[$key[0]]."<br>";          	//通过数组$key中第一个值获取数组$lamp中一个元素的值
	echo $lamp[$key[1]]."<br>";          	//通过数组$key中第二个值获取数组$lamp中另一个元素的值
	
	
	
	
?>

转载于:https://my.oschina.net/u/932154/blog/99749