发布于 由admin

研究 WordPress wp_list_pluck 函数的数组处理优化设计

WordPress wp_list_pluck 函数的数组处理优化设计

大家好，今天我们要深入探讨 WordPress 中的一个实用函数：wp_list_pluck。 尽管它看起来很简单，但其背后蕴含着不少数组处理优化的思想。理解 wp_list_pluck 的设计，能帮助我们更好地处理数据，提升代码性能，同时也能启发我们设计更高效的数组处理函数。

wp_list_pluck 的基本功能

wp_list_pluck 的核心功能是从一个对象数组或关联数组数组中提取指定键的值，并将这些值组成一个新的数组返回。 它的基本用法如下：

/**
 * Retrieves a list of values from a list of associative arrays or objects.
 *
 * @since 3.1.0
 *
 * @param array        $list     An array of associative arrays or objects to pluck from.
 * @param string|int   $field    Field from the object to place into a new array.
 * @param string|int   $index_key Optional. Field from the object to use as keys for the new array.
 *                               Default null.
 * @return array Array of found values.  If `$index_key` is set, an array of found values with keys
 *               corresponding to `$index_key`.
 */
function wp_list_pluck( $list, $field, $index_key = null ) {
    if ( ! is_array( $list ) ) {
        return array();
    }

    $newlist = array();

    if ( null === $index_key ) {
        foreach ( $list as $key => $value ) {
            if ( is_object( $value ) ) {
                if ( isset( $value->$field ) ) {
                    $newlist[ $key ] = $value->$field;
                } else {
                    $newlist[ $key ] = null; // Or handle missing property as needed
                }
            } else {
                if ( isset( $value[ $field ] ) ) {
                    $newlist[ $key ] = $value[ $field ];
                } else {
                    $newlist[ $key ] = null; // Or handle missing key as needed
                }
            }
        }
    } else {
        foreach ( $list as $value ) {
            if ( is_object( $value ) ) {
                if ( isset( $value->$index_key ) ) {
                    if ( isset( $value->$field ) ) {
                        $newlist[ $value->$index_key ] = $value->$field;
                    } else {
                        $newlist[ $value->$index_key ] = null; // Or handle missing property as needed
                    }
                } else {
                    $newlist[ $key ] = null; // Or handle missing key as needed
                    // Consider:  throw new InvalidArgumentException("Index key '$index_key' not found in object");
                }

            } else {
                if ( isset( $value[ $index_key ] ) ) {
                    if ( isset( $value[ $field ] ) ) {
                        $newlist[ $value[ $index_key ] ] = $value[ $field ];
                    } else {
                        $newlist[ $value[ $index_key ] ] = null; // Or handle missing key as needed
                    }
                } else {
                    $newlist[ $key ] = null; // Or handle missing key as needed
                    // Consider:  throw new InvalidArgumentException("Index key '$index_key' not found in array");
                }
            }
        }
    }

    return $newlist;
}

让我们通过几个例子来理解其用法：

例子 1：从对象数组中提取 post_title

$posts = array(
    (object) array( 'ID' => 1, 'post_title' => 'Hello World' ),
    (object) array( 'ID' => 2, 'post_title' => 'Another Post' ),
);

$titles = wp_list_pluck( $posts, 'post_title' );
// $titles will be:
// array(
//   0 => 'Hello World',
//   1 => 'Another Post',
// )

例子 2：从关联数组数组中提取 name，并使用 id 作为索引

$users = array(
    array( 'id' => 1, 'name' => 'John Doe' ),
    array( 'id' => 2, 'name' => 'Jane Doe' ),
);

$names_by_id = wp_list_pluck( $users, 'name', 'id' );
// $names_by_id will be:
// array(
//   1 => 'John Doe',
//   2 => 'Jane Doe',
// )

例子 3：处理缺失的键或属性

$items = array(
  (object) array('id' => 1, 'label' => 'First Item'),
  (object) array('id' => 2) // Missing 'label'
);

$labels = wp_list_pluck($items, 'label');

// $labels will be:
// array(
//   0 => 'First Item',
//   1 => null,  // Because the second object is missing the 'label' property
// )

数组处理优化设计

