Expresión regular para alfanuméricos y guiones bajos

Para hacer coincidir una cadena que contiene , solamente esos caracteres (o una cadena vacía), intente

"^[a-zA-Z0-9_]*$"

Esto funciona para expresiones regulares .NET y probablemente también para muchos otros lenguajes.

Desglosando:

^ : start of string
[ : beginning of character group
a-z : any lowercase letter
A-Z : any uppercase letter
0-9 : any digit
_ : underscore
] : end of character group
* : zero or more of the given characters
$ : end of string

Si no desea permitir cadenas vacías, use + en lugar de *.

Como han señalado otros, algunos lenguajes de expresiones regulares tienen una forma abreviada para [a-zA-Z0-9_]. En el lenguaje de expresiones regulares .NET, puede activar el comportamiento de ECMAScript y usar \w como taquigrafía ^\w*$ or ^\w+$). Tenga en cuenta que en otros idiomas, y de forma predeterminada en .NET, \w es algo más amplio y también coincidirá con otros tipos de caracteres Unicode (gracias a Jan por señalar esto). Entonces, si realmente tiene la intención de igualar , solamente esos caracteres, usar la forma explícita (más larga) es probablemente lo mejor.

Hay mucha verbosidad aquí, y estoy profundamente en contra, por lo que mi respuesta concluyente sería:

/^\w+$/

\w es equivalente a [A-Za-z0-9_], que es más o menos lo que quieres. (a menos que introduzcamos unicode en la mezcla)

Usando el patrón de velas del + cuantificador coincidirá con uno o más caracteres. Si también desea aceptar una cadena vacía, use * preferiblemente.

Quieres comprobar que cada carácter coincide con tus requisitos, por eso utilizamos:

[A-Za-z0-9_]

E incluso puedes usar la versión abreviada:

\w

Que es equivalente (en algunos sabores de expresiones regulares, así que asegúrese de verificar antes de usarlo). Luego, para indicar que toda la cadena debe coincidir, usa:

^

Para indicar que la cadena debe comenzar con ese carácter, luego use

$

Para indicar la cadena debe terminar con ese carácter. Entonces usa

\w+ or \w*

Para indicar "1 o más", o "0 o más". Poniéndolo todo junto, tenemos:

^\w*$

Um ... pregunta: ¿Necesita tener al menos un carácter o no? ¿Puede ser una cadena vacía?

^[A-Za-z0-9_]+$

Hará al menos un guión bajo o alfanumérico en mayúsculas o minúsculas. Si puede ser de longitud cero, simplemente sustituya el + por *

^[A-Za-z0-9_]*$

Edit:

Si es necesario incluir signos diacríticos (como cedilla - ç), entonces deberá usar la palabra carácter que hace lo mismo que el anterior, pero incluye los caracteres diacríticos:

^\w+$

Or

^\w*$

