Javascript似乎没有正确返回Parse对象

Question

I have a function called makeNewNode() that should take a Parse GeoPoint object and return a (custom) Parse object called node that contains a GeoPoint object with the key "location" and a pointer to another custom Parse object with the key "stop." What this function should do is essentially "snap" to a node if there is one within the SNAP_RADIUS of its GeoPoint. If not, return a brand new node with a null "stop" pointer and a "location" of the parameter geoPoint .

I have a couple issues with this code.

The first is that it seems to always fail to return anything. The Parse query always returns success, which is good. However, it only returns something usable when it "snaps." Otherwise it just returns an undefined results variable.

The second (and main) is that regardless of snapping or not, the function never returns anything remotely similar to the node object that I'm expecting. This leads me to believe through extensive use of console.log that node is never changed or affected by the actions within the success function of the query.

The third is related to the previous in a more general sense. Every time I've tried to return an object from a function in Javascript it hasn't acted the way I've expected. Every time I've tried to change a variable from within a query's success function nothing actually changes. I am a little new to this more in-depth Javascript as my previous experience has been a little more light.

This is the troublesome code.

function makeNewNode(geoPoint) {
  var node = {};
  var Node = Parse.Object.extend("Nodes");
  var query = new Parse.Query(Node);
  query.withinMiles("location",geoPoint,SNAP_RADIUS);
  query.first({
    success: function(results) {
      console.log(results);
      console.log(results + "");
      if (results == undefined) {
        node = new Node();
        node.set("location",geoPoint);
        node.set("stop",null);
        node.save();
        console.log(node.id);
      } else {
        node = results;
      }
    },
    error: function(error) {
      console.log("Failed to create a node. Error: " + error.message + ".");
    }
  });
  return node;
}

And here is where I call it.

var geoPoint = new Parse.GeoPoint(location.lat(),location.lng());
var newnode = makeNewNode(geoPoint);

Any ideas or suggestions about my code or either of the three questions is greatly appreciated.

Answer 1

A cleaner way is to use promises, so that the save of the newly created object can be handled without the extra callback parameter and without creating deeper and deeper nesting of success functions. Moreover, the caller may want to make a node as part of some larger set of asynch steps.

A promise version looks like this:

// return a promise that, when fulfilled, creates a new node with
// at the geoPoint, or, if a node exists within SNAP_RADIUS, returns that node
function makeNewNode(geoPoint) {
    var Node = Parse.Object.extend("Nodes");
    var query = new Parse.Query(Node);
    query.withinMiles("location",geoPoint,SNAP_RADIUS);
    return query.first().then(function(node) {
        if (!node) {
            node = new Node();
            node.set("location", geoPoint);
            node.set("stop", null);
        }
        return (node.isNew())? node.save() : Parse.Promise.as(node);
    });
}

The caller can now chain this with other promises.

EDIT - Here's how you call it. Lets say we get the geoPoint in another asynchronous call, then...

var geoPoint = new Parse.GeoPoint(location.lat(),location.lng());
makeNewNode(geoPoint).then(function(newNode) {
    console.log("new node id is " + newNode.id);
}, function(error) {
    console.log("error " + error.message);
});

What's up with all the returns? A promise is a placeholder for the result. Returning it gives the caller and object to which they can attach a completion function (using the then() method). That completion callback can also return a promise (that's the inner return), so that they can be chained arbitrarily. The second parameter to then() is an optional callback to handle failure.

Answer 2

I don't know if you are aware of the async issues, but they might be the problem.

function makeNewNode(geoPoint) {
  var Node = Parse.Object.extend("Nodes");
  var node = new Node();
  var query = new Parse.Query(Node);
  query.withinMiles("location",geoPoint,SNAP_RADIUS);
  query.first({
    success: function(results) {
      console.log(results);
      console.log(results + "");
      if (results == undefined) {
        node.set("location",geoPoint);
        node.set("stop",null);
        node.save(function() {
          console.log(node.id);
        });
      } else {
        node.set("location", results.get("location"));
        node.set("stop", results.get("stop"));
      }
    },
    error: function(error) {
      console.log("Failed to create a node. Error: " + error.message + ".");
    }
  });
  return node;
}

query.first() is an async function. When your function returns, the async function may have not called your callback. In this situation, the return value would be the object {} as you defined at the beginning.

Later when you assign a new value( new Node() and so) to node , the returned value would still be the previous object, instead of the new object assigned to node .

The simple fix would be to use a pre-assigned object for returning, and update its content later, just like my example above.

However, this is never a good solution for an async code snippet. You should use either a callback or a promise to return the new Node .

Using a callback would be like:

function makeNewNode(geoPoint, callback) {
  var Node = Parse.Object.extend("Nodes");
  var node;
  var query = new Parse.Query(Node);
  query.withinMiles("location",geoPoint,SNAP_RADIUS);
  query.first({
    success: function(results) {
      console.log(results);
      console.log(results + "");
      if (results == undefined) {
        node.set("location", geoPoint);
        node.set("stop", null);
        node.save(function() {
          console.log(node.id);
          callback(null, node);
        });
      } else {
        callback(null, results);
      }
    },
    error: function(error) {
      console.log("Failed to create a node. Error: " + error.message + ".");
      callback(error);
    }
  });
}

And you would be able to use it like:

makeNewNode(geoPoint, function(err, newNode) {
  // use your new Node here.
})