Javascript 在函数中设置全局变量

我要做的是在函数外初始化一个全局变量，在函数内设置变量，然后在函数后打印变量值。但是，当我打印时，它会注销

未提供任何消息

在本例中，我尝试使用itemLocation变量执行此操作

var itemLocation;
Parse.Cloud.define("eBayCategorySearch", function (request, response) {
    url = 'http://svcs.ebay.com/services/search/FindingService/v1';
    Parse.Cloud.httpRequest({
        url: url,
        params: {
            'OPERATION-NAME': 'findItemsByKeywords',
                'SERVICE-VERSION': '1.12.0',
                'SECURITY-APPNAME': '*APP ID GOES HERE*',
                'GLOBAL-ID': 'EBAY-US',
                'RESPONSE-DATA-FORMAT': 'JSON',
                'itemFilter(0).name=ListingType': 'itemFilter(0).value=FixedPrice',
                'keywords': request.params.item,
        },
        success: function (httpResponse) {
            // parses results
            var httpresponse = JSON.parse(httpResponse.text);
            var items = [];
            httpresponse.findItemsByKeywordsResponse.forEach(function (itemByKeywordsResponse) {
                itemByKeywordsResponse.searchResult.forEach(function (result) {
                    result.item.forEach(function (item) {
                        items.push(item);
                    });
                });
            });


            // count number of times each unique primaryCategory shows up (based on categoryId), returns top two IDs and their respective names
            var categoryIdResults = {};

            // Collect two most frequent categoryIds
            items.forEach(function (item) {
                var id = item.primaryCategory[0].categoryId;
                if (categoryIdResults[id]) categoryIdResults[id]++;
                else categoryIdResults[id] = 1;
            });

            var top2 = Object.keys(categoryIdResults).sort(function (a, b) {
                return categoryIdResults[b] - categoryIdResults[a];
            }).slice(0, 2);
            console.log('Top category Ids: ' + top2.join(', '));

            var categoryNameResults = {};

            // Collect two most frequent categoryNames  
            items.forEach(function (item) {
                var categoryName = item.primaryCategory[0].categoryName;
                if (categoryNameResults[categoryName]) categoryNameResults[categoryName]++;
                else categoryNameResults[categoryName] = 1;
            });

            var top2Names = Object.keys(categoryNameResults).sort(function (a, b) {
                return categoryNameResults[b] - categoryNameResults[a];
            }).slice(0, 2);
            console.log('Top category Names: ' + top2Names.join(', '));

            // compare categoryIdResults to userCategory object
            //Extend the Parse.Object class to make the userCategory class
            var userCategory = Parse.Object.extend("userCategory");

            //Use Parse.Query to generate a new query, specifically querying the userCategory object.
            query = new Parse.Query(userCategory);

            //Set constraints on the query.
            query.containedIn('categoryId', top2);
            query.equalTo('parent', Parse.User.current())

            //Submit the query and pass in callback functions.
            var isMatching = false;
            query.find({
                success: function (results) {
                    var userCategoriesMatchingTop2 = results;
                    console.log("userCategory comparison success!");
                    console.log(results);

                    for (var i = 0; i < results.length; i++) {
                        itemCondition = results[i].get("itemCondition");
                        console.log(itemCondition);

                        itemLocation = results[i].get("itemLocation");
                        console.log(itemLocation);

                        minPrice = results[i].get("minPrice");
                        console.log(minPrice);

                        maxPrice = results[i].get("maxPrice");
                        console.log(maxPrice);

                        itemSearch = request.params.item;
                        console.log(itemSearch);
                    }

                    if (userCategoriesMatchingTop2 && userCategoriesMatchingTop2.length > 0) {
                        isMatching = true;
                    }

                    response.success({
                        "results": [{
                            "Number of top categories": top2.length
                        }, {
                            "Top category Ids": top2
                        }, {
                            "Top category names": top2Names
                        }, {
                            "Number of matches": userCategoriesMatchingTop2.length
                        }, {
                            "User categories that match search": userCategoriesMatchingTop2
                        }, {
                            "Matching Category Condition": itemCondition
                        }, {
                            "Matching Category Location": itemLocation
                        }, {
                            "Matching Category MaxPrice": maxPrice
                        }, {
                            "Matching Category MinPrice": minPrice
                        }, {
                            "Search Term": itemSearch
                        },

                        ]
                    });
                    console.log('User categories that match search: ', results);
                },
                error: function (error) {
                    //Error Callback
                    console.log("An error has occurred");
                    console.log(error);
                }
            });
        },
        error: function (httpResponse) {
            console.log('error!!!');
            response.error('Request failed with response code ' + httpResponse.status);
        }
    });
});
console.log(itemLocation);

