WP_Ajax_Response
Send XML response back to Ajax request.
Contents
More Information More Information
Role of WP_Ajax_Response Role of WP_Ajax_Response
WP_Ajax_Response is WordPress’ class for generating XML-formatted responses to Ajax requests. This is most commonly used to generate responses to custom AJAX actions when using the wp_ajax_ action hook.
Methods and Properties Methods and Properties
NOTE: Refer source code for the complete methods and properties.
Properties Properties
- $responses()
- An array that stores the XML responses to be sent.
Methods Methods
- WP_Ajax_Response($args)
- Constructor (PHP4-compatible). If provided arguments, it passes them directly to the add method.
- add($args)
- This method takes an associative array of various options to be used in the AJAX response XML.
- send()
- This will set the correct content type for the header, output the response xml, then die – ensuring a proper XML response.
Usage Usage
To use WP_Ajax_Response, you need to instantiate the class with an array of options, then call the instances send() method to output the response.
The options array takes the following key=>value pairs:
- ‘what’
- A string containing the XMLRPC response type (used as the name of the xml element).
- ‘action’
- A boolean or string that will behave like a nonce. This is added to the response element’s action attribute.
- ‘id’
- This is either an integer (usually 1) or a WP_Error object (if you need to return an error). Most commonly, the id value is used as a boolean, where 1 is a success and 0 is a failure.
- ‘old_id’
- This is
falseby default, but you can alternatively provide an integer for the previous id, if needed. - ‘position’
- This is an integer or a string where -1 = top, 1 = bottom, ‘html ID’ = after, ‘-html ID’ = before
- ‘data’
- A string containing output content or a message (such as html). This is disregarded if you pass a WP_Error object as the id.
- ‘supplemental’
- This can an associative array of strings, which will be rendered into children of the
<supplemental>element. Keys become element names, and values are embedded in CDATA within those elements. Useful for passing additional information to the browser.
Response Format Response Format
Responses are made in the XML-RPC format and may be handled by JavaScript.
A typical WordPress autosave response looks like this:
<?xml version='1.0' standalone='yes'?>
<wp_ajax>
<response action='autosave_1'>
<autosave id='1' position='1'>
<response_data>
<![CDATA[Draft saved at 9:31:55 pm.]]>
</response_data>
<supplemental></supplemental>
</autosave>
</response>
</wp_ajax>
Let’s break this example down to see what it means:
- <wp_ajax>
- This the root element of every response. All responses made by the WP_Ajax_Response class are wrapped in the
<wp_ajax>element.
- <response>
- Immediately within the wp_ajax element is
<response>, which contains the attributes ‘action’ and ‘position’. These attributes correspond to the ‘action’ and ‘position’ key=>value pairs defined in the options array.
- <autosave> (arbitrary)
- Next, the above example shows an
<autosave>element – this element matches the value of the ‘what’ key=>value pair in the options array. In your own use, this element can be named whatever you like, provided it is a valid XML element name.
- <response_data> / <wp_error_data>
- Within the custom response element (e.g.
<autosave>), there will either be a<response_data>element (with CDATA tag) or a<wp_error_data>element. If you pass a WP_Error object to WP_Ajax_Response as the ‘id’ in your options array, the<wp_error_data>element is automatically generated. Otherwise, the<response_data>element is used with whatever value you passed to WP_Ajax_Response with your option array’s “data” value.
- For the most part, any content you want to pass back to the browser (such as HTML), can be passed in your option array’s “data” key=>value pair.
- <supplemental>
- Finally, the
<supplemental>element will contain whatever arbitrary structure you decide to pass along with your option array’s “supplemental” key=>value pair.
Source Source
File: wp-includes/class-wp-ajax-response.php
class WP_Ajax_Response {
/**
* Store XML responses to send.
*
* @since 2.1.0
* @var array
*/
public $responses = array();
/**
* Constructor - Passes args to WP_Ajax_Response::add().
*
* @since 2.1.0
*
* @see WP_Ajax_Response::add()
*
* @param string|array $args Optional. Will be passed to add() method.
*/
public function __construct( $args = '' ) {
if ( ! empty( $args ) ) {
$this->add( $args );
}
}
/**
* Appends data to an XML response based on given arguments.
*
* With `$args` defaults, extra data output would be:
*
* <response action='{$action}_$id'>
* <$what id='$id' position='$position'>
* <response_data><![CDATA[$data]]></response_data>
* </$what>
* </response>
*
* @since 2.1.0
*
* @param string|array $args {
* Optional. An array or string of XML response arguments.
*
* @type string $what XML-RPC response type. Used as a child element of `<response>`.
* Default 'object' (`<object>`).
* @type string|false $action Value to use for the `action` attribute in `<response>`. Will be
* appended with `_$id` on output. If false, `$action` will default to
* the value of `$_POST['action']`. Default false.
* @type int|WP_Error $id The response ID, used as the response type `id` attribute. Also
* accepts a `WP_Error` object if the ID does not exist. Default 0.
* @type int|false $old_id The previous response ID. Used as the value for the response type
* `old_id` attribute. False hides the attribute. Default false.
* @type string $position Value of the response type `position` attribute. Accepts 1 (bottom),
* -1 (top), HTML ID (after), or -HTML ID (before). Default 1 (bottom).
* @type string|WP_Error $data The response content/message. Also accepts a WP_Error object if the
* ID does not exist. Default empty.
* @type array $supplemental An array of extra strings that will be output within a `<supplemental>`
* element as CDATA. Default empty array.
* }
* @return string XML response.
*/
public function add( $args = '' ) {
$defaults = array(
'what' => 'object',
'action' => false,
'id' => '0',
'old_id' => false,
'position' => 1,
'data' => '',
'supplemental' => array(),
);
$parsed_args = wp_parse_args( $args, $defaults );
$position = preg_replace( '/[^a-z0-9:_-]/i', '', $parsed_args['position'] );
$id = $parsed_args['id'];
$what = $parsed_args['what'];
$action = $parsed_args['action'];
$old_id = $parsed_args['old_id'];
$data = $parsed_args['data'];
if ( is_wp_error( $id ) ) {
$data = $id;
$id = 0;
}
$response = '';
if ( is_wp_error( $data ) ) {
foreach ( (array) $data->get_error_codes() as $code ) {
$response .= "<wp_error code='$code'><![CDATA[" . $data->get_error_message( $code ) . ']]></wp_error>';
$error_data = $data->get_error_data( $code );
if ( ! $error_data ) {
continue;
}
$class = '';
if ( is_object( $error_data ) ) {
$class = ' class="' . get_class( $error_data ) . '"';
$error_data = get_object_vars( $error_data );
}
$response .= "<wp_error_data code='$code'$class>";
if ( is_scalar( $error_data ) ) {
$response .= "<![CDATA[$error_data]]>";
} elseif ( is_array( $error_data ) ) {
foreach ( $error_data as $k => $v ) {
$response .= "<$k><![CDATA[$v]]></$k>";
}
}
$response .= '</wp_error_data>';
}
} else {
$response = "<response_data><![CDATA[$data]]></response_data>";
}
$s = '';
if ( is_array( $parsed_args['supplemental'] ) ) {
foreach ( $parsed_args['supplemental'] as $k => $v ) {
$s .= "<$k><![CDATA[$v]]></$k>";
}
$s = "<supplemental>$s</supplemental>";
}
if ( false === $action ) {
$action = $_POST['action'];
}
$x = '';
$x .= "<response action='{$action}_$id'>"; // The action attribute in the xml output is formatted like a nonce action.
$x .= "<$what id='$id' " . ( false === $old_id ? '' : "old_id='$old_id' " ) . "position='$position'>";
$x .= $response;
$x .= $s;
$x .= "</$what>";
$x .= '</response>';
$this->responses[] = $x;
return $x;
}
/**
* Display XML formatted responses.
*
* Sets the content type header to text/xml.
*
* @since 2.1.0
*/
public function send() {
header( 'Content-Type: text/xml; charset=' . get_option( 'blog_charset' ) );
echo "<?xml version='1.0' encoding='" . get_option( 'blog_charset' ) . "' standalone='yes'?><wp_ajax>";
foreach ( (array) $this->responses as $response ) {
echo $response;
}
echo '</wp_ajax>';
if ( wp_doing_ajax() ) {
wp_die();
} else {
die();
}
}
}
Expand full source code Collapse full source code View on Trac
Methods Methods
- __construct — Constructor - Passes args to WP_Ajax_Response::add().
- __get — Make private properties readable for backwards compatibility.
- __isset — Make private properties checkable for backwards compatibility.
- __set — Make private properties settable for backwards compatibility.
- __unset — Make private properties un-settable for backwards compatibility.
- add — Appends data to an XML response based on given arguments.
- send — Display XML formatted responses.
Changelog Changelog
| Version | Description |
|---|---|
| 2.1.0 | Introduced. |
User Contributed Notes User Contributed Notes
You must log in before being able to contribute a note or feedback.
Typical Response Example
This demonstrates a typical response. The first code block shows the PHP required to create a simple response. The second code block shows the generated XML.
The above example would output the following XML:
<?xml version='1.0' standalone='yes'?> <wp_ajax> <response action='update_something_1'> <foobar id='1' position='1'> <response_data><![CDATA[<p><strong>Hello world!</strong></p>]]></response_data> <supplemental></supplemental> </foobar> </response> </wp_ajax>Error Response Example from Codex
This demonstrates a typical error response. The first code block shows the PHP required to generate such a response, and the second code block shows the generated XML output. Note that you can just as easily give your response an id of 0 instead of generating a new WP_Error. The choice is up to you.
$response = array( 'what'=>'stuff', 'action'=>'delete_something', 'id'=>new WP_Error('oops','I had an accident.'), 'data'=>'Whoops, there was a problem!' ); $xmlResponse = new WP_Ajax_Response($response); $xmlResponse->send();The above example would output the following XML:
<?xml version='1.0' standalone='yes'?> <wp_ajax> <response action='delete_something_0'> <stuff id='0' position='1'> <wp_error code='oops'><![CDATA[I had an accident.]]></wp_error> <supplemental></supplemental> </stuff> </response> </wp_ajax>Note how this response completely disregards our ‘data’ value.