php函数总结

最新推荐文章于 2024-04-23 22:47:07 发布
最新推荐文章于 2024-04-23 22:47:07 发布
阅读量217 收藏
点赞数
分类专栏： PHP 文章标签： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32017281/article/details/107677131
版权

字符串函数

trim

说明

trim ( string $str [, string $charlist = " \t\n\r\0\x0B" ] )

此函数返回字符串str去除首尾空白字符后的结果。如果不指定第二个参数， trim() 将去除这些字符：

  1. " " (ASCII 32 (0x20))，普通空格符。
  2. “\t” (ASCII 9 (0x09))，制表符。
  3. “\n” (ASCII 10 (0x0A))，换行符。
  4. “\r” (ASCII 13 (0x0D))，回车符。
  5. “\0” (ASCII 0 (0x00))，空字节符。
  6. “\x0B” (ASCII 11 (0x0B))，垂直制表符。
参数

  • str
    待处理的 字符串 。

  • charlist
    可选参数，过滤字符也可由charlist参数指定。一般要列出所有希望过滤的字符，也可以使用'..'列出一个字符范围。

返回值

过滤后的字符串。

case
 //    "        These are a few words :) ...  "
$text    =  "\t\tThese are a few words :) ...  " ;
/*
"    Example string
"
 */
 $binary  =  "\x09Example string\x0A" ;
 // "Hello World"
 $hello   =  "Hello World" ;

//    "These are a few words :) ..."
 $trimmed  =  trim ( $text );

//  "These are a few words :)"
 $trimmed  =  trim ( $text ,  " \t." );

//   "o Wor"
 $trimmed  =  trim ( $hello ,  "Hdle" );


 // 清除 $binary 首位的 ASCII 控制字符
// （包括 0-31）
 $clean  =  trim ( $binary ,  "\x00..\x1F" );  //  "Example string"

str_pad

说明

str_pad ( string $input , int $pad_length [, string $pad_string = " " [, int $pad_type = STR_PAD_RIGHT ]] )

该函数返回input被从左端、右端或者同时两端被填充到制定长度后的结果。如果可选的pad_string参数没有被指定，input将被空格字符填充，否则它将被`pad_string 填充到指定长度。

参数

  • input
    输入字符串。

  • pad_length
    如果pad_length的值是负数，小于或者等于输入字符串的长度，不会发生任何填充。

  • pad_string
    如果填充字符的长度不能被pad_string整除，那么pad_string可能会被缩短。

  • pad_type
    可选的pad_type参数的可能值为STR_PAD_RIGHT，STR_PAD_LEFT或STR_PAD_BOTH。如果没有指定pad_type，则假定它是STR_PAD_RIGHT。

返回值

返回填充后的字符串。

case
$input  =  "Alien" ;
echo  str_pad ( $input ,  10 );                       // 输出 "Alien     "
 echo  str_pad ( $input ,  10 ,  "-=" ,  STR_PAD_LEFT );   // 输出 "-=-=-Alien"
 echo  str_pad ( $input ,  10 ,  "_" ,  STR_PAD_BOTH );    // 输出 "__Alien___"
 echo  str_pad ( $input ,  6  ,  "___" );                // 输出 "Alien_"

str_repeat

说明

str_repeat ( string $input , int $multiplier )

返回input重复multiplier次后的结果。

参数

  • input
    待操作的字符串。

  • multiplier
    input被重复的次数。 multiplier必须大于等于0。如果multiplier被设置为0，函数返回空字符串。

返回值

返回重复后的字符串。

case
echo  str_repeat ( "-=" ,  10 );  // -=-=-=-=-=-=-=-=-=-=
echo str_repeat('a',0);     //   ''

str_split

说明

str_split ( string $string [, int $split_length = 1 ] )

将一个字符串转换为数组。

参数

  • string
    输入字符串。

  • split_length
    每一段的长度。

返回值

如果指定了可选的split_length参数，返回数组中的每个元素均为一个长度为split_length的字符块，否则每个字符块为单个字符。

如果split_length小于1，返回FALSE。如果split_length参数超过了string超过了字符串string的长度，整个字符串将作为数组仅有的一个元素返回。

case
$str  =  "Hello" ;
/**
Array
(
    [0] => H
    [1] => e
    [2] => l
    [3] => l
    [4] => o
)
 */
 $arr1  =  str_split ( $str );
 /**
Array
(
    [0] => Hel
    [1] => lo
)
  */
 $arr2  =  str_split ( $str ,  3 );

strrev

说明

strrev ( string $string )

返回string反转后的字符串。

参数
  • string
    待反转的原始字符串。
返回值

返回反转后的字符串。

case
echo  strrev ( "Hello world!" );  // 输出 "!dlrow olleH"

strtolower

说明

strtolower ( string $string )

将string中所有的字母字符转换为小写并返回。

参数
  • string
    输入字符串。
返回值

返回转换后的小写字符串。

case
//mary had a little lamb and she loved it so
echo strtolower ( $str );

strtoupper

说明

将string中所有的字母字符转换为大写并返回。

同strtolower

ucfirst

说明

ucfirst ( string $str )

将str的首字符（如果首字符是字母）转换为大写字母，并返回这个字符串。

参数
  • str
    输入字符串。
返回值

返回结果字符串

case
$foo  =  'hello world!' ;
 $foo  =  ucfirst ( $foo );              // Hello world!

 $bar  =  'HELLO WORLD!' ;
 $bar  =  ucfirst ( $bar );              // HELLO WORLD!
 $bar  =  ucfirst ( strtolower ( $bar ));  // Hello world!

lcfirst

说明

将str的首字符（如果首字符是字母）转换为小写字母，并返回这个字符串。
同ucfirst()

ucwords

说明

ucwords ( string $str )

将str中每个单词的首字符（如果首字符是字母）转换为大写字母，并返回这个字符串。
这里单词的定义是紧跟在空白字符（空格符、制表符、换行符、回车符、水平线以及竖线）之后的子字符串。

参数
  • str
    输入字符串。
返回值

返回转换后的字符串。

case
$foo  =  'hello world!' ;
 $foo  =  ucwords ( $foo );              // Hello World!

 $bar  =  'HELLO WORLD!' ;
 $bar  =  ucwords ( $bar );              // HELLO WORLD!
 $bar  =  ucwords ( strtolower ( $bar ));  // Hello World!

htmlentities

说明

htmlentities ( string $string )

把字符串转为 HTML 实体

参数
  • string
    输入字符串。
返回值

返回转换后的字符串。

case
$str  =  "A 'quote' is <b>bold</b>" ;

 //  A 'quote' is &lt;b&gt;bold&lt;/b&gt;
 echo  htmlentities ( $str );

strip_tags

说明

strip_tags ( string $str [, string $allowable_tags ] )

该函数尝试返回给定的字符串 str 去除空字符、HTML 和 PHP 标记后的结果。

参数

  • string
    输入字符串。

  • allowable_tags
    使用可选的第二个参数指定不被去除的字符列表。
    HTML 注释和 PHP 标签也会被去除。这里是硬编码处理的，所以无法通过 allowable_tags 参数进行改变。

返回值

返回处理后的字符串。

case
//  Test paragraph. Other text
$text  =  '<p>Test paragraph.</p><!-- Comment --> <a href="#fragment">Other text</a>' ;

 // 允许 <p> 和 <a>
 //  <p>Test paragraph.</p> <a href="#fragment">Other text</a>
 echo  strip_tags ( $text ,  '<p><a>' );

addcslashes

说明

addcslashes ( string $str )

在指定字符前添加反斜线转义字符串中字符

stripcslashes

说明

striplashes ( string $str )

删除addcslashes()添加的反斜线

ord

说明

ord ( string $string )

返回字符串string第一个字符的ASCII码值。

参数
  • string
    输入字符串。
返回值

返回整型的 ASCII 码值。

chr

说明

chr ( int $ascii )

返回相对应于ascii所指定的单个字符。

参数
  • string
    输入字符串。
返回值

返回规定的字符

strcasecmp

说明

strcasecmp ( string $str1 , string $str2 )

二进制安全比较字符串（不区分大小写）。

参数
  • str1
    第一个字符串。
  • str2
    第二个字符串。
返回值

如果str1小于str2返回< 0；如果str1大于str2返回> 0；如果两者相等，返回0。

chunk_split

说明

chunk_split ( string $body [, int $chunklen = 76 [, string $end = “\r\n” ]] )

使用此函数将字符串分割成小块。它会在每 chunklen 个字符后边插入 end。

参数

  • body
    要分割的字符。

  • chunklen
    分割的尺寸。

  • end
    行尾序列符号。

返回值

返回分割后的字符。

case
$str = "Yar?m kilo ?ay, yar?m kilo ?eker";
//  Yar? m ki lo ? ay, yar? m ki lo ? eker
echo chunk_split($str, 4);
//  Yar?_+_m ki_+_lo ?_+_ay, _+_yar?_+_m ki_+_lo ?_+_eker_+_
## explode

###### 说明

> explode ( string $delimiter , string $string [, int $limit ] )

此函数返回由字符串组成的数组，每个元素都是`string`的一个子串，它们被字符串`delimiter`作为边界点分割出来。

###### 参数

- delimiter
边界上的分隔字符

- chunklen
分割的尺寸。

- string
输入的字符串

- limit
如果设置了`limit`参数并且是正数，则返回的数组包含最多`limit`个元素，而最后那个元素将包含`string`的剩余部分。
如果`limit`参数是负数，则返回除了最后的`-limit`个元素外的所有元素。
如果`limit`是`0`，则会被当做`1`。


###### 返回值
返回分割后的字符。


###### case

```php
$pizza   =  "piece1 piece2 piece3 piece4 piece5 piece6" ;

