• 前端PHP入门-025-数组-重中之重

    数组是PHP中一个 很很很很很很很很很很重要 的一个 数据类型 。
    学习数组，大家主要学习两部份的知识：
    1.数组的定义，定义中的一些注意的坑
    2.数组的函数使用

    认识数组

    数组定义

    数组在之前我们让大家记住两个观点：

    1. 数组可以存入 多个不同类型 的数据，是一个复合数据类型。
    2. 数组的英文是array，学一了一下最简单的数组声明。

    那我们来进行简单的回顾：

    1. <?php
    3.     $shu = array(1 , 1.5 , true ,'天王盖地虎，小鸡炖蘑菇');
    5.     echo '<pre>';
    6.     var_dump($shu);
    7.     echo '</pre>';
    9. ?>

    在上例中，我们发现我们存入了：

    1. 整型
    2. 浮点
    3. 布尔
    4. 字符串

    注： 上例中echo pre这个标签的主要目的是为 原样输出 <HTML的时候学习过&tt;，格式展示的更好看，更清晰。

    我们用var_dump()打印出来显示看一下效果：

    看图说话：

    1. array(size = 4) 说明里面有4个元素
    2. 0 => int 1 我们知道int是整型的意思，1是一个整型的数值。那前面的0,1,2,3和=>代表什么意思呢？
    3. 最新前的0，1，2，3代表的是值的读取标识号，我们称之为下标或者键（英文：key）
    4. => 是一个符号标准叫法叫作： 键值对应符 。因此，以后再看到 0=> int 1 可以这样来说。 下标访问符0对应整型的1。
    5. 我们还称数组里面的键值对为 元素 ， 元素 就是 键值对 的组合。

    在学习JavaScript的时候也有键值对的

    我们通过上例，其实你一不小心的就完成了数组其中的一种声明方式：
    ① 索引数组的声明
    所谓索引数组：就是 下标 全为 整型 的 数组 。

    你真的认识数组了吗?

    索引数组的下标必须要从0开始吗？
    答：这个问题其实不然，索引数组并不一定要从0开始。
    那如何能够不从0开始呢？
    答：需要用到大家在上面学的一 小块知识 哟。就是键值对应符。我们来动手写写。

    代码从模拟开始,模拟长了就有了自己的风格!有点像武侠中的 象形拳 .

    1. <?php
    2. $kele = array('只有不断努力才能博得未来',10 => 'NoAlike', '胖先生课堂' , '信胖哥得永生', 19 => '我最喜欢的歌是悟空' , '欧洲杯开始了');
    4.     //打印显示$kele
    5.     echo '<pre>';
    6.     var_dump($kele);
    7.     echo '</pre>';
    8. ?>

    上例中，我们一不小心就写了一个索引数组。不过索引数组的下标不是从0 开始的，而是从 10 开始的。

    不过上面的例子中，我们觉得写的不优美，我们可以将代码写的更加优美一些，格式更加清晰一些。

    1. <?php
    3. $kele = array(
    4.             '只有不断努力才能博得未来',
    5.             10 => 'NoAlike',
    6.             '胖先生课堂' ,
    7.             '信胖哥得永生',
    8.             19 => '我最喜欢的歌是悟空' ,
    9.             '欧洲杯开始了'
    10.         );
    12.     //打印显示$kele
    13.     echo '<pre>';
    14.     var_dump($kele);
    15.     echo '</pre>';
    16. ?>

    代码不是给你一个人看的,是给大家看的,漂亮优雅的代码就是你的形象

    运行代码效果：

    看图说话：

    1. 索引数组若不强制声明他的下标，他的下标是从0开始的。（我们的第一个数组的值：只有不断努力才能博得未来。这个值的 下标为0 ）。
    2. 如果我指定过下标他的下标就为我指定的值。如 下标为10和下标为19 ，都是通过我指定的下标值。
    3. 若某个值（如NoAlike），强制指定了下标（下标为10）。在它后面加上的值（胖先生课堂），不指定下标的话。他们的下标增长规律为 最大值+1 。

    例如：我最喜欢的歌是悟空下标为19.我在后面加上了：欧洲杯开始了。它的下标自动增长为了20。

    难吗?其实不难,对不对

    驾驭数组

    向索引数组中增加元素

    学习完了索引数组的创建，接下来我们学习索引数组的 增加 | 修改 | 删除 。

    1. <?php
    3. $minren = array(
    4.             '林志玲',
    5.             '王珞丹',
    6.             '郑晓彤',
    7.             '贾玲'
    8.         );
    10. //如何向这$minren这个数组中增加元素呢
    12. //猜猜范冰冰的下标是多少？
    13. $minren[] = '范冰冰';
    15. $minren[100] = '范爷';
    17. //它的下标又为几呢？
    18. $minren[] = '李晨';
    20. ?>

    总结：

    1. 向索引数组中增加元素用:
      1. 数组变量名[]
      2. 数组变量名[键值]
    2. 键值的增长规则与之前的规则一样。都是最大值加1的原则。

    向索引数组中删除元素

    我们还拿刚刚的数组来举例：

    待着疑问
    1.假设我不喜欢：郑晓彤，如何将郑晓彤给删掉呢？
    2.如果删除掉后范冰冰的下标为多少呢？
    3.如果在后面再追加一个元素，会填掉：“郑晓彤”留下来的空吗？ 
    1. <?php
    3. $minren = array(
    4.             '林志玲',
    5.             '王珞丹',
    6.             '郑晓彤',
    7.             '贾玲',
    8.             '范冰冰'
    9.         );
    13. unset($minren[2]);//弄掉了
    15. $minren[] = '金星';
    17. echo '<pre>';
    19. var_dump($minren);
    21. echo '</pre>';
    23. ?>

    运行效果:

    看图说话:

    1. 使用unset 删除变量 的方式来删除数组里面的值。
    2. 删除了中间的值，并 不会 让后面的下标向前自动移动。而是原来的值为多少就为多少
    3. 删除掉其中的某个值，新加入的值不会替换掉原来的位置，依然遵循最大值加1的原则。

    更新数组中的数据

    我们学习最简单的创造、增加和删除。我相信大家一定能够推理出如何修改值了。

    1. <?php
    3. $minren = array(
    4.             '林志玲',
    5.             '王珞丹',
    6.             '郑晓彤',
    7.             '贾玲',
    8.             '范冰冰'
    9.         );
    11. $minren[4] = '范爷';
    13. $minren[0] = '志玲,不结婚是等我吗?';
    15. echo '<pre>';
    17. var_dump($minren);
    19. echo '</pre>';
    21. ?>

    运行结果:

    看图说话:

    用变量名[键] = 新值。就把数组中的值定的值修改了。
    很简单吧

    索引数组的其他声明方式

    直接用之前未声明的变量，用变量名后面接中括号的方式声明数组。

    1. <?php
    3.     //直接写一个变量后面加上中括号，声明变量
    4.     $qi[] = '可口可乐';
    5.     $qi[10] ='百事可乐';
    7.     echo '<pre>';
    8.     var_dump($qi);
    9.     echo '</pre>';
    11. ?>

    推荐:简写方式

    1. <?php
    3.     $pang = [
    4.                 '杨幂',
    5.                 '王珞丹',
    6.                 100 => '刘亦菲',
    7.                 '黄圣依',
    8.                 '范冰冰'
    9.             ];
    11.     echo '<pre>';
    12.     var_dump($pang);
    13.     echo '</pre>';
    15. ?>

    问:数组长多是多少?

    关联数组[重点]

    声明关联数组

    索引数组适当的变一下形就出现了关联数组。只要数组里面有一个为字符串的数组，就为关联数组。

    通过上例中，我们发现数组的下标只能够为字符串，当然不能够满足我的需求。

    声明关联数组:

    • 跟索引数组的声明方式完成一样。
    • 不同的地方: 必须要指定 字符串 的 下标 和 必须 要使用 键值对应符 。
    1. <?php
    2.     //声明一下关联数组
    3.     $rela = array(
    4.             '帅' => '胖先生',
    5.             '很帅' => '黄晓明',
    6.             '灰常灰常帅' => '宁泽涛',
    7.             '有男人味的大叔' => '吴秀波',
    8.     );
    10.     //再来玩玩简洁声明
    12.     $drink = [
    13.              '美' => '凤姐',
    14.              '很美' => '芙蓉姐姐',
    15.              'verymei' => '王涛',
    16.              '心中滴女神呀' => '杨澜',
    17.              100 => '孙俪',
    18.              '娘娘',
    19.             ];
    21.     // 输出 $rela
    22.     echo '<pre>';
    23.     var_dump($rela);
    24.     echo '</pre>';
    26.     // 输出$drink
    27.     echo '<pre>';
    28.     var_dump($drink);
    29.     echo '</pre>';
    30. ?>

    运行结果：

    我们通过实验知道：

    1. 声明关联数组是 键名 => 值
    2. 在关联数组可以有索引数组的元素
    3. 重点: 关联数组中的索引数组的元素后再声明了无下标的元素，依然是最大值+1原则。(观察上图中的值为孙俪、娘娘的两个元素)。

    操纵关联数组

    1. <?php 
    2. $drink = [
    3.              '美' => '凤姐',
    4.              '很美' => '芙蓉姐姐',
    5.              'verymei' => '王涛',
    6.              '心中滴女神呀' => '杨澜',
    7.              100 => '孙俪',
    8.              '娘娘',
    9.             ];
    12. //追加方式与索引数组是一样的 
    13. $drink['ynj'] = '伊能静'; 
    14. //输出试试 
    15. echo '<pre>';
    16. var_dump($drink);
    18. echo '</pre>'; 
    19. //删除一个试试 
    20. unset($drink['verymei']);
    22. echo '<pre>';
    23. var_dump($drink);
    24. echo '</pre>'; 
    27. //将芙蓉姐姐 改成：心里美才是真的美 
    28. $drink['很美'] = '心里美才是真的美'; 
    30. echo '<pre>';
    31. var_dump($drink);
    32. echo '</pre>'; 
    33. ?>

    运行结果:

    关联数组其他形式的声明方式

    1. <?php
    3.     $drink['nf'] = '农夫山泉';
    5.     $cocacola = '可口可乐';
    7.     //当然可以是变量哟
    8.     $drink['kl'] = $cocacola;
    10.     $data = array(
    11.         'kl' => $cocacola,
    13.     );
    15. ?>

    通过上例我们发现，在关联数组当中也是可以不用array，直接在变量后面接括号。 括号里面插入字符串下标，一样也声明成功 。
    后面插入变量的例子，只不过把字符串变成了变量，当然没有问题。

    数组当中插入数组

    数组可以插入整型、浮点、字符串，那么数组当中可不可以插入数组呢？
    当然可以

    在学习数组的时候，我们定义了这样一组名词。对于 WEB前端 的各位请了解即可

    1. 一维数组 数组里面没有其他数组，只有单纯的一些变量或者值。
    2. 二维数组 数组里面插入了单层的一个数组，或者多个数组
    3. 三维数组 在数组（A）里面插入了一个数组（B），在B数组里面又插入了一层级的数组（C），这种我们就称为三维数组
    4. 超过三维的，统统都叫多维数组。

    注： 索引数组和关联数组当中都可以再插入其他数组，让数组变为 多维的 。

    我们来声明一个一维数组,只有一个维度。索引、关联均可,这个操作大家都很熟。

    1.一维数组

    1. <?php
    3.     //一维的索引数组
    4.     $data = [1 , 2 , 3 , 4 ,  10 => 250];
    6.     //一维的关联数组
    8.     $rela = [
    9.         'beijing' => '北京',
    10.         'shanghai' => '上海',
    11.         'tj' => '天津',
    12.     ];
    14.     echo '<pre>';
    15.     var_dump($rela);
    16.     echo '</pre>';
    18.     echo '<pre>';
    19.     var_dump($data);
    20.     echo '</pre>';
    21. ?>

    2.二维数组

    1. <?php
    2.     $person = array(
    4.         'office' => '办公室',
    6.         //注意：插入第一个数组哟
    7.         'family' => array(
    9.             '爸爸',
    10.             '妈妈',
    11.             'yeye' => '爷爷',
    12.             'nn' => '奶奶',
    13.         ),
    15.         //注意：又插入了一个平级的数组
    16.         'jiaotong' => array(
    17.             '自行车',
    18.             '摩托车',
    19.             '汽车',
    20.             '飞机',
    21.         ),
    22.     );
    24.     echo '<pre>';
    25.     var_dump($person);
    26.     echo '</pre>';
    27. ?>

    运行效果

    我们发现变量person 是一个数组类型。有三个元素（size=3）。

    • 第一个元素为 office 对应的是一个字符串“办公室”，
    • 第二个元素为family 里面是一个数组，这个数组又有4个元素，值分别为：爸爸、妈妈、爷爷、奶奶。
    • 第三个元素为jiaotong，里面也为一个数组有4个元素，值分别为：自行车、摩托车、汽车、飞机。

    好了，二维好声明，只要把格式写对了，确定是在一个数组里面再插入一个数组就好。

    那如何访问：爷爷和爸爸这两个值呢？

    1. <?php
    2.     $person = [
    4.         'office' => '办公室',
    6.         //注意：插入第一个数组哟
    7.         'family' => [
    9.             '爸爸',
    10.             '妈妈',
    11.             'yeye' => '爷爷',
    12.             'nn' => '奶奶',
    13.         ],
    15.         //注意：又插入了一个平级的数组
    16.         'jiaotong' => [
    17.             '自行车',
    18.             '摩托车',
    19.             '汽车',
    20.             '飞机',
    21.         ],
    22.     ];
    24.     //访问“爸爸”这什值
    25.     echo $person['family'][0];
    27.     echo '<br />-----分割线------<br />';
    29.     //访问“爷爷”这什值
    30.     echo $person['family']['yeye'];
    32.     echo '<br />-----分割线------<br />';
    34.     //访问“汽车”这什值
    35.     echo $person['jiaotong'][2];
    37. ?>

    我们看看结果如下：

    看图说话:

    • 访问二维数组不过是按照之前的下标读取方式依次向下读取即可。
    • 先写上变量，中括号写上family这个下标，再写上要访问元素的下标。

    3.三维数组

    1. <?php
    2.     $area = array(
    4.         'china' => array(
    6.             '上海',
    7.             '湖北',
    8.             '天津',
    9.             '北京' => array(
    10.                 'hd' => '海淀',
    11.                 '朝阳',
    12.                 '房山',
    13.                 'cp' => '昌平',
    14.             ),
    16.             '广东' => array(
    17.                 '深圳',
    18.                 '广州',
    19.                 '佛山',
    20.                 'dg' => '东莞',
    22.             ),
    24.         ),
    26.         'usa' => array(
    28.             '华盛顿',
    29.             '旧金山',
    30.             '纽约' => array(
    31.                     '曼哈顿区',
    32.                     '皇后区',
    33.                     '布鲁克林区',
    34.             ),
    36.         ),
    37.     );
    39.     echo '<pre>';
    40.     var_dump($area);
    41.     echo '</pre>';
    42. ?>

    运行效果：

    看图说话：

    • 在变量$area下有二个数组，一个为china，一个为usa。
    • 在china这个数组里面插入了上海、湖北、天津，又插入了北京和广东。而北京和广东又是一个数组。在北京和广东这两个数组里面分别有不同的元素。
    • 在这usa 这个数组里面插美国的华盛顿、旧金山和纽约。而纽约下面又是一个数组，说明了纽约下面的几个区。

    所以说，三维数组就是在数组里面再插入一个数组(A)，在A数组里面插入一个数组。

    获取数据

    1. <?php
    3. $area = array(
    5.     'china' => array(
    7.         '上海',
    8.         '湖北',
    9.         '天津',
    10.         '北京' => array(
    11.             'hd' => '海淀',
    12.             '朝阳',
    13.             '房山',
    14.             'cp' => '昌平',
    15.         ),
    17.         '广东' => array(
    18.             '深圳',
    19.             '广州',
    20.             '佛山',
    21.             'dg' => '东莞',
    23.         ),
    25.     ),
    27.     'usa' => array(
    29.         '华盛顿',
    30.         '旧金山',
    31.         '纽约' => array(
    32.                 '曼哈顿区',
    33.                 '皇后区',
    34.                 '布鲁克林区',
    35.         ),
    37.     ),
    38. );
    40. //读取华盛顿
    41. echo $area['usa']['0'];
    43. //读取：布鲁克林
    44. echo $area['usa']['纽约'][2];
    46. //读取：昌平
    47. echo $area['china']['北京']['cp'];
    49. //修改cp下标的值改为：西城区
    51. $area['china']['北京']['cp'] = '西城区';
    53. //输出看看原来昌平的值是否发生了变化
    54. echo $area['china']['北京']['cp'];
    56. ?>

    通过上面我们发现数组学习起来不难。

    学习多维数组的难点：

    注意格式: 将每个维度的 换行 、 缩进弄整齐 。就不容易出错了。

    【切记】

    1. 数组元素间的分割符为逗号，
    2. 在数组中插入数组的时候，不要在结尾处写成了分号（ ； ）
  • 相关阅读:
    Android：JNI之Java和C层的相互调用及多线程的回调实现
    高通sdm845_la2.0源码编译及使用QFIL刷机
    git常用指令
    Bouml快速使用指南
    Linux内核数据结构之kfifo详解
    输入系统：进程间双向通信(socketpair+binder)
    Android : 跟我学Binder --- (6) JAVA实现
    【LeetCode】167. Two Sum II
    【LeetCode】1. Two Sum
    【LeetCode】206. Reverse Linked List
  • 原文地址：https://www.cnblogs.com/pangxiansheng/p/5ec0d87089b7249db954710ca9128cc4.html
Copyright © 2020-2023  润新知