PHP 常用数组API

最新推荐文章于 2022-11-12 15:39:39 发布

xiongxiaolin123

最新推荐文章于 2022-11-12 15:39:39 发布

阅读量448

点赞数

分类专栏： PHP

本文链接：https://blog.csdn.net/xiongxiaolin123/article/details/96696177

版权

PHP 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

常用数组API

1. 语言结构 array()

/**
   * 创建数组
   * 方法：array(key=>value,key=>value,etc.)
   * return: 一个数组
   * 1. 三种类型的数组: 索引数组 - 带有数字索引的数组;关联数组 - 带有指定的键的数组;多维数组 - 包含一个或多个数组的数组
   */
  function demo() {
    // 索引数组
    $cars = array("Volvo", "BMW", "Toyota");
    echo "I like ".$cars[0].", ".$cars[1]." and ".$cars[2].".<br>";
    var_dump($cars);
    // 遍历并打印索引数组的值
    $arrlength = count($cars);
    for($x = 0; $x < $arrlength; $x++) {
      echo $cars[$x];
      echo "<br>"; 
    }
    foreach($cars as $car_key => $car) {
      echo $car_key.": ".$car;
      echo "<br>";
    }
    echo "<br><hr>";

    // 关联数组
    $age = array("Bill" => "60", "Steve" => "56", "Mark" => "31");
    echo "Bill is ".$age["Bill"]." years old.<br><br>";
    
    echo "根据内部指针迭代foreach方式: <br>";
    foreach($age as $age_key => $age_val) {
      echo $age_key.": ".$age_val;
      echo "<br>";
    }
    echo "<br>";

    echo "获取所有键名迭代: <br>";
    $age_keys = array_keys($age);
    for($i = 0; $i < count($age_keys); $i++) {
      $age_key = $age_keys[$i];
      echo $age_key.": ".$age[$age_key];
      echo "<br>";
    }
    echo "<br>";

    echo "根据内部指针迭代1: <br>";
    reset($age);    //需要重置数组内部指针
    for($y = 0; $y < count($age); $y++) {
      $key = key($age);
      echo $key.": ".$age[$key];
      next($age);
      echo "<br>";
    }
    echo "<br>";
    
    echo "根据内部指针迭代2: <br>";
    reset($age);    //需要重置数组内部指针
    while($age_key = key($age)) {
      echo $age_key.": ".$age[$age_key];
      next($age);
      echo "<br>";
    }
    echo "<br>";

    // 二维数组
    $cars_mutil = array(
      array("Volvo", 100, 96),
      array("BMW", 60, 59),
      array("Toyota", 110, 100)
    );
    foreach($cars_mutil as $cars_mutil_key => $cars_mutil_val) {
      echo $cars_mutil_key.": <br>";
      print_r($cars_mutil_val);
      echo "<br>";
    }
    echo "<br>";

    // php5.4+起，可使用[]代替array()
    $test_array = ["aaa", "bbb", "ab"=>"4343"];
    var_dump($test_array);
  }
  // demo();

2. array_change_key_case(array [,case]): 将数组的所有的键都转换为大写或小写字母

/**
   * 将数组的所有的键都转换为大写或小写字母
   * array_change_key_case(array [,case])
   * params:
   *  array: 规定要使用的数组
   *  case: CASE_LOWER(=0)(默认值)-将数组的键转换为小写字母;CASE_UPPER(=1)-将数组的键转换为大写字母
   * return: 一个新数组
   */
  function demo2() {
    $age = array("Bill" => "60", "Steve" => "56", "Mark" => "31");
    print_r($age);
    echo "<br>";
    // 传常量
    print_r(array_change_key_case($age, CASE_LOWER));
    echo "<br>";
    print_r(array_change_key_case($age, CASE_UPPER));
    echo "<br><hr>";
    // 传数值
    print_r(array_change_key_case($age, 0));
    echo "<br>";
    print_r(array_change_key_case($age, 1));
    echo "<br><hr>";

    // 如果数组同行中有相同键名，则最后的元素会覆盖其他元素
    $pets = array(
      "a" => "Cat",
      "B" => "Dog",
      "c" => "Horse",
      "b" => "Bird"
    );
    print_r(array_change_key_case($pets));
  }
  // demo2();

