Javascript 如何制作。然后在进行下一步之前完全完成？

所以，我在数据库中添加了一个机构，然后在数据库中添加了一个特殊的机构。一个机构可以有1到多个特价，因此我尝试在第3个

.then（）

下创建一个关系。问题是，然后第三个

。然后（）

在建立之前执行，并将特殊添加到数据库中。我需要首先向数据库中添加building和special，因为我需要获取它们的objectid，

var-buildmentobjectid和
var specialObjectId

在建立关系之前，我如何确保检索到机构和特殊对象

    //Save the establishment objectId
    var establishmentObjectId;
    //Save the special objectID
    var specialObjectId;

    //Save establishment
    .then(() => {
        //Get the add form data
        var addName = document.getElementById('add_name');
        var addCountry = document.getElementById('add_country');
        var addEstablishmentType = document.getElementById('add_establishment_type');
        var addCuisineType = document.getElementById('add_cusine_type');

        //Create establishment from user's enteries
        var establishment = {
            Name: addName.value,
            Address: addAddress.value,
            Suburb: addSuburb.value,
            Country: addCountry.value,
            Cuisine_Type: addCuisineType.value,
            Establishment_Type: addEstablishmentType.value
        }

        //Save establishment to db
        Backendless.Data.of('Establishment').save( establishment )
        .then( function( savedObject ) {
            establishmentObjectId = savedObject.objectId;
            console.log( "new Establishment instance has been saved" );
          })
        .catch( function( error ) {
            console.log( "an error has occurred " + error.message );
          });
    })
    //Save special
    .then(() => {
        //Get the add form data
        var addCategory = document.getElementById('add_category');
        var addTypeOfSpecial = document.getElementById('add_type_of_special');
        var addDescription = document.getElementById('add_description');

        //Create special from user's enteries
        var special = {
            Category: addCategory.value,
            Type_Of_Special: addTypeOfSpecial.value,
            Description: addDescription.value
        }

        //Save special to db
        Backendless.Data.of('Special').save( special )
        .then( function( savedObject ) {
            specialObjectId = savedObject.objectId;
            console.log( "new Special instance has been saved" );
            })
        .catch( function( error ) {
            console.log( "an error has occurred " + error.message );
            });
    })
    //Add special to establishment/form relation
    .then(() => {

        //These are undefined even though they are declared above
        console.log(establishmentObjectId);
        console.log(specialObjectId);

        var parentObject = { objectId:establishmentObjectId };
        var childObject = { objectId:specialObjectId };
        var children = [ childObject ];

        Backendless.Data.of( "Establishment" ).addRelation( parentObject, "establishmentSpecials", children )
        .then( function( count ) {
          console.log( "relation has been set" );
        })
        .catch( function( error ) {
          console.log( "server reported an error - " + error.message );
        });

    })

非常感谢
每当您处于承诺链中时，99%的情况下，当您创建新承诺（使用API调用或
新承诺
等）时，您应该将其返回，或者将其与其他内容（如
承诺。all
并返回）。这意味着可能的拒绝可以在更高的级别上处理，并且意味着链中的下一个
。然后
只会在前一个
完成后启动。然后
完成

每改变一次

Backendless.Data.of(

到

此外，您可能不希望像您当前所做的那样，在每一个级别上都进行捕获。每当您捕获捕获时，您都会将一个被拒绝的承诺变成一个已解决的承诺，然后再执行后续的
。然后
s可能会在之前的
中的所有内容都成功完成的假设下运行。对于这样的顺序异步操作，如果任何地方出现错误，您可能希望停止整个过程，而不是继续（这可能会导致错误）

例如，如果（'Establish'）.save的
backEndings.Data.of（'Establish'）.save失败，则
establishmentObjectId
永远不会被分配到，并尝试稍后在最后的
中使用它。那么
将无法工作。与
specialObjectId
类似

对于这个代码，还有一个更好的模式：不是使用两个单独的<代码>。然后< /Cult> S，一个获得<代码> SuthObjutd < /Cord>，一个获得<代码>专用Objult<代码>，考虑让这些操作并行运行，运行最终<代码>。然后< <代码> >通过<代码>承诺>所有< /代码>。大致如下：
const getEstablishmentObjectId = () => {
  //Get the add form data
  // ...
  //Create establishment from user's enteries
  var establishment = {
    // ...
  }
  //Save establishment to db
  return Backendless.Data.of('Establishment').save(establishment)
    .then(savedObject => savedObject.objectId);
};
const getSpecialObjectId = () => {
    // ...
    return Backendless.Data.of('Special').save(special)
      .then(savedObject => savedObject.objectId);
};

Promise.all([
  getEstablishmentObjectId(),
  getSpecialObjectId(),
]).then(([establishmentObjectId, specialObjectId]) => {
    console.log(establishmentObjectId);
    console.log(specialObjectId);
    var parentObject = {
      objectId: establishmentObjectId
    };
    // etc
  })
  .catch((error) => {
    console.log('Error', error);
  });

无论何时处于承诺链中，99%的情况下，当您创建一个新承诺（使用API调用或
新承诺
等）时，您都应该返回它，或者将它与其他内容（如
承诺。全部
并返回）。这意味着可能的拒绝可以在更高的级别上处理，并且意味着链中的下一个
。然后
只会在前一个
完成后启动。然后
完成

每改变一次

Backendless.Data.of(

到

此外，您可能不希望像您当前所做的那样，在每一个级别上都进行捕获。每当您捕获捕获时，您都会将一个被拒绝的承诺变成一个已解决的承诺，然后再执行后续的
。然后
s可能会在之前的
中的所有内容都成功完成的假设下运行。对于这样的顺序异步操作，如果任何地方出现错误，您可能希望停止整个过程，而不是继续（这可能会导致错误）

例如，如果（'Establish'）.save的
backEndings.Data.of（'Establish'）.save失败，则
establishmentObjectId
永远不会被分配到，并尝试稍后在最后的
中使用它。那么
将无法工作。与
specialObjectId
类似

对于这个代码，还有一个更好的模式：不是使用两个单独的<代码>。然后< /Cult> S，一个获得<代码> SuthObjutd < /Cord>，一个获得<代码>专用Objult<代码>，考虑让这些操作并行运行，运行最终<代码>。然后< <代码> >通过<代码>承诺>所有< /代码>。大致如下：
const getEstablishmentObjectId = () => {
  //Get the add form data
  // ...
  //Create establishment from user's enteries
  var establishment = {
    // ...
  }
  //Save establishment to db
  return Backendless.Data.of('Establishment').save(establishment)
    .then(savedObject => savedObject.objectId);
};
const getSpecialObjectId = () => {
    // ...
    return Backendless.Data.of('Special').save(special)
      .then(savedObject => savedObject.objectId);
};

Promise.all([
  getEstablishmentObjectId(),
  getSpecialObjectId(),
]).then(([establishmentObjectId, specialObjectId]) => {
    console.log(establishmentObjectId);
    console.log(specialObjectId);
    var parentObject = {
      objectId: establishmentObjectId
    };
    // etc
  })
  .catch((error) => {
    console.log('Error', error);
  });

返回您要等待的承诺，当它完成下一个
时，
将被执行创建承诺链，然后返回承诺。它将努力解决这个问题
return backfundle.Data.of（“建立”）
返回您要等待的承诺，当它完成下一个
时。然后将执行
创建承诺链，然后返回承诺。它将努力解决这个问题<代码>返回（“机构”）的返回数据。