js调用api，是异步的，怎样才能保证数据已经取到

Question

本帖最后由 zioc2014 于 2013-12-03 11:00:34 编辑

Answer 1

setInterval定时去检测location是否有值  一般貌似是写在回调函数里的 把要执行的代码  貌似

Answer 2

没办法。
只能在
getLocation，getLastServiceTime 两个函数的回调函数上做手脚。函数的回调函数上分别设个flag,当两个flag都为真时，再处理别的函数。

Answer 3

setInterval定时去检测getNewPageState.
当然，你前面要放好条件。

Answer 4

这是异步编程最基本的方法啊，亲，回调函数啊，callback啊。callback就是用来解决不能马上完成的任务的啊。想象一下这样的场景：
A：亲，告诉我location是多少，快啊，我要用
B：木有办法，这个得问服务器，问服务器的话，时间就不确定了，你想想啊，我得去服务器那里跑一趟不是，这路上堵不堵车我也不确定不是？服务器那里可能正忙着呢不是？blabla...
A：说重点！到底能不能给我！
B：这个真没办法return给你，这样把，你给我个callback函数，我从服务器大哥那里拿到数据后就调用你的callback函数，顺便把数据给你传过去。
A：这还差不多。幸好js可以把函数当参数传递，look，回调函数给你，接着！
再想象一下这样的场景：
A：B君，给我XXX的值，快哦
B：wait，我看下，恩，这个我得先问C君要YYY的值，然后*&#￥%……这样一番计算，才能得到XXX的值。呼叫C君，C君，给我YYY的值，快哦
C：骚等一下，B君，这个值要问服务器大哥，你给我callback函数吧，我到时候call你。
B：花擦！真麻烦。*&#￥%……这样一番计算要放在callback中进行了。A妹子咋办啊，不能撂着不管啊。这样吧，让A给我个回调函数，我在我的callback中计算完了，再调用A给我的回调函数，然后把XXX的值给她。
A：B君葛革，好了没有啊，伦家要用XXX的值。
B：A妹妹啊，你给我个callback函数吧，C君说这个可能要等一段时间呢，我到时候计算好了再call你，好么？
A：你妹啊，我姐们还等着我给她返回ZZZ呢，要不是没有XXX我老娘算不出ZZZ，我才懒得理你呢。麻烦死了，什么callback函数什么到时候call我啊，我头都大了！
...这也是回调函数的弊端。
详情请了解 JavaScript异步编程的Promise模式番外：
A：自从换了Promise模式，我只要相信B君葛革的诺言，一切就ok啦~

Answer 5

callback里改变flag
是不是还是要用setInterval去判断flag？ 如果是true才返回？觉得这个方法不是很好，看起来没有更好的办法了

Answer 6

知道callback，第一次听说Promise模式，看了下，感觉用来解决我现在的问题太复杂了你说得就是
6L的意思吧？

Answer 7

callback模式是这样的：//创建新PageState
function getNewPageState(buyerNick,callback) {
   getLocation(buyerNick,function(location){
      getLastServiceTime(buyerNick,function(lastServiceTime ){
          var buyerInfo = new BuyerInfo(buyerNick, location, lastServiceTime);
 
          var type = "remai";
          var pageNo = 1;
          var pageSize = 3;
          var promTab = new PromTab(type, pageNo, pageSize);
 
          var _pageState = new PageState(buyerInfo,promTab);
          
          callback(_pageState ); //不是return 而是调用callback然后传参，
          //同理getLocation\getLastServiceTime也应该设计成这样，而不是return
          //getLocation = function(buyerNick,callback){ ....callback(location);}
      });
   });
}
/*调用：
getNewPageState(buyerNick,function(pageState){
  //pageState
});*/
primise模式是这样：//假设用的是jQuery的实现
//创建新PageState
function getNewPageState(buyerNick) {
   var defer = $.Deferred();
   
   $.when(getLocation(buyerNick),getLastServiceTime(buyerNick))
     .done(function(locationlastServiceTime ){
       var buyerInfo = new BuyerInfo(buyerNick, location, lastServiceTime);
          var type = "remai";
          var pageNo = 1;
          var pageSize = 3;
          var promTab = new PromTab(type, pageNo, pageSize);
 
          var _pageState = new PageState(buyerInfo,promTab);
          defer.resolve(_pageState );
   });
   
   return defer.promise();
}
/*调用：
getNewPageState(buyerNick).done(function(pageState){
  //pageState
});*/

