maoting

浏览: 47202 次
性别:
来自: 北京

最近访客更多访客>>

iy2017

eyeti123

小动物不困

吴小帅啊

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

javascript方法总结_String

博客分类：

javascript

javascript常用属性方法总结

String类型(对象中的方法可以在基本的字符串之中访问到)

属性：str.length

方法：(以下方法对原始字符串都没有影响)

1. 字符方法

str.charAt(),str.charCodeAt():都接收一个参数，即基于0的字符位置。

charAt方法以单字符字符串的形式返回给定位置的那个字符；

charCodeAt返回的是字符串编码；

ECMAScript5还定义了另外一个访问字符串的方法，在支持的浏览器中，可以用方括号加数字索引来访问字符串中的特定字符，例如：str[1] //"e"

2. 字符串的操作

str.concat();用于将一个字符串或多个字符串拼接起来，返回的得到的新字符串。但实践中使用的更多的还是"+"

slice()、substr()、substring():接收一个或者两个参数，第一个参数制定子字符串的开始位置，而第二个参数（在指定的情况下）表示子字符串到哪里结束。具体来说，slice()和substring()在第二个参数指定的子子字符串最后一个字符后面的位置。而substr()的第二个参数指定的则是返回字符串的个数.如果没有给这些方法传递第二个参数，则字符串的长度作为结束位置。注意：如果是负值时，slice()方法会将传入的负值与字符串的长度相加，substring()方法会把所有负值参数都转换为0,substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为0.

3. 字符串位置方法

indexof() lastIndexOf(),这两个方法都是从一个字符串中搜索给定的子字符串，然后返回子字符串的位置（如果没有找到，则返回-1）。

indexof()方法从字符串的开头向后搜索子字符串；

lastIndexOf()方法是从字符串的末尾向前搜索子字符串。可接受第二个参数，表示从字符串中的那个位置开始搜索。

4. trim()方法（ECMAScript5中定义）

5. 字符串大小转换方法

toLowerCase()、 toLocaleLowerCase()、 toUpperCase() 、toLocaleUpperCase()

6. localeCompare()

比较两个字符串，并返回下列中的一个值：-1 0 1（在字母表中的顺序）

7. fromCharCode()

静态方法，接收字符编码，转换成字符串。

<script type="text/javascript">
		//var str = Hello World;
		var str = new String("Hello World");
		
		console.log(str.length);
		
		//字符方法
		console.log(str.charAt(1));
		console.log(str.charCodeAt(1));
		console.log(str.concat("world"));
		
		//字符串的操作
		console.log("str.slice(3):"+str.slice(3));
		console.log("str.substring(3):"+str.substring(3));
		console.log("str.substr(3):"+str.substr(3));
		console.log("str.slice(3,7):"+str.slice(3,7));
		console.log("str.substring(3,7):"+str.substring(3,7));
		console.log("str.substr(3,7):"+str.substr(3,7));
		console.log("str.slice(-3):"+str.slice(-3));
		console.log("str.substring(-3):"+str.substring(-3));
		console.log("str.substr(-3):"+str.substr(-3));
		console.log("str.slice(3,-4):"+str.slice(3,-4));
		console.log("str.substring(3,-4):"+str.substring(3,-4));//会将较小的数作为开始位置，将较大的数作为结束位置
		console.log("str.substr(3,-4):"+str.substr(3,-4));
		
		//字符串的位置
		console.log(str.indexOf("o"));
		console.log(str.lastIndexOf("o"));
		console.log(str.indexOf("o",6));
		console.log(str.lastIndexOf("o",6));
		
		console.log(" str   ".trim());
		
		//字符串大小写的转换
		console.log(str.toLocaleLowerCase());
		console.log(str.toLowerCase());
		console.log(str.toLocaleUpperCase());
		console.log(str.toUpperCase());
		
		//字符串模式的匹配方法

		console.log(str.localeCompare("brick"));
		console.log(str.localeCompare("Hello World"));
		console.log(str.localeCompare("Hello World "));
		
		//静态方法
		console.log(String.fromCharCode(104,101,108,111));
	</script>

运行结果：

8.字符串的模式匹配方法

match() search() replace()split()

match方法

stringObj.match(rgExp)

参数 stringObj ：必选项。对其进行查找的 String 对象或字符串文字。

