Puntos de conocimiento de JavaScript-regulares

Others 2021-03-30 10:48:07 views: null

Regular

1. Concepto

Regular: es una fórmula lógica para la manipulación de cadenas. De hecho, algunos caracteres representativos especiales definidos de antemano se utilizan para formar una cadena regular para realizar algunas operaciones de búsqueda y reemplazo en la cadena.

En segundo lugar, cree una

  1. Método de creación literal: var reg = / rule string / modifier;
   var reg = /web/ig;
   console.log(reg);///web/gi
  1. Método de creación del constructor: var reg = new RegExp ('cadena de reglas', 'modificador');
    var reg1 = new RegExp('web', 'ig');
    console.log(reg1);///web/gi

Tres, modificador

  1. i: ignorar mayúsculas y minúsculas ignorar mayúsculas y minúsculas

  2. g: coincidencia global global

   var str = 'web123WEB456web789web000';
   var reg = /web/gi;
   var s = str.replace(reg, 'python');
   console.log(s);//python123python456python789python000

Cuatro, método de cuerda

  1. Reemplazar: string.replace (regular, nuevo carácter); devuelve una nueva cadena, la cadena original no cambiará
   var str = 'web123WEB456web789web000';
   var reg = /web/gi;
   var s = str.replace(reg, 'python');
   console.log(s);//python123python456python789python000
  1. Separado: string.split (regular); devuelve una nueva matriz
   var str = 'web123Web456web789web000';
   var reg = /web/gi;
   var arr = str.split(reg);
   console.log(arr)//(5) ["", "123", "456", "789", "000"]
  1. Selección: string.match (regular); Seleccione los caracteres que cumplen las condiciones, forme una nueva matriz y regrese
   var str = 'web123Web456web789web000';
   var reg = /\d/ig; // 匹配数字
   var arr2 = str.match(reg);
   console.log(arr2);//(12) ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "0", "0"]
  1. Buscar: string.search (regular); comience a hacer coincidir desde la posición donde el subíndice es 0, y devuelva el subíndice después de hacer coincidir el carácter regular
   var str = 'web123Web456web789web000';
   var reg = /\d/ig; // 匹配数字
   console.log(str.search(reg));//3

5. Método de recuperación (ejecutivo, prueba)

  1. exec: regular.exec (cadena que debe coincidir); se devolverá una matriz de caracteres calificados cada vez

  2. test: regular.test (la cadena que debe coincidir); devuelve si la coincidencia es exitosa, si la coincidencia es exitosa, devuelve verdadero, si falla, devuelve falso

* Si no se agrega el modificador g, la búsqueda o coincidencia comienza desde 0 cada vez. Si se agrega g, significa que la coincidencia comienza desde la siguiente posición de la coincidencia anterior. Después de que el resultado de la coincidencia devuelve nulo o falso, Partido Revancha desde 0

* reg.lastIndex Obtiene la posición actual donde comienza el partido regular

   var str = 'web123web456';
   var reg = /\d\d\d/g;
   console.log(reg.lastIndex); // 0
   console.log(reg.exec(str)); // ["1", index: 3, input: "web123web456", groups: undefined]
   console.log(reg.lastIndex); // 4
   console.log(reg.exec(str)); // 2
   console.log(reg.lastIndex); // 5
   console.log(reg.exec(str)); // 3
   
   console.log(reg.lastIndex); // 0
   console.log(reg.test(str)); // true
   console.log(reg.lastIndex); // 6
   console.log(reg.test(str)); // true
   console.log(reg.lastIndex); // 12
   console.log(reg.test(str)); // false
   console.log(reg.lastIndex); // 0
   console.log(reg.test(str)); // true

