js菜鸟正则表达式和function类型

/*var box=new RegExp('box');//第一个参数是模式字符串
alert(box);// /box/是字面量表示法
var box=new RegExp('box',ig);//第二个参数可选模式修饰符


var box=/Box/ig;//使用字面量方式的正则
alert(box);


var pattern=new RegExp("Box",i);//不区分大小写
var str='box';
alert(pattern.test(str));


alert(/'box'/i.test('Box'));//一句话正则






var pattern =/box/i;
var str='this is a box';
alert(pattern.exec(str));//返回的类型是Object，数组是object类型，如果没有返回就是none


var pattern=/box/ig;//如果没有开启全局就会返回第一个box
 var str='this is a Box !that is a box !';
alert(str.match(pattern));
var a=str.match(pattern);
alert(a[0]);//证明它是数组


var pattern=/box/i;//如果找到就会返回第一个位置
 var str='this is a Box !that is a box !';
alert(str.search(pattern));
var pattern=/box/ig;//如果没有开启全局就会返回第一个被替换
 var str='this is a Box !that is a box !';
alert(str.replace(pattern,'tom'));
var pattern=/!/i;//把字符串通过正则表达式拆分成数组
 var str='this is a Box !that is a box !';
alert(str.split(pattern));


//ps：静态属性无需声明即可用，实例属性需要声明才能用
var pattern=/(g)oogle/ig;
var str='this is a google map';//必须先执行一下下面的属性才有效multiline是是否支持多行
pattern.test(str);
//alert(RegExp.input);//当前被匹配的字符串s_等同于alert（RegExp[s_]）
//alert(RegExp.leftContext);//最后一次匹配前的字符串s'
//alert(RegExp.rightContext);
//alert(RegExp.lastMatch);//最后一个匹配字符串s$
alert(RegExp.lastParen);//匹配圆括号内的字符串s+


实例属性测试全局是否设置等问题基本没什么用
var pattern=/g.gle/;//.的意思是可以匹配除换行符以外的任意字符，一对一匹配
var str='this is a google map';


alert(pattern.test(str));
var pattern=/go*gle/;//o*,表示0个，1个和多个o
var str='this is a google map';


alert(pattern.test(str));
var pattern=/go+gle/;//o+表示一个或者多个
var str='this is a google map';


alert(pattern.test(str));
var pattern=/go？gle/;//o？表示一个或者0个
var str='this is a google map';


alert(pattern.test(str));


var pattern=/g。？gle/;//。？表示一个或者0个任意字符
var str='this is a google map';


alert(pattern.test(str));




var pattern=/go(2,4)gle/;//o(2,4)表示匹配o2-4次，包含2和4；
var str='this is a google map';


alert(pattern.test(str));


var pattern=/go(2)gle/;//o(2)表示只能匹配2次；
var str='this is a google map';


alert(pattern.test(str));


var pattern=/go(2，)gle/;//o(2，)表示匹配2次或2次以上；
var str='this is a google map';


alert(pattern.test(str));


var pattern=/[a-z]oogle/;//表示26个小写字母，任意一个都匹配
var str='this is a google map';


alert(pattern.test(str));


var pattern=/[A-Z]oogle/i;//表示26个小写字母，任意一个都匹配
var str='this is a google map';


alert(pattern.test(str));


var pattern=/[0-9]*oogle/i;//[0-9]*表示0次1次或者多次
var str='this is a 444444444444oogle map';


alert(pattern.test(str));


var pattern=/[a-zA-Z0-9]oogle/i;//表示括号任意一个都匹配
var str='this is a google map';


alert(pattern.test(str));


var pattern=/[^0-9]oogle/i;//表示除了括号任意一个都匹配
var str='this is a google map';


alert(pattern.test(str));
var pattern=/[a-z]+/;//
var str='gg';


alert(pattern.test(str));


var pattern=/^[0-9]+oogle/i;//^符号放在括号外面表示从头匹配，+可以匹配一个或者多个
var str='this is a 4oogle map';


alert(pattern.test(str));


var pattern=/\woogle/i;//表示匹配字母及下划线
var str='this is a google map';


alert(pattern.test(str));


var pattern=/\Woogle/i;//表示不是匹配字母及下划线
var str='this is a google map';


alert(pattern.test(str));


var pattern=/^[a-z]oogl[0-9]$/i;//表示强制首匹配，强制尾匹配
var str='this is a googl8 map';


alert(pattern.test(str));


var pattern=/\d/;//
var str='this is a goog map';


alert(pattern.test(str));


var pattern=/goo\sgle/;//\s表示空格匹配
var str='goo gle';
alert(pattern.test(str));




var pattern=/goo\bgle/;//\b表示是否到达了边界
var str='google';
alert(pattern.test(str));


var pattern=/google|baidu|hehe/;//|表示匹配其中任意一项
var str='google';
alert(pattern.test(str));




var pattern=/(google)(4,8)$/;//分组，表示google4-8次
var str='google';
alert(pattern.test(str));


var pattern=/google(4,8)$/;//表示e4-8次
var str='google';
alert(pattern.test(str));


var pattern=/8(.*)8/;//表示8-8匹配
var str='8google8';
alert(pattern.test(str));
alert(RegExp.$1);//表示获取模式中第一个匹配的字符串


var pattern=/8(.*)8/;
var str='8google8';
document.write(str.replace(pattern,'<strong>$1<strong>'));//$1表示分组获取字符串匹配到的字符




var pattern=/(.*)\s(.*)/;//(.*)表示分组\s表示空格
var str='baidu google';
alert(str.replace(pattern,$2 $1));//表示位置交换


var pattern=/[a-z]+/;//+这里使用了贪婪
var str='abcdefg';
alert(str.replace(pattern,'1'));//表示将字符串全部替换成了1


var pattern=/[a-z]+?/;//+这里使用了惰性
var str='abcdefg';
alert(str.replace(pattern,'1'));//表示只有第一个字符串变成了1.


var pattern=/[a-z]+?/g;//+这里使用了惰性，开启全局
var str='abcdefg';
alert(str.replace(pattern,'1'));//表示每一个字符串都变成了1


var pattern=/8(.*)8/;//使用了贪婪匹配到的是第一个和最后一个8
var str='8google8 8google8 8google8';
document.write(str.replace(pattern,'<strong>$1<strong>'));//$1表示分组获取字符串匹配到的字符




var pattern=/8(.*?)8/g;//使用了惰性并且要开始全局var pattern=/8([^8]*?)8/g;
var str='8google8 8google8 8google8';
document.write(str.replace(pattern,'<strong>$1<strong>'));//$1表示分组获取字符串匹配到的字符


//<strong>google<strong>
//检查邮政的编码
var pattern=/[1-9][0-9][5]/;
var str='408415';//必须是6位，首位不能为0，必须是数字
alert(pattern.test(str));


//检查压缩包
var pattern=/^[\w\-]+\.(zip|gz|rar)$/;//\w+一位或者多位，^限制它从首字母开始匹配ps:选择符号必须用分组符号括起来来
var str='1-23.zip';//文件名可以字母数字下划线中间有个点
alert(pattern.exec(str));




//删除空格
var pattern=/\s/g;//删除空格
var str='11 122 2222 222';
alert(str.replace(pattern,''));


//删除首位空格
var pattern=/^\s+/;
var str='    a    b   ';
var result=str.replace(pattern,'');
pattern=/\s+$/;
result=result.replace(pattern,'');
alert(result)




//删除首位空格
var pattern=/^\s+(.+?)\s+$/;//.+是贪婪模式，惰性模式
var str='    a    b   ';
var result=pattern.exec(str)[1];//使用分组模式
alert(result);


//邮箱的正则
var pattern=/^([\w\-\.]+)@([\w\-]+)\.([a-zA-Z]{3})$/;//
var str='[e-mail]';
alert(pattern.test(str));


*/