rgExp ：必选项。为包含正则表达式模式和可用标志的正则表达式对象。也可以是包含正则表达式模式和可用标志的变量名或字符串文字。

其余说明与exec（正则表达式的方法）一样，不同的是如果match的表达式匹配了全局标记g将出现所有匹配项，而match不用循环，但所有匹配中不会包含子匹配项。exec需要循环，但可以包含子匹配项。

<script type="text/javascript">
	var r, regExpG; // 声明变量。  
	var s = "The rrain in Spain falls mainly in the plain";  
	    
	regExp= /(\w+)in/i; // 创建正则表达式模式。  
	regExpG = /(\w+)in/ig; // 创建正则表达式模式。 
	
	function MatchDemo(){  
		console.log("-----------match-------------"); 
	    r0 = s.match(regExp); // 尝试去匹配搜索字符串。 
	    r = s.match(regExpG); // 尝试去匹配搜索字符串。  
	    document.write(r0+ "<br/>"); 
	    document.write(r+ "<br/>");// 返回的数组包含了所有 "ain" 出现的四个匹配，r[0]、r[1]、r[2]、r[3]。 // 但没有子匹配项a。  
	    for(key in r0){   
			document.write(key + "=>" + r0[key] + "<br/>");   
		} 
		for(key in r){   
			document.write(key + "=>" + r[key] + "<br/>");   
		}  
	}
	MatchDemo();
	</script>

运行结果： IE：运行结果：（FF,Safari，Chrome）

<script type="text/javascript">
	var r, regExpG; // 声明变量。  
	var s = "The rrain in Spain falls mainly in the plain";  
	    
	regExp= /(\w+)in/i; // 创建正则表达式模式。  
	regExpG = /(\w+)in/ig; // 创建正则表达式模式。 
	function execDemo(){  
		document.write("-----------exec-------------"+ "<br/>"); 
	    r0 = regExp.exec(s); // 尝试去匹配搜索字符串。 
	    r = regExpG.exec(s); // 尝试去匹配搜索字符串。  
	    document.write(r0+ "<br/>"); 
	    document.write(r+ "<br/>");
	    for(key in r0){   
			document.write(key + "=>" + r0[key] + "<br/>");   
		} 
		for(key in r){   
			document.write(key + "=>" + r[key] + "<br/>");   
		}  
		document.write("--------while------------" + "<br/>");
		while((arr = regExpG.exec(s)) !=null){
			document.write(arr+ "<br/>"); 
			for(key in r0){   
				document.write(key + "=>" + r0[key] + "<br/>");   
			} 
		}
	}
	execDemo();
	
	</script>

运行结果： IE：运行结果：（FF,Safari，Chrome）

说明：根据手册，exec只返回匹配结果的第一个值，比如上例如果不用while循环，将只返回'rrain'，无论re表达式用不用全局标记g。但是如果为正则表达式设置了全局标记g，exec 从以 lastIndex 的值指示的位置开始查找。如果没有设置全局标志，exec 忽略 lastIndex 的值，从字符串的起始位置开始搜索。利用这个特点可以反复调用exec遍历所有匹配，等价于match具有g标志。当然，如果正则表达式忘记用g，而又用循环（比如：while、for等)，exec将每次都循环第一个，造成死循环。exec的输出将包含子匹配项。

exec如果不循环有g无g时的输出相同。

match有g和无g时输出不同

当包含分组的正则表达式进行过test,match,search这些方法之后，每个分组都被放在一个特殊的地方以备将来使用，这些存储是分组中的特殊值，我们称之为反向引用

Js代码   
var re = /(A?(B?(C?)))/;  
/*上面的正则表达式将依次产生三个分组 
(A?(B?(C?))) 最外面的 
(B?(C?)) 
(C?)*/  
str = "ABC";  
re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中  
alert(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);  
//反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用  
re = /\d+(\D)\d+\1\d+/;  
str = "2008-1-1";  
alert(re.test(str));//true  
str = "2008-4_3";  
alert(re.test(str));//false  

使用反向引用可以要求字符串中某几个位置上的字符必须相同.另外，在replace这类方法中可用特殊字符序列来表示反向引用

Js代码   
re = /(\d+)\s(\d+)/;  
str = "1234 5678";  
alert(str.replace(re,"$2 $1"));//在这个里面$1表示第一个分组1234,$2则表示5678  

