使用javascript/jquery基于正则表达式计算长度字符串

假设我有一个任意的正则表达式。如何计算匹配所需的字符串长度

示例（

regex

=>可匹配字符串的最小长度）：

[0-9]{3}[0-9]{2}

=>6

[0-9]{4}[0-9]{2}

=>7

[0-9]{2}.[0-9]{3}.[0-9]{3}/[0-9]{4}-[0-9]{2}

=>17

[0-9]{3}.[0-9]{3}.[0-9]{3}-[0-9]{2}

=>14

[0-9]{2}/[A-Z]{2}/[0-9]{4}

=>10

我还需要一个函数，它以一个正则表达式和一个介于1和使用上述函数计算的大小之间的整数作为参数（如

position（regex，number）

），并返回该位置的字符类型（数字、字母或符号）

示例：

• 示例1：位置3是一个“数字”
• 示例2：位置3是一个“符号”
• 例5：位置4是一个“字母”

更新

这里的目标是实现这一点：

function size_of(regex) {
    //
}

function type_of(regex, posicao) {
    //
}

function generate_string(tamanho) {
    //
}

$(document).on('.valida', 'focus', function(){
    var regex = $(this).attr('pattern');

    var counter = 0;
    var tam = size_of(regex);
    var str = generate_string(tam);

    $(this).val(str);
    $(this).keypress(function(event){
        var tecla = e.which;

        if(typeof tecla == type_of(regex, counter)){
            str = str + tecla;
            counter++;
        }

        $(this).val(str);
    });
});

更新2

一些有用的例子：

1->计算长度：（只需更加通用）

更新3-最终代码

上述脚本的最终代码是：

jsfiddle

function parse(regexString){
    var regex = /((?!\[|\{).(?!\]|\}))|(?:\[([^\]]+)\]\{(\d+)\})/g,
        match,
        model = [];
    while (match = regex.exec(regexString)) {
        if(typeof match[1] == 'undefined'){
            for(var i=0;i<match[3];i++){
                model.push(match[2]);
            }
        }else{
            model.push(match[1]);
        }
    }
    return model;
}

function replaceAt(s, n, t) {
    return s.substring(0, n) + t + s.substring(n + 1);
}

function size_of(regex) {
    var parsedRegexp = parse(regex);
    return parsedRegexp.length;
}

function type_of(regex, posicao) {
    var parsedRegexp = parse(regex);
    var pos = parsedRegexp[posicao];

    if(pos == '0-9')
        return 'number';

    if(pos == 'A-Z' || pos == 'a-z')
        return 'string';

    return pos;
}

function generate_string(regex, tamanho) {
    var str = '';

    for(var i=0; i<tamanho; i++) {
        var type = type_of(regex, i);
        if(type == 'number' || type == 'string')
            str = str + '_';
        else
            str = str + type;
    }

    return str;
}

var counter;
var tam;
var str;
var regex;

$('.valida').each(function(){

    $(this).on('focus', function(e){
        regex = $(this).attr('pattern');

        counter = 0;
        tam = size_of(regex);
        str = generate_string(regex, tam);

        $(this).val(str);
    });

    $(this).on('keypress', function(e){
        e.preventDefault();

        var tecla = e.which;

        if(tecla >= 48 && tecla <= 57)
            var tecla2 = tecla - 48;
        else
            var tecla2 = String.fromCharCode(tecla);

        result = $("<div>");
        result.append( "tecla = "+tecla+"<br>" );

        var t = type_of(regex, counter);

        if(counter < tam) {
            if(t != 'number' && t != 'string') {
                str = replaceAt(str, counter, t);
                counter++;
            }

            t = type_of(regex, counter);

            if(typeof tecla2 == t) {
                result.append( "tecla2 = "+tecla2+"<br>" );
                str = replaceAt(str, counter, tecla2);
                counter++;
            }
        }

        result.append( "counter = "+counter+"<br>" );
        $("#result").empty().append(result);

        $(this).val(str);
    });

});

代码

function parse(regexString){
    var regex = /((?!\[|\{).(?!\]|\}))|(?:\[([^\]]+)\]\{(\d+)\})/g,
        match,
        model = [];
    while (match = regex.exec(regexString)) {
        if(typeof match[1] == 'undefined'){
            for(var i=0;i<match[3];i++){
                model.push(match[2]);
            }
        }else{
            model.push(match[1]);
        }
    }
    return model;
}

function replaceAt(s, n, t) {
    return s.substring(0, n) + t + s.substring(n + 1);
}

function size_of(regex) {
    var parsedRegexp = parse(regex);
    return parsedRegexp.length;
}