//  array(6) { [0]=> string(6) "piece1" [1]=> string(6) "piece2" [2]=> string(6) "piece3" [3]=> string(6) "piece4" [4]=> string(6) "piece5" [5]=> string(6) "piece6" }
var_dump(explode(' ',$pizza));

//  array(2) { [0]=> string(6) "piece1" [1]=> string(34) "piece2 piece3 piece4 piece5 piece6" }
var_dump(explode(' ',$pizza,2));

//  array(4) { [0]=> string(6) "piece1" [1]=> string(6) "piece2" [2]=> string(6) "piece3" [3]=> string(6) "piece4" }
var_dump(explode(' ',$pizza,-2));

//  array(1) { [0]=> string(41) "piece1 piece2 piece3 piece4 piece5 piece6" }
var_dump(explode(' ',$pizza,0));

echo chunksplit($str, 4,’+_’);



## explode

###### 说明

> explode ( string $delimiter , string $string [, int $limit ] )

此函数返回由字符串组成的数组，每个元素都是`string`的一个子串，它们被字符串`delimiter`作为边界点分割出来。

###### 参数

- delimiter
边界上的分隔字符

- chunklen
分割的尺寸。

- string
输入的字符串

- limit
如果设置了`limit`参数并且是正数，则返回的数组包含最多`limit`个元素，而最后那个元素将包含`string`的剩余部分。
如果`limit`参数是负数，则返回除了最后的`-limit`个元素外的所有元素。
如果`limit`是`0`，则会被当做`1`。


###### 返回值
此函数返回由字符串组成的`array`，每个元素都是`string`的一个子串，它们被字符串`delimiter`作为边界点分割出来。

如果`delimiter`为空字符串`' '`，`explode()`将返回`FALSE`。如果`delimiter`所包含的值在`string`中找不到，并且使用了负数的`limit`，那么会返回空的`array`，否则返回包含`string`单个元素的数组。



###### case

```php
$pizza   =  "piece1 piece2 piece3 piece4 piece5 piece6" ;

//  array(6) { [0]=> string(6) "piece1" [1]=> string(6) "piece2" [2]=> string(6) "piece3" [3]=> string(6) "piece4" [4]=> string(6) "piece5" [5]=> string(6) "piece6" }
var_dump(explode(' ',$pizza));

//  array(2) { [0]=> string(6) "piece1" [1]=> string(34) "piece2 piece3 piece4 piece5 piece6" }
var_dump(explode(' ',$pizza,2));

//  array(4) { [0]=> string(6) "piece1" [1]=> string(6) "piece2" [2]=> string(6) "piece3" [3]=> string(6) "piece4" }
var_dump(explode(' ',$pizza,-2));

//  array(1) { [0]=> string(41) "piece1 piece2 piece3 piece4 piece5 piece6" }
var_dump(explode(' ',$pizza,0));

// array(0) { }
var_dump(explode('?', $pizza, -2));

// array(1) { [0]=> string(41) "piece1 piece2 piece3 piece4 piece5 piece6" }
var_dump(explode('?', $pizza));

implode

说明

implode ( string $glue , array $pieces )

implode ( array $pieces )

用glue将一维数组的值连接为一个字符串。

参数
  • glue
    默认为空的字符串。
  • pieces
    要转换的数组。
返回值

返回一个字符串，其内容为由glue分割开的数组的值。

case
$array = array('lastname', 'email', 'phone');
// lastname,email,phone
var_dump(implode(",", $array));

// Empty string when using an empty array:
// string(0) ""
var_dump(implode('hello', array()));

substr

说明

substr ( string $string , int $start [, int $length ] )

返回字符串string由start和length参数指定的子字符串。

参数
  • string
    输入字符串。
  • start
    如果start是非负数，返回的字符串将从string的start位置开始，从`0 开始计算。

如果start是负数，返回的字符串将从string结尾处向前数第start个字符开始。

如果string的长度小于或等于start，将返回FALSE。

  • length
    如果提供了正数的length，返回的字符串将从start处开始最多包括length个字符（取决于string的长度）。

如果提供了负数的length，那么string末尾处的许多字符将会被漏掉（若 start 是负数则从字符串尾部算起）。如果start不在这段文本中，那么将返回一个空字符串。

如果提供了值为0，FALSE或NULL的length，那么将返回一个空字符串。

如果没有提供length，返回的子字符串将从start位置开始直到字符串结尾。

返回值

返回提取的子字符串， 或者在失败时返回 FALSE 。

case
echo substr('abcdef', 1);      // bcdef
echo substr('abcdef', 1, 3);   // bcd

echo substr('abcdef', 0, 8);   // abcdef
echo substr('abcdef', -1, 1);  // f

