Javascript JS-从字符串中获取最长的非重复字符子字符串

我正试图解决一个网站上的任务。我解决这个问题的方法是迭代一个字符串，然后先填充一个数组，直到我找到一个重复字符，然后开始填充另一个数组，直到我在那里也找到一个重复字符。一旦我有了两个填充的数组，我会比较它们并保留较长的一个，直到我完成迭代。但是通过这些方法，我最终检查了很多事情，不确定当我填充了

secondArray

时该怎么做，我仍然在进行子迭代，以避免填充

firstArray

。 一般来说，这段代码太麻烦了，我不知道该如何解决这个问题

s = "anviaj"
s = "eeydgwdykpv"

var lengthOfLongestSubstring = function(s) {
    let firstArray = [];
    let secondArray = [];
    let firstArrayFull = false;
    let secondArrayFull = false;
    let subIterationFinished = false;
    if (s.length == 1)
            return s;
    for (var i = 0; i < s.length -1; i++) {
        if (!firstArrayFull) {
            firstArray.push(s.charAt(i));
        } else if (!secondArrayFull) { secondArray.push(s.charAt(i)); } 
        for (let j = i + 1; j < s.length; j++) {
            if (j + 1 == s.length) { 
                subIterationFinished = true;
                checkArrays();
            }  
            if (!firstArrayFull && !firstArray.includes(s.charAt(j))) {
                if (secondArrayFull && !subIterationFinished) {
                   firstArray = firstArray;
                } else {
                   firstArray.push(s.charAt(j));
                }

            } else { 
                firstArrayFull = true;
                if (secondArrayFull) {
                    checkArrays();
                }
            } 
            if (firstArrayFull && secondArray.length != 0 && secondArray.includes(s.charAt(j))) { 
                secondArrayFull = true;
                checkArrays();
             }
            if (firstArrayFull && secondArray.length != 0 && !secondArray.includes(s.charAt(j))) {
                secondArray.push(s.charAt(j));
            }
        }
    }

    function checkArrays() {
        if (secondArray.length > firstArray.length) {
            firstArray = [];
            firstArrayFull = false;
            secondArrayFull = true;
        } else {
            secondArray = [];
            secondArrayFull = false;
            firstArrayFull = true;
        }
    }

    return secondArray.length > firstArray.length ? secondArray : firstArray;
};

console.log(lengthOfLongestSubstring(s));

s=“anviaj”
s=“eeydgwdykpv”
var lengthOfLongestSubstring=函数{
设firstArray=[]；
设secondArray=[]；
设firstArrayFull=false；
设secondArrayFull=false；
设subIterationFinished=false；
如果（s.length==1）
返回s；
对于（变量i=0；ifirstArray.length）{
firstArray=[]；
firstArrayFull=false；
secondArrayFull=true；
}否则{
secondArray=[]；
secondArrayFull=false；
firstArrayFull=真；
}
}
返回secondArray.length>firstArray.length？secondArray:firstArray；
};
console.log（lengthOfLongestSubstring）；

这很有挑战性，但我明白了

这是一个O（n）解。再好不过了

函数lengthOfLongestSubstring（str）{
var currentLength=0；
var结果=0；
var键={}；
for（str中的var i）{
如果（键[str[i]]==true）{
currentLength=0；
键={}；
}
键[str[i]]=true；
currentLength++；
如果（currentLength>结果）{
结果=当前长度；
}
}
返回结果
}
log（lengthOfLongestSubstring（“bbbbb”）；
log（lengthOfLongestSubstring（“abcdaajkljl”）；
log（lengthOfLongestSubstring（“pwkwkew”）；
console.log（lengthOfLongestSubstring（“ysbghjrfumqjpyktddsnxftvdqgxzlvrneaynufhgyqxwaqzelmbsiyxaubrqvguvehpmrykhvikqzwtg”）可用于检查子字符串是否重复


s=“anviaj”
s1=“eeydgwdykpv”
函数findLongest（str）{
//reduce（）迭代从拆分输入创建的数组，并返回最长的子字符串
返回str.split（“”）.reduce（（a，c，i）=>{
//使用str的第一个字符开始我们的子字符串
设sub=str[0]，j=0；
//如果子字符串中已有字符，则sub.includes（char）返回true
而（++ja.length？sub:a；
},'');
}
控制台日志（findLongest）
log（findLongest（s1））
使用两个变量，一个用于跟踪最长的子字符串，另一个用于跟踪当前最长的子字符串而不重复。
遍历字符串。
检查当前单词是否包含当前字符

如果包含，则检查具有最长子字符串的当前单词的长度。如果大于，则更新最长的子字符串

从上次看到的索引更新当前单词，直到当前单词的长度

继续，直到输入字符串结束


var lengthOfLongestSubstring=函数{
var longestSubstring=''；
var currentWord=''；
对于（变量i=0；i-1）{
if（longestSubstring.lengthconsole.log（lengthOfLongestSubstring（“ysbghjrfumqjpyktddsnxftvdqgxzlvrneaynufhgyqxwaqzelmbsiyxaubrqvguvehpmrykhvikqzwtg”）这是一个有效的，O（n）解决方案，它只构造最后一个字符串一次，并针对一个20.000长度的字符串进行测试（它应该仍然很快，有一百万个字符，但stackoverflow将输入限制为30K个字符）


/**
*@param{string}s
*@return{number}
*/
var lengthOfLongestSubstring=函数{
var l=0；
var r=0；