function type_of(regex, posicao) {
    var parsedRegexp = parse(regex);
    var pos = parsedRegexp[posicao];

    if(pos == '0-9')
        return 'number';

    if(pos == 'A-Z' || pos == 'a-z')
        return 'string';

    return pos;
}

function generate_string(regex, tamanho) {
    var str = '';

    for(var i=0; i<tamanho; i++) {
        var type = type_of(regex, i);
        if(type == 'number' || type == 'string')
            str = str + '_';
        else
            str = str + type;
    }

    return str;
}

var counter;
var tam;
var str;
var regex;

$('.valida').each(function(){

    $(this).on('focus', function(e){
        regex = $(this).attr('pattern');

        counter = 0;
        tam = size_of(regex);
        str = generate_string(regex, tam);

        $(this).val(str);
    });

    $(this).on('keypress', function(e){
        e.preventDefault();

        var tecla = e.which;

        if(tecla >= 48 && tecla <= 57)
            var tecla2 = tecla - 48;
        else
            var tecla2 = String.fromCharCode(tecla);

        result = $("<div>");
        result.append( "tecla = "+tecla+"<br>" );

        var t = type_of(regex, counter);

        if(counter < tam) {
            if(t != 'number' && t != 'string') {
                str = replaceAt(str, counter, t);
                counter++;
            }

            t = type_of(regex, counter);

            if(typeof tecla2 == t) {
                result.append( "tecla2 = "+tecla2+"<br>" );
                str = replaceAt(str, counter, tecla2);
                counter++;
            }
        }

        result.append( "counter = "+counter+"<br>" );
        $("#result").empty().append(result);

        $(this).val(str);
    });

});

函数解析（regexString）{
var regex=/（（？！\[\\{）。（？！\]\}））（？：\[（[^\]+）\]\{（\d+）\}）/g，
匹配，
模型=[]；
while（match=regex.exec（regexString））{
if（匹配类型[1]=“未定义”）{
对于（var i=0；i我相信这个问题的一般解决方案将涉及实现一个函数，该函数生成一个与每个正则表达式对应的有限状态自动机对象

这似乎与手头的问题有关

还可以查看此链接：（）
在您的特定情况下，您可以尝试以下代码（）：

var basicRegexLength=函数（正则表达式）{
var i；
regex=regex.replace（/（\[0-9\]\[A-Z\]）/gi，”）；
对于（i=1；i<10；i++）{
regex=regex.replace（新的RegExp（'\\{'+i+'\\}'，g'），数组（i+1）.join（'.'）；
}
返回regex.length；
};
我为简单的正则表达式做了一个小解析器，就像您正在使用的一样

它基本上为每个预期字符创建一个数组，该数组的类型为字符（0-9，A-Z）或字符本身

function parse(regexString){
    var regex = /((?!\[|\{).(?!\]|\}))|(?:\[([^\]]+)\]\{(\d+)\})/g,
        match,
        model = [];
    while (match = regex.exec(regexString)) {
        if(typeof match[1] == 'undefined'){
            for(var i=0;i<match[3];i++){
                model.push(match[2]);
            }
        }else{
            model.push(match[1]);
        }
    }
    return model;
}


此外，您还可以通过以下方式获取字符总数：

myresult.length;

myresult[n];

以及第n个字符的类型，通过：

myresult.length;

myresult[n];

我无法理解长度值从何而来我想根据正则表达式确定的模式来计算它。所以基本上你需要一个正则表达式解析器来解析模式本身，并生成关于它的信息……这里的实际用例是什么？我想使用正则表达式来获得测试字符串的长度会更容易而不是计算正则表达式的长度。也许我理解不正确，但如果您事先有正则表达式，那么手动将每个正则表达式映射到预期的字符串长度不是更容易吗，除非有过多的正则表达式需要跟踪？我想生成一个随机字符串将有助于完成我想要的内容。但是在你告诉我所有的例子都是php或perl（我几乎什么都不知道）。在jquery或javascript中有什么方法可以做到这一点吗？你能发布一个你需要匹配的所有正则表达式的列表吗？如果它们之间有一个共同的模式，可以用来为你的用例编写一个专门的解决方案。我没有一个共同的模式，脚本应该是更通用的。为了实现这一点，我只需要知道如何做到这一点o按照我在问题（字符串长度和字符类型）中提出的要求去做。当我这样做时，我可以在这里发布最终的代码以进行评估。这个例子将是一个很好的起点，junt不需要更一般：只有一个问题：为什么在循环中选择限制为10？它会寻找从
{1}
到
{10}的重复值
…如果您需要更多或更少，请根据需要进行调整。+1回答不错。应选择此作为解决方案。