3. array_chunk(array,size [,preserve_key]): 把数组分割为带有两个元素的数组

/**
   * 把数组分割为带有两个元素的数组
   * array_chunk(array,size [,preserve_key])
   * params:
   *  array: 规定要使用的数组
   *  size: 整数值，规定每个新数组包含多少个元素
   *  preserve_key: true-保留原始数组中的键名;false(默认值)-每个结果数组使用从零开始的新数组索引
  *  return: 返回一个多维的索引数组
   */
  function demo3() {
    $cars = array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
    print_r(array_chunk($cars, 2));
    echo "<br><hr>";
    
    $age = array(
      "Bill" => 60,
      "Steve"=>"56",
      "Mark"=>"31",
      "David"=>"35"
    );
    print_r(array_chunk($age, 2, true));
  }
  // demo3();

4. array_column(array,column_key [,index_key]): 返回输入数组中某个单一列的值

/**
   * 返回输入数组中某个单一列的值
   * array_column(array,column_key [,index_key])
   * params:
   *  array: 规定要使用的多维数组(记录集)
   *  column_key: 需要返回值得列名
   *  index_key: 用作返回数组得索引/键的列
   * tips: 存在的问题https://learnku.com/articles/16778
   * version: 5.5+
   */
  function demo4() {
    // 表示由数据库返回的可能记录集的数组
    $a = array(
      array(
        'id' => 5698,
        'first_name' => 'Bill',
        'last_name' => 'Gates'
      ),
      array(
        'id' => 4767,
        'first_name' => 'Steve',
        'last_name' => 'Jobs'
      ),
      array(
        'id' => 3809,
        'first_name' => 'Mark',
        'last_name' => 'Zuckerberg'
      )
    );
    $last_names = array_column($a, 'last_name');
    print_r($last_names);
    echo "<br>";
    print_r(array_column($a, 'last_name', 'id'));
    echo "<br>";
    print_r(array_combine( array_keys($last_names), array_column($a, 'last_name')));
  }
  // demo4();

5. array_combine(keys, values): 通过合并两个数组来创建一个新数组，其中的一个数组是键名，另一个数组的值为键值

/**
   * 通过合并两个数组来创建一个新数组，其中的一个数组是键名，另一个数组的值为键值
   * array_combine(keys, values)
   * params: 
   *  keys: 键名数组
   *  values: 键值数组
   * return: 两个数组的元素个数必须相同则返回新数组，不同则返回报错，建议捕获
   * tips: 错误与异常https://www.cnblogs.com/zyf-zhaoyafei/p/6928149.html#excetion
   */
  function demo5() {
    $fname = array("Bill","Steve","Mark");
    $age = array("60","56","31");
    $text = array();

    $c = array_combine($fname, $age);
    print_r($c);
    echo "<br>";
    // 这里无法捕获Error，只能通过其他方式，再错误回调里面抛出异常
    try {
      array_combine($fname, $text);
    } catch(Exception $e) {
      echo 'Message: ' .$e->errorMessage();   //自定义异常处理方法
    }
  }
  // demo5();

6. array_count_values(array): 对数组中的所有值进行计数

/**
   * 对数组中的所有值进行计数
   * array_count_values(array)
   * params:
   *  array: 规定要使用的数组
   * return: 返回关联数组，其元素的键名是原数组的值，键值是该值在原数组中出现的次数
   */
  function demo6() {
    $a = array("A", "Cat", "Dog", "A", "Dog");
    print_r($a);
    echo "<br>";
    print_r(array_count_values($a));
    echo "<br><hr>";

    // 多维数组使用，找到特定值的项数
    $list = array(
      array('id' => 1, 'userId' => 5),
      array('id' => 2, 'userId' => 5),
      array('id' => 3, 'userId' => 7)
    );
    $userids = array_column($list, 'userId');
    print_r($userids);
    $count = array_count_values($userids);
    print_r($count);
    $find_userid = 5;
    echo $count[$find_userid];
  }
  // demo6();

7. array_fill(index, number, value): 用给定的键值填充数组

