多數(shù)時候遇到需要解碼的情況多點(diǎn), 所以會先介紹解碼decode, 后介紹編碼encode.
下文會提供Javascript C# Java三種語言下不同方法的實現(xiàn)和簡單說明, 會涉及到正則和位運(yùn)算的典型用法.
Javascript的實現(xiàn)
解碼的實現(xiàn)
1
2
3
|
function decode(s) {
return unescape(s.replace(/\\(u[0-9a-fA-F]{4})/gm, '%$1'));
}
|
unescape是用來處理%uXXXX這樣格式的字符串,
將\uXXXX替換成%uXXXX后unescape就可以處理了.
編碼的實現(xiàn)
1
2
3
4
5
|
function encode1(s) {
return escape(s).replace(/%(u[0-9A-F]{4})|(%[0-9A-F]{2})/gm, function($0, $1, $2) {
return $1 && '\\' + $1.toLowerCase() || unescape($2);
});
}
|
和解碼中相對應(yīng), 使用escape編碼,
然后將%uXXXX替換為\uXXXX,
因為escape還可能把一些字符編碼成%XX的格式,
所以這些字符還需要使用unescape還原回來.
escape編碼結(jié)果%uXXXX中的XXXX是大寫的,
所以后面的replace只處理大寫的A-F.
另一種編碼的實現(xiàn)
不使用正則和escape
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
function encode2(s) {
var i, c, ret = [],
pad = '000';
for (i = 0; i < s.length; i++) {
c = s.charCodeAt(i);
if (c > 256) {
c = c.toString(16);
ret[i] = '\\u' + pad.substr(0, 4 - c.length) + c;
} else {
ret[i] = s[i];
}
}
return ret.join('');
}
|
遍歷字符串中的字符, 那些charCode大于256的會轉(zhuǎn)換成16進(jìn)制字符串c.toString(16),
如果不足4位則左邊補(bǔ)0pad.substr(0,
4 - c.length). 結(jié)尾將遍歷的結(jié)果合并成字符串返回.
C#的實現(xiàn)
解碼的實現(xiàn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
static Regex reUnicode = new Regex(@"\\u([0-9a-fA-F]{4})", RegexOptions.Compiled);
public static string Decode(string s)
{
return reUnicode.Replace(s, m =>
{
short c;
if (short.TryParse(m.Groups[1].Value, System.Globalization.NumberStyles.HexNumber, CultureInfo.InvariantCulture, out c))
{
return "" + (char)c;
}
return m.Value;
});
}
|
正則和js中的一樣, 將XXXX轉(zhuǎn)換以16進(jìn)制System.Globalization.NumberStyles.HexNumber解析為short類型,
然后直接(char)c就能轉(zhuǎn)換成對應(yīng)的字符, ""
+ (char)c用于轉(zhuǎn)換成字符串類型返回.
由于正則中也有\uXXXX,
所以需要寫成\\uXXXX來表示匹配字符串\uXXXX,
而不是具體的字符.
上面使用到了Lambda, 需要至少dotnet 4的SDK才能編譯通過, 可以在dotnet 2下運(yùn)行.
編碼的實現(xiàn)
1
2
3
4
5
6
|
static Regex reUnicodeChar = new Regex(@"[^\u0000-\u00ff]", RegexOptions.Compiled);
public static string Encode(string s)
{
return reUnicodeChar.Replace(s, m => string.Format(@"\u{0:x4}", (short)m.Value[0]));
}
|
和C#的解碼實現(xiàn)正好相反, 0-255之外的字符, 從char轉(zhuǎn)換成short,
然后string.Format以16進(jìn)制,
至少輸出4位.
Java的實現(xiàn)
解碼的實現(xiàn)
和C#相似的, 使用正則
1
2
3
4
5
6
7
8
9
10
11
12
|
static final Pattern reUnicode = Pattern.compile("\\\\u([0-9a-zA-Z]{4})");
public static String decode1(String s) {
Matcher m = reUnicode.matcher(s);
StringBuffer sb = new StringBuffer(s.length());
while (m.find()) {
m.appendReplacement(sb,
Character.toString((char) Integer.parseInt(m.group(1), 16)));
}
m.appendTail(sb);
return sb.toString();
}
|
Java語言沒有內(nèi)嵌正則語法, 也沒有類似C#的@"\u1234"原始形式字符串的語法,
所以要表示正則中匹配\,
就需要\\\\,
其中2個是用于Java中字符轉(zhuǎn)義, 2個是正則中的字符轉(zhuǎn)義.
Java語言中沒有設(shè)計函數(shù)或者委托的語法, 所以它的正則庫提供的是find appendReplacement appendTail這些方法的組合,
等價于js和C#中的replace.
這里使用StringBuffer類型是由于appendReplacement只接受這個類型, StringBuffer有線程安全的額外操作,
所以性能差一點(diǎn). 也許第三方的正則庫能把API設(shè)計的更好用點(diǎn).
Integer.parseInt(m.group(1),
16)用于解析為int類型,
之后再(char),
以及Character.toString轉(zhuǎn)換成字符串.
解碼的另一種實現(xiàn)
因為StringBuffer的原因,
不使用正則的實現(xiàn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public static String decode2(String s) {
StringBuilder sb = new StringBuilder(s.length());
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (c == '\\' && chars[i + 1] == 'u') {
char cc = 0;
for (int j = 0; j < 4; j++) {
char ch = Character.toLowerCase(chars[i + 2 + j]);
if ('0' <= ch && ch <= '9' || 'a' <= ch && ch <= 'f') {
cc |= (Character.digit(ch, 16) << (3 - j) * 4);
} else {
cc = 0;
break;
}
}
if (cc > 0) {
i += 5;
sb.append(cc);
continue;
}
}
sb.append(c);
}
return sb.toString();
}
|
手工做就是麻煩很多, 代碼中也一坨的符號.
遍歷所有字符chars,
檢測到\u這樣的字符串,
檢測后續(xù)的4個字符是否是16進(jìn)制數(shù)字的字符表示. 因為Character.isDigit會把一些其它語系的數(shù)字也算進(jìn)來,
所以保險的做法'0'
<= ch && ch <= '9'.
Character.digit會把0-9返回為int類型的0-9,
第2個參數(shù)是16時會把a-f返回為int類型的10-15.
剩下的就是用|=把各個部分的數(shù)字合并到一起,
轉(zhuǎn)換成char類型. 還有一些調(diào)整遍歷位置等.
編碼的實現(xiàn)
考慮到Java正則的杯具, 還是繼續(xù)手工來吧, 相對解碼來說代碼少點(diǎn).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public static String encode(String s) {
StringBuilder sb = new StringBuilder(s.length() * 3);
for (char c : s.toCharArray()) {
if (c < 256) {
sb.append(c);
} else {
sb.append("\\u");
sb.append(Character.forDigit((c >>> 12) & 0xf, 16));
sb.append(Character.forDigit((c >>> 8) & 0xf, 16));
sb.append(Character.forDigit((c >>> 4) & 0xf, 16));
sb.append(Character.forDigit((c) & 0xf, 16));
}
}
return sb.toString();
}
|
對應(yīng)于上文Java編碼的實現(xiàn)正好是反向的實現(xiàn), 依舊遍歷字符, 遇到大于256的字符, 用位運(yùn)算提取出4部分并使用Character.forDigit轉(zhuǎn)換成16進(jìn)制數(shù)對應(yīng)的字符.
剩下就是sb.toString()返回了.
總結(jié)
-
編碼從邏輯上比解碼簡單點(diǎn).
-
對付字符串, js還是最順手的, 也方便測試.
-
位運(yùn)算的性能很高.
-
Java的正則庫設(shè)計的很不方便, 可以考慮第三方.
-
Java的語法設(shè)計現(xiàn)在看來呆板, 落后, 也沒有js那種靈活.
-
上文Java的非正則實現(xiàn)可以寫成等價的C#代碼.
轉(zhuǎn)：http://netwjx./blog/2012/07/07/encode-and-decode-unicode-escape-string/