wp_list_pluck 在数组处理方面体现了一些优化设计：

  1. 类型检查和兼容性： 函数能同时处理对象数组和关联数组数组，通过 is_object() 来判断每个元素的类型，并使用相应的属性/键访问方式 ($value->$field vs. $value[$field])。 这使得该函数更加通用，可以应用于多种数据结构。

  2. 可选的索引键： 通过 $index_key 参数，可以自定义结果数组的键。 这在需要根据某个字段的值来组织数据时非常有用，避免了手动循环和重新索引数组。

  3. 错误处理 (缺失键/属性): 函数在访问不存在的键或属性时，默认将其值设置为 null。 这避免了潜在的错误，并允许调用者根据实际情况处理缺失的数据。 建议在一些场景中，可以抛出异常，以便更早地发现问题。

  4. 避免不必要的循环: 函数只循环一次输入数组。 对于大型数组，这比多次循环要高效得多。

代码分析和优化方向

现在我们来深入分析 wp_list_pluck 的代码，并探讨可能的优化方向。

1. 类型判断的优化

当前的实现中，is_object() 在每次循环中都会被调用。 如果数组中的所有元素都是相同的类型（要么都是对象，要么都是数组），我们可以将类型判断移到循环之外，以减少函数调用的开销。

function wp_list_pluck_optimized( $list, $field, $index_key = null ) {
    if ( ! is_array( $list ) ) {
        return array();
    }

    $newlist = array();
    $first_element = reset($list); // Get the first element without changing the array pointer

    $is_object = is_object($first_element); // Determine the type only once

    if ( null === $index_key ) {
        foreach ( $list as $key => $value ) {
            if ( $is_object ) {
                if ( isset( $value->$field ) ) {
                    $newlist[ $key ] = $value->$field;
                } else {
                    $newlist[ $key ] = null;
                }
            } else {
                if ( isset( $value[ $field ] ) ) {
                    $newlist[ $key ] = $value[ $field ];
                } else {
                    $newlist[ $key ] = null;
                }
            }
        }
    } else {
        foreach ( $list as $value ) {
            if ( $is_object ) {
                if ( isset( $value->$index_key ) ) {
                    if ( isset( $value->$field ) ) {
                        $newlist[ $value->$index_key ] = $value->$field;
                    } else {
                        $newlist[ $value->$index_key ] = null;
                    }
                } else {
                    $newlist[ $key ] = null; // Or throw exception
                }
            } else {
                if ( isset( $value[ $index_key ] ) ) {
                    if ( isset( $value[ $field ] ) ) {
                        $newlist[ $value[ $index_key ] ] = $value[ $field ];
                    } else {
                        $newlist[ $value[ $index_key ] ] = null;
                    }
                } else {
                    $newlist[ $key ] = null; // Or throw exception
                }
            }
        }
    }

    return $newlist;
}

这种优化在处理大型数组时，可以显著减少函数调用的次数，从而提高性能。

注意: 这种优化假设数组中的所有元素类型一致。 如果数组中混合了对象和数组，这种优化可能会导致错误。 在实际应用中，需要根据数据的特点来决定是否进行这种优化。

2. 使用 array_column (PHP >= 5.5)

PHP 5.5 引入了 array_column 函数，专门用于从多维数组中返回单列的值。 如果我们的数据是关联数组数组，并且不需要自定义索引键，那么可以使用 array_column 来替代 wp_list_pluck，通常 array_column 的性能会更好，因为它是在底层实现的。

if ( function_exists( 'array_column' ) ) {
    function wp_list_pluck_array_column( $list, $field ) {
        return array_column( $list, $field );
    }
}

array_column 无法处理对象数组，也无法自定义索引键。 因此，我们需要根据实际情况选择使用哪个函数。

3. 避免重复的 isset 调用

在 $index_key 不为 null 的情况下，代码会重复调用 isset 来检查 $index_key 和 $field 是否存在。 我们可以将这些 isset 调用合并，以减少函数调用的次数。

