Javascript 使用正则表达式拆分复杂字符串

如何使用正则表达式拆分此字符串：

在该阵列中：

---

基本规则是字符串应以空格分隔，除非括号[]中存在空格

你不能；正则表达式基于没有堆栈的状态机，因此您可以记住嵌套级别的数量

---

但也许您可以使用一个技巧：尝试将字符串转换为有效的。然后您可以使用eval将其解析为JavaScript对象。

您不能；正则表达式基于没有堆栈的状态机，因此您可以记住嵌套级别的数量

---

但也许您可以使用一个技巧：尝试将字符串转换为有效的。然后，您可以使用eval将其解析为JavaScript对象。

您可以拆分吗？您可以拆分吗？如果规则这么简单，我建议您手动执行。逐步遍历每个角色，并跟踪嵌套级别，每个角色增加1[每个角色减少1]。如果到达嵌套==0的空间，则拆分

编辑：

---

我在想，我还可以提到，在某些语言中，还有其他模式匹配工具在本地支持这类事情。例如，在Lua中，您可以使用“%b[]”来匹配平衡嵌套[]。当然，Lua没有内置的分割函数

如果规则这么简单，我建议手动操作。逐步遍历每个角色，并跟踪嵌套级别，每个角色增加1[每个角色减少1]。如果到达嵌套==0的空间，则拆分

编辑：

---

我在想，我还可以提到，在某些语言中，还有其他模式匹配工具在本地支持这类事情。例如，在Lua中，您可以使用“%b[]”来匹配平衡嵌套[]。当然，Lua没有内置的分割函数

另一种是循环方法，在这种方法中，您可以一次解构一层嵌套的方括号，否则很难确保单个regexp按预期工作

下面是ruby中的一个示例：

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
left = str.dup
tokn=0
toks=[]
# Deconstruct
loop do
  left.sub!(/\[[^\]\[]*\]/,"\{#{tokn}\}")
  break if $~.nil?
  toks[tokn]=$&
  tokn+=1
end
left=left.split(/\s+/)
# Reconstruct
(toks.size-1).downto(0) do |tokn|
  left.each { |str| str.sub!("\{#{tokn}\}", toks[tokn]) }
end

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
toks=[]
level=st=en=0; 
str.each_byte do |c|
  en+=1; 
  level+=1 if c=='['[0]; 
  level-=1 if c==']'[0]; 
  if level==0 && c==' '[0]
    toks.push(str[st,en-1-st]);
    st=en
  end
end    
toks.push(str[st,en-st]) if st!=en 
p toks

上面使用了{n}，其中n在解构过程中是一个整数，因此在某些情况下，字符串中的原始输入会破坏重建。不过，这应该可以说明这种方法

不过，编写通过迭代字符进行拆分的代码更简单、更安全

ruby中的示例：

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
left = str.dup
tokn=0
toks=[]
# Deconstruct
loop do
  left.sub!(/\[[^\]\[]*\]/,"\{#{tokn}\}")
  break if $~.nil?
  toks[tokn]=$&
  tokn+=1
end
left=left.split(/\s+/)
# Reconstruct
(toks.size-1).downto(0) do |tokn|
  left.each { |str| str.sub!("\{#{tokn}\}", toks[tokn]) }
end

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
toks=[]
level=st=en=0; 
str.each_byte do |c|
  en+=1; 
  level+=1 if c=='['[0]; 
  level-=1 if c==']'[0]; 
  if level==0 && c==' '[0]
    toks.push(str[st,en-1-st]);
    st=en
  end
end    
toks.push(str[st,en-st]) if st!=en 
p toks

---

另一种是循环方法，在这种方法中，您一次解构一层嵌套的方括号，否则它是hardTM，以确保单个regexp按预期工作

下面是ruby中的一个示例：

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
left = str.dup
tokn=0
toks=[]
# Deconstruct
loop do
  left.sub!(/\[[^\]\[]*\]/,"\{#{tokn}\}")
  break if $~.nil?
  toks[tokn]=$&
  tokn+=1
end
left=left.split(/\s+/)
# Reconstruct
(toks.size-1).downto(0) do |tokn|
  left.each { |str| str.sub!("\{#{tokn}\}", toks[tokn]) }
end

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
toks=[]
level=st=en=0; 
str.each_byte do |c|
  en+=1; 
  level+=1 if c=='['[0]; 
  level-=1 if c==']'[0]; 
  if level==0 && c==' '[0]
    toks.push(str[st,en-1-st]);
    st=en
  end
end    
toks.push(str[st,en-st]) if st!=en 
p toks

上面使用了{n}，其中n在解构过程中是一个整数，因此在某些情况下，字符串中的原始输入会破坏重建。不过，这应该可以说明这种方法

不过，编写通过迭代字符进行拆分的代码更简单、更安全

ruby中的示例：

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
left = str.dup
tokn=0
toks=[]
# Deconstruct
loop do
  left.sub!(/\[[^\]\[]*\]/,"\{#{tokn}\}")
  break if $~.nil?
  toks[tokn]=$&
  tokn+=1
end
left=left.split(/\s+/)
# Reconstruct
(toks.size-1).downto(0) do |tokn|
  left.each { |str| str.sub!("\{#{tokn}\}", toks[tokn]) }
end

str = "a[a=d b&c[e[100&2=34]]] e[cheese=blue and white] x[a=a b]"
toks=[]
level=st=en=0; 
str.each_byte do |c|
  en+=1; 
  level+=1 if c=='['[0]; 
  level-=1 if c==']'[0]; 
  if level==0 && c==' '[0]
    toks.push(str[st,en-1-st]);
    st=en
  end
end    
toks.push(str[st,en-st]) if st!=en 
p toks

---

在使用Oniguruma时，可以使用正则表达式实现这一点，因为它有一个允许某些类型嵌套的扩展。然而，我不相信任何javascript impl都包含这个扩展，而且不管怎样，我同意Dolphin的观点，即非正则表达式方法将更快、更干净。你可以很容易地实现一个状态机，在使用Oniguruma时可以用正则表达式实现，因为它有一个允许某些类型嵌套的扩展。然而，我不相信任何javascript impl都包含这个扩展，而且不管怎样，我同意Dolphin的观点，即非正则表达式方法将更快、更干净。您可以很容易地为此实现一个状态机。