ในเบราว์เซอร์ IE 7 8 หากคุณใช้แอตทริบิวต์ TRIM () เพื่อลบช่องว่างจะมีการรายงานข้อผิดพลาด
ดังนั้นจึงมีวิธีแก้ไขปัญหานี้ต่อไปนี้:
var aa = $ ("#id"). val (). trim () --- วิธีการตัดแต่ง () ไม่สามารถแยกวิเคราะห์ได้ใน IE
สารละลาย:
[var aa = $ .trim ($ ("#id"). val ()); ] นี่ไม่ใช่เรื่องง่ายที่จะใช้ดังนั้นใช้อันที่แนะนำด้านล่าง คนแรกได้รับการทดสอบ
กลุ่มคน W3C ถูกเตะเข้าหัวโดยลาและพวกเขาไม่สนับสนุนฟังก์ชั่นการตัดแต่ง (และ trimleft, trimright) จนกระทั่ง Java Script 1.8.1 น่าเสียดายที่ Firefox3.5 เท่านั้นที่รองรับตอนนี้ เนื่องจากการลบช่องว่างทั้งสองด้านของสตริงเป็นเรื่องธรรมดาเกินไปห้องสมุดที่สำคัญทั้งหมดมีเงาของตัวเอง นอกจากนี้ชาวต่างชาติมีพลังงานวิจัยมากมายและได้ประสบความสำเร็จมากมาย
ใช้ 1 ตกลง (เขียนสิ่งนี้ใน JS จากนั้นติดตามสตริงที่คุณต้องการลบพื้นที่โดยตรง trim ())
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ (/^/s/s*/, ''). แทนที่ (// s/s*$/, '');
-
มันดูไม่ค่อยดีนักและฉันใช้การเปลี่ยนปกติสองครั้ง ความเร็วจริงนั้นน่าทึ่งมากเนื่องจากการเพิ่มประสิทธิภาพภายในของเบราว์เซอร์ ตัวอย่างที่มีชื่อเสียงของการประกบสตริงการเพิ่มโดยตรงนั้นเร็วกว่าสตริงบัฟเฟอร์ที่ทำจากอาร์เรย์ ไลบรารีคลาส BASE2 ใช้การใช้งานนี้
ใช้ 2
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ (/^/s/, ''). แทนที่ (// s $/, '');
-
มันคล้ายกับการใช้งาน 1 แต่ช้ากว่าเล็กน้อยเหตุผลหลักคือก่อนอื่นถือว่ามีช่องว่างอย่างน้อยหนึ่งช่อง prototype.js ใช้การใช้งานนี้ แต่ชื่อของมันคือแถบเนื่องจากวิธีการต้นแบบพยายามเปลี่ยนชื่อเป็นทับทิม
การดำเนินการ 3
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้. substring (math.max (นี้. search (// s/), 0),. search (// s/s*$/) 1);
-
ส่วนที่ว่างเปล่านั้นได้มาจากการสกัดกั้น (แน่นอนว่าตัวละครช่องว่างจะได้รับอนุญาตตรงกลาง) และมีวิธีการรวม 4 วิธี ที่ตั้งไว้ล่วงหน้านั้นฉลาดมาก Substring ใช้ตัวเลขสองตัวเป็นพารามิเตอร์ Math.Max ใช้ตัวเลขสองตัวเป็นพารามิเตอร์และการค้นหาจะกลับไปที่หมายเลขหนึ่ง ความเร็วช้ากว่าสองด้านบนเล็กน้อย แต่มันเร็วกว่าด้านล่างมาก
ใช้ 4
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
กลับมาอีกครั้ง (/^/s |/s $/g, '');
-
สิ่งนี้สามารถเรียกได้ว่าเป็นเวอร์ชันที่เรียบง่ายของการใช้งาน 2 ซึ่งคือการใช้ผู้ให้บริการผู้สมัครเพื่อเชื่อมต่อสองปกติ แต่การทำเช่นนั้นจะล้มเหลวในการบรรลุโอกาสในการเพิ่มประสิทธิภาพเบราว์เซอร์ซึ่งไม่ดีเท่าการรับรู้ 3 เพราะมันดูสง่า
ใช้ 5
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
var str = this;
str = str.match (// s (?:/s/s)*/);
กลับมา Str? str [0]: '';
-
การจับคู่คือการกลับไปที่อาร์เรย์และส่วนที่ตรงตามข้อกำหนดของสตริงต้นฉบับกลายเป็นองค์ประกอบของมัน เพื่อป้องกันไม่ให้พื้นที่ว่างตรงกลางของสตริงถูกตัดการเชื่อมต่อเราจำเป็นต้องใช้การจัดกลุ่มที่ไม่ใช่การจับ (?: exp) เนื่องจากอาร์เรย์อาจว่างเปล่าเราจึงต้องทำการตัดสินเพิ่มเติมในภายหลัง ดูเหมือนว่าเบราว์เซอร์จะมีประสิทธิภาพน้อยกว่าในการจัดกลุ่มการประมวลผลและคำหนึ่งคำช้ากว่า ดังนั้นอย่าเชื่อโชคลางเกี่ยวกับกฎแม้ว่ามันจะมีอำนาจทุกอย่าง
การดำเนินการ 6
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ retlace (/^/s*(/s*(/s/s)*)/s*$/, '$ 1');
-
ระบุชิ้นส่วนที่ต้องการและใส่ไว้ในสตริงที่ว่างเปล่า แต่ประสิทธิภาพนั้นแย่มากโดยเฉพาะใน IE6
การดำเนินการ 7
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ retlace (/^/s*(/s*(?:/s/s)*)/s*$/, '$ 1');
-
มันคล้ายกับการใช้งาน 6 แต่ใช้แพ็คเก็ตที่ไม่ใช่การจับเพื่อให้ได้เปรียบและประสิทธิภาพการทำงานดีขึ้นเล็กน้อย
การดำเนินการ 8
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ (/^/s*((?: [/s/s]*/s)?)/s*$/, '$ 1');
-
ฉันปรับปรุงสองแนวคิดข้างต้นใช้การจัดกลุ่มที่ไม่ได้จับและชุดอักขระและแทนที่ * ด้วย? ซึ่งน่าทึ่งมาก โดยเฉพาะอย่างยิ่งใน IE6 ความบ้าคลั่งสามารถใช้เพื่ออธิบายการปรับปรุงประสิทธิภาพนี้และฆ่า Firefox โดยตรงในไม่กี่วินาที
ใช้ 9
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
ส่งคืนสิ่งนี้ (/^/s*([/s/s]*?)/s*$/, '$ 1');
-
คราวนี้ฉันใช้การจับคู่ขี้เกียจเพื่อแทนที่การจัดกลุ่มที่ไม่ได้จับกุมซึ่งได้รับการปรับปรุงใน Firefox และ IE ไม่ได้บ้าเหมือนครั้งที่แล้ว
ตระหนักถึง 10
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
var str = สิ่งนี้
whitespace = '/n/r/t/f/x0b/xa0/u2000/u2001/u2002/u2003/u2004/u2020 05/u2006/u2007/u2008/u2009/u200a/u200b/u2028/u2028
สำหรับ (var i = 0, len = str.length; i = 0; i--) {
if (whitespace.indexof (str.charat (i)) === -1) {
str = str.substring (0, i 1);
หยุดพัก;
-
-
ส่งคืน whitespace.indexof (str.charat (0)) === -1? str: '';
-
ฉันแค่อยากจะบอกว่าคนที่สร้างสิ่งนี้ไม่ได้อธิบายว่าเป็นวัวอีกต่อไป แต่อยู่ในระดับเดียวกับพระเจ้า ก่อนอื่นแสดงรายการอักขระว่างเปล่าที่เป็นไปได้ทั้งหมดตัดด้านหน้าว่างเปล่าในการสำรวจครั้งแรกและตัดด้านหลังว่างเปล่าเป็นครั้งที่สอง กระบวนการทั้งหมดใช้เฉพาะดัชนีและ substring ซึ่งเป็นวิธีการดั้งเดิมที่ออกแบบมาเป็นพิเศษสำหรับการประมวลผลสตริงและไม่ใช้ความสม่ำเสมอ ความเร็วนั้นรวดเร็วอย่างน่าอัศจรรย์และคาดว่าจะใกล้เคียงกับการใช้ไบนารีภายในและมีประสิทธิภาพที่โดดเด่นใน IE และ Firefox (แน่นอนว่าเบราว์เซอร์อื่น ๆ ไม่ต้องสงสัยเลย) ความเร็วเป็นศูนย์มิลลิวินาทีทั้งหมดนอกจากนี้
ดำเนินการ 11
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
var str = สิ่งนี้
str = str.replace (/^/s/, '');
สำหรับ (var i = str.length-1; i> = 0; i--) {
if (//s/.test(STR.SHARAT(I))) {
str = str.substring (0, i 1);
หยุดพัก;
-
-
return str;
-
การใช้งาน 10 ได้บอกเราว่าวิธีการสกัดกั้นสตริงปกติที่ไม่ทราบ แต่เดิมนั้นดีกว่าการทดแทนปกติแม้ว่ามันจะซับซ้อนกว่าเล็กน้อย แต่ตราบใดที่ความสม่ำเสมอไม่ซับซ้อนเกินไปเราสามารถใช้เบราว์เซอร์เพื่อเพิ่มประสิทธิภาพความสม่ำเสมอเพื่อปรับปรุงประสิทธิภาพการดำเนินการของโปรแกรมและบรรลุประสิทธิภาพ 8 ประสิทธิภาพใน IE ฉันไม่คิดว่าทุกคนจะใช้การใช้งาน 10 ในโครงการเพราะการใช้งานช่องว่างนั้นยาวเกินไปและยากที่จะจดจำ (แน่นอนถ้าคุณกำลังสร้างห้องสมุดชั้นเรียนมันจะเริ่มต้นอย่างแน่นอน) การใช้งาน 11 สามารถกล่าวได้ว่าเป็นเวอร์ชันที่ดีขึ้น ช่องว่างด้านหน้าถูกตัดออกโดยการเปลี่ยนเป็นประจำ พวกเขาได้รับการรักษาด้วยวิธีการดั้งเดิมในภายหลัง เอฟเฟกต์ไม่ด้อยกว่ารุ่นดั้งเดิม แต่ความเร็วนั้นน่าทึ่ง
ใช้ 12
การคัดลอกรหัสมีดังนี้:
string.prototype.trim = function () {
var str = สิ่งนี้
str = str.replace (/^/s/s*/, '')
ws = // s/,
i = str.length;
ในขณะที่ (ws.test (str.charat (-i)));
return str.slice (0, i 1);
-
เวอร์ชันการปรับปรุงที่ดีขึ้นของการใช้งาน 10 และการใช้งาน 11 ถูกเขียนขึ้น โปรดทราบว่ามันไม่เกี่ยวกับความเร็วประสิทธิภาพ แต่เกี่ยวกับความสะดวกในหน่วยความจำและแอปพลิเคชัน และสองรุ่นก่อน ๆ คือศูนย์มิลลิวินาทีนอกจากนี้พวกเขาจะใช้สิ่งนี้เพื่อทำงานและทำให้ผู้คนตกใจในอนาคต
ต่อไปนี้เป็นผลการเปรียบเทียบที่ได้รับจากชาวต่างชาติ พื้นหลังการดำเนินการคือการดำเนินการตัดแต่งในบทความนี้ (มากกว่า 27,600 อักขระ)
ใช้ Firefox 2 IE 6
TRIM1 15MS TRIM2 31MS TRIM3 46MS 31MS
TRIM4 47ms 46ms
TRIM5 156ms 1656ms
Trim6 172ms 2406ms
Trim7 172ms 1640ms
TRIM8 281ms TRIM9 125ms 78ms
TRIM10 TRIM11 TRIM12 การใช้งานฟังก์ชั่นการตัดแต่งเผยให้เห็นความคิดของคุณเอง หากคุณต้องการเข้าใจสิ่งที่ผู้เขียนต้นฉบับพูดโปรดอ่านข้อความต้นฉบับ
ขณะนี้มี 12 วิธีในการลบช่องว่างใน JS:
ใช้ 1
string.prototype.trim = function () {return this.replace (/^/s/s*/, ''). reflace (// s/s*$/, ''); -
ใช้ 2
string.prototype.trim = function () {return this.replace (/^/s+/, '') .retlace (// s+$/, ''); -
การดำเนินการ 3
string.prototype.trim = function () {return this.s string (math.max (this.search (// s/), 0), this.search (// s/s*$/) + 1); -
ใช้ 4
string.prototype.trim = function () {return this.replace (/^/s+|/s+$/g, ''); -
string.prototype.trim = function () {var str = this; str = str.match (// s+(?:/s+/s+)*/); กลับมา Str? str [0]: ''; -
string.prototype.trim = function () {return this.replace (/^/s*(/s*(/s+/s+)*)/s*$/, '$ 1'); -
การดำเนินการ 7
string.prototype.trim = function () {return this.replace (/^/s*(/s*(?:/s+/s+)*)/s*$/, '$ 1'); -
string.prototype.trim = function () {return this.replace (/^/s*((?: [/s/s]*/s)?)/s*$/, '$ 1'); -
string.prototype.trim = function () {return this.replace (/^/s*([/s/s]?)/s*$/, '$ 1'); -
string.prototype.trim = function () {var str = this, whitespace = ' /n/r/t/f/x0b/xa0/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/? สำหรับ (var i = 0, len = str.length; i <len; i ++) {ถ้า (whitespace.indexof (str.charat (i)) === -1) {str = str.s สตริง (i); หยุดพัก; }} สำหรับ (i = str.length -1; i> = 0; i--) {ถ้า (whitespace.indexof (str.charat (i)) === -1) {str = str.s สตริง (0, i + 1); หยุดพัก; }} ส่งคืน whitespace.indexof (str.charat (0)) === -1? str: ''; -
ดำเนินการ 11
string.prototype.trim = function () {var str = this, str = str.replace (/^/s+/, ''); สำหรับ (var i = str.length-1; i> = 0; i--) {ถ้า (//s/.test(str.starat(i))) {str = str.s สตริง (0, i + 1); หยุดพัก; }} return str; -
ใช้ 12
string.prototype.trim = function () {var str = this, str = str.replace (/^/s/s*/, ''), ws = // s/, i = str.length; ในขณะที่ (ws.test (str.charat (-i))); return str.slice (0, i + 1); -
มันดูไม่ค่อยดีนักและฉันใช้การเปลี่ยนปกติสองครั้งและความเร็วจริงนั้นน่าทึ่งมากเนื่องจากการเพิ่มประสิทธิภาพภายในของเบราว์เซอร์ ตัวอย่างที่มีชื่อเสียงของการประกบสตริงซึ่งเร็วกว่า Stringb? r ที่ทำจากอาร์เรย์ ไลบรารีคลาส Base2 ใช้การใช้งานนี้
มันคล้ายกับการใช้งาน 1 แต่ช้ากว่าเล็กน้อยส่วนใหญ่เป็นเพราะก่อนอื่นถือว่ามีช่องว่างอย่างน้อยหนึ่งช่อง prototype.js ใช้การใช้งานนี้ แต่ชื่อของมันคือแถบเนื่องจากวิธีการต้นแบบมุ่งมั่นที่จะมีชื่อเดียวกับ r y
ส่วนที่ว่างเปล่านั้นได้มาจากการสกัดกั้น (แน่นอนว่าตัวละครช่องว่างจะได้รับอนุญาตตรงกลาง) และมีการเรียกใช้วิธีการดั้งเดิมสี่วิธี มันได้รับการออกแบบอย่างชาญฉลาดและสตริง S ใช้ตัวเลขสองตัวเป็นพารามิเตอร์ Math.Max ใช้ตัวเลขสองตัวเป็นพารามิเตอร์และการค้นหาส่งคืนตัวเลข ความเร็วช้ากว่าสองด้านบนเล็กน้อย แต่เร็วกว่าส่วนใหญ่ด้านล่าง
สิ่งนี้สามารถเรียกได้ว่าเป็นเวอร์ชันที่เรียบง่ายของการใช้งาน 2 ซึ่งคือการใช้ตัวดำเนินการผู้สมัครเพื่อเชื่อมต่อสองกฎ แต่การทำเช่นนั้นจะสูญเสียโอกาสในการเพิ่มประสิทธิภาพเบราว์เซอร์ซึ่งไม่ดีเท่าการรับรู้ 3 เพราะมันดูสง่า
ใช้ 5
การจับคู่ส่งคืนอาร์เรย์ดังนั้นส่วนของสตริงต้นฉบับที่ตรงตามข้อกำหนดจะกลายเป็นองค์ประกอบ เพื่อป้องกันไม่ให้ช่องว่างตรงกลางของสตริงถูกแยกออกเราจำเป็นต้องใช้การจัดกลุ่มที่ไม่ได้จับ (?: exp) เนื่องจากอาร์เรย์อาจว่างเปล่าเราจึงต้องทำการตัดสินเพิ่มเติมในภายหลัง ดูเหมือนว่าเบราว์เซอร์จะอ่อนแอในการจัดกลุ่มการประมวลผลและหนึ่งคำช้า ดังนั้นอย่าเชื่อโชคลางเกี่ยวกับกฎแม้ว่ามันจะมีอำนาจทุกอย่าง
การดำเนินการ 6
ระบุชิ้นส่วนที่ต้องการและใส่ไว้ในสตริงที่ว่างเปล่า แต่ประสิทธิภาพนั้นแย่มากโดยเฉพาะใน IE6
มันคล้ายกับการใช้งาน 6 แต่ใช้แพ็คเก็ตที่ไม่ใช่การจับเพื่อให้ได้เปรียบและประสิทธิภาพการทำงานดีขึ้นเล็กน้อย
การดำเนินการ 8
ฉันปรับปรุงสองแนวคิดข้างต้นใช้การจัดกลุ่มที่ไม่ได้จับและชุดตัวละครและแทนที่ * ด้วย? ซึ่งน่าทึ่งมาก โดยเฉพาะอย่างยิ่งใน IE6 ความบ้าคลั่งสามารถใช้เพื่ออธิบายการปรับปรุงประสิทธิภาพนี้และฆ่า Firefox โดยตรงในไม่กี่วินาที
ใช้ 9
คราวนี้ฉันใช้การจับคู่ขี้เกียจเพื่อแทนที่การจัดกลุ่มที่ไม่ได้จับกุมซึ่งได้รับการปรับปรุงใน Firefox และ IE ไม่ได้บ้าเหมือนครั้งที่แล้ว
ตระหนักถึง 10
ฉันแค่อยากจะบอกว่าคนที่สร้างสิ่งนี้ไม่ได้อธิบายว่าเป็นวัวอีกต่อไป แต่อยู่ในระดับเดียวกับพระเจ้า ก่อนอื่นแสดงรายการช่องว่างที่เป็นไปได้ทั้งหมดตัดช่องว่างด้านหน้าในการเดินทางครั้งแรกและตัดช่องด้านหลังเป็นครั้งที่สอง กระบวนการทั้งหมดใช้เฉพาะ indexof และ s string ซึ่งเป็นวิธีการดั้งเดิมที่ออกแบบมาเป็นพิเศษสำหรับการประมวลผลสตริงและไม่ใช้ความสม่ำเสมอ ความเร็วนั้นเร็วอย่างน่าอัศจรรย์อาจใกล้เคียงกับการใช้งานไบนารีภายในและมีประสิทธิภาพที่ดีใน IE และ Firefox (แน่นอนเบราว์เซอร์อื่น ๆ ไม่ต้องสงสัยเลย) ความเร็วทั้งหมดอยู่ที่ศูนย์มิลลิวินาที
การใช้งาน 10 ได้บอกเราว่าวิธีการสกัดกั้นสตริงดั้งเดิมปกติดีกว่าการแทนที่ปกติแม้ว่ามันจะซับซ้อนกว่าเล็กน้อย แต่ตราบใดที่ความสม่ำเสมอไม่ซับซ้อนเกินไปเราสามารถใช้เบราว์เซอร์เพื่อเพิ่มประสิทธิภาพความสม่ำเสมอเพื่อปรับปรุงประสิทธิภาพการดำเนินการของโปรแกรมเช่นการบรรลุประสิทธิภาพ 8 ประสิทธิภาพใน IE ฉันไม่คิดว่าจะมีใครใช้การใช้งาน 10 ในโครงการเพราะการใช้งานช่องว่างนั้นยาวเกินไปและจำได้ยาก (แน่นอนถ้าคุณกำลังสร้างห้องสมุดชั้นเรียนมันเป็นครั้งแรก) การใช้งาน 11 สามารถกล่าวได้ว่าเป็นเวอร์ชันที่ดีขึ้น ช่องว่างในส่วนแรกจะถูกตัดออกโดยการเปลี่ยนเป็นประจำและการประมวลผลในภายหลังจะทำโดยวิธีการดั้งเดิม เอฟเฟกต์ไม่ด้อยกว่ารุ่นดั้งเดิม แต่ความเร็วนั้นน่าทึ่งมาก
เวอร์ชันการปรับปรุงที่ดีขึ้นของวิธีการเขียนการใช้งาน 10 และการใช้งาน 11 ไม่เกี่ยวกับความเร็วประสิทธิภาพ แต่เกี่ยวกับหน่วยความจำและการใช้งานที่ง่าย และสองรุ่นก่อนอยู่ในระดับศูนย์มิลลิวินาทีดังนั้นฉันจะใช้สิ่งนี้เพื่อทำงานและทำให้ตกใจในอนาคต