C # Advanced Tutorial-Strings y expresiones regulares

Método de cadena:

Crear cadena

System.String(string是这个类的别名)
System.Text.StringBuilder

System.String clase
1, cree una cadena string s = "euphoria";
2, obtenga la longitud de la cadena s.Length (atributo)
3, compare si la cadena es la misma s == "euphoria"
4, string connection s = " http: // ”+ s;
5, use una sintaxis similar a un indexador para obtener un carácter en la cadena stringName [index] s [0] s [3]

Acerca de la cadena: la cadena creada por cadena es en realidad un tipo de datos inmutable. Una vez que se inicializa el objeto de cadena, la cadena no se puede cambiar. En el ejemplo anterior, se crea una nueva Cadena, copie el contenido de la cadena anterior a la nueva cadena. Luego asigne la referencia de la nueva cadena al objeto de la cadena. (Modifique repetidamente la cadena dada, la eficiencia será muy baja)

Otros metodos

1, Método CompareTo (), compare el contenido de la cadena
2, Reemplace () reemplace el carácter o cadena dada con otro carácter o cadena
3, Divida () en el lugar donde aparece el carácter dado, coloque el carácter La división de cadena es llamada matriz de cadenas
4, SubString () recupera la subcadena
5 en una posición determinada en la cadena , ToLower () convierte la cadena a
6 minúsculas , ToUpper () convierte la cadena a
7 mayúsculas , Trim () elimina el espacio en blanco al principio y punto

8, método Concat (), fusionar cadenas
9, método CopyTo (), copiar los caracteres especificados en la cadena a una matriz
10, método Format (), cadena de formato
11, método IndexOf (), obtener la cadena La primera aparición de un posición dada de cadena o carácter
12, método IndexOfAny (),
13, Insert () inserta una instancia de cadena en el índice especificado de otra instancia de cadena
14, Join () para fusionar cadenas Array, crea una nueva cadena

Clase StringBuilder (ubicada en el espacio de nombres System.Text)
1, cree el objeto
StringBuilder StringBuilder sb = new StringBuilder ("www.taikr.com");
StringBuilder sb = new StringBuilder (20);
StringBuilder sb = new StringBuilder ("www.devsiki .com ", 100);
Acerca del uso de memoria cuando se crea el objeto StringBuilder
2, método Append (), agregar un carácter a la cadena actual
3, Insert () agregar una cadena de un formato específico
4, Remove () de la actual cadena Elimina el carácter
5, Reemplaza () en la cadena actual, reemplaza otro carácter o cadena con un carácter o cadena
6, ToString () extrae la cadena almacenada en el StringBuilder actual en una cadena de caracteres inmutable

Expresión regular:

Que es la expresion regular

Un patrón que coincide con el texto de entrada. El marco .Net proporciona un motor de expresiones regulares que permite este tipo de coincidencia. El patrón consta de uno o más caracteres, operadores y estructuras.

El lenguaje de expresión regular es un lenguaje especialmente utilizado para el procesamiento de cadenas. Se proporciona soporte para él en muchos idiomas, y c # no es una excepción. Puede ayudarnos a resolver los siguientes problemas:
1. Recuperación: Obtener la parte que queremos de la cadena a través de expresiones regulares.
2. Coincidencia: Juicio Si la cadena dada cumple con la lógica de filtrado de
la expresión regular La expresión regular expresa las reglas de escritura de una cadena

Caso de uso: Determine si la contraseña ingresada por el usuario es legal y si el formato del buzón ingresado por el usuario es legal

La composición de
expresiones regulares : las expresiones regulares son patrones de texto compuestos por caracteres ordinarios y caracteres especiales (llamados metacaracteres). Este patrón describe una o más cadenas que deben coincidir al buscar el cuerpo principal del texto.

Métodos y delegados de uso común para manipular expresiones regulares:

Aprendamos sobre algunos métodos estáticos y delegados de la clase Regex en System.Text.RegularExpressions

