检查javascript中数组的连续顺序

var userInput = prompt('enter number here');
var number = new Array(userInput.toString().split(''));
if (number ????){ //checks if the number is in a continuous stream
alert(correct);
}
else{
alert(invalid);
}

在Javascript中，我能在"????"做什么来检查它是否在连续的顺序/流?此外，我怎么能做到这一点，使它只检查这个顺序/流后在数组中的特定索引?这意味着用户输入"12345678901234"会弹出正确的窗口，但"12347678901234"会弹出无效的窗口?(注意有两个7)对于第二部分"3312345678901234"将弹出正确，这是如何实现的?

您可以编写一个函数，检查任何字符串是否从给定索引开始的连续/递增的字母数字字符流，如下所示:

function checkContinuous(str, startIndex) {
    startindex = startIndex || 0;
    if (str.length <= startIndex) {
        return false;
    }
    var last = str.charCodeAt(startIndex);
    for (var i = startIndex + 1; i < str.length; i++) {
        ++last;
        if (str.charCodeAt(i) !== last) {
            return false;
        }
    }
    return true;
}

如果它只是数字，并且从9换行到0被认为是连续的，那么它就像这样稍微复杂一点:

function checkContinuous(str, startIndex) {
    // make sure startIndex is set to zero if not passed in
    startIndex = startIndex || 0;
    // skip chars before startIndex
    str = str.substr(startIndex);
    // string must be at least 2 chars long and must be all numbers
    if (str.length < 2 || !/^d+$/.test(str)) {
        return false;
    }
    // get first char code in string
    var last = str.charCodeAt(0);
    // for the rest of the string, compare to last code
    for (var i = 1; i < str.length; i++) {
        // increment last charCode so we can compare to sequence
        if (last === 57) {
            // if 9, wrap back to 0
            last = 48;
        } else {
           // else just increment
            ++last;
        }
        // if we find one char out of sequence, then it's not continuous so return false
        if (str.charCodeAt(i) !== last) {
            return false;
        }
    }
    // everything was continuous
    return true;
}

工作演示:http://jsfiddle.net/jfriend00/rHH4B/

不需要数组，只需一次返回一个字符。

当你遇到0时，替换为10，并继续直到数字不能比前一个多。

function continuousFromChar(str, start){
    start= start || 0;
    var i= 0, L= str.length, prev;
    while(L){
        c= +(str.charAt(-- L)) || 10; // use 10 for 0
        prev=+(str.charAt(L- 1));       
        if(c-prev  !== 1) break;
    }
    return  start>=L;
}
var s= "3312345678901234";
continuousFromChar(s,2)
/*  returned value: (Boolean)
true
*/

这将在实时条目中进行检查，但是可以使用类似的原理来检查按钮提交或类似的条目。我不能百分之百确定你想要哪种方式，所以我选择了现场直播的方式。

HTML

<input id="stream" type="text" />

Javascript

window.addEventListener("load", function () {
    document.getElementById("stream").addEventListener("keyup", function (evt) {
        var target = evt.target;
        var value = target.value;
        var prev;
        var last;
        var expect;
        target.value = value.replace(/[^d]/, "");
        if (value.length > 1) {
            prev = parseInt(value.slice(-2, -1), 10);
            last = parseInt(value.slice(-1), 10);
            expect = prev + 1;
            if (expect > 9) {
                expect = 0;
            }
            if (last !== expect) {
                target.value = value.slice(0, value.length - 1);
            }
        }
    }, false);
});

在jsfiddle

通过改变这里的值

if (value.length > 1) {

您可以更改检查的开始位置。

更新:好的，所以这是你想要的函数，你坚持它将字符串分割成一个数组。然后使用上面的引用，您可以将其转换为如下内容:

Javascript

window.addEventListener("load", function () {
    var testStrings = [
        "0123456789012",
        "0123456789",
        "0123455555",
        "555012345678901234",
        "0123455555"];
    function test(string, offset) {
        if (typeof string !== "string" || /[^d]/.test(string)) {
            return false;
        }
        var array = string.split("");
        var prev;
        var last;
        var expect;
        return !array.some(function (digit, index) {
            if (index >= offset) {
                prev = parseInt(array[index - 1], 10);
                last = parseInt(digit, 10);
                expect = prev + 1;
                if (expect > 9) {
                    expect = 0;
                }
                if (last !== expect) {
                    return true;
                }
            }
            return false;
        });
    }
    testStrings.forEach(function (string) {
        console.log(string, test(string, 1));
    });
});

在jsfiddle

由于你的问题没有完全指定所有的可能性，上面的代码对于空字符串(")将返回true，当然你可以简单地在开头添加一个检查。

我也不执行任何检查为您的偏移量的有效数字，但同样这是一些简单的东西，您可以添加。

当然，这些只是许多可能的解决方案中的一(两个)，但希望它能使你的思想朝着正确的方向发展。

这里有一些很好的答案，但我想展示一个细微的变化。我认为展示JavaScript的一些不同方面和在代码中区分兴趣是很重要的。

函数作为第一类对象是很酷的——"连续"的确切规则可以通过改变谓词函数来改变。也许我们应该允许跳过数字?没有问题。也许我们允许十六进制数字?没有问题。

follows

这可以实现，因为字符串支持索引。这将与其他具有适当follows函数的类数组对象一样工作。注意continuous函数中没有使用特定于字符串的函数

代码也在jsfiddle上:

// returns true only iff b "follows" a; this can be changed
function follows_1Through9WithWrappingTo0(b,a) {
    if (b === "1" && a === undefined) {
        // start of sequence
        return true;
    } else if (b === "0" && a === "9") {
        // wrap
        return true;
    } else {
        // or whatever
        return (+b) === (+a) + 1;
    }
}
function continuous(seq, accordingTo, from) {
   // strings can be treated like arrays; this code really doesn't care
   // and could work with arbitrary array-like objects
   var i = from || 0;
   if ((seq.length - i) < 1) {
       return true;
   }
   var a = undefined;
   var b = undefined;
   for (; i < seq.length; i++) {
      b = seq[i];
      if (!accordingTo(b, a)) {
         return false; // not continuous
      }
      a = b;
   }
   return true;
}
function assert(label, expr, value) {
    if (!(expr === value)) {
        alert("FAILED: " + label);
    }
}
var follows = follows_1Through9WithWrappingTo0;
assert("empty1", continuous("", follows), true);
assert("empty2", continuous("foobar", follows, 6), true);
assert("skip", continuous("331234", follows, 2), true);
assert("good 1", continuous("123456789", follows), true);
assert("good 2", continuous("12345678901234", follows), true);
assert("bad seq 1", continuous("12347678901234", follows), false);
assert("bad seq 2", continuous("10", follows), false);
// here a different predicate ensures all the elements are the same
var areAllSame = function (b, a) {
                     return a === undefined || a === b;
                 };
assert("same", continuous("aaaaa", areAllSame), true);

请注意，跳过也可以从continuous函数中提取:在具有更好的"函数式"集合支持的语言中，例如c#，这正是我首先要做的。

相关内容

最新更新

热门标签：