php基础巩固加强(四)

1.什么是数组？

数组就是在内存里有一块连续的内存空间（堆空间），这里面可以保存多个数据，数据没有数据类型的限制。

2.       PHP数组与其他语言的数组区别？

a)         PHP数组没有长度限制，其他语言C必须事先指定数组长度，如果超出长度，就称之为溢出。

b)         PHP数组没有数据类型限制，其他语言C在事先必须声明数组能存储的数据类型。

c)         数组的下标可以是数值也可以是字符串。

数组基本语法

关键字:array

显示数组语法

$arr = array(元素1，元素2，元素3…); //数据类型一定是数组

显示数组语法demo如下:

//定义数组
//显示定义数组array
$arr1 = array('犬夜叉','男',200,180,140); //索引类型数组.当前数组的下标(键名[key])全是数字(整形)

//var_dump($arr1);
echo $arr1[3];  //输出:180

隐式数组语法

$arr[] = 元素1;       //定义一个$arr变量，将元素1添加进来

$arr[] = 元素2;       //将元素2添加到$arr变量中

隐式数组语法demo如下:

//隐式定义数组
$arr2[] = '桔梗';
$arr2[] = '女';
$arr2[] = 18;
$arr2[] = 165;
$arr2[] = 90;

var_dump($arr2);

//访问数组
echo $arr2[1];    //输出:女   因为数组的下标默认从0开始

访问数组

数组本质是变量，访问的时候就是直接使用变量，但是因为数组元素有多个，而系统没有办法直接区分到底用户是访问的哪一个，所以需要用户在访问数组的时候，使用数组下标（键名）

语法:$数组变量[下标]

     数值下标:$arr[数值]

     字符串下标:$arr[‘字符串’]

访问数组demo:

//访问数组
$arr = array('九阳真经','降龙十八掌','六脉神剑','北冥神功');

echo $arr[1];  //输出:降龙十八掌

数组分类

根据数组的下标的不同进行分类

索引数组：当前数组的下标（键名）全是数字（整型）

关联数组：当前数组的下标全是字符串（使用最多）

混合数组：数组的下标既有数字又有字符串

索引数组

定义方式:系统自动分配下标

系统自动分配下标demo:

//系统自动分配索引序列号（下标键名）
// 0 => 犬夜叉，键值对形式  0就是:键(key)  犬夜叉就是:值(value)


//显示
$arr1 = array('a','b','c');
//上方$arr1的数组定义方式等价于这种:$arr1 = array(0=>'a',1=>'b',2=>'c');
var_dump($arr1);


//隐式
$arr2[] = 'a';  //等价于:$arr2[0] = 'a';
$arr2[] = 'b';  //等价于:$arr2[1] = 'b';
$arr2[] = 'c';  //等价于:$arr2[2] = 'c';
var_dump($arr2);

定义方式:用户手动分配下标

第一种:

//手动分配下标
//显示
$arr3 = array( 3 => 'a',2 => 'b',1 => 'c'); //a的索引下标是3  b的索引下标是2  c的索引下标是1 
var_dump($arr3);

第二种:

//手动分配下标
//隐式
$arr4[5] = 'a';  //a的下标是5
$arr4[3] = 'b';  //b的下标是3
$arr4[1] = 'c';  //c的下标是1
var_dump($arr4);

第三种(比较特殊):

//手动分配下标
//显示的方式创建数组
$arr5 = array('a',5 => 'b','c');
var_dump($arr5); 

/*输出如下:
array (size=3)
  0 => string 'a' (length=1)
  5 => string 'b' (length=1)
  6 => string 'c' (length=1)

以上可以看出 a值的索引是0  b值的索引是5  c值的索引是6
*/

系统分配所引方式

1.系统是从0开始分配下标,依次递增1

2.用户可以手动分配下标(下标不能重复:重复的效果就是覆盖)

3.如果用户在某一处指定了下标,那么后续元素自动分配的下标从前面的最大值(索引)开始。详情看上方索引数组第三种方式

关联数组

定义关联数组

显示创建关联数组

demo:

//关联数组
//显示方式创建关联数组
$arr1 = array('a' => 'a', 'b' => 'b','c' => 'c'); //$arr1数组中的元素全是键值对类型,a的键(key)是a,b的键是b,c的键是c，并且键全是string(字符串)类型
var_dump($arr1);

隐式创建关联数组

demo:

