Flex (actionscript3.0)字符串处理类MyStringUtils.as

做项目的过程中，难免要用到一些个公共的处理类，比如 字符串 日期 格式化 数组等。本人写的一个字符串处理类，希望大家指点交流。

功能包括：

1,处理xml相关的字符，因为在跟后台java打交道时，这个问题经常遇到:把xml里面的特殊字符转换成替代字符

2,判断空

3,去除两头的空格

4,取得指定字符在串中的位置

5,截取字符串

6,从开始下标截取一定长度的字符串

7,将字符串转换为数组

8,替换字符串

9,替换全部字符串

10,反转字符: abc==>cba

11,取得某个字符的ASCII码

12,取得某个位置的字符

13,大小写转换

14,将字符转换成boolean值

15,去除头部的空格

16,去除尾部的空格

17,是否以某个字符串开头

18,是否以某个字符串开头[忽略大小写]

19,判断是否以某个字符串结尾

20,判断是否以某个字符串结尾[忽略大小写]

21,判断是否是数字

22,比较是否相同

23,按照某个标识分割成数组

24,判断是否包含

25,与UTF-8编码的相互转换

2. //
3. //  My System
4. //  Copyright 2008-2009 My Systems Incorporated
5. //  All Rights Reserved.
6. //
7. //  NOTICE: My System permits you to use, modify, and distribute this file
8. //  Langversion ActionScript 3.0
9. //  playerversion Flash 9.0
10. //  DATE: 2008-12-04 keren
11. //  QQ: 994251681
12. //  MSN: keren1515@hotmail.com
13. //
15. package org.app.utils.common
16. {
17.     import mx.utils.StringUtil;
18.     /**
19.      * 注意：/unnnn,表示十六进制的unicode编码；
20.      *      /xnn ,表示十六进制的ascii编码；
21.      */ 
22.     public class MyStringUtils
23.     {
24.         private static var instance:MyStringUtils;
25.         public static function getInstance():MyStringUtils{
26.             if(instance == null){
27.                 instance = new MyStringUtils(new SingletonEnforcer());
28.             }
29.             return instance;
30.         }
31.         public function MyStringUtils(enforcer:SingletonEnforcer)
32.         {
33.             if(enforcer==null)throw new Error("This class is singletonEnforcer.");
34.         }
35.         
36.         public static var C_EMPTY:String = "";//空
37.         public static var C_BLANK:String = " ";//空格
38.         public static var C_NEW_LINE:String = "/n";//新行
39.         public static var C_TAB:String = "/t";//Tab符
40.         public static var C_BACKSAPCE:String = "/b";//回退符
41.         public static var C_NEXTPAGE:String = "/f";//制表符（换页格式符）
42.         public static var C_RETURN:String = "/r";//回车符
43.         /** 用在 encodeXML(String) 和 decodeXML(String) */
44.         private var translateArray:Array = [
45.             [ "&", "&" ],//这个要放在第一位
                [ " ", " "],
                [ "<", "&lt;" ],
                [ ">", "&gt;" ],
                [ "/"", "&quot;" ],
                [ "'", "&apos;" ],
                [ "", "&szlig;" ],
                [ "/"", "&quot;" ]
46.         ];
47.         
48.         /**
49.          * 把xml里面的特殊字符转换成替代字符
50.          */ 
51.         public function encodeXML(text:String):String{
52.             var s:String = text;
53.             for (var i:int = 0; i < translateArray.length; i++) {
54.                 s = this.replaceAll(s, translateArray[i][0], translateArray[i][1]);
55.             }
56.             return s;
57.         }
58.         /**
59.          * 把替代字符还原成xml字符
60.          */
61.         public function decodeXML(text:String):String{
62.             var s:String = text;
63.             for (var i:int = 0; i < translateArray.length; i++) {
64.                 s = this.replaceAll(s, translateArray[i][1], translateArray[i][0]);
65.             }
66.             return s;
67.         }
68.         
69.         /**
70.          * 判断空
71.          */ 
72.         public function isEmpty(str:String):Boolean{
73.             if(str == null)return true;
74.             str = this.trim(str);
75.             if(str == null || str.length<=0)return true;
76.             return false;
77.         }
78.         
79.         /**
80.          * 去除两头的空格
81.          */ 
82.         public function trim(str:String):String{
83.             return StringUtil.trim(str);
84.         }
85.         
86.         /**
87.          * 取得字符串位置
88.          * @param String src 操作的字符串
89.          * @param String str 匹配的串
90.          * @param int index 开始的位置[默认值：0]
91.          * 
92.          * @return int 返回匹配的位置，－1表示没有匹配的
93.          */ 
94.         public function indexOf(src:String, str:String, index:int=0):int{
95.             //if(this.isEmpty(src)||this.isEmpty(str))return -1;
96.             return src.indexOf(str,index);
97.         }
98.         /**
99.          * 取得字符串位置
100.          * @param String src 操作的字符串
101.          * @param String str 匹配的串
102.          * @param int index 开始的位置[默认值：字符串长度-1]
103.          * 
104.          * @return int 返回匹配的位置，－1表示没有匹配的
105.          */ 
106.         public function lastIndexOf(src:String, str:String, index:int=-1):int{
107.             //if(this.isEmpty(src)||this.isEmpty(str))return -1;
108.             //if(index==-1)index=src.length-1;//默认值：字符串长度-1
109.             //return src.lastIndexOf(str,index);
110.             
111.             if(index == -1)
112.                 return src.lastIndexOf(str);
113.             else
114.                 return src.lastIndexOf(str, index);
115.         }
116.         
117.         /**
118.          * 截取字符串
119.          * [注] 1,substring方法中，如果参数为负数，会自动转化为0；
120.          *      2,substring方法中，如果结束下标小于开始下标，表示反向截取；
121.          * @param String src 源串
122.          * @param int start 起始位置
123.          * @param int end 结束位置
124.          * 
125.          * @return String 截取的串
126.          */ 
127.         public function subString(src:String, index_start:int=0, 
128.                                 index_end:int=-1):String{
129.             if(index_end ==-1){
130.                 return src.substring(index_start);
131.             }else{
132.                 return src.substring(index_start, index_end);
133.             }
134.         }
135.         
136.         /**
137.          * 从开始下标截取一定长度的字符串
138.          * [注]start:-1表示倒数第一个字符；－2表示倒数第二个字符，依次类推;
139.          *     若指定的长度超过了剩余的长度，则取剩余的全部长度;
140.          * @param String src 源串
141.          * @param int start 开始位置
142.          * @param int length 截取长度
143.          * 
144.          * @return String 截取的串
145.          */ 
146.         public function substr(src:String, start:int, length:int=-1):String{
147.             if(length ==-1){
148.                 return src.substr(start);
149.             }else{
150.                 return src.substr(start, length);
151.             }
152.         }
153.         
154.         // search(正则表达式) match()?????/
155.         
156.         /**
157.          * 将字符串转换为数组
158.          * @param String src 源串
159.          * @param String ch 标识串
160.          * 
161.          * @return Array 以标识分割的字符串数组
162.          */ 
163.         public function toArray(src:String, ch:String):Array{
164.             return src.split(ch);
165.         }
166.         
167.         /**
168.          * 替换字符串
169.          * @param String src 源串
170.          * @param String from_ch 被替换的字符
171.          * @param String to_ch 替换的字符
172.          * @param Boolean rp_all 是否替换掉全部匹配字符,true:是|false：否
173.          * 
174.          * @return String 结果字符串
175.          */ 
176.         public function replace(src:String, from_ch:String, 
177.                         to_ch:String, rp_all:Boolean=false):String{
178.             while(src.indexOf(from_ch)!=-1){
179.                 src = src.replace(from_ch, to_ch);
180.                 if(!rp_all)return src;
181.             }
182.             return src;
183.         }
184.         /**
185.          * 替换全部字符串
186.          * @param String src 源串
187.          * @param String from_ch 被替换的字符
188.          * @param String to_ch 替换的字符
189.          * 
190.          * @return String 结果字符串
191.          */ 
192.         public function replaceAll(src:String, from_ch:String,
193.                                 to_ch:String):String{
194.             return src.split(from_ch).join(to_ch);
195.         }
196.         
197.         /**
198.          * 反转字符: abc==>cba
199.          * @param String src 源串
200.          * 
201.          * @return String 反转之后的串
202.          */ 
203.         public function reverse(src:String):String{
204.             var arr:Array = src.split("");
205.             arr = arr.reverse();
206.             return arr.join("");
207.         }
208.         
209.         /**
210.          * 取得某个字符的ASCII码
211.          */ 
212.         public function charCodeAt(src:String, index:int):int{
213.             return src.charCodeAt(index);
214.         }
215.         
216.         /**
217.          * 取得某个位置的字符
218.          */ 
219.         public function charAt(src:String, index:int):String{
220.             return src.charAt(index);
221.         }
222.         
223.         /**
224.          * 大小写转换
225.          */ 
226.         public function toUpperCase(src:String):String{
227.             return src.toUpperCase();
228.         }
229.         public function toLowerCase(src:String):String{
230.             return src.toLowerCase();
231.         }
232.         
233.         /**
234.          * 将字符转换成boolean值
235.          */ 
236.         public function booleanValue(src:String):Boolean{
237.             var trimmed:String = this.trim(src).toLowerCase();
238.             return trimmed == "true"
239.                 || trimmed == "t"
240.                 || trimmed == "yes"
241.                 || trimmed == "1";
242.         }
243.         
244.         /**
245.          * 去除头部的空格
246.          */ 
247.         public function trimLeadingWhitespace(src:String):String{
248.             var ch:String;
249.             var index:int = 0;
250.             while((ch = src.charAt(index)) == C_BLANK){
251.                 index++;
252.             }
253.             return this.subString(src, index);
254.         }
255.         /**
256.          * 去除尾部的空格
257.          */ 
258.         public function trimTrailingWhitespace(src:String):String{
259.             var ch:String;
260.             var index:int = src.length-1;
261.             while((ch = src.charAt(index)) == C_BLANK){
262.                 index--;
263.             }
264.             return this.subString(src, 0, index+1);//注意这里要＋1
265.         }
266.         
267.         /**
268.          * 是否以某个字符串开头
269.          */ 
270.         public function startsWith(src:String, prefix:String):Boolean{
271.             if(this.isEmpty(src) || this.isEmpty(prefix)) return false;
272.             if(src.length < prefix.length) return false;
273.             return src.indexOf(prefix) == 0;
274.         }
275.         
276.         /**
277.          * 是否以某个字符串开头[忽略大小写]
278.          */
279.         public function startsWithIgnoreCase(src:String, prefix:String):Boolean{
280.             if(this.isEmpty(src) || this.isEmpty(prefix)) return false;
281.             if(src.length < prefix.length) return false;
282.             var tmp:String = src.toLowerCase();
283.             var s:String = prefix.toLowerCase();
284.             return tmp.indexOf(s) == 0;
285.         }
286.         /**
287.          * 是否以某个字符串结尾
288.          */
289.         public function endsWith(src:String, suffix:String):Boolean{
290.             if(this.isEmpty(src) || this.isEmpty(suffix)) return false;
291.             if(src.length < suffix.length) return false;
292.             return src.lastIndexOf(suffix) == src.length - suffix.length;
293.         }
294.         /**
295.          * 是否以某个字符串结尾[忽略大小写]
296.          */
297.         public function endsWithIgnoreCase(src:String, suffix:String):Boolean{
298.             if(this.isEmpty(src) || this.isEmpty(suffix)) return false;
299.             if(src.length < suffix.length) return false;
300.             var tmp:String = src.toLowerCase();
301.             var s:String = suffix.toLowerCase();
302.             return tmp.lastIndexOf(s) == tmp.length - s.length;
303.         }
304.         
305.         /**
306.          * 是否是数字
307.          */ 
308.         public function isNumeric(src:String):Boolean{
309.             if (this.isEmpty(src)) return false;
310.             var regx:RegExp = /^[-+]?/d*/.?/d+(?:[eE][-+]?/d+)?$/;
311.             return regx.test(src);
312.         }
313.         
314.         /**
315.          * 是否相同
316.          */ 
317.         public function equals(src:String, dest:String):Boolean{
318.             return src == dest;//?????
319.         }
320.         public function equalsIgnoreCase(src:String, dest:String):Boolean{
321.             var t:String = src.toLowerCase();
322.             var s:String = dest.toLowerCase();
323.             return s == t;//?????
324.         }
325.         
326.         /**
327.          * 按照某个标识分割成数组
328.          */ 
329.         public function split(src:String, flg:String):Array{
330.             return src.split(flg);
331.         }
332.         
333.         /**
334.          * 包含
335.          */ 
336.         public function contains(src:String, flg:String):Boolean{
337.             return src.indexOf(flg) !=- 1;
338.         }
339.         
340.         /**
341.          * 把字符串转换成UTF-8的编码
342.          */ 
343.         public function encodeUTF(src:String):String{
344.             return encodeURIComponent(src);
345.         }
346.         /**
347.          * 从UTF-8转换成原来的编码
348.          */ 
349.         public function decodeUTF(src:String):String{
350.             return decodeURIComponent(src);
351.         }
352.         
353.         
354.         
355.         
356.     }//end class
357.     
358. }//end package
359. /**
360.  * 这里使用了一个内部类 SingletonEnforcer ，
361.  * 在类对外是无法访问的，所以巧妙的阻止了用new来创建，
362.  * 但还是能使用 new Singleton(null) 来创建。
363.  */
364. class SingletonEnforcer {}