/**
   * 用给定的键值填充数组
   * array_fill(index, number, value)
   * params: 
   *  index: 被返回数组的第一个索引
   *  number: 规定要插入的元素数
   *  value: 规定供填充数组所使用的值
   */
  function demo12() {
    $a1 = array_fill(3, 4, "blue");
    print_r($a1);
  }
  // demo12();

8. array_fill_keys(keys, value): 用指定键名的给定键值填充数组

/**
   * 用指定键名的给定键值填充数组
   * array_fill_keys(keys, value)
   * params: 
   *  keys: 使用该数组的值作为键
   *  value: 规定供填充数组所使用的值
   */
  function demo13() {
    $keys = array("a", "b", "c", "d");
    $a1 = array_fill_keys($keys, "blue");
    print_r($a1);
    echo "<br><hr>";

    $arr1 = array(
      "a" => "first",
      "b" => "second",
      "c" => "something",
      "red"
    );
    $arr2 = array(
      "a" => "first",
      "b" => "something",
      "letsc"
    );
    print_r(array_fill_keys($arr1, $arr2));
  }
  // demo13();

9. array_filter(array, callbackfunction): 用回调函数过滤数组中的值

/**
   * 用回调函数过滤数组中的值
   * array_filter(array, callbackfunction)
   * params: 
   *  array: 规定要使用的数组
   *  callbackfunction: 回调函数
   */
  function demo14() {
    function test_odd($var) {
      // return ($var & 1);    // Warning: A non-numeric value encountered,要避免混合数值运算,或使用强制类型转换，但要注意高低位转换问题
      return true;
    }

    $a1 = array("a", "b", 2, 3, 4);
    print_r(array_filter($a1, "test_odd"));
  }
  // demo14();

10. array_flip(array): 用于反转/交换数组中所有的键名以及它们关联的键值

/**
   * 用于反转/交换数组中所有的键名以及它们关联的键值
   * array_flip(array)
   * params: 
   *  array: 规定要使用的数组
   * tips: array_flip得到的是重复元素最后的键和值,用array_unique得到的是两个重复元素第一个键和值
   */
  function demo15() {
    $a1 = array("a" => "red", "b" => "green", "c" => "blue", "d" => "yellow");
    $result = array_flip($a1);
    print_r($a1);
    print_r($result);
    echo "<br>";

    $arr =array("a"=>"a1","b"=>'b1',"c"=>"a2","d"=>"a1");
    $arr1 = array_flip($arr);
    print_r($arr1);
  }
  // demo15();

11. array_key_exists(key, array): 检查指定的键名是否存在于数组中

/**
   * 检查指定的键名是否存在于数组中
   * array_key_exists(key, array)
   * params: 
   *  key: 规定键名
   *  array: 规定要使用的数组
   */
  function demo16() {
    $a = array(
      "Volvo" => "XC90",
      "BMW" => "X5",
      "SE",
    );
    if (array_key_exists("Volvo", $a)) {
      echo "键名存在!";
    } else {
      echo "键名不存在!";
    }
    echo "<br>";
    if (array_key_exists(0, $a)) {
      echo "键名存在!";
    } else {
      echo "键名不存在!";
    }
  }
  // demo16();

12. array_keys(array, value, strict): 返回数组中所有的键名

/**
   * 返回数组中所有的键名
   * array_keys(array, value, strict)
   * params: 
   *  array: 规定要使用的数组
   *  value: 您可以指定键值，然后只有该键值对应的键名会被返回
   *  strict: true - 返回带有指定键值的键名。依赖类型，数字 5 与字符串 "5" 是不同的;false - 默认值。不依赖类型，数字 5 与字符串 "5" 是相同的
   */
  function demo17() {
    $a = array(
      "Volvo"=>"XC90",
      "BMW"=>"X5",
      "Toyota"=>"Highlander",
      5,
      "5"
    );
    print_r(array_keys($a));
    print_r(array_keys($a, "X5"));
    print_r(array_keys($a, 5, true));
  }
  // demo17();

13. array_map(myfunction,array1,array2,array3…): 把数组中的每个值发送到用户自定义函数，返回新的值

