来源： 标签/6.5/型钢混凝土/wp包括/超高压

<?php（电话）
/**
*核心元数据API
 *
*用于检索和操作各种WordPress对象类型的元数据的函数。元数据
对象的*是由一个简单的键值对表示的。对象可能包含多个
*共享相同密钥且仅在值上不同的元数据条目。
 *
*@package WordPress
*@子包元数据
 */

要求 ABSPATH公司 . WPINC公司 . “/class-wp-metadata-lazyloader.php”;

/**
*为指定对象添加元数据。
 *
*@自2.9.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$object_id对象元数据的id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。如果非标量，则必须可序列化。
*@param bool$unique可选。指定的元数据键对于对象是否应唯一。
*如果为true，并且对象已经具有指定元数据键的值，
*不做任何更改。默认值为false。
*@return int|false成功时的元ID，失败时为false。
 */
功能 添加元数据（_M）( $元类型, $对象id, $元键, $元值, $唯一 = 虚假的 ) {
       全球的 $wpdb;

       如果 ( ! $元类型 || ! $元键 || ! 是数字（_N）( $object_id（对象id） ) ) {
               返回 虚假的;
       }

       $对象id = 绝对值( $对象id );
       如果 ( ! $对象id ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       $元_子类型 = 获取对象子类型( $元类型, $对象id );

       $列 = 消毒密钥( $元类型 . “_id” );

       //expected_slashed（$meta_key）
       $元键   = wp_unslash（取消刷新）( $元键 );
       $元值 = wp_unslash（W）( $元值 );
       $元值 = 消毒meta( $元键, $元值, $元类型, $元_子类型 );

       /**
*短路添加特定类型的元数据。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`add_post_metadata`
*-`add_comment_metadata（添加注释元数据）`
*-`add_term_metadata`
*-`add_user_metadata`
         *
*@自3.1.0起
         *
*@param null|bool$check是否允许为给定类型添加元数据。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。如果非标量，则必须可序列化。
*@param bool$unique指定的元键对于对象是否应该是唯一的。
         */
       $支票 = 应用筛选器( “添加_{$元类型}_元数据”, 无效的, $对象id, $元键, $元值, $唯一 );
       如果 ( 无效的 !== $支票 ) {
               返回 $支票;
       }

       如果 ( $唯一 && $wpdb->获取变量(
               $wpdb->准备(
                       “从中选择计数（*）$表WHERE meta_key=%s与$列=%d“,
                       $元键,
                       $对象id
               )
       ) ) {
               返回 虚假的;
       }

       $元数据 = $元值;
       $元值 = 可以序列化( $元值 );

       /**
*在添加特定类型的meta之前立即激发。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
         *
*可能的挂钩名称包括：
         *
*-`add_post_meta`
*-`add_comment_meta`
*-`add_term_meta`
*-`add_user_meta`
         *
*@自3.1.0起
         *
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
         */
       do_操作( “添加_{$元类型}_元“, $对象id, $元键, $元数据 );

       $结果 = $wpdb->插入(
               $表,
               阵列(
                       $列     => $对象id,
                       '元键'   => $元键,
                       '元值' => $元值,
               )
       );

       如果 ( ! $结果 ) {
               返回 虚假的;
       }

       中等美元 = (整数) $wpdb->插入id;

       wp_cache_delete（wp_cache_delete）( $对象id, $元类型 . “元数据（_M）” );

       /**
*添加特定类型的meta后立即激发。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
         *
*可能的挂钩名称包括：
         *
*-`added_post_meta`
*-`added_comment_meta`
*-`added_term_meta`
*-`added_user_meta`
         *
*@自2.9.0起
         *
*@param int$mid成功更新后的元ID。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
         */
       do_操作( “已添加_{$meta类型}_元“, 中等美元, $object_id（对象id）, $元键, $元数据 );

       返回 中等美元;
}

/**
*更新指定对象的元数据。如果指定对象的值不存在
*ID和元数据键，将添加元数据。
 *
*@自2.9.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“post”、“comment”、“term”、“user”，
*或具有关联元表的任何其他对象类型。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。如果非标量，则必须可序列化。
*@param混合了$prev_value可选。更新前要检查的上一个值。
*如果指定，则仅使用更新现有元数据条目
*此值。否则，更新所有条目。默认空字符串。
*@return int | bool如果具有给定键的字段不存在，则为新的元字段ID
*因此添加了，成功更新时为true，
*失败或传递给函数的值为false
*与数据库中已有的相同。
 */
功能 更新元数据( $元类型, $对象id, $元键, $meta_value（元值）, $prev_value = '' ) {
       全球的 $wpdb;

       如果 ( ! $meta类型 || ! $元键 || ! 是数字（_N）( $对象id ) ) {
               返回 虚假的;
       }

       $对象id = 吸收( $对象id );
       如果 ( ! $对象id ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       $元_子类型 = 获取对象子类型( $元类型, $对象id );

       $列   = 清理密钥( $元类型 . “_id” );
       $id_列 = ( “用户” === $元类型 ) ? “umeta_id” : '元id';

       //expected_slashed（$meta_key）
       $raw_meta_key（原始密钥） = $元键;
       $元键     = wp_unslash（取消刷新）( $meta密钥 );
       $passed_value（已通过值） = $元值;
       $meta_value（元值）   = wp_unslash（取消刷新）( $元值 );
       $元值   = 消毒meta( $元键, $元值, $元类型, $元_子类型 );

       /**
*短路更新特定类型的元数据。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`update_post_metadata`
*-`update_comment_metadata`
*-`update_term_metadata`
*-`update_user_metadata（更新用户元数据）`
         *
*@自3.1.0起
         *
*@param null|bool$check是否允许更新给定类型的元数据。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。如果非标量，则必须可序列化。
*@param混合了$prev_value可选。更新前要检查的上一个值。
*如果指定，则仅使用更新现有元数据条目
*此值。否则，更新所有条目。
         */
       $支票 = 应用筛选器( “更新_{$meta类型}_元数据”, 无效的, $对象id, $元键, $元值, $prev_value );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       //如果没有给定上一个值并且密钥只存在一次，请将现有值与新值进行比较。
       如果 ( 空的( $prev_value ) ) {
               $old_value（旧值） = 获取元数据( $元类型, $object_id（对象id）, $元键 );
               如果 ( 是可计算的( $old_value（旧值） ) && 计数( $old_value（旧值） ) === 1 ) {
                       如果 ( $old_value（旧值）[0] === $元值 ) {
                               返回 虚假的;
                       }
               }
       }

       $元ID = $wpdb->获得_科尔( $wpdb->准备( “”选择“$id_列发件人$表WHERE meta_key=%s与$列=%d“, $meta密钥, $对象id ) );
       如果 ( 空的( $元ID ) ) {
               返回 添加元数据（_M）( $元类型, $对象id, $raw_meta_key（原始密钥）, $passed_value（已通过值） );
       }

       $元数据 = $元值;
       $元值 = 可以序列化( $元值 );

       $数据 = 契约( '元值' );
       $其中 = 阵列(
               $列   => $对象_id,
               '元键' => $元键,
       );

       如果 ( ! 空的( $prev_value ) ) {
               $prev_value         = 可以序列化( $prev_value );
               $其中['元值'] = $prev_value;
       }

       foreach公司 ( $元ID 作为 $元id ) {
               /**
*在更新特定类型的元数据之前立即激发。
                 *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
                 *
*可能的挂钩名称包括：
                 *
*-`update_post_meta`
*-`update_comment_meta`
*-`update_term_meta`
*-`update_user_meta`
                 *
*@自2.9.0起
                 *
*@param int$meta_id要更新的元数据项的id。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
                 */
               do_操作( “更新_{$元类型}_元“, $元id, $对象id, $元键, $_元数据 );

               如果 ( “发布” === $元类型 ) {
                       /**
*在更新帖子元数据之前立即激发。
                         *
*@自2.9.0起
                         *
*@param int$meta_id要更新的元数据条目的id。
*@param int$object_id帖子id。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。这将是值的PHP序列化字符串表示
*如果值是数组、对象或其本身是PHP序列化字符串。
                         */
                       do_操作( “update_postmeta”, $元id, $对象id, $元键, $meta_value（元值） );
               }
       }

       $结果 = $wpdb->更新( $表, $数据, $其中 );
       如果 ( ! $结果 ) {
               返回 虚假的;
       }

       wp_cache_delete（wp_cache_delete）( $对象id, $元类型 . “元数据（_M）” );

       foreach公司 ( $元ID 作为 $元id ) {
               /**
*更新特定类型的元数据后立即激发。
                 *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
                 *
*可能的挂钩名称包括：
                 *
*-`updated_post_meta`
*-`updated_comment_meta`
*-`updated_term_meta`
*-`updated_user_meta`
                 *
*@自2.9.0起
                 *
*@param int$meta_id更新元数据条目的id。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
                 */
               do_操作( “已更新_{$元类型}_元“, $元id, $对象id, $元键, $元数据 );

               如果 ( '发布' === $元类型 ) {
                       /**
*在更新帖子的元数据后立即激发。
                         *
*@自2.9.0起
                         *
*@param int$meta_id更新元数据条目的id。
*@param int$object_id帖子id。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。这将是值的PHP序列化字符串表示
*如果值是数组、对象或其本身是PHP序列化字符串。
                         */
                       do_操作( '更新的邮戳', $meta_id美元, $对象id, $元键, $元值 );
               }
       }

       返回 真的;
}

/**
*删除指定对象的元数据。
 *
*@自2.9.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value可选。元数据值。如果非标量，则必须可序列化。
*如果指定，则只删除具有此值的元数据条目。
*否则，删除具有指定meta_key的所有条目。
*通过“null”、“false”或空字符串跳过此检查。
*（为了向后兼容，不可能传递空字符串
*删除值为空字符串的条目。）
*默认为空字符串。
*@param bool$delete_all可选。如果为true，则删除所有对象的匹配元数据条目，
*忽略指定的object_id。否则，只删除
*匹配指定object_id的元数据条目。默认为false。
*@return bool成功删除时为True，失败时为false。
 */
功能 删除元数据( $元类型, $对象id, $元键, $元值 = '', $删除_全部 = 虚假的 ) {
       全球的 $wpdb;

       如果 ( ! $meta类型 || ! $元键 || ! 是数字（_N）( $对象id ) && ! $删除_全部 ) {
               返回 虚假的;
       }

       $对象id = 吸收( $对象id );
       如果 ( ! $对象id && ! $删除_全部 ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       $类型_列 = 清理密钥( $元类型 . “_id” );
       $id_列   = ( “用户” === $元类型 ) ? 'umeta_id' : '元id';

       //expected_slashed（$meta_key）
       $元键   = wp_unslash（取消刷新）( $元键 );
       $元值 = wp_unslash（取消刷新）( $元值 );

       /**
*短路删除特定类型的元数据。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`delete_post_metadata`
*-`delete_comment_metadata`
*-`delete_term_metadata`
*-`delete_user_metadata`
         *
*@自3.1.0起
         *
*@param null|bool$delete是否允许删除给定类型的元数据。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$meta_value元数据值。如果非标量，则必须可序列化。
*@param bool$delete_all是否删除匹配的元数据条目
*对于所有对象，忽略指定的$object_id。
*默认为false。
         */
       $支票 = 应用筛选器( “删除_{$元类型}_元数据”, 无效的, $object_id（对象id）, $元键, $元值, $删除_全部 );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       $元数据 = $元值;
       $元值 = 可以序列化( $元值 );

       $查询 = $wpdb->准备( “选择$id_列发件人$表WHERE meta_key=%s“, $元键 );

       如果 ( ! $删除_全部 ) {
               $查询 .= $wpdb->准备( “和$类型_列=%d“, $对象id );
       }

       如果 ( '' !== $元值 && 无效的 !== $元值 && 虚假的 !== $元值 ) {
               $查询 .= $wpdb->准备( '与元值=%s', $meta_value（元值） );
       }

       $元ID = $wpdb->获取（_col）( $查询 );
       如果 ( ! 计数( $元ID ) ) {
               返回 虚假的;
       }

       如果 ( $删除_全部 ) {
               如果 ( '' !== $元值 && 无效的 !== $元值 && 虚假的 !== $元值 ) {
                       $对象ID = $wpdb->获得_科尔( $wpdb->准备( “”选择“$类型_列发件人$表WHERE meta_key=%s AND meta_value=%s“, $元键, $元值 ) );
               } 其他的 {
                       $对象ID = $wpdb->获得_科尔( $wpdb->准备( “”选择“$类型_列发件人$表WHERE meta_key=%s“, $元键 ) );
               }
       }

       /**
*在删除特定类型的元数据之前立即激发。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（帖子、评论、术语、用户或任何其他类型，以及相关联的元表）。
         *
*可能的挂钩名称包括：
         *
*-`delete_post_meta`
*-`delete_comment_meta`
*-`delete_term_meta`
*-`delete_user_meta`
         *
*@自3.1.0起
         *
*@param string[]$meta_ids要删除的元数据条目ID数组。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
         */
       do_操作( “删除_{$元类型}_元“, $元ID, $对象id, $元键, $元数据 );

       //老式动作。
       如果 ( “发布” === $元类型 ) {
               /**
*在删除帖子的元数据之前立即激发。
                 *
*@自2.9.0起
                 *
*@param string[]$meta_ids要删除的元数据条目ID数组。
                 */
               do_操作( '删除邮戳', $元ID );
       }

       $查询 = “”删除来自“$表何处$id_列在（“ . 内爆( ',', $元ID ) . ' )';

       $count个 = $wpdb->查询( $查询 );

       如果 ( ! $count个 ) {
               返回 虚假的;
       }

       如果 ( $删除_全部 ) {
               $数据 = (阵列) $对象ID;
       } 其他的 {
               $数据 = 阵列( $对象id );
       }
       wp_cache_delete_多个( $数据, $元类型 . “元数据（_M）” );

       /**
*删除特定类型的元数据后立即激发。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
         *
*可能的挂钩名称包括：
         *
*-`deleted_post_meta`
*-`deleted_comment_meta`
*-`deleted_term_meta`
*-`deleted_user_meta`
         *
*@自2.9.0起
         *
*@param string[]$meta_ids要删除的元数据条目ID数组。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param混合了$_meta_value元数据值。
         */
       do_操作( “已删除_{$meta类型}_元“, $元ID, $object_id（对象id）, $元键, $元数据 );

       //老式动作。
       如果 ( “发布” === $元类型 ) {
               /**
*删除帖子的元数据后立即激发。
                 *
*@自2.9.0起
                 *
*@param string[]$meta_ids要删除的元数据条目ID数组。
                 */
               do_操作( 'deleted_postmeta', $meta_ids（_ID） );
       }

       返回 真的;
}

/**
*检索指定对象类型和ID的元数据字段的值。
 *
*如果元字段存在，如果`$single`为true，则返回单个值，
*或值数组（如果为false）。
 *
*如果元字段不存在，则结果取决于get_metadata_default（）。
*默认情况下，如果`$single`为true，则返回空字符串，或者返回空数组
*如果是假的。
 *
*@自2.9.0起
 *
*@参见get_metadata_raw（）
*@参见get_metadata_default（）
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key可选。元数据键。如果未指定，则检索的所有元数据
*指定的对象。默认空字符串。
*@param bool$single可选。如果为true，则仅返回指定`$meta_key`的第一个值。
*如果未指定`$meta_key`，则此参数无效。默认为false。
*@return mixed如果`$single`为false，则为值数组。
*如果`$single`为true，则元字段的值。
*对于无效的`$object_id`（非数字、零或负值）为False，
*或如果未指定`$meta_type`。
*如果传递了有效但不存在的对象ID，则为空字符串。
 */
功能 获取元数据( $元类型, $对象_id, $元键 = '', 单个$ = 虚假的 ) {
       价值$ = 获取元数据( $元类型, $对象id, $元键, 单个$ );
       如果 ( ! 完整（_N）( 价值$ ) ) {
               返回 价值$;
       }

       返回 获取元数据默认值( $元类型, $对象id, $元键, 单个$ );
}

/**
*检索指定对象的原始元数据值。
 *
*@自5.5.0起
 *
*@param string$meta_type对象元数据的类型适用于。接受“post”、“comment”、“term”、“user”，
*或具有关联元表的任何其他对象类型。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key可选。元数据键。如果未指定，则检索的所有元数据
*指定对象。默认空字符串。
*@param bool$single可选。如果为true，则仅返回指定`$meta_key`的第一个值。
*如果未指定`$meta_key`，则此参数无效。默认为false。
*@return mixed如果`$single`为false，则为值数组。
*如果`$single`为true，则元字段的值。
*对于无效的“$object_id”（非数字、零或负值）为False，
*或如果未指定`$meta_type`。
*如果值不存在，则为Null。
 */
功能 获取元数据( $元类型, $对象id, $元键 = '', 单个$ = 虚假的 ) {
       如果 ( ! $元类型 || ! 是数字（_N）( $对象id ) ) {
               返回 虚假的;
       }

       $对象id = 吸收( $对象id );
       如果 ( ! $对象id ) {
               返回 虚假的;
       }

       /**
*短路元字段的返回值。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（帖子、评论、术语、用户或任何其他类型，以及相关联的元表）。
*返回非空值将有效地使函数短路。
         *
*可能的过滤器名称包括：
         *
*-`get_post_metadata`
*-`get_comment_metadata`
*-`get_term_metadata`
*-`get_user_metadata`
         *
*@自3.1.0起
*@自5.5.0起添加了`$meta_type`参数。
         *
*@param mixed$value要返回的值，可以是单个元数据值，也可以是数组
值的*取决于“$single”的值。默认为null。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param bool$single是否只返回指定`$meta_key`的第一个值。
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
         */
       $支票 = 应用筛选器( “获取_{$元类型}_元数据”, 无效的, $对象id, $元键, 单个$, $元类型 );
       如果 ( 无效的 !== $支票 ) {
               如果 ( 单个$ && 是数组（_A）( $支票 ) ) {
                       返回 $支票[0];
               } 其他的 {
                       返回 $支票;
               }
       }

       $元缓存 = wp_cache_get（wp_cach_get）( $对象id, $元类型 . “元数据（_M）” );

       如果 ( ! $元缓存 ) {
               $元缓存 = 更新meta_cache( $元类型, 阵列( $对象id ) );
               如果 ( 发行( $元缓存[ $对象id ] ) ) {
                       $元缓存 = $元缓存[ $对象id ];
               } 其他的 {
                       $元缓存 = 无效的;
               }
       }

       如果 ( ! $元键 ) {
               返回 $元缓存;
       }

       如果 ( 发行( $元缓存[ $元键 ] ) ) {
               如果 ( 单个$ ) {
                       返回 可以取消序列化( $元缓存[ $元键 ][0] );
               } 其他的 {
                       返回 阵列_贴图( '可能被插入（_U）', $元缓存[ $元键 ] );
               }
       }

       返回 无效的;
}

/**
*检索指定元键和对象的默认元数据值。
 *
*默认情况下，如果`$single`为true，则返回空字符串，或者返回空数组
*如果是假的。
 *
*@自5.5.0起
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param bool$single可选。如果为true，则只返回指定的“$meta_key”的第一个值。
*如果未指定`$meta_key`，则此参数无效。默认为false。
*@return mixed如果`$single`为false，则为默认值数组。
*如果`$single`为true，则元字段的默认值。
 */
功能 获取元数据默认值( $元类型, $对象id, $元键, 单个$ = 虚假的 ) {
       如果 ( 单个$ ) {
               价值$ = '';
       } 其他的 {
               价值$ = 阵列();
       }

       /**
*过滤指定元键和对象的默认元数据值。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
         *
*可能的过滤器名称包括：
         *
*-`default_post_metadata`
*-`default_comment_metadata`
*-`default_term_metadata`
*-`default_user_metadata（默认用户元数据）`
         *
*@自5.5.0起
         *
*@param mixed$value要返回的值，可以是单个元数据值，也可以是数组
值的*取决于“$single”的值。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param bool$single是否只返回指定`$meta_key`的第一个值。
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
         */
       美元价值 = 应用筛选器( “默认值_{$元类型}_元数据”, 价值$, $对象id, $元键, 单个$, $元类型 );

       如果 ( ! 单个$ && ! wp_is_numeric_数组( 价值$ ) ) {
               价值$ = 阵列( 价值$ );
       }

       返回 价值$;
}

/**
*确定给定对象ID是否存在具有给定键的元字段。
 *
*@自3.3.0起
 *
*@param string$meta_type对象元数据的类型用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$object_id对象元数据的id用于。
*@param string$meta_key元数据密钥。
*@return bool具有给定键的元字段是否存在。
 */
功能 元数据已存在( $元类型, $对象id, $元键 ) {
       如果 ( ! $元类型 || ! 是数字（_N）( $对象id ) ) {
               返回 虚假的;
       }

       $对象id = 吸收( $对象_id );
       如果 ( ! $对象id ) {
               返回 虚假的;
       }

       /**此过滤器记录在wp-includes/meta.php中*/
       $支票 = 应用筛选器( “获取_{$元类型}_元数据”, 无效的, $对象id, $元键, 真的, $元类型 );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       $元缓存 = wp_cache_get（wp_cach_get）( $对象id, $元类型 . “元数据（_M）” );

       如果 ( ! $元缓存 ) {
               $meta_cache（_C） = 更新meta_cache( $元类型, 阵列( $object_id（对象id） ) );
               $元缓存 = $元缓存[ $对象id ];
       }

       如果 ( 发行( $元缓存[ $元键 ] ) ) {
               返回 真的;
       }

       返回 虚假的;
}

/**
*按元ID检索元数据。
 *
*@自3.3.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$meta_id特定元数据行的id。
*@return stdClass|false{
*元数据对象，如果元数据不存在，则为布尔值“false”。
 *
*@type string$meta_key元键。
*@type混合了$meta_value未序列化的meta值。
*@type string$meta_id可选。当元类型为除“user”之外的任何值时的元ID。
*@type string$umeta_id可选。元类型为“user”时的元ID。
*@type字符串$post_id可选。元类型为“post”时的对象ID。
*@type string$comment_id可选。元类型为“comment”时的对象ID。
*@type string$term_id可选。元类型为“term”时的对象ID。
*@type string$user_id可选。元类型为“user”时的对象ID。
 * }
 */
功能 获取元数据( $元类型, $元id ) {
       全球的 $wpdb;

       如果 ( ! $元类型 || ! 是数字（_N）( $元id ) || 地板( $元id ) != $元id ) {
               返回 虚假的;
       }

       $元id = (整数) $元id;
       如果 ( $元id <= 0 ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       /**
*通过元ID获取元字段时，短接返回值。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`get_post_metadata_by_mid`
*-`get_comment_metadata_by_mid`
*-`get_term_metadata_by_mid`
*-`get_user_metadata_by_mid`
         *
*@自5.0.0起
         *
*@param stdClass | null$value要返回的值。
*@param int$meta_id元id。
         */
       $支票 = 应用筛选器( “获取_{$元类型}_元数据_by_mid“, 无效的, $元id );
       如果 ( 无效的 !== $支票 ) {
               返回 $支票;
       }

       $id_列 = ( “用户” === $元类型 ) ? “umeta_id” : 'meta_id';

       $元 = $wpdb->获取（_R）( $wpdb->准备( “从中选择*$表何处$id_列=%d“, $元id ) );

       如果 ( 空的( $元 ) ) {
               返回 虚假的;
       }

       如果 ( 发行( $元->元值（_V） ) ) {
               $元->元值（_V） = 可以取消序列化( $元->元值（_V） );
       }

       返回 $元;
}

/**
*按元ID更新元数据。
 *
*@自3.3.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$meta_id特定元数据行的id。
*@param string$meta_value元数据值。如果非标量，则必须可序列化。
*@param string | false$meta_key可选。您可以提供元键来更新它。默认为false。
*成功更新时返回bool True，失败时返回false。
 */
功能 更新元数据( $元类型, $元id, $元值, $元键 = 虚假的 ) {
       全球的 $wpdb;

       //确保一切有效。
       如果 ( ! $元类型 || ! 是数字（_N）( $元id ) || 地板( $元id ) != $元id ) {
               返回 虚假的;
       }

       $元id = (整数) $元id;
       如果 ( $元id <= 0 ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       $列   = 消毒密钥( $元类型 . “_id” );
       $id_列 = ( “用户” === $元类型 ) ? “umeta_id” : '元id';

       /**
*短路通过元ID更新特定类型的元数据。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`update_post_metadata_by_mid`
*-`update_comment_metadata_by_mid`
*-`update_term_metadata_by_mid`
*-`update_user_metadata_by_mid`
         *
*@自5.0.0起
         *
*@param null|bool$check是否允许更新给定类型的元数据。
*@param int$meta_id元id。
*@param混合了$meta_value元值。如果非标量，则必须可序列化。
*@param string | false$meta_key元键（如果提供）。
         */
       $支票 = 应用筛选器( “更新_{$元类型}_元数据_by_mid“, 无效的, $元id, $meta_value（元值）, $元键 );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       //获取元数据，如果找到则继续。
       $元 = 获取元数据( $元类型, $元id );
       如果 ( $元 ) {
               $原始密钥 = $元->元键（_K）;
               $对象id   = $元->{$列};

               /*
*如果指定了新的元密钥（最后一个参数），请更改元密钥，
*否则在update语句中使用原始密钥。
                 */
               如果 ( 虚假的 === $元键 ) {
                       $元键 = $原始密钥;
               } 埃尔塞夫 ( ! 是字符串( $元键 ) ) {
                       返回 虚假的;
               }

               $元_子类型 = 获取对象子类型( $元类型, $对象id );

               //清理元数据。
               $元数据 = $元值;
               $元值 = 消毒meta( $meta密钥, $元值, $元类型, $meta_子类型 );
               $元值 = 可以序列化( $元值 );

               //格式化数据查询参数。
               $数据 = 阵列(
                       '元键'   => $元键,
                       '元值' => $元值,
               );

               //格式化where查询参数。
               $其中               = 阵列();
               $其中[ $id_列 ] = $元id;

               /**此操作记录在wp-includes/meta.php中*/
               do_操作( “更新_{$元类型}_元“, $元id, $对象id, $元键, $元数据 );

               如果 ( “发布” === $元类型 ) {
                       /**此操作记录在wp-includes/meta.php中*/
                       do_操作( “update_postmeta”, $元id, $对象id, $元键, $meta_value（元值） );
               }

               //运行更新查询，$data中的所有字段都是%s，$其中是%d。
               $结果 = $wpdb->更新( $表, $数据, $其中, “%s”, “%d” );
               如果 ( ! $结果 ) {
                       返回 虚假的;
               }

               //清除缓存。
               wp_cache_delete（wp_cache_delete）( $对象id, $元类型 . “元数据（_M）” );

               /**此操作记录在wp-includes/meta.php中*/
               do_操作( “已更新_{$元类型}_元“, $元id, $对象id, $元键, $元数据 );

               如果 ( “发布” === $元类型 ) {
                       /**此操作记录在wp-includes/meta.php中*/
                       do_操作( '更新的邮戳', $元id, $对象id, $元键, $元值 );
               }

               返回 真的;
       }

       //如果没有找到元数据。
       返回 虚假的;
}

/**
*按元ID删除元数据。
 *
*@自3.3.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$meta_id特定元数据行的id。
*@return bool成功删除时为True，失败时为false。
 */
功能 删除元数据( $元类型, $元id ) {
       全球的 $wpdb;

       //确保一切有效。
       如果 ( ! $元类型 || ! 是数字（_N）( $meta_id美元 ) || 地板( $元id ) != $元id ) {
               返回 虚假的;
       }

       $元id = (整数) $元id;
       如果 ( $元id <= 0 ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       //对象和ID列。
       $列   = 清理密钥( $元类型 . “_id” );
       $id_列 = ( “用户” === $meta类型 ) ? “umeta_id” : '元id';

       /**
*短路，通过元ID删除特定类型的元数据。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`delete_post_metadata_by_mid`
*-`delete_comment_metadata_by_mid`
*-`delete_term_metadata_by_mid`
*-`delete_user_metadata_by_mid`
         *
*@自5.0.0起
         *
*@param null|bool$delete是否允许删除给定类型的元数据。
*@param int$meta_id元id。
         */
       $支票 = 应用筛选器( “删除_{$元类型}_元数据_by_mid“, 无效的, $元id );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       //获取元数据，如果找到则继续。
       $元 = 获取元数据( $元类型, $元id );
       如果 ( $元 ) {
               $对象id = (整数) $元->{$列};

               /**此操作记录在wp-includes/meta.php中*/
               do_操作( “”删除“_{$元类型}_元“, (阵列) $元id, $对象id, $元->元键（_K）, $元->元值（_V） );

               //老式动作。
               如果 ( '发布' === $元类型 || '评论' === $元类型 ) {
                       /**
*在删除特定类型的帖子或注释元数据之前立即激发。
                         *
*钩子名称的动态部分`$meta_type`是指元
对象类型（帖子或评论）。
                         *
*可能的挂钩名称包括：
                         *
*-`delete_postmeta`
*-`delete_commentmeta`
*-`delete_termmeta`
*-`delete_usermeta`
                         *
*@自3.4.0起
                         *
*@param int$meta_id要删除的元数据项的id。
                         */
                       do_操作( “删除_{$元类型}元“, $元id );
               }

               //运行查询，如果删除将返回true，否则返回false。
               $结果 = (布尔) $wpdb->删除( $表, 阵列( $id_列 => $元id ) );

               //清除缓存。
               wp_cache_delete（wp_cache_delete）( $对象id, $元类型 . “元数据（_M）” );

               /**此操作记录在wp-includs/meta.php中*/
               do_操作( “已删除_{$元类型}_元“, (阵列) $元id, $对象id, $元->元键（_K）, $元->元值（_V） );

               //老式动作。
               如果 ( “发布” === $元类型 || '评论' === $元类型 ) {
                       /**
*删除特定类型的帖子或注释元数据后立即激发。
                         *
*钩子名称的动态部分`$meta_type`是指元
对象类型（帖子或评论）。
                         *
*可能的挂钩名称包括：
                         *
*-`deleted_postmeta删除`
*-`deleted_commentmeta`
*-`deleted_termmeta`
*-`deleted_usermeta`
                         *
*@自3.4.0起
                         *
*@param int$meta_id已删除元数据条目id。
                         */
                       do_操作( “已删除_{$元类型}元“, $meta_id美元 );
               }

               返回 $结果;

       }

       //找不到元ID。
       返回 虚假的;
}

/**
*更新指定对象的元数据缓存。
 *
*@自2.9.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string | int[]$object_ids要更新缓存的对象ID的数组或逗号分隔列表。
*@return array |指定对象的false元数据缓存，失败时为false。
 */
功能 更新meta_cache( $元类型, $对象ID ) {
       全球的 $wpdb;

       如果 ( ! $meta类型 || ! $对象ID ) {
               返回 虚假的;
       }

       $表 = _获取元数据表( $元类型 );
       如果 ( ! $表 ) {
               返回 虚假的;
       }

       $列 = 清理密钥( $元类型 . “_id” );

       如果 ( ! 是数组（_A）( $对象ID ) ) {
               $对象ID = preg_替换( '|[^0-9,]|', '', $对象ID );
               $对象ID = 爆炸( ',', $对象ID );
       }

       $对象ID = 阵列_贴图( “intval”, $对象ID );

       /**
*短路更新特定类型的元数据缓存。
         *
*钩子名称的动态部分“$meta_type”是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
*返回非空值将有效地使函数短路。
         *
*可能的挂钩名称包括：
         *
*-`update_post_metadata_cache`
*-`update_comment_metadata_cache`
*-`update_term_metadata_cache`
*-`update_user_metadata_cache`
         *
*自5.0.0起
         *
*@param mixed$check是否允许更新给定类型的元缓存。
*@param int[]$object_ids要更新元缓存的对象ID数组。
         */
       $支票 = 应用筛选器( “更新_{$元类型}_元数据缓存“, 无效的, $对象ID );
       如果 ( 无效的 !== $支票 ) {
               返回 (布尔) $支票;
       }

       $cache_key     = $元类型 . '_meta'（_M）;
       $非缓存ID = 阵列();
       $缓存         = 阵列();
       $cache_values   = wp_cache_get_multiple（wp_cach_get_multiple）( $对象ID, $cache_key );

       foreach公司 ( $cache_values 作为 $id（美元） => $缓存对象 ) {
               如果 ( 虚假的 === $缓存对象 ) {
                       $非缓存ID[] = $id（美元）;
               } 其他的 {
                       $缓存[ $id（美元） ] = $缓存对象;
               }
       }

       如果 ( 空的( $非缓存ID ) ) {
               返回 $缓存;
       }

       //获取元信息。
       $id_list   = 内爆( ',', $非缓存ID );
       $id_列 = ( “用户” === $元类型 ) ? “umeta_id” : '元id';

       $元列表 = $wpdb->获取结果( “”选择“$列，元键，元值来自$表其中$列英寸($id_list)订购依据$id_列ASC“, 阵列_A );

       如果 ( ! 空的( $元列表 ) ) {
               foreach公司 ( $元列表 作为 $metarow（元行） ) {
                       $mpid（$mpid） = (整数) $metarow（元行）[ $列 ];
                       $mkey（美元） = $metarow（元行）['元键'];
                       $mval（百万美元） = $meta行['元值'];

                       //强制子键为数组类型。
                       如果 ( ! 发行( $缓存[ $mpid（$mpid） ] ) || ! 是数组（_A）( $缓存[ $mpid（$mpid） ] ) ) {
                               $缓存[ $mpid（$mpid） ] = 阵列();
                       }
                       如果 ( ! 发行( $缓存[ $mpid（$mpid） ][ $mkey（美元） ] ) || ! 是数组（_A）( $缓存[ $mpid（$mpid） ][ $mkey（美元） ] ) ) {
                               $缓存[ $mpid美元 ][ 百万美元 ] = 阵列();
                       }

                       //向当前pid/key添加一个值。
                       $缓存[ $mpid（$mpid） ][ $mkey（美元） ][] = $mval（百万美元）;
               }
       }

       $数据 = 阵列();
       foreach公司 ( $非缓存ID 作为 $id美元 ) {
               如果 ( ! 发行( $缓存[ $id美元 ] ) ) {
                       $缓存[ $id（美元） ] = 阵列();
               }
               $数据[ $id（美元） ] = $缓存[ $id（美元） ];
       }
       wp_cache_add_多个( $数据, $cache_key );

       返回 $缓存;
}

/**
*检索延迟加载元数据的队列。
 *
*@自4.5.0起
 *
*@return WP_Metadata_Lazyloader元数据Lazyloader队列。
 */
功能 wp_元数据_偶氮加载器() {
       静止的 $wp_metadata_lazyloader;

       如果 ( 无效的 === $wp_metadata_lazyloader ) {
               $wp_metadata_lazyloader = 新的 WP_元数据_ azyloader();
       }

       返回 $wp_metadata_lazyloader;
}

/**
*给定一个元查询，生成要附加到主查询的SQL子句。
 *
*@自3.2.0起
 *
*@参见WP_Meta_Query
 *
*@param array$meta_query元查询。
*@param string$type元的类型。
*@param string$primary_table主数据库表名。
*@param string$primary_id_column主id列名。
*@param object$context可选。主查询对象。默认为null。
*@返回字符串[]|false{
*包含要附加到主查询的JOIN和WHERE SQL子句的数组，
*或false，如果请求的元类型不存在表。
 *
*@type string$join SQL片段以附加到主join子句。
*@type string$，其中SQL片段附加到主where子句。
 * }
 */
功能 获取meta_sql( $元查询, $类型, $primary_table（主表）, $primary_id_column, $上下文 = 无效的 ) {
       $meta_query_obj（元查询） = 新的 WP_元数据_查询( $元查询 );
       返回 $元查询对象->获取sql( $类型, $primary_table（主表）, $primary_id_column, $上下文 );
}

/**
*检索指定对象类型的元数据表的名称。
 *
*@自2.9.0起
 *
*@global wpdb$wpdb WordPress数据库抽象对象。
 *
*@param string$type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@return string|false元数据表名，如果不存在元数据表，则为false
 */
功能 _获取元数据表( $类型 ) {
       全球的 $wpdb;

       $table_name（表格名称） = $类型 . “meta”;

       如果 ( 空的( $wpdb->$表格名称 ) ) {
               返回 虚假的;
       }

       返回 $wpdb->$表格名称;
}

/**
*确定元键是否被视为受保护。
 *
*@自3.1.3起
 *
*@param string$meta_key元数据密钥。
*@param string$meta_type可选。对象元数据的类型为。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。默认空字符串。
*@return bool元键是否被视为受保护。
 */
功能 受保护的元数据( $元键, $元类型 = '' ) {
       $sanitized_key = preg_替换( "/[^\x20像素-\x7E型\p{L}]/“, '', $元键 );
       $受保护     = 斯特伦( $sanitized_key ) > 0 && ( '_' === $sanitized_key[0] );

       /**
*过滤元密钥是否被视为受保护。
         *
*@自3.2.0起
         *
*@param bool$protected密钥是否被视为受保护。
*@param string$meta_key元数据密钥。
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
         */
       返回 应用筛选器( '是受保护的元数据', $受保护, $meta密钥, $元类型 );
}

/**
*清理元值。
 *
*@自3.1.3起
*@自4.9.8起添加了`$object_subtype`参数。
 *
*@param string$meta_key元数据密钥。
*@param混合了要清理的$meta_value元数据值。
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$object_subtype可选。对象类型的子类型。默认空字符串。
*@return混合了Sanitized$meta_value。
 */
功能 消毒meta( $元键, $元值, $对象类型, $object_子类型 = '' ) {
       如果 ( ! 空的( $对象_子类型 ) && has_filter（有过滤器）( “消毒_{$对象类型}_元_{$元键}_的_{$对象_子类型}" ) ) {

               /**
*过滤特定元类型和子类型的特定元键的清理。
                 *
*钩子名称的动态部分，`$object_type`，`$meta_key`，
*和`$object_subtype`，表示元数据对象类型（comment、post、term或user），
*分别为元键值和对象子类型。
                 *
*@自4.9.8起
                 *
*@param混合了要清理的$meta_value元数据值。
*@param string$meta_key元数据密钥。
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$object_subtype对象子类型。
                 */
               返回 应用筛选器( “消毒_{$对象类型}_元_{$元键}_的_{$对象_子类型}", $元值, $元键, $对象类型, $对象_子类型 );
       }

       /**
*过滤特定元类型的特定元密钥的净化。
         *
*钩子名称、`$meta_type`和`$meta_key`的动态部分，
*指元数据对象类型（评论、帖子、术语或用户）和元数据
*键值。
         *
*@自3.3.0起
         *
*@param混合了要清理的$meta_value元数据值。
*@param string$meta_key元数据密钥。
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
         */
       返回 应用筛选器( “消毒_{$对象类型}_元_{$元键}", $元值, $元键, $对象类型 );
}

/**
*注册元密钥。
 *
*建议为对象类型和对象子类型的特定组合注册元键。如果通过
*省略对象子类型，将为整个对象类型注册元键，但可以部分注册
*在同一对象类型和子类型存在更具体的同名元键时被覆盖。
 *
*如果对象类型不支持任何子类型，例如用户或注释，通常应调用此函数
*不传递子类型。
 *
*@自3.3.0起
*@自4.6.0起{@linkhttps://core.trac.wordpress.org/ticket/35658被改进的
*以支持要附加到已注册元密钥的数据数组}。的上一个参数
*`$sanitize_callback`和`$auth_callback `已折叠到此数组中。
*@自4.9.8以来，“$object_subtype”参数已添加到参数数组中。
*@自5.3.0起有效的元类型扩展为包括“数组”和“对象”。
*@自5.5.0起将`$default`参数添加到arguments数组。
*@since 6.4.0将`$revisions_enabled`参数添加到参数数组中。
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$meta_key要注册的元键。
*@param数组$args{
*注册时用于描述元密钥的数据。
 *
*@type string$object_subtype A子类型；例如，如果对象类型为“post”，则为post类型。如果留空，
*元密钥将在整个对象类型上注册。默认为空。
*@type string$type与此元键关联的数据类型。
*有效值为“string”、“boolean”、“integer”、“number”、“array”和“object”。
*@type string$description附加到此元键的数据的描述。
*@type bool$single元键是否每个对象有一个值，或每个对象有值数组。
*@type mixed$default如果尚未设置值，则从get_metadata（）返回默认值。
*使用非单一元键时，默认值为第一个条目。
*换句话说，当调用get_metadata（）时，`$single`设置为`false`，
*此处给定的默认值将封装在数组中。
*@type callable$sanitize_callback清理`$meta_key`数据时要调用的函数或方法。
*@type可调用$auth_callback可选。执行edit_post_meta时要调用的函数或方法，
*add_post_meta和delete_post_meta功能检查。
*@type bool|array$show_in_rest与此元键关联的数据是否可以被视为公共的
*应该可以通过REST API访问。自定义帖子类型还必须声明
*支持通过REST访问注册元数据的自定义字段。
*注册复杂元值时，此参数可以是可选的
*使用“schema”或“prepare_callback”键而不是布尔值的数组。
*@type bool$revisions_enabled是否为此meta_key启用修订支持。仅当
*对象类型为“post”。
 * }
*@param string | array$已弃用。请改用“$args”。
*@return bool如果元键在全局数组中成功注册，则返回True，否则返回false。
*使用不同的清理和身份验证回调注册元密钥将触发这些回调，
*但不会添加到全局注册表。
 */
功能 寄存器_元数据( $对象类型, $元键, $个参数, $已弃用 = 无效的 ) {
       全球的 $wp_meta_keys;

       如果 ( ! 是数组（_A）( $wp_meta_keys ) ) {
               $wp_meta_keys = 阵列();
       }

       $默认值 = 阵列(
               '对象子类型'   => '',
               “类型”             => “字符串”,
               '说明'       => '',
               “默认”           => '',
               “单个”           => 虚假的,
               '清理回调' => 无效的,
               '授权回调'     => 无效的,
               “show_in_rest”     => 虚假的,
               '修订_启用' => 虚假的,
       );

       //过去有单独的参数用于清理和授权回调。
       $has_old_sanitize_cb = 虚假的;
       $has_old_auth_cb     = 虚假的;

       如果 ( 可调用（_C）( $个参数 ) ) {
               $个参数 = 阵列(
                       '清理回调' => $个参数,
               );

               $has_old_sanitize_cb = 真的;
       } 其他的 {
               $个参数 = (阵列) $个参数;
       }

       如果 ( 可调用（_C）( $已弃用 ) ) {
               $个参数['授权回调'] = $已弃用;
               $has_old_auth_cb       = 真的;
       }

       /**
*在注册meta时过滤注册参数。
         *
*@自4.6.0起
         *
*@param array$args元注册参数的数组。
*@param array$defaults默认参数的数组。
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$meta_key元键。
         */
       $个参数 = 应用筛选器( '注册表_元数据_参数', $个参数, $默认值, $对象类型, $meta密钥 );
       未设置( $默认值['默认'] );
       $个参数 = wp_parse_args( $个参数, $默认值 );

       //注册数组元时需要项架构。
       如果 ( 虚假的 !== $个参数[“show_in_rest”] && “数组” === $个参数[“类型”] ) {
               如果 ( ! 是数组（_A）( $个参数['显示_列表'] ) || ! 发行( $个参数[“show_in_rest”]['架构']['项目'] ) ) {
                       _做错了( __功能__, __( '注册要在REST API中显示的“数组”元类型时，必须为“show_in_REST.schema.items”中的每个数组项指定架构。' ), '5.3.0' );

                       返回 虚假的;
               }
       }

       $对象_子类型 = ! 空的( $个参数['对象子类型'] ) ? $个参数['对象子类型'] : '';
       如果 ( $个参数['修订_启用'] ) {
               如果 ( “发布” !== $对象类型 ) {
                       _做错了( __函数__, __( “除非对象类型支持修订，否则元键无法启用修订支持。” ), '6.4.0' );

                       返回 虚假的;
               } 埃尔塞夫 ( ! 空的( $对象_子类型 ) && ! 后类型支持( $对象_子类型, '修订' ) ) {
                       _做错了( __功能__, __( “除非对象子类型支持修订，否则元键无法启用修订支持。” ), '6.4.0' );

                       返回 虚假的;
               }
       }

       //如果未提供“auth_callback”，请回退到“is_protected_meta（）”。
       如果 ( 空的( $个参数['授权回调'] ) ) {
               如果 ( 受保护的元数据( $元键, $对象类型 ) ) {
                       $个参数['授权回调'] = “__return_false”;
               } 其他的 {
                       $个参数['授权回调'] = “__return_true”;
               }
       }

       //Back-compat：旧的清理和身份验证回调应用于所有对象类型。
       如果 ( 可调用（_C）( $个参数['清理回调'] ) ) {
               如果 ( ! 空的( $object_子类型 ) ) {
                       添加筛选器( “消毒_{$对象类型}_元_{$元键}_的_{$对象_子类型}", $个参数['清理回调'], 10, 4 );
               } 其他的 {
                       添加筛选器( “消毒_{$对象类型}_元_{$元键}", $args美元['清理回调'], 10, 三 );
               }
       }

       如果 ( 可调用（_C）( $args美元['授权回调'] ) ) {
               如果 ( ! 空的( $对象_子类型 ) ) {
                       添加筛选器( “身份验证_{$对象类型}_元_{$元键}_的_{$对象_子类型}", $个参数['授权回调'], 10, 6 );
               } 其他的 {
                       添加筛选器( “身份验证_{$对象类型}_元_{$meta密钥}", $个参数['授权回调'], 10, 6 );
               }
       }

       如果 ( 数组关键字存在( “默认”, $个参数 ) ) {
               $模式 = $个参数;
               如果 ( 是数组（_A）( $个参数[“show_in_rest”] ) && 发行( $个参数[“show_in_rest”]['架构'] ) ) {
                       $模式 = 数组合并( $模式, $个参数[“show_in_rest”]['架构'] );
               }

               $支票 = 从模式重置验证值( $个参数[“默认”], $架构 );
               如果 ( is_wp_错误( $支票 ) ) {
                       _做错了( __功能__, __( '注册默认元数据时，数据必须与提供的类型匹配。' ), '5.5.0' );

                       返回 虚假的;
               }

               如果 ( ! has_filter（有过滤器）( “默认值_{$对象类型}_元数据”, '过滤默认元数据' ) ) {
                       添加筛选器( “默认值_{$对象类型}_元数据”, '过滤默认元数据', 10, 5 );
               }
       }

       //全局注册表仅包含使用4.6.0中添加的参数数组注册的元键。
       如果 ( ! $has_old_auth_cb && ! $has_old_sanitize_cb ) {
               未设置( $个参数['对象子类型'] );

               $wp_meta_keys[ $对象类型 ][ $object_子类型 ][ $元键 ] = $个参数;

               返回 真的;
       }

       返回 虚假的;
}

/**
*过滤到default_{$object_type}_metadata并添加默认值。
 *
*@自5.5.0起
 *
*@param混合了$value传递给筛选器的当前值。
*对象元数据的@param int$object_id id用于。
*@param string$meta_key元数据密钥。
*@param bool$single如果为true，则只返回指定`$meta_key`的第一个值。
*如果未指定`$meta_key`，则此参数无效。
*@param string$meta_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@return mixed如果`$single`为false，则为默认值数组。
*如果`$single`为true，则元字段的默认值。
 */
功能 过滤默认元数据( 价值$, $object_id（对象id）, $元键, 单个$, $元类型 ) {
       全球的 $wp_meta_keys;

       如果 ( wp_安装() ) {
               返回 价值$;
       }

       如果 ( ! 是数组（_A）( $wp_meta_keys ) || ! 发行( $wp_meta_keys[ $元类型 ] ) ) {
               返回 美元价值;
       }

       $默认值 = 阵列();
       foreach公司 ( $wp_meta_keys[ $元类型 ] 作为 $子类型 => $元数据 ) {
               foreach公司 ( $元数据 作为 $元密钥 => $个参数 ) {
                       如果 ( $元密钥 === $元键 && 数组键存在( “默认”, $个参数 ) ) {
                               $默认值[ $子类型 ] = $个参数;
                       }
               }
       }

       如果 ( ! $默认值 ) {
               返回 美元价值;
       }

       //如果此元类型没有子类型，则默认值被键控为空字符串。
       如果 ( isset公司( $默认值[''] ) ) {
               $元数据 = $默认值[''];
       } 其他的 {
               $子类型 = 获取对象子类型( $元类型, $对象id );
               如果 ( ! 发行( $默认值[ $子类型 ] ) ) {
                       返回 价值$;
               }
               $元数据 = $默认值[ $子类型 ];
       }

       如果 ( 单个$ ) {
               价值$ = $元数据[“默认”];
       } 其他的 {
               价值$ = 阵列( $元数据[“默认”] );
       }

       返回 价值$;
}

/**
*检查元密钥是否已注册。
 *
*@自4.6.0起
*@自4.9.8起添加了`$object_subtype`参数。
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$meta_key元数据密钥。
*@param string$object_subtype可选。对象类型的子类型。默认空字符串。
*@return bool True，如果元密钥已注册到对象类型，并且如果提供，
对象子类型。如果不是，则为False。
 */
功能 已注册的密钥存在( $对象类型, $元键, $对象_子类型 = '' ) {
       $元键 = 获取注册元密钥( $对象类型, $对象_子类型 );

       返回 发行( $meta_keys（$meta_keys）[ $元键 ] );
}

/**
*从已注册密钥列表中注销元密钥。
 *
*@自4.6.0起
*@自4.9.8起添加了`$object_subtype`参数。
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$meta_key元数据密钥。
*@param string$object_subtype可选。对象类型的子类型。默认空字符串。
*@return bool如果成功，则返回True。如果未注册元密钥，则为False。
 */
功能 取消注册元数据密钥( $对象类型, $元键, $object_子类型 = '' ) {
       全球的 $wp_meta_keys;

       如果 ( ! 已注册的密钥存在( $对象类型, $元键, $对象_子类型 ) ) {
               返回 虚假的;
       }

       $个参数 = $wp_meta_keys[ $对象类型 ][ $对象_子类型 ][ $元键 ];

       如果 ( 发行( $个参数['清理回调'] ) && 可调用（_C）( $个参数['消毒_回调'] ) ) {
               如果 ( ! 空的( $对象_子类型 ) ) {
                       删除过滤器( “消毒_{$对象类型}_元_{$元键}_的_{$对象_子类型}", $个参数['清理回调'] );
               } 其他的 {
                       删除过滤器( “消毒_{$对象类型}_元_{$元键}", $个参数['清理回调'] );
               }
       }

       如果 ( 发行( $args美元['授权回调'] ) && 可调用（_C）( $args美元['授权回调'] ) ) {
               如果 ( ! 空的( $对象_子类型 ) ) {
                       删除过滤器( “身份验证_{$对象类型}_元_{$元键}_的_{$对象_子类型}", $个参数['授权回调'] );
               } 其他的 {
                       删除筛选器（_F）( “身份验证_{$对象类型}_元_{$元键}", $个参数['授权回调'] );
               }
       }

       未设置( $wp_meta_keys[ $对象类型 ][ $对象_子类型 ][ $元键 ] );

       //做一些清理工作。
       如果 ( 空的( $wp_meta_keys[ $对象类型 ][ $对象_子类型 ] ) ) {
               未设置( $wp_meta_keys[ $对象类型 ][ $对象_子类型 ] );
       }
       如果 ( 空的( $wp_meta_keys[ $对象类型 ] ) ) {
               未设置( $wp_meta_keys[ $对象类型 ] );
       }

       返回 真的;
}

/**
*检索对象类型的已注册元数据参数列表，这些参数由其元键进行键控。
 *
*@自4.6.0起
*@自4.9.8起添加了`$object_subtype`参数。
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param string$object_subtype可选。对象类型的子类型。默认空字符串。
*@return array[]已注册元数据参数的列表，由其元键键控。
 */
功能 获取注册元密钥( $对象类型, $对象_子类型 = '' ) {
       全球的 $wp_meta_keys;

       如果 ( ! 是数组（_A）( $wp_meta_keys ) || ! 发行( $wp_meta_keys（$wp_meta_keys）[ $对象类型 ] ) || ! 发行( $wp_meta_keys[ $对象类型 ][ $对象_子类型 ] ) ) {
               返回 阵列();
       }

       返回 $wp_meta_keys[ $对象类型 ][ $对象_子类型 ];
}

/**
*检索指定对象的已注册元数据。
 *
*结果包括专门为
*为整个对象类型注册的对象的子类型和元。
 *
*@自4.6.0起
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$object_id元数据所针对的对象的id。
*@param string$meta_key可选。已注册元数据键。如果未指定，则检索所有已注册的
指定对象的元数据。
*@return mixed如果指定了键的单个值或值数组。所有注册密钥的数组
*以及对象ID的值（如果不是）。如果给定的$meta_key未注册，则为False。
 */
功能 获取注册元数据( $对象类型, $对象id, $元键 = '' ) {
       $对象_子类型 = 获取对象子类型( $对象类型, $object_id（对象id） );

       如果 ( ! 空的( $元键 ) ) {
               如果 ( ! 空的( $对象_子类型 ) && ! 已注册的密钥存在( $对象类型, $元键, $对象_子类型 ) ) {
                       $对象_子类型 = '';
               }

               如果 ( ! 已注册的密钥存在( $对象类型, $元键, $对象_子类型 ) ) {
                       返回 虚假的;
               }

               $元键     = 获取注册元密钥( $对象类型, $对象_子类型 );
               $meta_key_data = $元键[ $元键 ];

               $数据 = 获取元数据( $对象类型, $对象id, $元键, $meta_key_data[“单个”] );

               返回 $数据;
       }

       $数据 = 获取元数据( $对象类型, $对象id );
       如果 ( ! $数据 ) {
               返回 阵列();
       }

       $元键 = 获取注册元密钥( $对象类型 );
       如果 ( ! 空的( $对象_子类型 ) ) {
               $元键 = 阵列_合并( $元键, 获取注册元密钥( $对象类型, $对象_子类型 ) );
       }

       返回 数组交叉键( $数据, $元键 );
}

/**
*根据允许的列表筛选出“register_meta（）”参数。
 *
*`register_meta（）`args可能会随时间而更改，因此需要允许的列表
*明确关闭是一种保修封条。
 *
*@access私有
*@自5.5.0起
 *
*@param array$args来自`register_meta（）`的参数。
*@param array$default_args“register_meta（）”的默认参数。
*@return数组已筛选参数。
 */
功能 _wp_register_meta_args_allowed列表( $个参数, $default_args（默认值_ args） ) {
       返回 数组交叉键( $args美元, $default_args（默认值_ args） );
}

/**
*返回特定类型的给定对象ID的对象子类型。
 *
*@自4.9.8起
 *
*@param string$object_type对象元数据的类型适用于。接受“帖子”、“评论”、“术语”、“用户”、，
*或具有关联元表的任何其他对象类型。
*@param int$object_id要检索其子类型的对象的id。
*@return string对象子类型或空字符串（如果未指定子类型）。
 */
功能 获取对象子类型( $对象类型, $对象id ) {
       $对象id     = (整数) $对象id;
       $对象_子类型 = '';

       转换 ( $对象类型 ) {
               案例 “发布”:
                       $帖子类型 = 获取发布类型( $object_id（对象id） );

                       如果 ( ! 空的( $帖子类型 ) ) {
                               $对象_子类型 = $帖子类型;
                       }
                       打破;

               案例 “术语”:
                       $术语 = 获取项（_term）( $对象id );
                       如果 ( ! $术语 运算符 工作包期限 ) {
                               打破;
                       }

                       $对象_子类型 = $术语->分类学;
                       打破;

               案例 '评论':
                       $条评论 = 获取注释（_C）( $对象id );
                       如果 ( ! $条评论 ) {
                               打破;
                       }

                       $对象_子类型 = '评论';
                       打破;

               案例 “用户”:
                       $用户 = 获取用户（_B）( “id”, $对象id );
                       如果 ( ! $用户 ) {
                               打破;
                       }

                       $对象_子类型 = “用户”;
                       打破;
       }

       /**
*过滤非标准对象类型的对象子类型标识符。
         *
*钩子名称的动态部分`$object_type`是指元对象类型
*（post、comment、term、user或任何其他具有关联元表的类型）。
         *
*可能的挂钩名称包括：
         *
*-`get_object_subtype_post`
*-`get_object_subtype_comment`
*-`get_object_subtype_term`
*-`get_object_subtype_user`
         *
*@自4.9.8起
         *
*@param string$object_subtype要重写的空字符串。
*@param int$object_id要获取其子类型的对象的id。
         */
       返回 应用筛选器( “获取对象子类型_{$对象类型}", $对象_子类型, $对象id );
}