精华内容
下载资源
问答
  • php常用数组函数

    千次阅读 2017-03-25 01:23:26
    php常用数组函数

    php常用数组函数

    大致需求前文以及简单介绍过,数据表按照时间生成,每天一张,每张表大约80W+数据量,加上需要获取多日的数据,例如获取连续5日登陆的用户。

    需求:玩家留存率、时间可选,开始时间以及结束时间

    表头包含:新注册用户数量、次日留存、2日留存…30日留存

    分析:

    1. 留存率公式:第N日该批用户登录数量/当日注册用户数量
    2. log表数据结构比较特殊,所有的log表字段一致,只用type去区分,字段为id、插入时间、用户ID、用户名称、type、参数1…参数20,实际参数代表的意义以及type的意思均为代码中常量定义。

    因此如果单纯用mysql语句去操作,涉及跨表、联合、join等操作,实际测试单一一条语句均要超过6s以上,这种情况是完全无法接受的,因为查询时间可选,那么就导致如果筛选多日,随随便便都需要等待1分钟以上。


    所以最终选择只用mysql去做最简单的查询操作,包含上尽可能多的的where语句限定并group by特定的key,其余全部使用php去操作数组完成,最后成果为每一条独立的sql语句耗时0.2-0.3s左右(全表无索引),包含php操作后最后输出单日数据约1s左右,因为此后台只是内部使用,已基本满足要求。


    1.非常好用的Laravel内置数组辅助函数,array_pluck()

    array_pluck(array $array,string $value_column_name[, string $key_column_name])

    此函数可以将一个对象数组,按照你想要的方式提取出你指定的$key=>$value形式Map图(键值对数组),或单纯的返回一列的一维数组。

    • 第一个参数:需要提取的数组,一般用于Laravel查询构造器返回的查询结果数据,一个对象数组。

    • 第二个参数:需要提取的值的列名

    • 第三个参数(可选):需要提取的key的列名

    例如(均为伪代码,只是示意用法):

    原数组:
    [
     {
         id:1,
         name:'hello',
     },
     {
         id:2,
         name:'hello2',
     }
    ]
    
    array_pluck(array,'name');
    返回:['hello','hello2']
    
    array_pluck(array,'name','id');
    返回:
    array(
        "1"=>"hello",
        "2"=>"hello2"
    );

    2.最常用的array_filter()

    具体定义可以自行查询w3school,一个小技巧就是如果不传入第二个func参数,则会为数组去除空元素,需要注意的一点是任何php认为为空的值均会过滤掉,例如0,false,‘’等

    3.可为混合数字字串排序的sort类函数,例如:ksort()、krsort()等

    此类函数均含有第二个flag参数,可以设置检索排序模式,例如:0-5分钟、5-10分钟、30分钟、60分钟、120+分钟,如果出现顺序打乱后,只需要简单的调用sort类函数,至于是过滤按照key还是value就需要看实际需求了,第二个参数传入4,当做自然排序即可

    展开全文
  • PHP 常用数组API

    2019-07-21 10:19:43
    常用数组API 1. 语言结构 array() /** * 创建数组 * 方法:array(key=>value,key=>value,etc.) * return: 一个数组 * 1. 三种类型的数组: 索引数组 - 带有数字索引的数组;关联数组 - 带有指定的键的数组;...

    常用数组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();
    
    展开全文
  • PHP常用数组函数

    2018-08-07 12:17:54
    array_change_key_case 将数组中的所有键名修改为全大写或小写 array_change_key_case(array,CASE_UPPER|CASE_LOWER) ...php $input_array = array('a', 'b', 'c', 'd', 'e'); print_r(array_chunk(...

     

    array_change_key_case

    将数组中的所有键名修改为全大写或小写

    array_change_key_case(array,CASE_UPPER|CASE_LOWER)

    array_chunk

    将一个数组分割成多个

    <?php
    $input_array = array('a', 'b', 'c', 'd', 'e');
    print_r(array_chunk($input_array, 2));
    print_r(array_chunk($input_array, 2, true));//true保留原来数组的键名
    ?>

    array_column

    返回数组中指定的一列

    <?php
    ​
    $arr = [
    ​
            ['name'=>'huangyuxin','age'=>11],
            ['name'=>'zhangsan','age'=>12]
    ​
        ];
    ​
    $first_name = array_column($arr,'name');
    ​
    var_dump($first_name);
    ​
    结果:
    array(2) { [0]=> string(10) "huangyuxin" [1]=> string(8) "zhangsan" }

    array_combine

    创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值

    <?php
    $a = array('green', 'red', 'yellow');
    $b = array('avocado', 'apple', 'banana');
    $c = array_combine($a, $b);
    结果:
    Array
    (
        [green]  => avocado
        [red]    => apple
        [yellow] => banana
    )

    array_count_values

    统计数组中的值出现的次数,值作为键名,次数作为值

    <?php
    $array = array(1, "hello", 1, "world", "hello");
    print_r(array_count_values($array));
    ?>
    ​
    结果:
    Array
    (
        [1] => 2
        [hello] => 2
        [world] => 1
    )

    array_diff_assoc

    带索引检查数组的差集,键名也比较

    <?php
    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
    $array2 = array("a" => "green", "yellow", "red");
    $result = array_diff_assoc($array1, $array2);
    print_r($result);
    ?>
    ​
    结果:
    Array
    (
        [b] => brown
        [c] => blue
        [0] => red
    )

    array_diff

    带索引检查数组的差集,键名不用比较

    array_fill_keys

    使用指定的键和值填充数组

    <?php
    $keys = array('foo', 5, 10, 'bar');
    $a = array_fill_keys($keys, 'banana');
    print_r($a);
    ?>
    结果:
    Array
    (
        [foo] => banana
        [5] => banana
        [10] => banana
        [bar] => banana
    )

    array_fill

    用给定的值填充数组

    $a = array_fill(5, 6, 'banana');
    结果:
    Array
    (
        [5]  => banana
        [6]  => banana
        [7]  => banana
        [8]  => banana
        [9]  => banana
        [10] => banana
    )

    array_filter(回调)

    用回调函数过滤数组中的单元

    <?php
    ​
        $array = array(1,2,3,4,5,6,7);  
        function test($a){  
          
            if($a%2 == 1){  
                return $a;  
            }  
        }  
          
        $res = array_filter($array,'test');  
        var_dump($res); 
    ​
    结果:
    array(4) { [0]=> int(1) [2]=> int(3) [4]=> int(5) [6]=> int(7) }

    array_map(回调)

    为数组的每个元素应用回调函数

    <?php
    ​
        $array = array(1,2,3,4);  
        function test($a){  
            $a = $a * 3;  
            return $a;  
        }  
          
        $res = array_map('test',$array);  
        var_dump($res);  
    ​

    array_walk(回调)

    使用用户自定义函数对数组中的每个元素做回调处理,改变原数组

    <?php
    ​
        $array = array(1,2,3,4);  
        function test(&$a){ 
            $a = $a * 3;  
            return $a;  
        }  
          
        $res = array_walk($array,'test');  
        var_dump($array);  
    ​

    array_flip

    交换数组中的键和值

    array_key_exists

    检查数组里是否有指定的键名或索引

    <?php
    ​
    $array = ['a','b'];
    $res = array_key_exists(1,$array);
    var_dump($res);//true

    array_merge

    合并数组

    array_pad

    以指定长度将一个值填充进数组

    $input = array(12, 10, 9);
    $result = array_pad($input, 5, 0);
    // result is array(12, 10, 9, 0, 0)

    array_pop

    弹出数组最后一个单元

    array_shift

    将数组开头的单元移出数组

    array_push

    将一个或多个单元压入数组的末尾

    <?php
    $stack = array("orange", "banana");
    array_push($stack, "apple", "raspberry");
    print_r($stack);
    ?>
    ​
    结果:
    Array
    (
        [0] => orange
        [1] => banana
        [2] => apple
        [3] => raspberry
    )

    array_unshift

    在数组开头插入一个或多个单元

    array_product

    计算数组中所有值的乘积

    array_sum

    对数组中所有值求和

    array_rand

    从数组中随机取出一个或多个单元

    <?php
    ​
    $array = ['a','b','c'];
    ​
    $res = array_rand($array,1); //0 一个返回key
    ​
    $res = array_rand($array,2); //随机取两个值,array
    ​
    var_dump($res);

    array_reverse

    反转数组单元

    array_search

    查找某值,有返回key,否则false

    <?php
    $array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
    ​
    $key = array_search('green', $array); // $key = 2;
    $key = array_search('red', $array);   // $key = 1;
    ?>

    in_array

    检查数组中是否存在某个值,有返回true

    array_splice

    从数组中取出一段

    $input = array("a", "b", "c", "d", "e");
    ​
    $output = array_slice($input, 2);      // returns "c", "d", and "e"
    $output = array_slice($input, 0, 3);   // returns "a", "b", and "c"
    $output = array_slice($input, 0, 3,true);   // 保持键名
    var_dump($output);

    array_unique

    移除数组中重复的值

    shuffle

    打乱一个数组

    list

    将数组中的值赋予变量

    $info = array('coffee', 'brown', 'caffeine');
    // 列出所有变量
    list($drink, $color, $power) = $info;

    range

    创建一个范围的数组

    $res = range(0,100);
    var_dump($res);

    rsort

    逆向排序,按值

    <?php
    $input = array("a", "b", "c", "d", "e");
    $input = array(1,2,3,4); // 4 3 2 1
    ​
    $output = rsort($input);     
    ​
    var_dump($input);

    sort

    正向排序,按值

    <?php
    ​
    $input = array(1,3,2,4);
    ​
    $output = sort($input);     
    ​
    var_dump($input);

    ksort

    对数组按照键名排序

    krsort

    对数组按键名倒序

    指针操作

    <?php
    $arr = array(1,3,2,4);
    $next = next($arr);//指针指向下一个
    $val = current($arr);//当前元素的值
    $key = key($arr);//当前元素的key
    $reset = reset($arr);//指针重置
    $end = end($arr);//指针指向最后
    $pre = prev($arr);//指针向前一位
    $val = current($arr);
    var_dump($val);
    展开全文
  • php里面的常用数组函数: public function array_function_test(){ $arr=[1,5,68,15,45,23,78,95,2,6,65]; $arr1=[1,5,6,2]; $arrs=array( 0=>array(1,5,68,15,4), 1=>array(15,45,23,78), 2=>...

    php里面的常用数组函数:

    public function array_function_test(){
            $arr=[1,5,68,15,45,23,78,95,2,6,65];
    
            $arr1=[1,5,6,2];
    
            $arrs=array(
                0=>array(1,5,68,15,4),
                1=>array(15,45,23,78),
                2=>array(23,78,95,2,6),
                3=>array(5,68,15,45,23)
            );
    
            echo "<pre>";
    //        print_r(array_diff($arr,$arr1));   //返回数组的差积(两个数组的不同之处)
    //        print_r(array_intersect($arr,$arr1));   //返回数组的交集(两个数组的相同之处)
    //        print_r(array_values($arrs));   //获得数组的值
    //        print_r(array_keys($arr1));   //获得数组的键
    //        print_r(array_push($arr,'xx','cc'));  //将一个字或者多个数据插入数组的末尾,返回数组的长度
    //        print_r(array_pop($arr));   //弹出数组的最后一位元素
    //        print_r(array_flip($arr));   //交换数组键与值的位置
    //        print_r(array_key_exists(3,$arr));   //判断给定的键值是否存在这个数组中,如果存在就返回1,不存在就不返回
    //        print_r(array_chunk($arr,2,true));    //将一个数组分割成多个数组,每个数组的长度是2
    //        print_r(array_slice($arr,4,6));  //将数组中的一段取出来,此函数忽略键名
    //        print_r(array_search(3,$arr));   //在数组中检索字符串,存在则返回当前字符串的键名称,不存在则不返回
    //        print_r(array_shift($arr));    //将数组的第一个元素弹出,并且将剩下的元素的键名向前移动一位(相当于重新对数组进行排序)
    //        print_r(array_unshift($arr,'SA','DE'));     //从数组开头插入多个或者多个数据,并返回数组长度
    //        print_r(range(0,12));   //创建一个包含指定单元范围的数组
    
            $firstname = "Peter";
            $lastname = "Griffin";
            $age = "41";
            $result = compact("firstname", "lastname", "age");    //将多个预定好的变量组成一个以变量名为键的数组
            print_r($result);
            
            exit();
        }

     

    php里面常用的字符串函数:

    public function str_function_test(){
            $str='Hello World  www !!';
    
            $arr = ["a","b","c"];
    
            echo "<pre>";
    //        字符串长度
    //        print_r(strlen($str));   //返回字符串长度
    
    //        字符串查找
    //        print_r(strpos($str,"l"));   //查找指定字符串首次出现的位置
    //        print_r(stripos($str,"l"));   //忽略大小写,查找指定字符串首次出现的位置
    //        print_r(strrpos($str,"l"));    //查找指定字符串最后一次出现的位置
    //        print_r(strripos($str,"l"));    //忽略大小写,查找指定字符串最后一次出现的位置
    //        print_r(strstr($str,"l"));    //查找指定字符串首次出现之后的字符串
    //        print_r(stristr($str,"l"));    //忽略大小写,查找指定字符串首次出现之后的字符串
    //        print_r(strchr($str,"l"));    //查找指定字符串首次出现之后的字符串
    //        print_r(strrchr($str,"l"));    //查找指定字符串最后一次出现之后的字符串
    //        print_r(str_replace("W","6",$str));    //查找指定字符串,并全部替换成另外指定字符串
    //        print_r(str_ireplace("W","6",$str));    //忽略大小写,查找指定字符串,并全部替换成另外指定字符串
    
              //字符串大小写
    //        print_r(strtolower($str));   //把字符串全部转换为小写,并返回小写之后的字符串
    //        print_r(strtoupper($str));   //把字符串全部转换为大写,并返回大写之后的字符串
    //        print_r(ucwords($str));   //把字符串单词开头转换为大写,并返回转换后的字符串
    //        print_r(ucfirst($str));   //把字符串开头第一个字母转换为大写,并返回转换后的字符串
    //        print_r(lcfirst($str));   //把字符串开头第一个字母转换为小写,并返回转换后的字符串
    
    //        字符串的截取
    //        print_r(substr($str,2,10));    //截取字符串,从2的位置开始截取10位
    //        print_r(substr_replace($str,"666",2,10));    //替换截取字符串,从2的位置开始截取10位,并替换成指定字符串
    
    //        过滤
    //        print_r(trim($str));    //默认过滤字符串两端的空格,也可以过滤指定字符串
    //        print_r(ltrim($str));    //过滤字符串左端空格字符串
    //        print_r(rtrim($str));    //过滤字符串右端空格字符串
    //        print_r(addslashes($str));   //使用反斜线引用字符串中的特殊字符
    
    //        拆分/合并
    //        print_r(implode($arr));    //将数组值合并成字符串
    //        print_r(join($arr));    //将数组值合并成字符串
    //        print_r(explode(" ",$str));    //将字符串以指定标识,拆分成数组
    //        print_r(str_split($str,2));    //将字符串以指定数量,拆分成数组
    
    //        print_r(iconv('UTF-8','GB2312',$string));    //将$string由utf-8编码转化为GBK格式
    //        print_r(mb_convert_encoding('UTF-8','GB2312',$string));    //作用跟iconv一样,但是效率差一点,兼容性更强
    
    
    //        其他
    //        print_r(strrev($str));    //字符串反转
    //        print_r(str_repeat("3",5));    //字符串重复
            print_r(str_shuffle($str));    //字符串随机排序
    
            exit();
        }

     

    php里面常用的文件操作函数:

       public function file_function_test(){
            $path = 'C:\Users\Administrator\Desktop\test.txt';
    //        一、判断普通文件和目录
    //        $file = is_file($path);    //判断是否文件,返回布尔值
    //        $file = is_dir($path);    //判断是否目录,返回布尔值
    
    //        二、文件的属性
    //        $file = filetype($path);    //获取文件类型
    //        $file = file_exists($path);    //判断文件是否存在
    //        $file = filesize($path);    //获取文件大小,默认字节为单位
    //        $file = fileatime($path);    //获取文件最近被访问时间
    //        $file = date('Y-m-d h:i:s',filectime($path));    //获取文件最后改变时间(任何数据的修改)
    //        $file = filemtime($path);    // 获取文件最后内容被修改时间(指仅是内容修改)
    
    //        三、目录的基本操作
    //        $file = basename($path,".txt");  //获取路径的文件名,若第二个有参数则返回内容去掉参数内容
    //        $file = dirname($path);    //获取文件路径
    //        $file = pathinfo($path);    //得到指定路径的四部分内容:目录名 $file['dirname']="C:\Users\Administrator\Desktop"、基本名 $file['basename']="test.txt",扩展名 $file['extenssion']="txt",文件名 $file['filename']="test"
    //        $file = mkdir($path);    //新建目录
    //        $file = rmdir($path);    //删除指定的空目录
    //        $file = scandir($path);    //列出指定路径中的文件和目录
    
    //        四、文件的基本操作
    //        $file = fopen($path,'r');    //打开文件或URL,第二个参数‘r’,以只读方式打开,mode具体说明自行百度
    //        $file = fclose($file);    //关闭文件
    //        $file = file_get_contents($path);    //把整个文件读入一个字符串中
    //        $file = file_put_contents($path,"Runoob");    //内容写入指定的文件中,文件不存在则自动创建
    //        $file = readfile($path);    //读入一个文件并写入到输出缓冲
            $file = unlink($path);    //删除文件
            
            echo "<pre>";var_dump($file);
            exit;
        }

     

    展开全文
  • // 列出他们的其中一个 list ( $drink , , $power ) = $info ; echo " $drink has $power .\n" ; // 或者让我们跳到仅第三个 list ( , , $power ) = $info ; echo "I need $...
  • PHP数组常用方法

    2018-07-13 16:28:11
    PHP数组常用方法目录结构: ----|-判断/查找: | |_ is_array — 检测变量是否是数组 | |_ in_array — 检查数组中是否存在某个值 | |_ array_key_exists — ...
  • PHP数组常用函数

    2019-10-06 09:02:04
    array_chunk():将一个数组分割多个 $input_array = array('a', 'b', 'c', 'd', 'e'); array_chunk($input_array, 2); # [['a', 'b'], ['c', 'd'],['e']] array_chunk($input_array, 2, true); # [[0 => 'a', 1 ...
  • PHP数组常用方法 目录结构: ----|-判断/查找: | |_ is_array — 检测变量是否是数组 | |_ in_array — 检查数组中是否存在某个值 | |_ array_key_exists — 检查数组里是否有指定的键名或索引 | |_ array_search ...
  • php 数组常用函数

    2019-12-02 17:18:57
    php教程中数组是种强大的数据类型,他可以做的事情很多,可以存储不同的数据类型在一个数组中,下面我们列出数组常用的操作,排序,键名对数组排序等做法。 /* 数组常用函数 * *数组的排序函数 * sort() * ...
  • PHP数组常用函数

    2016-12-30 16:24:00
    PHP数组是种强大的数据类型,他可以做的事情很多,可以存储不同的数据类型在一个数组中,下面我们列出数组常用的操作,排序,键名对数组排序等做法。 /* 数组常用函数 * *数组的排序函数 * sort() * ...
  • php数组常用函数

    2017-01-02 20:06:00
    array_column— 返回数组中指定的一 array_combine— 创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值 array_count_values— 统计数组中所有的值出现的次数 array_diff_assoc...
  • PHP常用的十个数组函数in_arrayarray_searcharray_key_existsarray_valuesarray_filterarray_columnarray_mergearray_poplistksort in_array 【in_əˈrā】 检查数组中是否存在某个值 <?php @see ...
  • php教程中数组是种强大的数据类型,他可以做的事情很多,可以存储不同的数据类型在一个数组中,下面我们列出数组常用的操作,排序,键名对数组排序等做法。 /* 数组常用函数  *  * 数组的排序函数 ...
  • 目录前言内容:一、判断/查找:1、is_array — 检测变量是否是数组1、语法2、使用3、类似的方法2、in_array — 检查数组中是否存在某个值1、语法2、使用3、array_key_exists — 检查数组里是否有指定的键名或索引1、...
  • php数组

    2016-09-13 13:20:51
    数组php中应用非常的多了在我们找工作时可能数组试题也多在学习中也就到比较多,这里给各位整理了大量的关于php数组的例子,有兴趣的和小编来看这篇php入门数组的使用到面试题文章. 1.数组的概念 数组就是一个...
  • PHP数组

    2018-06-12 01:28:00
    PHP数组的分类 索引数组数组的下标是整数 关联数组数组的下标是字符串 ③PHP数组的创建 php数组元素由两部分组成,键名【下标】和键值 索引数组的创建,可以显示创建,也可以隐式创建,创建的...
  • 常用数组函数

    2019-06-24 21:04:30
    php 中的数组函数 ... array_column— 返回数组中指定的一 array_combine— 创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值 array_count_values— 统计数组中所有的值 array_d...
  • 常用数组相关的函数   五.面向对象   六.三大特性以及修饰符、关键字   七.抽象类、接口、多态性   八.魔术方法,魔术常量       一.PHP循环结构分类: (1)While循环  语法格式:
  • PHP 数组

    2018-02-07 13:31:00
    数组能够在单个变量中存储多个值: 数组是什么 数组是一个能在变量中存储多个值的特殊变量 在 PHP中,array()函数用于创建数组: array(); 在PHP中,有三种类型的数组: 数值数组-带有数字ID键的数组 关联...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,043
精华内容 6,817
关键字:

列出php常用数组