Seis, metacaracteres

  1. Punto: coincide con todos los caracteres excepto la nueva línea
   var str = '\n 123';
   var reg = /./;
   console.log(reg.exec(str));//[" ", index: 1, input: "↵ 123", groups: undefined]
  1. []: Conjunto de caracteres, el conjunto de caracteres que se van a hacer coincidir, no es necesario agregar, separar o comillas en el conjunto de caracteres [^]: conjunto de caracteres, el conjunto de caracteres de los caracteres que se van a hacer coincidir
   var str = 'web123web456';
   var reg = /[413]/ig;
   console.log(reg.exec(str)); // 1
   console.log(reg.exec(str)); // 3
  1. \ d: coincide con los dígitos del juego de caracteres 0-9 == \ d \ D: coincide con los que no son dígitos
   var str = 'web123';
   var reg = /\d\d\d/ig;
   console.log(reg.exec(str)); // 123
   var reg = /\D/ig;
   console.log(reg.exec(str)); // w
   
   // 银行卡密码 6位数字
   var reg = /\d\d\d\d\d\d/;
   var str = 'a12345';
   console.log(reg.test(str));//false
  1. \ s: coincide con espacios \ S: coincide con no espacios
   var str = 'web 123';
   var reg = /\s/ig;
   console.log(reg.exec(str)); // 3
   var reg = /\S/ig;
   console.log(reg.exec(str)); // 0
  1. \ w: coincide con números, letras, _ \ W: coincide con no dígitos, letras, _
   var str = '_w1.23*';
   var reg = /\w/ig;
   console.log(reg.exec(str)); // _
   var reg = /\W/ig;
   console.log(reg.exec(str)); // .
  1. \ b: coincide con el límite de la palabra \ B: coincide con el límite que no es de palabras
   var str = 'you are a beautiful boy';
   var reg = /\ba/ig; // 匹配a左边是边界的a
   console.log(reg.exec(str)); // 4
   var reg = /a\B/ig; // 匹配a右边不是单词边界
   console.log(reg.exec(str)); // 4
  1. ^: lo que comienza con $: termina con
   var str = '912345';
   var reg = /^\d\d\d\d\d\d$/;
   console.log(reg.test(str)); //true
   console.log(reg.exec(str)); //["912345", index: 0, input: "912345", groups: undefined]

Siete, varios personajes

  1. a ?: significa uno o cero
   var str = '1web123';
   var reg = /\d?/ig;
   console.log(reg.exec(str));//["1", index: 0, input: "1web123", groups: undefined]
  1. a *: Significa hacer coincidir 0 o varios caracteres consecutivos, para hacer coincidir tantos como sea posible
   var str = '123456web33333';
   var reg = /\d*/;
   console.log(reg.exec(str));//["123456", index: 0, input: "123456web33333", groups: undefined]
  1. a +: Significa hacer coincidir al menos uno o más caracteres consecutivos, tanto como sea posible para hacer coincidir
   var str = 'webweb3444';
   var reg = /\d+/;
   console.log(reg.exec(str));//["3444", index: 6, input: "webweb3444", groups: undefined]
  1. a {n, m}: significa coincidir al menos n veces y coincidir como máximo m veces
  • a {n}: significa que solo coincide n veces
   var str = 'web1234567890';
   var reg = /\d{3}/;
   console.log(reg.exec(str)); // 123
  • a {n,}: coincide al menos n veces
   var str = 'web1234567890';
   var reg = /\d{3,}/;
   console.log(reg.exec(str)); // 1234567890
  • a {n, m}: significa coincidir al menos n veces y coincidir como máximo m veces
   var str = 'web1234567890';
   var reg = /^web\d{3,6}/;
   console.log(reg.exec(str)); // web123456