var项目位置；
define（“eBayCategorySearch”，函数（请求、响应）{
url='1〕http://svcs.ebay.com/services/search/FindingService/v1';
Parse.Cloud.httpRequest({
url:url，
参数：{
“OPERATION-NAME”：“findItemsByKeywords”，
“服务版本”：“1.12.0”，
“SECURITY-APPNAME”：“*应用程序ID位于此处*”，
“GLOBAL-ID”：“EBAY-US”，
“RESPONSE-DATA-FORMAT”：“JSON”，
'itemFilter（0.name=ListingType'：'itemFilter（0.value=FixedPrice'，
“关键字”：request.params.item，
},
成功：函数（httpResponse）{
//解析结果
var httpresponse=JSON.parse（httpresponse.text）；
var项目=[]；
httpresponse.findItemsByKeywordsResponse.forEach（函数（itemByKeywordsResponse）{
itemByKeywordsResponse.searchResult.forEach（函数（结果）{
result.item.forEach（函数（项）{
项目。推送（项目）；
});
});
});
//计算每个唯一primaryCategory出现的次数（基于categoryId），返回前两个ID及其各自的名称
变量categoryIdResults={}；
//收集两个最常见的类别
items.forEach（功能（项目）{
变量id=item.primaryCategory[0]。类别id；
if（categoryIdResults[id]）categoryIdResults[id]++；
else categoryIdResults[id]=1；
});
var top2=Object.keys（categoryIdResults）.sort（函数（a，b）{
返回categoryIdResults[b]-categoryIdResults[a]；
}).切片（0,2）；
log（'Top-category-id:'+top2.join（'，'）；
var categoryNameResults={}；
//收集两个最常见的类别名称
items.forEach（功能（项目）{
var categoryName=item.primaryCategory[0]。categoryName；
if（categoryNameResults[categoryName]）categoryNameResults[categoryName]++；
else categoryName结果[categoryName]=1；
});
var top2Names=Object.keys（categoryNameResults）.sort（函数（a，b）{
返回categoryNameResults[b]-categoryNameResults[a]；
}).切片（0,2）；
log（'顶级类别名称：'+top2Names.join（'，'）；
//将categoryIdResults与userCategory对象进行比较
//扩展Parse.Object类以生成userCategory类
var userCategory=Parse.Object.extend（“userCategory”）；
//使用Parse.Query生成新的查询，特别是查询userCategory对象。
query=新建Parse.query（userCategory）；
//对查询设置约束。
query.containedIn（'categoryId'，top2）；
query.equalTo（'parent'，Parse.User.current（））
//提交查询并传入回调函数。
var isMatching=假；
查询.查找({
成功：功能（结果）{
var userCategoriesMatchingTop2=结果；
log（“userCategory比较成功！”）；
控制台日志（结果）；
对于（var i=0；i0）{
isMatching=true；
}
成功({
“结果”：[{
“顶级类别数量”：top2.1长度
}, {
“顶级分类ID”：top2
}, {
“顶级类别名称”：Top2名称
}, {
“匹配数”：userCategoriesMatchingTop2.length
}, {
“匹配搜索的用户类别”：userCategoriesMatchingTop2
}, {
“匹配类别条件”：itemCondition
}, {
“匹配类别位置”：itemLocation
}, {
“匹配类别MaxPrice”：MaxPrice
}, {
“匹配类别MinPrice”：MinPrice
}, {
“搜索词”：itemSearch
},
]
});
log（'与搜索匹配的用户类别：'，结果）；
},
错误：函数（错误）{
//错误回调
log（“发生错误”）；
console.log（错误）；
}
});
},
错误：函数（httpResponse）{
console.log
var itemLocation;
var promise; // variable holding the promise
Parse.Cloud.define("eBayCategorySearch", function (request, response) {
    url = 'http://svcs.ebay.com/services/search/FindingService/v1';
    // set the promise
    promise = Parse.Cloud.httpRequest({
        // your code goes here (setting the variables)
    });
});

// once the promise has been resolved
promise.then(function(resp){
    console.log(itemLocation);
});