Javascript 与类似Excel的引用单元格匹配的正则表达式

我正在尝试创建一个正则表达式，该正则表达式只匹配a-Z（包括a-Z）范围内的字母以及0-100（包括a-Z）范围内的数字。如果在我的正则表达式之前有任何数字，我不希望它匹配。例如：5A1不应匹配，因为它前面有数字5，即使A1在字符串中。同样，如果在该范围之后有任何数值，比如A10000，我不希望它匹配（不应该匹配，因为1000在100之外）

下面展示了我试图匹配的内容：

A34A1//不匹配
5A1//不匹配
2.344A1//不匹配
A1001//不匹配
A1//匹配A1
A10//匹配A10
A100//匹配A100
求和（A1:A2）//匹配A1和A2
求和（A1:A2，5A1，A3）//匹配A1，A2，A3

我一直在尝试这些正则表达式，但不确定如何排除该范围之前或之后的任何数字：

/[A-Z]{1,2}[1-9]{0,3}/g
/（[^0-9]）[A-Z]{1,2}[0-9]{1,3}/g

给你：

(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])

$1

将保留您的比赛

用法示例：

var re = /(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])/gim; 

解释 它必须是行的开头，或者不是数字：

(?:^|[^0-9])

然后，您有一个或两个字母后跟100或一个或两个数字：

([A-Z](?:100|[0-9]?[0-9]))

那么它必须是你的行尾或者不是字母/数字的东西：

(?=$|[^0-9A-Z])

给你：

(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])

$1

将保留您的比赛

用法示例：

var re = /(?:^|[^0-9])([A-Z](?:100|[0-9][0-9]?))(?=$|[^0-9A-Z])/gim; 

解释 它必须是行的开头，或者不是数字：

(?:^|[^0-9])

然后，您有一个或两个字母后跟100或一个或两个数字：

([A-Z](?:100|[0-9]?[0-9]))

那么它必须是你的行尾或者不是字母/数字的东西：

(?=$|[^0-9A-Z])

匹配A1、A2、Z100 但不是A101或A1000

([A-Z](\d{1,2}(?!\d)|100))

SUM(.*)

• 注：如果没有

  （？！\d）

  ，“A1000”将被识别为“A100”

以和开头（以和结尾）

SUM(.*)

可以有任意数量的“：”或“，”集合，后跟可选空格和可选数字 匹配和（A1:A2，5A1，A3）

匹配A1、A2、Z100 但不是A101或A1000

([A-Z](\d{1,2}(?!\d)|100))

SUM(.*)

• 注：如果没有

  （？！\d）

  ，“A1000”将被识别为“A100”

以和开头（以和结尾）

SUM(.*)

可以有任意数量的“：”或“，”集合，后跟可选空格和可选数字 匹配和（A1:A2，5A1，A3）

---

这不应该比这更复杂

/^[A-Z](\d\d?|100)$/

---

这不应该比这更复杂

/^[A-Z](\d\d?|100)$/

使用此正则表达式：

/\b[A-Z]([0-9]{1,2}|100)\b/

或更简单的等效物：

/\b[A-Z]([0-9][0-9]?|100)\b/

/\b[A-Z](\d\d?|100)\b/

或更短的数字元字符等价物：

/\b[A-Z]([0-9][0-9]?|100)\b/

/\b[A-Z](\d\d?|100)\b/

在正则表达式的开头和结尾使用

\b

元字符，可以消除任何不需要的前置或尾随字符。

[A-Z]

字符类仅包含一个大写字母来开始单元格引用。数字部分由

0-99

或

100

交替处理，其中

0-99

部分由一到两位字符类处理。如果您喜欢的话，\d元字符也可以代替显式的

[0-9]

字符类

下面是一个示例Ruby程序（类似于Javascript的regex风格），展示了它的工作原理：

data = [
  [ "A34A1",   false ],
  [ "5A1",     false ],
  [ "2.344A1", false ],
  [ "A1001",   false ],
  [ "A1",      true ],
  [ "A10",     true ],
  [ "A100",    true ],
  [ "SUM(A1:A2)", true ],
  [ "SUM(A1:A2, 5A1, A3)", true ]
]

data.each do |pair|
  puts "#{pair[1] == !(pair[0] =~ /\b[A-Z]([0-9]{1,2}|100)\b/).nil? ? 'Pass' : 'Fail'}: '#{pair[0]}'"
end

在

数据

数组中，每对的第二个元素是布尔值，用于确定测试单元引用是否应匹配

运行此程序的输出显示所有测试均通过：

> ruby regex_test.rb
Pass: 'A34A1'
Pass: '5A1'
Pass: '2.344A1'
Pass: 'A1001'
Pass: 'A1'
Pass: 'A10'
Pass: 'A100'
Pass: 'SUM(A1:A2)'
Pass: 'SUM(A1:A2, 5A1, A3)'