str_replace

说明

str_replace ( mixed $search , mixed $replace , mixed KaTeX parse error: Expected 'EOF', got '&' at position 16: subject [, int &̲count ] )

该函数返回一个字符串或者数组。该字符串或数组是将subject中全部的search都被replace替换之后的结果。

如果没有一些特殊的替换需求（比如正则表达式），你应该使用该函数替换ereg_replace()和preg_replace()。

参数

如果search和replace为数组，那么str_replace()将对subject做二者的映射替换。如果replace的值的个数少于search的个数，多余的替换将使用空字符串来进行。如果search是一个数组而replace是一个字符串，那么search中每个元素的替换将始终使用这个字符串。该转换不会改变大小写。

  • search
    查找的目标值，也就是needle。一个数组可以指定多个目标。

  • replace
    search的替换值。一个数组可以被用来指定多重替换。

  • subject
    执行替换的数组或者字符串。也就是haystack。

如果subject是一个数组，替换操作将遍历整个subject，返回值也将是一个数组。

  • count
    如果被指定，它的值将被设置为替换发生的次数。
返回值

该函数返回替换后的数组或者字符串。

case
//  223
//echo str_replace("1", "2", "123");

//  Hll Wrld f PHP
$vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
//echo str_replace ( $vowels ,  "" ,  "Hello World of PHP" );


$phrase = "You should eat fruits, vegetables, and fiber every day.";
$healthy = array("fruits", "vegetables", "fiber");
$yummy1 = array("pizza", "beer", "ice cream");
//  You should eat pizza, beer, and ice cream every day.
//echo str_replace ( $healthy ,  $yummy1 ,  $phrase );

$yummy2 = array("pizza", "beer");
//  You should eat pizza, beer, and every day.
//echo str_replace ( $healthy ,  $yummy2 ,  $phrase );

$str = str_replace("ll", "", "good golly miss molly!", $count);
//  2
//echo $count;

str_ireplace

说明

str_replace()忽略大小写版本

substr_count

说明

substr_count ( string $haystack , string $needle [, int $offset = 0 [, int $length ]] )

返回子字符串needle在字符串haystack中出现的次数。注意needle区分大小写。该函数不会计算重叠字符串。

参数

  • haystack
    在此字符串中进行搜索。

  • needle
    要搜索的字符串。

  • offset
    开始计数的偏移位置。

  • length
    指定偏移位置之后的最大搜索长度。如果偏移量加上这个长度的和大于haystack的总长度，则打印警告信息。

返回值

该函数返回整型。

case

$text = 'This is a test';
echo strlen($text);  // 14

echo substr_count($text, 'is');  // 2

// 字符串被简化为 's is a test'，因此输出 1
echo substr_count($text, 'is', 3);

// 字符串被简化为 's i'，所以输出 0
echo substr_count($text, 'is', 3, 3);

// 因为 5+10 > 14，所以生成警告
echo substr_count($text, 'is', 5, 10);

// 输出 1，因为该函数不计算重叠字符串
$text2 = 'gcdgcdgcd';
echo substr_count($text2, 'gcdgcd');

substr_replace

说明

substr_replace ( mixed $string , mixed $replacement , mixed $start [, mixed $length ] )

substr_replace()在字符串string的副本中将由start和可选的length参数限定的子字符串使用replacement进行替换。

参数

  • string
    输入字符串。

  • replacement
    替换字符串。

  • start
    如果start为正数，替换将从string的start位置开始。

如果start为负数，替换将从string的倒数第start个位置开始。

  • length
    如果设定了这个参数并且为正数，表示string中被替换的子字符串的长度。如果设定为负数，它表示待替换的子字符串结尾处距离string末端的字符个数。如果没有提供此参数，那么它默认为strlen( string ) （字符串的长度）。当然，如果length为0，那么这个函数的功能为将replacement插入到string的start位置处。
返回值

返回结果字符串。如果string是个数组，那么也将返回一个数组。

case
$var = 'ABCDEFGH:/MNRPQR/';
//  bob
echo substr_replace($var, 'bob', 0);
//  bob
echo substr_replace($var, 'bob', 0, strlen($var));
//  bobABCDEFGH:/MNRPQR/
echo substr_replace($var, 'bob', 0, 0);
//  ABCDEFGH:/bob/
echo substr_replace($var, 'bob', 10, -1);
//  ABCDEFGH:/bob/
echo substr_replace($var, 'bob', -7, -1);
//  ABCDEFGH://
echo substr_replace($var, '', 10, -1);

similar_text

说明

similar_text ( string $first , string KaTeX parse error: Expected 'EOF', got '&' at position 17: …econd [, float &̲percent ] )
计算两个字符串的相似度

参数

  • first
    第一个字符串。

  • second
    第二个字符串。

  • percent
    通过引用方式传递第三个参数，similar_text()将计算相似程度百分数。

返回值

返回在两个字符串中匹配字符的数目。

case
$var1 = 'Hello';
$var2 = 'Hello';
$var3 = 'hello';
// 5
echo similar_text($var1, $var2);
// 4
echo similar_text($var1, $var3);

$var_1 = 'PHP IS GREAT';
$var_2 = 'WITH MYSQL';
// 计算公式为相同字符长度*2/两段字符的总长度
similar_text($var_1, $var_2, $percent);
// 27.272727272727
echo $percent;
// 18.181818181818
similar_text($var_2, $var_1, $percent);
echo $percent;

strstr

说明

strstr ( string $haystack , mixed $needle [, bool $before_needle = false ] )
返回haystack字符串从needle第一次出现的位置开始到haystack结尾的字符串。

参数

  • haystack
    输入字符串。

  • needle
    如果needle不是一个字符串，那么它将被转化为整型并且作为字符的序号来使用。

  • before_needle
    若为TRUE，strstr()将返回needle在haystack中的位置之前的部分。

返回值

返回字符串的一部分或者FALSE（如果未发现 needle）。

case
$email = 'name@example.com';
//  @example.com
echo strstr($email, '@');
//  name
echo strstr($email, '@', true);

stristr

说明

strstr()忽略大小写版本

strrchr

说明

strrchr ( string $haystack , mixed $needle )

该函数返回haystack字符串中的一部分，这部分以needle的最后出现位置开始，直到haystack末尾。

参数

  • haystack
    在该字符串中查找。

  • needle
    如果needle包含了不止一个字符，那么仅使用第一个字符。该行为不同于strstr()。

如果needle不是一个字符串，那么将被转化为整型并被视为字符顺序值。

返回值

返回字符串的一部分或者FALSE（如果未发现 needle）。

case
$path = '/www/public_html/index.html';
//  /index.html
echo strrchr($path, "/");

strtr

说明

strtr ( string $str , string $from , string $to )

strtr ( string $str , array $replace_pairs )

该函数返回str的一个副本，并将在from中指定的字符转换为to中相应的字符。比如，$from[$n]中每次的出现都会被替换为$to[$n]，其中$n是两个参数都有效的位移(offset)。

如果from与to长度不相等，那么多余的字符部分将被忽略。str的长度将会和返回的值一样。

