mozilla
Los resultados de tu búsqueda

    Using XMLHttpRequest

    This translation is incomplete. Please help translate this article from English.

    XMLHttpRequest makes sending HTTP requests very easy.  You simply create an instance of the object, open a URL, and send the request.  The HTTP status of the result, as well as the result's contents, are available in the request object when the transaction is completed.

    Synchronous and asynchronous requests

    XMLHttpRequest supports both synchronous and asynchronous communications.

    Note: You shouldn't use synchronous XMLHttpRequests because, due to the inherently asynchronous nature of networking, there are various ways memory and events can leak when using synchronous requests.

    In versions of Firefox prior to Firefox 3, synchronous XMLHttpRequest requests blocked the user interface.  In order to make it possible for the user to terminate frozen requests, Firefox 3 no longer does so.

    Example: Synchronous request

    This example demonstrates how to make a simple synchronous request.

    var req = new XMLHttpRequest();
    req.open('GET', 'http://www.mozilla.org/', false); 
    req.send(null);
    if(req.status == 200)
      dump(req.responseText);

    Line 1 instantiates the XMLHttpRequest object.  Line 2 then opens a new request, specifying that a GET request will be used to fetch the Mozilla.org home page, and that the operation should not be asynchronous.

    Line 3 sends the request.  The null parameter indicates that no body content is needed for the GET request.

    Line 4 checks the status code after the transaction is completed.  If the result is 200 -- HTTP's "OK" result -- the document's text content is output to the console.

    Example: Non-HTTP synchronous request

    Despite its name, XMLHttpRequest can be used for non-HTTP requests.  This example shows how to use it to fetch a file from the local file system.

    var req = new XMLHttpRequest();
    req.open('GET', 'file:///home/user/file.json', false); 
    req.send(null);
    if(req.status == 0)
      dump(req.responseText);

    The key thing to note here is that the result status is being compared to 0 for success instead of 200.  This is because the file and ftp schemes do not use HTTP result codes.

    Example: Asynchronous request

    If you use XMLHttpRequest from an extension, you should use it asynchronously.  In this case, you receive a callback when the data has been received, which lets the browser continue to work as normal while your request is being handled.

    var req = new XMLHttpRequest();
    req.open('GET', 'http://www.mozilla.org/', true);
    req.onreadystatechange = function (aEvt) {
      if (req.readyState == 4) {
         if(req.status == 200)
          dump(req.responseText);
         else
          dump("Error loading page\n");
      }
    };
    req.send(null); 

    Line 2 specifies true for its third parameter to indicate that the request should be handled asynchronously.

    Line 3 creates an event handler function object and assigns it to the request's onreadystatechange attribute.  This handler looks at the request's readyState to see if the transaction is complete in line 4, and if it is, and the HTTP status is 200, dumps the received content.  If an error occurred, an error message is displayed.

    Line 11 actually initiates the request.  The callback routine is called whenever the state of the request changes.

    Analyzing and manipulating HTML responseText

    If you use XMLHttpRequest to get the content of a remote HTML webpage, the responseText will be a string containing a "soup" of all the HTML tags, which can be hard to manipulate and analyze. There are three primary ways of analyzing this HTML soup string

    1. Safely parsing with nsIScriptableUnescapeHTML will quickly convert the HTML string into DOM, while striping out javascript and other advanced elements, including the <head> of the webpage.
    2. RegExp can be used if you always know the content of the HTML responseText beforehand. You might want to remove line breaks, if you use RegExp to scan with regard to linebreaks. However, this method is a "last resort" since if the HTML code changes slightly, the method will likely fail.
    3. Using a hidden chrome or content-level iframe to load up the webpage can also be done to then manipulate it as DOM, however there are security risks to giving remote code this level of privileged access, which can cause issues for the review of your addon. For example, if a webpage executes the common "document.location = redirecttothispage.html" command on load, this will get interpreted as changing the browser chrome location (document.location in an extension) as opposed to the webpage location (content.document.location in an extension), thus destroying all browser components. Alternatively, and somewhat safer, a responseText string attained through a XMLHttpRequest can be analyzed using RegExp to remove potential JavaScript problems, then loaded into the hidden iframe that you have set up:
    document.getElementById('hiddenXULiframe').contentWindow.document.body.innerHTML = req.responseText
    

    Using FormData objects

    The FormData object lets you compile a set of key/value pairs to send using XMLHttpRequest. It's primarily intended for use in sending form data, but can be used independently from forms in order to transmit keyed data. The transmitted data is in the same format that the form's submit() method would use to send the data if the form's encoding type were set to "multipart/form-data".

    Creating a FormData object from scratch

    You can build a FormData object yourself, instantiating it then appending fields to it by calling its append() method, like this:

    var formData = new FormData();
    
    formData.append("username", "Groucho");
    formData.append("accountnum", 123456);
    formData.append("afile", fileInputElement.files[0]);
    
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "http://foo.com/submitform.php");
    xhr.send(formData);
    

    This example builds a FormData object containing values for fields named "username" and "accountnum", then uses the XMLHttpRequest method send() to send the form's data.

    Retrieving a FormData object from an HTML form

    To construct a FormData object that contains the data from an existing <form>, specify that form element when creating the FormData object:

    newFormData = new FormData(someFormElement);
    

    For example:

    var formElement = document.getElementById("myFormElement");
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "submitform.php");
    xhr.send(new FormData(formElement));
    

    You can also add data to the FormData object between retrieving it from a form and sending it, like this:

    var formElement = document.getElementById("myFormElement");
    formData = new FormData(formElement);
    formData.append("serialnumber", serialNumber++);
    xhr.send(formData); 
    

    This lets you augment the form's data before sending it along, to include additional information that's not necessarily user editable on the form.

    Sending files using a FormData object

    You can also send files using FormData. Simply include an <input> element of type "file":

    <form enctype="multipart/form-data" method="post" name="fileinfo" id="fileinfo">
      <label>Your email address:</label>
      <input type="email" autocomplete="on" autofocus name="userid" placeholder="email" required size="32" maxlength="64"><br />
      <label>Custom file ID:</label>
      <input type="text" name="fileid" size="12" maxlength="32"><br />
      <label>File to stash:</label>
      <input type="file" name="file" required>
    </form>
    <div id="output"></div>
    <a href="javascript:sendForm()">Stash the file!</a>
    

    Then you can send it using code like the following:

    function sendForm() {
      var output = document.getElementById("output");
      var data = new FormData(document.getElementById("fileinfo"));
      
      data.append("CustomField", "This is some extra data");
      
      var xhr = new XMLHttpRequest();
      xhr.open("POST", "stash.pl", false)
      xhr.send(data);
      if (xhr.status == 200) {
        output.innerHTML += "Uploaded!<br />";
      } else {
        output.innerHTML += "Error " + xhr.status + " occurred uploading your file.<br />";
      }
    }
    

    Note that this example is directing the output to a Perl CGI script running on the server, and handles HTTP errors, although not prettily.

    Handling binary data

    Although XMLHttpRequest is most commonly used to send and receive textual data, it can be used to send and receive binary content.

    Receiving binary data

    The load_binary_resource() function shown below loads binary data from the specified URL, returning it to the caller.

    function load_binary_resource(url) {
      var req = new XMLHttpRequest();
      req.open('GET', url, false);
      //XHR binary charset opt by Marcus Granado 2006 [http://mgran.blogspot.com]
      req.overrideMimeType('text/plain; charset=x-user-defined');
      req.send(null);
      if (req.status != 200) return '';
      return req.responseText;
    }
    

    The magic happens in line 5, which overrides the MIME type, forcing Firefox to treat it as plain text, using a user-defined character set.  This tells Firefox not to parse it, and to let the bytes pass through unprocessed.

    var filestream = load_binary_resource(url);
    var abyte = filestream.charCodeAt(x) & 0xff; // throw away high-order byte (f7)

    The example above fetches the byte at offset x within the loaded binary data.  The valid range for x is from 0 to filestream.length-1.

    See downloading binary streams with XMLHttpRequest for a detailed explanation. See also downloading files.

    Receiving binary data using JavaScript typed arrays

    Gecko 2.0 (Firefox 4 / Thunderbird 3.3 / SeaMonkey 2.1) adds a Gecko-specific mozResponseArrayBuffer property to the XMLHttpRequest object, which contains a JavaScript typed array representing the raw binary contents of the response from the server. This lets you read the binary data without taking any special steps.

    var xhr = new XMLHttpRequest();
    xhr.open("GET", "binary_file", false);
    xhr.send(null);
    
    buffer = xhr.mozResponseArrayBuffer;
    if (buffer) {
      var byteArray = new UInt8Array(buffer);
      for (var i=0; i<byteArray.byteLength; i++) {
        // do something with each byte in the array
      }
    }
    

    This example reads a binary file and interprets it as 8-bit unsigned integers.

    Sending binary data

    This example transmits binary content asynchronously, using the POST method.

    var req = new XMLHttpRequest();
    req.open("POST", url, true);
    // set headers and mime-type appropriately
    req.setRequestHeader("Content-Length", 741);
    req.sendAsBinary(aBody);

    Line 4 sets the Content-Length header to 741, indicating that the data is 741 bytes long.  Obviously you need to change this value based on the actual size of the data being sent.

    Line 5 uses the sendAsBinary() method to initiate the request.

    You can also send binary content by passing an instance of the nsIFileInputStream to send().  In that case, you don't have to set the Content-Length header yourself, as the information is fetched from the stream automatically:

    // Make a stream from a file.
    var stream = Components.classes["@mozilla.org/network/file-input-stream;1"]
                           .createInstance(Components.interfaces.nsIFileInputStream);
    stream.init(file, 0x04 | 0x08, 0644, 0x04); // file is an nsIFile instance   
    
    // Try to determine the MIME type of the file
    var mimeType = "text/plain";
    try {
      var mimeService = Components.classes["@mozilla.org/mime;1"]
              .getService(Components.interfaces.nsIMIMEService);
      mimeType = mimeService.getTypeFromFile(file); // file is an nsIFile instance
    }
    catch(e) { /* eat it; just use text/plain */ }
    
    // Send    
    var req = Components.classes["@mozilla.org/xmlextras/xmlhttprequest;1"]
                        .createInstance(Components.interfaces.nsIXMLHttpRequest);
    req.open('PUT', url, false); /* synchronous! */
    req.setRequestHeader('Content-Type', mimeType);
    req.send(stream);
    

    Monitoring progress

    XMLHttpRequest provides the ability to listen to various events that can occur while the request is being processed. This includes periodic progress notifications, error notifications, and so forth.

    In Firefox 3.5 and later

    Firefox 3.5 adds support for DOM progress event monitoring of XMLHttpRequest transfers; this follows the Web API specification for progress events.

    var req = new XMLHttpRequest();
    
    req.addEventListener("progress", updateProgress, false);
    req.addEventListener("load", transferComplete, false);
    req.addEventListener("error", transferFailed, false);
    req.addEventListener("abort", transferCanceled, false);
    
    req.open();
    
    ...
    
    // progress on transfers from the server to the client (downloads)
    function updateProgress(evt) {
      if (evt.lengthComputable) {
        var percentComplete = evt.loaded / evt.total;
        ...
      } else {
        // Unable to compute progress information since the total size is unknown
      }
    }
    
    function transferComplete(evt) {
      alert("The transfer is complete.");
    }
    
    function transferFailed(evt) {
      alert("An error occurred while transferring the file.");
    }
    
    function transferCanceled(evt) {
      alert("The transfer has been canceled by the user.");
    }
    

    Lines 3-6 add event listeners for the various events that are sent while performing a data transfer using XMLHttpRequest.  See nsIDOMProgressEvent and nsIXMLHttpRequestEventTarget for details on these events.

    Note: You need to add the event listeners before calling open() on the request.  Otherwise the progress events will not fire.

    The progress event handler, specified by the updateProgress() function in this example, receives the total number of bytes to transfer as well as the number of bytes transferred so far in the event's total and loaded fields.  However, if the lengthComputable field is false, the total length is not known and will be zero.

    Progress events exist for both download and upload transfers. The download events are fired on the XMLHttpRequest object itself, as shown in the above sample. The upload events are fired on the XMLHttpRequest.upload object, as shown below:

    var req = new XMLHttpRequest();
    
    req.upload.addEventListener("progress", updateProgress, false);
    req.upload.addEventListener("load", transferComplete, false);
    req.upload.addEventListener("error", transferFailed, false);
    req.upload.addEventListener("abort", transferCanceled, false);
    
    req.open();
    Note: Progress events are not available for the file: protocol.

    In Firefox 3 and earlier

    If, for example, you wish to provide progress information to the user while the document is being received, you can use code like this:

    function onProgress(e) {
      var percentComplete = (e.position / e.totalSize)*100;
      // ...
    }
    
    function onError(e) {
      alert("Error " + e.target.status + " occurred while receiving the document.");
    }
    
    function onLoad(e) {
      // ...
    }
    // ...
    var req = new XMLHttpRequest();
    req.onprogress = onProgress; // or req.addEventListener("progress", onProgress, false);
    req.open("GET", url, true);
    req.onload = onLoad; // or req.addEventListener("load", onLoad, false);
    req.onerror = onError; // or req.addEventListener("error", onError, false);
    req.send(null);
    

    The onprogress event's attributes, position and totalSize, indicate the current number of bytes received and the total number of bytes expected, respectively.

    All of these events have their target attribute set to the XMLHttpRequest they correspond to.

    Note: Firefox 3 properly ensures that the values of the target, currentTarget, and this fields of the event object are set to reference the correct objects when calling event handlers for XML documents represented by XMLDocument. See bug 198595 for details.

    Cross-site XMLHttpRequest

    Este artículo cubre características introducidas en Firefox 3.5

    Firefox 3.5 supports cross-site requests by implementing the web applications working group's Access Control for Cross-Site Requests standard.  As long as the server is configured to allow requests from your web application's origin, XMLHttpRequest will work.  Otherwise, an INVALID_ACCESS_ERR exception is thrown.

    Bypassing the cache

    Normally, XMLHttpRequest tries to retrieve content from the cache, if it's available.  To bypass this, do the following:

    var req = new XMLHttpRequest();
    req.open('GET', url, false);
    req.channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
    req.send(null);
    Note: This approach will only work in Gecko-based software, as the channel attribute is Gecko-specific.

    An alternate, cross-browser compatible approach is to append a timestamp to the URL, being sure to include a "?" or "&" as appropriate.  For example:

    http://foo.com/bar.html

    becomes

    http://foo.com/bar.html?12345

    and

    http://foo.com/bar.html?foobar=baz

    becomes

    http://foo.com/bar.html?foobar=baz&12345

    Since the local cache is indexed by URL, this causes every request to be unique, thereby bypassing the cache.

    You can automatically adjust URLs using the following code:

    var req = new XMLHttpRequest();
    req.open("GET", url += (url.match(/\?/) == null ? "?" : "&") + (new Date()).getTime(), false);
    req.send(null); 

    Security

    Nota sobre Firefox 3

    Versions of Firefox prior to Firefox 3 allowed you to set the preference capability.policy.<policyname>.XMLHttpRequest.open</policyname> to allAccess to give specific sites cross-site access.  This is no longer supported.

    Downloading JSON and JavaScript from extensions

    For security reasons, extensions should never use eval() to parse JSON or JavaScript code downloaded from the web.  See Downloading JSON and JavaScript in extensions for details.

    Using XMLHttpRequest from JavaScript modules / XPCOM components

    Instantiating XMLHttpRequest from a JavaScript module or an XPCOM component works a little differently; it can't be instantiated using the XMLHttpRequest() constructor. The constructor is not defined inside components and the code results in an error. You'll need to create and use it using a different syntax.

    Instead of this:

    var req = new XMLHttpRequest();
    req.onprogress = onProgress;
    req.onload = onLoad;
    req.onerror = onError;
    req.open("GET", url, true);
    req.send(null);
    

    Do this:

    var req = Components.classes["@mozilla.org/xmlextras/xmlhttprequest;1"]
                        .createInstance(Components.interfaces.nsIXMLHttpRequest);
    req.onprogress = onProgress;
    req.onload = onLoad;
    req.onerror = onError;
    req.open("GET", url, true);
    req.send(null);
    

    For C++ code you would need to QueryInterface the component to an nsIEventTarget in order to add event listeners, but chances are in C++ using a channel directly would be better.

    See also

    1. MDC AJAX introduction
    2. HTTP access control
    3. How to check the security state of an XMLHTTPRequest over SSL
    4. XMLHttpRequest - REST and the Rich User Experience
    5. Microsoft documentation
    6. Apple developers' reference
    7. "Using the XMLHttpRequest Object" (jibbering.com)
    8. The XMLHttpRequest Object: W3C Working Draft
    9. Web Progress Events specification
    10. Reading Ogg files with JavaScript (Chris Double)

    Etiquetas y colaboradores del documento

    Contributors to this page: inma_610, teoli
    Última actualización por: teoli,