使用此正则表达式：

/\b[A-Z]([0-9]{1,2}|100)\b/

或更简单的等效物：

/\b[A-Z]([0-9][0-9]?|100)\b/

/\b[A-Z](\d\d?|100)\b/

或更短的数字元字符等价物：

/\b[A-Z]([0-9][0-9]?|100)\b/

/\b[A-Z](\d\d?|100)\b/

在正则表达式的开头和结尾使用

\b

元字符，可以消除任何不需要的前置或尾随字符。

[A-Z]

字符类仅包含一个大写字母来开始单元格引用。数字部分由

0-99

或

100

交替处理，其中

0-99

部分由一到两位字符类处理。如果您喜欢的话，\d元字符也可以代替显式的

[0-9]

字符类

下面是一个示例Ruby程序（类似于Javascript的regex风格），展示了它的工作原理：

data = [
  [ "A34A1",   false ],
  [ "5A1",     false ],
  [ "2.344A1", false ],
  [ "A1001",   false ],
  [ "A1",      true ],
  [ "A10",     true ],
  [ "A100",    true ],
  [ "SUM(A1:A2)", true ],
  [ "SUM(A1:A2, 5A1, A3)", true ]
]

data.each do |pair|
  puts "#{pair[1] == !(pair[0] =~ /\b[A-Z]([0-9]{1,2}|100)\b/).nil? ? 'Pass' : 'Fail'}: '#{pair[0]}'"
end

在

数据

数组中，每对的第二个元素是布尔值，用于确定测试单元引用是否应匹配

运行此程序的输出显示所有测试均通过：

> ruby regex_test.rb
Pass: 'A34A1'
Pass: '5A1'
Pass: '2.344A1'
Pass: 'A1001'
Pass: 'A1'
Pass: 'A10'
Pass: 'A100'
Pass: 'SUM(A1:A2)'
Pass: 'SUM(A1:A2, 5A1, A3)'

r=/
(?
这句话通常是这样写的：

r = /(?<!\d)[A-Z](?:\d{1,2}|100)(?!\d)/

test = ["A34A1", "5A1", "2.344A1", "A1001", "A1", "A10", "A100",
        "SUM(A1:A2, 5A1, A3)", "A100A", "_A1", "A1_"] 

test.each { |s| puts "#{s} -> #{s.scan(r)}" }
A34A1               -> ["A34"]
5A1                 -> []
2.344A1             -> []
A1001               -> []
A1                  -> ["A1"]
A10                 -> ["A10"]
A100                -> ["A100"]
SUM(A1:A2, 5A1, A3) -> ["A1", "A2", "A3"]
A100A               -> ["A100"]
_A1                 -> ["A1"]
A1_                 -> ["A1"]

r=/（？[“A34”]
5A1->[]
2.344A1->[]
A1001->[]
A1->[“A1”]
A10->[“A10”]
A100->[“A100”]
总和（A1:A2，5A1，A3）->[“A1”，“A2”，“A3”]
A100A->[“A100”]
_A1->[“A1”]
A1->[“A1”]
r=/
(?
这句话通常是这样写的：

r = /(?<!\d)[A-Z](?:\d{1,2}|100)(?!\d)/

test = ["A34A1", "5A1", "2.344A1", "A1001", "A1", "A10", "A100",
        "SUM(A1:A2, 5A1, A3)", "A100A", "_A1", "A1_"] 

test.each { |s| puts "#{s} -> #{s.scan(r)}" }
A34A1               -> ["A34"]
5A1                 -> []
2.344A1             -> []
A1001               -> []
A1                  -> ["A1"]
A10                 -> ["A10"]
A100                -> ["A100"]
SUM(A1:A2, 5A1, A3) -> ["A1", "A2", "A3"]
A100A               -> ["A100"]
_A1                 -> ["A1"]
A1_                 -> ["A1"]

r=/（？[“A34”]
5A1->[]
2.344A1->[]
A1001->[]
A1->[“A1”]
A10->[“A10”]
A100->[“A100”]
总和（A1:A2，5A1，A3）->[“A1”，“A2”，“A3”]
A100A->[“A100”]
_A1->[“A1”]
A1->[“A1”]
谢谢，但这似乎不适用于最后两个示例？OP的规范不需要两个字母。@AlphaWolf修复了它。我错了一个字符。谢谢，但这似乎不适用于最后两个示例？OP的规范不需要两个字母。@AlphaWolf修复了它。我错了一个字符。
r=/\b[A-Z]（[0-9]{1,2}100）\b/
，
“A34A”。scan（r）#=>[]
，
“A1”。scan（r）#=>[]
和
“A1”。scan（r）#=>[]
，所有这些都是不正确的。我刚刚读了你的简历。欢迎来到古老的鲁比斯特俱乐部。
r=/\b[A-Z]（[0-9]{1,2}>100）\b//code>，