8. Otros personajes

  1. |: o

  2. (): Grupo para obtener el valor coincidente del grupo: RegExp. $ 1 RegExp. $ 2

   var str = 'web1zweb2web3';
   var reg = /web(1|5)(w|z)/;
   console.log(reg.exec(str)); //  ["web1z", "1", "z", index: 0, input: "web1zweb2web3", groups: undefined]
   console.log(RegExp.$1);//1
   console.log(RegExp.$2);//z
  1. (? :): Coincidencia de no adquisición
   var str = 'web1zweb2web3';
   var reg = /web(?:5|2)/; // web后面是5或者是2的web
   console.log(reg.exec(str));//["web2", index: 5, input: "web1zweb2web3", groups: undefined]
  1. (? =): Comprobación previa afirmativa positiva
   var str = 'web123webdffff';
   var reg = /web(?=\d+)/; // web后面必须跟数字
   console.log(reg.exec(str));//["web", index: 0, input: "web123webdffff", groups: undefined]
  1. (?!): Comprobación previa positiva negativa
   var reg = /web(?!\d+)/; // web后面不跟数字的
   console.log(reg.exec(str));//["web", index: 6, input: "web123webdffff", groups: undefined]
  1. (? <=): Verificación previa afirmativa inversa
   var reg = /(?<=\d+)web/; // web的前面是跟数字的web
   console.log(reg.exec(str)); // 6
  1. (? <!): Verificación previa negativa inversa
   var reg = /(?<!\d+)web/;
   console.log(reg.exec(str)); // 0
   
   // 不能全是数字的组合
   var str = '124456';
   var reg = /(?!^\d+$)^[0-9a-zA-Z]+$/;
   console.log(reg.test(str)); // false
   
   // 必须是数字和字母的组合 不能全是数字、不能全是字母
   var reg = /(?!^\d+$)(?!^[a-zA-Z]+$)^[0-9a-zA-Z]+$/;
   var str = '1223a3344';
   console.log(reg.test(str)); // false

Regular de uso común

1. La expresión del dígito de control

  1. Número: ^ [0-9] * $

  2. número de n dígitos: ^ \ d {n} $

  3. Al menos n dígitos: ^ \ d {n,} $

  4. mn dígitos: ^ \ d {m, n} $

  5. Números que comienzan con cero y distintos de cero: ^ (0 | [1-9] [0-9] *) $

  6. Números que comienzan con un valor distinto de cero y hasta dos lugares decimales: ^ ([1-9] [0-9] *) + (. [0-9] {1,2})? $

  7. Números positivos o negativos con 1-2 posiciones decimales: ^ (-)? \ D + (. \ D {1,2})? $

  8. Positivo, negativo y decimal: ^ (- | +)? \ D + (. \ D +)? $

  9. Números reales positivos con dos decimales: ^ [0-9] + (. [0-9] {2})? $

  10. Números reales positivos con 1 ~ 3 posiciones decimales: ^ [0-9] + (. [0-9] {1,3})? $

  11. Entero positivo distinto de cero: ^ [1-9] \ d * $ o ^ ([1-9] [0-9] ) {1,3} $ o ^ +? [1-9] [0-9] PS

  12. Entero negativo distinto de cero: ^ - [1-9] [] 0-9 " $ o ^ - [1-9] \ d $

  13. Entero no negativo: ^ \ d + $ o ^ [1-9] \ d * | 0 $

  14. Entero no positivo: ^ - [1-9] \ d * | 0 $ o ^ ((- \ d +) | (0 +)) $

  15. Número de punto flotante no negativo: ^ \ d + (. \ D +)? $ O ^ [1-9] \ d *. \ D * | 0. \ d * [1-9] \ d * | 0? .0 + | 0 $

  16. Número de punto flotante no positivo: ^ ((- \ d + (. \ D +)?) | (0 + (. 0 +)?)) $ O ^ (- ([1-9] \ d *. \ D * | 0. \ D * [1-9] \ d *)) | 0? .0+ | 0 $

  17. Número de punto flotante positivo: ^ [1-9] \ d *. \ D * | 0. \ d * [1-9] \ d * $ o ^ (([0-9] +. [0-9] [ 1-9 ] [0-9] ) | ([0-9] [1-9] [0-9] . [0-9] +) | ([0-9] [1-9] [0- 9] )) $

  18. Números de coma flotante negativos: ^ - ([1-9] \ d *. \ D * | 0. \ d * [1-9] \ d *) $ o ^ (- (([0-9] +. [ 0-9 ] [1-9] [0-9] ) | ([0-9] [1-9] [0-9] . [0-9] +) | ([0-9] [1- 9] [0-9] ))) $

  19. Número de coma flotante: ^ (-? \ D +) (. \ D +)? $ O ^ -? ([1-9] \ d *. \ D * | 0. \ d * [1-9] \ d * | 0? .0+ | 0) $