//关联数组
//隐式方式创建关联数组
$arr2['a'] = 'apple';  //apple的键是:a
$arr2['b'] = 'banana'; //banana的键是:b
$arr2['c'] = 'cake';  //cake的键是:c
$arr2['d'] = 'duck';  //duck的键是:d

var_dump($arr2);

//访问关联数组
echo $arr2['a'];  //输出:apple
echo $arr2['d']; //输出:duck

关联数组

1.下标必须使用引号包含

2.下标不允许重复,重复会覆盖

遍历数组

将数组里面的所有元素都取出来。

count()：对数组长度进行计算，返回数组元素的个数（长度）

for循环遍历数组demo:

  //数组遍历
$arr = array('邹荣华','王默','李伟豪','张日晖','陶丹凤','周娃女','邓桂敏');
//          0     1     2     3        4     5     6
//索引数组：下标连续

//获得数组长度
$length = count($arr);
//echo $length;       输出:7

//for循环遍历数组
for($i = 0; $i < $length;$i++)
   {
   //输出当前数组元素
   echo $arr[$i],"\t";
}

  //以上for循环输出:邹荣华 王默 李伟豪 张日晖 陶丹凤 周娃女 邓桂敏

for循环数组有以下几点要求:

1.       数组必须是索引数组

2.       所以必须是连续的索引

3.       索引必须从0开始

如果数组是一个关联数组，那么就完全不能使用for循环来进行遍历。PHP提供了一个foreach来实现对数组元素的遍历

语法:foreach(数组 as 键值对$key => $value)

{

    //使用$key当做当前元素的下标

    //使用$value当做当前元素的值

}

foreach遍历数组demo如下:

$arr = array('邹荣华','王默','李伟豪','张日晖','陶丹凤','周娃女','邓桂敏');

//foreach遍历数组
foreach($arr as $key => $value)
{
    echo 'key = ' . $key . ' value = ' . $value . '<br/>';
}

/*
以上foreach 输出如下:
key = 0 value = 邹荣华
key = 1 value = 王默
key = 2 value = 李伟豪
key = 3 value = 张日晖
key = 4 value = 陶丹凤
key = 5 value = 周娃女
key = 6 value = 邓桂敏
*/


//定义一个关联数组
$array['name'] = '张三丰';
$array['age']  = 103;
$array['jineng'] = '太极';
$array['department'] = '武当';

var_dump($array);

//foreach遍历
foreach($array as $key => $value)
{
    echo 'key = ' . $key . ' value = ' . $value . '<br/>';
}

/*
以上foreach 输出如下:
key = name value = 张三丰
key = age value = 103
key = jineng value = 太极
key = department value = 武当
*/

数组指针

每个数组都默认有一个指针(定位符),默认指向数组的第一个元素。如果在对数组使用循环遍历，那么该指针会在访问指针当前所指向的元素之后，将自己向下移动一位，指向下一个元素的地址。如果当指针遍历完最后一个元素，指针会继续下移，从而移除数据空间(元素),从而再次对数组元素进行访问的时候，返回FALSE。

函数遍历数组

each():每次从数组中获取当前数组指针所指向的元素，返回一个有四个元素的数组（关联+索引），并且将数组的指针下移一位

each访问数组元素会得到关联索引混合数组,并且会将数组指针下移

each访问数组demo如下:

//each访问数组

//定义数组
$arr['name'] = '张无忌';
$arr['age'] = '20';
$arr['power'] = '乾坤大挪移';
$arr['company'] = '明教';
//var_dump($arr);

//each
var_dump(each($arr));     //name
var_dump(each($arr));     //age
var_dump(each($arr));     //power
var_dump(each($arr));     //company
var_dump(each($arr));     //false

/*
以上所有each($arr)输出结果如下:
array (size=4)
  1 => string '张无忌' (length=9)
  'value' => string '张无忌' (length=9)
  0 => string 'name' (length=4)
  'key' => string 'name' (length=4)
array (size=4)
  1 => string '20' (length=2)
  'value' => string '20' (length=2)
  0 => string 'age' (length=3)
  'key' => string 'age' (length=3)
array (size=4)
  1 => string '乾坤大挪移' (length=15)
  'value' => string '乾坤大挪移' (length=15)
  0 => string 'power' (length=5)
  'key' => string 'power' (length=5)
array (size=4)
  1 => string '明教' (length=6)
  'value' => string '明教' (length=6)
  0 => string 'company' (length=7)
  'key' => string 'company' (length=7)
boolean false

所以each()函数会返回一个有四个元素的的数组 以上的输出的结果中0和key就是键值对中的键(即key) 而1和value就是键值对中的值(即value)
*/
each在得不到数据（数组指针指向数组最末，没有元素）的时候返回FALSE
each本身不能重置数组指针