search 方法：返回与正则表达式查找内容匹配的第一个子字符串的位置（偏移位）。 stringObj.search(rgExp)

参数

stringObj ：必选项。要在其上进行查找的 String 对象或字符串文字。

rgExp ：必选项。包含正则表达式模式和可用标志的正则表达式对象。

说明：如果找到则返回子字符至开始处的偏移位，否则返回-1。

Java代码 





function SearchDemo(){   
    var r, re; // 声明变量。   
    var s = "The rain in Spain falls mainly in the plain.";   
    re = /falls/i; // 创建正则表达式模式。   
    re2 = /tom/i;   
    r = s.search(re); // 查找字符串。   
    r2 = s.search(re2);   
    return("r：" + r + "；r2：" + r2);   
}   
document.write(SearchDemo());   

输出：r：18；r2：-1

replace方法：

stringObj.replace(rgExp, replacement ) 方法的参数 replacement 可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有 0 个或多个这样的参数。接下来的参数是一个整数，声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。结果为将每一匹配的子字符串替换为函数调用的相应返回值的字符串值。

<script type="text/javascript">
		Function.prototype.method = function(name,func){  
        this.prototype[name] = func;  
          
    }  
   String.method('de',function(){  
        var entity={  
            quot:'""',  
            lt:'<',  
            gt:'>'  
        }  
        return function(){  
            return this.replace(/&([^&;]+)([1]+)/g,  
                function(a,b,c,d,e){  
                    console.log("a:"+a);  
                    console.log("b:"+b);  
                    console.log("c:"+c);  
                    console.log("d:"+d);  
                    console.log("e:"+e);  
                    var r = entity[b];  
                    return typeof r ==='string'?r:a;  
                });  
        };  
   }());  
     
   console.log('&lt1&quot1&gt1;'.de()); 
	</script>

运行结果：

当包含分组的正则表达式进行过test,match,search，exec这些方法之后，每个分组都被放在一个特殊的地方以备将来使用，这些存储是分组中的特殊值，我们称之为反向引用

var re = /(A?(B?(C?)))/;  
/*上面的正则表达式将依次产生三个分组 
(A?(B?(C?))) 最外面的 
(B?(C?)) 
(C?)*/  
str = "ABC";  
re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中  
alert(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);  
//反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用  
re = /\d+(\D)\d+\1\d+/;  
str = "2008-1-1";  
alert(re.test(str));//true  
str = "2008-4_3";  
alert(re.test(str));//false

使用反向引用可以要求字符串中某几个位置上的字符必须相同.另外，在replace这类方法中可用特殊字符序列来表示反向引用

re = /(\d+)\s(\d+)/;  
str = "1234 5678";  
alert(str.replace(re,"$2 $1"));//在这个里面$1表示第一个分组1234,$2则表示5678

split方法用于把一个字符串分割成字符串数组。

语法
stringObject.split(separator,howmany)

参数	描述
separator	必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
howmany	可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

返回值
一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。

但是，如果 separator 是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）。

<script type="text/javascript">
	var r, regExpG; // 声明变量。  
	var s = "The rrain in Spain falls mainly in the plain";  
	    
	regExp= /(\w+)in/i; // 创建正则表达式模式。  
	regExpG = /(\w+)in/ig; // 创建正则表达式模式。 
	
	function SplitDemo(){  
	    r1 = s.split(regExp);
	    r1 = s.split(regExp);
	    r2 = s.split(regExpG);
	    document.write(r1+ "<br/>"); //["The ", "rra", " in ", "Spa", " falls ", "ma", "ly in the ", "pla", ""]
	    document.write(r2+ "<br/>"); //["The ", "rra", " in ", "Spa", " falls ", "ma", "ly in the ", "pla", ""]
	    
	}
	SplitDemo();
	var colorText = "red,blue,green,yellow";
	var colors1 = colorText.split(",");
	var colors2 = colorText.split(",",2);
	var colors3 = colorText.split(/[^\,]+/);//此处……号表示非，因为在【】中
	document.write(colors1+"<br/>");//["red","blue","green","yellow"]
	document.write(colors2+"<br/>");//["red","blue"]
	document.write(colors3+"<br/>");//["",",","",",",",""]
	</script>