Dos, la expresión del carácter de control.

  1. Caracteres chinos: ^ [\ u4e00- \ u9fa5] {0,} $

  2. Inglés y números: ^ [A-Za-z0-9] + $ o ^ [A-Za-z0-9] {4,40} $

  3. Todos los caracteres con una longitud de 3 a 20: ^. {3,20} $

  4. Una cadena que consta de 26 letras en inglés: ^ [A-Za-z] + $

  5. Una cadena que consta de 26 letras mayúsculas en inglés: ^ [AZ] + $

  6. Una cadena que consta de 26 letras minúsculas en inglés: ^ [az] + $

  7. Una cadena que consta de números y 26 letras en inglés: ^ [A-Za-z0-9] + $

  8. Una cadena que consta de números, 26 letras en inglés o guiones bajos: ^ \ w + $ o ^ \ w {3,20} $

  9. Chino, inglés, números que incluyen guiones bajos: ^ [\ u4E00- \ u9FA5A-Za-z0-9 _] + $

  10. Chino, inglés, números, pero sin guiones bajos ni otros símbolos: ^ [\ u4E00- \ u9FA5A-Za-z0-9] + $ o ^ [\ u4E00- \ u9FA5A-Za-z0-9] {2,20} $

  11. Puede ingresar caracteres como ^% & ',; =? Error de análisis de KaTeX: No se puede usar la función' \ "'en modo matemático en la posición 1: \ ̲" ̲: [^% &',; =? \ X22 ] + 12 Está prohibido ingresar caracteres que contengan ~: [^ ~ \ x22] +

Tres expresiones de demanda especial

  1. Correo electrónico 地址 ： ^ \ w + ([- +.] \ W +) @ \ w + ([-.] \ W +) . \ W + ([-.] \ W +) * $

  2. 域名 ： [a-zA-Z0-9] [- a-zA-Z0-9] {0,62} (/. [A-zA-Z0-9] [- a-zA-Z0-9] {0 , 62}) + /.?

  3. URL de Internet: [a-zA-z] +: // [^ \ s] * 或 ^ http: // ([\ w-] +.) + [\ W-] + (/ [\ w -. /? % & =] *)? $

  4. Número de teléfono móvil: ^ (13 [0-9] | 14 [5 | 7] | 15 [0 | 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9] | 18 [0 | 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9]) \ d {8} $

  5. Número de teléfono ("XXX-XXXXXXX", "XXXX-XXXXXXXX", "XXX-XXXXXXX", "XXX-XXXXXXXX", "XXXXXXX" y "XXXXXXXX): ^ ((\ d {3,4} -) | \ d {3.4} -)? \ D {7,8} $

  6. Número de teléfono nacional (0511-4405222, 021-87888822): \ d {3} - \ d {8} | \ d {4} - \ d {7}

  7. Número de identificación (15 dígitos, 18 dígitos): ^ \ d {15} | \ d {18} $

  8. Número de identificación corto (número, letra x final): ^ ([0-9]) {7,18} (x | X)? $ O ^ \ d {8,18} | [0-9x] {8, 18 } | [0-9X] {8,18}? $

  9. Si el número de cuenta es legal (comenzando con una letra, permitiendo de 5 a 16 bytes, permitiendo guiones bajos alfanuméricos): ^ [a-zA-Z] [a-zA-Z0-9 _] {4,15} $

  10. Contraseña (comenzando con una letra, longitud entre 6 ~ 18, solo puede contener letras, números y guiones bajos): ^ [a-zA-Z] \ w {5,17} $

  11. Contraseña segura (debe contener una combinación de letras y números en mayúsculas y minúsculas, no puede usar caracteres especiales y la longitud es de 8 a 10): ^ (? =. \ D) (? =. [Az]) (? =. * [AZ]). {8,10} $

  12. Formato de fecha: ^ \ d {4} - \ d {1,2} - \ d {1,2}

  13. 12 meses de un año (01 ～ 09 y 1 ～ 12): ^ (0? [1-9] | 1 [0-2]) $

  14. 31 días de un mes (01 ～ 09 y 1 ～ 31): ^ ((0? [1-9]) | ((1 | 2) [0-9]) | 30 | 31) $

  15. Formato de entrada de dinero:

  16. 1. Hay cuatro representaciones de dinero que podemos aceptar: "10000.00" y "10,000.00", y "10000" y "10,000" sin "puntos": ^ [1-9] [0-9] * $

  17. 2. Esto significa cualquier número que no comience con 0, pero también significa que un carácter "0" no pasa, por lo que usamos la siguiente forma: ^ (0 | [1-9] [0-9] *) PS

  18. 3. Un 0 o un número que no comience con 0. También podemos permitir un signo negativo al comienzo: ^ (0 | -? [1-9] [0-9] *) $

  19. 4. Esto significa un 0 o un número posiblemente negativo que no comience con 0. Deje que el usuario comience con 0. Elimine también el signo negativo, porque el dinero no puede ser negativo. Lo que queremos agregar a continuación es una explicación Posible parte decimal: ^ [0-9] + (. [0-9] +)? $

  20. 5. Debe tenerse en cuenta que debe haber al menos 1 dígito después del punto decimal, por lo que no se pasa "10", sino que se pasa "10" y "10.2": ^ [0-9] + (. [0 - 9] {2})? $

  21. 6. De esta manera, estipulamos que debe haber dos dígitos después del punto decimal. Si cree que es demasiado duro, puede hacer esto: ^ [0-9] + (. [0-9] {1,2 PS

  22. 7. Esto le permite al usuario escribir solo un lugar decimal. Ahora debemos considerar la coma en el número, podemos hacer esto: ^ [0-9] {1,3} (, [0-9] {3}) * (. [0-9] {1,2})? $

  23. 8.1 a 3 dígitos, seguido de una coma + 3 dígitos, la coma se vuelve opcional, no obligatoria: ^ ([0-9] + | [0-9] {1,3} (, [0-9] {3} ) *) (. [0-9] {1,2})? $

  24. Comentarios: Este es el resultado final, no olvides que "+" se puede reemplazar con "*". Si crees que una cadena vacía también es aceptable (extraño, ¿por qué?) Finalmente, no olvides quitar la barra invertida cuando usando la función Kong, los errores generales están aquí

  25. xml 文件 ： ^ ([a-zA-Z] ±?) + [a-zA-Z0-9] + \. [x | X] [m | M] [l | L] $

  26. Expresión regular de caracteres chinos: [\ u4e00- \ u9fa5]

  27. Caracteres de doble byte: [^ \ x00- \ xff] (incluidos los caracteres chinos, se pueden utilizar para calcular la longitud de la cadena (un carácter de doble byte cuenta como 2, el carácter ASCII cuenta como 1))

  28. Expresión regular para líneas en blanco: \ n \ s * \ r (se puede usar para eliminar líneas en blanco)

  29. Expresión regular de marcado HTML: <(\ S *?) [^>] >. ? </ \ 1> | <. *? /> (La versión que circula en Internet es una lástima, y ​​lo anterior es solo una parte de it. Para el complejo La etiqueta anidada sigue siendo indefensa)

  30. Expresión regular del primer y último carácter en blanco: ^ \ s * | \ s * Error de análisis de KaTeX: Secuencia de control no definida: \ s en la posición 4: o (^ \ ̲s̲ *) | (\ s * ) (se puede usar para eliminar el comienzo de una línea Espacio en blanco al final de la línea (incluidos espacios, tabulaciones, feeds de formularios, etc.), expresiones muy útiles)

  31. Número de Tencent QQ: [1-9] [0-9] {4,} (El número de Tencent QQ comienza en 10000)

  32. Código postal chino: [1-9] \ d {5} (?! \ D) (el código postal chino tiene 6 dígitos)

  33. Dirección IP: \ d +. \ D +. \ D +. \ D + (útil al extraer la dirección IP)

  34. Dirección IP: ((?: (?: 25 [0-5] | 2 [0-4] \ d | [01]? \ D? \ D) \.) {3} (?: 25 [0-5 ] | 2 [0-4] \ d | [01]? \ D? \ D))

Supongo que te gusta

Origin blog.csdn.net/qq_41008567/article/details/107109194
Recomendado
Clasificación
Diario
Más
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)
2024-04-28(9)
2024-04-27(28)

Code World

© 2018 codetd.com