Método estático IsMatch

(El valor de retorno es un tipo booleano, utilizado para determinar si la cadena especificada coincide con la cadena de expresión regular, tiene tres métodos sobrecargados)
bool IsMatch (entrada de cadena, patrón de cadena);
Parámetros: entrada: el elemento coincidente que se buscará Cadena .
patrón: el patrón de expresión regular que se va a hacer coincidir.
Devolver resultado: si la expresión regular encuentra una coincidencia, es verdadera; de lo contrario, es falsa.
bool IsMatch (entrada de cadena, patrón de cadena, opciones de RegexOptions);
Parámetros: entrada: La cadena para buscar coincidencias.
patrón: el patrón de expresión regular que se va a hacer coincidir.
opciones: una combinación bit a bit de valores de enumeración que proporcionan opciones de coincidencia.
Devolver resultado: si la expresión regular encuentra una coincidencia, es verdadera; de lo contrario, es falsa.
bool IsMatch (entrada de cadena, patrón de cadena, opciones de RegexOptions, TimeSpan matchTimeout);
Parámetros: entrada: La cadena para buscar coincidencias.
patrón: el patrón de expresión regular que se va a hacer coincidir.
opciones: una combinación bit a bit de valores de enumeración que proporcionan opciones de coincidencia.
matchTimeout: intervalo de tiempo de espera, o System.Text.RegularExpressions.Regex.InfiniteMatchTimeout indica que el método no debe agotar el tiempo de espera.
Devolver resultado: si la expresión regular encuentra una coincidencia, es verdadera; de lo contrario, es falsa.

Acerca del parámetro RegexOptions

Es un tipo enumerado con los siguientes valores enumerados.
RegexOptions valores enumerados. Indicadores en línea.
ExplicitCapture n Solo se capturan los grupos nombrados o numerados.
IgnoreCase i no distingue entre mayúsculas y minúsculas.
IgnorePatternWhitespace x elimina los espacios en blanco sin escape en el patrón y Habilitar comentarios marcados por #.
Modo multilínea MultiLine m, el principio es modificar el significado del
modo de línea única ^ y $ SingleLine s, que corresponde a MultiLine

El logo introvertido puede definir opciones de coincidencia con una intensidad menor (un grupo de unidades)

Método estático

Coincidir （System.Text.RegularExpressions）

El método estático Match utiliza las opciones de coincidencia especificadas para buscar la primera coincidencia de la expresión regular especificada en la cadena de entrada. Devuelve un objeto que contiene información sobre la coincidencia. También hay tres métodos sobrecargados con los mismos parámetros que el método IsMatch. Además, en la clase Regex, hay un método no estático con el mismo nombre, que es más eficiente cuando es adecuado para varias instancias.
Match Match (entrada de cadena, patrón de cadena);
Match Match (entrada de cadena, patrón de cadena, opciones de RegexOptions);
Match Match (entrada de cadena, patrón de cadena, opciones de RegexOptions, TimeSpan matchTimeout);

Coincidencias （System.Text.RegularExpressions）

El método estático Matches busca todas las coincidencias de la expresión regular especificada en la cadena de entrada especificada. La diferencia con el método anterior es que este método devuelve todas las coincidencias. También tiene tres métodos sobrecargados y los parámetros son exactamente los mismos que los del método Match.

MatchCollection Matches(string input, string pattern);
MatchCollection Matches(string input, string pattern, RegexOptions options);
MatchCollection Matches(string input, string pattern, RegexOptions options, TimeSpan matchTimeout);

Reemplaza 函数 （System.Text.RegularExpressions）