Aunque es más detallado que \w, Personalmente aprecio la legibilidad de los nombres completos de las clases de caracteres POSIX ( http://www.zytrax.com/tech/web/regex.htm#special ), entonces yo diría:

^[[:alnum:]_]+$

Sin embargo, aunque la documentación de los enlaces anteriores establece que \w "Coincidirá con cualquier carácter en el rango 0 - 9, A - Z y a - z (equivalente a POSIX [: alnum:])", no he encontrado que esto sea cierto. No con grep -P de todas formas. Debe incluir explícitamente el guión bajo si usa [:alnum:] pero no si usas \w. No se puede superar lo siguiente para breve y dulce:

^\w+$

Junto con la legibilidad, el uso de las clases de caracteres POSIX (http://www.regular-expressions.info/posixbrackets.html) significa que su expresión regular puede funcionar en cadenas no ASCII, lo que las expresiones regulares basadas en rango no harán ya que dependen del orden subyacente de los caracteres ASCII que pueden ser diferentes de otros conjuntos de caracteres y, por lo tanto, excluirán algunos caracteres no ASCII ( letras como œ) que quizás desee capturar.

En Ciencias de la Computación, un valor alfanumérico a menudo significa que el primer carácter no es un número, sino un alfabeto o un guión bajo. A partir de entonces, el personaje puede ser 0-9, A-Z, a-z, o subrayado (_).

Así es como lo haría:

Probado en php:

$regex = '/^[A-Za-z_][A-Za-z\d_]*$/'

o toma esto

^[A-Za-z_][A-Za-z\d_]*$

y colóquelo en su lenguaje de desarrollo.

Qué tal si:

^([A-Za-z]|[0-9]|_)+$

... si quieres ser explícito, o:

^\w+$

... si lo prefiere conciso (sintaxis Perl).

use lookaheads para hacer "al menos una" cosas. Créame, es mucho más fácil.

Aquí hay un ejemplo que requeriría de 1 a 10 caracteres, que contiene al menos un dígito y una letra:

^(?=.*\d)(?=.*[A-Za-z])[A-Za-z0-9]{1,10}$

NOTA: podría haber usado \ w pero luego entran en juego consideraciones ECMA / Unicode aumentando la cobertura de caracteres del \ w "carácter de palabra".

Prueba estas extensiones multilingües que he hecho para cuerdas.

IsAlphaNumeric: la cadena debe contener al menos 1 alfa (letra en el rango Unicode, especificada en charSet) y al menos 1 número (especificado en numSet). Además, la cadena debe estar formada solo por alfa y números.

IsAlpha: la cadena debe contener al menos 1 alfa (en el idioma charSet especificado) y comprender solo alfa.

IsNumeric: la cadena debe contener al menos 1 número (en el idioma especificado numSet) y comprender solo números.

Se puede especificar el rango charSet / numSet para el idioma deseado. Los rangos Unicode están disponibles en el siguiente enlace:

http://www.ssec.wisc.edu/~tomw/java/unicode.html

API:

    public static bool IsAlphaNumeric(this string stringToTest)
    {
        //English
        const string charSet = "a-zA-Z";
        const string numSet = @"0-9";

        //Greek
        //const string charSet = @"\u0388-\u03EF";            
        //const string numSet = @"0-9";

        //Bengali
        //const string charSet = @"\u0985-\u09E3";
        //const string numSet = @"\u09E6-\u09EF";

        //Hindi
        //const string charSet = @"\u0905-\u0963";
        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^(?=[" + numSet + @"]*?[" + charSet + @"]+)(?=[" + charSet + @"]*?[" + numSet + @"]+)[" + charSet + numSet +@"]+$").Success;
    }

    public static bool IsNumeric(this string stringToTest)
    {
        //English
        const string numSet = @"0-9";

        //Hindi
        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^[" + numSet + @"]+$").Success;
    }

    public static bool IsAlpha(this string stringToTest)
    {
        //English
        const string charSet = "a-zA-Z";

        return Regex.Match(stringToTest, @"^[" + charSet + @"]+$").Success;
    }

Uso:

        //English
        string test = "AASD121asf";

        //Greek
        //string test = "Ϡϛβ123";

        //Bengali
        //string test = "শর৩৮";

        //Hindi
        //string test = @"क़लम३७ख़";

        bool isAlphaNum = test.IsAlphaNumeric();

La siguiente expresión regular coincide con caracteres alfanuméricos y guiones bajos:

^[a-zA-Z0-9_]+$

Por ejemplo, en Perl:

#!/usr/bin/perl -w

my $arg1 = $ARGV[0];

# check that the string contains *only* one or more alphanumeric chars or underscores
if ($arg1 !~ /^[a-zA-Z0-9_]+$/) {
  print "Failed.\n";
} else {
    print "Success.\n";
}

Esto debería funcionar en la mayoría de los casos.

/^[\d]*[a-z_][a-z\d_]*$/gi

Y por la mayoría me refiero

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Explicación

1. ^ ... $ - haga coincidir el patrón que comienza y termina con
2. [\d]* - coincidir con cero o más dígitos
3. [a-z_] - coincidir con un alfabeto o guión bajo
4. [a-z\d_]* - coincidir con un alfabeto, un dígito o un subrayado
5. /gi - coincidir globalmente en la cadena y no distingue entre mayúsculas y minúsculas

Esto funciona para mí, encontré esto en "Mastering Regular Expressions" de O'Reilly:

/^\w+$/

Explicación:

• ^ afirma la posición al comienzo de la cadena
  • \ w + coincide con cualquier carácter de palabra (igual a [a-zA-Z0-9_])
  • "+" Quantifier - Coincide entre una e ilimitadas veces, tantas veces como sea posible, devolviendo según sea necesario (codicioso)
• $ afirma la posición al final de la cadena

Verifíquese usted mismo:

const regex = /^\w+$/;
const str = `nut_cracker_12`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Para mí, hubo un problema en el sentido de que quiero distinguir entre alfanumérico, numérico y alfanumérico, por lo que para asegurarme de que una cadena alfanumérica contiene al menos un alfanumérico y al menos un numérico, utilicé:

^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$

Para aquellos de ustedes que buscan una coincidencia alfanumérica Unicode, es posible que desee hacer algo como:

^[\p{L} \p{Nd}_]+$

Leer más en http://unicode.org/reports/tr18/ y en http://www.regular-expressions.info/unicode.html

Aquí está la expresión regular de lo que desea con un cuantificador para especificar al menos 1 carácter y no más de 255 caracteres

[^a-zA-Z0-9 _]{1,255}

Creo que no está tomando caracteres latinos y Unicode en sus coincidencias. Por ejemplo, si necesita utilizar caracteres "ã" o "ü", el uso de "\ w" no funcionará.

Alternativamente, puede utilizar este enfoque:

^[A-ZÀ-Ýa-zà-ý0-9_]+$

¡Espero eso ayude!

Para verificar toda la cadena y no permitir cadenas vacías, intente

^[A-Za-z0-9_]+$

^\w*$ funcionará para las siguientes combinaciones

1
123
1av
pRo
av1

esto funciona para mí, puedes intentarlo

[\\p{Alnum}_]

Formato requerido Permitir estos 3:

1. 0142171547295
2. 014-2171547295
3. 123abc

No permita otros formatos:

validatePnrAndTicketNumber(){
    let alphaNumericRegex=/^[a-zA-Z0-9]*$/;
    let numericRegex=/^[0-9]*$/;
    let numericdashRegex=/^(([1-9]{3})\-?([0-9]{10}))$/;
   this.currBookingRefValue = this.requestForm.controls["bookingReference"].value;
   if(this.currBookingRefValue.length == 14 && this.currBookingRefValue.match(numericdashRegex)){
     this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else if(this.currBookingRefValue.length ==6 && this.currBookingRefValue.match(alphaNumericRegex)){
    this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else if(this.currBookingRefValue.length ==13 && this.currBookingRefValue.match(numericRegex) ){
    this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else{
    this.requestForm.controls["bookingReference"].setErrors({'pattern': true});
   }
}

<input name="booking_reference" type="text" [class.input-not-empty]="bookingRef.value"
    class="glyph-input form-control floating-label-input" id="bookings_bookingReference"
    value="" maxlength="14" aria-required="true" role="textbox" #bookingRef
    formControlName="bookingReference" (focus)="resetMessageField()" (blur)="validatePnrAndTicketNumber()"/>