Espressione regolare per contare il numero di virgole in una stringa

Come posso costruire una espressione regolare che corrisponde ad una stringa di qualsiasi lunghezza che contiene tutti i caratteri, ma che deve contenere il 21 virgole?

  • Deve contenere esattamente, o almeno 21 virgole?
  • CSV di convalida?
InformationsquelleAutor | 2009-05-14



9 Replies
  1. 90
    /^([^,]*,){21}[^,]*$/

    Che è:

    ^     Start of string
    (     Start of group
    [^,]* Any character except comma, zero or more times
        A comma
    ){21} End and repeat the group 21 times
    [^,]* Any character except comma, zero or more times again
    $     End of string
    • Molto bella spiegazione. Basta assicurarsi che si inserisce nel commento nel codice.
    • grazie davvero bene l’unica cosa è ,,,,,,,,,,,,,,,,, ecc è consentito come posso includere questo?
    • Questa regex permetterà 21 giorni consecutivi di virgole – per evitare che il cambiamento sia il * a +
    • Inoltre, utilizzando *+ (o ++) invece di * (o +) può essere più veloce, se il tuo motore regex supporta.
    • Inoltre, per quanto riguarda Robert commento – vedi la mia risposta al di sotto del quale usi?x) per consentire i commenti, in modo che entrambe le regex e spiegazione possono vivere insieme.
    • JavaScript non supporta possessivo quantificatori. Dubito che sarebbe una notevole differenza comunque qui.

  2. 11

    Se si utilizza una regex varietà che supporta il Possessivo quantificatore (ad esempio Java), si può fare:

    ^(?:[^,]*+,){21}[^,]*+$

    Possessivo occorrenza può essere migliore performance di un Avido quantificatore.


    Spiegazione:

    (?x)    # enables comments, so this whole block can be used in a regex.
    ^       # start of string
    (?:     # start non-capturing group
    [^,]*+  # as many non-commas as possible, but none required
    ,       # a comma
    )       # end non-capturing group
    {21}    # 21 of previous entity (i.e. the group)
    [^,]*+  # as many non-commas as possible, but none required
    $       # end of string
  3. 7

    Potrebbe essere più veloce e più comprensibile per scorrere la stringa, contare il numero di virgole trovato e poi confrontarlo con 21.

  4. 7

    Esattamente il 21 virgole:

    ^([^,]*,){21}[^,]$

    Almeno 21 virgole:

    ^([^,]?,){21}.*$
    • Il primo match sarà più di 21 virgole (perché non è ancorato) e se si ancorano la stringa dovrà terminare con la virgola
    • Giá risolto … ^^
    • Oops … non risolto … ma ora …
    • Questo non è giusto. Perché si richiede che la stringa non termina con una virgola? La questione non è dire che.
    • Ha potuto risolvere il problema abbastanza facilmente con:^([^,]*,){21}([^,]*)$
  5. 1
    ^(?:[^,]*)(?:,[^,]*){21}$
    • È possibile rimuovere la ‘?:’ se non lo si utilizza .NET
    • A prescindere dalla regex versione, si dovrebbe lasciare l’ ?: se non si desidera acquisire il gruppo.
  6. 1

    se esattamente 21:

    /^[^,]*(,[^,]*){21}$/

    se almeno 21:

    /(,[^,]*){21}/

    Tuttavia, vorrei suggerire di non utilizzare espressioni regolari per tale compito semplice. Perché è lenta.

  7. 0

    Che lingua? Probabilmente c’è un metodo più semplice.

    Per esempio…

    In CFML, si può solo vedere se ListLen(MyString) 22

    In Java, è possibile confrontare MyString.split(',') al 22

    ecc…

  8. 0
    var valid = ((" " + input + " ").split(",").length == 22);

    o…

    var valid = 21 == (function(input){
        var ret = 0;
        for (var i=0; i<input.length; i++)
            if (input.substr(i,1) == ",")
                ret++;
        return ret
    })();

    Un rendimento migliore rispetto…

    var valid = (/^([^,]*,){21}[^,]*$/).test(input);
  9. -10
    .*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,
    • Questo match sarà più di 21 virgole
    • Ed è illeggibile troppo! C’è un motivo per {num} sintassi esiste.
    • Concordato, è illeggibile. Il {21} sintassi è preferibile. Ma si fa il punto visibilmente: solo ripetere ciò che si desidera. Essa ha anche il vantaggio di lavorare nel vecchio regex ambienti che non supportano il numero di ripetizioni di sintassi.
    • E ‘ anche estremamente inefficiente. Il primo punto-star inizialmente consumare tutta la stringa, poi tornare indietro quanto basta per lasciare che il comma seguente partita. Quindi il secondo punto-star-virgola avere nulla a partita, in modo che il primo sarà costretto a tornare indietro di nuovo, e così via. Questa è una ricetta per il catastrofico backtracking. regular-expressions.info/catastrophic.html

Lascia un commento