参数

  • str
    待转换的字符串 。

  • from
    字符串中与将要被转换的目的字符to相对应的源字符。

  • to
    字符串中与将要被转换的字符from相对应的目的字符。

  • replace_pairs
    参数replace_pairs可以用来取代to和from参数，因为它是以array('from' => 'to', ...)格式出现的数组。

返回值

返回转换后的字符串。

如果replace_pairs中包含一个空字符串（""）键，那么将返回FALSE。

case
$trans = array("hello" => "hi", "hi" => "hello");
//  hello all, I said hi
echo strtr("hi all, I said hello", $trans);

// 1001
echo strtr("baab", "ab", "01");

$trans = array("ab" => "01");
//  ba01
echo strtr("baab", $trans);

strpos

说明

strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )

返回needle在haystack中首次出现的数字位置。

参数

  • haystack
    在该字符串中进行查找。

  • needle
    如果needle不是一个字符串，那么它将被转换为整型并被视为字符的顺序值。

  • offset
    如果提供了此参数，搜索会从字符串该字符数的起始位置开始统计。和strrpos()、strripos()不一样，这个偏移量不能是负数。

返回值

返回转换后的字符串。

返回needle存在于haystack字符串起始的位置(独立于 offset)。同时注意字符串位置是从0开始，而不是从1开始的。

如果没找到needle，将返回FALSE

此函数可能返回布尔值FALSE，但也可能返回等同于FALSE的非布尔值。应使用===运算符来测试此函数的返回值。

case
$mystring = 'abc';
$findme = 'a';
//  0    注意这里使用的是 ===。简单的 == 无法判断,因为 'a' 是第 0 位置上的（第一个）字符。
echo strpos($mystring, $findme);


$mystring = 'abc';
$findme = 'a';
//  0  使用 !== 操作符。使用 != 无法判断，因为 'a' 的位置是 0。语句 (0 != false) 的结果是 false。
echo strpos($mystring, $findme);

// 忽视位置偏移量之前的字符进行查找
$newstring = 'abcdef abcdef';
// $pos = 7, 不是 0
echo strpos($newstring, 'a', 1);

stripos

说明

strpos()忽略大小写

strrpos

说明

返回字符串haystack中needle最后一次出现的数字位置。其它同strpos()

strripos

说明

strrpos()忽略大小写

strlen

说明

strlen ( string $string )

返回给定的字符串string的长度。

参数
  • string
    需要计算长度的字符串。
返回值

成功则返回字符串string的长度；如果string为空，则返回0。

case
$str = 'abcdef';
echo strlen($str);  // 6

array_combin

说明

array_combine ( array $keys , array $values )

返回一个array，用来自keys数组的值作为键名，来自values数组的值作为相应的值。

参数
  • keys
    将被作为新数组的键。非法的值将会被转换为字符串类型（ string ）。
  • values
    将被作为数组的值。
返回值

返回合并的array，如果两个数组的单元数不同则返回FALSE并且抛出E_WARNING。

case
$a  = array( 'green' ,  'red' ,  'yellow' );
 $b  = array( 'avocado' ,  'apple' ,  'banana' );
 // array(3) { ["green"]=> string(7) "avocado" ["red"]=> string(5) "apple" ["yellow"]=> string(6) "banana" }
var_dump(array_combine ( $a ,  $b ));

 $b  = array( 'avocado' ,  'apple'  );

//Warning: array_combine(): Both parameters should have an equal number of elements
//bool(false)
 var_dump(array_combine ( $a ,  $b ));

range

说明

range( mixed $start , mixed $limit [, number $step = 1 ] )

建立一个包含指定范围单元的数组。

参数
  • start
    序列的第一个值。

  • limit
    序列结束于 limit 的值。

  • step
    如果给出了step的值，它将被作为单元之间的步进值。step应该为正值。如果未指定，step则默认为1。

返回值

返回的数组中从 start 到 limit 的单元，包括它们本身。

case
//  array(6) { [0]=> int(0) [1]=> int(1) [2]=> int(2) [3]=> int(3) [4]=> int(4) [5]=> int(5) }
var_dump(range ( 0 ,  5 ));

//  array(3) { [0]=> int(0) [1]=> int(2) [2]=> int(4) }
var_dump(range ( 0 ,  5,2 ));

//   array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" }
var_dump(range ( 'a' ,  'd' ));


//  array(2) { [0]=> string(1) "a" [1]=> string(1) "c" }
var_dump(range ( 'a' ,  'd',2 ));

array_fill

说明

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

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

参数
  • start_index
    返回的数组的第一个索引值。
    如果start_index是负数，那么返回的数组的第一个索引将会是start_index，而后面索引则从0开始。

  • num
    插入元素的数量。必须大于0

  • value
    用来填充的值。

返回值

返回填充后的数组。

错误／异常

如果 num 少于一个，将会抛出 E_WARNING 。

case
// array(2) { [5]=> string(6) "banana" [6]=> string(6) "banana" }
var_dump(array_fill ( 5 ,  2 ,  'banana' ));
// array(4) { [-2]=> string(4) "pear" [0]=> string(4) "pear" [1]=> string(4) "pear" [2]=> string(4) "pear" }
var_dump(array_fill (- 2 ,  4 ,  'pear' ));

array_chunk

说明

array_chunk ( array $input , int $size [, bool $preserve_keys = false ] )

将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。

参数
  • input
    需要操作的数组

  • size
    每个数组的单元数目

  • preserve_keys
    设为TRUE，可以使 PHP 保留输入数组中原来的键名。如果你指定了FALSE，那每个结果数组将用从0开始的新数字索引。默认值是FALSE。

返回值

得到的数组是一个多维数组中的单元，其索引从零开始，每一维包含了size个元素。

错误／异常

如果size小于1，会抛出一个E_WARNING错误并返回NULL。

case
$input_array  = array( 'a' ,  'b' ,  'c' ,  'd' ,  'e' );
//  array(3) { [0]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "b" } [1]=> array(2) { [0]=> string(1) "c" [1]=> string(1) "d" } [2]=> array(1) { [0]=> string(1) "e" } }
 var_dump ( array_chunk ( $input_array ,  2 ));
 //  array(3) { [0]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "b" } [1]=> array(2) { [2]=> string(1) "c" [3]=> string(1) "d" } [2]=> array(1) { [4]=> string(1) "e" } }
 var_dump ( array_chunk ( $input_array ,  2 ,  true ));

array_merge

说明

array_merge ( array $array1 [, array $… ] )

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

如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。

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

参数
  • array1

要合并的初始数组

  • …

要合并的数组的变量列表。

返回值

返回结果数组。

case
$array1  = array( "color"  =>  "red" ,  2 ,  4 );
 $array2  = array( "a" ,  "b" ,  "color"  =>  "green" ,  "shape"  =>  "trapezoid" ,  4 );
 // array(7) { ["color"]=> string(5) "green" [0]=> int(2) [1]=> int(4) [2]=> string(1) "a" [3]=> string(1) "b" ["shape"]=> string(9) "trapezoid" [4]=> int(4)
var_dump(array_merge ( $array1 ,  $array2 ));

array_slice

说明

array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )

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

参数
  • array

输入的数组。

  • offset

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

  • length

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

  • preserve_keys

