整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
符串作為基本的信息交流的橋梁，幾乎被所有的編程語言所實現（然而c、c++沒有提供）。多數開發者幾乎每天都在和字符串打交道，語言內置的String模塊，極大地提升了開發者的效率。JavaScript通過自動裝箱字符串字面量為String對象，自然地繼承了String.prototype的所有方法，更加簡化了字符串的使用。
截止ES6，字符串共包含31個標準的API方法，其中有些方法出鏡率較高，需要摸透原理；有些方法之間相似度較高，需要仔細分辨；甚至有些方法執行效率較低，應當盡量少的使用。下面將從String構造器方法說起，逐步幫助你掌握字符串
String構造器方法
fromCharCode
fromCharCode() 方法返回使用指定的Unicode序列創建的字符串，也就是說傳入Unicode序列，返回基于此創建的字符串。
語法：fromCharCode(num1, num2,…)，傳入的參數均為數字。
如下這是一個簡單的例子，將返回 ABC、abc、*、+、- 和 /：
String.fromCharCode(65, 66, 67); // "ABC" String.fromCharCode(97, 98, 99); // "abc" String.fromCharCode(42); // "*" String.fromCharCode(43); // "+" String.fromCharCode(45); // "-" String.fromCharCode(47); // "/"
看起來fromCharCode像是滿足了需求，但實際上由于js語言設計時的先天不足（只能處理UCS-2編碼，即所有字符都是2個字節，無法處理4字節字符），通過該方法并不能返回一個4字節的字符，為了彌補這個缺陷，ES6新增了fromCodePoint方法
fromCodePoint(ES6)
fromCodePoint() 方法基于ECMAScript 2015（ES6）規范，作用和語法同fromCharCode方法，該方法主要擴展了對4字節字符的支持。
// "" 是一個4字節字符，我們先看下它的數字形式 "".codePointAt(); // 119558 //調用fromCharCode解析之，返回亂碼 String.fromCharCode(119558); // "?" //調用fromCodePoint解析之，正常解析 String.fromCodePoint(119558); // ""
除了擴展對4字節的支持外，fromCodePoint還規范了錯誤處理，只要是無效的Unicode編碼，就會拋出錯誤RangeError: Invalid code point...，這就意味著，只要不是符合Unicode字符范圍的正整數（Unicode最多可容納1114112個碼位），均會拋出錯誤，而String.fromCharCode()均返回空字符串
String.fromCodePoint('abc'); // RangeError: Invalid code point NaN
String.fromCodePoint(Infinity); // RangeError: Invalid code point Infinity
String.fromCodePoint(-1.23); // RangeError: Invalid code point -1.23
raw(ES6)
raw() 方法基于ECMAScript 2015（ES6）規范，它是一個模板字符串的標簽函數，作用類似于Python的r和C#的@字符串前綴，都是用來獲取一個模板字符串的原始字面量。
語法： String.raw(callSite, …substitutions)，callSite即模板字符串的『調用點對象』，…substitutions表示任意個內插表達式對應的值，這里理解起來相當拗口，下面我將通俗的講解它。
// 防止特殊字符串被轉義
String.raw`a\nb\tc`; // 輸出為 "a\nb\tc"
// 支持內插表達式
let name="louis";
String.raw`Hello \n ${name}`; // "Hello \n louis"
// 內插表達式還可以運算
String.raw`1+2=${1+2},2*3=${2*3}`; // "1+2=3,2*3=6"
// 對象的raw屬性值為字符串時，從第二個參數起，它們分別被插入到下標為0，1，2，...n的元素后面
String.raw({raw: 'abcd'}, 1, 2, 3); // "a1b2c3d"
// 對象的raw屬性值為數組時，從第二個參數起，它們分別被插入到數組下標為0，1，2，...n的元素后面
String.raw({raw: ['a', 'b', 'c', 'd']}, 1, 2, 3); // "a1b2c3d"
那么怎么解釋String.raw函數按照下標挨個去插入的特性呢？
In most cases, String.raw() is used with template strings. The first syntax mentioned above is only rarely used, because the JavaScript engine will call this with proper arguments for you, just like with other tag functions.
這意味著，String.raw作為函數調用時，基本與ES6的tag標簽模板一樣
// 如下是tag函數的實現
function tag(){
const array=arguments[0];
return array.reduce((p, v, i)=> p + (arguments[i] || '') + v);
}
// 回顧一個simple的tag標簽模板
tag`Hello ${ 2 + 3 } world ${ 2 * 3 }`; // "Hello 5 world 6"
// 其實就想當于如下調用
tag(['Hello ', ' world ', ''], 5, 6); // "Hello 5 world 6"
因此String.raw作為函數調用時，不論對象的raw屬性值是字符串還是數組，插槽都是天生的，下標為0，1，2，…n的元素后面都是插槽（不包括最后一個元素）。實際上，它相當于是這樣的tag函數：
function tag(){
const array=arguments[0].raw;
if(array===undefined || array===null){ // 這里可簡寫成 array==undefined
throw new TypeError('Cannot convert undefined or null to object');
}
return array.reduce((p, v, i)=> p + (arguments[i] || '') + v);
}
實際上，String.raw作為函數調用時，若第一個參數不是一個符合標準格式的對象，執行將拋出TypeError錯誤。
String.raw({123: 'abcd'}, 1, 2, 3); // TypeError: Cannot convert undefined or null to object
String.prototype
和其他所有對象一樣，字符串實例的所有方法均來自String.prototype。以下是它的屬性特性：
writable: false
enumerable: false
configurable: false
可見，字符串屬性不可編輯，任何試圖改變它屬性的行為都將拋出錯誤。
屬性
String.prototype共有兩個屬性，如下：
方法
字符串原型方法分為兩種，一種是html無關的方法，一種是html有關的方法。我們先看第一種。但是無論字符串方法如何厲害，都不至于強大到可以改變原字符串。
常用的方法有，charAt、charCodeAt、concat、indexOf、lastIndexOf、localeCompare、match、replace、search、slice、split、substr、substring、toLocaleLowerCase、toLocaleUpperCase、toLowerCase、toString、toUpperCase、trim、valueof 等ES5支持的，以及 codePointAt、contains、endsWith、normalize、repeat、startsWith 等ES6支持的，還包括 quote、toSource、trimLeft、trimRight 等非標準的。
接下來我們將對各個方法分別舉例闡述其用法。若沒有特別說明，默認該方法兼容所有目前主流瀏覽器。
charAt
charAt() 方法返回字符串中指定位置的字符。
語法：str.charAt(index)
index 為字符串索引（取值從0至length-1），如果超出該范圍，則返回空串
console.log("Hello, World".charAt(8)); // o, 返回下標為8的字符串o
charCodeAt
charCodeAt() 返回指定索引處字符的 Unicode 數值。
語法：str.charCodeAt(index)
index 為一個從0至length-1的整數。如果不是一個數值，則默認為 0，如果小于0或者大于字符串長度，則返回 NaN。
Unicode 編碼單元（code points）的范圍從 0 到 1,114,111。開頭的 128 個 Unicode 編碼單元和 ASCII 字符編碼一樣.
charCodeAt() 總是返回一個小于 65,536 的值。因為高位編碼單元需要由一對字符來表示，為了查看其編碼的完成字符，需要查看 charCodeAt(i) 以及 charCodeAt(i+1)
console.log("Hello, World".charCodeAt(8)); // 111
console.log("前端工程師".charCodeAt(2)); // 24037, 可見也可以查看中文Unicode編碼
concat
concat() 方法將一個或多個字符串拼接在一起，組成新的字符串并返回。
語法：str.concat(string2, string3, …)
console.log("早".concat("上","好")); // 早上好 1
但是 concat 的性能表現不佳，強烈推薦使用賦值操作符（+或+=）代替 concat。”+” 操作符大概快了 concat 幾十倍。
indexOf 和 lastIndexOf
indexOf() 方法用于查找子字符串在字符串中首次出現的位置，沒有則返回 -1。該方法嚴格區分大小寫，并且從左往右查找。而 lastIndexOf 則從右往左查找，其它與前者一致。
語法：str.indexOf(searchValue [, fromIndex=0])，str.lastIndexOf(searchValue [, fromIndex=0])
searchValue 表示被查找的字符串，fromIndex 表示開始查找的位置，默認為0，如果小于0，則查找整個字符串，若超過字符串長度，則該方法返回-1，除非被查找的是空字符串，此時返回字符串長度。
console.log("".indexOf("",100)); // 0
console.log("IT改變世界".indexOf("世界")); // 4
console.log("IT改變世界".lastIndexOf("世界")); // 4
localeCompare
localeCompare() 方法用來比較字符串，如果指定字符串在原字符串的前面則返回負數，否則返回正數或0，其中0 表示兩個字符串相同。該方法實現依賴具體的本地實現，不同的語言下可能有不同的返回。
語法：str.localeCompare(str2 [, locales [, options]])
var str="apple";
var str2="orange";
console.log(str.localeCompare(str2)); // -1
console.log(str.localeCompare("123")); // 1
match
match() 方法用于測試字符串是否支持指定正則表達式的規則，即使傳入的是非正則表達式對象，它也會隱式地使用new RegExp(obj)將其轉換為正則表達式對象。
語法：str.match(regexp)
該方法返回包含匹配結果的數組，如果沒有匹配項，則返回 null。
描述
相關 RegExp 方法
var str="World Internet Conference"; console.log(str.match(/[a-d]/i)); // ["d", index: 4, input: "World Internet Conference"] console.log(str.match(/[a-d]/gi)); // ["d", "C", "c"] // RegExp 方法如下 console.log(/[a-d]/gi.test(str)); // true console.log(/[a-d]/gi.exec(str)); // ["d", index: 4, input: "World Internet Conference"]
由上可知，RegExp.test(str) 方法只要匹配到了一個字符也返回true。而RegExp.exec(str) 方法無論正則中有沒有包含 g 標志，RegExp.exec將直接返回第一個匹配結果，且該結果同 str.match(regexp) 方法不包含 g 標志時的返回一致。
replace
語法 str.replace( regexp | substr, newSubStr | function[, flags] )
參數
簡單概括,replace擁有兩個參數,第一個是需要替換的字符串或者正則表達式;第二個是新的字符串或者一個function,這樣參數便有四種組合.
該方法并不改變調用它的字符串本身，而只是返回替換后的字符串.
var b=a.replace("before","after");
console.log(b); // "what is this? after"
如果第一個參數是正則表達式,新的字符串中可以用$符號取正則中匹配的子串(也就是正則中被括號包裹的部分):
var a="what is this? before"; var b=a.replace(/(^\w+).*?(\w+)$/,"$2 $1");//括號分割的部分依次為子串1....n console.log(b); // "before what"
第二個參數其實可為一個function,最終字符串將以function的返回值作為replace的返回值,以下是該function的形參: function(match,p1…,offset,string),可見至少包含三個形參(即arguments.length>=3)
function replacer(match,p1,p2,offset,string){
//此時p1=" is",p2=" this"
return p1+" that";//如果返回為空串,則匹配內容替換為空,如果不返回,則匹配內容替換為undefined
}
var a="what is this? before";
var b=a.replace(/(\s\w+)(\s\w+)/,replacer);
console.log(b); // "what is that? before"
function replacer(match,offset,string){
//由于字符串中不會有括號進行分組,此時沒有子串
return offset+" that";//偏移為4
}
var a="what is this? before";
var b=a.replace(" is this",replacer);
console.log(b); // "what4 that? before"
基于 replace 方法的第三個用法, 我們可以實現一個tmpl方法, 輸入一個模板字符串, 輸入一個key-value對象, 即可生成新的字符串.
var template="one {a} two {b} {c}",
obj={a:"apple",b:"orange",c:"..."},
_array=[];
function tmpl(template,obj){
var retu=template.replace(/([^{}]*){(.)}/g,function(match,p1,p2,offset,string){
_array.push({'match':match, 'p1':p1, 'p2':p2, 'offset':offset, 'string':string});
return p1+obj[p2];
});
console.table && console.table(_array);
!console.table && console.log(_array);
console.log(retu);
}
tmpl(template,obj);
.（小數點）:匹配除換行符之外的任何單個字符。例如，/.n/將會匹配 "nay, an apple is on the tree" 中的 'an' 和 'on'，但是不會匹配 'nay'。
[^xyz]:一個反向字符集。也就是說， 它匹配任何沒有包含在方括號中的字符。你可以使用破折號（-）來指定一個字符范圍。任何普通字符在這里都是起作用的。例如，[^abc] 和 [^a-c] 是一樣的。他們匹配"brisket"中的‘r’，也匹配“chop”中的‘h’。
search
search() 方法用于測試字符串對象是否包含某個正則匹配，相當于正則表達式的 test 方法，且該方法比 match() 方法更快。如果匹配成功，search() 返回正則表達式在字符串中首次匹配項的索引，否則返回-1。
注意：search方法與indexOf方法作用基本一致，都是查詢到了就返回子串第一次出現的下標，否則返回-1，唯一的區別就在于search默認會將子串轉化為正則表達式形式，而indexOf不做此處理，也不能處理正則
語法：str.search(regexp) var str="abcdefg"; console.log(str.search(/[d-g]/)); // 3, 匹配到子串"defg",而d在原字符串中的索引為3
search() 方法不支持全局匹配（正則中包含g參數），如下：
console.log(str.search(/[d-g]/g)); // 3, 與無g參數時,返回相同
slice
slice() 方法提取字符串的一部分，并返回新的字符串。該方法有些類似 Array.prototype.slice 方法。
語法：str.slice(start, end)
首先 end 參數可選，start可取正值，也可取負值。
var str="It is our choices that show what we truly are, far more than our abilities."; console.log(str.slice(0,-30)); // It is our choices that show what we truly are console.log(str.slice(-30)); // , far more than our abilities.
split
split() 方法把原字符串分割成子字符串組成數組，并返回該數組。
語法：str.split(separator, limit)
兩個參數均是可選的，其中 separator 表示分隔符，它可以是字符串也可以是正則表達式。如果忽略 separator，則返回的數組包含一個由原字符串組成的元素。如果 separator 是一個空串，則 str 將會被分割成一個由原字符串中字符組成的數組。limit 表示從返回的數組中截取前 limit 個元素，從而限定返回的數組長度。
var str="today is a sunny day";
console.log(str.split()); // ["today is a sunny day"]
console.log(str.split("")); // ["t", "o", "d", "a", "y", " ", "i", "s", " ", "a", " ", "s", "u", "n", "n", "y", " ", "d", "a", "y"]
console.log(str.split(" ")); // ["today", "is", "a", "sunny", "day"]
使用limit限定返回的數組大小，如下：
console.log(str.split(" ", 1)); // ["today"]
console.log(str.split(/\s*is\s*/)); // ["today", "a sunny day"]
// 若正則分隔符里包含捕獲括號，則括號匹配的結果將會包含在返回的數組中。
console.log(str.split(/(\s*is\s*)/)); // ["today", " is ", "a sunny day"]
substr
substr() 方法返回字符串指定位置開始的指定數量的字符。
語法：str.substr(start[, length])
start 表示開始截取字符的位置，可取正值或負值。取正值時表示start位置的索引，取負值時表示 length+start位置的索引。
length 表示截取的字符長度。
var str="Yesterday is history. Tomorrow is mystery. But today is a gift."; console.log(str.substr(47)); // today is a gift. console.log(str.substr(-16)); // today is a gift.
substring
substring() 方法返回字符串兩個索引之間的子串。
語法：str.substring(indexA[, indexB])
indexA、indexB 表示字符串索引，其中 indexB 可選，如果省略，則表示返回從 indexA 到字符串末尾的子串。
描述
substring 要截取的是從 indexA 到 indexB（不包含）之間的字符，符合以下規律：
var str="Get outside every day. Miracles are waiting everywhere."; console.log(str.substring(1,1)); // "" console.log(str.substring(0)); // Get outside every day. Miracles are waiting everywhere. console.log(str.substring(-1)); // Get outside every day. Miracles are waiting everywhere. console.log(str.substring(0,100)); // Get outside every day. Miracles are waiting everywhere. console.log(str.substring(22,NaN)); // Get outside every day.
toLocaleLowerCase & toLocaleUpperCase
toLocaleLowerCase() 方法返回調用該方法的字符串被轉換成小寫的值，轉換規則根據本地化的大小寫映射。而toLocaleUpperCase() 方法則是轉換成大寫的值。
語法：str.toLocaleLowerCase(), str.toLocaleUpperCase()
console.log('ABCDEFG'.toLocaleLowerCase()); // abcdefg
console.log('abcdefg'.toLocaleUpperCase()); // ABCDEFG
toLowerCase & toUpperCase
這兩個方法分別表示將字符串轉換為相應的小寫，大寫形式，并返回
console.log('ABCDEFG'.toLowerCase()); // abcdefg
console.log('abcdefg'.toUpperCase()); // ABCDEFG
toString & valueOf
這兩個方法都是返回字符串本身。
語法：str.toString(), str.valueOf()
var str="abc"; console.log(str.toString()); // abc console.log(str.toString()==str.valueOf()); // true
對于對象而言，toString和valueOf也是非常的相似，它們之間有著細微的差別，請嘗試運行以下一段代碼：
var x={
toString: function () { return "test"; },
valueOf: function () { return 123; }
};
console.log(x); // test
console.log("x=" + x); // "x=123"
console.log(x + "=x"); // "123=x"
console.log(x + "1"); // 1231
console.log(x + 1); // 124
console.log(["x=", x].join("")); // "x=test"
當 “+” 操作符一邊為數字時，對象x趨向于轉換為數字，表達式會優先調用 valueOf 方法，如果調用數組的 join 方法，對象x趨向于轉換為字符串，表達式會優先調用 toString 方法。
trim
trim() 方法清除字符串首尾的空白并返回。
語法：str.trim()
console.log(" a b c ".trim()); // "a b c"
trim() 方法是 ECMAScript 5.1 標準加入的，它并不支持IE9以下的低版本IE瀏覽器
if(!String.prototype.trim) {
String.prototype.trim=function () {
return this.replace(/^\s+|\s+$/g,'');
};
}
codePointAt(ES6)
codePointAt() 方法基于ECMAScript 2015（ES6）規范，返回使用UTF-16編碼的給定位置的值的非負整數。
語法：str.codePointAt(position)
console.log("a".codePointAt(0)); // 97
console.log("\u4f60\u597d".codePointAt(0)); // 20320
includes(ES6)
includes() 方法基于ECMAScript 2015（ES6）規范，它用來判斷一個字符串是否屬于另一個字符。如果是，則返回true，否則返回false。
語法：str.includes(subString [, position])
subString 表示要搜索的字符串，position 表示從當前字符串的哪個位置開始搜索字符串，默認值為0。
var str="Practice makes perfect.";
console.log(str.includes("perfect")); // true
console.log(str.includes("perfect",100)); // false
實際上，Firefox 18~39中該方法的名稱為contains，由于bug 1102219的存在，它被重命名為includes() 。目前只有Chrome v41+和Firefox v40+版本瀏覽器實現了它，如需在其它版本瀏覽器中使用該方法，請參考 Polyfill。
endsWith(ES6)
endsWith() 方法基于ECMAScript 2015（ES6）規范，它基本與 contains() 功能相同，不同的是，它用來判斷一個字符串是否是原字符串的結尾。若是則返回true，否則返回false。
語法：str.endsWith(substring [, position])
與contains 方法不同，position 參數的默認值為字符串長度。
var str="Learn and live.";
console.log(str.endsWith("live.")); // true
console.log(str.endsWith("Learn",5)); // true
startsWith(ES6)
startsWith() 方法基于ECMAScript 2015（ES6）規范，它用來判斷當前字符串是否是以給定字符串開始的，若是則返回true，否則返回false。
語法：str.startsWith(subString [, position])
var str="Where there is a will, there is a way.";
console.log(str.startsWith("Where")); // true
console.log(str.startsWith("there",6)); // true
normalize(ES6)
normalize() 方法基于ECMAScript 2015（ES6）規范，它會按照指定的 Unicode 正規形式將原字符串正規化。
語法：str.normalize([form])
form 參數可省略，目前有四種 Unicode 正規形式，即 “NFC”、”NFD”、”NFKC” 以及 “NFKD”，form的默認值為 “NFC”。如果form 傳入了非法的參數值，則會拋出 RangeError 錯誤。
var str="\u4f60\u597d";
console.log(str.normalize()); // 你好
console.log(str.normalize("NFC")); // 你好
console.log(str.normalize("NFD")); // 你好
console.log(str.normalize("NFKC")); // 你好
console.log(str.normalize("NFKD")); // 你好
function toUnicode(theString) {
var unicodeString='';
for (var i=0; i < theString.length; i++) {
var theUnicode=theString.charCodeAt(i).toString(16).toUpperCase();
while (theUnicode.length < 4) {
theUnicode='0' + theUnicode;
}
theUnicode='\\u' + theUnicode;
unicodeString +=theUnicode;
}
return unicodeString;
}
toUnicode('你好'); // "\u4f60\u597d"
repeat(ES6)
repeat() 方法基于ECMAScript 2015（ES6）規范，它返回重復原字符串多次的新字符串。
語法：str.repeat(count)
count 參數只能取大于等于0 的數字。若該數字不為整數，將自動轉換為整數形式，若為負數或者其他值將報錯。
var str="A still tongue makes a wise head."; console.log(str.repeat(0)); // "" console.log(str.repeat(1)); // A still tongue makes a wise head. console.log(str.repeat(1.5)); // A still tongue makes a wise head. console.log(str.repeat(-1)); // RangeError:Invalid count value
常用的方法有 anchor，link 其它方法如 big、blink、bold、fixed、fontcolor、fontsize、italics、small、strike、sub、sup均已廢除。
接下來我們將介紹 anchor 和 link 兩個方法，其他廢除方法不作介紹。
anchor
anchor() 方法創建一個錨標簽。
語法：str.anchor(name)
name 指定被創建的a標簽的name屬性，使用該方法創建的錨點，將會成為 document.anchors 數組的元素。
var str="this is a anchor tag";
document.body.innerHTML=document.body.innerHTML + str.anchor("anchor1"); // body末尾將會追加這些內容 <a name="anchor1">this is a anchor tag</a>
link
link() 方法同樣創建一個a標簽。
語法：str.link(url)
url 指定被創建的a標簽的href屬性，如果url中包含特殊字符，將自動進行編碼。例如 " 會被轉義為 &\quot。 使用該方法創建的a標簽，將會成為 document.links 數組中的元素。
var str="百度";
document.write(str.link("https://www.baidu.com")); // <a >百度</a>
小結
部分字符串方法之間存在很大的相似性，要注意區分他們的功能和使用場景。如：
substr 和 substring，都是兩個參數，作用基本相同，兩者第一個參數含義相同，但用法不同，前者可為負數，后者值為負數或者非整數時將隱式轉換為0。前者第二個參數表示截取字符串的長度，后者第二個參數表示截取字符串的下標；同時substring第一個參數大于第二個參數時，執行結果同位置調換后的結果。 search方法與indexOf方法作用基本一致，都是查詢到了就返回子串第一次出現的下標，否則返回-1，唯一的區別就在于search默認會將子串轉化為正則表達式形式，而indexOf不做此處理，也不能處理正則。 另外，還記得嗎？concat方法由于效率問題，不推薦使用。
通常，字符串中，常用的方法就charAt、indexOf、lastIndexOf、match、replace、search、slice、split、substr、substring、toLowerCase、toUpperCase、trim、valueof 等這些。熟悉它們的語法規則就能熟練地駕馭字符串
參考文章：
https://segmentfault.com/a/1190000010753942
https://segmentfault.com/a/1190000012688190
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String
onkeypress 在用戶按下并放開任何字母數字鍵時發生。系統按鈕（例如，箭頭鍵和功能鍵）無法得到識別。[響應一個鍵] onkeyup 在用戶放開任何先前按下的鍵盤鍵時發生。 onkeydown 在用戶按下任何鍵盤鍵（包括系統按鈕，如箭頭鍵和功能鍵）時發生。[響應幾個鍵的組合]可以響應Ctrl、Alt、Shift等功能鍵和鍵的組合，而onkeypress不能 onfocusout 失去光標事件 onfocus 獲得光標事件 onabort 圖片下載被打斷時 onblur 元素失去焦點時 onclick 鼠標點擊 ondblclick 鼠標雙擊 onerror 加載文檔或圖片發生錯誤時 onmousedown 鼠標被按下時 onmousemove 鼠標被移動時 onmouseout 鼠標離開元素時 onmouseover 鼠標經過元素時 onmouseup 釋放鼠標按鍵時 onunload 用戶離開頁面時
100個原生JavaScript使用功能代碼片段
目錄
1.原生JavaScript實現字符串長度截取
2.原生JavaScript獲取域名主機
3.原生JavaScript清除空格
4.原生JavaScript替換全部
5.原生JavaScript轉義html標簽
6.原生JavaScript還原html標簽
7.原生JavaScript判斷是否為數字類型
8.原生JavaScript時間日期格式轉換
9.原生JavaScript設置cookie值
10.原生JavaScript獲取cookie值
11.原生JavaScript加入收藏夾
12.原生JavaScript設為首頁
13.原生JavaScript判斷IE6
14.原生JavaScript加載樣式文件
15.原生JavaScript返回腳本內容
16.原生JavaScript清除腳本內容
17.原生JavaScript動態加載腳本文件
18.原生JavaScript返回按ID檢索的元素對象
19.原生JavaScript返回瀏覽器版本內容
20.原生JavaScript元素顯示的通用方法
21.原生JavaScript中有insertBefore方法,可惜卻沒有insertAfter方法?用如函數實現
22.原生JavaScript中兼容瀏覽器綁定元素事件
23.原生JavaScript光標停在文字的后面，文本框獲得焦點時調用
24.原生JavaScript檢驗URL鏈接是否有效
25.原生JavaScript格式化CSS樣式代碼
26.原生JavaScript壓縮CSS樣式代碼
27.原生JavaScript獲取當前路徑
28.原生JavaScriptIP轉成整型
29.原生JavaScript整型解析為IP地址
30.原生JavaScript實現checkbox全選與全不選
31.原生JavaScript判斷是否移動設備
32.原生JavaScript判斷是否移動設備訪問
33.原生JavaScript判斷是否蘋果移動設備訪問
34.原生JavaScript判斷是否安卓移動設備訪問
35.原生JavaScript判斷是否Touch屏幕
36.原生JavaScript判斷是否在安卓上的谷歌瀏覽器
37.原生JavaScript判斷是否打開視窗
38.原生JavaScript獲取移動設備初始化大小
39.原生JavaScript獲取移動設備最大化大小
40.原生JavaScript獲取移動設備屏幕寬度
41.原生JavaScript完美判斷是否為網址
42.原生JavaScript根據樣式名稱檢索元素對象
43.原生JavaScript判斷是否以某個字符串開頭
44.原生JavaScript判斷是否以某個字符串結束
45.原生JavaScript返回IE瀏覽器的版本號
46.原生JavaScript獲取頁面高度
47.原生JavaScript獲取頁面scrollLeft
48.原生JavaScript獲取頁面可視寬度
49.原生JavaScript獲取頁面寬度
50.原生JavaScript獲取頁面scrollTop
51.原生JavaScript獲取頁面可視高度
52.原生JavaScript跨瀏覽器添加事件
53.原生JavaScript跨瀏覽器刪除事件
54.原生JavaScript去掉url前綴
55.原生JavaScript隨機數時間戳
56.原生JavaScript全角半角轉換,iCase: 0全到半，1半到全，其他不轉化
57.原生JavaScript確認是否鍵盤有效輸入值
58.原生JavaScript獲取網頁被卷去的位置
59.原生JavaScript另一種正則日期格式化函數+調用方法
60.原生JavaScript時間個性化輸出功能
61.原生JavaScript解決offsetX兼容性問題
62.原生JavaScript常用的正則表達式
63.原生JavaScript實現返回頂部的通用方法
64.原生JavaScript獲得URL中GET參數值
65.原生JavaScript實現全選通用方法
66.原生JavaScript實現全部取消選擇通用方法
67.原生JavaScript實現打開一個窗體通用方法
68.原生JavaScript判斷是否為客戶端設備
69.原生JavaScript獲取單選按鈕的值
70.原生JavaScript獲取復選框的值
71.原生JavaScript判斷是否為郵箱
72.原生JavaScript判斷是否有列表中的危險字符
73.原生JavaScript判斷字符串是否大于規定的長度
74.原生JavaScript判斷字符串是為網址不區分大小寫
75.原生JavaScript判斷字符串是否為小數
76.原生JavaScript判斷字符串是否為整數
77.原生JavaScript判斷字符串是否為浮點數
78.原生JavaScript判斷字符是否為A-Za-z英文字母
79.原生JavaScript判斷字符串是否郵政編碼
80.原生JavaScript判斷字符是否空NULL
81.原生JavaScript用正則表達式提取頁面代碼中所有網址
82.原生JavaScript用正則表達式清除相同的數組(低效率)
83.原生JavaScript用正則表達式清除相同的數組(高效率)
84.原生JavaScript用正則表達式按字母排序，對每行進行數組排序
85.原生JavaScript字符串反序
86.原生JavaScript用正則表達式清除html代碼中的腳本
87.原生JavaScript動態執行JavaScript腳本
88.原生JavaScript動態執行VBScript腳本
89.原生JavaScript實現金額大寫轉換函數
90.原生JavaScript常用的正則表達式大收集
91.原生JavaScript實現窗體改變事件resize的操作（兼容所以的瀏覽器）
92.原生JavaScript用正則清除空格分左右
93.原生JavaScript判斷變量是否空值
94.原生JavaScript實現base64解碼
95.原生JavaScript實現utf8解碼
96.原生JavaScript獲取窗體可見范圍的寬與高
97.原生JavaScript判斷IE版本號（既簡潔.又向后兼容！）
98.原生JavaScript獲取瀏覽器版本號
99.原生JavaScript半角轉換為全角函數
100.原生JavaScript全角轉換為半角函數
代碼片段
function cutstr(str, len) {
var temp;
var icount=0;
var patrn=/[^\x00-\xff]/; // 匹配雙字節字符(包括漢字在內)
var strren="";
for (var i=0; i < str.length; i++) {
if (icount < len - 1) {
temp=str.substr(i, 1);
if (patrn.exec(temp)==null) {
icount=icount + 1;
} else {
icount=icount + 2;
}
} else {
break;
}
}
return strre + "...";
}
function getHost(url) {
var host="null";
if (typeof url==undefined || url===null) {
url=window.location.href;
}
var regex=/^\w+\:\/\/([^\/]*).*/;
var match=url.match(regex);
if (typeof match !=undefined && match !=null) {
host=match[1];
}
return host;
}
String.prototype.trim=function() {
var reExtraSpace=/^\s*(.*?)\s+$/;
return this.replace(reExtraSpace, "$1");
}
String.prototype.replaceAll=function(s1, s2) {
return this.replace(new RegExp(s1, "gm"), s2);
}
function HtmlEncode(text) {
return text.replace(/&/g, '&')
.replace(/\"/g, '"')
.replace(/</g, '<')
.replace(/>/g, '>');
}
function HtmlDecode(text) {
return text.replace('&', /&/g)
.replace('"', /\"/g)
.replace('<', /</g)
.replace('>', />/g);
}
function isDigit(value) {
var patrn=/^[0-9]*$/;
if (patrn.exec(value)==null || value=="") {
return false
} else {
return true
}
}
Date.prototype.Format=function(formatStr) {
var str=formatStr;
var Week=['日', '一', '二', '三', '四', '五', '六'];
str=str.replace(/yyyy|YYYY/, this.getFullYear());
str=str.replace(/yy|YY/, (this.getYear() % 100) > 9 ? (this.getYear() % 100).toString() : '0' + (this.getYear() % 100));
str=str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1).toString() : '0' + (this.getMonth() + 1));
str=str.replace(/M/g, (this.getMonth() + 1));
str=str.replace(/w|W/g, Week[this.getDay()]);
str=str.replace(/dd|DD/, this.getDate() > 9 ? this.getDate().toString() : '0' + this.getDate());
str=str.replace(/d|D/g, this.getDate());
str=str.replace(/hh|HH/, this.getHours() > 9 ? this.getHours().toString() : '0' + this.getHours());
str=str.replace(/h|H/g, this.getHours());
str=str.replace(/mm/, this.getMinutes() > 9 ? this.getMinutes().toString() : '0' + this.getMinutes());
str=str.replace(/m/g, this.getMinutes());
str=str.replace(/ss|SS/, this.getSeconds() > 9 ? this.getSeconds().toString() : '0' + this.getSeconds());
str=str.replace(/s|S/g, this.getSeconds());
return str
}
function setCookie(name, value, Hours) {
var d=new Date();
var offset=8;
var utc=d.getTime() + (d.getTimezoneOffset() * 60000);
var nd=utc + (3600000 * offset);
var exp=new Date(nd);
exp.setTime(exp.getTime() + Hours * 60 * 60 * 1000);
document.cookie=name + "=" + escape(value) + ";path=/;expires=" + exp.toGMTString() + ";domain=360doc.com;"
}
function getCookie(name) {
var arr=document.cookie.match(new RegExp("(^| )" + name + "=([^;]*)(;|$)"));
if (arr !=null) return unescape(arr[2]);
return null
}
function AddFavorite(sURL, sTitle) {
try {
window.external.addFavorite(sURL, sTitle)
} catch(e) {
try {
window.sidebar.addPanel(sTitle, sURL, "")
} catch(e) {
alert("加入收藏失敗，請使用Ctrl+D進行添加")
}
}
}
function setHomepage() {
if (document.all) {
document.body.style.behavior='url(#default#homepage)';
document.body.setHomePage('http://***');
} else if (window.sidebar) {
if (window.netscape) {
try {
netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect")
} catch(e) {
alert("該操作被瀏覽器拒絕，如果想啟用該功能，請在地址欄內輸入 about:config,然后將項 signed.applets.codebase_principal_support 值該為true")
}
}
var prefs=Components.classes['@mozilla.org/preferences-service;1'].getService(Components.interfaces.nsIPrefBranch);
prefs.setCharPref('browser.startup.homepage', 'http://***')
}
}
var ua=navigator.userAgent.toLowerCase();
var isIE6=ua.indexOf("msie 6") > -1;
if (isIE6) {
try {
document.execCommand("BackgroundImageCache", false, true)
} catch(e) {}
}
function LoadStyle(url) {
try {
document.createStyleSheet(url)
} catch(e) {
var cssLink=document.createElement('link');
cssLink.rel='stylesheet';
cssLink.type='text/css';
cssLink.href=url;
var head=document.getElementsByTagName('head')[0];
head.appendChild(cssLink)
}
}
function evalscript(s) {
if(s.indexOf('<script')==-1) return s;
var p=/<script[^\>]*?>([^\x00]*?)<\/script>/ig;
var arr=[];
while(arr=p.exec(s)) {
var p1=/<script[^\>]*?src=\"([^\>]*?)\"[^\>]*?(reload=\"1\")?(?:charset=\"([\w\-]+?)\")?><\/script>/i;
var arr1=[];
arr1=p1.exec(arr[0]);
if(arr1) {
appendscript(arr1[1], '', arr1[2], arr1[3]);
} else {
p1=/<script(.*?)>([^\x00]+?)<\/script>/i;
arr1=p1.exec(arr[0]);
appendscript('', arr1[2], arr1[1].indexOf('reload=') !=-1);
}
}
return s;
}
function stripscript(s) {
return s.replace(/<script.*?>.*?<\/script>/ig, '');
}
function appendscript(src, text, reload, charset) {
var id=hash(src + text);
if(!reload && in_array(id, evalscripts)) return;
if(reload && $(id)) {
$(id).parentNode.removeChild($(id));
}
evalscripts.push(id);
var scriptNode=document.createElement("script");
scriptNode.type="text/javascript";
scriptNode.id=id;
scriptNode.charset=charset ? charset : (BROWSER.firefox ? document.characterSet : document.charset);
try {
if(src) {
scriptNode.src=src;
scriptNode.onloadDone=false;
scriptNode.onload=function () {
scriptNode.onloadDone=true;
JSLOADED[src]=1;
};
scriptNode.onreadystatechange=function () {
if((scriptNode.readyState=='loaded' || scriptNode.readyState=='complete') && !scriptNode.onloadDone) {
scriptNode.onloadDone=true;
JSLOADED[src]=1;
}
};
} else if(text){
scriptNode.text=text;
}
document.getElementsByTagName('head')[0].appendChild(scriptNode);
} catch(e) {}
}
function $(id) {
return !id ? null : document.getElementById(id);
}
function browserVersion(types) {
var other=1;
for(i in types) {
var v=types[i] ? types[i] : i;
if(USERAGENT.indexOf(v) !=-1) {
var re=new RegExp(v + '(\\/|\\s)([\\d\\.]+)', 'ig');
var matches=re.exec(USERAGENT);
var ver=matches !=null ? matches[2] : 0;
other=ver !==0 && v !='mozilla' ? 0 : other;
}else {
var ver=0;
}
eval('BROWSER.' + i + '=ver');
}
BROWSER.other=other;
}
function $(id) {
return !id ? null : document.getElementById(id);
}
function display(id) {
var obj=$(id);
if(obj.style.visibility) {
obj.style.visibility=obj.style.visibility=='visible' ? 'hidden' : 'visible';
} else {
obj.style.display=obj.style.display=='' ? 'none' : '';
}
}
function insertAfter(newChild, refChild) {
var parElem=refChild.parentNode;
if(parElem.lastChild==refChild){
refChild.appendChild(newChild);
}else{
parElem.insertBefore(newChild, refChild.nextSibling);
}
}
function addEventSamp(obj, evt, fn){
if (obj.addEventListener) {
obj.addEventListener(evt, fn, false);
}else if(obj.attachEvent){
obj.attachEvent('on' + evt, fn);
}
}
function focusLast(){
var e=event.srcElement;
var r=e.createTextRange();
r.moveStart('character',e.value.length);
r.collapse(true);
r.select();
}
function getUrlState(URL) {
var xmlhttp=new ActiveXObject("microsoft.xmlhttp");
xmlhttp.Open("GET", URL, false);
try {
xmlhttp.Send();
} catch(e) {
} finally {
var result=xmlhttp.responseText;
if(result) {
if(xmlhttp.Status==200){
return true;
}else{
return false;
}
} else {
return false;
}
}
}
function formatCss(s){ //格式化代碼
s=s.replace(/\s*([\{\}\:\;\,])\s*/g, "$1");
s=s.replace(/;\s*;/g, ";"); //清除連續分號
s=s.replace(/\,[\s\.\#\d]*{/g, "{");
s=s.replace(/([^\s])\{([^\s])/g, "$1 {\n\t$2");
s=s.replace(/([^\s])\}([^\n]*)/g, "$1\n}\n$2");
s=s.replace(/([^\s]);([^\s\}])/g, "$1;\n\t$2");
return s;
}
function yasuoCss (s) { //壓縮代碼
s=s.replace(/\/\*(.|\n)*?\*\//g, ""); //刪除注釋
s=s.replace(/\s*([\{\}\:\;\,])\s*/g, "$1");
s=s.replace(/\,[\s\.\#\d]*\{/g, "{"); //容錯處理
s=s.replace(/;\s*;/g, ";"); //清除連續分號
s=s.match(/^\s*(\S+(\s+\S+)*)\s*$/); //去掉首尾空白
return (s==null) ? "" : s[1];
}
var currentPageUrl="";
if (typeof this.href===undefined) {
currentPageUrl=document.location.toString().toLowerCase();
}
else {
currentPageUrl=this.href.toString().toLowerCase();
}
function _ip2int(ip){
var num=0;
ip=ip.split(".");
num=Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]);
num=num >>> 0;
return num;
}
function _int2iP(num){
var str;
var tt=new Array();
tt[0]=(num >>> 24) >>> 0;
tt[1]=((num << 8) >>> 24) >>> 0;
tt[2]=(num << 16) >>> 24;
tt[3]=(num << 24) >>> 24;
str=String(tt[0]) + "." + String(tt[1]) + "." + String(tt[2]) + "." + String(tt[3]);
return str;
}
function checkAll() {
var selectall=document.getElementById("selectall");
var allbox=document.getElementsByName("allbox");
if (selectall.checked) {
for (var i=0; i < allbox.length; i++) {
allbox[i].checked=true;
}
} else {
for (var i=0; i < allbox.length; i++) {
allbox[i].checked=false;
}
}
}
function isMobile(){
if (typeof this._isMobile==='boolean'){
return this._isMobile;
}
var screenWidth=this.getScreenWidth();
var fixViewPortsExperiment=rendererModel.runningExperiments.FixViewport || rendererModel.runningExperiments.fixviewport;
var fixViewPortsExperimentRunning=fixViewPortsExperiment && (fixViewPortsExperiment.toLowerCase()==="new");
if(!fixViewPortsExperiment){
if(!this.isAppleMobileDevice()){
screenWidth=screenWidth/window.devicePixelRatio;
}
}
var isMobileScreenSize=screenWidth < 600;
var isMobileUserAgent=false;
this._isMobile=isMobileScreenSize && this.isTouchScreen();
return this._isMobile;
}
function isMobileUserAgent() {
return (/iphone|ipod|android.*mobile|windows.*phone|blackberry.*mobile/i.test(window.navigator.userAgent.toLowerCase()));
}
function isAppleMobileDevice() {
return (/iphone|ipod|ipad|Macintosh/i.test(navigator.userAgent.toLowerCase()));
}
function isAndroidMobileDevice(){
return (/android/i.test(navigator.userAgent.toLowerCase()));
}
function isTouchScreen() {
return (('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch);
}
function isNewChromeOnAndroid(){
if(this.isAndroidMobileDevice()){
var userAgent=navigator.userAgent.toLowerCase();
if((/chrome/i.test(userAgent))){
var parts=userAgent.split('chrome/');
var fullVersionString=parts[1].split(" ")[0];
var versionString=fullVersionString.split('.')[0];
var version=parseInt(versionString);
if(version >=27){
return true;
}
}
}
return false;
}
function isViewportOpen() {
return !!document.getElementById('wixMobileViewport');
}
function getInitZoom() {
if(!this._initZoom) {
var screenWidth=Math.min(screen.height, screen.width);
if(this.isAndroidMobileDevice() && !this.isNewChromeOnAndroid()) {
screenWidth=screenWidth / window.devicePixelRatio;
}
this._initZoom=screenWidth /document.body.offsetWidth;
}
return this._initZoom;
}
function getZoom(){
var screenWidth=(Math.abs(window.orientation)===90) ? Math.max(screen.height, screen.width) : Math.min(screen.height, screen.width);
if(this.isAndroidMobileDevice() && !this.isNewChromeOnAndroid()){
screenWidth=screenWidth/window.devicePixelRatio;
}
var FixViewPortsExperiment=rendererModel.runningExperiments.FixViewport || rendererModel.runningExperiments.fixviewport;
var FixViewPortsExperimentRunning=FixViewPortsExperiment && (FixViewPortsExperiment==="New" || FixViewPortsExperiment==="new");
if(FixViewPortsExperimentRunning){
return screenWidth / window.innerWidth;
}else{
return screenWidth / document.body.offsetWidth;
}
}
function getScreenWidth(){
var smallerSide=Math.min(screen.width, screen.height);
var fixViewPortsExperiment=rendererModel.runningExperiments.FixViewport || rendererModel.runningExperiments.fixviewport;
var fixViewPortsExperimentRunning=fixViewPortsExperiment && (fixViewPortsExperiment.toLowerCase()==="new");
if(fixViewPortsExperiment){
if(this.isAndroidMobileDevice() && !this.isNewChromeOnAndroid()){
smallerSide=smallerSide/window.devicePixelRatio;
}
}
return smallerSide;
}
function IsURL(strUrl) {
var regular=/^\b(((https?|ftp):\/\/)?[-a-z0-9]+(\.[-a-z0-9]+)*\.(?:com|edu|gov|int|mil|net|org|biz|info|name|museum|asia|coop|aero|[a-z][a-z]|((25[0-5])|(2[0-4]\d)|(1\d\d)|([1-9]\d)|\d))\b(\/[-a-z0-9_:\@&?=+,.!\/~%\$]*)?)$/i
if (regular.test(strUrl)) {
return true;
}
else {
return false;
}
}
function getElementsByClassName(name) {
var tags=document.getElementsByTagName('*') || document.all;
var els=[];
for (var i=0; i < tags.length; i++) {
if (tags[i].className) {
var cs=tags[i].className.split(' ');
for (var j=0; j < cs.length; j++) {
if (name==cs[j]) {
els.push(tags[i]);
break;
}
}
}
}
return els;
}
String.prototype.startWith=function (s) {
return this.indexOf(s)==0;
}
String.prototype.endWith=function (s) {
var d=this.length - s.length;
return (d >=0 && this.lastIndexOf(s)==d);
}
function getIE(){
if (window.ActiveXObject){
var v=navigator.userAgent.match(/MSIE ([^;]+)/)[1];
return parseFloat(v.substring(0, v.indexOf(".")));
}
return false;
}
function getPageHeight() {
var g=document, a=g.body, f=g.documentElement, d=g.compatMode=="BackCompat"
? a
: g.documentElement;
return Math.max(f.scrollHeight, a.scrollHeight, d.clientHeight);
}
function getPageScrollLeft(){
var a=document;
return a.documentElement.scrollLeft || a.body.scrollLeft;
}
function getPageViewWidth(){
var d=document, a=d.compatMode=="BackCompat"
? d.body
: d.documentElement;
return a.clientWidth; // 可視寬度為clientWidth
}
// 考慮帶滾動條的全部寬度
function getPageWidth(){
var g=document, a=g.body, f=g.documentElement, d=g.compatMode=="BackCompat"
? a
: g.documentElement;
return Math.max(f.scrollWidth, a.scrollWidth, d.clientWidth);
}
function getPageScrollTop(){
var a=document;
return a.documentElement.scrollTop || a.body.scrollTop;
}
function getPageViewHeight() {
var d=document, a=d.compatMode=="BackCompat"
? d.body
: d.documentElement;
return a.clientHeight;
}
function addEvt(oTarget, sEvtType, fnHandle) {
if(!oTarget) {return;}
if(oTarget.addEventListener) {
oTarget.addEventListener(sEvtType, fnHandle, false);
} else if(oTarget.attachEvent) {
oTarget.attachEvent("on" + sEvtType, fnHandle);
} else {
oTarget["on" + sEvtType]=fnHandle;
}
}
function delEvt(oTarget, sEvtType, fnHandle){
if(!oTarget) {return;}
if(oTarget.addEventListener) {
oTarget.addEventListener(sEvtType,fnHandle,false);
} else if(oTarget.attachEvent) {
oTarget.attachEvent("on" + sEvtType,fnHandle);
} else {
oTarget["on" + sEvtType]=fnHandle;
}
}
function removeUrlPrefix(a) {
a=a.replace(/：/g,":").replace(/．/g,".").replace(/／/g,"/");
while(trim(a).toLowerCase().indexOf("http://")==0) {
a=trim(a.replace(/http:\/\//i,""));
}
return a;
}
function uniqueId() {
var a=Math.random, b=parseInt;
return Number(new Date()).toString()+b(10*a())+b(10*a())+b(10*a());
}
function chgCase(sStr,iCase){
if(typeof sStr !="string" || sStr.length <=0 || !(iCase===0 || iCase==1)){
return sStr;
}
var i,oRs=[],iCode;
if(iCase){/*半->全*/
for(i=0; i<sStr.length;i+=1){
iCode=sStr.charCodeAt(i);
if(iCode==32){
iCode=12288;
}else if(iCode < 127){
iCode +=65248;
}
oRs.push(String.fromCharCode(iCode));
}
}else{/*全->半*/
for(i=0; i<sStr.length;i+=1){
iCode=sStr.charCodeAt(i);
if(iCode==12288){
iCode=32;
}else if(iCode > 65280 && iCode < 65375){
iCode -=65248;
}
oRs.push(String.fromCharCode(iCode));
}
}
return oRs.join("");
}
function checkKey(iKey){
if(iKey==32 || iKey==229){return true;} /*空格和異常*/
if(iKey>47 && iKey < 58){return true;} /*數字*/
if(iKey>64 && iKey < 91){return true;} /*字母*/
if(iKey>95 && iKey < 108){return true;} /*數字鍵盤1*/
if(iKey>108 && iKey < 112){return true;} /*數字鍵盤2*/
if(iKey>185 && iKey < 193){return true;} /*符號1*/
if(iKey>218 && iKey < 223){return true;} /*符號2*/
return false;
}
function getScrollXY() {
return document.body.scrollTop ? {
x: document.body.scrollLeft,
y: document.body.scrollTop
}: {
x: document.documentElement.scrollLeft,
y: document.documentElement.scrollTop
}
}
Date.prototype.format=function(format) { // author: meizz
var o={
"M+" : this.getMonth() + 1, // month
"d+" : this.getDate(), // day
"h+" : this.getHours(), // hour
"m+" : this.getMinutes(), // minute
"s+" : this.getSeconds(), // second
"q+" : Math.floor((this.getMonth() + 3) / 3), // quarter
"S" : this.getMilliseconds() // millisecond
}
if(/(y+)/.test(format)) {
format=format.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));
}
for(var k in o)if(new RegExp("("+ k +")").test(format)) {
format=format.replace(RegExp.$1, RegExp.$1.length==1 ? o[k] : ("00"+ o[k]).substr((""+ o[k]).length));
}
return format;
}
alert(new Date().format("yyyy-MM-dd hh:mm:ss"));
/*
1、< 60s, 顯示為“剛剛”
2、>=1min && < 60 min, 顯示與當前時間差“XX分鐘前”
3、>=60min && < 1day, 顯示與當前時間差“今天 XX:XX”
4、>=1day && < 1year, 顯示日期“XX月XX日 XX:XX”
5、>=1year, 顯示具體日期“XXXX年XX月XX日 XX:XX”
*/
function timeFormat(time){
var date=new Date(time)
, curDate=new Date()
, year=date.getFullYear()
, month=date.getMonth() + 1
, day=date.getDate()
, hour=date.getHours()
, minute=date.getMinutes()
, curYear=curDate.getFullYear()
, curHour=curDate.getHours()
, timeStr;
if(year < curYear){
timeStr=year +'年'+ month +'月'+ day +'日 '+ hour +':'+ minute;
}else{
var pastTime=curDate - date
, pastH=pastTime/3600000;
if(pastH > curHour){
timeStr=month +'月'+ day +'日 '+ hour +':'+ minute;
}else if(pastH >=1){
timeStr='今天 ' + hour +':'+ minute +'分';
}else{
var pastM=curDate.getMinutes() - minute;
if(pastM > 1){
timeStr=pastM +'分鐘前';
}else{
timeStr='剛剛';
}
}
}
return timeStr;
}
// 針對火狐不支持offsetX/Y
function getOffset(e) {
var target=e.target, // 當前觸發的目標對象
eventCoord,
pageCoord,
offsetCoord;
// 計算當前觸發元素到文檔的距離
pageCoord=getPageCoord(target);
// 計算光標到文檔的距離
eventCoord={
X : window.pageXOffset + e.clientX,
Y : window.pageYOffset + e.clientY
};
// 相減獲取光標到第一個定位的父元素的坐標
offsetCoord={
X : eventCoord.X - pageCoord.X,
Y : eventCoord.Y - pageCoord.Y
};
return offsetCoord;
}
function getPageCoord(element) {
var coord={ X : 0, Y : 0 };
// 計算從當前觸發元素到根節點為止，
// 各級 offsetParent 元素的 offsetLeft 或 offsetTop 值之和
while (element){
coord.X +=element.offsetLeft;
coord.Y +=element.offsetTop;
element=element.offsetParent;
}
return coord;
}
//正整數
/^[0-9]*[1-9][0-9]*$/;
//負整數
/^-[0-9]*[1-9][0-9]*$/;
//正浮點數
/^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/;
//負浮點數
/^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
//浮點數
/^(-?\d+)(\.\d+)?$/;
//email地址
/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
//url地址
/^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$/;
//年/月/日（年-月-日、年.月.日）
/^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$/;
//匹配中文字符
/[\u4e00-\u9fa5]/;
//匹配帳號是否合法(字母開頭，允許5-10字節，允許字母數字下劃線)
/^[a-zA-Z][a-zA-Z0-9_]{4,9}$/;
//匹配空白行的正則表達式
/\n\s*\r/;
//匹配中國郵政編碼
/[1-9]\d{5}(?!\d)/;
//匹配身份證
/\d{15}|\d{18}/;
//匹配國內電話號碼
/(\d{3}-|\d{4}-)?(\d{8}|\d{7})?/;
//匹配IP地址
/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/;
//匹配首尾空白字符的正則表達式
/^\s*|\s*$/;
//匹配HTML標記的正則表達式
< (\S*?)[^>]*>.*?|< .*? />;
function backTop(btnId) {
var btn=document.getElementById(btnId);
var d=document.documentElement;
var b=document.body;
window.onscroll=set;
btn.style.display="none";
btn.onclick=function() {
btn.style.display="none";
window.onscroll=null;
this.timer=setInterval(function() {
d.scrollTop -=Math.ceil((d.scrollTop + b.scrollTop) * 0.1);
b.scrollTop -=Math.ceil((d.scrollTop + b.scrollTop) * 0.1);
if ((d.scrollTop + b.scrollTop)==0) clearInterval(btn.timer, window.onscroll=set);
},
10);
};
function set() {
btn.style.display=(d.scrollTop + b.scrollTop > 100) ? 'block': "none";
}
};
backTop('goTop');
// 用法：如果地址是 test.htm?t1=1&t2=2&t3=3, 那么能取得：GET["t1"], GET["t2"], GET["t3"]
function get_get() {
querystr=window.location.href.split("?");
if(querystr[1]) {
var GETs=querystr[1].split("&"),
GET=new Array();
for(i=0; i < GETs.length; i++){
tmp_arr=GETs[i].split("=");
key=tmp_arr[0];
GET[key]=tmp_arr[1];
}
}
return querystr[1];
}
function checkall(form, prefix, checkall) {
var checkall=checkall ? checkall : 'chkall';
for(var i=0; i < form.elements.length; i++) {
var e=form.elements[i];
if(e.type=="checkbox"){
e.checked=form.elements[checkall].checked;
}
}
}
function uncheckAll(form) {
for (var i=0; i < form.elements.length; i++){
var e=form.elements[i];
if (e.name !='chkall')
e.checked=!e.checked;
}
}
function openWindow(url,windowName,width,height){
var x=parseInt(screen.width / 2.0) - (width / 2.0);
var y=parseInt(screen.height / 2.0) - (height / 2.0);
var isMSIE=(navigator.appName=="Microsoft Internet Explorer");
if (isMSIE) {
var p="resizable=1,location=no,scrollbars=no,width=";
p=p+width;
p=p+",height=";
p=p+height;
p=p+",left=";
p=p+x;
p=p+",top=";
p=p+y;
retval=window.open(url, windowName, p);
} else {
var win=window.open(url, "ZyiisPopup", "top=" + y + ",left=" + x + ",scrollbars=" + scrollbars + ",dialog=yes,modal=yes,width=" + width + ",height=" + height + ",resizable=no" );
eval("try { win.resizeTo(width, height); } catch(e) { }");
win.focus();
}
}
function client(o){
var b=navigator.userAgent.toLowerCase();
var t=false;
if (o=='isOP'){
t=b.indexOf('opera') > -1;
}
if (o=='isIE'){
t=b.indexOf('msie') > -1;
}
if (o=='isFF'){
t=b.indexOf('firefox') > -1;
}
return t;
}
function get_radio_value(field){
if(field && field.length){
for(var i=0; i < field.length; i++){
if(field[i].checked){
return field[i].value;
}
}
}else {
return;
}
}
function get_checkbox_value(field) {
if(field && field.length){
for(var i=0; i < field.length; i++){
if(field[i].checked && !field[i].disabled){
return field[i].value;
}
}
} else {
return;
}
}
function isEmail(str){
var re=/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/;
if (re.test(str) !=true) {
return false;
}else{
return true;
}
}
function isValidReg(chars){
var re=/<|>|\[|\]|\{|\}|『|』|※||||§|||||||□||㊣|﹋|⊕|⊙|〒|ㄅ|ㄆ|ㄇ|ㄈ|ㄉ|ㄊ|ㄋ|ㄌ|ㄍ|ㄎ|ㄏ|ㄐ|ㄑ|ㄒ|ㄓ|ㄔ|ㄕ|ㄖ|ㄗ|ㄘ|ㄙ|ㄚ|ㄛ|ㄜ|ㄝ|ㄞ|ㄟ|ㄢ|ㄣ|ㄤ|ㄥ|ㄦ|ㄧ|ㄨ|ㄩ|■|▄|▆|\*|@|#|\^|\\/;
if (re.test( chars)==true) {
return false;
}else{
return true;
}
}
function isValidLength(chars, len) {
if (chars.length < len) {
return false;
}
return true;
}
function isValidURL( chars ) {
var re=/^([hH][tT]{2}[pP]:\/\/|[hH][tT]{2}[pP][sS]:\/\/)(\S+\.\S+)$/;
if (!isNULL(chars)) {
chars=jsTrim(chars);
if (chars.match(re)==null)
return false;
else
return true;
}
return false;
}
function isValidDecimal( chars ) {
var re=/^\d*\.?\d{1,2}$/;
if (chars.match(re)==null)
return false;
else
return true;
}
function isNumber(chars) {
var re=/^\d*$/;
if (chars.match(re)==null)
return false;
else
return true;
}
function isFloat(str) {
for(i=0;i<str.length;i++) {
if((str.charAt(i)<"0" || str.charAt(i)>"9")&& str.charAt(i) !='.') {
return false;
}
}
return true;
}
function isLetters(str) {
var re=/^[A-Za-z]+$/;
if (str.match(re)==null)
return false;
else
return true;
}
function isValidPost( chars ) {
var re=/^\d{6}$/;
if (chars.match(re)==null)
return false;
else
return true;
}
function isNULL( chars ) {
if (chars==null)
return true;
if (jsTrim(chars).length==0)
return true;
return false;
}
var aa=document.documentElement.outerHTML.match(/(url\(|src=|href=)[\"\']*([^\"\'\(\)\<\>\[\] ]+)[\"\'\)]*|(http:\/\/[\w\-\.]+[^\"\'\(\)\<\>\[\] ]+)/ig).join("\r\n").replace(/^(src=|href=|url\()[\"\']*|[\"\'\>\) ]*$/igm,"");
alert(aa);
Array.prototype.unique=function() {
return this.reverse().join(",").match(/([^,]+)(?!.*\1)/ig).reverse();
}
String.prototype.unique=function() {
var x=this.split(/[\r\n]+/);
var y='';
for(var i=0; i < x.length; i++){
if(!new RegExp("^"+x[i].replace(/([^\w])/ig,"\\$1")+"$","igm").test(y)) {
y +=x[i]+"\r\n";
}
}
return y;
}
function SetSort(){
var text=K1.value.split(/[\r\n]/).sort().join("\r\n"); // 順序
var test=K1.value.split(/[\r\n]/).sort().reverse().join("\r\n"); // 反序
K1.value=(K1.value !=text) ? text : test;
}
function IsReverse(text) {
return text.split('').reverse().join('');
}
function clear_script() {
K1.valu e=K1.value.replace(/<script.*?>[\s\S]*?<\/script>|\s+on[a-zA-Z]{3,16}\s?=\s?"[\s\S]*?"|\s+on[a-zA-Z]{3,16}\s?=\s?'[\s\S]*?'|\s+on[a-zA-Z]{3,16}\s?=[^ >]+/ig,"");
}
function javascript(){
try{
eval(K1.value);
}catch(e){
alert(e.message);
}
}
function vbscript() {
try{
var script=document.getElementById("K1").value;
if(script.trim()=="") return;
window.execScript('On Error Resume Next \n'+script+'\n If Err.Number<>0 Then \n MsgBox "請輸入正確的VBScript腳本!",48,"腳本錯誤!" \n End If',"vbscript")
} catch(e) {
alert(e.message);
}
}
function transform(tranvalue) {
try {
var i=1;
var dw2=new Array("", "萬", "億"); //大單位
var dw1=new Array("拾", "佰", "仟"); //小單位
var dw=new Array("零", "壹", "貳", "叁", "肆", "伍", "陸", "柒", "捌", "玖"); //整數部分用
//以下是小寫轉換成大寫顯示在合計大寫的文本框中
//分離整數與小數
var source=splits(tranvalue);
var num=source[0];
var dig=source[1];
//轉換整數部分
var k1=0; //計小單位
var k2=0; //計大單位
var sum=0;
var str="";
var len=source[0].length; //整數的長度
for (i=1; i <=len; i++) {
var n=source[0].charAt(len - i); //取得某個位數上的數字
var bn=0;
if (len - i - 1 >=0) {
bn=source[0].charAt(len - i - 1); //取得某個位數前一位上的數字
}
sum=sum + Number(n);
if (sum !=0) {
str=dw[Number(n)].concat(str); //取得該數字對應的大寫數字，并插入到str字符串的前面
if (n=='0') sum=0;
}
if (len - i - 1 >=0) { //在數字范圍內
if (k1 !=3) { //加小單位
if (bn !=0) {
str=dw1[k1].concat(str);
}
k1++;
} else { //不加小單位，加大單位
k1=0;
var temp=str.charAt(0);
if (temp=="萬" || temp=="億") //若大單位前沒有數字則舍去大單位
str=str.substr(1, str.length - 1);
str=dw2[k2].concat(str);
sum=0;
}
}
if (k1==3) //小單位到千則大單位進一
{
k2++;
}
}
//轉換小數部分
var strdig="";
if (dig !="") {
var n=dig.charAt(0);
if (n !=0) {
strdig +=dw[Number(n)] + "角"; //加數字
}
var n=dig.charAt(1);
if (n !=0) {
strdig +=dw[Number(n)] + "分"; //加數字
}
}
str +="元" + strdig;
} catch(e) {
return "0元";
}
return str;
}
//拆分整數與小數
function splits(tranvalue) {
var value=new Array('', '');
temp=tranvalue.split(".");
for (var i=0; i < temp.length; i++) {
value[i]=temp[i];
}
return value;
}
匹配中文字符的正則表達式： [\u4e00-\u9fa5]
匹配雙字節字符（包括漢字在內）：[^\x00-\xff]
匹配空行的正則表達式：\n[\s| ]*\r
匹配 HTML 標記的正則表達式：<(.*)>.*<\/\1>|<(.*) \/>
匹配首尾空格的正則表達式：(^\s*)|(\s*$)
匹配 IP 地址的正則表達式：/(\d+)\.(\d+)\.(\d+)\.(\d+)/g
匹配 Email 地址的正則表達式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配網址 URL 的正則表達式：http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
sql 語句：^(select|drop|delete|create|update|insert).*$
非負整數：^\d+$
正整數：^[0-9]*[1-9][0-9]*$
非正整數：^((-\d+)|(0+))$
負整數：^-[0-9]*[1-9][0-9]*$
整數：^-?\d+$
非負浮點數：^\d+(\.\d+)?$
正浮點數：^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
非正浮點數：^((-\d+\.\d+)?)|(0+(\.0+)?))$
英文字符串：^[A-Za-z]+$
英文大寫串：^[A-Z]+$
英文小寫串：^[a-z]+$
英文字符數字串：^[A-Za-z0-9]+$
英數字加下劃線串：^\w+$
E-mail地址：^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$
URL：^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$ 或：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$
郵政編碼：^[1-9]\d{5}$
電話號碼：^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$
手機號碼：^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$
雙字節字符（包括漢字在內）：^\x00-\xff
匹配首尾空格：(^\s*)|(\s*$)
匹配 HTML 標記：<(.*)>.*<\/\1>|<(.*) \/>
匹配空行：\n[\s| ]*\r
提取信息中的網絡鏈接：(h|H)(r|R)(e|E)(f|F) *=*('|")?(\w|\\|\/|\.)+('|"| *|>)?
提取信息中的郵件地址：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
提取信息中的圖片鏈接：(s|S)(r|R)(c|C) *=*('|")?(\w|\\|\/|\.)+('|"| *|>)?
提取信息中的 IP 地址：(\d+)\.(\d+)\.(\d+)\.(\d+)
提取信息中的中國手機號碼：(86)*0*13\d{9}
提取信息中的中國固定電話號碼：(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}
提取信息中的中國電話號碼（包括移動和固定電話）：(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}
提取信息中的中國郵政編碼：[1-9]{1}(\d+){5}
提取信息中的浮點數（即小數）：(-?\d*)\.?\d+
提取信息中的任何數字 ：(-?\d*)(\.\d+)?
IP：(\d+)\.(\d+)\.(\d+)\.(\d+)
電話區號：^0\d{2,3}$
騰訊 QQ 號：^[1-9]*[1-9][0-9]*$
帳號（字母開頭，允許 5-16 字節，允許字母數字下劃線）：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
中文、英文、數字及下劃線：^[\u4e00-\u9fa5_a-zA-Z0-9]+$
(function(){
var fn=function(){
var w=document.documentElement ? document.documentElement.clientWidth : document.body.clientWidth
,r=1255
,b=Element.extend(document.body)
,classname=b.className;
if(w < r){
// 當窗體的寬度小于1255的時候執行相應的操作
}else{
// 當窗體的寬度大于1255的時候執行相應的操作
}
}
if(window.addEventListener){
window.addEventListener('resize', function(){ fn(); });
}else if(window.attachEvent){
window.attachEvent('onresize', function(){ fn(); });
}
fn();
})();
function ltrim(s){ return s.replace( /^(\s*| *)/, ""); }
function rtrim(s){ return s.replace( /(\s*| *)$/, ""); }
function trim(s){ return ltrim(rtrim(s)); }
/**
* 判斷變量是否空值
* undefined, null, '', false, 0, [], {} 均返回true，否則返回false
*/
function empty(v){
switch (typeof v){
case 'undefined' : return true;
case 'string' : if(trim(v).length==0) return true; break;
case 'boolean' : if(!v) return true; break;
case 'number' : if(0===v) return true; break;
case 'object' :
if(null===v) return true;
if(undefined !==v.length && v.length==0) return true;
for(var k in v){return false;} return true;
break;
}
return false;
}
function base64_decode(data){
var b64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var o1, o2, o3, h1, h2, h3, h4, bits, i=0,ac=0,dec="",tmp_arr=[];
if (!data) { return data; }
data +='';
do {
h1=b64.indexOf(data.charAt(i++));
h2=b64.indexOf(data.charAt(i++));
h3=b64.indexOf(data.charAt(i++));
h4=b64.indexOf(data.charAt(i++));
bits=h1 << 18 | h2 << 12 | h3 << 6 | h4;
o1=bits >> 16 & 0xff;
o2=bits >> 8 & 0xff;
o3=bits & 0xff;
if (h3==64) {
tmp_arr[ac++]=String.fromCharCode(o1);
} else if (h4==64) {
tmp_arr[ac++]=String.fromCharCode(o1, o2);
} else {
tmp_arr[ac++]=String.fromCharCode(o1, o2, o3);
}
} while (i < data.length);
dec=tmp_arr.join('');
dec=utf8_decode(dec);
return dec;
}
95, 原生JavaScript實現utf8解碼
function utf8_decode(str_data){
var tmp_arr=[],i=0,ac=0,c1=0,c2=0,c3=0;str_data +='';
while (i < str_data.length) {
c1=str_data.charCodeAt(i);
if (c1 < 128) {
tmp_arr[ac++]=String.fromCharCode(c1);
i++;
} else if (c1 > 191 && c1 < 224) {
c2=str_data.charCodeAt(i + 1);
tmp_arr[ac++]=String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
i +=2;
} else {
c2=str_data.charCodeAt(i + 1);
c3=str_data.charCodeAt(i + 2);
tmp_arr[ac++]=String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
i +=3;
}
}
return tmp_arr.join('');
}
function getViewSize() {
var de=document.documentElement;
var db=document.body;
var viewW=de.clientWidth==0 ? db.clientWidth : de.clientWidth;
var viewH=de.clientHeight==0 ? db.clientHeight : de.clientHeight;
return Array(viewW ,viewH);
}
var _IE=(function(){
var v=3, div=document.createElement('div'), all=div.getElementsByTagName('i');
while (
div.innerHTML='<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
all[0]
);
return v > 4 ? v : false ;
}());
function browserVersion(types) {
var other=1;
for (i in types) {
var v=types[i] ? types[i] : i;
if (USERAGENT.indexOf(v) !=-1) {
var re=new RegExp(v + '(\\/|\\s|:)([\\d\\.]+)', 'ig');
var matches=re.exec(USERAGENT);
var ver=matches !=null ? matches[2] : 0;
other=ver !==0 && v !='mozilla' ? 0 : other;
} else {
var ver=0;
}
eval('BROWSER.' + i + '=ver');
}
BROWSER.other=other;
}
function ToDBC(str){
var result='';
for(var i=0; i < str.length; i++){
code=str.charCodeAt(i);
if(code >=33 && code <=126){
result +=String.fromCharCode(str.charCodeAt(i) + 65248);
}else if (code==32){
result +=String.fromCharCode(str.charCodeAt(i) + 12288 - 32);
}else{
result +=str.charAt(i);
}
}
return result;
}
篇是接著上一篇“Python系列(14)”接下來的對于字符串的使用介紹，最好這2篇一起看，是比較系統的對于字符串知識點的部分。
Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。
如下實例：
print "My name is %s and weight is %d kg!" % ('Zara', 21)
以上實例輸出結果：
My name is Zara and weight is 21 kg!
上面代碼中的%s，可以記s為string（字符串）的首字母，代表的是格式化替換字符串類型的數據
python字符串格式化符號:
格式化操作符輔助指令:
Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它增強了字符串格式化的功能。下一篇文章將對此字符串的函數 str.format()進行詳細介紹。
python中三引號可以將復雜的字符串進行復制:
python三引號允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。
三引號的語法是一對連續的單引號或者雙引號（通常都是成對的用）。
>>> hi='''hi
there'''
>>> hi
'hi\nthere'
>>> print hi
hi
there
三引號讓程序員從引號和特殊字符串的泥潭里面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。
一個典型的用例是，當你需要一塊HTML或者SQL時，這時用字符串組合，特殊字符串轉義將會非常的繁瑣。
老鐵們，大佬們，今天就給大家介紹到這里啦~~有興趣的可以加關注或點贊轉發給朋友喲~【愛他(她)就讓他(她)去搬磚吧】
敬請期待~~你我一同進步！！！有任何問題皆可留言詢問~~謝各位大佬關注！！
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
