WordPress как на ладони
Недорогой хостинг для сайтов на WordPress: wordpress.jino.ru Шаблоны сайтов на русском
функция не описана

WP::parse_request() WP 2.0.0

Parse request to find correct WordPress query.

Sets up the query variables based on the request. There are also many filters and actions that can be used to further manipulate the result.

Это метод класса: WP

  • Global. WP_Rewrite. $wp_rewrite
Хуки из метода
Возвращает

Ничего (null).

Использование

$WP = new WP();
$var = $WP->parse_request( $extra_query_vars );
$extra_query_vars(массив/строка)
Set the extra query variables.
По умолчанию: ''

Код WP::parse request: wp-includes/class-wp.php VER 5.1.1

<?php
public function parse_request( $extra_query_vars = '' ) {
	global $wp_rewrite;

	/**
	 * Filters whether to parse the request.
	 *
	 * @since 3.5.0
	 *
	 * @param bool         $bool             Whether or not to parse the request. Default true.
	 * @param WP           $this             Current WordPress environment instance.
	 * @param array|string $extra_query_vars Extra passed query variables.
	 */
	if ( ! apply_filters( 'do_parse_request', true, $this, $extra_query_vars ) ) {
		return;
	}

	$this->query_vars     = array();
	$post_type_query_vars = array();

	if ( is_array( $extra_query_vars ) ) {
		$this->extra_query_vars = & $extra_query_vars;
	} elseif ( ! empty( $extra_query_vars ) ) {
		parse_str( $extra_query_vars, $this->extra_query_vars );
	}
	// Process PATH_INFO, REQUEST_URI, and 404 for permalinks.

	// Fetch the rewrite rules.
	$rewrite = $wp_rewrite->wp_rewrite_rules();

	if ( ! empty( $rewrite ) ) {
		// If we match a rewrite rule, this will be cleared.
		$error               = '404';
		$this->did_permalink = true;

		$pathinfo         = isset( $_SERVER['PATH_INFO'] ) ? $_SERVER['PATH_INFO'] : '';
		list( $pathinfo ) = explode( '?', $pathinfo );
		$pathinfo         = str_replace( '%', '%25', $pathinfo );

		list( $req_uri ) = explode( '?', $_SERVER['REQUEST_URI'] );
		$self            = $_SERVER['PHP_SELF'];
		$home_path       = trim( parse_url( home_url(), PHP_URL_PATH ), '/' );
		$home_path_regex = sprintf( '|^%s|i', preg_quote( $home_path, '|' ) );

		// Trim path info from the end and the leading home path from the
		// front. For path info requests, this leaves us with the requesting
		// filename, if any. For 404 requests, this leaves us with the
		// requested permalink.
		$req_uri  = str_replace( $pathinfo, '', $req_uri );
		$req_uri  = trim( $req_uri, '/' );
		$req_uri  = preg_replace( $home_path_regex, '', $req_uri );
		$req_uri  = trim( $req_uri, '/' );
		$pathinfo = trim( $pathinfo, '/' );
		$pathinfo = preg_replace( $home_path_regex, '', $pathinfo );
		$pathinfo = trim( $pathinfo, '/' );
		$self     = trim( $self, '/' );
		$self     = preg_replace( $home_path_regex, '', $self );
		$self     = trim( $self, '/' );

		// The requested permalink is in $pathinfo for path info requests and
		//  $req_uri for other requests.
		if ( ! empty( $pathinfo ) && ! preg_match( '|^.*' . $wp_rewrite->index . '$|', $pathinfo ) ) {
			$requested_path = $pathinfo;
		} else {
			// If the request uri is the index, blank it out so that we don't try to match it against a rule.
			if ( $req_uri == $wp_rewrite->index ) {
				$req_uri = '';
			}
			$requested_path = $req_uri;
		}
		$requested_file = $req_uri;

		$this->request = $requested_path;

		// Look for matches.
		$request_match = $requested_path;
		if ( empty( $request_match ) ) {
			// An empty request could only match against ^$ regex
			if ( isset( $rewrite['$'] ) ) {
				$this->matched_rule = '$';
				$query              = $rewrite['$'];
				$matches            = array( '' );
			}
		} else {
			foreach ( (array) $rewrite as $match => $query ) {
				// If the requested file is the anchor of the match, prepend it to the path info.
				if ( ! empty( $requested_file ) && strpos( $match, $requested_file ) === 0 && $requested_file != $requested_path ) {
					$request_match = $requested_file . '/' . $requested_path;
				}

				if ( preg_match( "#^$match#", $request_match, $matches ) ||
					preg_match( "#^$match#", urldecode( $request_match ), $matches ) ) {

					if ( $wp_rewrite->use_verbose_page_rules && preg_match( '/pagename=\$matches\[([0-9]+)\]/', $query, $varmatch ) ) {
						// This is a verbose page match, let's check to be sure about it.
						$page = get_page_by_path( $matches[ $varmatch[1] ] );
						if ( ! $page ) {
							continue;
						}

						$post_status_obj = get_post_status_object( $page->post_status );
						if ( ! $post_status_obj->public && ! $post_status_obj->protected
							&& ! $post_status_obj->private && $post_status_obj->exclude_from_search ) {
							continue;
						}
					}

					// Got a match.
					$this->matched_rule = $match;
					break;
				}
			}
		}

		if ( isset( $this->matched_rule ) ) {
			// Trim the query of everything up to the '?'.
			$query = preg_replace( '!^.+\?!', '', $query );

			// Substitute the substring matches into the query.
			$query = addslashes( WP_MatchesMapRegex::apply( $query, $matches ) );

			$this->matched_query = $query;

			// Parse the query.
			parse_str( $query, $perma_query_vars );

			// If we're processing a 404 request, clear the error var since we found something.
			if ( '404' == $error ) {
				unset( $error, $_GET['error'] );
			}
		}

		// If req_uri is empty or if it is a request for ourself, unset error.
		if ( empty( $requested_path ) || $requested_file == $self || strpos( $_SERVER['PHP_SELF'], 'wp-admin/' ) !== false ) {
			unset( $error, $_GET['error'] );

			if ( isset( $perma_query_vars ) && strpos( $_SERVER['PHP_SELF'], 'wp-admin/' ) !== false ) {
				unset( $perma_query_vars );
			}

			$this->did_permalink = false;
		}
	}

	/**
	 * Filters the query variables whitelist before processing.
	 *
	 * Allows (publicly allowed) query vars to be added, removed, or changed prior
	 * to executing the query. Needed to allow custom rewrite rules using your own arguments
	 * to work, or any other custom query variables you want to be publicly available.
	 *
	 * @since 1.5.0
	 *
	 * @param string[] $public_query_vars The array of whitelisted query variable names.
	 */
	$this->public_query_vars = apply_filters( 'query_vars', $this->public_query_vars );

	foreach ( get_post_types( array(), 'objects' ) as $post_type => $t ) {
		if ( is_post_type_viewable( $t ) && $t->query_var ) {
			$post_type_query_vars[ $t->query_var ] = $post_type;
		}
	}

	foreach ( $this->public_query_vars as $wpvar ) {
		if ( isset( $this->extra_query_vars[ $wpvar ] ) ) {
			$this->query_vars[ $wpvar ] = $this->extra_query_vars[ $wpvar ];
		} elseif ( isset( $_GET[ $wpvar ] ) && isset( $_POST[ $wpvar ] ) && $_GET[ $wpvar ] !== $_POST[ $wpvar ] ) {
			wp_die( __( 'A variable mismatch has been detected.' ), __( 'Sorry, you are not allowed to view this item.' ), 400 );
		} elseif ( isset( $_POST[ $wpvar ] ) ) {
			$this->query_vars[ $wpvar ] = $_POST[ $wpvar ];
		} elseif ( isset( $_GET[ $wpvar ] ) ) {
			$this->query_vars[ $wpvar ] = $_GET[ $wpvar ];
		} elseif ( isset( $perma_query_vars[ $wpvar ] ) ) {
			$this->query_vars[ $wpvar ] = $perma_query_vars[ $wpvar ];
		}

		if ( ! empty( $this->query_vars[ $wpvar ] ) ) {
			if ( ! is_array( $this->query_vars[ $wpvar ] ) ) {
				$this->query_vars[ $wpvar ] = (string) $this->query_vars[ $wpvar ];
			} else {
				foreach ( $this->query_vars[ $wpvar ] as $vkey => $v ) {
					if ( is_scalar( $v ) ) {
						$this->query_vars[ $wpvar ][ $vkey ] = (string) $v;
					}
				}
			}

			if ( isset( $post_type_query_vars[ $wpvar ] ) ) {
				$this->query_vars['post_type'] = $post_type_query_vars[ $wpvar ];
				$this->query_vars['name']      = $this->query_vars[ $wpvar ];
			}
		}
	}

	// Convert urldecoded spaces back into +
	foreach ( get_taxonomies( array(), 'objects' ) as $taxonomy => $t ) {
		if ( $t->query_var && isset( $this->query_vars[ $t->query_var ] ) ) {
			$this->query_vars[ $t->query_var ] = str_replace( ' ', '+', $this->query_vars[ $t->query_var ] );
		}
	}

	// Don't allow non-publicly queryable taxonomies to be queried from the front end.
	if ( ! is_admin() ) {
		foreach ( get_taxonomies( array( 'publicly_queryable' => false ), 'objects' ) as $taxonomy => $t ) {
			/*
			 * Disallow when set to the 'taxonomy' query var.
			 * Non-publicly queryable taxonomies cannot register custom query vars. See register_taxonomy().
			 */
			if ( isset( $this->query_vars['taxonomy'] ) && $taxonomy === $this->query_vars['taxonomy'] ) {
				unset( $this->query_vars['taxonomy'], $this->query_vars['term'] );
			}
		}
	}

	// Limit publicly queried post_types to those that are publicly_queryable
	if ( isset( $this->query_vars['post_type'] ) ) {
		$queryable_post_types = get_post_types( array( 'publicly_queryable' => true ) );
		if ( ! is_array( $this->query_vars['post_type'] ) ) {
			if ( ! in_array( $this->query_vars['post_type'], $queryable_post_types ) ) {
				unset( $this->query_vars['post_type'] );
			}
		} else {
			$this->query_vars['post_type'] = array_intersect( $this->query_vars['post_type'], $queryable_post_types );
		}
	}

	// Resolve conflicts between posts with numeric slugs and date archive queries.
	$this->query_vars = wp_resolve_numeric_slug_conflicts( $this->query_vars );

	foreach ( (array) $this->private_query_vars as $var ) {
		if ( isset( $this->extra_query_vars[ $var ] ) ) {
			$this->query_vars[ $var ] = $this->extra_query_vars[ $var ];
		}
	}

	if ( isset( $error ) ) {
		$this->query_vars['error'] = $error;
	}

	/**
	 * Filters the array of parsed query variables.
	 *
	 * @since 2.1.0
	 *
	 * @param array $query_vars The array of requested query variables.
	 */
	$this->query_vars = apply_filters( 'request', $this->query_vars );

	/**
	 * Fires once all query variables for the current request have been parsed.
	 *
	 * @since 2.1.0
	 *
	 * @param WP $this Current WordPress environment instance (passed by reference).
	 */
	do_action_ref_array( 'parse_request', array( &$this ) );
}