Sabemos que las expresiones regulares se utilizan principalmente para verificar, extraer, dividir y reemplazar caracteres. La función Reemplazar implementa la función de reemplazo.
1) Reemplazar (entrada de cadena, patrón de cadena, reemplazo de cadena)
// la entrada es la cadena de origen, el patrón es Condiciones coincidentes, el reemplazo es el contenido del reemplazo, que consiste en convertir en él el contenido que cumple con el patrón de condiciones coincidentes. Por
ejemplo, string result = Regex.Replace ("abc", "ab", "##");
/ / El resultado es ## c, es reemplazar el ab en la cadena abc con ##
2) Reemplazar (entrada de cadena, patrón de cadena, reemplazo de cadena, opciones de RegexOptions)
// RegexOptions es un tipo enumerado, usado para hacer algunos ajustes.
// Use comentarios al frente RegexOptions.IgnorePatternWhitespace se usa al hacer coincidir. Si ignora el caso al hacer coincidir, puede usar RegexOptions.IgnoreCase,
como string result = Regex.Replace ("ABc", "ab", "##" , RegexOptions.IgnoreCase);
si es simple El reemplazo se puede lograr con las dos funciones anteriores. Pero si hay algunos reemplazos complejos, como hacer coincidir una gran cantidad de contenido, es necesario reemplazar contenido diferente con caracteres diferentes. utilizar las siguientes dos funciones

3) Reemplazar (entrada de cadena, patrón de cadena, evaluador MatchEvaluator);
// evaluador es un proxy, de hecho, es simplemente un puntero de función, y una función se usa como parámetro.
// Debido a que no hay puntero en C #, use el proxy para implementar funciones similares Puede usar funciones de enlace de proxy para especificar el reemplazo complejo que desea implementar.

4) Reemplazar (entrada de cadena, patrón de cadena, evaluador MatchEvaluator, opciones de RegexOptions);
// Las funciones anteriores en esta función son las mismas, excepto que hay un poco más de tipo de enumeración para especificar si ignorar el caso y otras configuraciones

Dividir texto dividido

Utilice la posición de coincidencia de expresión regular para dividir el texto en una matriz de cadenas. También hay tres métodos sobrecargados, y el valor de retorno es una matriz de
cadenas string [] Split (entrada de cadena, patrón de cadena);

string [] Split (entrada de cadena, patrón de cadena, opciones de RegexOptions);

cadena [] División (entrada de cadena, patrón de cadena, opciones de RegexOptions, TimeSpan matchTimeout);

@símbolo

A menudo agregamos el carácter @ delante de la cadena de expresión regular, para que el compilador no pueda analizar el carácter de escape, pero existe como la gramática (metacarácter) de la expresión regular.

cadena s = @ “www.baidu.com \ n lkjsdflkj”;

Metacarácter de ancla

A menudo agregamos el carácter @ delante de la cadena de expresión regular, para que el compilador no pueda analizar el carácter de escape, pero existe como la gramática (metacarácter) de la expresión regular.
Descripción del carácter
\ b coincide con el principio o el final de una palabra
\ B coincide con el comienzo o el final de una palabra que no es una palabra
^ La coincidencia debe aparecer al principio de la cadena o al principio de la línea
$ La coincidencia debe aparecer en las siguientes posiciones : el final de la cadena, el \ al final de la cadena n antes o al final de la línea.
\ A Especifica que la coincidencia debe aparecer al principio de la cadena (ignorando la opción Multilínea).
\ z Especifica que la coincidencia debe aparecer al final de la cadena (ignorando la opción Multilínea).
\ z Especifica que la coincidencia debe ocurrir al final de la cadena o antes de \ n al final de la cadena (ignorando la opción Multilínea).
\ G especifica que la coincidencia debe aparecer al final de la coincidencia anterior. Cuando se usa con Match.NextMatch (), esta aserción asegura que todas las coincidencias sean continuas.

Ejemplo 1: Inicio de la configuración de la zona ^
string str = "Soy gato azul";
Console.WriteLine (Regex.Replace (str, "^", "Listo para comenzar:"));

Ejemplo 2: El principio y el final de la zona $
string str = "Soy gato azul";
Console.WriteLine (Regex.Replace (str, "$", "¡Se acabó!"));

