-1 
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”会弹出正确，如何实现？

4

4 回答 4

0

这将检查实时条目，但类似的原理可以用于检查按钮提交或类似的条目。我不是 100% 确定你想要哪种方式，所以我选择了 live 方法。

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，当然您可以简单地在开头添加一个检查。

我也不会为您的偏移量执行任何有效数字检查，但这也是您可以添加的简单内容。

当然，这些只是众多可能解决方案中的一（两个），但希望它能让您的思想朝着正确的方向发展。

于 2013-05-03T00:31:59.583 回答
0

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

  1. 作为第一类对象的函数很酷 - 只需更改谓词函数即可更改“连续”的确切规则。也许我们应该允许跳过数字？没问题。也许我们允许十六进制数字？没问题。follows只需更改特定规则的相应功能即可。

  2. 这可以通用实现，因为字符串支持索引。这将与具有适当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#，这正是我首先要做的。

于 2013-05-03T01:23:31.863 回答
0

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

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/

于 2013-05-02T23:52:35.297 回答
0

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

当您击中 0 时，替换为 10，然后继续直到该数字不比前一个多 1。

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
*/
于 2013-05-03T00:45:08.720 回答