Answer 8

Promise 模式实际上就是我说的意思
在 Promise 模式中，必须当注册的若干个异步通讯都完成时，回调才会执行
因此实际上仍然是“同步方式”

Answer 9

异步的都会提供回调函数提供下一步操作先执行getLocation，并设置回调，在回调中执行getLastServiceTime（注意传递getLocation获取到内容），再在getLastServiceTime的回调函数里面执行红色的代码，异步的函数return没什么意义，可以删除了    var buyerInfo = new BuyerInfo(buyerNick, location, lastServiceTime);
 
    var type = "remai";
    var pageNo = 1;
    var pageSize = 3;
    var promTab = new PromTab(type, pageNo, pageSize);
 
    _pageState = new PageState(buyerInfo,promTab)
 

Answer 10

知道callback，第一次听说Promise模式，看了下，感觉用来解决我现在的问题太复杂了你说得就是
6L的意思吧？
不明白他们在讨论什么，要是用callback，还有什么可讨论的么？什么flag，什么setInterval，完全不知道在说什么。用回调函数的一般做法是额外增加一个参数，这个参数类型是函数类型，一般调用的时候都使用匿名函数传参。例如getLocation：
function getLocation(nick,callback){
  //用nick获取location
  $.ajax({
    url;...
    data:...
    success: function(response){
      var location = response.location;
      callback(location);
    }
  });
}调用：function getNewPageState(nick,callback) {
  getLocation(nick,function(location){
    //好吧，这里你可以拿到location了，尽情的用吧，
    //不过，还想还有lastServerTime没拿到
    //于是：
    getLastServerTime(nick,function(time){
       //好了，location和lastServerTime都有了，尽情的用吧，
       //
     
       //pageState弄好了怎么返回？return? no no no
       //这里已经return不回去了，好吧，不是说好的callback吗？
       callback(pageState);
    });
  });
}

Answer 11

知道callback，第一次听说Promise模式，看了下，感觉用来解决我现在的问题太复杂了你说得就是
6L的意思吧？

是一种异步模型
就是用同步思维写异步代码,task.do().then(function(){docallback()}).then(function(){docallback()})

Answer 12

1var gflag = {
a : 0,  //getLocationFlag
b :0,  //getLastServiceTime
}
var time = null;
function getLocation(){

}
function getLastServiceTime(){

}
function getNewPageState(){
if(gflag.a==1&&gflag.b==1){
clearInterval(time);
doYouFunction();
}
if(gflag.a==0&&gflag.b==0){
getLastServiceTime();
getLocation();
}
if(gflag.a==1&&gflag.b==0){
getLastServiceTime();
}
if(gflag.a==0&&gflag.b==1){
getLocation();
}
time = setInterval(getNewPageState,500);
}
2
function getNewPageState(){
require([getLocation,getLastServiceTime],doYouFunction);
}

Answer 13

谢谢大家！！！（只能回3次，最后一次了） 大概明白了（callback我会写，promise今天第一次知道），其实我的错误是不应该用return（又想callback又想return）顺便问一下13L的 代码2是什么意思？

Answer 14

难道这个不是flag吗？
if ( !remaining ) {
deferred.resolveWith( resolveContexts, resolveValues );
}

Answer 15

您能解释下您的代码么   主要是第二段看不懂  require.js？

Answer 16

var gflag = {
        a : 0,  //getLocationFlag
        b :0,  //getLastServiceTime
}function getLocation(next){
    if(gflag.a==1){
     next();
     return;
    }else{
     function wrapCallback(next){
     return next.done
     }
     ajax;  
    }
}
function getLastServiceTime(next){
if(gflag.b==1){
next();
     return;
    }else{
     function wrapCallback(next){
     return next.done
     }
     ajax;  
    }
}
function requrie(){
var depend = arguments[0]; // depend = [getLocation,getLastServiceTime]
var remaining = len = depend.length;

var queue = {
data : [getLocation,getLastServiceTime,YouFunction],
next : function(){
queue.data[++queue.i];
},
i : 0,
done : function(){
queue[i](queue.next);
}
}


function YouFunction(){
youcode
}
var updateFunc = function(){

}

if(len>1){
queue.done();
}

if ( !remaining ) {
queue.next().done();
}

}