Metacaracteres de sintaxis básica

Descripción del carácter
. Coincidir con cualquier carácter excepto el salto de línea
\ w Coincidir con letras, números, guiones bajos, caracteres chinos (refiriéndose a letras mayúsculas y minúsculas, números 0-9, guión bajo_)
\ W \ w complemento (excepto para "letras mayúsculas y minúsculas, 0 -9 dígitos, excepto el subrayado _ ")
\ s coincide con cualquier carácter en blanco (incluido el salto de línea / n, el retorno de carro / r, el carácter de tabulación / t, el carácter de tabulación vertical / v, el carácter de alimentación de formulario / f)
\ S El complemento de \ s (excepto los caracteres definidos por \ s)
\ d coincide con dígitos (0-9 dígitos)
\ D representa el complemento de \ d (excepto 0-9 dígitos)

En expresiones regulares, \ es un carácter de escape. * Es un meta carácter. Si desea representar un carácter \. *, Debe utilizar \. *

Ejemplo 1: Solo se permiten números en la
cadena de verificación strCheckNum1 = "23423423a3", strCheckNum2 = "324234";
Console.WriteLine ("Match string" + strCheckNum1 + "Si es un número:" + Regex.IsMatch (strCheckNum1, @ " ^ \ d * Error de análisis de KaTeX: Secuencia de control no definida: \ d en la posición 91:… rCheckNum2, @ "^ \ ̲d̲ * "));

Ejemplo 2: Marcar solo permite ingresar cualquier
cadena excepto letras mayúsculas y minúsculas, números del 0 al 9 y guión bajo _. StrCheckStr1 = "abcds_a", strCheckStr2 = " && (((((2", strCheckStr3 = " && (((( ";
string regexStr = @" ^ \ W * $ ";
Console.WriteLine (" cadena coincidente "+ strCheckStr1 +" ¿Es cualquier carácter excepto letras mayúsculas y minúsculas, números del 0 al 9 y guión bajo_: "+ Regex.IsMatch (strCheckStr1, regexStr));
Console.WriteLine ("cadena coincidente" + strCheckStr2 + "si es cualquier carácter excepto letras mayúsculas y minúsculas, números del 0 al 9 y subrayado_:" + Regex.IsMatch (strCheckStr2, regexStr)) ;
Console.WriteLine ("cadena coincidente" + strCheckStr3 + "si se trata de cualquier carácter excepto letras mayúsculas y minúsculas, números del 0 al 9 y subrayado_:" + Regex.IsMatch (strCheckStr3, regexStr));

Antónimo

Descripción del carácter
\ W Complemento de \ w (excepto "letras mayúsculas y minúsculas, números 0-9, guión bajo_")
\ S Complemento de \ s (excepto los caracteres definidos por \ s)
\ D significa \ d El complemento de (excepto 0 -9 dígitos)
\ B coincide con la posición que no es el principio o el final de una palabra
[ab] coincide con el carácter entre corchetes
[ac] el carácter entre ayc es un carácter
[^ x] coincide excepto x Cualquier carácter otro que
[^ adwz] coincide con cualquier carácter excepto adwz

// Ejemplo: Buscar todas las
cadenas de caracteres excepto ahou strFind1 = "¡Soy un gato!", StrFind2 = "¡El gato azul de mi nombre!";
Console.WriteLine ("Todos los caracteres excepto ahou, caracteres originales para:" + strFind1 + "Después reemplazo: "+ Regex.Replace (strFind1, @" [^ ahou] "," "));
Console.WriteLine (" Todos los caracteres excepto ahou, los caracteres originales son: "+ strFind2 +" Después del reemplazo: "+ Regex. Reemplazar (strFind2, @ "[^ ahou]", " "));

Repetir descripción de caracteres

Descripción del carácter
{n} Coincide con el carácter anterior n veces
{n,} Coincide con el carácter anterior n veces o más de n veces
{n, m} ¿Coincide con el carácter anterior nam veces
? Repita cero o una vez

• Repite una o más veces

• Repetir cero o más veces

Ejemplo: Verifique si el contenido de entrada es un número QQ legal (Nota: el número QQ tiene 5-12 dígitos)
cadena isQq1 = "1233", isQq2 = "a1233", isQq3 = "0123456789123", isQq4 = "556878544";
cadena regexQq = @ "^ \ d {5,12} $";
Console.WriteLine (isQq1 + "¿Es un número QQ legal (5-12 dígitos):" + Regex.IsMatch (isQq1, regexQq));
Console.WriteLine (isQq2 + "¿Es un número QQ legal (5-12 dígitos):" + Regex.IsMatch (isQq2, regexQq));
Console.WriteLine (isQq3 + "Es un número QQ legal (5-12 dígitos):" + Regex .IsMatch (isQq3, regexQq));
Console.WriteLine (isQq4 + "¿Es un número QQ legal (5-12 dígitos):" + Regex.IsMatch (isQq4, regexQq));

Partido alternativo

Descripción de carácter
| Realiza una operación lógica "o" (O) en dos condiciones coincidentes.

Ejemplo 1: Buscar números o letras
string findStr1 = "ad (d3) -df";
string regexFindStr = @ "[az] | \ d";
string newStrFind = String.Empty;
MatchCollection newStr = Regex.Matches (findStr1, regexFindStr) ;
newStr.Cast (). Select (m => m.Value) .ToList (). ForEach (i => newStrFind + = i);
Console.WriteLine (findStr1 + La nueva cadena de letras y números en "es:" + newStrFind);
Ejemplo 2: Muestra el nombre de una persona ("zhangsan; lisi, wangwu.zhaoliu")
string strSplit = "zhangsan; lisi, wangwu.zhaoliu";
string regexSplitstr = @ "[;] | [,] | [.] ";
Regex.Split (strSplit, regexSplitstr) .ToList (). ForEach (i => Console.WriteLine (i));

Agrupar expresiones regulares ()

Utilice paréntesis para especificar la subexpresión (también denominada agrupación)
Ejemplo 1: caracteres individuales repetidos y caracteres de agrupación repetidos
Console.WriteLine ("Introduzca una cadena arbitraria para probar la agrupación:");
cadena inputStr = Console.ReadLine ();
cadena strGroup1 = @ "a {2}";
Console.WriteLine ("Un solo carácter repite 2 dos veces y se reemplaza con 22, el resultado es:" + Regex.Replace (inputStr, strGroup1, "22"));
// Repetir uso múltiple (abcd) {n} para agrupar la
cadena de restricción strGroup2 = @ "(ab \ w {2}) {2}";
Console.WriteLine ("Repita 2 para agrupar caracteres dos veces y reemplácelos con 5555, el resultado es:" + Regex .Replace (inputStr, strGroup2, "5555"));
Ejemplo 2: Verifique la dirección IP4 (como: 192.168.1.4, cuatro segmentos, cada segmento tiene un máximo de tres dígitos, cada segmento tiene un número máximo de 255 y el primer dígito no puede ser 0)
string regexStrIp4 = @ "^ (((2 [0-4] \ d | 25 [0-5] | [01]? \ d \ d?).) {3} (2 [ 0-4] \ d | 25 [0-5] | [01]? \ D \ d?)) $ ";
Console.WriteLine (" Ingrese una dirección IP4: ");
string inputStrIp4 = Console.ReadLine () ;
Console.WriteLine (inputStrIp4 + "¿Es una dirección IP4 legal:" + Regex.IsMatch (inputStrIp4, regexStrIp4));
Console.WriteLine ("Ingrese una dirección IP4:");
string inputStrIp4Second = Console.ReadLine ();
Console .WriteLine (inputStrIp4 + "¿Es una dirección IP4 legal:" + Regex.IsMatch (inputStrIp4Second, regexStrIp4));