那么强咖啡与强调料的构成后。用来配合特定的字符串。斜体为白。

咖啡馆需要举行一个订单系统,以契合饮料供应要求。

正则表达式是叙一组字符串特征的模式,用来配合特定的字符串

本人是原本的豫西南方人,属于南阳,靠近陕西!

1.头是这么设计的:

首要细分三个组成部分:中心语法、RegExp对象的点子、[JS中支持正则表达式的String对象方法](http://www.cnblogs.com/gulei/p/6296663.html#a3)

今日便享受给大家有些方言吧!!

 1 /**
 2  * 饮料抽象类
 3  *
 4  */
 5 public abstract class Beverage {
 6     
 7     protected String description;
 8     
 9     public String getDescription() {
10         return this.description;
11     }
12     
13     /**
14      * 子类需自定义自己的价格
15      * @return
16      */
17     public abstract double cost();
18     
19 }

 

01

各个一样种饮料都要连续该抽象类,并覆写cost()方法。

同一、基本语法

太阳——日头

2.但买咖啡时要考虑到调料的片段,每种咖啡会加不同种植之调味品,比如蒸奶、豆浆、摩卡或者覆盖奶泡,那么订单系统要考虑加盟不同调料后底价格。因此待实现不同的子类来定义添加不同调料后的价。大家理解,一栽咖啡以及多调味品有多组合方式,那么强咖啡及多种佐料的组成后,几乎是相仿爆炸!

在JS中,正则表达式为对象,用如下两栽方法定义:

做——(跟“走”同音)

 

一直量法: /pattern/attributes;创建RegExp对象法:new RegExp(pattern,attributes);

国——(跟“乖”同音)

保护最困难:

var reg=/hi/i;//字面量
var reg=new RegExp('hi','i');//构造函数(参数1:最简单的正则匹配字母hi;参数2:表示匹配时不分大小写)

——娃

假定某种饮料价格调整;或是新增了某种饮料,怎么惩罚?

 

——妞

 

元字符:( [ { \ ^ $ | ) ? * + .(若匹配元字符本身要转义)

——(跟“受”同音)

新兴通过改良后,把是否在某种调料作为饮料的性能,并以饮料抽象类吃实现cost方法,子类可以覆写cost方法并安装添加的佐料最终确定增长不同调料后的价:

 1、直接量

——(跟“百”同音)

 1 /**
 2  * 饮料抽象类
 3  *
 4  */
 5 public abstract class Beverage {
 6     
 7     private boolean milk;//牛奶
 8     private boolean soy;//豆浆
 9     private boolean mocha;//摩卡
10     private boolean whip;//奶泡
11     
12     private double milkCost = 0.19;
13     private double soyCost = 0.26;
14     private double mochaCost = 0.29;
15     private double whipCost = 0.17;
16     
17     protected String description;
18     
19     //setter getter method
20 
21     public String getDescription() {
22         return this.description;
23     }
24     
25     public double cost() {
26         double condimentCost = 0.0;
27         if (hasMilk()) {
28             condimentCost += milkCost;
29         }
30         if (hasSoy()) {
31             condimentCost += soyCost;
32         }
33         if (hasMocha()) {
34             condimentCost += mochaCost;
35         }
36         if (hasWhip()) {
37             condimentCost += whipCost;
38         }
39         return condimentCost;
40     }
41     
42 }
43 
44 /**
45  * 低糖咖啡
46  *
47  */
48 public class Decaf extends Beverage {
49     
50     @Override
51     public String getDescription() {
52         return "It is Decaf.";
53     }
54 
55     @Override
56     public double cost() {
57         super.setMilk(true);//添加牛奶调料
58         return 1.99 + super.cost();
59     }
60     
61 }

  最简便的正则匹配模式,使用字符本身进行匹配

可以——中

这样一来,如果产生五种咖啡,那么单纯待贯彻五个子类即可,不同的子类可以活设置添加不同的佐料。

var reg=/hi/;//匹配一个hi字符

板车——拉车(发音“lao,”车)

只是这样的宏图有必然的题目:

 2、元字符

——

1)调料价格的改动会要我们转移现有代码;

  正字符是一对标记和字母之三结合,用来代替普通字符,元字符有.\d\w\s等,详尽附表


2)出现新调料,就用加上新的法,并转移父类中的cost方法;

var reg=/./;// .表示除换行符以外的任一字符
var reg=/\d/;// \d表示0-9的数字
...

真为普通话,斜体为白

3)若出现新的饮品,如红茶,那么新的饮料继承该父类,父类中的佐料属性并无正好,如奶泡等;

 3、字符转义