默认会重新排序并重置数组的数字索引。可以通过将preserve_keys设为TRUE来改变此行为。

返回值

返回结果数组。

case
$input  = array( "a" ,  "b" ,  "c" ,  "d" ,  "e" );

 $output  =  array_slice ( $input ,  2 );       // returns "c", "d", and "e"
 $output  =  array_slice ( $input , - 2 ,  1 );   // returns "d"
 $output  =  array_slice ( $input ,  0 ,  3 );    // returns "a", "b", and "c"

/**
 Array
(
    [0] => c
    [1] => d
)
 */
 print_r ( array_slice ( $input ,  2 , - 1 ));

 /**
 /**
Array
(
    [2] => c
    [3] => d
)
 */
  */
 print_r ( array_slice ( $input ,  2 , - 1 ,  true ));

array_diff

说明

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

对比返回在array1中但是不在array2及任何其它参数数组中的值。

参数
  • array1

要被对比的数组

  • array2

和这个数组进行比较

  • …

更多相比较的数组

返回值

返回一个数组，该数组包括了所有在array1中但是不在任何其它参数数组中的值。注意键名保留不变。

case
$array1  = array( "a"  =>  "green" ,  "red" ,  "blue" ,  "red" );
 $array2  = array( "b"  =>  "green" ,  "yellow" ,  "red" );
 /**
  Array
(
    [1] => blue
)
  */
 print_r(array_diff ( $array1 ,  $array2 ));

array_intersect

说明

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

array_intersect()返回一个数组，该数组包含了所有在array1中也同时出现在所有其它参数数组中的值。注意键名保留不变。

参数
  • array1

要被对比的数组

  • array2

和这个数组进行比较

  • …

更多相比较的数组

返回值

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

case
$array1  = array( "a"  =>  "green" ,  "red" ,  "blue" ,  "red" );
 $array2  = array( "b"  =>  "green" ,  "yellow" ,  "red" );
 /**
Array
(
    [a] => green
    [0] => red
)
  */
 print_r(array_intersect ( $array1 ,  $array2 ));

array_search

说明

array_search ( mixed $needle , array $haystack [, bool $strict = false ] )

在haystack中搜索needle参数。

参数
  • needle

搜索的值
如果needle是字符串，则比较以区分大小写的方式进行。

  • haystack

这个数组。

  • strict

如果可选的第三个参数strict为TRUE，则array_search()将在haystack中检查完全相同的元素。这意味着同样检查haystack里needle的类型，并且对象需是同一个实例。

返回值

如果找到了needle则返回它的键，否则返回FALSE。

如果needle在haystack中出现不止一次，则返回第一个匹配的键。要返回所有匹配值的键，应该用array_keys()加上可选参数search_value来代替。

此函数可能返回布尔值FALSE，但也可能返回等同于FALSE的非布尔值。

case
$array  = array( 0  =>  'blue' ,  1  =>  'red' ,  2  =>  'green' ,  3  =>  'red' );

 $key  =  array_search ( 'green' ,  $array );  // $key = 2;
 $key  =  array_search ( 'red' ,  $array );    // $key = 1;

array_splice

说明

array_splice ( array &$input , int $offset [, int $length = 0 [, mixed $replacement ]] )

把input数组中由offset和length指定的单元去掉，如果提供了replacement参数，则用其中的单元取代。

input中的数字键名不被保留。

参数
  • input

输入的数组。

  • offset

如果offset为正，则从input数组中该值指定的偏移量开始移除。如果offset为负，则从input末尾倒数该值指定的偏移量开始移除。

  • length

如果省略length，则移除数组中从offset到结尾的所有部分。如果指定了length并且为正值，则移除这么多单元。如果指定了length并且为负值，则移除从offset到数组末尾倒数length为止中间所有的单元。
当给出了replacement时要移除从offset到数组末尾所有单元时，用count($input)作为length。

  • replacement

如果给出了replacement数组，则被移除的单元被此数组中的单元替代。

如果offset和length的组合结果是不会移除任何值，则replacement数组中的单元将被插入到offset指定的位置。 注意替换数组中的键名不保留。

如果用来替换replacement只有一个单元，那么不需要给它加上array()，除非该单元本身就是一个数组、一个对象或者NULL。

返回值

返回一个包含有被移除单元的数组。

case
$input  = array( "red" ,  "green" ,  "blue" ,  "yellow" );
 array_splice ( $input ,  2 );
 // $input is now array("red", "green")

 $input  = array( "red" ,  "green" ,  "blue" ,  "yellow" );
 array_splice ( $input ,  1 , - 1 );
 // $input is now array("red", "yellow")

 $input  = array( "red" ,  "green" ,  "blue" ,  "yellow" );
 array_splice ( $input ,  1 ,  count ( $input ),  "orange" );
 // $input is now array("red", "orange")

 $input  = array( "red" ,  "green" ,  "blue" ,  "yellow" );
 array_splice ( $input , - 1 ,  1 , array( "black" ,  "maroon" ));
 // $input is now array("red", "green",
//          "blue", "black", "maroon")

 $input  = array( "red" ,  "green" ,  "blue" ,  "yellow" );
 array_splice ( $input ,  3 ,  0 ,  "purple" );
 // $input is now array("red", "green",
//          "blue", "purple", "yellow");

array_sum

说明

array_sum ( array $array )

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

参数
  • array

输入的数组。

返回值

所有值的和以整数或浮点数的结果返回。

case
// 20
$a  = array( 2 ,  4 ,  6 ,  8 );

// 6.9
 $b  = array( "a"  =>  1.2 ,  "b"  =>  2.3 ,  "c"  =>  3.4 );

in_array

说明

in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )

检查数组中是否存在某个值

参数
  • needle

待搜索的值。 如果needle是字符串，则比较是区分大小写的。

  • haystack

这个数组。

  • strict

如果第三个参数strict的值为TRUE则检查needle的类型是否和haystack中的相同。

返回值

如果找到needle则返回TRUE，否则返回FALSE。

case

$os  = array( "Mac" ,  "NT" ,  "Irix" ,  "Linux" );
// bool(true)
var_dump(in_array ( "Irix" ,  $os ));

$a  = array( '1.10' ,  12.4 ,  1.13 );
//  bool(false)
var_dump(in_array ( '12.4' ,  $a ,  true ));

next

说明

next ( array &$array )

将数组中的内部指针向前移动一位

参数
  • array

受影响的array。

返回值

返回数组内部指针指向的下一个单元的值，或当没有更多单元时返回 FALSE 。

Warning

此函数可能返回布尔值 FALSE ，但也可能返回等同于 FALSE 的非布尔值。

prev

说明

prev ( array &$array )

将数组的内部指针倒回一位

参数
  • array

受影响的array。

返回值

返回数组内部指针指向的前一个单元的值，或当没有更多单元时返回 FALSE 。

Warning

此函数可能返回布尔值 FALSE ，但也可能返回等同于 FALSE 的非布尔值。

reset

说明

reset ( array &$array )

将数组的内部指针指向第一个单元

参数
  • array

受影响的array。

返回值

返回数组第一个单元的值，如果数组为空则返回 FALSE 。

end

说明

end ( array &$array )

将数组的内部指针指向最后一个单元

参数
  • array