//foreach进行遍历
/*
foreach($arr as $key => $value)
{
   echo $key. ':'.$value.'<br/>';
}
*/
//foreach指针遍历完了之后数组指针指向数组末端
//var_dump(each($arr));	 //false


使用each循环遍历数组,循环条件是一个赋值表达式 请看一下while循环

//each配合循环while遍历数组

while($each = each($arr))
{
    //while内部条件顺序
    //1.先计算表达式结果
    //1.1先计算右边each($arr)，得到数组或者FALSE
    //1.2进行赋值，将结果赋值给$each变量
    //2.判断条件：对$each进行自动转换，如果是数组变成true，如果是FALSE就不需要转变

    //如果each得到数组元素，就为真，进入循环体
    //如果each得不到元素，返回FALSE，就不再进入循环体

    //输出元素信息
    echo 'key = ',$each[0] ,' value = ',$each['value'],'<br/>';
}

list使用

list是一个语法结构,将得到的数组里的元素,必须是以0开始的索引元素,对应的赋值给list所指定的变量里。

语法:list($first,$second,$third) = array('张无忌',20,'男','乾坤大挪移');

<=========>

$first = '张无忌';

$second = 20;

$third = '男';

因为each返回的结果里有两个索引元素0和1，所以一般使用list与each进行配对使用

list+each+while循环遍历数组demo如下:

//定义数组
$arr['name'] = '张无忌';
$arr['age'] = '20';
$arr['power'] = '乾坤大挪移';
$arr['company'] = '明教';


//list($first,$second) = each($arr);
//each($arr)
//array(0 => 'name','key' => 'name',1 => '张无忌','value' => '张无忌');
//echo $first,$second;

//list($third,$fourth) = array(1 => 'third','fourth' => 'fourth');
list($third,$fourth) = FALSE;
//list结构允许数组是一个布尔值FALSE，从而不会去数组里取元素赋值给对应的变量

//list+each+while遍历数组
while(list($first,$second) = each($arr))
{
    //判断each得到的结果
    echo $first,$second;
}

/*以上while循环中$first和$second会输出以下内容:

name张无忌age20power乾坤大挪移company明教  即:$first就是key $second就是value
*/

list搭配each的好处：能够直接将数组的元素取出来，且赋值给变量，而在后续的程序中可以直接使用变量来操作。

二维数组

数组的元素的值是一个数组数据类型。

array

(

   'person1' => array('name' => '张无忌','age' => 20,'power' => '九阳神功'),

   'person2' => array('name' => '周芷若','age' => 18,'power' => '九阴真经')

);

二维数组demo如下:

//二维数组
$arr = array
(
    'person1' => array('name' => '乔峰','age' => 36,'power' => '降龙十八掌'),
    'person2' => array('name' => '段誉','age' => 18,'power' => '凌波微步'),
    'person3' => array('name' => '虚竹','age' => 23,'power' => '北冥神功')
);

//var_dump($arr);

//访问乔峰的年龄
//echo $arr['person1']['age'];       //36

//访问Person1
//echo $arr['person1'];                //错误，不能直接echo数组
//var_dump($arr['person1']);

//print_r打印数组
//print_r($arr['person1']);             //打印数组结构和内容，不管数据类型以及元素个数


//一维数组
$qiaofeng = array('name' => '乔峰','age' => 36,'power' => '降龙十八掌');
//echo $qiaofeng['power'];

//二维数组遍历
foreach($arr as $key => $value)
{
    //将二维数组遍历成一维数组，然后直接访问一维数组里的数据（元素）
    //输入个人信息
    echo "$key :姓名是" . $value['name'] . ' 年龄是' . $value['age'] . ' 技能是' . $value['power'] . '<br/>';

}

二维数组增删改查Demo如下:

//二维数组增删改查

//定义一个数组
$arr = array();

//新增数组元素
$arr[] = array('a','b');
$arr[] = array('c','d');

//查看数组
echo $arr[0][1];  //输出:b
echo $arr[1][0];  //输出:c


//修改数组
//修改二维数组d=>e
$arr[1][1] = 'e';
echo $arr[1][1]; //输出:e

//修改一维数组0 => 'hello world';
$arr[0] = 'hello world';
//var_dump($arr);