/**
   * 把数组中的每个值发送到用户自定义函数，返回新的值
   * array_map(myfunction,array1,array2,array3...)
   * params: 
   *  myfunction: 自定义函数
   * tips: 当参数数组为多个时，自定义函数为null才会进行合并返回新数组，否则只有第一个数组生效
   */
  function demo18() {
    function myfn($v) {
      echo "--".$v;
      return ($v*$v);
    }
    $a = array(1, 2, 3, 4, 5);
    $a2 = array(10, 20, 30, 40, 50);
    print_r(array_map("myfn", $a, $a2));    //这里只返回$a的函数处理

    $b = array("A", "B");
    $b2 = array("C", "D", "E");
    print_r(array_map(null, $b, $b2));
  }
  // demo18();

14. array_merge(array1,array2,array3…)：把一个或多个数组合并为一个数组

/**
   * 把一个或多个数组合并为一个数组
   * array_merge(array1,array2,array3...)
   * tips:
   *  1. 当数组中索引都是数字索引时，会把数组重新从第一个数组开始，并索引从0开始生成新的数组
   *  2.当数组中有数字也有非数字时，数字索引会和非数字索引一样，后面替换前面的
   *  3. 相同键名下，后面键名的值会覆盖前面的
   */
  function demo19() {
    $a1 = array(
      "A",
      "B"
    );
    $a2 = array(
      "C",
      "D",
      "B"
    );
    print_r(array_merge($a1, $a2));
    echo "<br><hr>";

    // 相同键名下，后面键名的值会覆盖前面的
    $b1 = array(
      "AB" => "x",
      "CB" => "xl"
    );
    $b2 = array(
      "DB" => "xxl",
      "CB" => "xxxl"
    );
    print_r(array_merge($b1, $b2));
  }
  // demo19();

15. array_merge_recursive(array1,array2,array3…)：递归地合并一个或多个数组

/**
   * 递归地合并一个或多个数组
   * array_merge_recursive(array1,array2,array3...)
   * tips: 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组
   */
  function demo20() {
    $a1 = array(
      "a" => "red",
      "b" => "green"
    );
    $a2 = array(
      "c" => "blue",
      "b" => "yellow"
    );
    print_r(array_merge_recursive($a1, $a2));
  }
  // demo20();

16. array_pad(array,size,value)：用值将数组填补到指定长度

/**
   * 用值将数组填补到指定长度
   * array_pad(array,size,value)
   * params: 
   *  array: 规定数组
   *  size: 规定从函数返回的数组中元素的个数
   *  value: 规定从函数返回的数组中新元素的值
   */
  function demo22() {
    $a = array_pad(["red","green"], 3, "ab");
    print_r($a);
  }
  // demo22();

17. array_pop(array)：删除数组的最后一个元素（出栈）

/**
   * 删除数组的最后一个元素（出栈）
   * array_pop(array)
   * params: 
   *  array: 规定数组
   * return: 返回删除的元素
   */
  function demo23() {
    $a = array(
      "red",
      "green",
      "blue"
    );
    array_pop($a);
    print_r($a);
  }
  // demo23();

18. array_push(array,value1,value2…)：将一个或多个元素插入数组的末尾（入栈）

/**
   * 将一个或多个元素插入数组的末尾（入栈）
   * array_push(array,value1,value2...)
   * params: 
   *  array: 规定数组
   *  value: 要添加的值
   * return: 然后返回新数组的长度
   */
  function demo24() {
    $a = array(
      "red",
      "green",
      "blue"
    );
    array_push($a, "val1", "val2", "val3");
    print_r($a);
  }
  // demo24();

19. array_product(array)：计算数组中所有值的乘积

/**
   * 计算数组中所有值的乘积
   * array_product(array)
   * params: 
   *  array: 规定数组
   */
  function demo25() {
    $a = array(2, 3);
    print_r(array_product($a));
  }
  // demo25();

20. array_rand(array, number)：返回数组中一个或多个随机的键