受影响的array。

返回值

返回数组第一个单元的值，如果数组为空则返回 FALSE 。

list

说明

list ( mixed $varname [, mixed $… ] )

把数组中的值赋给一些变量(语言结构)

参数
  • varname

变量

返回值

返回指定的数组。回 FALSE 。

case
$info  = array( 'coffee' ,  'brown' ,  'caffeine' );

 // 列出所有变量
 list( $drink ,  $color ,  $power ) =  $info ;


 // 列出他们的其中一个
 list( $drink , ,  $power ) =  $info ;


 // 或者让我们跳到仅第三个
 list( , ,  $power ) =  $info ;


 // list() 不能对字符串起作用
 list( $bar ) =  "abcde" ;
 var_dump ( $bar );  // NULL

array_shift

说明

array_shift ( array &$array )

将array的第一个单元移出并作为结果返回，将array的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变。

参数
  • array

输入的数组。

返回值

返回移出的值，如果array为空或不是一个数组则返回NULL。

case
$stack  = array( "orange" ,  "banana" ,  "apple" ,  "raspberry" );
 $fruit  =  array_shift ( $stack );
 /**
  Array
(
    [0] => banana
    [1] => apple
    [2] => raspberry
)
  */
 // 并且 orange 被赋给了 $fruit 。
 print_r ( $stack );

array_pop

说明

array_pop ( array &$array )

弹出并返回array数组的最后一个单元，并将数组array的长度减一。如果array为空（或者不是数组）将返回NULL。此外如果被调用不是一个数组则会产生一个Warning。

参数
  • array

需要做出栈的数组。

返回值

返回移出的值，如果array为空或不是一个数组则返回NULL。

case
$stack  = array( "orange" ,  "banana" ,  "apple" ,  "raspberry" );
 $fruit  =  array_pop ( $stack );
 /**
  Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
  */
 //  并且 rasberry 将被赋给 $fruit 。
 print_r ( $stack );

array_unshift

说明

array_unshift ( array &$array , mixed $var [, mixed $… ] )

将传入的单元插入到array数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变。

参数
  • array

输入的数组。

  • var

开头插入的变量。

返回值

返回 array 数组新的单元数目。

case
$queue  = array( "orange" ,  "banana" );
//  4
 echo array_unshift ( $queue ,  "apple" ,  "raspberry" );

array_push

说明

array_push ( array &$array , mixed $var [, mixed $… ] )

将array当成一个栈，并将传入的变量压入array的末尾。array的长度将根据入栈变量的数目增加。

参数
  • array

输入的数组。

  • var

要压入的值。

返回值

返回处理之后数组的元素个数。。

case
$stack  = array( "orange" ,  "banana" );
// 4
echo array_push ( $stack ,  "apple" ,  "raspberry" );

shuffle

说明

shuffle ( array &$array )

将数组打乱

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

count

说明

count ( mixed $var [, int $mode = COUNT_NORMAL ] )

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

参数
  • var

数组或者对象。

  • mode

如果可选的mode参数设为1，count()将递归地对数组计数。对计算多维数组的所有单元尤其有用。mode的默认值是0。count()识别不了无限递归。

返回值

返回var中的单元数目。如果var不是数组类型或者实现了Countable接口的对象，将返回1，如果var是NULL则结果是0。count()对没有初始化的变量返回0，但对于空数组也会返回0。

case

$b [ 0 ]  =  7 ;
 $b [ 5 ]  =  9 ;
 $b [ 10 ] =  11 ;
 //  3
echo count ( $b );

//  0
echo count ( null );

// 1
echo count ( false );


$food  = array( 'fruits'  => array( 'orange' ,  'banana' ,  'apple' ),
               'veggie'  => array( 'carrot' ,  'collard' ,  'pea' ));

//  8
 echo  count ( $food ,  COUNT_RECURSIVE );

// 2
 echo  count ( $food );

array_flip

说明

array_flip ( array $trans )

array_flip()返回一个反转后的array

注意trans中的值需要能够作为合法的键名，如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转。

如果同一个值出现了多次，则覆盖前面的。

参数
  • trans

要交换键/值对的数组。

返回值

成功时返回交换后的数组，如果失败返回NULL。

case

$trans  = array( "a"  =>  1 ,  "b"  =>  1 ,  "c"  =>  2 );
 $trans  =  array_flip ( $trans );
 /**
  Array
(
    [1] => b
    [2] => c
)
  */
 var_dump ( $trans );

array_keys

说明

array_keys ( array $array [, mixed $search_value [, bool $strict = false ]] )

返回数组中部分的或所有的键名

参数
  • input

一个数组，包含了要返回的键。

  • search_value

如果指定了这个参数，只有包含这些值的键才会返回。

  • strict

判断在搜索的时候是否该使用严格的比较（===）。

返回值

返回input里的所有键。

case
$array  = array( 0  =>  100 ,  "color"  =>  "red" );
/**
 Array
(
    [0] => 0
    [1] => color
)
 */
 print_r ( array_keys ( $array ));

 $array  = array( "blue" ,  "red" ,  "green" ,  "blue" ,  "blue" );
 /**
  Array
(
    [0] => 0
    [1] => 3
    [2] => 4
)
  */
 print_r ( array_keys ( $array ,  "blue" ));

 $array  = array( "color"  => array( "blue" ,  "red" ,  "green" ),
                "size"   => array( "small" ,  "medium" ,  "large" ));
 /**
  Array
(
    [0] => color
    [1] => size
)
  */
 print_r ( array_keys ( $array ));

array_values

说明

array_values ( array $input )

返回数组中所有的值并给其建立数字索引。

参数
  • input

数组。

返回值

返回含所有值的索引数组。

case
$array  = array( "size"  =>  "XL" ,  "color"  =>  "gold" );
/**
 Array
(
    [0] => XL
    [1] => gold
)
 */
 print_r ( array_values ( $array ));

array_count_values

说明

array_count_values ( array $input )

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

参数
  • input

数组。

返回值

返回一个关联数组，用input数组中的值作为键名，该值在数组中出现的次数作为值。

错误／异常

对数组里面的每个不是string和integer类型的元素抛出一个警告错误（ E_WARNING ）。

case
$array  = array( 1 ,  "hello" ,  1 ,  "world" ,  "hello" );
/**
 Array
(
    [1] => 2
    [hello] => 2
    [world] => 1
)
 */
 print_r ( array_count_values ( $array ));

array_reverse

说明

array_reverse ( array $array [, bool $preserve_keys = false ] )

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

参数
  • array

数组。

  • preserve_keys

如果设置为TRUE会保留数字的键。非数字的键则不受这个设置的影响，总是会被保留。

返回值

返回反转后的数组。

case
$input   = array( "php" ,  4.0 , array( "green" ,  "red" ));
/**
Array
(
    [0] => Array
        (
            [0] => green
            [1] => red
        )
    [1] => 4
    [2] => php
)
 */
 $result  =  array_reverse ( $input );
 /**
Array
(
    [2] => Array
        (
            [0] => green
            [1] => red
        )
    [1] => 4
    [0] => php
)

  */
 $result_keyed  =  array_reverse ( $input ,  true );

array_rand

说明

