Javascript 递归返回语句

这是我为解决一个问题而编写的程序。检查数组中是否存在等于最大数的元素之和，如果存在，则返回true，否则返回false

var found = "false";
var max;

function ArrayAdditionI(array) { 

max = Math.max.apply(null,array);
var p = array.indexOf(max);

array.splice(p,1);
array.sort(function(a, b){return a-b;});


found = findSum(array, 0, 0);

return found;

}

function findSum(array, sum, startIndex){

for(var i = startIndex; i < array.length ; i++){

    sum += array[i]; 

    if(sum === max){
        found = "true";
        break;
    }else if(sum > max){
        break;
    }

     if(i+2 < array.length && sum < max){
         findSum(array, sum, i+2);
    }

}
    if(startIndex < array.length && sum !== max){
        return findSum(array, 0, startIndex+1);
    }

    return found;
}

ArrayAdditionI(readline());

var found=“false”；
var-max；
函数ArrayAdditionI（数组）{
max=Math.max.apply（null，数组）；
var p=数组的indexOf（最大值）；
阵列拼接（p，1）；
sort（函数（a，b）{返回a-b；}）；
found=findSum（数组，0，0）；
发现退货；
}
函数findSum（数组、求和、startIndex）{
对于（var i=startIndex；i最大值）{
打破
}
if（i+2

我必须使用全局变量find来表示在哪里找到了和。return语句总是返回未定义的

另外，如果我在下面的if语句中使用return语句，代码将无法正常工作

if(i+2 < array.length && sum < max){
    return findSum(array, sum, i+2);
}

if（i+2

这不是问题的最佳解决方案，但这是我正在使用的版本

---

我的问题是，如果在if语句中使用return语句，为什么会出现未定义的情况。此外，我尝试不使用全局函数，如果sum==max，则使用return true，最后返回false，它总是返回false或undefined

--更新2：带有错误结果的代码--

函数数组添加（数组）{
var max=Math.max.apply（null，数组）；
//从数组中删除max元素
var p=数组的indexOf（最大值）；
阵列拼接（p，1）；
//排序数组
sort（函数（a，b）{返回a-b；}）；
//调用查找和函数
返回findSum（数组，0，0，max）；
}
函数findSum（数组、求和、startIndex）{
对于（var i=startIndex；i最大值）{
打破
}
if（i+2

程序的开始是这个调用：ArrayAdditionI（[7,2,90,31,50]）； 回报应该是真实的。 此外，数组加法（[1,2,3,4]）；这是真的。 然而，ArrayAdditionI（[1,2,3100]）；这是错误的

****之间的return语句，当删除代码时有效，否则我要么得到false，要么未定义。我不明白这部分！为什么删除return可以解决这个问题，我认为每个递归调用都必须使用return语句

---

问题是否可能是由多个电话引起的？我是否以不正确的方式使用递归？

以下函数应给出正确或错误的答案，说明数组中的任何值组合是否产生最大值

    var a = [
        1, 1, 1, 1, 1, 1,
        1, 1, 1, 9
    ]
    var b = [1,1,1,5]
    function MembersHoldMaxSum(arr) {
        var i, r = false, index, max = Math.max.apply(null, arr), index;
        for (i = 0; i <= arr.length - 1; i++) {
            for (index = 0; index <= arr.length - 1; index++) {
                var new_arr = [], ct;
                for (ct = 0; ct <= arr.length - 1; ct++) {
                    if (index != ct) { new_arr.push(arr[ct]) }
                }
                while (new_arr.length != 1) {
                    var sum = 0, ct2 = 0;
                    for (ct2 = 0; ct2 <= new_arr.length - 1; ct2++) {
                        sum += new_arr[ct2];
                    }
                    if (sum == max) { return true }
                    new_arr.pop()
                }
            }
        }
        return r
    }
    var returns_true = MembersHoldMaxSum(a);
    var returns_false = MembersHoldMaxSum(b);

var a=[
1, 1, 1, 1, 1, 1,
1, 1, 1, 9
]
变量b=[1,1,1,5]
函数成员SholdMaxSum（arr）{
var i，r=false，index，max=Math.max.apply（null，arr），index；
对于（i=0；i，代码中存在一些可能导致错误的错误

T.J.克劳德已经说过，用实际的布尔值代替字符串

find
变量未在
findSum
函数中定义。这使得JavaScript假定您正在设置一个全局变量。
添加
var found=false；
作为
findSum
函数的第一行

在最后一个
if
中，在您的
for
中有一个对
findSum
函数的调用，但它既不返回其值，也不将其分配给
found
变量

解决这些问题并用结果更新您的问题。
问题是什么？如何不使用全局值？如何更好地解决问题？旁注：不要将字符串用于布尔值。将布尔值用于布尔值。：-）例如，
found=false
（not
found=“false”
），
found=true
（not
found=“true”
），
if（found）
（而不是
if（found==“true”）
）…我的问题是，如果我在if语句中使用return语句，为什么我会得到未定义的结果。此外，我尝试过不使用global并在sum==max时使用return true，并且在return false的最后，它总是返回false或未定义的结果。您是否需要使用它对任意元素组合或任意两个元素进行求和？如果需要，我将编辑我的问题n、 任意数量的elementsFound都是一个全局变量。如果我使用返回语句，我会得到未定义的。上面的代码正在工作。我只是想知道为什么递归和返回语句不工作。我不得不添加全局变量作为解决方法。抱歉，我放弃了尝试了解代码的工作方式以及您需要的其他内容。您正在分配g
found
var有时返回值，有时返回值。它是在最顶端定义的。var found=false。有两个函数，数组加法，第一个被调用，以数组作为输入参见最后一行，第二个函数find sum检查和是否存在。当我递归调用该函数时，我在if语句中加上一个返回，我得到了未定义，返回为false。我将发布不起作用的代码。我用旧代码更新了我的问题。它没有给出正确的结果。@Maryam请不要忘记这个问题。我花了相当多的时间为您创建一个工作示例。如果您有时间，请单击请在问题上打绿色复选标记，以便接受答案。这会给您和我额外的声誉分数。提前感谢。
    var a = [
        1, 1, 1, 1, 1, 1,
        1, 1, 1, 9
    ]
    var b = [1,1,1,5]
    function MembersHoldMaxSum(arr) {
        var i, r = false, index, max = Math.max.apply(null, arr), index;
        for (i = 0; i <= arr.length - 1; i++) {
            for (index = 0; index <= arr.length - 1; index++) {
                var new_arr = [], ct;
                for (ct = 0; ct <= arr.length - 1; ct++) {
                    if (index != ct) { new_arr.push(arr[ct]) }
                }
                while (new_arr.length != 1) {
                    var sum = 0, ct2 = 0;
                    for (ct2 = 0; ct2 <= new_arr.length - 1; ct2++) {
                        sum += new_arr[ct2];
                    }
                    if (sum == max) { return true }
                    new_arr.pop()
                }
            }
        }
        return r
    }
    var returns_true = MembersHoldMaxSum(a);
    var returns_false = MembersHoldMaxSum(b);