//删除数组
//删除二维数组
unset($arr[1][0]);

//删除一维数组
unset($arr[0]);
var_dump($arr);

数组相关函数

key():获取当前数组当前指针所指向元素的下标

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

var_dump(key($arr)); //输出:name

current():获取当前数组指针所指向的元素的值

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

//current函数
var_dump(current($arr)); //输出:杨过

next():返回数组当前指针所指向的下一位的元素的值，并指针下移一位

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

//current函数
var_dump(current($arr)); //输出:杨过

//next函数
var_dump(next($arr)); //输出：23

var_dump(key($arr)); //输出:age

注意:如果当前指针已经在数组元素的最后一个元素,那么 返回指针依然下移一位 移除了数组

prev():返回当前指针所在位置的前一个元素的值，并且将指针向前移动一位

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

//current函数
var_dump(current($arr)); //输出:杨过

//next函数
var_dump(next($arr)); //输出：23

var_dump(key($arr)); //输出:age

//prev函数
var_dump(prev($arr)); //输出:杨过
var_dump(key($arr)); //输出：name

注意:如果当前指针已经在数组元素的第一个元素，那么使用Prev()函数将会将数组的指针移除数组，返回FALSE

如果指针一旦移除数组，那么都不能通过prev或者next将指针拉回来。

end():获取数组元素最后一个元素的值，指针也会指向最后一个元素

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

var_dump(end($arr)); //输出:黯然销魂掌
var_dump(key($arr));  //输出:power

注意:end()函数与reset()函数有异曲同工之妙，也能把移除数组的指针给重置回来

reset:重置数组的指针，让数组指针指向第一个元素，如果成功返回第一个元素的值，失败返回FALSE

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

var_dump(end($arr)); //输出:黯然销魂掌
var_dump(key($arr));  //输出:power

//reset()函数
var_dump(reset($arr)); //输出:杨过
var_dump(key($arr));  //输出:name

注意:如果数组第一个元素被删除，那么指针重置之后，是第二个元素（从第一个有效元素开始）

函数对数组进行遍历

demo如下:

//reset,key,current,next对数组进行遍历

$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

while($value = current($arr)){
    //如果$value有值，那么结果就是TRUE
    //获取键名
    $key = key($arr);

    //输出
    echo 'key 为',$key,' value ',$value,'<br/>';

    //改变数组的指针：下移
    next($arr);
}

//如果后续还需要使用函数来访问数组，那么需要重置数组指针，foreach不需要，因为foreach会自己重置数组指针

array_keys():获取数组的所有下标,返回一个索引数组,数组元素的值都是目标数组的下标

demo如下:

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

var_dump(array_keys($arr));

/*
输出如下:
array (size=3)
  0 => string 'name' (length=4)
  1 => string 'age' (length=3)
  2 => string 'power' (length=5)
*/

array_values():获取数组所有的值，返回一个索引数组

demo如下：

//定义数组
$arr = array(
    'name' => '杨过',
    'age'  => 23,
    'power'=> '黯然销魂掌'
);

//array_values()函数使用;
var_dump(array_values($arr));

/*
输出如下:
array (size=3)
  0 => string '杨过' (length=6)
  1 => int 23
  2 => string '黯然销魂掌' (length=15)
*/

即便是针对二维或者多维数组，那么array_keys()和array_values()函数结果也是一样的

二维或多维数组demo如下:

//二维数组
$arr2 = array(
    'person1' => array('赵敏','18'),
    'person2' => array('青翼蝠王',56)
);

var_dump(array_keys($arr2));
/*输出如下:
array (size=2)
  0 => string 'person1' (length=7)
  1 => string 'person2' (length=7)
*/


var_dump(array_values($arr2));
/*输出如下:
array (size=2)
  0 => 
    array (size=2)
      0 => string '赵敏' (length=6)
      1 => string '18' (length=2)
  1 => 
    array (size=2)
      0 => string '青翼蝠王' (length=12)
      1 => int 56
*/

数据结构模拟函数

栈: 先进后出,压栈(把数据加入到栈里),出栈(把栈里的数据弹出来)

队列: 先进先出,入队(从数组尾端插入数据),出队(把数组的元素,从头部出来)

以下四个函数

1、都是对原数组进行操作。

2、都会重置数组里面的索引

array_push(): 从数组的尾端加入一个元素(压栈)

array_pop();从数组尾端弹出弹出一个元素(出栈)

demo如下(压栈和出栈):

