奥门新浦京官方网站PHP开发之自定义函数及数组

正文将介绍一些PHP开垦中自定义函数和数组相关的学识,PHP开垦者能够关怀一下。

  • 数组的前奏下标能够不从0初阶,例子为从2上马。

    $data = array(2=>’A’,’B’,’C’);     运转结果:$data =
    array(2=>’A’,3=>’B’,4=>’C’卡塔尔;

rsort(卡塔尔(قطر‎ 函数对数组的成分依据键值进行逆向排序。与 arsort(卡塔尔国的职能基本雷同。

一、自定义函数

自定义函数正是大家团结定义的函数,在PHP中自定义函数格式如下:

function funname(arg1, arg2, arg3......){

//TODO

return values;

}

<?php 
function fun($m, $n){ 
if($m==0 || $n==0){ 
return 0; 
}else{ 
$a=$m*$n; 
return $a; 
} 
} 

$p=2; 
$h=3; 
echo $p."*".$h."=".fun($p,$h); 
?>

出口结果:
奥门新浦京官方网站 1上边再举二个可变参数的函数

<?php 
/*
function fun($m, $n){
if($m==0 || $n==0){
return 0;
}else{
$a=$m*$n;
return $a;
}
}

$p=2;
$h=3;
echo $p."*".$h."=".fun($p,$h); */ 

function fun($m, $n=1, $x=2){ 
$a=$m*$n*$x; 
return $a; 
} 

$p=2; 
echo fun($p)."<br>";          // 2*1*2 = 4 
echo fun($p, 3)."<br>";       // 2*3*2 = 12 
echo fun($p, 3, 3)."<br>";    // 2*3*3 = 18 
?>

奥门新浦京官方网站 2

再来看看自定义函数援引传递

<?php  
    /*   
    function fun($m, $n){ 
        if($m==0 || $n==0){ 
            return 0; 
        }else{ 
            $a=$m*$n; 
            return $a; 
        } 
    } 

    $p=2; 
    $h=3; 
    echo $p."*".$h."=".fun($p,$h);  
    */  

    /* 
    function fun($m, $n=1, $x=2){ 
        $a=$m*$n*$x; 
        return $a; 
    } 

    $p=2; 
    echo fun($p)."<br>";          // 2*1*2 = 4 
    echo fun($p, 3)."<br>";       // 2*3*2 = 12 
    echo fun($p, 3, 3)."<br>";    // 2*3*3 = 18 
    */  

    function fun(&$n){  
        $n=$n*$n;  
    }  
    $p=2;  
    fun($p);  
    echo $p;  
?>

奥门新浦京官方网站 3

 

评释:该函数为 array
中的单元授予新的键名。那将去除原有的键名而不仅是重复排序。

二、数组定义赋值

1、数组基本写作格式

轻易款式:array(值1, 值2, 值3, …….)

array(“aa”, 12, true, 2.2, “test”, 50卡塔尔(قطر‎; //通过数组下标获得多少

全体格局:array(键1=>值1, 键2=>值2, ……卡塔尔国

array(“title”=>”aa”, “age”=>20State of Qatar;  //只好通过键名获得数量

2、创制数组的秘技

//第一种  
$arr1=array(11, 22, 33, "44");  
//第二种  
$arr2=array('a'=>'11', 'b'=>'22');  
//第三种  
$arr3[0]='20';  
$arr3[1]='30';

 

假如成功则赶回 TRUE,不然重回 FALSE。

三、数组操作

1、修改

$arr=array(11, 22, 33, 44);

$arr[0]=55;  //数组变为$arr=array(55, 22, 33, 44);

2、删除

$arr=array(11, 22, 33, 44);

unset($arr[0]);    //数组变为$arr=array(22, 33, 44);

3、使用

$arr=array(11, 22, 33, 44);

echo $arr[0];

$arr=array('a'=>11, 'b'=>22, 'c'=>33, 'd'=>44);

echo $arr['b']];

4、遍历

$arr=array('a'=>11, 'b'=>22, 'c'=>33, 'd'=>44);

foreach($arr as $value){ //无键名

echo $value."<br>";

}

foreach($arr as $id=>$value){  //输出键和值

echo $id."__".$value."<br>";

}

四、二维数组

$arr=array(array("1","11","111"), array("2","22","222"));

echo $arr[1][2];

五、数组函数

(1)array_change_key_case(array, case)

array:必需,数组。

case:可选,CASE_LOWETiggo(暗中同意值,小写字母重返数组的键),CASE_UPPELAND(大写字母重返数组的键卡塔尔

成效:将数组的装有的 KEY 都转移为大写或小写。

<?php 
2.
$a=array("a"=>"Cat","b"=>"Dog","c"=>"Horse"); 
3.
print_r(array_change_key_case($a,CASE_UPPER)); 
4.
?>  
5.
结果:Array ( [A] => Cat [B] => Dog [C] => Horse )

(2)array_chunk(array,size,preserve_key)

array:必需。

size:必需,规定每种新数组富含多少成分。

preserve_key:可选,true(保留键名),false(新索引)

功效:把三个数组分成新的数组块。

<?php  
    //array_chunk(array,size,preserve_key)  

    $a1=array("a"=>"Cat","b"=>"Dog","c"=>"Horse","d"=>"Cow");  
    print_r(array_chunk($a1,2));  

    $a2=array("a"=>"Cat","b"=>"Dog","c"=>"Horse","d"=>"Cow");  
    print_r(array_chunk($a2,2,true));  

?>   
结果:

Array ( [0] => Array ( [0] => Cat [1] => Dog ) [1]
=> Array ( [0] => Horse [1] => Cow ) )
Array ( [0] => Array ( [a] => Cat [b] => Dog ) [1]
=> Array ( [c] => Horse [d] => Cow ) )

…….

像这么的函数超级多,能够在用的时候再查,列表如下(php代表第叁遍面世版本)

函数 描述 PHP
array() 创建数组。 3
array_change_key_case() 返回其键均为大写或小写的数组。 4
array_chunk() 把一个数组分割为新的数组块。 4
array_combine() 通过合并两个数组来创建一个新数组。 5
array_count_values() 用于统计数组中所有值出现的次数。 4
array_diff() 返回两个数组的差集数组。 4
array_diff_assoc() 比较键名和键值,并返回两个数组的差集数组。 4
array_diff_key() 比较键名,并返回两个数组的差集数组。 5
array_diff_uassoc() 通过用户提供的回调函数做索引检查来计算数组的差集。 5
array_diff_ukey() 用回调函数对键名比较计算数组的差集。 5
array_fill() 用给定的值填充数组。 4
array_filter() 用回调函数过滤数组中的元素。 4
array_flip() 交换数组中的键和值。 4
array_intersect() 计算数组的交集。 4
array_intersect_assoc() 比较键名和键值,并返回两个数组的交集数组。 4
array_intersect_key() 使用键名比较计算数组的交集。 5
array_intersect_uassoc() 带索引检查计算数组的交集,用回调函数比较索引。 5
array_intersect_ukey() 用回调函数比较键名来计算数组的交集。 5
array_key_exists() 检查给定的键名或索引是否存在于数组中。 4
array_keys() 返回数组中所有的键名。 4
array_map() 将回调函数作用到给定数组的单元上。 4
array_merge() 把一个或多个数组合并为一个数组。 4
array_merge_recursive() 递归地合并一个或多个数组。 4
array_multisort() 对多个数组或多维数组进行排序。 4
array_pad() 用值将数组填补到指定长度。 4
array_pop() 将数组最后一个单元弹出(出栈)。 4
array_product() 计算数组中所有值的乘积。 5
array_push() 将一个或多个单元(元素)压入数组的末尾(入栈)。 4
array_rand() 从数组中随机选出一个或多个元素,并返回。 4
array_reduce() 用回调函数迭代地将数组简化为单一的值。 4
array_reverse() 将原数组中的元素顺序翻转,创建新的数组并返回。 4
array_search() 在数组中搜索给定的值,如果成功则返回相应的键名。 4
array_shift() 删除数组中的第一个元素,并返回被删除元素的值。 4
array_slice() 在数组中根据条件取出一段值,并返回。 4
array_splice() 把数组中的一部分去掉并用其它值取代。 4
array_sum() 计算数组中所有值的和。 4
array_udiff() 用回调函数比较数据来计算数组的差集。 5
array_udiff_assoc() 带索引检查计算数组的差集,用回调函数比较数据。 5
array_udiff_uassoc() 带索引检查计算数组的差集,用回调函数比较数据和索引。 5
array_uintersect() 计算数组的交集,用回调函数比较数据。 5
array_uintersect_assoc() 带索引检查计算数组的交集,用回调函数比较数据。 5
array_uintersect_uassoc() 带索引检查计算数组的交集,用回调函数比较数据和索引。 5
array_unique() 删除数组中重复的值。 4
array_unshift() 在数组开头插入一个或多个元素。 4
array_values() 返回数组中所有的值。 4
array_walk() 对数组中的每个成员应用用户函数。 3
array_walk_recursive() 对数组中的每个成员递归地应用用户函数。 5
arsort() 对数组进行逆向排序并保持索引关系。 3
asort() 对数组进行排序并保持索引关系。 3
compact() 建立一个数组,包括变量名和它们的值。 4
count() 计算数组中的元素数目或对象中的属性个数。 3
current() 返回数组中的当前元素。 3
each() 返回数组中当前的键/值对并将数组指针向前移动一步。 3
end() 将数组的内部指针指向最后一个元素。 3
extract() 从数组中将变量导入到当前的符号表。 3
in_array() 检查数组中是否存在指定的值。 4
key() 从关联数组中取得键名。 3
krsort() 对数组按照键名逆向排序。 3
ksort() 对数组按照键名排序。 3
list() 把数组中的值赋给一些变量。 3
natcasesort() 用“自然排序”算法对数组进行不区分大小写字母的排序。 4
natsort() 用“自然排序”算法对数组排序。 4
next() 将数组中的内部指针向前移动一位。 3
pos() current() 的别名。 3
prev() 将数组的内部指针倒回一位。 3
range() 建立一个包含指定范围的元素的数组。 3
reset() 将数组的内部指针指向第一个元素。 3
rsort() 对数组逆向排序。 3
shuffle() 把数组中的元素按随机顺序重新排列。 3
sizeof() count() 的别名。 3
sort() 对数组排序。 3
uasort() 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联。 3
uksort() 使用用户自定义的比较函数对数组中的键名进行排序。 3
usort() 使用用户自定义的比较函数对数组中的值进行排序。 3

可选的首个参数包括其余的排序标记。

  • unset(卡塔尔   删除全数数组  
      删除单个数组成分 

语法
rsort(array,sorttype)参数 描述
array 必须。输入的数组。
sorttype 可选。规定怎么排列数组的值。大概的值:

        初阶数组:$data = array(‘name’=> ‘洛初’,’age’=>
24,’sex’=> ‘女’卡塔尔;

SORT_REGULATiggo – 暗中同意。以它们原本的类型实行管理(不变类型)。
SORT_NUMEWranglerIC – 把值作为数字来拍卖
SORT_ST迈凯伦720SING – 把值作为字符串来管理
SORT_LOCALE_ST昂科雷ING – 把值作为字符串来拍卖,基于本地设置*。
 

        unset($data卡塔尔;                    运行结果:NULL

*:该值是 PHP 4.4.0 和 5.0.2 新加的。在 PHP 6
以前,使用了系统的区域设置,能够用 setlocale(State of Qatar 来退换。自 PHP 6
起,必得用 i18n_loc_set_default() 函数。

        unset($data[‘name’]State of Qatar;       运维结果:$data =
array(‘age’=>24,’sex’=>’女’卡塔尔国;

例子

 

 代码如下


<?php
$my_array = array(“a” => “Dog”, “b” => “Cat”, “c” =>
“Horse”);
rsort($my_array);
print_r($my_array);
?>输出:

  • list(卡塔尔    把数组中的值赋给一些变量 

Array
(
[0] => Horse
[1] => Dog
[2] => Cat
)
Like sort(), rsort() assigns new keys for the elements in array. It will
remove any existing keys you may have assigned, rather than just
reordering the keys.  This means that it will destroy associative keys.

        $data = array(‘洛初’,’女’,’24’);

$animals = array(“dog”=>”large”,  “cat”=>”medium”, 
“mouse”=>”small”);
print_r($animals);
//Array ( [dog] => large [cat] => medium [mouse] => small
)

        list($a,$b,$c卡塔尔国 = $data;             运营结果:$a=’洛初’;
$b=’女’; $c=’24’;

rsort($animals);
print_r($animals);
//Array ( [0] => small [1] => medium [2] => large )

        注释:该函数只用于数字索引的数组,且只要数字索引从 0 开端。   
  

Use KSORT() or KRSORT() to preserve associative keys.


  • range(卡塔尔国  
     自动生成贰个满含钦命范围单元的数据

        $data = range(0,5State of Qatar;        运转结果:$data = array(0,1,2,3,4,5卡塔尔;

 


  • array_count_values(array卡塔尔(قطر‎用于总结数组中有所值现身的次数。   总结数组中相近成分的个数 

        $data = array(‘name’=> ‘洛初’,’age’=> 24,’sex’=>
‘女’,’nickname’=>’洛初’);

        array_count_values($data卡塔尔国;            运维结果:array(‘洛初’=>2,’24’=>1,’女’=>1卡塔尔(قطر‎;


  • array_change_key_case(array,case卡塔尔国 
    把数组中全部键改过为小写或大写。     将数组中负有的键调换大小写 

        

        array必须。规定要运用的数组。

        case        可选。或然的值:CASE_LOWEPAJERO –
默许值。将数组的键调换为小写字母。CASE_UPPE途锐 –
将数组的键调换为大写字母。

        $data = array(‘Name’=> ‘洛初’,’Age’=> 24,’Sex’=> ‘女’);

        array_change_key_case($data,CASE_UPPER);    

        运转结果:$data = array(‘NAME’=> ‘洛初’,’AGE’=>
24,’SEX’=> ‘女’State of Qatar;

         array_change_key_case($data,CASE_LOWER);  

        运转结果:$data = array(‘name’=> ‘洛初’,’age’=>
24,’sex’=> ‘女’卡塔尔国;


  • array_chunk(array,size,preserve_key卡塔尔   把一个数组分割为新的数组块。    把数组分割为新的数组块 

        array:必需,数组;   

        size:必得,规定每一个新数组包括多少个成分   

        preserve_key:可选,true – 保留原始数组中的键名。false –
暗中同意。各个结果数组使用从零开端的新数组索引

        $data = array(‘Name’=> ‘洛初’,’Age’=> 24,’Sex’=> ‘女’);

        array_chunk($data,2);    

        运维结果:$data =
array(0=>array(0=>’洛初’,1=>24卡塔尔(قطر‎,1=>array(0=>’女’卡塔尔(قطر‎卡塔尔(قطر‎;

 


  • array_column(array,column_key,index_key卡塔尔   再次来到输入数组中有个别单一列的值

     

  •   

        column_key:必须,供给再次回到值的列。该参数也足以是NULL,此时将重临整个数组 

        index_key:可选,用作再次来到数组的目录或键的列。

        $data =
array(    array(‘id’=>1,’name’=>’洛初’),    array(‘id’=>2,’name’=>’洛秋’),    array(‘id’=>2,’name’=>’洛末’),);

        array_column($data,’name’State of Qatar;        运转结果:$data =
array(0=>’洛初’,1=>’洛秋’,2=>’洛末’卡塔尔;


  • array_combine(keys,valuesState of Qatar  通过统一多少个数组来创建多个新数组,当中的三个数组成分为键名,另一个数组成分为键值

        keys:必得,键名数组;        values:必得,键值数组;

        $fname=array(“Bill”,”Steve”,”Mark”);    $age=array(“60″,”56″,”31”);

        array_combine($fname,$age卡塔尔(قطر‎;        运转结果:array(‘Bill’=>60,’Steve’=>56,’Mark’=>31卡塔尔(قطر‎;

        注释:键名数组和键值数组的要素个数必得一致!若是内部叁个数组为空,或许三个数组的因素个数区别,则该函数重临false。 


  • 填充数组

        array_fill(index,number,value卡塔尔国  用给定的键值填充数组。        用键值填充数组

        index:必得,被重返数组的率先个目录;

        number:必得,规定要插入的成分数;

        value:必需,规定供填充数组所使用的值 ;

     
  array_fill(3,4,blue卡塔尔;        运营结果:array(“3″=>”blue”,”4″=>”blue”,”5″=>”blue”,”6″=>”blue”卡塔尔(قطر‎;

 

        array_fill_keys(keys,valueState of Qatar  用钦赐键名的给定键值填充数组。
  使用内定的键和值填充数组

        keys:必需,使用该数组的值作为键。非法值将被转移为字符串;

        value:必得,填充数组所使用的值;

        $keys = array(“a”,”b”,”c”,”d”);  
 array_fill_keys($keys,”blueState of Qatar;   
 运维结果:array(“a”=>”blue”,”b”=>”blue”,”c”=>”blue”,”d”=>”blue”卡塔尔国;


  • array_filter(array,callbackfunctionState of Qatar 用回调函数过滤数组中的成分

        array必得。规定要过滤的数组。

        callbackfunction必须。规定要接收的回调函数。

        该函数把输入数组中的每一种键值传给回调函数。借使回调函数再次来到true,则把输入数组中的当前键值再次回到结果数组中。数组键名保持不改变。

        function test_odd($var){    return($var & 1);    }

        $a1=array(“a”,”b”,2,3,4);        array_filter($a1,”test_odd”卡塔尔(قطر‎;
       运营结果:array(“3″=>”3″卡塔尔;


  • array_flip(array卡塔尔国   交流数组中的键和值。    反转数组中存有的键以致它们关联的值       

        $a1=array(“a”=>”red”,”b”=>”green”,”c”=>”blue”,”d”=>”yellow”);
   array_flip($a1卡塔尔(قطر‎;  
 运维结果:array(“red”=>”a”,”green”=>”b”,”blue”=>”c”,”yellow”=>”d”卡塔尔;


  • array_key_exists(key,array卡塔尔  检查钦点的键名是还是不是存在于数组中。
      检查有个别数组中是或不是留存内定的键名,假若键名存在则赶回
    true,借使键名不设有则赶回 false       

        key必需。规定键名。        array必得。规定数组。

 


 

  • array_keys(array,value,strict卡塔尔  
    再次回到数组中持有的键名。 重回饱含数组中持有键名的三个新数组   
       

        array必须。规定数组。

        value可选。您可以内定键值,然后独有该键值对应的键名会被重临。

        strict         可选。与 value 参数一齐行使。恐怕的值:true –
再次来到带有钦点键值的键名。信任类型,数字 5 与字符串 “5”
是分裂的。    false – 暗中认可值。不正视类型,数字 5 与字符串 “5” 是同等的。

 

        $a=array(“Volvo”=>”XC90″,”BMW”=>”X5″,”Toyota”=>”Highlander”);

        array_keys($a卡塔尔(قطر‎;        运维结果:array(“0″=>”Volvo”,”1″=>”BMW”,”2″=>”Toyota”卡塔尔(قطر‎;

        array_keys($a,”奥迪Q3″卡塔尔;         运行结果:array(“0″=>”Toyota”卡塔尔;

        $a=array(10,20,30,”10″);

        array_keys($a,”10″,falseState of Qatar;     运转结果:array(“0″=>0,”1″=>3卡塔尔国;

        array_keys($a,”10″,trueState of Qatar;     运转结果:array(“0″=>3卡塔尔国;

 


  • array_map(myfunction,array1,array2,array3…)  把数组中的每种值发送到顾客自定义函数,再次来到新的值。 将客户自定义函数功效到数组中的各样值上,并赶回顾客自定义函数作用后的隐含新值的数组。 
         

        myfunction必须。顾客自定义函数的称呼,恐怕是 null。

        array1必须。规定数组。          array2可选。规定数组。        array3可选。规定数组。

 

        将函数名赋值为 null 时:

        $a1=array(“Dog”,”Cat”);$a2=array(“Puppy”,”Kitten”);array_map(null,$a1,$a2);

        运维结果:Array ( [0] => Array ( [0] => Dog [1]
=> Puppy ) [1] => Array ( [0] => Cat [1] => Kitten )
);


  • array_multisort(array1,sorting
    order,sorting type,array2,array3…卡塔尔(قطر‎     
    对四个数组或多维数组实行排序。     
     重返排序数组,您能够输入一个或七个数组。函数先对第叁个数组举办排序,接着是其它数组,倘若多少个或七个值相像,它将对下二个数组举办排序。 
         

        sorting order    可选。规定排列顺序。可能的值:    SORT_ASC –
暗中认可。按升序排列 (A-Z卡塔尔(قطر‎。    SORT_DESC – 按降序排列 (Z-A卡塔尔。

        sorting type    可选。规定排序类型。大概的值:

                SORT_REGULA陆风X8 – 默许。把各样按正常顺序排列(Standard
ASCII,不改造类型)。

                SORT_NUME君越IC – 把每一类作为数字来拍卖。

                SORT_ST昂CoraING – 把各类作为字符串来拍卖。

                SORT_LOCALE_STTiggoING –
把各种作为字符串来拍卖,基于当前区域安装(可透过 setlocale(卡塔尔进行改过)。

                SORT_NATURAL – 把每一类作为字符串来拍卖,使用近似natsort(卡塔尔 的自然排序。

                SORT_FLAG_CASE – 能够整合(按位或)SORT_STRING 或
SORT_NATURAL 对字符串进行排序,不区分轻重缓急写。

 

        注释:字符串键大将被保留,不过数字键老马被再次索引,从 0
早先,并以 1 依次增加。

    您可以在各样数组后安装排序依次和排序类型参数。若无设置,每一种数组参数会动用暗中同意值。

                  参数中的数组被当成二个表的列并以行来扩充排序 – 那看似
SQL 的 O宝马X5DE福睿斯 BY
子句的功力。第三个数组是要排序的首要数组。数组中的行(值)相比为同一的话,就能依照下二个输入数组中相应值的深浅举行排序,由此及彼。


        array_values(array卡塔尔    再次回到数组中保有的值。

        count(array,modeState of Qatar    
再次来到数组桐月素的多寡。

        sizeof(array,mode)     count() 的别名。

        compact(var1,var2…State of Qatar    创设包括变量名和它们的值的数组。

        extract(array,extract_rules,prefix卡塔尔    从数组中将变量导入到当前的符号表。

        in_array(search,array,typeState of Qatar    检查数组中是否存在钦赐的值。

        key(arrayState of Qatar    从涉嫌数组中收获键名。

       
range(low,high,step卡塔尔     创设包涵钦定范围单元的数组。

        shuffle(array卡塔尔    将数组打乱。    该函数为数组中的成分分配新的键名。本来就有键主力被去除

        array_pad(array,size,value卡塔尔国    用值将数组增补到钦赐长度。        即便您将 size
参数设置为负数,该函数会在原始数组此前插入新的要素。

        array_pop(array卡塔尔国    删除数组的末了贰个要素(出栈)。

        array_push(array,value1,value2…卡塔尔(قطر‎将叁个或八个成分插入数组的末梢(入栈)。

        array_shift(array卡塔尔(قطر‎     删除数组中第三个要素,并赶回被去除成分的值。    假诺键名是数字的,全体因素都会拿走新的键名,从
0 开首,并以 1 递增

        array_unshift(array,value1,value2,value3…State of Qatar    在数组起首插入三个或八个因素。    该函数会回去数组否月素的个数。

        array_product(arrayState of Qatar        计算数组中全体值的乘积。

        array_sum(arrayState of Qatar    重回数组中值的和。

        array_rand(array,number卡塔尔国        重临数组中贰个或两个随机的键名。

        array_reduce(array,myfunction,initial卡塔尔    通过选用客户自定义函数,以字符串重回数组。

        array_replace(array1,array2,array3…State of Qatar    使用后边数组的值替换第三个数组的值。

        array_replace_recursive(array1,array2,array3…卡塔尔     递归地使用前边数组的值替换第一个数组的值。

        array_merge(array1,array2,array3…卡塔尔(قطر‎    把叁个或三个数组合併为一个数组。

        array_merge_recursive(array1,array2,array3…卡塔尔    递归地统一三个或八个数组。

        array_reverse(array,preserve卡塔尔        以相反的依次再次来到数组。对于整数键名,假若第1个参数钦点为
true,则成分的键名保持不改变,不然键老将错失。

        array_search(value,array,strict卡塔尔(قطر‎        找寻数组中加以的值并重返键名。 

        array_slice(array,start,length,preserve卡塔尔国    重返数组中被选定的局地。

        array_splice(array,start,length,array卡塔尔国    删除并替换数组中钦点的要素。

        array_unique(array卡塔尔国    删除数组中的重复值。    当多少个数组元素的值极其时,只保留第贰个因素,其余的要素被删除。

        array_walk(array,myfunction,userdata…卡塔尔    对数组中的每一种成员使用顾客函数。

        array_walk_recursive(array,myfunction,parameter…State of Qatar    对数组中的种种成员递归地运用客户函数。

 


 

  • 排序

       arsort(array,sortingtype卡塔尔 
  对涉嫌数组根据键值进行降序排序。

       asort(array,sortingtype卡塔尔    对关联数组根据键值进行升序排序。

       krsort(array,sortingtype卡塔尔国   
对数组遵照键名逆向排序。

       ksort(array,sortingtype卡塔尔    对数组依照键名排序。

       natcasesort(array卡塔尔    用“自然排序”算法对数组进行不区分轻重缓急写字母的排序。

       natsort(array卡塔尔  
 用“自然排序”算法对数组排序。

       rsort(array,sortingtype卡塔尔    对数组逆向排序。

       sort(array,sortingtype卡塔尔国    对数组排序。 
 

       uasort(array,myfunction卡塔尔国   
使用客商自定义的相比函数对数组中的键值实行排序。

       uksort(array,myfunction卡塔尔国    使用顾客自定义的可比函数对数组中的键名进行排序。

       usort(array,myfunction卡塔尔(قطر‎    使用客户自定义的可比函数对数组进行排序。

 


 

  • 数组指针的移位

        current(array卡塔尔国    重临数组中的当前成分。

        each(arrayState of Qatar    重返数组中当前的键/值对。

        end(arrayState of Qatar    将数组的中间指针指向最终二个因素。

        prev(arrayState of Qatar    将数组的中间指针倒回一人。

        next(array卡塔尔国    将数组中的内部指针向前挪动壹人。

        reset(array卡塔尔    将数组的中间指针指向第三个成分。

        pos(array)    current()
的别名。

 

    注释: 如若数组包涵空的单元,大概单元的值是
0 则该函数境遇这几个单元也回到 FALSE。

             要正确遍历只怕含有空单元或许单元值为 0 的数组,请参见
each(卡塔尔国 函数。

    注释:each(卡塔尔(قطر‎函数重回当前成分的键名和键值,并将在那之中指针向前移动。

            该因素的键名和键值会被重回带有两个要素的数组中。三个成分(1
和 Value)包括键值,三个成分(0 和 Key)富含键名。

            假设内部指针超出了数组范围,本函数将回到 FALSE。  

 


 

  • 相比数组,再次来到差集

    array_diff(array1,array2,array3…卡塔尔(قطر‎     比较数组,重临差集(只相比键值)。

    array_diff_assoc(array1,array2,array3…卡塔尔  相比较数组,重回差集(相比较键名和键值)。

    array_diff_key(array1,array2,array3…卡塔尔国     比较数组,再次来到差集(只相比键名)。

    array_diff_uassoc(array1,array2,array3…,myfunction卡塔尔(قطر‎     比较数组,再次回到差集(相比键名和键值,使用客商自定义的键名相比函数)。

        array_udiff(array1,array2,array3…,myfunctionState of Qatar        比较数组,重返差集(只比较值,使用二个顾客自定义的键名相比较函数)。

        array_diff_ukey(array1,array2,array3…,myfunction) 
 相比数组,再次来到差集(只相比较键名,使用客商自定义的键名比较函数)。

        array_udiff_assoc(array1,array2,array3…,myfunction卡塔尔国    相比数组,再次回到差集(相比键和值,使用内建函数相比键名,使用客商自定义函数比较键值)。

        array_udiff_uassoc(array1,array2,array3…,myfunction_key,myfunction_value卡塔尔(قطر‎        相比较数组,重返差集(比较键和值,使用八个顾客自定义的键名比较函数)。

  • 相比数组,再次回到交集

    array_intersect(array1,array2,array3…卡塔尔(قطر‎     比较数组,再次来到交集(只相比较键值)。

    array_intersect_assoc(array1,array2,array3…卡塔尔(قطر‎      比较数组,重临交集(相比键名和键值)。

    array_intersect_key(array1,array2,array3…卡塔尔      相比数组,重回交集(只相比键名)。

    array_intersect_uassoc(array1,array2,array3…,myfunctionState of Qatar      比较数组,再次来到交集(相比较键名和键值,使用客商自定义的键名比较函数)。

                array_intersect_ukey(array1,array2,array3…,myfunction卡塔尔 比较数组,重返交集(只相比较键名,使用客户自定义的键名相比函数)。

               
array_uintersect(array1,array2,array3…,myfunction卡塔尔    相比数组,重返交集(只相比值,使用三个客户自定义的键名相比函数)。

                array_uintersect_assoc(array1,array2,array3…,myfunction卡塔尔国相比较数组,再次回到交集(相比键和值,使用内建函数相比键名,使用顾客自定义函数相比键值)。

                array_uintersect_uassoc(array1,array2,array3…,myfunction_key,myfunction_value卡塔尔国比较数组,再次来到交集(相比较键和值,使用五个客商自定义的键名相比较函数)。

发表评论

电子邮件地址不会被公开。 必填项已用*标注