… …

  如果需要寻找元字符本身,则用以初字符之前加\展开转义 

 

var reg=/\./;//匹配一个.
var reg=/\\/;// 匹配一个\

设计原则:类应该对扩大开放,对修改关闭。

 4、重复

 

  量词用于限定它面前表达式匹配的次数,有*+?{}等

装饰者模式思想:以饮料也基点,然后以运作时因为调料来“装饰”饮料。

var reg=/\d\d\d/;//匹配3个数字
var reg=/\d*/;//匹配任意数量数字,可能是0个
var reg=/\d+/;//匹配1个到多个数字
var reg=/\d?/;//匹配0到1个数字
var reg=/\d{3}/;//匹配3个数字
var reg=/\d{3,}/;//匹配3到多个数字
var reg=/\d{3,6}/;//匹配3到6个数字

例如客户要摩卡和奶泡深焙咖啡,那么一旦开的凡:

 5、字符类

将一个深焙咖啡对象;

  在[]的限定中上加字符,在中括号内的元字符不需展开转义‘-’表示到,它的意向呢以括号中任选其同样

以摩卡目标装饰;

var reg=/[abc]/;//匹配'a','b','c'其中之一
var reg=/[() +\]/;//匹配'(',')',' ','+','\'其中之一,[]内部不需要转义
var reg=/[0-9a-z]/;//匹配0至9和a至z,即[0123456789abcdefghijklmnopqrstuvwxyz]
var reg=/[0-9][a-z]/;//匹配前一个数字后一个字母的两位字符,区别于上述匹配一位字符

坐奶泡对象装饰;

6、分支条件

摩卡和奶泡属于调味品,但是也是装饰者,它的品类反映了她装饰的对象,所谓反映,指的是两者类型一致。那么所有调料需要连续Beverage。

  使用|把不同规则分隔开,类似条件选择,从左到右依次测试每个条件,满足其中任一条件即可,当满足某个分枝成功后即便不再管其它的子了

 

var reg=/0\d{2}-\d{8}|0\d{3}-\d{7}/;//匹配固定电话:前3后8或前4后7,即021-12345678或0553-7654321

采用装饰者模式设计的代码:

7、分组

 1 /**
 2  * 饮料抽象类
 3  *
 4  */
 5 public abstract class Beverage {
 6     
 7     protected String description;
 8     
 9     public String getDescription() {
10         return this.description;
11     }
12     
13     /**
14      * 获取每种饮料的价格
15      * @return
16      */
17     public abstract double cost();
18 }
19 
20 /**
21  * 调料抽象类
22  *
23  */
24 public abstract class Condiment extends Beverage {
25     
26     public abstract String getDescription();
27     
28 }

  使用()来担保裹子表达式,以便对这部分子表达式整体操作,如重或后朝引用

此间调料继承饮料,仅仅是为了使双边兼有同等的种类,并非为复用父类的作为。

var reg=/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/;//匹配IP地址
//意思为:((一个不大于255的数字)+‘.’)整体重复三次+(一个不大于255的数字)

脚是饮料的子类:

8、反义

 1 /**
 2  * 深焙咖啡
 3  *
 4  */
 5 public class DarkRoast extends Beverage {
 6     
 7     public DarkRoast() {
 8         description = "DarkRoast";
 9     }
10     @Override
11     public double cost() {
12         return 0.19;
13     }
14 
15 }
16 
17 /**
18  * 浓缩咖啡
19  *
20  */
21 public class Espresso extends Beverage {
22     
23     public Espresso() {
24         description = "Espresso";
25     }
26     
27     @Override
28     public double cost() {
29         return 1.99;
30     }
31 
32 }
33 
34 /**
35  * 黑咖啡
36  *
37  */
38 public class HoseBlend extends Beverage {
39     
40     public HoseBlend() {
41         description = "Hose Blend Coffee";
42     }
43     
44     @Override
45     public double cost() {
46         return 0.99;
47     }
48 
49 }

  查找无属指定项目以外的字符,有\D\W\S[^]等,其中\D等价于[^\d] 除数字外任意字符

调料(装饰者)子类:

var reg=/[^abc]/;//匹配一个不是abc的字符,即除abc以外的任一字符
 1 /**
 2  * 摩卡
 3  *
 4  */
 5 public class Mocha extends Condiment {
 6 
 7     private Beverage beverage;
 8     
 9     public Mocha(Beverage beverage) {
10         this.beverage = beverage;
11     }
12 
13     @Override
14     public String getDescription() {
15         return beverage.getDescription() + ", Mocha";
16     }
17 
18     @Override
19     public double cost() {
20         return 0.20 + beverage.cost();
21     }
22 
23 }
24 
25 /**
26  * 豆浆
27  *
28  */
29 public class Soy extends Condiment {
30     
31     private Beverage beverage;
32     
33     public Soy(Beverage beverage) {
34         this.beverage = beverage;
35     }
36 
37     @Override
38     public String getDescription() {
39         return beverage.getDescription() + ", Soy";
40     }
41 
42     @Override
43     public double cost() {
44         return 0.23 + beverage.cost();
45     }
46 
47 }
48 
49 /**
50  * 奶泡
51  *
52  */
53 public class Whip extends Condiment {
54     
55     private Beverage beverage;
56     
57     public Whip(Beverage beverage) {
58         this.beverage = beverage;
59     }
60     
61     @Override
62     public String getDescription() {
63         return beverage.getDescription() + ", Whip";
64     }
65 
66     @Override
67     public double cost() {
68         return 0.69 + beverage.cost();
69     }
70 
71 }

 9、后朝引用

测试代码:

  使用()分组匹配的子表达式,将机关拥有一个分组编号,可用于后续又引用

 1 public class ComponentTest {
 2     @Test
 3     public void test() {
 4         Beverage beverage = new Espresso();
 5         System.out.println(beverage.getDescription() + ", $" + beverage.cost());
 6         Beverage beverage2 = new HoseBlend();
 7         beverage2 = new Mocha(beverage2);
 8         beverage2 = new Mocha(beverage2);
 9         beverage2 = new Whip(beverage2);
10         System.out.println(beverage2.getDescription() + ", $" + beverage2.cost());
11         Beverage beverage3 = new DarkRoast();
12         beverage3 = new Soy(beverage3);
13         beverage3 = new Mocha(beverage3);
14         beverage3 = new Whip(beverage3);
15         System.out.println(beverage3.getDescription() + ", $" + beverage3.cost());
16     }
17 }
var reg=/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}\2/;//这里有分组有嵌套,\1代表外层分组(下划线),\2表示内层分组(红色)

运作结果:

  可以于定义分组编号(即命名)语法为:(?<name>exp)或(?’name’exp),将分组命名为name,再倒为引用时语法为:\k<name>

