Javascript 不等待解决的承诺

我刚听说了承诺，听起来。。。承诺（好的，我要走了）

我希望显示以下代码：
-在初始化变量之前 -在

initVariables

-

someName

-在

initVariables

-

someName

-在

initElements

但我得到的却是：
-在初始化变量之前 -在初始化变量之前 -在

initVariables

之前-在

initElements

有人来帮我吗？：-）
谢谢大家D

var url = "https://opendata.paris.fr/api/records/1.0/search/?dataset=stations-velib-disponibilites-en-temps-reel&rows=100&facet=banking&facet=bonus&facet=status&facet=contract_name"

var test = Object.create(MyTestClass);
console.log(test.testVariable);

let loadVariables = new Promise(function(resolve, reject) {
  test.initVariables(url);
  resolve(test);
  console.log(test.testVariable);
});

loadVariables.then(function(test){
  test.initElements();
});
console.log(test.testVariable);

而

MyTestClass

的定义如下：

var MyTestClass = {

    testVariable: "before initVariables",

    initVariables: function(url) {
        $.getJSON(url, function (result) {
            this.testVariable += " - " + result.records[0].fields.name;
        });
    },

    initElements: function() {
        this.testVariable += " - after initElements";
    }
}

---

承诺立竿见影。它们不会立即解析/拒绝的唯一方法是，如果您在它们内部执行某些操作（如调用

$.getJSON

），并且仅基于

$.getJSON

的回调调用

解析/拒绝

function getJSONP(url) {
  return new Promise(function(resolve, reject) {
     $.getJSON(url, resolve);
  }
}

或

这就更清楚了

然后你就可以做了

 getJSONP(someURL).then(function(result) {
   console.log(result);
 });

---

承诺立竿见影。它们不会立即解析/拒绝的唯一方法是，如果您在它们内部执行某些操作（如调用

$.getJSON

），并且仅基于

$.getJSON

的回调调用

解析/拒绝

function getJSONP(url) {
  return new Promise(function(resolve, reject) {
     $.getJSON(url, resolve);
  }
}

或

这就更清楚了

然后你就可以做了

 getJSONP(someURL).then(function(result) {
   console.log(result);
 });

---

Promise

构造函数不是必需的，因为

$.getJSON（）

返回一个jQuery Promise对象，该对象公开

。然后

函数

$.getJSON（）

不是从问题的

javascript

函数返回的

此

是

jqxhr

jQuery承诺对象，除非在

$.ajax（）

调用的

context

中设置。您可以使用

Function.prototype.bind（）

或

$.proxy（）

在

处设置
此
。然后（）

链接到

test.initVariables

，其中

$.getJSON（url）

调用从函数返回

var MyTestClass={
testVariable:“在初始化变量之前”，
initVariables:函数（url）{
返回$.getJSON（url）
},
HandlerResult:函数（结果）{
this.testVariable+=“-”+result.records[0].fields.name；
log（this.testVariable）；
},
initElements:function（）{
this.testVariable+=“-after initElements”；
console.log（this.testVariable）
}
}
变量url=”https://opendata.paris.fr/api/records/1.0/search/?dataset=stations-velib disponibilites en temps reel&rows=100&FACT=banking&FACT=BOUNS&FACT=status&FACT=CONTACT_name”；
var test=Object.create（MyTestClass）；
log（test.testVariable）；
var loadVariables=test.initVariables（url）；
加载变量
.然后（$.proxy（test.handleResult，test））
.then（$.proxy（test.initElements，test））
.fail（函数（jqxhr、textStatus、errorshown）{
日志（textStatus，errorshown）；
});
Promise
构造函数不是必需的，因为
$.getJSON（）
返回一个jQuery Promise对象，该对象公开
。然后
函数

$.getJSON（）
不是从问题的
javascript
函数返回的
此
是
jqxhr
jQuery承诺对象，除非在
$.ajax（）
调用的
context
中设置。您可以使用
Function.prototype.bind（）
或
$.proxy（）
在
处设置
此
。然后（）
链接到
test.initVariables
，其中
$.getJSON（url）
调用从函数返回


var MyTestClass={
testVariable:“在初始化变量之前”，
initVariables:函数（url）{
返回$.getJSON（url）
},
HandlerResult:函数（结果）{
this.testVariable+=“-”+result.records[0].fields.name；
log（this.testVariable）；
},
initElements:function（）{
this.testVariable+=“-after initElements”；
console.log（this.testVariable）
}
}
变量url=”https://opendata.paris.fr/api/records/1.0/search/?dataset=stations-velib disponibilites en temps reel&rows=100&FACT=banking&FACT=BOUNS&FACT=status&FACT=CONTACT_name”；
var test=Object.create（MyTestClass）；
log（test.testVariable）；
var loadVariables=test.initVariables（url）；
加载变量
.然后（$.proxy（test.handleResult，test））
.then（$.proxy（test.initElements，test））
.fail（函数（jqxhr、textStatus、errorshown）{
日志（textStatus，errorshown）；
});
为了解释观察到的结果，预期结果缺少异步操作的效果。以下是一些可能有帮助的规则：

创建新承诺时，将同步调用承诺执行器函数。当在
新承诺（executor）
语句或表达式之后继续执行时，executor函数返回

通过调用允诺上的
然后
或
捕获
方法提供的允诺反应处理程序，在它们被调用的允诺得到解决后，在它们自己的线程中异步执行

假设
$.getJSON
请求在HTTP GET操作发生后以异步方式进行回调

浏览代码：

//**  The top of code executing in a thread, say "T1":

var url = "https://www.example.com"

var test = Object.create(MyTestClass);
//** here test.testVariable inherits "before initVariables"

console.log(test.testVariable);

let loadVariables = new Promise(function(resolve, reject) {
  test.initVariables(url);
//** here an asynchronous $getJSON request has been initiated but not completed

  resolve(test);
//**  here the Promise has been synchronously fulfilled,
//**  during execution of this executor function,  with the test object.

  console.log(test.testVariable);

//** here test.testVariable inherits "before initVariables"
//**  because we are still running synchronously in thread "T1" from the top.

});

loadVariables.then(function(test){
  test.initElements();
//** this is some time later, not in thread "T1", because
//** then and catch callbacks are made asynchronously.

});
console.log(test.testVariable);

  // here thread "T1" is still executing,
  // testVariable has not been updated yet.

请注意，使用
test
对象同步实现所创建的承诺最终是没有用的。等待GET请求使用结果数据回调需要重新考虑要采取的方法。
为了解释观察到的结果，预期结果缺少异步操作的效果。以下是一些可能有帮助的规则：

创建新承诺时，将同步调用承诺执行器函数。当在
新承诺（executor）
语句或表达式之后继续执行时，executor函数返回

通过调用允诺上的
then
或
catch
方法提供的允诺反应处理程序，在对允诺进行调用后，在它们自己的线程中异步执行