/**
   * 返回数组中一个或多个随机的键
   * array_rand(array, number)
   * params: 
   *  array: 规定数组
   *  number: 规定返回多少随机键名
   * tips: 如果返回一个随机值，则一个返回键名
   */
  function demo26() {
    $a = array(2, 3, 5, 6, 2, 21, 44221166);
    print_r(array_rand($a, 2));
    $a2=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    print_r(array_rand($a2, 1));    //返回键名
  }
  // demo26();

21. array_reduce(array,myfunction,initial)：通过使用用户自定义函数，以字符串返回数组

/**
   * 通过使用用户自定义函数，以字符串返回数组
   * array_reduce(array,myfunction,initial)
   * params: 
   *  array: 规定数组
   *  myfunction: 自定义函数
   *  initial: 规定发送到函数的初始值
   */
  function demo27() {
    function myfn($v1, $v2) {
      return $v1.'-'.$v2;
    }
    $a = array("AA", "BB", "CC");
    print_r(array_reduce($a, "myfn"));
  }
  // demo27();

22. array_replace(array, array1,array2,array3…)：使用后面数组的值替换第一个数组的值

/**
   * 使用后面数组的值替换第一个数组的值
   * array_replace(array, array1,array2,array3...)
   * params: 
   *  array: 规定数组
   *  array1: 指定要替换array的值的数组
   */
  function demo28() {
    $a1 = array("AA", "BB");
    $a2 = array("CC", "DD");
    print_r(array_replace($a1, $a2));
    
    $a1=array("a"=>"red","green");
    $a2=array("a"=>"orange","b"=>"burgundy");
    print_r(array_replace($a1,$a2));
  }
  // demo28();

23. array_replace_recursive(array, array1,array2,array3…)：递归地使用后面数组的值替换第一个数组的值

/**
   * 递归地使用后面数组的值替换第一个数组的值
   * array_replace_recursive(array, array1,array2,array3...)
   * params: 
   *  array: 规定数组
   *  array1: 指定要替换array的值的数组
   *  tips: 如果没有为每个数组指定一个键，该函数的行为将等同于 array_replace() 函数
   */
  function demo29() {
    $a1=array("a"=>array("red"),"b"=>array("green","blue"),);
    $a2=array("a"=>array("yellow"),"b"=>array("black"));
    print_r(array_replace_recursive($a1,$a2));
  }
  // demo29();

24. array_reverse(array,preserve)：以相反的顺序返回数组

/**
   * 以相反的顺序返回数组
   * array_reverse(array,preserve)
   * params: 
   *  array: 规定数组
   *  preserve: 规定是否保留原始数组的键名,true保留
   */
  function demo30() {
    $a = array("A", "B", "C");
    print_r(array_reverse($a));

    $a2 = array("A" => "1", "B" => "2", "C" => "3");
    print_r(array_reverse($a2, true));
  }
  // demo30();

25. array_search(value,array,strict)：函数在数组中搜索某个键值，并返回对应的键名

/**
   * 函数在数组中搜索某个键值，并返回对应的键名
   * array_search(value,array,strict)
   * params: 
   *  value: 规定需要搜索的键值
   *  array: 规定数组
   *  strict: 为true则只有在数据类型和值都一致时才返回相应元素的键名
   */
  function demo31() {
    $a = array("A", "B", "C");
    print_r(array_search('B', $a));
  }
  // demo31();

26. array_shift(array)：删除数组中首个元素，并返回被删除元素的值

/**
   * 删除数组中首个元素，并返回被删除元素的值
   * array_shift(array)
   * params: 
   *  array: 规定数组
   */
  function demo32() {
    $a = array("A", "B", "C");
    print_r(array_shift($a));
    echo "<br>";
    print_r($a);
  }
  // demo32();

27. array_slice(array,start[,length][,preserve])：返回数组中被选定的部分

/**
   * 返回数组中被选定的部分
   * array_slice(array,start[,length][,preserve])
   * params: 
   *  array: 规定数组
   *  start: 规定取出元素的开始位置
   *  length: 规定被返回数组的长度
   *  preserve: 规定函数时保留键名还是重置键名。true-保留,false(默认)-重置。5.0.2+可用参数
   */
  function demo33() {
    $a = array("A", "B", "C", "D", "E");
    print_r($a);
    echo "<br>";
    print_r(array_slice($a, 1, 2));
  }
  // demo33();