/*function函数


//普通函数的声明方式
function box(i,j){
return i+j;
}
alert (box(1,2));


//变量函数的声明方式


//使用变量的初始化函数
var box=function (i,j){
return i+j;
}
alert(box(1,2))；




//使用Function构造函数,不推荐使用，影响性能


var box=new Function('i','j','return i+j');
alert(box(1,2));


//ps：函数可以传递函数，下面的例子不是作为函数来传递的而是作为函数的返回值来传递的


function box(sum,num){
return sum+num;
}
function sum(num){
return num+20;
}
var result=box(sum(20),20);//40,20sum(20)这里传递的是函数的返回值，和普通的变量一样
alert(result);


//ps：函数可以传递函数，下面的例子是作为函数来传递的
function box(sum,num){
return sum(num);
}
function sum(num){
return num+20;
}
var result=box(sum,20);//sum这里是传递的函数而不是传递的是函数的返回值
alert(result);




//函数的内部属性函数的的递归调用这样如果函数体有很多自身调用就会不好，所以function函数提供了一个内部属性
callee;
function sum(num){
if(num==1){
return 1;
}else{
return num*sum(num-1);
}
}
var result=sum(5);
alert(result);




//函数的内部属性函数的的递归调用
function sum(num){
if(num==1){
return 1;
}else{
return num*arguments.callee(num-1); //arguments.callee调用自身实现递归
}
}
var result=sum(5);
alert(result);


//window是一js里面最大的对象是最外围的对象
//alert(typeof window);//window是对象，类型是对象，表示的是全局
//alert(this);[object window]this目前表示的是window，因为它在window的范围下
//alert(typeof this);//和window一模一样，所以this就是window
var color='hong';
alert(window.color);//this.color其实是一样的
window.color='hong';//相当于var color='hong'
var box={
color:'lanse',
sayColor:function(){
alert(this.color);//这里的this代表的是box对象
}
};
box.sayColor();




//window是一js里面最大的对象是最外围的对象
//alert(typeof window);//window是对象，类型是对象，表示的是全局
//alert(this);[object window]this目前表示的是window，因为它在window的范围下
//alert(typeof this);//和window一模一样，所以this就是window


window.color='hong';//相当于var color='hong'
function sayColor(){
alert(this.color);//所以这里执行的是动态的，第一次是在window下，第二次是在box下面
}
sayColor();//这里还是在全局变量之下
var box={
color:'lanse'
//sayColor:function(){
//alert(this.color);//这里的this代表的是box对象
//}
};
box.sayColor=sayColor;//这里和我注释掉的是同样的方式


box.sayColor();//这里调用的是box对象里面的saycolor方法


function box(i,j){
return i+j;
}
function sum(i,j){//applay和call可以冒充其他的函数
return box.apply(this,[i,j]);//this表示windows的作用域，【】表示传递的参数
}
function sum2(i,j){
return box.apply(this,arguments);//arguments可以当作数组传递
}
alert (sum2(10,10));


function box(i,j){
return i+j;
}
function sum(i,j){//applay和call可以冒充其他的函数
return box.call(this,i,j);//this表示windows的作用域，【】表示传递的参数
}
function sum2(i,j){
return box.apply(this,arguments);//arguments可以当作数组传递
}
alert (sum(10,10));


var color='hong';//全局的
var box={
color:'lan'//局部
};
function sayColor(){
alert(this.color);
}
//用call冒充box下。冒充window下
sayColor.call(window);
sayColor.call(this);
sayColor.call(box);


*/


var color='hong';//全局的
var box={
color:'lan'//局部
};
function sayColor(){
alert(this.color);
}
//用call冒充box下。冒充window下
sayColor.call(window);
sayColor.call(this);
sayColor.call(bo