/**
* <P> Title: JavaScript Util </P>
* <P> Description: JavaScript 工具 </P>
* <P> Modify: 2011/11/30 </P>
* @author 馮萬里
* @version 1.0
*
* 為減少 js 關鍵詞的佔用,此檔案只佔用“c$”一個關鍵詞;
* 使用時用: c$.函式名(引數列表); 或者 c$().函式名(引數列表)
* 字串操作函式、日期操作函式、陣列操作函式等,直接增加到 String、Date、Array 類裡面,便於直接使用
*/ /**
* 獲取元素,或者在DOM載入完成時執行某函式
* @param arg 此引數為字串時,認為是 c$.getElement 的縮寫,用來獲取元素。用法參考 c$.getElement
* 如果 arg 是 function 則認為是 c$.ready 的縮寫,在dom載入完成時執行。沒有此引數則返回 c$ 物件。
* @param dom 需要選擇的DOM物件,預設是 window.document
* @return 沒有arg引數時返回 c$ 物件，arg引數是字串時返回查詢的元素，arg引數是函式時沒有返回內容。
*
* @example
* c$("mytext") // 返回 id 或者 name 為"mytext"的元素
* c$("#mytext") // 返回 id 為"mytext"的元素
* c$("@mytext") // 返回 name 為"mytext"的所有元素
* c$(".class1") // 返回 class 為"class1"的所有元素
* c$("$div") // 返回 標籤 為"div"的所有元素
* c$("$div #text1") // 返回 div 標籤裡面 id 為"text1"的元素(支援多級查詢，以空格分隔)
* c$(function(){alert('執行DOM載入完成事件');}); // 為 c$.ready(fun) 的縮寫
*
* c$.函式名(引數列表) // 呼叫這工具類裡面的函式
* c$().函式名(引數列表) // 呼叫這工具類裡面的函式
*/
var c$ = window.c$ = function(arg, dom) {
// 如果沒有引數，則返回 本物件；讓程式可以這樣寫： c$().函式名(引數列表)
if (arguments.length === ) return c$;
if (typeof arg == 'function') return c$.ready(arg);
// 有引數則呼叫獲取元素的函式,為 c$.getElement 的縮寫
return c$.getElement(arg, dom);
}; /**
* 這是錯誤除錯程式(僅IE、fiefox有效,w3c標準裡面沒有此定義)
* 當頁面發生錯誤時，提示錯誤訊息；僅測試環境裡會提示，正式環境下不提示錯誤。
* 注意：chrome、opera 和 safari 瀏覽器不支援 onerror 事件
* @param msg 出錯訊息
* @param url 出錯檔案的地址
* @param sLine 發生錯誤的行
* @return true 返回true,會消去 IE下那個惱人的“網頁上有錯誤”的提示
*/
window.onerror = function(msg, url, sLine) {
// 測試時可以提示出錯資訊；正式釋出時不提示
if (c$.isTest) {
var errorMsg = "當前頁面的javascript發生錯誤.\n\n";
errorMsg += "錯誤: " + msg + "\n";
errorMsg += "URL: " + url + "\n";
errorMsg += "行: " + sLine + "\n\n";
errorMsg += "點選“確定”消去此錯誤，“取消”保留此錯誤。\n\n";
return window.confirm( errorMsg );
}
// 返回true,會消去 IE下那個惱人的“網頁上有錯誤”的提示
return true;
}; /**
* 是否測試環境
* @return 如果是本機或者區域網，則認為是測試環境(為 true)； 其它則認為是正在釋出的環境(為 false)
* @example if (c$.isTest) alert('這是測試環境'); // 注意,這個是值,不是函式
*/
c$.isTest = (function() {
var url = window.location.href;
// 判斷網址,如果是本機或者區域網，則認為是測試環境
return (url.indexOf("http://localhost") === || url.indexOf("http://127.0.0.1") === ||
url.indexOf("http://192.168.") === || url.indexOf("file://") === );
})(); /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
* 瀏覽器相容 start
* --------------------------------------------------------------- */ /**
* 執行平臺判斷(是否 windows)
* @return 如果是 windows 平臺則為“true”，其它平臺則返回“false”
* @example if (c$.isWin) alert('這是 window 平臺'); // 注意,這個是值,不是函式
*/
c$.isWin = (window.navigator.appVersion.toLowerCase().indexOf("win") != -); /**
* 獲取瀏覽器型別
* @return [瀏覽器名稱, 版本]
* @example if (c$.browser()[0] == 'IE') alert('這是 IE 瀏覽器, 版本號為:' + c$.browser()[1]);
*/
c$.browser = function() {
var thisFun = arguments.callee;
// 如果曾經獲取過,不用再重複判斷,以提高效率
return thisFun._retValue || (thisFun._retValue = (function() {
var ua = window.navigator.userAgent.toLowerCase();
if (ua.indexOf('msie') > -) return ['IE', ua.match(/msie ([\d.]+)/)[]];
if (ua.indexOf('firefox') > -) return ['Firefox', ua.match(/firefox\/([\d.]+)/)[]];
if (ua.indexOf('opera') > -) return ['Opera', ua.match(/opera.([\d.]+)/)[]];
if (ua.indexOf('chrome') > -) return ['Chrome', ua.match(/chrome\/([\d.]+)/)[]];
if (ua.indexOf('safari') > -) return ['Safari', ua.match(/version\/([\d.]+)/)[]];
return ['Other', null];
})());
}; /**
* 瀏覽器判斷(注意,以下這些是值,不是函式)
* @example
* if (c$.browser.isIE) alert('這是 IE 瀏覽器');
* if (c$.browser.isIE6) alert('這是 IE6 瀏覽器');
* if (c$.browser.isNav) alert('這是 Netscape 瀏覽器');
* if (c$.browser.isFF) alert('這是 Firefox 瀏覽器');
* if (c$.browser.type == 'IE') alert('這是 IE 瀏覽器, 版本號為:' + c$.browser.version);
* alert('這是 ' + c$.browser.type + ' 瀏覽器, 版本號為:' + c$.browser.version);
*/
// 如果是火狐等瀏覽器則為“true”，IE瀏覽器則返回“false”
c$.browser.isNav = (window.navigator.appName.indexOf("Netscape") != -);
// 是否火狐
c$.browser.isFF = (window.navigator.userAgent.indexOf("Firefox") != -);
// 是否IE
c$.browser.isIE = (window.navigator.appName.indexOf("Microsoft") != -);
// 是否IE6
c$.browser.isIE6 = (window.navigator.userAgent && window.navigator.userAgent.split(";")[].toLowerCase().indexOf("msie 6.0") != -);
// 另一種獲取瀏覽器型別的寫法(值為字串),值會有: IE, Firefox, Opera, Chrome, Safari, Other
c$.browser.type = c$.browser()[];
// 瀏覽器的版本(值為字串)
c$.browser.version = c$.browser()[]; /**
* 獲取事件的 event
*/
c$.getEvent = function() {
if (c$.browser.isIE) return window.event; // IE
var func = c$.getEvent.caller;
while (func != null) {
var arg0 = func.arguments[];
if (arg0 instanceof Event) {
return arg0;
}
func = func.caller;
}
return null;
}; //標準瀏覽器就FIX,讓火狐相容IE的寫法
if (window.addEventListener) {
try {
// window.event 相容
window.constructor.prototype.__defineGetter__("event", c$.getEvent); // event.srcElement 相容；獲取瀏覽器的事件源
Event.prototype.__defineGetter__("srcElement", function(){ return this.target || this.srcElement; }); // event.fromElement 相容
Event.prototype.__defineGetter__("fromElement", function(){
var node;
if (this.type == "mouseover") {
node = this.relatedTarget;
}
else if (this.type == "mouseout") {
node = this.target;
}
if (!node) return;
while (node.nodeType != ) {
node = node.parentNode;
}
return node;
}); // event.toElement 相容
Event.prototype.__defineGetter__("toElement", function(){
var node;
if (this.type == "mouseout") {
node = this.relatedTarget;
}
else if (this.type == "mouseover") {
node = this.target;
}
if (!node) return;
while (node.nodeType != ) {
node = node.parentNode;
}
return node;
}); // <element>.runtimeStyle 相容
HTMLElement.prototype.__defineGetter__("runtimeStyle", function(){ return this.style; }); // <element>.innerText 相容 (Getter)
HTMLElement.prototype.__defineGetter__("innerText", function(){
var anyString = "";
var childS = this.childNodes;
for (var i = , length = childS.length; i < length; i++) {
if (childS[i].nodeType == )
anyString += childS[i].tagName == "BR" ? '\n' : childS[i].innerText;
else if(childS[i].nodeType == ) {
anyString += childS[i].nodeValue;
}
}
return anyString;
});
// <element>.innerText 相容 (Setter)
HTMLElement.prototype.__defineSetter__("innerText", function(sText) { this.textContent = sText; });
} catch(e){}
}
/* -------------------------------------------------------------------
* 瀏覽器相容 end
* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */ /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
* 內建物件額外新增函式 start
* --------------------------------------------------------------- */ /**
* 去除字串的前後空格
* @return 去除前後空格後的字串
* @example " dd dd ".trim() // 返回: "dd dd"
*/
String.prototype.trim = function(direct) {
return this.replace(new RegExp("(^(\\s* *)*)|((\\s* *)*$)", "g"), "");
}; /**
* 全部替換字串中的指定內容(正則表示式替換)
* @param regexp 把字串裡的regexp內容替換成newSubStr(此引數會作為正則表示式的字串處理)
* @param newSubStr 把字串裡的regexp內容替換成newSubStr
* @param flags 正則表示式的匹配方式,有: g global(全文查找出現的所有 pattern),i ignoreCase(忽略大小寫),m multiLine(多行查詢)；預設是 "gm"
* @return 替換後的字串。注意：當regexp為空時,字串的每個字前面都會加上newSubStr
* @example
* "add dda".replaceAll('a', '55') // 返回: "55dd dd55"
* "add+d+da".replaceAll('\\+', ' ') // 支援正則表示式的字串替換,特殊字元需要轉義,返回: "add d da"
*/
String.prototype.replaceAll = function(regexp, newSubStr, flags) {
regexp = regexp || '';
newSubStr = newSubStr || '';
flags = flags || 'gm';
var raRegExp = new RegExp("" + regexp, flags);
return this.replace(raRegExp, "" + newSubStr);
}; /**
* 全部替換字串中的指定內容(非正則表示式替換)
* @param oldStr 要替換的內容
* @param newStr 替換成這個內容
* @return 替換後的字串。注意：當 oldStr 為空時,不會替換
* @example
* "add dda".replaceAllStr('a', '55') // 返回: "55dd dd55"
* "add+d+da".replaceAllStr('+', ' ') // 不支援正則表示式的字串替換,返回: "add d da"
*/
String.prototype.replaceAllStr = function(oldStr, newStr) {
if (!oldStr) return this;
var str = this;
while(str.indexOf(oldStr) != -) str = str.replace(oldStr, newStr);
return str;
}; /**
* 判斷是否以子串開頭
* @param sub 被判斷的子串
* @return 是以子串開頭則返回 true，否則返回false
*/
String.prototype.startWith = function(sub) {
if (this === sub || sub === '') return true;
return this.length >= sub.length && this.slice(, sub.length) === sub;
}; /**
* 判斷是否以子串結尾
* @param sub 被判斷的子串
* @return 是以子串結尾則返回 true，否則返回false
*/
String.prototype.endWith = function(sub) {
if (this === sub || sub === '') return true;
return this.length >= sub.length && this.slice( - sub.length) === sub;
}; /**
* 字串格式化輸出
* @param value 格式化的物件內容(說明: 1. 屬性名稱區分大小寫; 2. 沒有匹配到到屬性輸出原始字串。)
* @return 格式化後的字串
* @example "#1 Name:#Name, Age:#Age".format({Name:"zhangsan", Age:23 }); // 返回："#1 Name:zhangsan, Age:23"
*/
String.prototype.format = function(value) {
return this.replace(new RegExp('#\\w+', 'gi'), function(match) {
var name = match.substring();
return value.hasOwnProperty(name) ? value[name] : match;
});
}; /**
* 獲取字元長度
* @param chsLength 一個非拉丁文(如中文)佔多少個字元，預設為2個 (改資料庫時需改這裡)
* @return 字元長度
* @example "aa哈哈".chsLeng() // 返回: 6
*/
String.prototype.chsLeng = function(chsLength) {
chsLength = (parseInt(chsLength) >= ) ? parseInt(chsLength) : ;
//去除非拉丁文(如中文)的長度
var noChsLength = this.replace(new RegExp('[^\x00-\xff]','gm'), "").length;
//中文長度
var chineseLength = (this.length - noChsLength) * chsLength;
return noChsLength + chineseLength;
}; /**
* 檢查字串是否包含中文，是則返回true，否則返回false (注:空字串返回 false)
* @param isAllChinese 是否要求全部都為中文
* @return 不填 isAllChinese，或者 isAllChinese 為 false 時，只要包含有中文即返回true，不包含一箇中文則返回false
* @return 當 isAllChinese 為 true 時，要求字串全部都為中文則返回 true，如果有一個不為中文則返回false
*
* @example
* "aa哈哈".hasChinese() // 返回: true
* "aa哈哈".hasChinese(true) // 返回: false
*/
String.prototype.hasChinese = function(isAllChinese) {
if ("" === this) return false;
//去除中文的長度
var noChsLength = this.replace(new RegExp('[^\x00-\xff]','gm'), "").length;
// \u4E00-\u9FA5 是漢字, \uFE30-\uFFA0 是全形符號, \u3002 是句號， \u201C \u201D 是雙引號
// var noChsLength = this.replace(new RegExp('([\u4E00-\u9FA5]|[\uFE30-\uFFA0]|[\u3002\u201C\u201D])','gm'), "").length;
return isAllChinese ? (noChsLength === ) : (noChsLength < this.length);
}; /**
* 檢查字串是否只由漢字、字母、數字組成
* @return boolean 如果通過驗證返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isChineseOrNumberOrLetter = function() {
return new RegExp("^[0-9a-zA-Z\u4e00-\u9fa5]+$").test(this);
}; /**
* 檢查字串是否只由數字、26個英文字母或者下劃線組成
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isNumber_Letter = function() {
return new RegExp("^\\w+$",'g').test(this);
}; /**
* 檢查字串是否只由數字、26個英文字母組成
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isNumberLetter = function() {
return new RegExp("^[A-Za-z0-9]+$",'g').test(this);
}; /**
* 檢查字串是否為email地址
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isEmail = function() {
return new RegExp("^[a-z0-9][a-z0-9\\-_.]*[a-z0-9]+@(([a-z0-9]([a-z0-9]*[-_]?[a-z0-9]+)+\\.[a-z0-9]+(\\.[a-z0-9]+)?)|(([1-9]|([1-9]\\d)|(1\\d\\d)|(2([0-4]\\d|5[0-5])))\\.(([\\d]|([1-9]\\d)|(1\\d\\d)|(2([0-4]\\d|5[0-5])))\\.){2}([1-9]|([1-9]\\d)|(1\\d\\d)|(2([0-4]\\d|5[0-5])))))$",'gi').test(this.trim());
}; /**
* 檢查字串是否為日期格式(正確格式如: 2011-03-28 或者 11/3/28, 2011年03月28日, 20111028)
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isDate = function() {
// 匹配檢查
var r = this.hasChinese() ?
this.match(/^(\d{,})(年)((?[-])|([-]))月((?[-])|([]\d)|([]))日?$/) : // 中文處理
this.match(/^(\d{,})(-|\/|\.)?((?[-])|([-]))\((?[-])|([]\d)|([]))$/);
if ( r == null ) return false;
// 日期是否存在檢查
var d = new Date(r[], r[]-, r[]);
return ((d.getFullYear()==r[] || d.getYear()==r[]) && (d.getMonth()+)==r[] && d.getDate()==r[]);
}; /**
* 檢查字串是否為時間格式(正確格式如: 13:04:06 或者 21時5分10秒, 210521)
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isTime = function() {
// 匹配檢查
var a = this.hasChinese() ?
this.match(/^(\d{,})([時時])(\d{,})分(\d{,})秒(\d+([毫微納納諾諾皮可飛飛阿託]秒)?)?$/) : // 中文處理
this.match(/^(\d{,})(:)?(\d{,})\(\d{,})([.]?\d+)?$/);
if (a == null) return false;
// 時間檢查
if (a[]>= || a[]>= || a[]>=) return false;
// 如果有“:”來分隔時間,則秒後面的數也要求有“.”來分隔
if (a[]==':' && a[] && a[].indexOf('.')==-) return false;
// 驗證成功
return true;
}; /**
* 檢查字串是否為日期和時間格式 (正確格式如: 2003/12/05 13:04:06 或者 2001年10月20日10時5分30秒, 20110208230406)
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isDateTime = function() {
var dateTimes = this.split(' ');
// 中文時,可以不用空格隔開日期和時間
if (dateTimes.length != && this.indexOf('日') != -) {
dateTimes = this.split('日');
dateTimes[] += '日';
}
// 無符號時,可以不用空格隔開日期和時間
if (dateTimes.length != && this.indexOf(':') == -
&& this.indexOf('-') == - && this.indexOf('/') == - && this.indexOf('.') == -) {
// 完整日期和時間
if (this.length >= ) {
dateTimes[] = this.substr(, );
dateTimes[] = this.substr();
}
// 短日期和時間,認為日期部分為6位
else {
dateTimes[] = this.substr(, );
dateTimes[] = this.substr();
}
}
// 英文時，必須空格隔開日期和時間
if (dateTimes.length != ) return false;
return (dateTimes[].isDate() && dateTimes[].isTime());
}; /**
* 檢查字串是否為URL地址
* @return boolean 符合返回true,否則返回false (注:空字串返回 false)
*/
String.prototype.isUrl = function() {
return /^(ftp|http|https):\/\/(\w+:{,}\w*@)?(\S+)(:[-]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/.test(this);
}; /**
* 轉換字串成 Unicode 編碼
* @return 轉換後的字串
* @example "哈,哈".toUnicode() 返回: "\u54C8\u002C\u54C8"
*/
String.prototype.toUnicode = function() {
// 注，不會編碼的字元： * + - . / @ _ 0-9 a-z A-Z
return escape(this).
// 替換中文
replace(new RegExp('%u[0-9a-f]{4}', 'gim'), function(match) {
return '\\' + match.substring();
}).
// 替換英文符號
replace(new RegExp('%[0-9a-f]{2}', 'gim'), function(match) {
return "\\u00" + match.substring();
});
}; /**
* 轉換字串成 Html 頁面上顯示的編碼
* @return 轉換後的字串
* @example "<div>".toHtmlCode() 返回: "<div>"
*/
String.prototype.toHtmlCode = function() {
var div = document.createElement('div');
var text = document.createTextNode(this);
div.appendChild(text);
return div.innerHTML;
}; /**
* 轉換字串由 Html 頁面上顯示的編碼變回正常編碼(以 toHtmlCode 函式對應)
* @return 轉換後的字串
* @example " ".toTextCode() // 返回: " "
*/
String.prototype.toTextCode = function() {
// 以下逐一轉換
var sour = this.
replaceAll("%", "%"). // 百分號
replaceAll("<", "<", "gim").replaceAll("<", "<"). // 小於號
replaceAll(">", ">", "gim").replaceAll(">", ">"). // 大於號
replaceAll("'", "'"). // 單引號
replaceAll("+", "+"). // 加號
replaceAll("\n?<br\\s*/?>\n?", "\n", "gim"). // 換行符
replaceAll(""", '"', "gim").replaceAll(""", '"'). // 雙引號
replaceAll(" ", " ", "gim").replaceAll(" ", " "). // 空格
replaceAll("(&)|(&)", "&", "gim"); // & 符號,為避免二次轉換,最後才轉換
return sour;
}; /**
* 清除HTML標籤
* @return 清除標籤後的內容
* @example "<div>haha</div>".removeHtmlTag() 返回: "haha"
*/
String.prototype.removeHtmlTag = function() {
var text = this.trim().
replaceAll("<!--.*-->", ""). // 清除註釋
replaceAll("</title>", "\n", "gim"). // 標題換行: </title> ==> 換行符
replaceAll("</tr>", "\n", "gim"). // tr換行: </tr> ==> 換行符
replaceAll("<[^>]+>", ""). // html標籤清除
toTextCode(); // 轉換字串由 Html 頁面上顯示的編碼變回正常編碼
return text;
}; /**
* 格式化時間字串
* @param format 格式化的字串(預設為：yyyy-MM-dd HH:mm:ss )
* @return 格式化時間後的字串
* @example new Date().format("yyyy-MM-dd HH:mm:ss.S")
*/
Date.prototype.format = function(format) {
// 預設顯示格式
format = format || "yyyy-MM-dd HH:mm:ss"; var o = {
"M{1,2}" : this.getMonth()+, // 月份 (返回1~12,或者01~12)
"d{1,2}" : this.getDate(), // 日期 (返回1~31,或者01~31)
"[h|H]{1,2}" : this.getHours(), // 小時 (返回1~23,或者01~23)
"m{1,2}" : this.getMinutes(), // 分鐘 (返回1~59,或者01~59)
"s{1,2}" : this.getSeconds(), // 秒 (返回1~59,或者01~59)
"q{1,2}" : Math.floor((this.getMonth()+)/), // 季度 (返回1~4,或者01~04)
"S" : this.getMilliseconds() // millisecond (返回1~999,或者01~99) 注意，“S”只能寫一個
} // 年份處理
if (/([y|Y]+)/.test(format)) {
format = format.replace(RegExp.$,(this.getFullYear()+"").substr( - RegExp.$.length));
}
// 逐個處理
for (var k in o) {
if (new RegExp("("+ k +")").test(format)) {
format = format.replace(RegExp.$, (RegExp.$.length == ? o[k] :(""+ o[k]).substr((""+ o[k]).length)));
}
}
return format;
}; // opera瀏覽器 沒有 陣列的 concat 函式,相容它
if (!Array.prototype.concat) {
Array.prototype.concat = function() {
var array = [];
for (var i = , length = this.length; i < length; i++) array.push(this[i]);
for (var i = , length = arguments.length; i < length; i++) {
if(arguments[i].constructor == Array) {
for(var j = , arrayLength = arguments[i].length; j < arrayLength; j++) {
array.push(arguments[i][j]);
}
} else {
array.push(arguments[i]);
}
}
return array;
};
} /**
* 陣列的逐個執行
* @param func 對數組裡的每個元素執行的函式
* @return 返回陣列本身,以便使用連綴
*
* @example
* var arr = [1, 2, 3];
* arr.each(function(value, i){
* alert(value); // 會把逐個值 alert 處理
* alert(this.length); // 這裡面的 this 是指被呼叫的陣列 arr
* });
*/
Array.prototype.each = function(func) {
for (var i = , length = this.length; i < length; i++) func.call(this, this[i], i);
return this;
}; /**
* 清空陣列
* @return 返回本陣列(即清空後的情況,可以不接收返回值,原陣列已經被清空)
*
* @example
* var arr = [1, 2, 3];
* arr.clear();
* alert(arr.length); // 提示為0
* alert(arr[0]); // 提示為 undefined
*/
Array.prototype.clear = function() {
this.length = ;
return this;
}; /**
* 查詢數組裡的某個值的下標
* @param value 要查詢的值
* @return 查詢到的值的下標,有多個這樣的值時返回第一個查詢到的下標,找不到則返回 -1
*
* @example
* var arr = ['a', 'b', 'c'];
* arr.indexOf('c'); // 返回 2
*/
Array.prototype.indexOf = function(value) {
for (var i = , length = this.length; i < length; i++) {
if (this[i] === value) return i;
}
return -;
}; /**
* 查詢數組裡的某個值的下標(從後面找起)
* @param value 要查詢的值
* @return 查詢到的值的下標,有多個這樣的值時返回最後一個查詢到的下標,找不到則返回 -1
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c'];
* arr.lastIndexOf('c'); // 返回 4
*/
Array.prototype.lastIndexOf = function(value) {
for (var i = this.length - ; i > ; i--) {
if (this[i] === value) return i;
}
return -;
}; /**
* 複製陣列(淺拷貝)
* @return 返回複製後的陣列
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c'];
* var arr2 = arr.clone(); // 返回的是另一個數組,對 arr2 的操作不再影響 arr
*/
Array.prototype.clone = function() {
return [].concat(this);
}; /**
* 判斷數組裡是否包含此值
* @param object 要查詢的值, 可以有多個
* @return 只有一個引數時：包含有則返回 true,沒有則返回 false；有多個引數時,要求每一個引數都包含才返回 true,否則返回 false
* 注：引用物件的判斷,只是簡單判斷引用地址是否相等,不判斷裡面的值
*
* @example
* var arr = ['a', 'b', 'c'];
* arr.contains('c'); // 返回 true
* arr.contains('d'); // 返回 false
* arr.contains('c', 'a'); // 返回 true
* arr.contains('a', 'd'); // 返回 false
*/
Array.prototype.contains = function(value) {
for (var i=; i < arguments.length; i++) {
if (this.indexOf(arguments[i]) === -) return false;
}
return true;
}; /**
* 刪除數組裡的某些值(只刪除第一個找到的值)
* @return 返回陣列本身,以便使用連綴
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c'];
* arr.remove('c'); // 此時的陣列刪除了第一個'c', 為: ['a', 'b', 'd', 'c']
* arr.remove('a', 'd'); // 還可以同時刪除多個值, 此時為: ['b', 'c']
* arr.remove('e'); // 傳入數組裡面沒有的值,不對陣列產生影響,也不會出現異常, 此時為: ['b', 'c']
*/
Array.prototype.remove = function() {
for (var i = ; i < arguments.length; i++) {
var value = arguments[i];
var index = this.indexOf(value);
if (index > -) this.splice(index, );
}
return this;
}; /**
* 刪除數組裡的某些值(刪除所有找到的值)
* @return 返回陣列本身,以便使用連綴
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c'];
* arr.removeAll('c'); // 此時的陣列刪除了所有的'c', 為: ['a', 'b', 'd']
* arr.removeAll('a', 'd'); // 還可以同時刪除多個值, 此時為: ['b']
* arr.removeAll('e'); // 傳入數組裡面沒有的值,不對陣列產生影響,也不會出現異常, 此時為: ['b']
*/
Array.prototype.removeAll = function() {
var index;
for (var i = ; i < arguments.length; i++) {
var value = arguments[i];
// 賦值給 index 且判斷是否大於 -1, 避免獲取兩次 index 以提高效率
while ((index = this.indexOf(value)) > -) {
this.splice(index, );
}
}
return this;
}; /**
* 返回沒有重複值的新陣列,原陣列不改變
* @return 返回過濾重複值後的新陣列
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c', null];
* var arr2 = arr.unique(); // arr2 為: ['a', 'b', 'd', 'c', null]
*/
Array.prototype.unique = function() {
var result = [];
for (var i=,l=this.length; i<l; i++) {
for (var j=i+; j<l; j++) {
if (this[i] === this[j]) j = ++i;
}
result.push(this[i]);
}
return result;
}; /**
* 對陣列中的每個元素都執行一次指定的函式
* 並且建立一個新陣列，該陣列元素是所有回撥函式執行時返回值為 true 的原陣列元素。原陣列不改變
* @param func 對數組裡的每個元素執行的函式
* @return 以陣列形式返回執行函式時返回值為 true 的原陣列元素
*
* @example
* var arr = [1, 23, 54, 67, 42, 66];
* var arr2 = arr.filter(function (value, index) {
* alert(this.length); // 這裡面的 this 是指被呼叫的陣列 arr
* return value % 2 === 0; // 返回偶數
* });
* alert(arr2); // 值為: [54, 42, 66]
*/
Array.prototype.filter = function(func) {
var result = [], array = this;
this.each(function(value, index) {
if (func.call(array, value, index)) result.push(value);
});
return result;
}; /**
* 以陣列形式返回原陣列中不為 null 與 undefined 的元素。原陣列不改變
* @return 以陣列形式返回原陣列中不為 null 與 undefined 的元素
*
* @example
* var arr = ['a', 'b', 'c', 'd', 'c', null];
* var arr2 = arr.notNull(); // arr2 為: ['a', 'b', 'c', 'd', 'c']
*/
Array.prototype.notNull = function() {
return this.filter(function (value) {
return value != null;
});
}; /**
* 返回數組裡的最大值
* 如果數組裡有不能直接轉成數值的值,或者有 NaN,則返回 NaN；空值按0處理,能轉成數值的字串會被轉成數值處理
* @return 返回數組裡的最大值(number型別)
*
* @example
* var arr = ['66', 44, 32.1, null];
* var arr2 = ['66', 44, 32.1, null, 'a'];
* alert( arr.max() ); // 值為: 66
* alert( arr2.max() ); // 值為: NaN
*/
Array.prototype.max = function() {
return Math.max.apply(null,this);
}; /**
* 返回數組裡的最小值
* 如果數組裡有不能直接轉成數值的值,或者有 NaN,則返回 NaN；空值按0處理,能轉成數值的字串會被轉成數值處理
* @return 返回數組裡的最小值(number型別)
*
* @example
* var arr = ['66', 44, 32.1, null, -1];
* var arr2 = ['66', 44, 32.1, null];
* alert( arr.min() ); // 值為: -1
* alert( arr2.min() ); // 值為: 0
*/
Array.prototype.min = function() {
return Math.min.apply(null,this);
}; /* -------------------------------------------------------------------
* 內建物件額外新增函式 end
* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */ /**
* 獲取單選按鈕對應的編號和名稱
* @param boxName 單選按鈕的name (注:不能根據id來查詢)
* @param init 單選按鈕的預設值
* @return 返回被選中的當選按鈕的value
*/
c$.getRadioValue = function(boxName, init) {
init = init || '';
var elements = document.getElementsByName(boxName);
// 如果沒有找到所要的單選按鈕，則直接返回
if (!elements) return init; // 如果只有一個單選按鈕
if ("radio" === elements.type && elements.checked) {
return elements.value;
}
// 迴圈檢查選中哪個
for (var i = , length = elements.length; i < length; i++) {
//如果選中此單選按鈕
if ("radio" === elements[i].type && elements[i].checked) {
return elements[i].value;
}
} return init;
}; /**
* checkbox全選: 全部勾上 或者全部不選
* @param checkboxList checkbox列表,可一個或者多個
* @param checked 為true則勾上，為false則全部不勾上；沒有這引數則以列表的第一個的反選為準
* @return c$ 物件本身，以支援連綴
*/
c$.selectAll = function(checkboxList, checked) {
// 沒有時選擇所有的checkbox
if (!checkboxList) {
var inputList = document.getElementsByTagName('INPUT');
checkboxList = [];
for (var i = , length = inputList.length; i < length; i++) {
if (inputList[i].type === "checkbox") checkboxList.push(inputList[i]);
}
// 沒有一個checkbox時,不用再執行
if ( checkboxList.length == ) return this;
}
// 沒有這引數時
if ( typeof(checked) === 'undefined' ) {
checked = ( "checkbox" === checkboxList.type ) ? (!checkboxList.checked) : (!checkboxList[].checked);
}
// 保證 checked 為 boolean 值
checked = !!checked;
// 只有一個時
if ( "checkbox" === checkboxList.type ) {
checkboxList.checked = checked;
}
// 兩個或者兩個以上時
else {
for ( var i = , length = checkboxList.length; i < length; i++ ) {
checkboxList[i].checked = checked;
}
}
return this;
}; /**
* 建立一個類
* @param arg 類裡面的屬性和方法,其中 init 或者 initialize 屬性可作為類的初始化函式
* @return 擴充套件後的類(可以不接收引數,原被擴充套件的類會被修改而引用不變)
*
* @example
* // 初始化類
* var Student = c$.create({
* init: function(name, age) {this.name=name; this.age=age;},
* show: function(){alert('name: ' + this.name + ' age:' + this.age);}
* });
* var stu1 = new Student('jack', 23); // new 一個實體類
* stu1.show();
* var stu2 = new Student('tom', 25); // 再 new 一個實體類
* stu2.show();
*/
c$.create = function(arg) {
function _fun() {
if (this.init && typeof this.init == 'function') this.init.apply(this, arguments);
else if (this.initialize && typeof this.initialize == 'function') this.initialize.apply(this, arguments);
}
if (arg && typeof arg == 'object') _fun.prototype = arg;
return _fun;
}; /**
* 類的擴充套件
* @param destination 被擴充套件的類
* @param 要擴充套件的內容
* @return 擴充套件後的類(可以不接收引數,原被擴充套件的類會被修改而引用不變)
*
* @example
* var a = new Object();
* c$.extend(a, {
* alertStr: function(str){alert(str);}
* });
* a.alertStr('要提示的內容'); // 呼叫
*/
c$.extend = function(destination, source) {
for (var property in source) {
destination[property] = source[property];
}
return destination;
}; /**
* 獲取物件的所有鍵的陣列
* @param object 物件
* @return 物件的所有鍵的陣列
*/
c$.keys = function(object) {
var keys = [];
for (var property in object) {
keys.push(property);
}
return keys;
}; /**
* 獲取物件的所有值的陣列
* @param object 物件
* @return 物件的所有值的陣列
*/
c$.values = function(object) {
var values = [];
for (var property in object) {
values.push(object[property]);
}
return values;
}; /**
* 返回某物件的複製(淺拷貝)
* @param object 物件
* @return 物件的所有值的陣列
*/
c$.clone = function(object) {
return c$.extend({}, object);
}; /**
* 將物件轉換成字串
* @param strValue 包含字串的物件
* @return 物件的字串
*/
c$.toStr = function(strValue) {
if (strValue || === strValue || false === strValue) return ("" + strValue);
// 不能轉換的返回空字串
return "";
}; /**
* 轉成 int 型別
* @param str 需轉換的字串
* @return int 數值,轉換不成功則返回0
*/
c$.toInt = function(str) {
//return (parseInt(str, 10) || 0);
return str >> ;
}; /**
* 轉成 float 型別
* @param str 需轉換的字串
* @return float 數值,轉換不成功則返回0
*/
c$.toFloat = function(str) {
return (parseFloat(str) || );
}; /**
* 把數值轉化成指定的數值字串,指定小數位,可加逗號
* @param value 需轉化的數值
* @param decimal 小數位。不指定則有小數的預設兩位,沒小數的不加小數(捨去部分會四捨五入)
* @param signNumber 數字每隔多少位加一個逗號，預設不加逗號
* @return 處理後的數值字串
* @example c$.toNumberStr('15154514541.6471', 2, 3) // 返回字串: 15,154,514,541.65
*/
c$.toNumberStr = function(value, decimal, signNumber) {
var retValue = "";
//如果沒有value值,賦值為0
value = value || "";
//如果不是數值
if (false === c$.isNumber(value)) value = ""; //去除前後空格,去除數值中的逗號
value = ("" + value).trim().replaceAll(",");
//去除非數值，以及0開頭的內容
value = "" + parseFloat(value); //分解字串； number[0]為整數部分， number[1]為小數部分
var number = value.split(".");
//如果字串是個整數
if ( === number.length) number[] = "";
number[] = ""; //如果是負數
if ( === value.indexOf("-")) {
number[] = number[].replace("-", "");
retValue += "-";
}
//如果是加號開頭
if ( === value.indexOf("+")) {
number[] = number[].replace("+", "");
retValue += "+";
} //如果沒有設定小數字，看數值情況，有小數的預設兩位，沒小數的不加小數
if (!decimal && !== decimal && value.indexOf(".") > ) decimal = ;
decimal = decimal>>; // 取整
//如果是科學計數法的數字
if (number[].indexOf("e") > ) {
var numberArry = number[].split("e");
number[] = numberArry[];
number[] = "e" + numberArry[];
decimal -= parseInt(numberArry[]);
}
//如果指定保留多少位小數
if ( < decimal) {
//給結果補足要求保留的小數字
for (var i = ; i < decimal; i++) {
number[] += "";
}
//四捨五入
var tem_number = retValue + number[] + number[].substring(, decimal) + "." + number[].substring(decimal, number[].length);
tem_number = "" + Math.round(tem_number);
var intLength = (retValue + number[]).length;
number[] = tem_number.substring(intLength, intLength + decimal);
} signNumber = signNumber>>; // 取整
//如果需要分隔數字
if ( < signNumber) {
//整數的第一部分的長度
var tem = number[].length % signNumber;
//如果整數部分的長度剛好是signNumber的倍數
if ( === tem) tem = signNumber;
//整數的第一部分
retValue += number[].substring(, tem);
//整數的其他部分
for (var i = ; i < parseInt((number[].length + signNumber - ) / signNumber); i++) {
var j = (i - ) * signNumber + tem;
retValue += "," + number[].substring(j, j + signNumber);
}
}
//如果不需要分隔數字
else {
retValue += number[];
} // 如果有小數則加上
if ((number[] + number[]).length > ) retValue += "." + number[] + number[]; // 返回數值字串
return retValue;
}; /**
* 獲取 form 表單的所有元素(僅 input, checkbox 等可以表單提交的元素)
* @param formField 表單(沒有引數則是整個頁面的所有 form),給出的不是 form 元素而是 div,table 之類的元素也可以
* @return 返回一個數組,裡面儲存著獲取的元素
*/
c$.getElements = function(formField) {
//儲存元素
var elements = [];
// 如果傳入的是字串,則根據此字串獲取物件
if (typeof formField === 'string') formField = c$(formField);
// 獲取指定form的元素
if (c$.isElement(formField)) {
if (formField.tagName == 'FORM') {
elements = formField.elements;
}
// 如果給出的不是form,而是div之類的,照樣獲取裡面可提交的元素
else {
elements = formField.getElementsByTagName('INPUT');
var selects = formField.getElementsByTagName('SELECT');
if (selects && selects.length > ) {
for(var i=, length = selects.length; i<length; i++){
elements.push(selects[i]);
}
}
var textareas = formField.getElementsByTagName('TEXTAREA');
if (textareas && textareas.length > ) {
for(var i=, length = textareas.length; i<length; i++){
elements.push(textareas[i]);
}
}
}
}
// 獲取form的所有元素
else {
var formArray = document.forms;
for (var i = ; i < formArray.length; i++) {
formField = formArray[i];
for (var j = , length = formField.length; j < length; j++) {
elements.push(formField[j]);
}
}
}
// 返回元素列表
return elements;
}; /**
* 檢查窗體是否可送出
* @param formField 待檢查的form,給出的不是 form 元素而是 div,table 之類的元素也可以
* @param type 提示型別,有： alert(逐步提示,縮寫A)、confirm(逐步判斷,縮寫C)、show(文字顯示,縮寫S,預設是show)
* 注: 以 alert 或者 confirm 提示資訊時,只要有其中一個驗證不正確則不再驗證下面,直接返回 false,避免不斷地alert；而show則驗證完整個form
* 如果 type 是 show 型別,且需要指定頁面顯示位置,則可指定顯示元素的id或者name,如: type={id:'顯示元素的id', name:'顯示元素的name'}
* @return boolean 檢查是否通過
*
* @example
* <form action="#">
* <table>
* <tr>
* <td>名稱：<input name="txt1" type="text" checkType="R{請輸入名稱}S{id:'error1'}" onchange="c$.checkElement(this)"/></td>
* <td id="error1"> </td>
* </tr>
* <tr>
* <td>金額：<input name="txt2" type="text" checkType="S{id:'error2'}F{max:999.99, min:0, dec:2, msg:'請輸入正確的金額'}" onchange="c$.checkElement(this)"/></td>
* <td id="error2"> </td>
* </tr>
* <tr>
* <td>人數：<input name="txt3" type="text" checkType="S{id:'error3'}R{請輸入人數}I{max:999, min:0, msg:'請輸入正確的人數'}" onchange="c$.checkElement(this)"/></td>
* <td id="error3"> </td>
* </tr>
* </table>
* <input type="submit" value="提交" onclick="return c$.checkForm(this.form);" />
* </form>
*/
c$.checkForm = function(formField, type) {
// 型別預設是 show,
type = type || 'show';
// 轉成小寫
type = typeof(type)=='string' ? type.toLowerCase() : type; var return_value = true;
//元素列表
var elements = c$.getElements(formField); //檢查窗體的所有元素
for (var index=, length=elements.length; index < length; index++) {
if (false === c$.checkElement(elements[index], type)) {
return_value = false;
// alert 和 confirm 驗證需要中斷,避免不斷地提示
if (type === 'alert' || type === 'a' || type === 'confirm' || type === 'c') return false;
}
}
//檢查通過
return return_value;
}; /**
* 檢查一個元素
* @param element 需檢查的元素
* @param type 提示型別,有： alert(縮寫A)、confirm(縮寫C)、show(文字顯示,縮寫S,預設是show)
* 如果 type 是 show 型別,且需要指定頁面顯示位置,則可指定顯示元素的id或者name,如: type={id:'顯示元素的id', name:'顯示元素的name'}
* @retrn boolean 檢查通過返回true,否則返回false
*
* @example
* <input id="txt1" name='txt1' type="text" checkType="R{請輸入金額}F{max:999.99, min:0, dec:2, msg:'請輸入正確的金額'}" />
* <input type="submit" value="提交" onclick="return c$.checkElement(document.getElementById('txt1'));" />
*
* 說明: 檢查型別的關鍵詞需緊跟大括號,不跟大括號則提示“M”的訊息或者預設的訊息;
* 使用“C”關鍵詞則是選擇提示框,點選“確定”可忽略此提示
* 大括號裡面的 msg 屬性是對應的提示訊息,需用引號括起來; 大括號裡面沒有冒號則認為全是提示訊息; 注:不能巢狀大括號
*/
c$.checkElement = function(element, type) {
//防呆
if (!element) return true;
// 型別預設是 show,
type = type || 'show';
// 轉成小寫
type = typeof(type)=='string' ? type.toLowerCase() : type; //所有需檢查訊息
var message = c$.toStr(element.getAttribute("checkType")).trim();
if (''===message)return true;//防呆
//獲取需檢查的型別,去除大括號裡面的內容
var checkType = message.replace(new RegExp("({[^}]*})*", 'g'), "").toUpperCase();
var value = element.value; //驗證型別
//必須輸入 (用法: checkType="R{請輸入名稱}" 或者 checkType="R{msg:'請輸入名稱'}" 或者 checkType="M{請輸入名稱}R")
var R_pos = (checkType.indexOf('R') > -); //整型 (用法: checkType="I{max:100, min:-50, name:'人數'}" 或者 checkType="I{min:-50,max:100,msg:'請輸入正確的人數'}")
// 注:有 name 屬性時, msg 屬性將不會生效; name屬性是提示訊息的名稱; 屬性 max, min 分別表示最大值最小值(含)
var I_pos = (checkType.indexOf('I') > -); //浮點型 (用法: checkType="F{max:999.99, min:0, dec:2, name:'金額'}" 或者 checkType="F{dec:2,max:999.99,msg:'請輸入正確的金額'}")
// 注:有 name 屬性時, msg 屬性將不會生效; name屬性是提示訊息的名稱; dec 屬性表示小數字數限制; 屬性 max, min 分別表示最大值最小值(含)
var F_pos = (checkType.indexOf('F') > -); //驗證字母數字 (用法: checkType="E{ID只能是字母和數字}" 或者 checkType="E{msg:'ID只能是字母和數字'}")
var E_pos = (checkType.indexOf("E") > -); //驗證字母數字下劃線 (用法: checkType="N{ID只能是字母,數字和下劃線}")
var N_pos = (checkType.indexOf("N") > -); //驗證輸入長度 (用法: checkType="L{len:100, msg:'名稱長度不能超過100'}")
var L_pos = (checkType.indexOf("L") > -); //驗證 email (用法: checkType="@{請輸入正確的郵箱地址}")
var EMail_pos = (checkType.indexOf("@") > -); //驗證 日期 (用法: checkType="D{日期輸入不正確}" 或者 checkType="D{msg:'日期輸入不正確'}")
var D_pos = (checkType.indexOf("D") > -); //驗證 時間 (用法: checkType="T{時間輸入不正確}" 或者 checkType="T{msg:'時間輸入不正確'}")
var T_pos = (checkType.indexOf("T") > -); //驗證 日期和時間 (用法: checkType="V{時間輸入不正確}" 或者 checkType="V{msg:'時間輸入不正確'}")
var V_pos = (checkType.indexOf("V") > -); //驗證 URL (用法: checkType="U{URL地址輸入不正確}" 或者 checkType="U{msg:'URL地址輸入不正確'}")
var U_pos = (checkType.indexOf("U") > -); // 共享的提示訊息,可以多個驗證都提示此一個(用法: M{提示訊息})
var M_pos = (checkType.indexOf('M') > -); //確認提示框,以提示框的形式提示出來,並可以選擇是否忽略此提示
var C_pos = (checkType.indexOf('C') > -) || type === 'confirm' || type === 'c'; // 直接顯示到頁面,不使用提示框
// 用法: 建議在函式的type引數上設值,也可以在元素上設定: checkType="R{請輸入名稱}S{id:'text1', name:'text1'}" 或者 checkType="SR{請輸入名稱}"
// 可根據屬性 id 或者 name 獲取要顯示的位置,不寫引數則預設顯示在節點的後面； 顯示內容使用 .innerHTML 追加進去,紅色字型顯示
var S_pos = (checkType.indexOf('S') > -) || type === 'show' || type === 's' || !!(type.id) || !!(type.name); var thisFun = arguments.callee;
/*
* 獲取所需檢查的型別的類別(匿名函式,僅供此函式內部使用; 快取此函式以減少記憶體消耗)
* @param key 對應的鍵
* @param message 所有需檢查訊息
* @return Object 所需檢查的型別的類別
*/
var getCheckTypeObj = thisFun.getCheckTypeObj || (thisFun.getCheckTypeObj = function(key, message) {
var upMess = message.toUpperCase();
// 如果此關鍵詞沒有跟大括號,返回空類別
if (upMess.indexOf(key + "{") < ) return {};
// 取出對應的大括號的訊息
var key_mess = message.substring(upMess.indexOf(key + "{")+);
key_mess = key_mess.substring(, key_mess.indexOf('}') + );
try {
// 將大括號的訊息轉成的類別
eval("var tem_obj = " + key_mess);
return tem_obj;
}
catch (e) {
// 如果大括號裡面的訊息不能轉成類別,則認為它全是提示訊息
return {msg: key_mess.substring(, key_mess.length - )};
}
}); /*
* 提示出對應的訊息(匿名函式,僅供此函式內部使用)
* @param key 對應的鍵
* @param element 需檢查的元素
* @param message 所有需檢查訊息
* @param iniMess 預設的提示訊息
* @return boolean 一般都返回false,僅當顯示選擇框點選“是”時返回true
*/
var showDialog = thisFun.showDialog || (thisFun.showDialog = function(key, element, message, C_pos, S_pos, iniMess) {
// 獲取提示訊息
var alert_message = (getCheckTypeObj(key, message).msg || getCheckTypeObj("M", message).msg || iniMess) + "!"; c$.setFocus(element); // "C"型別用 confirm 選擇框
if (C_pos) return confirm(alert_message);
// "S"型別用文字顯示到頁面
if (S_pos) {
var tem_obj = getCheckTypeObj("S", message);
// 建立一個物件來顯示內容
var font = document.createElement('font');
font.color = 'red';
// 以 element 作為提示元素的標誌
font.element = element;
font.innerHTML = alert_message; var showElement = null;
if (tem_obj.id) showElement = document.getElementById(tem_obj.id);
else if (tem_obj.name) showElement = document.getElementsByName(tem_obj.name)[];
else if (type.id) showElement = document.getElementById(type.id);
else if (type.name) showElement = document.getElementsByName(type.name)[]; // 沒有獲取到顯示的元素,或者設定id或者name屬性時,追加到節點後面
if (!showElement) {
document.body.appendChild(font);
// 插入到元素的後面
var pos = element.nextSibling;
pos.parentNode.insertBefore(font, pos);
}
else {
showElement.appendChild(font);
var br = document.createElement('br');
br.element = element;
showElement.appendChild(br);
}
}
else {
// 使用 alert 提示出來
alert(alert_message);
}
return false;
}); // 頁面顯示提示資訊時,先清除頁面的舊顯示
if (S_pos) {
var tem_obj = getCheckTypeObj("S", message);
var showElement = null;
if (tem_obj.id) showElement = document.getElementById(tem_obj.id);
else if (tem_obj.name) showElement = document.getElementsByName(tem_obj.name)[];
else if (type.id) showElement = document.getElementById(type.id);
else if (type.name) showElement = document.getElementsByName(type.name)[]; // 沒有獲取到顯示的元素,或者設定id或者name屬性時,追加到節點後面
if (!showElement) {
var nextElement = element.nextSibling;
if (nextElement && nextElement.tagName && nextElement.element === element) {
nextElement.parentNode.removeChild(nextElement);
}
}
else {
var childs = showElement.childNodes;
for (var i=, length = childs.length; i < length; i++) {
if (childs[i] && childs[i].tagName && childs[i].element === element) {
showElement.removeChild(childs[i]); // 刪除 font 標籤
showElement.removeChild(childs[i]); // 刪除 br 標籤
break;
}
}
}
} //一定要輸入
if (R_pos && "" === value && false === showDialog("R", element, message, C_pos, S_pos, "請輸入必要的值")) {
return false;
}
//可以不輸入時
else if ("" === value) {
return true;
}
//驗證整形
if (I_pos) {
var tem_obj = getCheckTypeObj("I", message);
if (S_pos) {
var checkResult = c$.isInt(element, tem_obj.max, tem_obj.min, tem_obj.name, false, S_pos);
if (true !== checkResult && false === showDialog("I", element, message, C_pos, S_pos, checkResult.errMessage || "請輸入正確的整數值")) return false;
}
else if (false === c$.isInt(element, tem_obj.max, tem_obj.min, tem_obj.name, false)) {
//有name屬性時按名稱提示,這裡不用重複提示; 否則取提示訊息
if (tem_obj.name || false === showDialog("I", element, message, C_pos, S_pos, "請輸入正確的整數值")) {
return false;
}
}
}
//驗證浮點型
if (F_pos) {
var tem_obj = getCheckTypeObj("F", message);
if (S_pos) {
var checkResult = c$.isNumber(element, tem_obj.max, tem_obj.min, tem_obj.dec, tem_obj.name, false, S_pos);
if (true !== checkResult && false === showDialog("F", element, message, C_pos, S_pos, checkResult.errMessage || "請輸入正確的數值")) return false;
}
else if (false === c$.isNumber(element, tem_obj.max, tem_obj.min, tem_obj.dec, tem_obj.name, false)) {
//有name屬性時按名稱提示,這裡不用重複提示; 否則取提示訊息
if (tem_obj.name || false === showDialog("F", element, message, C_pos, S_pos, "請輸入正確的數值")) {
return false;
}
}
}
//驗證輸入長度
if (L_pos) {
var tem_obj = getCheckTypeObj("L", message);
if (value.length > tem_obj.len && false === showDialog("L", element, message, C_pos, S_pos, "輸入的內容超過長度了，請縮短內容")) {
return false;
}
}
//驗證字母數字組合
if (E_pos && false === value.isNumberLetter() && false === showDialog("E", element, message, C_pos, S_pos, "此處只能輸入字母和數字")) return false;
//驗證字母數字下劃線組合
if (N_pos && false === value.isNumber_Letter() && false === showDialog("N", element, message, C_pos, S_pos, "此處只能輸入字母、數字和下劃線")) return false;
//email驗證
if (EMail_pos && false === value.isEmail() && false === showDialog("@", element, message, C_pos, S_pos, "請輸入正確的郵箱地址")) return false;
//日期驗證
if (D_pos && false === value.isDate() && false === showDialog("D", element, message, C_pos, S_pos, "請輸入正確的日期")) return false;
//時間驗證
if (T_pos && false === value.isTime() && false === showDialog("T", element, message, C_pos, S_pos, "請輸入正確的時間")) return false;
//日期和時間驗證
if (V_pos && false === value.isDateTime() && false === showDialog("V", element, message, C_pos, S_pos, "請輸入正確的時間")) return false;
//URL驗證
if (U_pos && false === value.isUrl() && false === showDialog("U", element, message, C_pos, S_pos, "請輸入正確的URL地址")) return false; //檢查通過
return true;
}; /**
* 整數檢查，判斷物件是否為數字(包括負數、科學記數法、逗號分隔的數)
* @param element 需檢查的物件,或者是字串
* @param max 最大值(含), 預設為 2147483647
* @param min 最小值(含), 預設為 -2147483648
* @param name 提示的訊息的名稱
* @param isMust 是否可以為空,true表示不可以為空, 否則可為空
* @param isAlert 是否以alert提示出錯資訊,為true時返回出錯資訊但不提示,否則以alert提示。驗證沒錯時,不管 isAlert 是什麼值都將返回 true
* 注： isAlert 為false或者沒有這引數時,直接 alert 提示出錯資訊,返回結果是 true 或 false。
* 但 isAlert 為true,且出錯時,將返回結果物件：{result:true|false, errMessage:'出錯資訊'}
* @return boolean 驗證符合則返回true,否則返回false
* @example if(c$.isInt(document.getElementById("amt"), 9999999, -9999999, "人數", flase))...
*/
c$.isInt = function(element, max, min, name, isMust, isAlert) {
// 沒有最大值時,預設為整型的最大值
if (typeof(max) !== 'number') {
max = ;
}
// 沒有最大值時,預設為整型的最大值
if (typeof(min) !== 'number') {
min = -;
}
return c$.isNumber(element, max, min, , name, isMust, isAlert);
}; /**
* 數字檢查，判斷物件是否為數字(包括負數、科學記數法、逗號分隔的數)
* @param element 需檢查的物件,或者是字串
* @param max 最大值(含)
* @param min 最小值(含)
* @param decimal 小數多少位
* @param name 提示的訊息的名稱
* @param isMust 是否可以為空,true表示不可以為空, 否則可為空
* @param isAlert 是否以alert提示出錯資訊,為true時返回出錯資訊但不提示,否則以alert提示。驗證沒錯時,不管 isAlert 是什麼值都將返回 true
* 注： isAlert 為false或者沒有這引數時,直接 alert 提示出錯資訊,返回結果是 true 或 false。
* 但 isAlert 為true,且出錯時,將返回結果物件：{result:true|false, errMessage:'出錯資訊'}
* @return boolean 驗證符合則返回true,否則返回false
*
* @example if(c$.isNumber(document.getElementById("amt"), 9999999.999, -9999999.999, 3, "金額", flase))...
*/
c$.isNumber = function(element, max, min, decimal, name, isMust, isAlert) {
var thisFun = arguments.callee;
//出錯時: 提示訊息,設定焦點,返回true
var doError = thisFun.doError || (thisFun.doError = function(msg, name, element, isAlert) {
var tem_name = name || '此項';
msg = msg.format({ name:tem_name });
// 有 isAlert 時不提示，但返回出錯結果
if (isAlert) return {result:false, errMessage:msg};
// 有 name 屬性時提示訊息,沒有則不提示
if (name) {
c$.setFocus(element);
alert(msg);
}
return false;
}); //獲取字串
var str = element.value || element.innerHTML || "" + element;
//去除空白; 去除逗號; 轉成大寫
str = str.replace(/\s/gi, '').replace(/[,]/gi, '').toUpperCase(); //不可以為空; 提示訊息: 請輸入 name !
if (true === isMust && "" === str) return doError("請輸入 #name !", name, element, isAlert);
//可以為空
if (!isMust && "" === str) return true; //是否為數值; 提示訊息: name 不是正確的數字!
if (!str.match(/^[+-]?\d+([.]?\d*)([eE][+-]\d+)?$/g)) return doError("#name 不是正確的數字!", name, element, isAlert);
// 如果沒有指定最大值,不可以超過數值的最大值
if ( !== max && !max) max = Number.MAX_VALUE;
//判斷最大值,提示訊息: name 不能大於 max
if (parseFloat(str) > parseFloat(max)) return doError("#name 不能大於 " + max, name, element, isAlert);
// 如果沒有指定最小值,不可以小於數值的最小值
if ( !== min && !min) min = - * Number.MAX_VALUE;
//判斷最小值,提示訊息: name 不能小於 min
if (parseFloat(str) < parseFloat(min)) return doError("#name 不能小於 " + min, name, element, isAlert); //小數判斷
decimal = parseInt(decimal);
if (decimal >= && (str.indexOf(".") > - || str.indexOf("E") > -)) {
//獲取小數點後的數字
var val = str.replace(/^[+-]?\d+[.]/g, '');
val = val.replace(/*([E][+-]\d+)?$/g, '');
//小數長度
var decimalLength = val.length; //如果是科學記演算法
if (str.indexOf("E") > -) {
decimalLength = val.length - parseInt(str.substring(str.indexOf("E") + , str.length));
}
// 要求整數時; 提示訊息: name 必須是整數
if (decimal === && (decimalLength > || (str.indexOf(".") > - && str.indexOf("E") == -))) {
return doError("#name 必須是整數!", name, element, isAlert);
}
//小數位判斷; 提示訊息: name 請保留 decimal 位小數
if (decimalLength > decimal) {
return doError("#name 請保留 " + decimal + " 位小數!", name, element, isAlert);
}
}
//檢驗通過
return true;
}; /**
* 判斷物件是否函式
* 說明：因為 typeof 判斷可能會把 dom 物件、正則等判斷為 function，故此做嚴謹判斷
* @param fn 需判斷的物件
* @return 是函式則為 true, 否則為 false
*/
c$.isFunction = function(fn) {
return (!!fn && !fn.nodeName && fn.constructor != String && fn.constructor != RegExp && fn.constructor != Array && /function/i.test( fn + "" ));
}; /**
* 判斷物件是否頁面元素
* @param obj 需判斷的物件
* @return 是頁面元素則為 true, 否則為 false
*/
c$.isElement = function(obj) {
return !!(obj && obj.nodeType == );
}; /**
* 清除form裡各元素的值
* @param form 需操作的form元素物件,預設所有form,給出的不是 form 元素而是 div,table 之類的元素也可以
* @return c$ 物件本身，以支援連綴
*/
c$.clearForm = function(form) {
//元素列表
var elements = c$.getElements(form); // 逐個元素處理
for (var i = , length = elements.length; i < length; i++) {
var tagName = elements[i].tagName.toLowerCase();
if (tagName === "textarea" || tagName === "select") {
elements[i].value = "";
continue;
} // 處理 input
// "button", "submit", "reset", "hidden", "image" 型別的不處理
if (!elements[i].type) continue;
var type = elements[i].type.toLowerCase();
// 選擇項
if ("checkbox" === type || "radio" === type) elements[i].checked = false;
// 單行輸入框, 多行輸入框, 下拉選單
else if ("text" === type || "password" === type) elements[i].value = "";
// 檔案上傳框
else if ("file" === type) {
//elements[i].value = ""; // firfox
//elements[i].outerHTML = elements[i].outerHTML; // IE
c$.clearFileInput(elements[i]); // 上面兩行的寫法也可以,只是改用這種更加好
}
}
return this;
}; /**
* 清空file的值
* @param file file元素
* @return c$ 物件本身，以支援連綴
*/
c$.clearFileInput = function(file) {
// 建立臨時form來實現
var form = document.createElement('form');
document.body.appendChild(form);
// 記住file在舊窗體中的地址
var pos = file.nextSibling;
form.appendChild(file);
form.reset();
pos.parentNode.insertBefore(file,pos);
document.body.removeChild(form);
return this;
}; /**
* 過濾數字(不符合的不讓輸入)
* @param isFloat 是否允許輸入一個小數點
* @param event 相容 IE 和 FireFox 的事件
* @example <input type="text" name="stdcost" onkeydown="return c$.inputNumber(true, event);"/>
*/
c$.inputNumber = function(isFloat, event) {
event = event || window.event;
// 獲取事件源
var source = event.target || event.srcElement;
// 不允許 shift 鍵
if ( event.shiftKey === true) return false; var keyCode = event.charCode || event.keyCode;
// 只允許輸入數字、刪除、左右鍵; 小數時可輸入一個小數點
if ( (keyCode >= && keyCode <= ) || (keyCode >= && keyCode <= ) ||
keyCode === || keyCode === || keyCode === || keyCode === ||
(isFloat && (keyCode === || keyCode === ) && source.value.length> && source.value.indexOf(".") == -)
) return true; return false;
}; /**
* 過濾字母(不符合的不讓輸入)
* @param event 相容 IE 和 FireFox 的事件
* @example <input type="text" name="stdcost" onkeydown="return c$.inputLetter(event);"/>
*/
c$.inputLetter = function(event) {
event = event || window.event;
// 不允許 ctrl 鍵和 shift 鍵
if ( event.ctrlKey === true || event.shiftKey === true) return false; var keyCode = event.charCode || event.keyCode;
// 只允許輸入字母、刪除、左右鍵
if ((keyCode >= && keyCode <= ) || keyCode == || keyCode == || keyCode == || keyCode == ) return true; return false;
}; /**
* 過濾字母數字(不符合的不讓輸入)
* @param event 相容 IE 和 FireFox 的事件
* @example <input type="text" name="stdcost" onkeydown="return c$.inputNumLetter(event);"/>
*/
c$.inputNumLetter = function(event) {
event = event || window.event;
// 不允許 ctrl 鍵和 shift 鍵
if ( event.ctrlKey === true || event.shiftKey === true) return false; var keyCode = event.charCode || event.keyCode;
// 只允許輸入字母、數字、刪除、左右鍵
if ((keyCode >= && keyCode <= ) ||
(keyCode >= && keyCode <= ) || (keyCode >= && keyCode <= ) ||
keyCode == || keyCode == || keyCode == || keyCode ==
) return true; return false;
}; /**
* 設定按鈕是否可用
* @param isDisabled 是否不可用,true為不可用，false為可用(預設可用)
* @param dom Dom物件，預設是 document
* @return c$ 物件本身，以支援連綴
*
* @example
* c$.setButtonUsed(true); // 設定頁面上所有的按鈕都不可用
* c$.setButtonUsed(); // 恢復頁面上所有的按鈕都可用
*/
c$.setButtonUsed = function(isDisabled, dom) {
isDisabled = isDisabled || false;
dom = dom || document; //INPUT物件
var obj = dom.getElementsByTagName("INPUT");
//INPUT物件判斷
for (var i = , length = obj.length; i < length; i++) {
var type = obj[i].type.toUpperCase();
if (type == "BUTTON" || type == "SUBMIT" || type == "RESET") {
obj[i].disabled = isDisabled;
}
} //BUTTON物件
var obj = dom.getElementsByTagName("BUTTON");
//INPUT物件判斷
for (var i = , length = obj.length; i < length; i++) {
obj[i].disabled = isDisabled;
}
return this;
}; /**
* 設定元素可用或者不可用
* @param objEle 元素物件(要設定多個元素可傳此引數為陣列,如果元素是iframe,則改變整個iframe)
* @param canUse 是否可用,true為可用，false為不可用(預設不可用)
* @return c$ 物件本身，以支援連綴
*
* @example
* c$.setElementDisable(document.getElementById('text1')); // 設定id為text1的元素不可用
* c$.setElementDisable(document.getElementById('text1'),true); // 恢復id為text1的元素可用
*/
c$.setElementDisable = function(objEle, canUse) {
// 防呆
if (!objEle || (!objEle.tagName && !objEle.length)) return this;
// 設定是否可用(預設不可用)
var disabled = !canUse; if (objEle.tagName) {
var tagName = objEle.tagName.toLowerCase();
// 輸入框,可用而不可寫
if ("textarea" === tagName) {
objEle.disabled = false;
objEle.readOnly = disabled;
}
// 圖片, 下拉選單, 選擇框
else if ("img" === tagName || 'button' === tagName || 'select' === tagName) {
objEle.disabled = disabled;
}
// A 標籤
else if ("a" === tagName) {
objEle.disabled = disabled;
// 修改點選事件
if (disabled) {
// 有 onclick 事件，則先備份著
if (objEle.onclick) objEle.onclick_bak = objEle.onclick;
// 修改點選事件
objEle.onclick = function(){return false;};
}
// 讓 A 可用時,讓它可點選，並還原點選事件
else {
// 有備份著 onclick 事件，則還原
if (objEle.onclick_bak) {
objEle.onclick = objEle.onclick_bak;
objEle.onclick_bak = null;
}
else {
objEle.onclick = null;
}
}
}
// iframe 框架,設定裡面的全部元素
else if ("iframe" === tagName) {
var dom = objEle.contentDocument || objEle.contentWindow.document;
// 存在跨域問題時, iframe 的 document 不可訪問
if (dom) c$.setDomDisable(canUse, dom);
}
// input 元素
else if (objEle.type) {
var type = objEle.type.toLowerCase();
// 輸入框,可用而不可寫
if ("text" === type) {
objEle.disabled = false;
objEle.readOnly = disabled;
}
// 選擇框,按鈕
else if ("radio" === type || "checkbox" === type || "button" === type || "submit" === type || "reset" === type) {
objEle.disabled = disabled;
}
}
}
// 陣列，要遞迴
else if (objEle.length) {
for (var i = , length = objEle.length; i < length; i++) {
c$.setElementDisable(objEle[i], canUse);
}
}
return this;
}; /**
* 設定整個頁面的元素都可用或者都不可用 (對frame,iframe裡面的元素暫未處理)
* @param canUse 是否可用,true為可用，false為不可用(預設不可用)
* @param dom Dom物件，預設是 document
* @param notChangeArr 不需要設定的元素的陣列
* @return c$ 物件本身，以支援連綴
*
* @example
* c$.setDomDisable(); // 設定整個頁面所有的元素都不可用
* c$.setDomDisable(true); // 恢復整個頁面所有的元素都可用
* c$.setDomDisable(false, document, [document.getElementById('btn'), document.getElementById('btn2')]); // 除id為btn,btn2的兩個元素外，設定整個頁面不可用
*/
c$.setDomDisable = function(canUse, dom, notChangeArr) {
dom = dom || window.document;
notChangeArr = notChangeArr || [];
var elements = dom.getElementsByTagName("*");
// 逐個元素遍歷修改
out: for (var i = , length = elements.length; i < length; i++ ) {
if (!elements[i] || !elements[i].tagName) continue;
// 頁面上不需更改的元素
for (var j = , len = notChangeArr.length; j < len; j++) {
// continue到外迴圈
if (elements[i] === notChangeArr[j]) continue out;
}
c$.setElementDisable(elements[i], canUse);
}
return this;
}; /**
* 設定頁面覆蓋層
* @param flag 為true則覆蓋,頁面不可操作； 否則取消覆蓋，頁面可操作
* @param zIndex 覆蓋層的z-index,預設99999
* @return c$ 物件本身，以支援連綴
*
* @example
* c$.cover(); // 取消頁面的覆蓋,頁面可操作
* c$.cover(true); // 覆蓋整個頁面,頁面不可操作
*/
c$.cover = function(flag, zIndex) {
var thisFun = arguments.callee;
// thisFun.overlay 作為覆蓋層物件,是這函式的全域性變數
// 覆蓋
if (flag === true) {
// 隱藏滾動條
var htmls = document.getElementsByTagName("html");
for (var i = , length = htmls.length; i < length; i++) {
htmls[i].style.overflow = "hidden";
}
// 不存在覆蓋層物件,則建立
if (!thisFun.overlay) {
thisFun.overlay = document.createElement("div");
// 覆蓋層樣式
var cssText = "position:absolute;";
cssText += "width:" + Math.max(document.body.scrollWidth, document.body.clientWidth) + "px;";
cssText += "height:" + Math.max(document.body.scrollHeight, document.body.clientHeight) + "px;";
cssText += "left: 0px;";
cssText += "top: 0px;";
cssText += "background-color: #D4D4D4;";
cssText += "filter:alpha(opacity=50);";
cssText += "-moz-opacity:0.50;";
cssText += "opacity:0.50;";
thisFun.overlay.style.cssText = cssText;
}
thisFun.overlay.style.zIndex = zIndex || ;
document.body.appendChild(thisFun.overlay);
}
// 取消覆蓋
else {
// 不存在覆蓋層物件,則不再操作
if (!thisFun.overlay) return this;
thisFun.overlay.parentNode.removeChild(thisFun.overlay);
// 恢復滾動條
var htmls = document.getElementsByTagName("html");
for (var i = , length = htmls.length; i < length; i++) {
htmls[i].style.overflow = "";
}
}
return this;
}; /**
* 開啟視窗(沒有高和寬引數時預設全屏)
* @param url 視窗地址
* @param name 視窗名稱
* @param width 視窗寬度
* @param height 視窗高度
* @return 返回開啟的子視窗物件
* @example c$.openWin('../common/Member.html?pform=form1&retid=Memid&retname=MemName', '');
*/
c$.openWin = function(url, name, width, height) {
// 預設寬度和高度為全屏
width = width || window.screen.width;
height = height || window.screen.height;
// 讓視窗顯示在螢幕中間
var top = (window.screen.height - height)/;
var left = (window.screen.width - width)/;
name = name || "";
var param = 'scrollbars=yes,top=' + top + ',left=' + left + ',width=' + width + ',height=' + height + ',resizable=yes';
return window.open(url, name, param);
}; /**
* 關閉視窗(IE上的關閉視窗時不提示)
* @param win 視窗物件
* @return c$ 物件本身，以支援連綴
*/
c$.closeWin = function(win) {
win = win || window;
win.opener = null; // 關閉IE6不提示
win.open("","_self"); // 關閉IE7不提示
//關閉視窗
win.close();
return this;
}; /**
* 刪除節點
* @param element 要刪除的元素
* @return c$ 物件本身，以支援連綴
* @example c$.removeElement(document.getElementById('text1')) // 刪除id為text1的節點
*/
c$.removeElement = function(element) {
if (element && element.nodeName) {
element.parentNode.removeChild(element);
}
return this;
}; /**
* 給網址加上時間戳,避免瀏覽器快取(已經有時間戳的，會修改時間戳)
* @param url 網址,沒有時使用所在頁面的地址
* @param flag 時間戳的引數名稱,預設用 timeStamp
*
* @example
* c$.addTimeStamp('http://localhost/index.html') // 返回字串： http://localhost/index.html?timeStamp=1315377347731
* c$.addTimeStamp('http://localhost/index.html?a=1&timeStamp=1315377347731') // 返回字串：http://localhost/index.html?a=1&timeStamp=1315388347762
*/
c$.addTimeStamp = function(url, flag) {
url = url || window.location.href;
// 時間戳的引數名稱
flag = flag || 'timeStamp'; // 判斷網址是否已經有時間戳,有則替換掉舊的時間戳
var flag_reg = new RegExp('([?&])' + flag + '=\\d*');
if (flag_reg.test(url)) {
return url.replace(flag_reg, RegExp.$ + flag + '=' + new Date().getTime());
} // 給網址增加時間戳引數
url += (url.indexOf("?") > ) ? "&" : "?";
url += flag + "=" + new Date().getTime();
return url;
}; /**
* 獲取URL裡面的網站域名
* @param url 網址；沒有引數時預設使用所在網頁的網址
* @return 返回網站的域名字串；不是有效網址時返回空字串
*/
c$.getHost = function(url) {
// 沒有引數時，預設用本站的
url = url || window.location.href;
// 用正則表示式來匹配
var match = url.match(/.*\:\/\/([^\/]*).*/);
// 能匹配則返回匹配的內容
if (match) return match[];
// 無法匹配(不是有效的網址)，則返回 null
return "";
}; /**
* 將 JSON 物件內容轉成字串(注：中文會被url轉碼)
* @param obj 被轉換的JSON物件
* @param key2lowerCase 是否需要將key轉成小寫,為true則轉成小寫，否則不轉
* @return 返回字串形式的json內容
* @example c$.json2str({a:1, b:[1,'2',3], c:'哈哈'}) // 返回字串: '{"a":1,"b":[1,"2",3],"c":"%E5%93%88%E5%93%88"}'
*/
c$.json2str = function (obj, key2lowerCase) {
var arr = [];
// undefined, null, false, 0, NaN, ''
if (!obj) return "" + obj;
// 轉換字串
var format = function(value) {
// 對字串的處理，URI轉碼, 以便提交資料
if (typeof value === 'string') return '"' + encodeURIComponent(value) + '"';
// 處理 日期
if (value && value.constructor === Date) return '"' + value.format() + '"';
// 處理 陣列
if (value && value.constructor === Array) {
// 使用臨時變數，避免修改源資料
var temArr = [];
for (var i=; i < value.length; i++) {
if (typeof(value[i]) == 'function') continue; // 自新增的函式,不用轉換
temArr.push(format(value[i]));
}
return '[' + temArr.join(',') + ']';
}
// 如果是 函式
if (typeof value === 'function') try { return format(value());}catch(e){ return value + ""; };
// 如果是 object, 這裡認為是 json，遞迴呼叫
if (typeof value === 'object' && value != null) return c$.json2str(value, key2lowerCase);
// undefined, null, bool, number 型別，直接返回
return value;
}
// bool, number, string, function, 陣列
if (typeof obj !== 'object' || obj.constructor === Array) return format(obj);
for (var key in obj) {
// 將key轉成小寫
var tem_key = key2lowerCase ? ("" + key).toLowerCase() : key;
arr.push('"' + encodeURIComponent(tem_key) + '":' + format(obj[key]));
}
return '{' + arr.join(',') + '}';
}; /**
* 分解URL請求引數
* @param href 網址；沒有引數時預設使用所在網頁的網址
* @param key2lowerCase 是否需要將key轉成小寫,為true則轉成小寫，否則不轉(預設不干涉)
* @return 返回json形式的引數內容
* @example c$.getRequestParams("http://localhost/index.html?d2d=哈哈&dd=oo111") // 返回物件: {d2d:'哈哈', dd:'oo111'}
*/
c$.getRequestParams = function(href, key2lowerCase) {
href = href || window.location.href;
var result = {};
var regex = /(\w+)=([^&]+)/gi;
var ms = href.match(regex);
if (ms == null) return result; for(var i = ; i < ms.length; i++) {
var ns = ms[i].match(regex);
var key = RegExp.$;
key = key2lowerCase ? ("" + key).toLowerCase() : key;
try { result[key] = decodeURIComponent(RegExp.$); }catch(e){}
} return result;
}; /**
* 對連結進行 UTF-8 編碼
* @param href 網址; 沒有網址返回空字串
* @param key2lowerCase 是否需要將key轉成小寫,為true則轉成小寫，否則不轉(預設不干涉)
* @return 返回轉編碼後的網址
* @example c$.encodeUrl("http://localhost/index.html?d2d=哈哈&dd=oo111") // 返回: "http://localhost/index.html?d2d=%E5%93%88%E5%93%88&dd=oo111"
*/
c$.encodeUrl = function(href, key2lowerCase) {
return c$.toQueryStr(null, href, key2lowerCase);
}; /**
* 把物件格式化成 URL 的引數形式
* @param obj 需要轉成引數的物件
* @param href 網址; 沒有網址則只返回格式化後的引數部分,有網址則拼接到網址上(還會修改網址上原有的值)
* @param key2lowerCase 是否需要將key轉成小寫,為true則轉成小寫，否則不轉(預設不干涉)
* @return 返回編碼後的字串
* @example
* c$.toQueryStr({d2d:'看看', b:2}, "http://localhost/index.html?d2d=哈哈&dd=oo111") // 返回: "http://localhost/index.html?d2d=%E7%9C%8B%E7%9C%8B&dd=oo111"
* c$.toQueryStr({d2d:'哈哈', b:2}) // 返回: "d2d=%E5%93%88%E5%93%88&b=2"
*/
c$.toQueryStr = function(obj, href, key2lowerCase) {
if (!href || typeof href != 'string') {
href = "";
}
// 把網址上的引數拼接到 obj 類裡面
else {
if (!obj || typeof obj != 'object') {
obj = c$.getRequestParams(href, key2lowerCase);
} else {
obj = c$.extend(c$.getRequestParams(href, key2lowerCase), obj);
}
} // 截取出網址(去掉引數部分)
var index = href.indexOf("?");
if (index > )
href = href.substring(, index) + '?'; var parts = [];
for (var key in obj) {
key = key2lowerCase ? ("" + key).toLowerCase() : key;
parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));
}
href += parts.join('&');
return href;
}; /**
* 獲取URL的引數
* @param name 要獲取的引數名稱
* @return String型別 返回獲取到的值,沒有對應的鍵時返回 null
*/
c$.getRequestValue = function(name) {
var res = new RegExp( "[\\?&]" + name + "=([^&#]*)" ).exec( window.location.href );
return res ? res[] : null;
}; /**
* 新增 onload 事件(多次呼叫此函式時會保證各函式的執行順序)
* @param fun 要新增到 onload 事件的函式
* @param win 要新增 onload 事件的視窗物件,預設為 window
* @return c$ 物件本身，以支援連綴
*/
c$.addOnloadFun = function(fun, win) {
if (!fun || typeof fun !== 'function') return this;
win = win || window; var thisFun = arguments.callee;
// thisFun.funList 作為本函式的全域性變數,保證多次呼叫本函式時可以共用
thisFun.funList = thisFun.funList || [];
thisFun.funList.push(fun);
if (thisFun.funList.length > ) return this; var doReady = function () {
var fn, i = , readyList;
if (thisFun.funList) {
// 為了減少變數查詢帶來的效能損耗，將它賦值給本地變數
readyList = thisFun.funList;
// 釋放引用
thisFun.funList = null;
while ( (fn = readyList[ i++ ]) ){
fn.call( win );
}
}
};
// IE
if (win.attachEvent) {
win.attachEvent('onload', doReady);
}
// firfox
else if (win.addEventListener) {
win.addEventListener('load', doReady, false);
} return this;
}; /**
* 獲取滑鼠的座標
* @return 返回滑鼠位置,形式如：{x: 531, y: 26}
*/
c$.getMousePos = function(ev) {
ev = ev || window.event;
var getX = ;
var getY = ;
// firfox
if (typeof(ev.pageX) == 'number') {
getX = 'ev.pageX';
getY = 'ev.pageY';
}
// IE
else if (document.body) {
getX = 'ev.clientX + document.body.scrollLeft - document.body.clientLeft';
getY = 'ev.clientY + document.body.scrollTop - document.body.clientTop';
}
// 重置函式,以提高效率,不用每次都判斷
var funstr = 'c$.getMousePos = function(ev) {';
funstr += ' ev = ev || window.event;';
funstr += ' return { x: ' + getX + ', y: ' + getY + ' };';
funstr += '};';
eval(funstr);
// 執行此函式,上面已經重置了此函式
return c$.getMousePos(ev);
}; /**
* 獲取元素位置
* @param element 元素
* @return 返回元素位置,形式如：{left: 531, top: 26}
*/
c$.getElementPos = function(element) {
var left = , top = ;
do {
left += element.offsetLeft;
top += element.offsetTop;
// 迴圈追加獲取父節點的位置
} while (element = element.offsetParent);
return {left: left, top: top};
}; /**
* 建立一個雜湊表物件
* @return 所建立的雜湊表物件
*
* @example
* var ht = c$.HashTable(); // 建立一個雜湊表物件
* ht.add('id', 55); // 新增值
* ht.set('id', 66); // 設值
* ht.get('id'); // 取值,沒有此值時返回 null
* ht.remove('id'); // 刪除值
* ht.clear(); // 清空雜湊表
* ht.contains('id'); // 判斷是否包含此鍵,返回 true 或者 false
* ht.containsValue(55); // 判斷是否包含此值,返回 true 或者 false
* ht.count(); // 統計此雜湊表裡面有多少元素,返回一個整數
* ht.keys(); // 返回一個數組,裡面包含此雜湊表裡面所有的 key
* ht.toString(); // 返回一個此雜湊表的 key 和 value 格式化後的字串,如: '{"a":1,"b":"哈哈"}'
* ht.clear().add('id', 55).set('name', 'myName').remove('age'); // add,set,remove,clear 函式支援連綴
*/
c$.HashTable = function() {
// 分別儲存 key 和 value
// 原本是用 Object 來儲存, 但如果 Object 被擴充套件了,將會影響結果,且 opera 的 Object 總是含有一個 event,最終改用陣列。
var keyArr = [], valueArr = []; // 返回一個雜湊物件
return {
// 新增一個元素
add : function(key, value) {
var index = keyArr.indexOf(key);
// 沒有此值時新增
if (index === -) {
keyArr.push(key);
valueArr.push(value);
}
// 有此值時修改
else {
valueArr[index] = value;
}
// 返回自身,以便連綴
return this;
}, // 刪除一個元素
remove : function(key) {
var index = keyArr.indexOf(key);
if (index > -) {
keyArr.remove(key);
valueArr.splice(index, );
}
return this;
}, // 獲取一個元素
get : function(key) {
var index = keyArr.indexOf(key);
if (index > -) {
return valueArr[index];
}
return null;
}, // 修改一個元素
set : function(key, value) {
return this.add(key, value);
}, // 獲取所有的 key
keys : function() {
// 返回一個複製的 key 陣列,以免被外部修改
return keyArr.clone();
}, // 清空
clear : function() {
keyArr.clear();
valueArr.clear();
return this;
}, // 判斷是否包含此鍵
contains : function(key) {
return keyArr.contains(key);
}, // 判斷是否包含此值
containsValue : function(value) {
return valueArr.contains(value);
}, // 統計
count : function() {
return keyArr.length;
} // 格式化
,toString : function() {
var arr = [];
for (var i = , n = keyArr.length; i < n; i++) {
arr.push('"' + encodeURIComponent(keyArr[i]) + '":' + c$.json2str(valueArr[i]));
}
return '{' + arr.join(',') + '}';
}
};
}; /**
* 設定iframe適應高度(必須在 iframe元素載入後執行,如在 onload 裡面執行,否則無效)
* @param iframe iframe元素
* @return c$ 物件本身，以支援連綴
* @example <iframe src='test.html' onload='c$.setIframeHeight(this)' /> // 載入 iframe 時，讓它自動調整高度
*/
c$.setIframeHeight = function(iframe) {
iframe = iframe || document.getElementsByTagName("iframe")[] || window.parent.document.getElementsByTagName("iframe")[];
if ( !iframe ) return this;
// IE
if ( iframe.Document && iframe.Document.body.scrollHeight ) {
iframe.height = iframe.Document.body.scrollHeight;
}
// Firefox
else if ( iframe.contentDocument && iframe.contentDocument.documentElement ) {
iframe.height = iframe.contentDocument.documentElement.scrollHeight + 'px';
//jQuery(iframe).height(jQuery(iframe.contentDocument.documentElement).height());
}
return this;
}; /**
* 新增收藏
* @param sURL 網站地址
* @param sTitle 網站名稱
* @return c$ 物件本身，以支援連綴
*/
c$.addFavorite = function(sURL, sTitle) {
sURL = sURL || window.location.href;
sTitle = sTitle || document.title;
var fns = [
function () { window.external.addFavorite(sURL, sTitle);},// IE
function () { window.sidebar.addPanel(sTitle, sURL, "");},// firefox (僅當地址為 ftp://, http:// 開頭時可以正常執行)
];
for (var i=, n=fns.length; i < n; i++) {
try { fns[i](); return this; }catch(e){}
} // 以上都不行
alert("加入收藏失敗，請使用Ctrl+D進行新增");
return this;
}; /**
* 設為首頁
* @param obj 設定物件
* @param url 網站地址
* @return c$ 物件本身，以支援連綴
* @example <a onclick="c$.setHome(this);">設為首頁</a>
*/
c$.setHome = function(obj, url) {
// 預設地址為本頁面
url = url || window.location.href;
try { // IE
obj = obj || document.body;
obj.style.behavior = 'url(#default#homepage)';
obj.setHomePage(url);
}
catch(e) {
if (window.netscape) {
try { // firefox
window.netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
}
catch (e) {
alert("此操作被瀏覽器拒絕！\n請在瀏覽器位址列輸入“about:config”並回車\n然後將 [signed.applets.codebase_principal_support]的值設定為'true',雙擊即可。");
}
var prefs = Components.classes['@mozilla.org/preferences-service;1'].getService(Components.interfaces.nsIPrefBranch);
prefs.setCharPref('browser.startup.homepage',url);
}
}
return this;
}; /**
* 設定為焦點
* @param element 物件
* @return c$ 物件本身，以支援連綴
* @example c$.setFocus(docuemnt.getElementById('text1')); // 在id為text1的元素上設定焦點
*/
c$.setFocus = function(element) {
//element.focus();
setTimeout(function(){try { element.focus(); } catch (e){}}, );
return this;
}; /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
* Ajax start
* --------------------------------------------------------------- */ /**
* 建立 XMLHttpRequest
* @return XMLHttpRequest
*/
c$.createXMLHttpRequest = function() {
var fns = [
function () { return new XMLHttpRequest(); }, // w3c, IE7+
function () { return new ActiveXObject('Msxml2.XMLHTTP'); }, // IE6
function () { return new ActiveXObject('Microsoft.XMLHTTP'); }, // IE5
];
var xmlHttp = false;
for (var i=, n=fns.length; i < n; i++) {
try {
xmlHttp = fns[i]();
c$.createXMLHttpRequest = fns[i]; // 重置函式, 不用每次呼叫都重複判斷
break;
}catch(e){}
}
return (xmlHttp || false);
}; /**
* 傳送 Ajax 請求
* 需改變的引數則需寫上，使用預設的不用寫，所有的引數都可以不寫
* @return paramObj 引數物件,具體參考下面的用例
* @return c$ 物件本身，以支援連綴
*
* c$.ajax({
* url : "submit.html", // 需要傳送的地址(預設: 當前頁地址)
* param : "a=1&b=2", // 需要傳送的傳參字串
* async : true, // 非同步或者同步請求(預設: true, 非同步請求)。如果需要傳送同步請求，請將此選項設定為 false
* cache : true, // 是否允許快取請求(預設: true, 允許快取)
* method : "GET", // 請求方式(預設: "GET"),也可用"POST"
* success : function(xmlHttp){....}, // 請求成功返回的動作
* error : function(xmlHttp, status){....}, // 請求失敗時的動作
* complete : function(xmlHttp, status){....} // 請求返回後的動作(不管成敗,且在 success 和 error 之後執行)
* });
*/
c$.ajax = function(paramObj) {
// 建立 XMLHttpRequest
var xmlHttp = c$.createXMLHttpRequest();
// 如果不支緩 Ajax，提示資訊
if (!xmlHttp) {
alert("您的瀏覽器不支援 Ajax，部分功能無法使用！");
return this;
} // 需要傳送的地址(預設: 當前頁地址)
paramObj.url = paramObj.url || "#";
// 非同步或者同步請求(預設: true, 非同步請求)
paramObj.async = paramObj.async || true;
// 快取策略(預設: 快取)
if (false == paramObj.cache) {
//paramObj.url = c$.addTimeStamp(paramObj.url); // 傳送地址,加上時間戳,下面改用設頭部資訊的形式，減少對傳參的影響
xmlHttp.setRequestHeader("If-Modified-Since","");
xmlHttp.setRequestHeader("Cache-Control","no-cache");
}
// 請求方式(預設: "GET")
paramObj.method = paramObj.method || "GET";
// get形式，將引數放到URL上
if ("GET" == ("" + paramObj.method).toUpperCase() && paramObj.param) {
paramObj.url += (paramObj.url.indexOf("?") > ) ? "&" : "?";
paramObj.url += paramObj.param;
paramObj.param = null;
paramObj.url = c$.encodeUrl(paramObj.url);
}
// 傳送請求
xmlHttp.open(paramObj.method, paramObj.url, paramObj.async);
// 執行回撥方法
xmlHttp.onreadystatechange = function() {
// XMLHttpRequest物件響應內容解析完成
if ( !== xmlHttp.readyState) return;
// 狀態正常時
if ( === xmlHttp.status) {
// 請求成功時的動作
if (paramObj.success) paramObj.success(xmlHttp);
}
else {
// 請求失敗時的動作
if (paramObj.error) paramObj.error(xmlHttp, xmlHttp.status);
// 預設的出錯處理
else alert("頁面發生Ajax錯誤，請聯絡管理人員! \n錯誤型別：" + xmlHttp.status + ": “" + location.pathname + "”");
}
// 請求返回後的動作(不管成敗,且在 success 和 error 之後執行)
if (paramObj.complete) paramObj.complete(xmlHttp, xmlHttp.status);
};
// 請求方式("POST")
if (paramObj.method.toUpperCase() === "POST") xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
// 傳送引數
xmlHttp.send(paramObj.param);
return this;
}; /**
* 獲取xmlHttp裡符合的資料
* @param xmlHttp XMLHttpRequest
* @param tagName 資料的 TagName
* @param init 預設值
* @param index 第幾個子元素
* @return 符合的資料的字串
*/
c$.getAjaxValue = function(xmlHttp, tagName, init, index) {
init = init || "";
index = index || ;
// 沒法繼續執行
if (!xmlHttp || !tagName) return init; try {
//獲取xmlHttp裡對應的值
var element1 = xmlHttp.responseXML.getElementsByTagName(tagName)[index].firstChild;
var value = element1.nodeValue || element1.data;
//如果能獲取值
if (value) return value;
}
catch (e) {}
// 異常或者沒能取到值時,返回預設值
return init;
}; /* -------------------------------------------------------------------
* Ajax end
* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */ /**
* 獲取元素
* @param str 直接寫則是指元素的ID或者name
* 如果需要精確指定則使用“#”開頭表示id,“@”開頭表示name,“.”開頭表示class,“$”開頭表示tagName
* 根據 name、class、tagName 查詢時,如果只找到一個則返回一個元素,找到多個則返回陣列； 根據id查詢時只會返回一個
* @param dom 需要選擇的DOM物件,預設是 window.document
* @return 如果能找到指定名稱的元素，返回元素物件； 如果找不到指定的元素，返回 null
*
* @example
* c$.getElement("mytext") // 返回 id 或者 name 為"mytext"的元素
* c$.getElement("#mytext") // 返回 id 為"mytext"的元素
* c$.getElement("@mytext") // 返回 name 為"mytext"的元素
* c$.getElement(".class1") // 返回 class 為"class1"的元素
* c$.getElement("$div") // 返回 標籤 為"div"的所有元素
* c$.getElement("$div #text1") // 返回 div 標籤裡面 id 為"text1"的元素(支援多級查詢，以空格分隔)
*/
c$.getElement = function(str, dom) {
if (!str) return null;
// 預設要查詢的 dom 物件
dom = dom || document; // 如果本身是頁面物件,直接返回
if (c$.isElement(str)) return str; // 判斷返回：只有一個的時候，返回一個元素；多個則返回陣列
var return_arr = function(elements) {
// 引數是陣列
if (elements && elements.constructor === Array) {
// 空陣列時
if (elements.length === ) return false;
// 只有一個的時候，直接返回一個元素
if (elements.length === && c$.isElement(elements[])) return elements[];
// 多個時傳回陣列
return elements;
}
// 引數是元素
if (c$.isElement(elements)) return elements;
// 沒有符合的
return false;
} // 獲取查詢的型別,以及查詢的字串
var getType = function(str) {
var type = null;
var find_str = str.substr();
// 判斷要查詢的型別
switch(str.substr(, )) {
case "#": type = 'id'; break;
case "@": type = 'name'; break;
case ".": type = 'class'; break;
case "$": type = 'tagName'; break;
// 沒有精確指定時
default: find_str = str;
}
return [type, find_str];
} // 獲取dom裡面的元素
var getDomElements = function(type, find_str, DOM) {
var elements = [];
if (DOM) {
// 如果 dom 是個陣列
if (DOM.length && DOM.constructor === Array) {
for(var i=, length = DOM.length; i<length; i++){
if (DOM[i].getElementsByTagName) {
var tem_elements = [];
// 根據 tagName 獲取元素
if (type === 'tagName') {elements = elements.concat(DOM[i].getElementsByTagName(find_str));}
// 獲取 dom 裡面的所有元素
else {elements = elements.concat(DOM[i].getElementsByTagName('*') || DOM[i].all);}
}
}
}
// 單個的 dom
else {
if (DOM.getElementsByTagName) {
// 根據 tagName 獲取元素
if (type === 'tagName') {elements = DOM.getElementsByTagName(find_str);}
// 獲取 dom 裡面的所有元素
else {elements = DOM.getElementsByTagName('*') || DOM.all;}
}
}
}
if (elements && elements.length) {
var ets = []; // 返回值
for (var i=, length = elements.length; i < length; i++) {
var et = elements[i];
if (c$.isElement(et)) {
// 判斷要查詢的型別
switch(type) {
case 'id': if(et.id == find_str)ets.push(et); break;
case 'name': if(et.name == find_str)ets.push(et); break;
case 'class': if((" "+et.className+" ").indexOf(" "+find_str+" ") != -)ets.push(et); break;
case 'tagName': if(et.tagName.toUpperCase() == find_str.toUpperCase())ets.push(et); break;
// 沒有精確指定時
default: if(et.id == find_str || et.name == find_str)ets.push(et);
}
}
}
var et = return_arr(ets);
if (et) return et;
}
// 沒有找到時
return null;
} // 根據 string 來獲取物件
if ("string" === typeof(str)) {
//按照空格分割引數
var values = str.trim().replace(/\s+/g, " ").split(" ");
var type = getType(values[])[];
var find_str = getType(values[])[];
// 優化一下效率; 根據 id 獲取元素
if (dom.getElementById && (type === 'id' || type === null)) {
var element = dom.getElementById(find_str);
if (c$.isElement(element)) {
if (values.length === )return element;
dom = element;
values.shift();
}
}
// 優化一下效率; 根據 name 獲取元素
if (dom.getElementsByName && (type === 'name' || type === null)) {
var elements = dom.getElementsByName(find_str);
var et = return_arr(elements);
if (et) {
if (values.length === )return et;
dom = et;
values.shift();
}
}
// 遍歷查詢
for(var i=, length = values.length; i<length; i++) {
type = getType(values[i])[];
find_str = getType(values[i])[];
dom = getDomElements(type, find_str, dom);
if (dom === null) return null; // 找不到時不再繼續
}
if (dom) return dom;
} // 找不到元素，則返回 null
return null;
}; /**
* 獲取元素的值
* @param name 元素的ID或者name
* @param init 預設值
* @return 元素的值(value 或者 innerHTML 或者 checkbox、radio選中的值)
*/
c$.getValue = function(name, init) {
//返回值
var retValue = "";
//如果沒有傳入預設值
if (arguments.length <= ) init = "";
var data = c$.getElement(name);
//如果沒有找到所要的元素，則直接返回預設值
if (!data) return init; //如果它是選擇框
if ("checkbox" === data.type) {
if (data.checked) return data.value;
return init;
}
//如果它是單選按鈕
if ("radio" === data.type || ( < data.length && "radio" === data[].type)) {
return c$.getRadioValue(name, init);
} //獲取元素的值; 沒有value屬性則取innerHTML
retValue = data.value || data.innerHTML;
//如果沒有取到值，返回預設值
return (retValue || init);
}; /**
* 表單序列化
* @param form 表單的id,name 或者表單物件,給出的不是 form 元素而是 div,table 之類的元素也可以
* @param encode 是否將值轉成 URL 編碼
* @return 表單序列化後的字串
*/
c$.serialize = function(form, encode) {
//元素列表
var elements = c$.getElements(form);
// 拼接引數
var param = "";
for (var i = , length = elements.length; i < length; i++) {
if (elements[i].type) {
var type = elements[i].type.toLowerCase();
// 選擇項,沒選中時跳過
if (type == "radio" || type == "checkbox") {
if (!elements[i].checked) continue;
}
// 按鈕不需要序列化
if ("button" === type || "submit" === type || "reset" === type) continue;
}
// 儲存名稱和值
var name = elements[i].name;
var value = elements[i].value;
// 如果需要轉變中文編碼
value = encode ? encodeURIComponent(value) : value;
if (param.length > ) param += "&";
param += name + "=" + value;
}
return param;
}; /**
* 當DOM載入就緒時執行某函式(比window.onload更早)
* @param fun [必填]需要執行的函式
* @return c$ 物件本身，以支援連綴
*
* @example
* c$.ready(function(){alert('執行DOM載入完成事件');});
* c$(function(){alert('執行DOM載入完成事件');}); // 為 c$.ready(fun) 的縮寫
*/
c$.ready = function (fun) {
if (!fun || typeof fun !== 'function') return this;
var thisFun = arguments.callee;
// thisFun.funList 作為本函式的全域性變數,保證多次呼叫本函式時可以共用
thisFun.funList = thisFun.funList || [];
thisFun.funList.push(fun);
if (thisFun.funList.length > ) return this;
// 執行的函式
var doReady = function () {
var fn, i = , readyList;
if (thisFun.funList) {
// 為了減少變數查詢帶來的效能損耗，將它賦值給本地變數
readyList = thisFun.funList;
// 釋放引用
thisFun.funList = null;
while( (fn = readyList[ i++ ]) ){
fn.call( document );
}
}
};
// FF, Opera, 高版webkit, 其他
if (document.addEventListener) {
document.addEventListener( "DOMContentLoaded", function(){
document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
doReady();
}, false );
window.addEventListener('load', doReady, false); // 為了保險起見，還註冊了 onload 事件
}
// IE
else if (document.attachEvent) {
document.attachEvent("onreadystatechange", function() {
if (document.readyState === "complete") {
document.detachEvent( "onreadystatechange", arguments.callee );
doReady();
}
});
window.attachEvent('onload', doReady); // 判斷文件是否處於最頂層,如果文件處於iframe中，呼叫doScroll方法成功時並不代表DOM載入完畢
var isToplevel = false;
try {
isToplevel = window.frameElement == null;
} catch(e) {} if (document.documentElement.doScroll && isToplevel) {
(function(){
try {
document.documentElement.doScroll("left");
} catch (error) {
window.setTimeout(arguments.callee, );
return;
}
doReady();
})();
}
}
return this;
};