1 Espresso, $1.99
2 Hose Blend Coffee, Mocha, Mocha, Whip, $2.08
3 DarkRoast, Soy, Mocha, Whip, $1.31
var reg=/((?<name>2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}\k<name>/;//给分组2命名为name,后续可用该名称来引用

 

  还足以忽略当前分组获得自行编号(即潜伏分组),语法为(?:exp)

java/IO中有好多运装饰者模式之统筹,有趣味的恋人可了解下。

var reg=/(?:(2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}\1/;//因为第一个分组被忽略,原来的分组2变为了分组1

 

 10、零宽度断言(也如环视)

  用于查找在某些内容(但连无包括这些情节)之前要后的物,类似\b^$指定一个岗位,这个职位设满足一定之格(断言)

  (?=exp)正前瞻,自身出现的岗位的尾能匹配表达式exp,如:\b\w+(?=ing\b),匹配以ing结尾的但词之前方有,等同于下划线部分

  (?!exp)反前瞻,自身出现的职的后面不能够配合表达式exp,如:\babc(?!ing\b),匹配不因为ing结尾的abc开头就词之abc,等同于下划线部分

  (?<=exp)正后顾,自身出现的职的前方能配合表达式exp,如:(?<=\bre)\w+\b,匹配以re开头的但词之晚半片,等同于下划线部分(JS不支持)

  (?<!exp)反溯,自身出现的职的面前不可知配合表达式exp,如:(?<!\bre)abc\b,匹配以re开头的abc结尾单词之abc,等同于下划线部分(JS不支持)

var str='reading';
var reg=/read(?=ing)/g;//正前瞻:在我们捕获read这个字符串时,筛选它接下来的字符串是不是ing
console.log(str.match(reg)[0]);//read

 11、贪婪和懒

  正则表达式匹配时,通常在苟一切表达式能得到匹配的前提下,会配合尽可能多之字符,这让称为贪婪匹配若需要懒惰匹配(即尽可能少的字符),那么一旦在限制重复的软性量词后加以?即可

var str='aabab';
console.log(str.match(/a.*b/)[0]);//aabab 默认贪婪模式
console.log(str.match(/a.*?b/)[0]);//aab 开启懒惰模式 
代码/语法 说明
*? 重复任意次,但尽可能少重复
+? 重复1次或更多次,但尽可能少重复
?? 重复0次或1次,但尽可能少重复
{n,m}? 重复n到m次,但尽可能少重复
{n,}? 重复n次以上,但尽可能少重复

 

 

 

 

 

 12、处理选项

  即使匹配规则,是否忽略大小写,多行等

名称 说明
IgnoreCase(忽略大小写) 匹配时不区分大小写。
Multiline(多行模式) 更改^和$的含义,使它们分别在任意一行的行首和行尾匹配,而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
Singleline(单行模式) 更改.的含义,使它与每一个字符匹配(包括换行符\n)。
IgnorePatternWhitespace(忽略空白) 忽略表达式中的非转义空白并启用由#标记的注释。
ExplicitCapture(显式捕获) 仅捕获已被显式命名的组。

 

附表:常用元字符详解

元字符 类型 说明
\ 特殊 转义符号,或将下一个字符标记为特殊字符(如\d)
| 特殊 分支条件,类似条件选择把不同规则分隔开
() 特殊 分组
[] 特殊 限定字符,如[abc]
[^] 特殊 负值字符串,如[^abc]除abc以外的任何字符
{} 特殊 限定次数
^ 位置 匹配字符串的开始
$ 位置 匹配字符串的结束
\b 位置 单词的开头或结尾,也就是单词的分界处
* 量词 重复零次或更多次(任意次)
+ 量词 重复一次或更多次(至少出现一次)
量词 重复零次或一次(最多出现一次)
{n} 量词 重复n次,n为数字
{n,} 量词 重复n次到无数次
{n,m} 量词 重复n次到m次
. 匹配 匹配除换行符以外的任意字符
\d 匹配 匹配一个数字字符,等价于[0-9]
\w 匹配 匹配字母或数字或下划线或汉字,只考虑英文情况下等价于[a-zA-Z0-9_]
\s 匹配 匹配任意的空白符

 

老二、RegExp对象的点子

1、test()**

  基本语法:**RegExpObject.test(str);**

**  **欠办法用于检测一个字符串是否匹配有模式(即加以的字符串使用该正则是否能够配合到情节),返回一个布尔值

var str="hello world";
var regexp=new RegExp("hello");//构造函数创建RegExp对象
console.log(regexp.test(str));//true
console.log(/hi/.test(str));//false,//字面量

2、exec()

  基本语法:RegExpObject.exec(str)**;**

  该方式用于检索字符串中的正则表达式的配合,返回一个配合结果的多次组,如果没匹配返回null;不是全局的状下及match()方法返回的数值相同

var str="hello world";
console.log(/hello/.exec(str));//["hello", index: 0, input: "hello world"] 
//第一为匹配的内容,第二为匹配的索引位置,第三为字符串本身
console.log(/hi/.exec(str));//null
console.log(/ello/.exec(str).index);//1 //index和input可以直接作为该方法返回的两个属性

 

 

其三、JS中支持正则表达式的String对象方法

1、search()

  查找:stringObject.search(regexp/str);

  该措施用于检索字符串中指定的子字符串,或探寻和正则表达式相匹配的字符串,它不执全局匹配(将忽略标志g),也未尝regexp对象的lastIndex属性,且连续打字符串开始位置展开搜寻,总是回到的凡stringObject匹配的第一个职务

var str = "hello"; 
console.log(str.search(/l/)); //2 返回匹配到的第一个位置(使用的regexp对象检索)
console.log(str.search('l')); //2 使用字符串进行匹配
console.log(str.search(/l/g)); //2 没有全局的概念 总是返回匹配到的第一个位置
console.log(str.search(/L/i)); //2 可以忽略大小写来检索
console.log(str.search(/a/)); //-1,如果没有检索到的话,则返回-1

2、match()

  匹配:stringObject.match(regexp/str

  该办法用于在字符串内找指定的价,或找到一个要基本上只正则表达式的匹配。该方法类似于indexOf()或者lastIndexOf(); 但是它回到的是指定的价,而休是字符串的职位;

var str = "hello"; 
console.log(str.match(/e/)); //["e", index: 1, input: "hello"] 返回一个数组,包括匹配到的字符,位置和自身
console.log(str.match('e'));//["e", index: 1, input: "hello"] 支持用字符串代替正则进行匹配
console.log(str.match(/l/g));//["l", "l"]支持全局匹配,返回匹配到的字符组成的数值

3、replace()

  替换:stringObject.replace(regexp/str,str/function);

  该措施用于在字符串中采取部分字符替换另一对字符,或者替换一个同正则表达式匹配的子字符串;默认只替换第一个门当户对的字符,可以加修饰符g进行全局替换。整体返回替换后的新字符串。

var str = "hello world";
console.log(str.replace("hello","a"));// a world,使用字符串匹配并替换
console.log(str.replace(/hello/,"b"));// b world,使用正则匹配并替换
console.log(str.replace(/l/g,""));// heo word,使用正则加装饰符g进行全局替换
console.log(str.replace(/(hello)[ ](\w+)/g,"$2 $1"));// world hello,$1,$2 代表正则中第一个和第二个分组所匹配的文本
//第二个参数是function函数
console.log(str.replace(/o/g,function(v){
  console.log(v);//打印2次o
  return '-';
}));//hell- w-rld,匹配替换为函数的返回值
console.log(str.replace(/(e).*(o)\b/g,function(){
  console.log(arguments);//["ello", "e", "o", 1, "hello world"]
  //第一个匹配的字符,第二和第三是分组匹配的内容,第四是匹配索引位置,第5个是原字符串
  return 'i';
}));// hi world

4、split()

  分割:stringObject.split(regexp/substr,[length]);

  欠措施把一个字符串分割成字符串数组,length设定返回数组的长短就过部分用给忽略(可选参数)

var str = "hello world";
console.log(str.split(" ");//["hello", "world"],使用字符分割为数组
console.log(str.split(/o/g));//["hell", " w", "rld"],使用正则匹配的内容来分割
console.log(str.split(/o/g,2));//["hell", " w"],指定返回数组的length

 

 

 

相关文章