$.get(url,[data],[callback],[type])
$.post(url,[data],[callback],[type])

$.get('/test"htmlcode">

$("#content").load('/user');
$.getJSON(url,[data],[callback])




如果是JSON数据回调会成功，否则失败


$.getJSON('/test',{type:1},function(){
  console.log(argument)
});
$.getScript(url,[claaback])




动态加载脚本文件


$.gerScript('/js/test.js',function(){
  alert(test(1,2));
});



$.ajax详细使用方法


$.ajax(url,[settings]);

$.ajax({
  url:'/test',
  success:function(){
    alert('ok');
  }
});




处理响应结果的回调函数：

success[成功]，error[请求失败]，

statusCode[指明返回的状态码的回调函数],

complete[请求返回前的回调函数(处理返回不同状态码的请求)]




$.ajax('/test',{
  success:function(data){
    console.log(arguments);
  },
  error:function(jqXHR,textStatus,err){
    //jqXHR:jQuery增强的XHR
    //textStatus:请求完成状态
    //err:底层通过throw抛出的异常对象，类型与值与错误类型有关
    console.log(arguments);
  },
  complete:function(jqXHR,textStatus){
    //jqXHR:jQuery增强的XHR
    //textStatus：请求完成状态success | error
    console.log(arguments);
  },
  statusCode:function(){
    '403':function(jqXHR,textStatus,err){
      //jqXHR:jQuery增强的XHR
      //textStatus:请求完成状态
      //err:底层通过throw抛出的异常对象，类型与值与错误类型有关
      console.log(arguments);
      console.log(400);
    },
    '400':function(){
      console.log(400);
    }
  }   
});



请求的数据：data,processData,contentType,traditional




$.ajax('/test',{
  //请求的数据内容
  data:{
    a:1,
    b:2
  },
  //请求的方式
  type:'POST',
  //是否对请求的数据进行转码(用于传输数据为html节点内容)
  processData:true,
  //当前的数据是否使用传统方式进行url编码
  traditional:true,
  //请求数据编码格式
  contentType:'application/json'
});



响应数据：dataType,dataFilter




$.ajax('/test',{
  success:function(data){
    console.log(typeof data)
  },
  //定义的返回数据的类型
  dataType:'json | html | text | jsonp | script',
  //返回底层的原始数据进行预处理
  dataFilter:function(data,type){
    //data:原始数据
    //type:指定的数据类型
  }  
});



前置处理：beforeSend




$.ajax('/test',{
  beforeSend:function(jqXHR,settings){
    console.log(arguments);
    jqXHR.setRequestHeader('test','haha');
    jqXHR.testData = {a:1,b:2};
  },
  complete:function(jqXHR){
    console.log(jqXHR.testData)
  }
});



请求类型：GET(默认) | POST | PUT | DELETE

同步异步：async(默认true)

是否缓存：cache(默认true)

其他参数：

1.global[是否触发全局事件]

2.ifModifed[仅在服务器数据改变时候加载数据]

3.username,password[http需要验证时候]

4.timeout[设置请求超时时间，若请求超时触发error]

5.context[回调中this指向的对象]

其他相关的API
$.ajaxSetup(option)
设置全局默认参数


//默认为get请求
$.ajax('/test');

//修改全局请求方式为post
$.ajaxSetup({
  type:'post',
  headers:{
    test:new Date().getTime
  },
  cache:false
});

//请求方式改变为post
$.ajax('/test');
$.ajaxPrefilter([dataTypes],handler(option,originalOptions,jqXHR))




请求发起前的预处理，提供了一种AOP(面向切面)编程模式，常见用途：

1.根据option设定执行特定处理逻辑

2.修改option值改变请求默认行为

3.通过return修改默认dataType
例：通过return修改默认dataType


$.ajaxPrefilter('text html json',function(options,originalOptions,jqXHR){
  //options请求参数，含默认值
  //originalOptions请求时传入的参数，不含默认值
  //jqXHR:jQuery增强的XHR
  console.log(arguments);
  if(options.url == '/test'){
    return 'text';
  }
});

$.ajax('/test',{
  type:'post',
  dataType:'text',
  //自定义属性
  test:'haha'
});




例：多次请求仅最后一次有效，避免多次请求导致的数据混乱


var requests = {};
$.ajaxPrefilter(function(options,originalOptions,jqXHR){
  if(requests[options.url]){
    requests[options.url].abort();
  }
  requests[options.url] = jqXHR;
});

$.ajax('/test/');
$.ajax('/test/');




例：统一修改请求路径


$.ajaxPrefilter(function(options){
  if(options.url.substr(0,5) == '/usr'){
    options.url = options.url.replace('/usr/','/user/');
    options.header = {
      a:1
    }
  }
});

$.ajax('/usr/');




全局事件
jQuery-1.9以后，全局事件必须绑定在document上


$(document).ajaxSuccess(globalEventHander);
$(document).ajaxError(globalEventHander);
$(document).ajaxComplete(globalEventHander);
$(document).ajaxStart(globalEventHander);
$(document).ajaxStop(globalEventHander);
$(document).ajaxSend(globalEventHander);
function globalEventHander(event){
  console.log(arguments);
  console.log(event.type);
}
$.ajax('/test"htmlcode">

var params = { a:1, b:2 };
var str = $.param(params);
console.log(str);
//a=1&b=2"



例：serialize()


<form>
  <div><input type="text" name="a" value="1"/></div>
  <div><input type="text" name="b" value="2"/></div>
  <div><input type="hidden" name="c" value="3"/></div>
</form>
<script type="text/javascript">
  $('form').submit(function() {
   console.log($(this).serialize());
   //a=1&b=2&c=3
   return false;
  });
</script>



例：serializeArray()


<form>
  First:<input type="text" name="First" value="1" /><br />
  Last :<input type="text" name="Last" value="2" /><br />
</form>
<script type="text/javascript">
  $('form').click(function(){
    x=$("form").serializeArray();
    console.log(x);
    //{[name:First,value:1],[name:Last,value:2]}
  });
</script>




ajax链式编程方法

在开发的过程，经常会遇到一些耗时间的操作，比如ajax读取服务器数据（异步操作），遍历一个很大的数组（同步操作）。不管是异步操作，还是同步操作，总之就是不能立即得到结果，JS是单线程语音，不能立即得到结果，便会一直等待（阻塞）。
一般的做法就是用回调函数（callback），即事先定义好一个函数，JS引擎不等待这些耗时的操作，而是继续执行下面的代码，等这些耗时操作结束后，回来执行事先定义好的那个函数。如下面的ajax代码：


$.ajax({
  url: "test.html",
  success: function(){
    console.log("success");
  },
  error: function(){
    console.log("error");
  }
});



但这样写不够强大灵活，也很啰嗦。为此，jQuery1.5版本引入Deferred功能，为处理事件回调提供了更加强大而灵活的编程模式。


$.ajax("test.html")
.done(
  function(){
    console.log("success");
  }
)
.fail(
  function(){
    console.log("error");
  }
);



不就是链式调用嘛，有何优点？
优点一：可以清晰指定多个回调函数


function fnA(){...}
function fnB(){...}
$.ajax("test.html").done(fnA).done(fnB);



试想一下，如果用以前的编程模式，只能这么写：


function fnA(){...}
function fnB(){...}
$.ajax({
  url: "test.html",
  success: function(){
    fnA();
    fnB();
  }
});



优点二：为多个操作指定回调函数


$.when($.ajax("test1.html"), $.ajax("test2.html"))
.done(function(){console.log("success");})
.fail(function(){console.log("error");});



用传统的编程模式，只能重复写success,error等回调了。