问题描述：

var str = \"${DataField}$ + ${Operation}$ + ${Data}$\";
如何得到 DataField Operation Data

网友观点：

<script>
var str = \\\"${DataField}$ + ${Operation}$ + ${Data}$\\\";
// 正则一
var reg2 = /[A-Z]\\w+(?=}\\$)/g
// 正则二
var reg3 = /\\b(?=\\w)\\w+(?=}\\$)/g
console.log(str.match(reg2).join(\' \'))
console.log(str.match(reg3).join(\' \'))
// 输出：DataField Operation Data
</script>

/\\${[^\\+]+}/

var str = \\\"${DataField}$ + ${Operation}$ + ${Data}$\\\";
var g = /\\${[^+]+}/;
var group = str.match(g);

    var str1 = \\\"${DataField}$ + ${Operation}$ + ${Data}$\\\";
var strArr=str1.split(\\\"+\\\");
var str =\\\"\\\";
for(var i=0;i<strArr.length;i++){
str=strArr[i].replace(\\\"${\\\", \\\"\\\");
str=str.replace(\\\"}$\\\", \\\"\\\");
alert(str)
}

如楼上所说，使用replace函数，
将$，{，}替换成空字符，将+替换成空格

正则的方式已经有很多了，我就说个非正则的吧，你可以使用split去根据+号切割，然后获取到三个数组。接下来每个数组去掉第一第二个字符串还有
最后那个字符串，然后就可以了

var str1 = \\\"${DataField}$+${Operation}$+${Data}$\\\";

console.log(str1.split(\\\"+\\\"));

var arr = str1.split(\\\"+\\\");

for(var i = 0; i < arr.length; i++) {

console.log(arr[i].slice(2, arr[i].length - 2));

}

JavaScript中正则表达式

正则表达式

什么是正则表达式

正则表达式：（Regular Expression）用于匹配规律规则的表达式，正则表达式最初是科学家 对人类神经系统的工作原理的早期研究，现在在编程语言中有广泛的应用。正则表通常被用来 检索、替换那些符合某个模式(规则)的文本。

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式的作用

1. 给定的字符串是否符合正则表达式的过滤逻辑(匹配)

2. 可以通过正则表达式，从字符串中获取我们想要的特定部分(提取)

3. 强大的字符串替换能力(替换)

正则表达式的测试

在线测试正则：正则表达式在线测试 | 菜鸟工具

正则表达式语法

语法

在 JavaScript 中，正则表达式也是对象，是一种索引类型。

使用一个正则表达式字面量是最简单的方式。两个 / 是正则表达式的定界符。

你可以通过下面两种方法创建一个正则表达式：

使用一个正则表达式字面量，如下所示：

var reg = /abc/;

正则表达式字面量在脚本加载后编译。若你的正则表达式是常量，使用这种方式可以获得更好的性能。

调用 RegExp 对象的构造函数，如下所示：

var re = new RegExp("abc");

相关正则方法

字符串的方法：

split() 根据匹配字符串切割父字符串

match() 使用正则表达式与字符串相比较，返回一个包含匹配结果的数组。

search() 对正则表达式或指定字符串进行搜索，返回第一个出现的匹配项的下标。 replace() 用正则表达式和字符串直接比较，然后用新的子串来替换被匹配的子串。

正则表达式方法：

exec() 在目标字符串中执行一次正则匹配操作。

test() 测试当前正则是否能匹配目标字符串。

split 方法：分割字符串，成为一个数组

var str = "aa bbb c dd eeeeee";

var arr = str.split(" ");

console.log(arr1);array(8)有三项空格

var arr1 = str.split(/\\s+/);s表示空格\\s+表示一个或多个空格

console.log(arr1);array（5）没有空格

var str2 = "bbaacaaaadddaeeeeeaaf";

var arr2 = str2.split(/a+/);a+表示一个或多个a

console.log(arr2);

search 方法：查询子串在父字符串中出现的位置

如果没有相对于的字符串就返回-1

var str = "abcdefg";

console.log(str.search("cd"));2

console.log(str.search("cdf"));-1

console.log(str.search(/ef/));4

console.log(str.search(/eff/));-1

match 方法：在父字符串中去匹配符合的子字符串，将结果输出到数组中

var str = "abbcccbbbbbddbbbdabbb";

var arr = str.match(/b+/g); //如果有全局修饰符 g，会在找到所有匹配的字符串后结束

console.log(arr);array（4）

var str1 = "aaaa o o bbb o o aaa";

var arr1 = str1.match(/o\\s+o/g);

console.log(arr1);array（2）

replace 方法：替换字符串的指定部分，返回值是一个新的替换后的字符串，原始字符串不受影响

var str = "Join the hello network";

var str1 = str.replace(/hello/,"byebye");

console.log(str);Join the hello network

console.log(str1);ByeBye is for sale at Squadhelp.com!

exec 方法：查找匹配的字符串，输出到数组中

不论有没有全局修饰符，都只会在找到第一个之后停止

var str = "aaaabccccbacabc";

var reg = /abc/;

var arr = reg.exec(str);

console.log(arr);[abc]

console.log(arr.index);3

test 方法：检测字符串中是否满足正则表达式的匹配规则，返回值是布尔值

var reg = /abc/;

console.log(reg.test("aaddccddabcddeeddfff"));true

console.log(/s+/.test("abc");false

正则表达式的组成

由一些普通字符和一些特殊字符（又叫元字符--metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义。

特殊字符：javascript 中常用特殊字符有 ( ) [ ] { } \\ ^ $ | ? * + .

若想匹配这类字符必须用转移符号 \\ 如：\\(,\\^,\\\\

预定义特殊字符：

\\t /\\t/ 制表符 eg: console.log(/\\t/.test(' '))

\\n /\\n 回车符 eg: console.log(/\\n/.test(`aaa bbb`));

\\f /\\f/ 换页符

\\b /\\b/ 空格

var reg = /\\s/;

console.log(reg.test(" "));true

// \\n 表示的是回车符

var str = `sdlfkjw

eofoa`;得用1前面的那个符号才能换行不然会报错

console.log(/\\n/.test(str));true

正则的术语

字符集

简单类: 正则的多个字符对应一个字符，我们可以用 [] 把它们括起来，让 [] 这个整体对应一个字符[abc]

例子：o[usb]t——obt、ost、out

var reg = /[abc]/;

console.log(reg.test("eeeb"));true

范围类: 有时匹配的东西过多，而且类型又相同，全部输入太麻烦，我们可以在中间加了个横线。[a-z]、[0-9]、[A-Z]

例子：id[0-9]——id0、id5

var reg = /[A-Q]/;

console.log(reg.test("A123456"));true

负向类: [] 前面加个元字符进行取反，表示匹配不能为括号里面的字符。[^a]

例子：o[^0-9]t——oat、o?t、o t

var reg = /[^A-Q]/;

console.log(reg.test("A"));false

console.log(reg.test("As2));true

组合类: 允许用中括号匹配不同类型的单个字符。[0-9a-b]

例子：o[0-9a-b]t——oat、o?t、o

特殊的：如果数字、大写字母、小写字母，按照这种顺序写的完整的范围，可以缩写

//var reg = /[0-9a-z]/;

//var reg = /[0-9A-Z]/;

var reg = /[0-z]/;

console.log(reg.test("a"));true

修饰符

g 修饰符：可以实现全局查找

var str = "aabblsdddbbbdlBBdllbbbbb";

var reg = /b+/g;

console.log(str.match(reg));array（3）

i 修饰符：字母大小写可以不敏感，a 可以匹配 a 或 A

var str = "aabblsdddbbbdlBBdllbbbbb";

var reg = /A/ig;

console.log(str.match(reg));array（2）

var reg = /A/i;

console.log(str.match(reg));array（1）

边界

^ 表示限制开头，后面的正则内容匹配的结果必须出现在字符串开始

var str = "hello Javascript";

console.log(/^hello/.test(str));true

console.log(/^hhello/.test(str));false

$ 表示限制结尾，前面的正则内容匹配的结果必须出现在字符串结尾

console.log(/script$/.test(str));true

console.log(/scripthaha$/.test(str));false

实际应用中，会同时限制开头和结尾

console.log(/^hello\\s+Javascript$/.test(str));true

非回车非换行字符 .

console.log(/^.+$/.test(`asldjf2830&*^`));true

console.log(/^.+$/.test(`asldjf

2830&*^`));false

\\d 数字字符 \\D 非数字字符

console.log(/^\\d+$/.test(`0123456789`));true

console.log(/^\\d+$/.test(`01234z56789`));false

console.log(/^\\D+$/.test(`askdAK *&^`));true

console.log(/^\\D+$/.test(`askdAK *&^7`));false

\\s 空白字符 \\S 非空白字符

console.log(/^\\s+$/.test(` 1

`));false

console.log(/^\\s+$/.test(`

`));true

console.log(/^\\S+$/.test(`AJO456`));true

console.log(/^\\S+$/.test(`AJO 456`));false

\\w 单词字符 \\W 非单词字符

console.log(/^\\w+$/.test(`abc09_A`));true

console.log(/^\\w+$/.test(`abc*09_A`));false

console.log(/^\\W+$/.test(`*&^%$ *`));true

console.log(/^\\W+$/.test(`a*&^%$ *`));false

量词

{n} 硬性量词 对应前面的内容必须在字符串中出现 n 次连续

var reg = /^\\d{5}$/;

console.log(reg.test("1234"));false

console.log(reg.test("12345"));true

console.log(reg.test("123456"));false

{n,m} 软性量词 对应前面的内容必须在字符串中出现 n-m 次连续

var reg = /^\\d{5,7}$/;

console.log(reg.test("1234"));false

console.log(reg.test("12345"));true

console.log(reg.test("123456"));true

console.log(reg.test("1234567"));true

console.log(reg.test("12345678"));false

{n,} 软性量词 对应前面的内容必须在字符串中出现至少 n 次连续

var reg = /^\\d{5,}$/;

console.log(reg.test("1234"));false

console.log(reg.test("12345"));true

console.log(reg.test("123456"));true

console.log(reg.test("1234567"));true

console.log(reg.test("123456789101112"));true

? 软性量词 表示前面的内容出现 0 次或 1次

var reg = /^\\d?$/;

console.log(reg.test("1"));true

console.log(reg.test(""));true

console.log(reg.test("12345"));false

* 软性量词 表示前面的内容出现 0 次或 任意次

var reg = /^\\d*$/;

console.log(reg.test("1"));true

console.log(reg.test(""));true

console.log(reg.test("12345"));true

+ 软性量词 表示前面的内容出现 1 次或 以上

var reg = /^\\d+$/;

console.log(reg.test(""));false

console.log(reg.test("1"));true

console.log(reg.test("12345"));true

// 分组

var reg = /^(bye){2}$/;

console.log(reg.test("byebye"));true

console.log(reg.test("bbyyee"));false

或操作符 |

var reg = /^a|bcd$/; //匹配时，要么匹配以a开头的，要么匹配以 bcd 结尾的

console.log(reg.test("cbcde"));false

console.log(reg.test("acbcde"));true

console.log(reg.test("abcd"));true

如果想在正则中，在两个规则之间只能选其中一个，不能包含其他的开头结尾，需要去讲或运算放到分组里

var reg = /^(ab|cd)$/;

console.log(reg.test("abcd"));false

console.log(reg.test("ab"));true

console.log(reg.test("cd"));true

正则中通过分组匹配到的字符串，会被进行编号，从 1 开始

在正则内部可以通过 \\1 方式，去对字符串进行反向引用

console.log(/^([a-z]{3})\\1$/.test("byebye"));true

console.log(/^([a-z]{3})\\1$/.test("byelie"));false

正则表达式以外通过 $1 ,进行字符串的引用

var str = "123*456".replace(/^(\\d{3})\\*(\\d{3})$/,"$2*$1");

第二个参数可以是一个函数

var str = "123*456".replace(/^(\\d{3})\\*(\\d{3})$/,function (match,$1,$2) {

return $1 * 3 + "/" + $2 * 2;

});

console.log(str);369/912

匹配中文字符

var reg = /^[\\u4e00-\\u9fa5]+$/;

console.log(reg.test("只有中文的文字内容"));true

console.log(reg.test("只有中文的文 字内容"));true

console.log(reg.test("只有中文的文a字内容"));false