array_rand ( array $input [, int $num_req = 1 ] )

从数组中取出一个或多个随机的单元，并返回随机条目的一个或多个键。

参数
  • input

输入的数组。

  • num_req

取出多少个单元。如果指定的数目超过数组里的数量将会产生一个E_WARNING级别的错误。

返回值

只取出一个，返回一个随机单元的键名，否则就返回一个包含随机键名的数组。这样你就可以随机从数组中取出键名和值。

case
$input  = array( "Neo" ,  "Morpheus" ,  "Trinity" ,  "Cypher" ,  "Tank" );
//  array(2) { [0]=> int(3) [1]=> int(4) }
var_dump(array_rand ( $input ,  2 ));

array_unique

说明

array_unique ( array $array [, int $sort_flags = SORT_STRING ] )

移除数组中重复的值

注意键名保留不变。 array_unique()先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。

当且仅当(string) $elem1 === (string) $elem2时两个单元被认为相同。就是说，当字符串的表达一样时。第一个单元将被保留。

参数
  • input

输入的数组。

返回值

返回已筛选的数组。

case
$input  = array( "a"  =>  "green" ,  "red" ,  "b"  =>  "green" ,  "blue" ,  "red" );
 $result  =  array_unique ( $input );
 /**
  Array
(
    [a] => green
    [0] => red
    [1] => blue
)
  */
 print_r ( $result );

sort

说明

升序对数组值进行排序,不保留键名

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

case
$arr = array( "lemon" ,  "orange" ,  "banana" ,  "apple" );

sort($arr);
//  array(4) { [0]=> string(5) "apple" [1]=> string(6) "banana" [2]=> string(5) "lemon" [3]=> string(6) "orange" }
var_dump($arr);

rsort

说明

降序对数组值进行排序,不保留键名

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( "lemon" ,  "orange" ,  "banana" ,  "apple" );

rsort($arr);
//  array(4) { [0]=> string(6) "orange" [1]=> string(5) "lemon" [2]=> string(6) "banana" [3]=> string(5) "apple" }
var_dump($arr);

asort

说明

升序对数组值进行排序

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。


$arr = array( "d"  =>  "lemon" ,  "a"  =>  "orange" ,  "b"  =>  "banana" ,  "c"  =>  "apple" );

asort($arr);
//  array(4) { ["c"]=> string(5) "apple" ["b"]=> string(6) "banana" ["d"]=> string(5) "lemon" ["a"]=> string(6) "orange" }
var_dump($arr);

arsort

说明

降序对数组值进行排序

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( "d"  =>  "lemon" ,  "a"  =>  "orange" ,  "b"  =>  "banana" ,  "c"  =>  "apple" );

arsort($arr);
//  array(4) { ["a"]=> string(6) "orange" ["d"]=> string(5) "lemon" ["b"]=> string(6) "banana" ["c"]=> string(5) "apple" }
var_dump($arr);

ksort

说明

升序对数组键进行排序

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( "d" => "lemon" ,  "a" => "orange" ,  "b" => "banana" ,  "c" => "apple" );

ksort($arr);
//  array(4) { ["a"]=> string(6) "orange" ["b"]=> string(6) "banana" ["c"]=> string(5) "apple" ["d"]=> string(5) "lemon" }
var_dump($arr);

krsort

说明

降序对数组键进行排序

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( "d" => "lemon" ,  "a" => "orange" ,  "b" => "banana" ,  "c" => "apple" );

krsort($arr);
//  array(4) { ["d"]=> string(5) "lemon" ["c"]=> string(5) "apple" ["b"]=> string(6) "banana" ["a"]=> string(6) "orange" }
var_dump($arr);

natsort

说明

用自然顺序对数组进行排序

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( "img12.png" ,  "img10.png" ,  "img2.png" ,  "img1.png" );

natsort($arr);
//  array(4) { [3]=> string(8) "img1.png" [2]=> string(8) "img2.png" [1]=> string(9) "img10.png" [0]=> string(9) "img12.png" }
var_dump($arr);

natcasesort

说明

用自然顺序对数组进行排序,不区分大小写

参数
  • array

输入的数组。

返回值

成功时返回TRUE， 或者在失败时返回FALSE。

$arr = array( 'IMG0.png' ,  'img12.png' ,  'img10.png' ,  'img2.png' ,  'img1.png' ,  'IMG3.png' );

natcasesort($arr);
//  array(6) { [0]=> string(8) "IMG0.png" [4]=> string(8) "img1.png" [3]=> string(8) "img2.png" [5]=> string(8) "IMG3.png" [2]=> string(9) "img10.png" [1]=> string(9) "img12.png" }
var_dump($arr);

array_change_key_case

说明

array_change_key_case ( array $input [, int $case = CASE_LOWER ] )

将数组中的所有键名改为全小写或大写。改变是根据后一个选项case参数来进行的。本函数不改变数字索引。

参数
  • input

输入的数组。

  • case

可以在这里用两个常量，CASE_UPPER或CASE_LOWER（默认值）。

返回值

返回一个键全是小写或者全是大写的数组；如果输入值（input）不是一个数组，那么返回FALSE

错误／异常

如果输入值（input）不是一个数组，就会抛出一个错误警告（ E_WARNING ）。

case
$input_array  = array( "FirSt"  =>  1 ,  "SecOnd"  =>  4 );
/**
 Array ( [FIRST] => 1 [SECOND] => 4 )
 */
 print_r ( array_change_key_case ( $input_array ,  CASE_UPPER ));

array_fill_keys

说明

array_fill_keys ( array $keys , mixed $value )

使用value参数的值作为值，使用keys数组的值作为键来填充一个数组。

参数
  • keys

使用该数组的值作为键。非法值将被转换为字符串。

  • value

填充使用的值。

返回值

返回填充后的数组。

case
$keys  = array( 'foo' ,  5 ,  10 ,  'bar' );
 $a  =  array_fill_keys ( $keys ,  'banana' );
 //  Array ( [foo] => banana [5] => banana [10] => banana [bar] => banana )
 print_r ( $a );

array_filter

说明

array_filter ( array $input [, callable $callback = “” ] )

依次将input数组中的每个值传递到callback函数。如果callback函数返回TRUE，则input数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。

参数
  • input

要循环的数组

  • callback

如果没有提供callback函数，将删除input中所有等值为FALSE的条目。

返回值

返回过滤后的数组。

case
function  odd ( $var )
{
     // returns whether the input integer is odd
     return( $var  &  1 );
}

function  even ( $var )
{
     // returns whether the input integer is even
     return(!( $var  &  1 ));
}

 $array1  = array( "a" => 1 ,  "b" => 2 ,  "c" => 3 ,  "d" => 4 ,  "e" => 5 );
 $array2  = array( 6 ,  7 ,  8 ,  9 ,  10 ,  11 ,  12 );

/**
 Array ( [a] => 1 [c] => 3 [e] => 5 )
 */
 print_r ( array_filter ( $array1 ,  "odd" ));
/**
 Array ( [0] => 6 [2] => 8 [4] => 10 [6] => 12 )
 */
 print_r ( array_filter ( $array2 ,  "even" ));

array_product

说明

array_product ( array $array )

以整数或浮点数返回一个数组中所有值的乘积。

