PHP5 - 数组 (数值数组 / 关联数组 / 多维数组) 遍历及 array API

小鱼儿 2023-07-06 09:50 21阅读 0赞

## 声明 ##

在 PHP5 中使用 `array()` 函数创建声明一个数组：

$arr = array('one', 'two', 'three');

其数组的类型有三种：

1.  **数值数组：** 带有数字 ID 键的数组。
2.  **关联数组：** 带有指定的键的数组(每个键关联一个值)。
3.  **多维数组：** 包含一个或多个数组的数组(二三维)。

## 获取数组长度 ##

在开始谈三种数组类型前，先来看一下如何获取数组长度。在 PHP5 中并不是使用 `.length` 获取，因为 PHP5 中数组不是对象(Object)。

使用 `count()` 函数来统计数组并返回长度：

# 声明
    $arr = array('one', 'two', 'three');
    
    # 返回长度
    echo count($arr);//3

## 一、数值数组 ##

其实就是普通的数组，即 **自动分配 ID 键(从 0 开始)** ：

# 自动分配 ID 键
    $arr = array('one', 'two', 'three');
    
    # 手动手配 ID 键
    $arr[3] = 'four';

## 二、关联数组 ##

所谓关联数组，指的是你 **分配给数组的指定的键** 的数组，有点类似对象的键值对。

# 第一种方式
    $arr = array('one' => '1', 'two' => '2');
    
    # 第二种方式
    $arr['one'] = '1';
    $arr['two'] = '2';

## 三、多维数组 ##

简单来说就是 **数组中嵌套数组**，它包含一个或多个数组的数组。

# 多维数组
    $arr = array(
        array('one'),
        array('two'),
        array('three')
    );
    
    # 格式化数组显示
    print '<pre>';
    print_r($arr);

**打印结果：**  
![在这里插入图片描述][20200218131653450.png]  
**通过观察数组维度，然后以索引下标方式访问。二维数组需要两个索引来选取元素，反之亦然：**

# 二维数组
    $arr = array(
        array('one'),
        array('two'),
        array('three')
    );
    
    # 选取 'two' 元素
    echo $arr[1][0];//two

同样，三维数组则需要 `array[一维下标][二维下标][三维下标]` 选取元素。

## 遍历数组 ##

遍历数组的需求很常见，下面我们分别遍历三种数组类型。

--------------------

**使用 `for` 循环来遍历【数值数组】：**

# 数值数组
    $arr = array('one', 'two', 'three');
    
    # 遍历
    for($i = 0; $i <= count($arr); $i++){ 
        echo $arr[$i];
        print '<br>';
    }
    // one
    // two
    // three

当然，使用 `foreach` 来遍历也是可以的。就像下面这样输出 key 与 value：

# 数字数组
    $arr = array('one', 'two', 'three');
    
    # 遍历数组
    foreach($arr as $key => $value){ 
        echo '索引：' . $key . '——————' . '值：' .$value;
    }
    // 索引：0——————值：one索引：1——————值：two索引：2——————值：three

--------------------

**使用 `foreach` 来遍历【关联数组】(注意：PHP5 的 foreach 会拷贝数组建立副本)：**

语法：`foreach($数组变量 as [$下标=>] $值){}`  
解释：通过 `$下标` 访问元素下标，通过 `$值` 访问元素值。

> \[$下标 =>\] 是可选参数。视情况而定。比如关联数组就需要，而数字数组就不需要。

# 关联数组
    $arr = array('one' => '1', 'two' => '2');
    
    # 遍历数组
    foreach($arr as $key => $value){ 
        echo '键：' . $key . '—————' . '值：' . $value;
    }
    // 键：one—————值：1键：two—————值：2

--------------------

**通过 `嵌套foreach` 遍历多维数组，说白了就是逐层遍历：**

# 二维数组
    $arr = array(
        0 => array('name' => 'Vue'),
        1 => array('name' => 'React'),
    );
    
    # 1. 首先遍历一维数组
    # 2. 然后再遍历二维数组
    # 注意：如果是三维以上则再次嵌套即可(但不建议三层以上)
    foreach($arr as $value){ 
        foreach($value as $value2){ 
            echo $value2 . '<br>';
        }
    }
    // Vue
    // React