//数组模拟数据结构：栈和队列

//空数组：栈
$arr = array();

//数组模拟栈
//压栈(即把数据压入到栈里)
array_push($arr,'one');
array_push($arr,'two');

var_dump($arr);
/*输出：
array (size=2)
  0 => string 'one' (length=3)
  1 => string 'two' (length=3)
 */

//出栈
var_dump(array_pop($arr)); //输出:two


var_dump($arr);
/*
输出:
array (size=1)
0 => string 'one' (length=3)
*/

array_shift(): 从数组头部将数组元素移出

array_unshift():从数组的头部插入数据

demo如下(入队和出队):

//PHP数组模拟队列数据结构

//初始化队列
$arr = array();

//入队,将元素从数组的尾部插入到数组里
array_push($arr,'one');
array_push($arr,'two');
array_push($arr,'three');

//出队，将元素从数组的头部弹出
var_dump(array_shift($arr)); //输出:one

var_dump($arr);
/*输出：
array (size=2)
  0 => string 'two' (length=3)
  1 => string 'three' (length=5)
*/

//以下内容与模拟队列数据结构无关
//从数组头部插入数据
array_unshift($arr,'four');

var_dump($arr);
/*输出:
array (size=3)
  0 => string 'four' (length=4)
  1 => string 'two' (length=3)
  2 => string 'three' (length=5)
*/

数组与字符串之间的转换

explode(): 将字符串按照指定的分隔符分解成一系列小的字符串，都成为数组的一个元素

implode(): 将一个数组里的所有的元素按照某个分隔符进行拼接，变成一个字符串

demo如下:

//数组与字符串之间的互相转换

//定义数组
$arr = array('黑猫警长','黑色','流氓');

//将一个数组拼接成一个字符串implode
$str = implode('|',$arr);
echo $str;   //输出:黑猫警长|黑色|流氓


//将一个有结构的字符串转换成一个数组：explode
$ex_arr = explode('|',$str);

var_dump($ex_arr);
/*
输出如下:
array (size=3)
  0 => string '黑猫警长' (length=12)
  1 => string '黑色' (length=6)
  2 => string '流氓' (length=6)
*/

range():按照ASCII码能够指定范围，自动生成数组元素的函数

demo如下:

//range,生成指定范围的数组
$arr1 = range(1,9);    //生成一个1到9 的索引数组
//print_r($arr);

$arr2 = range('a','z');    //生成一个a到z的索引数组
$arr3 = range('A','Z');    //生成一个A到Z的索引数组

//var_dump($arr1 + $arr2); //26个元素
//var_dump(array_merge($arr1,$arr2));  //35个元素

//合并生成的所有数组
$arr = array_merge($arr1,$arr2,$arr3);    //61个元素
//也可以这样直接简写为:$arr = array_merge(range(1,9),range('a','z'),range('A','Z'));

array_rand():从数组中随机取出指定长度的个数的元素下标

demo如下:

//range,生成指定范围的数组
$arr1 = range(1,9);    //生成一个1到9 的索引数组
//print_r($arr);

$arr2 = range('a','z');    //生成一个a到z的索引数组
$arr3 = range('A','Z');    //生成一个A到Z的索引数组

//var_dump($arr1 + $arr2); //26个元素
//var_dump(array_merge($arr1,$arr2));  //35个元素

//合并生成的所有数组
$arr = array_merge($arr1,$arr2,$arr3);    //61个元素
//也可以这样直接简写为:$arr = array_merge(range(1,9),range('a','z'),range('A','Z'));


//随机取出指定长度的字符串
//var_dump(array_rand($arr,4));

//得到4个随机下标
$arr_key = array_rand($arr,4);

shuffle():将原来的数组里的元素打乱

demo如下:

//range,生成指定范围的数组
$arr1 = range(1,9);    //生成一个1到9 的索引数组
//print_r($arr);

$arr2 = range('a','z');    //生成一个a到z的索引数组
$arr3 = range('A','Z');    //生成一个A到Z的索引数组

//var_dump($arr1 + $arr2); //26个元素
//var_dump(array_merge($arr1,$arr2));  //35个元素

//合并生成的所有数组
$arr = array_merge($arr1,$arr2,$arr3);    //61个元素
//也可以这样直接简写为:$arr = array_merge(range(1,9),range('a','z'),range('A','Z'));


//随机取出指定长度的字符串
//var_dump(array_rand($arr,4));

//得到4个随机下标
$arr_key = array_rand($arr,4);


