Préface
"Si vous n'accumulez pas de pas, vous ne pouvez pas atteindre mille kilomètres; si vous n'accumulez pas de petits courants, vous ne pouvez pas devenir une rivière"
12 avril 2019
(1) Correspondance des caractères et des index. Et enfin remplacer le personnage correspondant
MatchCollection accède à chaque membre de l'objet en récupérant la valeur de l'attribut de la collection. En même temps, à l'aide de la classe Match et de la classe MatchCollection, vous pouvez obtenir les détails de chaque correspondance obtenue via une expression régulière.
static void Main(string[] args)
{
//匹配字符，并索引出来，然后将它调换（查找替换）
string input = "a nihao haha shazi set" + "my name is ligang";
Console.WriteLine(input);
MatchCollection mc = Regex.Matches(input, @"ligang");
Console.WriteLine("共找到" + mc.Count + "个匹配");
foreach (Match s in mc)
{
Console.WriteLine("在索引" + s.Index + "处发现：" + s.Value);
}
Console.WriteLine("请输入要修改的字符值");
string names = Console.ReadLine();
string newname = Regex.Replace(input, "ligang", names);
Console.WriteLine("已经成功\n" + newname);
Console.ReadLine();
}
13 avril 2019
(2) Utilisation du groupe de symboles correspondant 1A2B3C4D [0] cartouche [0]
//要匹配的字符
string arr = "1A 2B 3C 4D ffee80 #80050";
//正则表达式
string zebds = @"((\d+)([a-z]))\s+";
//使用RegexOption.IgnorreCase枚举值表示不区分大小
Regex r = new Regex(zebds,RegexOptions.IgnoreCase);
//开始匹配字符串仅返回一次匹配结果
Match m = r.Match(arr);
//循环
while (m.Success) {
//显示匹配开始处索引值和匹配到的值
System.Console.WriteLine("Match=["+m+"]");
CaptureCollection cc = m.Captures;
foreach (Capture c in cc)
{
Console.WriteLine("\tCapture=["+c+"]");
}
for (int i = 0; i < m.Groups.Count; i++)
{
Group group = m.Groups[i];
System.Console.WriteLine("\t\tGroups[{0}]=[{1}]", i, group);
for (int j = 0; j < group.Captures.Count; j++)
{
Capture capture = group.Captures[j];
Console.WriteLine("\t\t\tCapture[{0}]=[{1}]", j, capture);
}
}
m = m.NextMatch();
}
Console.ReadLine();
18 avril 2019
(3) Utilisation simple des mathématiques
1) Arrondir à un entier, tant que le point décimal est supérieur à 0,1 (la limite maximale de la valeur est renvoyée)
Console.WriteLine(Math.Ceiling(32.1));
2) Arrondir à un entier, rejeter les décimales à un entier
Console.WriteLine(Math.Ceiling(32.1));
3) [32,100] Comparez les deux nombres avec la valeur minimale min (valeur maximale max)
Console.WriteLine(Math.Min(32,100));
4) Prenez le quotient de deux nombres
Console.WriteLine(Math.DivRem(50, 2, out int a));
5) Prenez la valeur absolue du nombre
Console.WriteLine(Math.Abs(-65));
6) Si le nombre est égal
Console.WriteLine(Math.Equals(10,10)); //取该数是否相等
13 avril 2019
(4) Append (), Insert (), Remove () de la classe StringBuilder sont simples à utiliser
string Digit = "张三";
StringBuilder SB = new StringBuilder(Digit);
Console.WriteLine(SB.Append("你好")); //显示“Append”张三你好，追加字符（添加）
Console.WriteLine(SB.Insert(2,"傻子")); //显示“Insert”张三傻子你好（从第几个字符开始插入，插入什么）
Console.WriteLine(SB.Insert(2, "傻子", 3)); //（从第几个字符开始插入，插入什么，插入几遍）
Console.WriteLine(SB.Remove(2,8)); //显示“Remove”张三你好，删除（从第几个开始删除，删除几个）
Console.WriteLine(SB.ToString()); //显示“Digit”字符串，表示当前对象
20 avril 2019
(5) Utilisation simple des classes Regex et des expressions régulières
1) Vérifiez que les lettres ne sont pas sensibles à la casse
public bool VerifyLetter(string input)
{
if (!Regex.IsMatch(input, @"^[A-Za-z]+$", RegexOptions.IgnoreCase))
return false;else return true;
}
2) Vérifiez la date de naissance valide
protected bool DateTimebool(string vale)
{
if (!DateTime.TryParse(vale, out DateTime Reult))
{
return false;
}
else
{
return true;
}
}
3) Vérifiez que le numéro de téléphone commençant par 1 [358] est valide
protected bool NumIPhone(string value)
{
Regex regx = new Regex(@"^1[358]\d{9}$", RegexOptions.Multiline);
if (!regx.IsMatch(value))
{
return false;
}
else
{
return true;
}
}
4) L'utilisation d'IsMath comme la possession de Regex reg = new Regex ("123456");
Si IsMatch () "contient" 123456 "dans cette chaîne, la valeur de retour est true / false.
//
bool b = a.IsMatch("你好你好123456");
"Match" correspond si "123456" est inclus, et si c'est le cas, il sera extrait.
var c = a.Match("你好你好哈哈123456");
Le type Var ici est un type inféré fortement typé, et il inférera et déterminera de quel type il est basé sur la valeur de droite.
string arr = " 15173381510* ";
string d= arr.Replace("*", "#"); //“Replace”将里面字符调换，（“要调换的”，“调换值”）
string o = arr.Trim(); //“Trim”将字符串内的前后空格给删除
Regex aa = new Regex("151"); //查找“151”
var dd = aa.Replace(arr, "999", 2, 3); //（字符源，替换值，偷换几次，从第几个字符开始替换）
string pp = arr.Insert(0, "插入"); //“Insert”插入（从第几个字符开始插入，插入的值）
string letter = "AbCd";
Console.WriteLine(Regex.IsMatch(letter,"abcd",RegexOptions.IgnoreCase)); //静态验证是否有“abcd”字符，忽略大小写
Méthodes couramment utilisées de la classe RegEx
Méthode de correspondance statique
À l'aide de la méthode de correspondance statique, vous pouvez obtenir la première sous-chaîne continue du modèle correspondant dans la source.
La méthode Match a deux surcharges statiques, sont
Regex.Match (INPUT String, String pattern);
Regex.Match (INPUT String, String pattern, the RegexOptions Options);
un premier paramètre de surcharge représente: un mode d'entrée
de Deux représentations de paramètres surchargées : entrée, mode et combinaison «OU bit à bit» de l'énumération RegexOptions.
Les valeurs valides de l'énumération RegexOptions sont:
Complied signifie que ce mode est compilé.
CultureInvariant signifie que l'arrière-plan culturel n'est pas pris en compte.
ECMAScript signifie qu'il est conforme à ECMAScript. Cette valeur ne peut être utilisée qu'avec IgnoreCase, Multiline et Complied.
ExplicitCapture signifie que seuls les groupes nommés explicitement sont enregistrés.
IgnoreCase signifie que l'entrée explicitement nommée n'est pas distinguée. Case
IgnorePatternWhitespace signifie supprimer l'espace blanc non échappé dans le modèle et activer le commentaire marqué par #.
Multiligne signifie mode multiligne. Changer la signification des métacaractères ^ et $. Ils peuvent correspondre au début et à la fin de la ligne.
Aucun signifie aucun paramètre. Cela n'a pas de sens.
RightToLeft signifie balayer et faire correspondre de droite à gauche. Pour le moment, la méthode de correspondance statique renvoie la première correspondance de droite à gauche.
Simple ligne signifie mode ligne unique. Modifiez la signification des métacaractères. Elle peut correspondre aux caractères de nouvelle ligne.
Remarque: Multiline peut être utilisé avec Singleline sans ECMAScript. Singleline et Multiline ne sont pas mutuellement exclusifs, mais s'excluent mutuellement avec ECMAScript.
Méthode des correspondances statiques
La forme surchargée de cette méthode est la même que la méthode statique Match, renvoyant un MatchCollection, qui représente l'ensemble des modèles correspondants dans l'entrée.
Méthode IsMatch statique
Cette méthode renvoie un booléen, la forme surchargée est la même que les correspondances statiques, si l'entrée correspond au modèle, elle retourne true, sinon elle retourne false.
Cela peut être compris comme suit: La méthode IsMatch renvoie si la collection retournée par la méthode Matches est vide.
20 avril 2019
(5) Méthodes couramment utilisées de la classe Datetime
Console.WriteLine("第"+DateTime.Now.Month+"月"); //显示今天第几月
Console.WriteLine(DateTime.Now.ToString()); //2019/4/12显示年月份加时间
//显示2019年4月星期5
Console.WriteLine(DateTime.Now.Year+"年"+DateTime.Now.Month+"月"+"星期"+Convert.ToInt16 (DateTime.Now.DayOfWeek));
Console.WriteLine(string.Format("{0:C}",10000)); //￥10,000.00
Console.WriteLine("购票时间{0}",DateTime.Now.ToShortTimeString()); //购票时间20:36
Console.WriteLine(DateTime.Now.ToLongDateString()); //2019年4月
Console.WriteLine(DateTime.Now.AddDays(-1)); //获取昨天日期
Console.WriteLine(DateTime.Now.AddYears(1)); //获取明年今日