28. array_slice(array,start[,length][,array2])：删除并替换数组中指定的元素

/**
   * 删除并替换数组中指定的元素
   * array_slice(array,start[,length][,array2])
   * params: 
   *  array: 规定数组
   *  start: 规定取出元素的开始位置,可以为负数
   *  length: 规定被移除的元素个数，也是被返回数组的长度
   *  array2: 规定带有要插入原始数组中元素的数组
   */
  function demo34() {
    $a = array("A", "B", "C", "D", "E");
    $a2 = array("a" => "purple", "b" => "orange");
    print_r(array_splice($a, 0, 2, $a2));
    echo "<br>";
    print_r($a);
  }
  // demo34();

29. array_sum(array)：返回数组中值的和

/**
   * 返回数组中值的和
   * array_sum(array)
   * params: 
   *  array: 规定数组
   * tips: 如果所有值都是整数，则返回一个整数值。如果其中有一个或多个值是浮点数，则返回浮点数
   */
  function demo35() {
    $a = array(15, 15, 25);
    echo array_sum($a);
  }
  // demo35();

30. array_unique(array [,sortingtype])：删除数组中的重复值

/**
   * 删除数组中的重复值
   * array_unique(array [,sortingtype])
   * params: 
   *  array: 规定数组
   *  sortingtype: 规定如何比较数组元素，项目参数为SORT_STRING、SORT_REGULAR、SORT_NUMERIC、SORT_LOCALE_STRING
   * tips: 当几个数组元素的值相等时，只保留第一个元素，其他的元素被删除。返回的数组中键名不变
   */
  function demo36() {
    $a = array("A" => "red", "B" => "green", "C" => "red");
    print_r(array_unique($a));
  }
  // demo36();

31. array_unshift(array,value1,value2,value3…)：在数组开头插入一个或多个元素

/**
   * 在数组开头插入一个或多个元素
   * array_unshift(array,value1,value2,value3...)
   * params: 
   *  array: 规定数组
   *  value1: 插入值
   */
  function demo37() {
    $a = array("A" => "red", "B" => "green", "C" => "red");
    print_r(array_merge($a, ["D" => "gray"]));
    print_r(array_unshift($a,"blue"));
    echo "<br>";
    print_r($a);
  }
  // demo37();

32. array_values(array)：返回数组中所有的值

/**
   * 返回数组中所有的值
   * array_values(array)
   * params: 
   *  array: 规定数组
   */
  function demo38() {
    $a = array("A" => "red", "B" => "green", "C" => "red");
    print_r(array_values($a));
  }
  // demo38();

33. array_walk(array,myfunction [,userdata…])：对数组中的每个成员应用用户函数

/**
   * 对数组中的每个成员应用用户函数
   * array_walk(array,myfunction [,userdata...])
   * params: 
   *  array: 规定数组
   *  myfunction: 自定义函数
   *  userdata: 规定用户自定义函数的参数。您能够向此函数传递任意多参数
   */
  function demo39() {
    function myfn($value, $key) {
      echo "The key $key has the value $value <br>";
    }
    $a = array("a" => "red", "b" => "green", "c" => "blue");
    array(array_walk($a, "myfn"));
    echo "<br><hr>";

    // 传引用
    function myfunction(&$value,$key) {
      $value="yellow";
    }
    $a2=array("a"=>"red","b"=>"green","c"=>"blue");
    array_walk($a2,"myfunction");
    print_r($a2);
  }
  // demo39();

34. array_walk_recursive(array,myfunction [,userdata…])：对数组中的每个成员递归地应用用户函数

/**
   * 对数组中的每个成员递归地应用用户函数
   * array_walk_recursive(array,myfunction [,userdata...])
   * params: 
   *  array: 规定数组
   *  myfunction: 自定义函数
   *  userdata: 规定用户自定义函数的参数。您能够向此函数传递任意多参数
   */
  function demo40() {
    function myfn($value, $key) {
      echo "The key $key has the value $value <br>";
    }
    $a = array("a" => "red", "b" => "green", "c" => "blue", "d" => ["a"=>"ff"]);
    array(array_walk_recursive($a, "myfn"));
    echo "<br><hr>";
  }
  // demo40();