function wp_list_pluck_optimized_isset( $list, $field, $index_key = null ) {
    if ( ! is_array( $list ) ) {
        return array();
    }

    $newlist = array();
    $first_element = reset($list);
    $is_object = is_object($first_element);

    if ( null === $index_key ) {
        foreach ( $list as $key => $value ) {
            if ( $is_object ) {
                if ( isset( $value->$field ) ) {
                    $newlist[ $key ] = $value->$field;
                } else {
                    $newlist[ $key ] = null;
                }
            } else {
                if ( isset( $value[ $field ] ) ) {
                    $newlist[ $key ] = $value[ $field ];
                } else {
                    $newlist[ $key ] = null;
                }
            }
        }
    } else {
        foreach ( $list as $value ) {
            if ( $is_object ) {
                if ( isset( $value->$index_key, $value->$field ) ) { // Combined isset call
                    $newlist[ $value->$index_key ] = $value->$field;
                } else {
                    // Handle cases where either index or field is missing
                    if (!isset($value->$index_key)) {
                        $newlist[$key] = null; //Or throw new InvalidArgumentException("Index key '$index_key' not found in object");
                    } else {
                        $newlist[$value->$index_key] = null;
                    }
                }
            } else {
                if ( isset( $value[ $index_key ], $value[ $field ] ) ) { // Combined isset call
                    $newlist[ $value[ $index_key ] ] = $value[ $field ];
                } else {
                    // Handle cases where either index or field is missing
                    if (!isset($value[$index_key])) {
                        $newlist[$key] = null; //Or throw new InvalidArgumentException("Index key '$index_key' not found in array");
                    } else {
                        $newlist[$value[$index_key]] = null;
                    }
                }
            }
        }
    }

    return $newlist;
}

isset 可以同时检查多个变量，这可以减少函数调用的开销。 但是，需要注意的是，如果其中一个变量不存在，isset 仍然会返回 false。 因此，我们需要确保在所有情况下都能正确处理缺失的键或属性。

4. 使用生成器 (PHP >= 5.5)

如果我们需要处理非常大的数组，可以考虑使用生成器来减少内存占用。 生成器允许我们逐个生成结果，而不是一次性将整个结果数组加载到内存中。

function wp_list_pluck_generator( $list, $field, $index_key = null ) {
    if ( ! is_array( $list ) ) {
        yield from []; // Return an empty generator
        return;
    }

    foreach ( $list as $key => $value ) {
        if ( is_object( $value ) ) {
            if ( null === $index_key ) {
                yield $key => isset( $value->$field ) ? $value->$field : null;
            } else {
                if ( isset( $value->$index_key ) ) {
                    yield $value->$index_key => isset( $value->$field ) ? $value->$field : null;
                }
            }
        } else {
            if ( null === $index_key ) {
                yield $key => isset( $value[ $field ] ) ? $value[ $field ] : null;
            } else {
                if ( isset( $value[ $index_key ] ) ) {
                    yield $value[ $index_key ] => isset( $value[ $field ] ) ? $value[ $field ] : null;
                }
            }
        }
    }
}

// 使用生成器:
$data = array(
  array('id' => 1, 'name' => 'Alice'),
  array('id' => 2, 'name' => 'Bob')
);

$names = [];
foreach (wp_list_pluck_generator($data, 'name', 'id') as $id => $name) {
  $names[$id] = $name;
}

// $names now contains the plucked data.

生成器函数使用 yield 关键字来返回值。 每次调用 yield 时，函数会暂停执行，并将值返回给调用者。 当调用者请求下一个值时，函数会从上次暂停的地方继续执行。

使用生成器可以显著减少内存占用，特别是在处理大型数据集时。 但是，生成器的性能可能不如直接操作数组，因为每次生成值都需要进行函数调用。

5. 使用引用传递 (谨慎使用)

在某些情况下，可以使用引用传递来避免复制大型数组，从而提高性能。 但是，使用引用传递需要非常小心，因为它可能会导致意外的副作用。

function wp_list_pluck_reference( array &$list, $field, $index_key = null ) {
    // ... (Implementation using references)
}

警告: 不要在 WordPress 核心函数中使用引用传递，除非你非常清楚自己在做什么。 引用传递可能会导致难以调试的错误，并且可能会破坏 WordPress 的向后兼容性。

性能测试

为了验证这些优化方案的有效性，我们需要进行性能测试。 可以使用 microtime() 函数来测量代码的执行时间。

$start = microtime( true );
// ... (Code to be tested)
$end = microtime( true );
$execution_time = ( $end - $start );
echo "Execution time: " . $execution_time . " secondsn";

可以使用不同大小的数组和不同的数据类型来进行测试，并比较不同优化方案的性能。

总结

wp_list_pluck 是一个功能强大的数组处理函数，它在 WordPress 中被广泛使用。 通过理解其设计和优化方向，我们可以更好地处理数据，提升代码性能。 针对类型判断、isset调用，以及内存占用等问题，我们可以考虑使用类型判断优化，array_column 函数，生成器等技术来提升代码执行效率，但同时也需要注意这些优化可能带来的副作用。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注