参数
  • array

这个数组。

返回值

以整数或浮点数返回一个数组中所有值的乘积。

case
//  384
echo array_product(array( 2 ,  4 ,  6 ,  8 ));
//  1
echo array_product(array());
一觀者也
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP常用函数总结
muwenbofx的博客
10-19 3318
文章目录​​​​ 目录 文章目录​​​​ 一、数字函数 二、字符串 提示：以下是本篇文章正文内容，下面案例可供参考 一、数字函数 1.abs() 函数返回一个数的绝对值。示例：echo abs(-4.2); 输出 4.2 2.ceil()函数向上舍入为最接近的整数。示例：echo ceil(5.1); echo ceil(-5.1); 输出：6；-5 3.floor()函数向下舍入为最接近的整数。示例：echo floor(5.1); echo floor(-5.1); ...
PHP危险函数总结
Lemon's blog
08-17 3673
前言：PHP中有很多危险函数，如phpinfo() ，这次就来详细总结一下PHP中的危险函数，方便以后学习。 一、PHP代码执行函数 eval()函数 定义和用法： eval() 函数把字符串按照 PHP 代码来计算. 该字符串必须是合法的 PHP 代码，且必须以分号结尾。 这个用法就会产生漏洞，通过一个例子来看一下： <?php $var = "var"; if (isset($_GE...
php危险函数总结
我是齐潇啊
03-28 5141
php危险函数笔记总结以及实操结果
php常用的函数总结
weixin_44944193的博客
06-04 9737
php usleep() 函数延迟代码执行若干微秒。 unpack() 函数从二进制字符串对数据进行解包。 uniqid() 函数基于以微秒计的当前时间，生成一个唯一的 ID。 time_sleep_until() 函数延迟代码执行直到指定的时间。 time_nanosleep() 函数延迟代码执行若干秒和纳秒。 sleep() 函数延迟代码执行若干秒。 show_source() 函数对文件进行语法高亮显示。 strip_whitespace() 函数返回已删除 PHP 注释以及空白字符的源代码文件。 .
php常用函数最全总结
wuhuagu_wuhuaguo的博客
10-09 5873
PHP常用函数总结 常用函数 echo()【语言结构】 print()//【语言结构】【有返回值】，若传输失败导致没有输出，它返回false var_dump() var_export()【有返回值，翻译一个合法的PHP代码】 printf()//类似与C语言的形式 printf("my name is %s, age %d", $name, $age);...
php常用函数总结表
05-24
php常用函数总结表php常用函数总结表php常用函数总结表php常用函数总结表
php函数总结大全
06-23
php函数总结，所有的函数 数组 函数 、 字符串函数、php 函数 内置函数 ，有详细的例子。
PHP函数积累总结
10-17
主要介绍了PHP函数积累，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
TCP相关问题总结
最新发布
qq_62835094的博客
04-23 593
假设TCP是两次握手，则可能会发生以下情况客户端发起TCP握手，向服务器发送SYN，但该数据因网络波动滞留此时触发超时重传，重新简历TCP连接当新建立的连接断开后，之前在网络中滞留的SYN连接请求传递到服务端，服务端误以为客户端需要建立TCP连接，因此会发送SYN+ACK请求，并进入连接建立状态，但客户端并不需要建立连接，不会发送数据，因此会造成服务端资源的浪费三次握手可以防止客户端无效连接信息再次到达服务器，导致重新连接之所以需要四次挥手，因为半关闭tcp通道允许双方互相发送数据，数据是双向流动的。
抓取电商产品数据的方法|PHP|Python多语言环境|高并发需求|电商商品API接口数据采集
TinagirlAPI的博客
04-17 352
解决方案：集成订单管理系统和物流跟踪功能，让客户能够方便地处理订单、发货，并为用户提供实时的物流跟踪信息。- 解决方案：支持信用卡、借记卡、PayPal等流行的在线支付方式，确保用户可以选择最适合自己的付款方式。- 解决方案：采用高性能的服务器、CDN加速服务、优化网站代码等措施，确保网站能够快速响应并保持稳定性。- 解决方案：整合营销工具，如优惠券系统、积分奖励、折扣活动等，提供多样的促销方式来吸引客户。- 解决方案：采用SSL加密技术保护网站的安全性，遵守相关法规和标准，确保用户数据安全。
upload-labs
XiaoYeZhu_1314的博客
04-18 191
完成upload靶场，通过中国蚁剑读取服务器的目录
Laravel 6 - 第十五章 验证器
逆旅岁月的博客
04-22 922
用于验证输入数据是否符合特定规则的一个组件，Laravel 6 提供了一个简洁且强大的验证系统，可以轻松验证来自用户输入或其他来源的数据。
Pikachu靶场通关教程
npc88888的博客
04-17 1134
账号:admin 密码：123456爆破代码。
高可用集群——keepalived
wzpny的博客
04-17 598
Keepalived起初是为LVS设计的，专门用来监控集群系统中各个服务节点的状态，后来有加入VRRP的功能，VRRP是（虚拟路由器冗余协议）的缩写VRRP出现的目的就是为了解决静态路由器出现的单点故障问题，它能偶保证网络的不间断、稳定的运行。所有，keepalived一方面具有功能，另一方面也具有功能。
ADOP带您了解电口模块和光模块的区别和运用场景
ADOP_BitRate的博客
04-18 1107
首先，我们将万兆电口模块的SFP+端口插到万兆交换机上，然后使用网线（如Cat6或Cat7网络跳线）连接万兆电口模块的RJ45接口和服务器/存储端的RJ45接口即可，且无需购买额外的设备（如光纤收发器），节省安装成本。值得注意的是，尽管10/100/1000M电口和1000M电口可能看起来相似，但由于交换机的电路设计不同，它们需要匹配不同速率的电口模块。现如今，光模块主要向着低功耗方向发展，以ADOP万兆电口模块为例，其功耗在2.5W以下，传输距离越远，功耗越低。
upload-labs靶场详解
lizhiiiii的博客
04-17 669
使用小皮集成环境来完成这个靶场 将文件放到WWW目录下就可以进行访问。
WP-AutoPostPro 汉化版： WordPress自动采集发布插件
04-19 346
WP-AutoPostPro 是目前最好用的WordPress自动采集发布插件，最大的特点是可以采集来自于任何网站的内容并自动发布到你的WordPress站点。真正做到可以采集任何网站的内容并自动发布，采集过程完全自动进行无需人工干预，并提供内容过滤、HTML标签过滤、关键词替换、自动链接、自动标签、自动下载远程图片到本地服务器、自动添加文章前缀后缀、并且可以使用微软翻译引擎将采集的文章自动翻译为各种语言进行发布。抄笔记 (chaobiji.cn)
PHP 爬虫如何配置代理 IP（CURL 函数）
打字爱好者。
04-19 317
在 PHP中 配置代理IP，可以通过设置 CURL库的选项来实现，代码如下：
phpfopen函数
07-28
总结来说，fopen函数提供了更多的灵活性和功能，适用于更复杂的文件操作，而file_get_contents函数则更简单方便，适用于简单的文件读取操作。具体使用哪个函数取决于你的需求和个人偏好。 #### 引用[.reference_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值