35. compact(var1,var2…)：创建包含变量名和它们的值的数组

/**
   * 创建包含变量名和它们的值的数组
   * compact(var1,var2...)
   * params: 
   *  var1: 变量
   */
  function demo41() {
    $fname = "xxl";
    $age = 25;

    print_r(compact("fname", "age"));

    $weight = "80";
    $a = array("weight");
    print_r(compact($a, "ffff"));
  }
  // demo41();

36. count(array)：返回数组中元素的数目

/**
   * 返回数组中元素的数目
   * count(array)
   * params: 
   *  array: 规定数组
   */
  function demo42() {
    $cars = array("Volvo", "BMW", "Toyota");
    echo count($cars);
  }
  // demo42();

37. current(array)：返回数组中指针指向的当前元素

/**
   * 返回数组中指针指向的当前元素
   * current(array)
   * params: 
   *  array: 规定数组
   * tips: 
   *  1. end(): 将内部指针指向数组中的最后一个元素，并输出
   *  2. next(): 将内部指针指向数组中的下一个元素，并输出
   *  3. prev(): 将内部指针指向数组中的上一个元素，并输出
   *  4. reset(): 将内部指针指向数组中的第一个元素，并输出
   *  5. each()(已废弃)
   *  6. key(): 返回数组内部指针当前指向元素的键名
   */
  function demo43() {
    $cars = array("Volvo", "BMW", "Toyota");
    echo current($cars);
  }
  // demo43();

38. extract(array)：从数组中将变量导入到当前的符号表

/**
   * 从数组中将变量导入到当前的符号表
   * extract(array)
   * params: 
   *  array: 规定数组
   */
  function demo44() {
    $a = "Original";
    $my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse", "color");
    extract($my_array);
    echo "\$a = $a; \$b = $b; \$c = $c";
  }
  // demo44();

39. in_array(search,array [,type])：检查数组中是否存在指定的值

/**
   * 检查数组中是否存在指定的值
   * in_array(search,array [,type])
   * params: 
   *  search: 规定要在数组搜索的值
   *  array: 规定要使用的数组
   *  type: 如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同
   */
  function demo45() {
    $a = array("a" => "Cat","b" => "Dog", "c" => "Horse", "color");
    if (in_array("Cat", $a)) {
      echo "匹配已找到";
    } else {
      echo "匹配未找到";
    }
  }
  // demo45();

40. list(var1,var2…)：把数组中的值赋给一些变量

/**
   * 把数组中的值赋给一些变量
   * list(var1,var2...)
   * params: 
   *  var1: 需要赋值的变量
   * tips: 与array()同为语言结构，不是函数;该函数只用于数字索引的数组，且假定数字索引从 0 开始
   */
  function demo46() {
    $aa = array("a" => "Cat","b" => "Dog", "c" => "Horse", "color", "age", "height");
    list($a, $b, $c) = $aa;
    echo "\$a = $a, \$b = $b, \$c = $c";
  }
  // demo46();

41. range(low,high [,step])：创建一个包含指定范围的元素的数组

/**
   * 创建一个包含指定范围的元素的数组
   * range(low,high [,step])
   * params: 
   *  low: 规定数组的最低值
   *  high: 规定数组的最高值
   *  step: 规定元素之间的步进制
   */
  function demo47() {
    $number = range(0, 5, 2);
    print_r($number);
  }
  // demo47();

42. shuffle(array)：把数组中的元素按随机顺序重新排列

/**
   * 把数组中的元素按随机顺序重新排列
   * shuffle(array)
   * params: 
   *  array: 规定要使用的数组
   */
  function demo48() {
    $a = array("A", "B", "C", "D", "E");
    shuffle($a);
    print_r($a);
  }
  // demo48();

43. sort()：排序相关

/**
   * 排序相关
   * sort()
   * tips: 排序函数非常多，需要时候再查
   */
  function demo49() {
    $a = array("A", "C", "B", "F");
    sort($a);
    print_r($a);
  }
  demo49();