我有一个表示“帐号”的字段，该字段大多数时候都不是数字。我需要对这些“数字”进行一些自动递增。显然不适合做数学。我们决定对我们有用的规则是，我们想要找到最右边的一组数字并将它们自动递增 1并返回重建的字符串（即使这使它变长了一个字符）。
这些数字的一些示例是：
我正在使用 C#/.NET 4.0。我将 Regex 列为标签，但这不是必需的。此解决方案不必在正则表达式中。
关于这样做的好方法有什么想法吗？理想的性能不是主要问题。我宁愿为此提供清晰且易于理解/维护的代码，除非它全部包含在正则表达式中。
谢谢！
var src = "ap45245jpb1234h";
var match = Regex.Match(src, @"(?<=(\D|^))\d+(?=\D*$)");
if(match.Success)
{
var number = int.Parse(match.Value) + 1;
var newNum=string.Format(
"{0}{1}{2}",
src.Substring(0,match.Index),
number,
src.Substring(match.Index + match.Length));
newNum.Dump(); //ap45245jpb1235h
}
解释正则表达式：从（字符串的开头）或（非数字）开始，匹配一个或多个数字，后跟零个或多个非数字，然后是字符串的结尾。
当然，如果提取的数字有前导零，事情就会出错。我将把这个作为练习留给读者。
使用 MatchEvaluator （正如@LB 在他们的回答中所建议的那样），这变得更轻了：
Regex.Replace(
src,
@"(?<=(\D|^))\d+(?=\D*$)",
m => (int.Parse(m.Value)+1).ToString())
如果我理解正确，您想在某个字符串中最右边的数字上加一。
您可以按照其他人的建议使用正则表达式，但是由于您正在尝试做一些非常具体的事情，因此正则表达式将证明比仅仅为您所做的实现算法要慢。
您可以针对 Regex 解决方案对此进行测试，并亲眼看看这会快得多：
我跑了 100 万次，并用秒表计时。
结果：
正则表达式 - 10,808,533 滴答
我的方式 - 253,355 滴答声
大约快 40 倍！！！
结论：针对特定问题的特定解决方案。
我的方式快了很多。
这是代码：
// Goes through a string from end to start, looking for the last digit character.
// It then adds 1 to it and returns the result string.
// If the digit was 9, it turns it to 0 and continues,
// So the digit before that would be added with one.
// Overall, it takes the last numeric substring it finds in the string,
// And replaces it with itself + 1.
private static unsafe string Foo(string str)
{
var added = false;
fixed (char* pt = str)
{
for (var i = str.Length - 1; i >= 0; i--)
{
var val = pt[i] - '0';
// Current char isn't a digit
if (val < 0 || val > 9)
{
// Digits have been found and processed earlier
if (added)
{
// Add 1 before the digits,
// Because if the code reaches this,
// It means it was something like 999,
// Which should become 1000
str = str.Insert(i + 1, "1");
break;
}
continue;
}
added = true;
// Digit isn't 9
if (val < 9)
{
// Set it to be itself + 1, and break
pt[i] = (char)(val + 1 + '0');
break;
}
// Digit is 9. Set it to be 0 and continue to previous characters
pt[i] = '0';
// Reached beginning of string and should add 1 before digits
if (i == 0)
{
str = str.Insert(0, "1");
}
}
}
return str;
}
假设您不想替换 1 位数字。
string input = "GS3R2C1234g";
var output = Regex.Replace(input, @"\d{2,}$*", m => (Convert.ToInt64(m.Value) + 1).ToString());
我建议如下：
string IncrementAccountNumber(string accountNumber)
{
var matches = Regex.Matches(accountNumber, @"\d+");
var lastMatch = matches[matches.Count - 1];
var number = Int32.Parse(lastMatch.Value) + 1;
return accountNumber.Remove(lastMatch.Index, lastMatch.Length).Insert(lastMatch.Index, number.ToString());
}
你可以使用这样的正则表达式：
(\d*)
这将使用Matches 方法对所有数字进行分组。然后，您可以获取最后一组并从该组进行修改。
然后你可以使用匹配索引和长度来重建你的字符串。
string input = "GS3R2C1234g";
string pattern = @"(\d*)";
var matches = Regex.Matches(input, pattern);
var lastMatch = matches[matches.Length - 1];
var value = int.Parse(lastMatch.Value);
value++;
var newValue = String.Format("{0}{1}{2}"input.Substring(0,lastMatch.Index),
value, input.Substring(lastMatch.Index+lastMatch.Length));
我没有进行错误检查。我将由您决定
如果您想要一个将结果拼接在一起的简单正则表达式：
private static readonly Regex _ReverseDigitFinder = new Regex("[0-9]+", RegexOptions.RightToLeft);
public static string IncrementAccountNumber(string accountNumber) {
var lastDigitsMatch = _ReverseDigitFinder.Match(accountNumber);
var incrementedPart = (Int64.Parse(lastDigitsMatch.Value) + 1).ToString();
var prefix = accountNumber.Substring(0, lastDigitsMatch.Index);
var suffix = accountNumber.Substring(lastDigitsMatch.Index + lastDigitsMatch.Length);
return prefix + incrementedPart + suffix;
}
笔记：
如果你想使用 LINQ：
private static readonly Regex _ReverseAccountNumberParser = new Regex("(?<digits>[0-9]+)|(?<nonDigits>[^0-9]+)", RegexOptions.RightToLeft);
public static string IncrementAccountNumber(string accountNumber) {
bool hasIncremented = false;
return String.Join("",
_ReverseAccountNumberParser
.Matches(accountNumber)
.Cast<Match>()
.Select(m => {
var nonDigits = m.Groups["nonDigits"].Value;
if(nonDigits.Length > 0) {
return nonDigits;
}
var digitVal = Int64.Parse(m.Groups["digits"].Value);
if(!hasIncremented) {
digitVal++;
}
hasIncremented = true;
return digitVal.ToString();
})
.Reverse());
}
对于它的价值，我最初不小心误读了这个，并认为你想要进位（即“A3G999 -> A4G000”）。这更有趣并且需要进位状态：
public static string IncrementAccountNumberWithCarry(string accountNumber) {
bool hasIncremented = false;
bool needToCarry = false;
var result = String.Join("",
_ReverseAccountNumberParser
.Matches(accountNumber)
.Cast<Match>()
.Select(m => {
var nonDigits = m.Groups["nonDigits"].Value;
if (nonDigits.Length > 0) {
return nonDigits;
}
var oldDigitVal = m.Groups["digits"].Value;
var digitVal = Int64.Parse(oldDigitVal);
if(needToCarry) {
digitVal++;
}
if (!hasIncremented) {
digitVal++;
hasIncremented = true;
}
var newDigitVal = digitVal.ToString();
needToCarry = newDigitVal.Length > oldDigitVal.Length;
if(needToCarry) {
newDigitVal = newDigitVal.Substring(1);
}
return newDigitVal;
})
.Reverse());
if(needToCarry) {
result = "1" + result;
}
return result;
}
测试用例：
Debug.Assert(IncrementAccountNumber("AC1234") == "AC1235");
Debug.Assert(IncrementAccountNumber("GS3R2C1234") == "GS3R2C1235");
Debug.Assert(IncrementAccountNumber("1234") == "1235");
Debug.Assert(IncrementAccountNumber("A-1234") == "A-1235");
Debug.Assert(IncrementAccountNumber("AC1234g") == "AC1235g");
Debug.Assert(IncrementAccountNumber("GS3R2C1234g") == "GS3R2C1235g");
Debug.Assert(IncrementAccountNumber("1234g") == "1235g");
Debug.Assert(IncrementAccountNumber("A-1234g") == "A-1235g");
Debug.Assert(IncrementAccountNumber("999") == "1000");
Debug.Assert(IncrementAccountNumber("GS3R2C9999g") == "GS3R2C10000g");
Debug.Assert(IncrementAccountNumberWithCarry("GS3R2C9999g") == "GS3R3C0000g");
Debug.Assert(IncrementAccountNumberWithCarry("999") == "1000");
string[] src = { "AC1234", "GS3R2C1234", "1234", "A-1234", "AC1234g",
"GS3R2C1234g", "1234g", "A-1234g", "999", "GS3R2C9999g" };
foreach (string before in src)
{
string after = Regex.Replace(before, @"\d+(?=\D*$)",
m => (Convert.ToInt64(m.Value) + 1).ToString());
Console.WriteLine("{0} -> {1}", before, after);
}
输出：
AC1234 -> AC1235
GS3R2C1234 -> GS3R2C1235
1234 -> 1235
A-1234 -> A-1235
AC1234g -> AC1235g
GS3R2C1234g -> GS3R2C1235g
1234g -> 1235g
A-1234g -> A-1235g
999 -> 1000
GS3R2C9999g -> GS3R2C10000g
笔记：
@LB 使用 lambda 表达式作为 MatchEvaluator FTW！
从@spender 的回答来看，前瞻 - (?=\D*$)- 确保只有最后一组数字匹配（但后瞻 - (?<=(\D|^))- 不需要）。
@JeffMoser 使用的 RightToLeft 选项允许它首先匹配最后一组数字，但没有静态Replace方法允许您 (1) 指定 RegexOptions，(2) 使用 MatchEvaluator，以及 (3) 限制替换的数量. 您必须先实例化一个 Regex 对象：
string[] src = { "AC1234", "GS3R2C1234", "1234", "A-1234", "AC1234g",
"GS3R2C1234g", "1234g", "A-1234g", "999", "GS3R2C9999g" };
foreach (string before in src)
{
Regex r = new Regex(@"\d+", RegexOptions.RightToLeft);
string after = r.Replace(before, m => (Convert.ToInt64(m.Value) + 1).ToString(), 1);
Console.WriteLine("{0} -> {1}", before, after);
}
输出：
AC1234 -> AC1235
GS3R2C1234 -> GS3R2C1235
1234 -> 1235
A-1234 -> A-1235
AC1234g -> AC1235g
GS3R2C1234g -> GS3R2C1235g
1234g -> 1235g
A-1234g -> A-1235g
999 -> 1000
GS3R2C9999g -> GS3R2C10000g
您可以尝试使用String.Split. 你可以使用类似的东西：
NameSplit=AccountNumber.split(new Char[] {'a','b','....'z'});
然后你可以在数组上循环找到最后一个数字（从NameSplit.length到循环1，第一个数字由 找到Int32.TryParse），增加该数字，然后再次将数组连接在一起String.Concat。
它可能比 RegEx 效率低，但我认为对于不了解 RegEx 的人来说更容易理解。