> 如果你想了解遍历原理，请访问：[https://wangjiabin.blog.csdn.net/article/details/104379573][https_wangjiabin.blog.csdn.net_article_details_104379573]

## 副本 ##

使用 `foreach` 遍历数组时，其实系统为我们建立了一个副本，遍历的结果 **不会影响到原数组**。

# Array
    $arr = array(1,2,3);
    
    # 遍历
    foreach($arr as $value){ 
        $value += 1;//尝试改变
        echo $value;//234
    }
    
    # 查看是否改变了元素组
    print '<pre>';
    print_r($arr);

![在这里插入图片描述][20200218175309587.png]

## Array API ##

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>array()</td> 
   <td>创建数组。</td> 
  </tr> 
  <tr> 
   <td>array_change_key_case()</td> 
   <td>返回其键均为大写或小写的数组。</td> 
  </tr> 
  <tr> 
   <td>array_chunk()</td> 
   <td>把一个数组分割为新的数组块。</td> 
  </tr> 
  <tr> 
   <td>array_combine()</td> 
   <td>通过合并两个数组来创建一个新数组。</td> 
  </tr> 
  <tr> 
   <td>array_count_values()</td> 
   <td>用于统计数组中所有值出现的次数。</td> 
  </tr> 
  <tr> 
   <td>array_diff()</td> 
   <td>返回两个数组的差集数组。</td> 
  </tr> 
  <tr> 
   <td>array_diff_assoc()</td> 
   <td>比较键名和键值，并返回两个数组的差集数组。</td> 
  </tr> 
  <tr> 
   <td>array_diff_key()</td> 
   <td>比较键名，并返回两个数组的差集数组。</td> 
  </tr> 
  <tr> 
   <td>array_diff_uassoc()</td> 
   <td>通过用户提供的回调函数做索引检查来计算数组的差集。</td> 
  </tr> 
  <tr> 
   <td>array_diff_ukey()</td> 
   <td>用回调函数对键名比较计算数组的差集。</td> 
  </tr> 
  <tr> 
   <td>array_fill()</td> 
   <td>用给定的值填充数组。</td> 
  </tr> 
  <tr> 
   <td>array_filter()</td> 
   <td>用回调函数过滤数组中的元素。</td> 
  </tr> 
  <tr> 
   <td>array_flip()</td> 
   <td>交换数组中的键和值。</td> 
  </tr> 
  <tr> 
   <td>array_intersect()</td> 
   <td>计算数组的交集。</td> 
  </tr> 
  <tr> 
   <td>array_intersect_assoc()</td> 
   <td>比较键名和键值，并返回两个数组的交集数组。</td> 
  </tr> 
  <tr> 
   <td>array_intersect_key()</td> 
   <td>使用键名比较计算数组的交集。</td> 
  </tr> 
  <tr> 
   <td>array_intersect_uassoc()</td> 
   <td>带索引检查计算数组的交集，用回调函数比较索引。</td> 
  </tr> 
  <tr> 
   <td>array_intersect_ukey()</td> 
   <td>用回调函数比较键名来计算数组的交集。</td> 
  </tr> 
  <tr> 
   <td>array_key_exists()</td> 
   <td>检查给定的键名或索引是否存在于数组中。</td> 
  </tr> 
  <tr> 
   <td>array_keys()</td> 
   <td>返回数组中所有的键名。</td> 
  </tr> 
  <tr> 
   <td>array_map()</td> 
   <td>将回调函数作用到给定数组的单元上。</td> 
  </tr> 
  <tr> 
   <td>array_merge()</td> 
   <td>把一个或多个数组合并为一个数组。</td> 
  </tr> 
  <tr> 
   <td>array_merge_recursive()</td> 
   <td>递归地合并一个或多个数组。</td> 
  </tr> 
  <tr> 
   <td>array_multisort()</td> 
   <td>对多个数组或多维数组进行排序。</td> 
  </tr> 
  <tr> 
   <td>array_pad()</td> 
   <td>用值将数组填补到指定长度。</td> 
  </tr> 
  <tr> 
   <td>array_pop()</td> 
   <td>将数组最后一个单元弹出（出栈）。</td> 
  </tr> 
  <tr> 
   <td>array_product()</td> 
   <td>计算数组中所有值的乘积。</td> 
  </tr> 
  <tr> 
   <td>array_push()</td> 
   <td>将一个或多个单元（元素）压入数组的末尾（入栈）。</td> 
  </tr> 
  <tr> 
   <td>array_rand()</td> 
   <td>从数组中随机选出一个或多个元素，并返回。</td> 
  </tr> 
  <tr> 
   <td>array_reduce()</td> 
   <td>用回调函数迭代地将数组简化为单一的值。</td> 
  </tr> 
  <tr> 
   <td>array_reverse()</td> 
   <td>将原数组中的元素顺序翻转，创建新的数组并返回。</td> 
  </tr> 
  <tr> 
   <td>array_search()</td> 
   <td>在数组中搜索给定的值，如果成功则返回相应的键名。</td> 
  </tr> 
  <tr> 
   <td>array_shift()</td> 
   <td>删除数组中的第一个元素，并返回被删除元素的值。</td> 
  </tr> 
  <tr> 
   <td>array_slice()</td> 
   <td>在数组中根据条件取出一段值，并返回。</td> 
  </tr> 
  <tr> 
   <td>array_splice()</td> 
   <td>把数组中的一部分去掉并用其它值取代。</td> 
  </tr> 
  <tr> 
   <td>array_sum()</td> 
   <td>计算数组中所有值的和。</td> 
  </tr> 
  <tr> 
   <td>array_udiff()</td> 
   <td>用回调函数比较数据来计算数组的差集。</td> 
  </tr> 
  <tr> 
   <td>array_udiff_assoc()</td> 
   <td>带索引检查计算数组的差集，用回调函数比较数据。</td> 
  </tr> 
  <tr> 
   <td>array_udiff_uassoc()</td> 
   <td>带索引检查计算数组的差集，用回调函数比较数据和索引。</td> 
  </tr> 
  <tr> 
   <td>array_uintersect()</td> 
   <td>计算数组的交集，用回调函数比较数据。</td> 
  </tr> 
  <tr> 
   <td>array_uintersect_assoc()</td> 
   <td>带索引检查计算数组的交集，用回调函数比较数据。</td> 
  </tr> 
  <tr> 
   <td>array_uintersect_uassoc()</td> 
   <td>带索引检查计算数组的交集，用回调函数比较数据和索引。</td> 
  </tr> 
  <tr> 
   <td>array_unique()</td> 
   <td>删除数组中重复的值。</td> 
  </tr> 
  <tr> 
   <td>array_unshift()</td> 
   <td>在数组开头插入一个或多个元素。</td> 
  </tr> 
  <tr> 
   <td>array_values()</td> 
   <td>返回数组中所有的值。</td> 
  </tr> 
  <tr> 
   <td>array_walk()</td> 
   <td>对数组中的每个成员应用用户函数。</td> 
  </tr> 
  <tr> 
   <td>array_walk_recursive()</td> 
   <td>对数组中的每个成员递归地应用用户函数。</td> 
  </tr> 
  <tr> 
   <td>arsort()</td> 
   <td>对数组进行逆向排序并保持索引关系。</td> 
  </tr> 
  <tr> 
   <td>asort()</td> 
   <td>对数组进行排序并保持索引关系。</td> 
  </tr> 
  <tr> 
   <td>compact()</td> 
   <td>建立一个数组，包括变量名和它们的值。</td> 
  </tr> 
  <tr> 
   <td>count()</td> 
   <td>计算数组中的元素数目或对象中的属性个数。</td> 
  </tr> 
  <tr> 
   <td>current()</td> 
   <td>返回数组中的当前元素。</td> 
  </tr> 
  <tr> 
   <td>each()</td> 
   <td>返回数组中当前的键／值对并将数组指针向前移动一步。</td> 
  </tr> 
  <tr> 
   <td>end()</td> 
   <td>将数组的内部指针指向最后一个元素。</td> 
  </tr> 
  <tr> 
   <td>extract()</td> 
   <td>从数组中将变量导入到当前的符号表。</td> 
  </tr> 
  <tr> 
   <td>in_array()</td> 
   <td>检查数组中是否存在指定的值。</td> 
  </tr> 
  <tr> 
   <td>key()</td> 
   <td>从关联数组中取得键名。</td> 
  </tr> 
  <tr> 
   <td>krsort()</td> 
   <td>对数组按照键名逆向排序。</td> 
  </tr> 
  <tr> 
   <td>ksort()</td> 
   <td>对数组按照键名排序。</td> 
  </tr> 
  <tr> 
   <td>list()</td> 
   <td>把数组中的值赋给一些变量。</td> 
  </tr> 
  <tr> 
   <td>natcasesort()</td> 
   <td>用“自然排序”算法对数组进行不区分大小写字母的排序。</td> 
  </tr> 
  <tr> 
   <td>natsort()</td> 
   <td>用“自然排序”算法对数组排序。</td> 
  </tr> 
  <tr> 
   <td>next()</td> 
   <td>将数组中的内部指针向前移动一位。</td> 
  </tr> 
  <tr> 
   <td>pos()</td> 
   <td>current() 的别名。</td> 
  </tr> 
  <tr> 
   <td>prev()</td> 
   <td>将数组的内部指针倒回一位。</td> 
  </tr> 
  <tr> 
   <td>range()</td> 
   <td>建立一个包含指定范围的元素的数组。</td> 
  </tr> 
  <tr> 
   <td>reset()</td> 
   <td>将数组的内部指针指向第一个元素。</td> 
  </tr> 
  <tr> 
   <td>rsort()</td> 
   <td>对数组逆向排序。</td> 
  </tr> 
  <tr> 
   <td>shuffle()</td> 
   <td>把数组中的元素按随机顺序重新排列。</td> 
  </tr> 
  <tr> 
   <td>sizeof()</td> 
   <td>count() 的别名。</td> 
  </tr> 
  <tr> 
   <td>sort()</td> 
   <td>对数组排序。</td> 
  </tr> 
  <tr> 
   <td>uasort()</td> 
   <td>使用用户自定义的比较函数对数组中的值进行排序并保持索引关联。</td> 
  </tr> 
  <tr> 
   <td>uksort()</td> 
   <td>使用用户自定义的比较函数对数组中的键名进行排序。</td> 
  </tr> 
  <tr> 
   <td>usort()</td> 
   <td>使用用户自定义的比较函数对数组中的值进行排序。</td> 
  </tr> 
 </tbody> 
</table>

[20200218131653450.png]: https://img-blog.csdnimg.cn/20200218131653450.png
[https_wangjiabin.blog.csdn.net_article_details_104379573]: https://wangjiabin.blog.csdn.net/article/details/104379573
[20200218175309587.png]: https://img-blog.csdnimg.cn/20200218175309587.png