//打乱数组下标元素
shuffle($arr_key);

综合以上range(),array_rand(),shuffle()函数可以实现生成随机验证码功能

验证码生成demo如下:

//生成验证码字符串

//range,生成指定范围的数组
$arr1 = range(1,9);    //生成一个1到9 的索引数组
//print_r($arr);

$arr2 = range('a','z');    //生成一个a到z的索引数组
$arr3 = range('A','Z');    //生成一个A到Z的索引数组

//var_dump($arr1 + $arr2); //26个元素
//var_dump(array_merge($arr1,$arr2));  //35个元素

//合并生成的所有数组
$arr = array_merge($arr1,$arr2,$arr3);    //61个元素
//也可以这样直接简写为:$arr = array_merge(range(1,9),range('a','z'),range('A','Z'));


//随机取出指定长度的字符串
//var_dump(array_rand($arr,4));

//得到4个随机下标
$arr_key = array_rand($arr,4);


//打乱数组下标元素
shuffle($arr_key);

//取得下标对应的数组的值
$captcha = '';

foreach($arr_key as $value)
{
    $captcha .= $arr[$value];
}

echo $captcha;

数组合并:+和array_merge()

         +:保存第一个数组的所有元素，如果后面的数组的元素与前面数组的元素的下标相同，那么就忽略，如果不同则加到第一个数组里,最终返回一个数组

         array_merge():先保留第一个数组的所有元素，如果后面数组的元素与前面数组的元素关联下标相同则用后面数组的元素覆盖前面的;如果是索引下标，直接添加到第一个数组后面，重置索引。

以上使用数组方式生成验证码比较麻烦，可以使用下面这种字符串方式生成验证码,代码如下:

//通过字符串来随机生成验证码
$str = "123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

//随机获取对应的字符
$captcha = '';

//生成4位随机验证码
for($i = 0;$i < 4;$i++)
{
    //获取1到61之间的随机数
    $num = mt_rand(1,61);

    //字符串获取某个字符，可以使用类似数组下标形式访问$str[0] 会输出:1
    $captcha .= $str[$num];
}

//输出验证码
echo $captcha;

数组的比较

数组的比较主要是比较数组长度，数组元素的值

==和===

==:要求数组长度一致，数组元素的值相等，下标也要相等

===:数组长度一致,值和类型都完全一致,出现的顺序必须也相同

demo如下:

//数组比较

$arr1 = array(1,2,3);
$arr2 = array(3,2,1);
$arr3 = array(2 =>3,1 => 2, 0 => 1);

//==比较
var_dump($arr1 == $arr2);  //false，下标对应的元素的值不等
var_dump($arr1 == $arr3);  //true


//===比较
var_dump($arr1 === $arr3);  //false

排序算法

冒泡算法,快速排序,选择排序和插入排序。

排序算法的要求

1、数组元素都必须的是数值

这里只说一下冒泡算法，冒泡原理如下:

1、第一次：拿着数组的第一个元素，分别从第二个元素开始比较，如果前面的元素比后面的元素大，则交换两个元素，得到较大的这个值，继续向后比较，直到数组元素的最后，实现一次冒泡（冒泡一次，就得到当前“剩余”数组的最大值，并且放到数组的“最后面”

2、第二次开始，还是从第一个元素开始比较，但是只比较到数组长度要-1位置，并且每次的比较次数都依次-1

冒泡排序算法代码如下:

//冒泡排序
$arr = array(2,3,8,4,1,7,9);

//因为排序需要每次将一个元素与数组的其他元素进行比较，所以需要两层循环来控制
//外层循环控制冒泡次数
//内存循环比较每次的大小，得到每次的最大值（泡）

for($i = 0,$length = count($arr);$i < $length;$i++)
{

    //内存循环
    for($j = 0;$j < ($length - $i - 1);$j++)
    {
        //拿着j变量所对应的数组元素，与后面的元素进行比较
        if($arr[$j] > $arr[$j + 1])
        {
            //交换位置
            $temp     = $arr[$j];
            $arr[$j]   = $arr[$j+1];
            $arr[$j+1] = $temp;
        }

    }
}

var_dump($arr);

/*输出如下:
array (size=7)
  0 => int 1
  1 => int 2
  2 => int 3
  3 => int 4
  4 => int 7
  5 => int 8
  6 => int 9
 * */

声明：禁止任何非法用途使用，凡因违规使用而引起的任何法律纠纷，本站概不负责。