Javascript เปรียบเทียบสองสตริง วิธีการ JavaScript สำหรับการทำงานกับสตริง รับอักขระในตำแหน่งที่กำหนดในสตริง

เมื่อคุณเขียน จาวาสคริปต์บ่อยครั้งที่คุณต้องท่องอินเทอร์เน็ตเพื่อค้นหาข้อมูลเกี่ยวกับไวยากรณ์และพารามิเตอร์สำหรับวิธีการที่ทำงานกับสตริง

ฉันได้อ่านบทความมากมายเกี่ยวกับการทำงานกับสตริง โพสต์นี้จะแสดงตัวอย่างและคำอธิบายโดยย่อเกี่ยวกับวิธีการทั่วไปในการทำงานกับสตริง ฉันได้พยายามใส่วิธีการทั่วไปไว้ที่ด้านบนเพื่อการอ้างอิงอย่างรวดเร็ว

แน่นอนว่านักพัฒนาที่มีประสบการณ์ส่วนใหญ่จะคุ้นเคยกับเทคนิคต่างๆ อยู่แล้ว แต่ฉันคิดว่านี่เป็นรายการที่ดีสำหรับผู้เริ่มต้นที่จะเข้าใจเทคนิคต่างๆ ที่สามารถช่วยดำเนินการที่ซับซ้อนด้วยวิธีง่ายๆ ได้สำเร็จ

การแปลงเป็นสตริง

คุณสามารถแปลงตัวเลข นิพจน์บูลีน หรือวัตถุเป็นสตริงได้:

เท่ากับ myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

คุณสามารถทำได้เช่นเดียวกันกับ สตริง():

เท่ากับ myNumber = 24; // 24 var myString = String(myNumber); // "24"

หากไม่แน่ใจว่ามีค่าอะไร โมฆะหรือ ไม่ได้กำหนดคุณสามารถใช้ สตริง()ซึ่งจะส่งคืนสตริงเสมอ ไม่ว่าค่าจะเป็นประเภทใดก็ตาม

การแยกสตริงออกเป็นสตริงย่อย

หากต้องการแยกสตริงออกเป็นอาร์เรย์ของสตริงย่อยคุณสามารถใช้วิธีนี้ได้ แยก():

Var myString = "มา,แยกจากกัน,ที่,ลูกน้ำ"; var substringArray = myString.split(","); // ["กำลังมา", "แยกจากกัน", "ที่", "ที่", "เครื่องหมายจุลภาค"] var arrayLimited = myString.split(",", 3); // ["มา", "แยกจากกัน", "ที่"]

ดังที่คุณเห็นในบรรทัดสุดท้าย พารามิเตอร์ตัวที่สองของฟังก์ชันคือขีดจำกัดจำนวนองค์ประกอบที่จะอยู่ในอาร์เรย์สุดท้าย

รับความยาวของสตริง

หากต้องการค้นหาจำนวนอักขระในสตริง เราใช้คุณสมบัติ ความยาว:

Var myString = "คุณค่อนข้างเป็นตัวละคร"; var stringLength = myString.length; // 25

ค้นหาสตริงย่อยในสตริง

มีสองวิธีในการค้นหาสตริงย่อย:

การใช้งาน ดัชนีของ():

Var stringOne = "จอห์นนี่ วัลโด แฮร์ริสัน วัลโด"; var โดยที่ Waldo = stringOne.indexOf("Waldo"); // 7

ดัชนีของ()วิธีการนี้จะเริ่มค้นหาสตริงย่อยจากจุดเริ่มต้นของสตริง และส่งกลับตำแหน่งของจุดเริ่มต้นของสตริงย่อยที่เกิดขึ้นครั้งแรก ในกรณีนี้ - ตำแหน่งที่ 7

การใช้งาน LastIndexOf():

Var stringOne = "จอห์นนี่ วัลโด แฮร์ริสัน วัลโด"; var โดยที่ Waldo = stringOne.lastIndexOf("Waldo"); // 22

วิธีการส่งกลับตำแหน่งเริ่มต้นของการเกิดขึ้นครั้งล่าสุดของสตริงย่อยในสตริง

ทั้งสองวิธีส่งคืน -1 หากไม่พบสตริงย่อย และทั้งสองวิธีใช้อาร์กิวเมนต์ตัวที่สองที่เป็นทางเลือกซึ่งระบุตำแหน่งในสตริงที่คุณต้องการให้เริ่มการค้นหา ดังนั้นหากอาร์กิวเมนต์ที่สองคือ "5" ดัชนีของ()เริ่มค้นหาจากตัวอักษร 5 โดยไม่สนใจตัวอักษร 0-4 ในขณะที่ LastIndexOf()เริ่มการค้นหาที่อักขระ 5 และทำงานย้อนกลับ โดยไม่สนใจอักขระ 6 และหลังจากนั้น

การแทนที่สตริงย่อย

หากต้องการแทนที่สตริงย่อยในสตริงด้วยสตริงย่อยอื่น คุณสามารถใช้ แทนที่():

Var slugger = "จอช แฮมิลตัน"; var BetterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log (ดีกว่า Slugger); // "โฮเซ่ เบาติสต้า"

อาร์กิวเมนต์แรกคือสิ่งที่คุณต้องการแทนที่ และอาร์กิวเมนต์ที่สองคือการขึ้นบรรทัดใหม่ ฟังก์ชันนี้จะแทนที่เฉพาะสตริงย่อยที่เกิดขึ้นครั้งแรกในสตริงเท่านั้น

หากต้องการแทนที่เหตุการณ์ทั้งหมด คุณต้องใช้นิพจน์ทั่วไปที่มีธงโกลบอล:

Var myString = "เธอขายปลอกกระสุนรถยนต์บนชายฝั่งยานยนต์"; var newString = myString.replace(/automotive/g, "sea"); console.log(newString); // "เธอขายเปลือกหอยที่ชายฝั่งทะเล"

อาร์กิวเมนต์ที่สองอาจมีเทมเพลตหรือฟังก์ชันพิเศษ คุณสามารถอ่านเพิ่มเติมได้

รับอักขระในตำแหน่งที่กำหนดในสตริง

เราสามารถรับสัญลักษณ์โดยใช้ฟังก์ชัน อักขระ():

Var myString = "นกแห่งขนนก"; var whatsAtSeven = myString.charAt(7); // "ฉ"

ตามปกติในกรณีของ JavaScript ตำแหน่งแรกในสตริงเริ่มต้นที่ 0 ไม่ใช่ 1

เป็นฟังก์ชันทางเลือกที่คุณสามารถใช้ได้ ถ่านรหัสAt()ฟังก์ชั่นซึ่งเป็นรหัสอักขระ

Var myString = "นกแห่งขนนก"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

โปรดทราบว่ารหัสสำหรับอักขระ "F" (ตำแหน่ง 11) แตกต่างจากอักขระ "f" (ตำแหน่ง 7)

การต่อสายอักขระ

ในกรณีส่วนใหญ่ คุณสามารถใช้ตัวดำเนินการ "+" เพื่อเชื่อมสตริงเข้าด้วยกัน แต่คุณสามารถใช้วิธีนี้ได้เช่นกัน เชื่อมต่อ():

Var stringOne = "Knibb High football"; var stringTwo = stringOne.concat("กฎ"); // "กฎฟุตบอล Knibb High"

ด้วยวิธีนี้เราสามารถรวมหลายบรรทัดเป็นบรรทัดเดียวตามลำดับที่เขียน:

Var stringOne = "Knibb"; var stringTwo = "สูง"; var stringThree = "ฟุตบอล"; var stringFour = "กฎ"; var FinalString = stringOne.concat (stringTwo, stringThree, stringFour); console.log(สุดท้ายสตริง); // "Knibb กฎฟุตบอลสูง"

การสกัดสตริงย่อย

มี 3 วิธีในการรับสตริงจากส่วนหนึ่งของสตริงอื่น:

โดยใช้ ชิ้น():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice (5, 10); // "ฟกิจ"

โดยใช้ สตริงย่อย ():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring (5, 10); // "ฟกีจ"

ในทั้งสองฟังก์ชัน พารามิเตอร์ตัวแรกคืออักขระที่สตริงย่อยเริ่มต้น (เริ่มจากตำแหน่ง 0) และอาร์กิวเมนต์ตัวที่สอง (เป็นทางเลือก) คือตำแหน่งของอักขระที่สตริงย่อยถูกส่งกลับ ตัวอย่าง (5, 10) ส่งคืนสตริงระหว่างตำแหน่ง 5 และ 9

โดยใช้ ซับสเตร():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr (5, 10); // "fghijklmno"

อาร์กิวเมนต์แรกคือตำแหน่งของอักขระที่ขึ้นบรรทัดใหม่ และอาร์กิวเมนต์ที่สองคือจำนวนอักขระจากตำแหน่งเริ่มต้นของบรรทัดใหม่ เหล่านั้น. (5, 10) ส่งคืนอักขระ 10 ตัว โดยเริ่มต้นที่ตำแหน่ง 5

แปลงสตริงเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก

การแปลมี 4 วิธี 2 ตัวแรกแปลงสตริงเป็นตัวพิมพ์ใหญ่:

Var stringOne = "พูดออกมา ฉันไม่ได้ยินคุณ"; var stringTwo = stringOne.toLocaleUpperCase(); // "พูดออกมา ฉัน"ไม่ได้ยินคุณ" var stringThree = stringOne.toUpperCase(); // "พูดมา ฉันไม่ได้ยินคุณ"

อีก 2 แปลงสตริงเป็นตัวพิมพ์เล็ก:

Var stringOne = "คุณไม่จำเป็นต้องตะโกน"; var stringTwo = stringOne.toLocaleLowerCase(); // "คุณไม่จำเป็นต้องตะโกน" var stringThree = stringOne.toLowerCase(); // "เธอไม่ต้องตะโกน"

ควรใช้วิธี "locale" เพราะ... ในสถานที่ต่าง ๆ เช่นในตุรกี การแสดงรีจิสเตอร์ไม่ทำงานอย่างที่เราคุ้นเคย ดังนั้นผลลัพธ์จึงอาจเป็นผลลัพธ์ที่เราต้องการ หากคุณใช้วิธี "สถานที่" ก็จะไม่มีปัญหาดังกล่าว

การจับคู่รูปแบบ

การจับคู่รูปแบบบนสตริงสามารถทำได้โดยใช้ 2 วิธี ซึ่งทำงานต่างกัน

วิธี จับคู่()ถูกนำไปใช้กับสตริงและใช้นิพจน์ทั่วไปเป็นพารามิเตอร์:

Var myString = "หัวจับไม้สามารถจับไม้ได้มากแค่ไหน"; var myPattern = /.ood/; var myResult = myString.match(myPattern); // ["ไม้"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "ไม้สามารถดึงหัวจับไม้ได้เท่าไหร่"

วิธี ผู้บริหาร()ใช้กับวัตถุนิพจน์ทั่วไปและรับสตริงเป็นพารามิเตอร์:

Var myString = "หัวจับไม้สามารถจับไม้ได้มากแค่ไหน"; var myPattern = /.huck/; var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "ไม้สามารถดึงหัวจับไม้ได้เท่าไหร่"

ในทั้งสองวิธี ระบบจะส่งคืนเฉพาะรายการที่ตรงกันรายการแรกเท่านั้น หากไม่มีการแข่งขันก็จะส่งคืน โมฆะ.

คุณยังสามารถใช้วิธีนี้ได้ ค้นหา()ซึ่งใช้นิพจน์ทั่วไปและส่งกลับตำแหน่งของรายการที่ตรงกันแรกในรูปแบบ:

Var myString = "สมมติ"; var patternLocation = myString.search(/ume/); // 3

หากไม่มีการแข่งขัน” -1 «.

การเปรียบเทียบสองสายสำหรับการเรียงลำดับ

คุณสามารถเปรียบเทียบ 2 สายเพื่อพิจารณาว่าข้อความใดเกิดก่อนตัวอักษร เมื่อต้องการทำเช่นนี้ เราจะใช้วิธีนี้ สถานที่เปรียบเทียบ()ซึ่งส่งคืนค่าที่เป็นไปได้ 3 ค่า:

Var myString = "ไก่"; var myStringTwo = "ไข่"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (Chrome ส่งคืน -2) whichCameFirst = myString.localeCompare("chicken"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome ส่งคืน 2)

ดังที่แสดงไว้ด้านบน จำนวนลบจะถูกส่งกลับหากอาร์กิวเมนต์สตริงอยู่หลังสตริงเดิม จำนวนบวกถ้าอาร์กิวเมนต์สตริงมาก่อนสตริงเดิม ถ้ากลับ 0 - หมายถึงเส้นเท่ากัน

หากต้องการตรวจสอบค่าที่ส่งคืน ควรใช้ if (result< 0), чем if (result === -1). Последнее не будет работать в Chrome.

ขอบคุณสำหรับความสนใจของคุณ ฉันหวังว่าคุณจะได้เรียนรู้สิ่งใหม่และน่าสนใจมากมาย!

ผู้เขียนบทความ: อเล็กซ์ หมวดหมู่:
วันที่เผยแพร่: 03/19/2013

ฉันจะเตือนคุณทันที ใช่ บทความนี้มีข้อผิดพลาดเล็กน้อย ยินดีรับความคิดเห็น มีคำชี้แจงที่ดีอยู่ที่นั่น)

ขอให้เป็นวันที่ดี

มีโอเปอเรเตอร์ที่คล้ายกันสองตัวใน JavaScript: == และ === หากคุณไม่ทราบความแตกต่าง อาจส่งผลให้เกิดข้อผิดพลาดมากมาย ฉันจึงตัดสินใจเปิดกระทู้นี้ อะไรคือความแตกต่างระหว่าง == และ === วิธีการทำงาน เหตุใดจึงเกิดเหตุการณ์เช่นนี้ และวิธีหลีกเลี่ยงข้อผิดพลาด

ตัวดำเนินการ == เปรียบเทียบเพื่อความเท่าเทียมกัน แต่ === เปรียบเทียบเอกลักษณ์ ข้อดีของตัวดำเนินการ === คือ มันไม่ได้แปลงค่าสองค่าให้เป็นประเภทเดียวกัน ด้วยเหตุนี้จึงมีการใช้กันทั่วไป

เอบีซี == ไม่ได้กำหนด; // จริงถ้า abc = ไม่ได้กำหนด | null abc === ไม่ได้กำหนด; // จริง - เฉพาะในกรณีที่ abc = ไม่ได้กำหนด!
เอบีซี == เท็จ; // จริงถ้า abc = false | 0 | - เอบีซี === เท็จ; // จริงก็ต่อเมื่อ abc = false!
ท้ายที่สุดแล้ว การสร้างความสับสนให้กับ false และ 0 (หรือ "" หรือ ) ไม่ใช่ความคิดที่ดีเลย

แน่นอน:
5 === 5; // จริง จริง === จริง; // จริง "abc" === "abc"; // จริง

และตอนนี้เป็นตัวอย่างที่น่าสนใจ
5 == 5; // จริง 5 === 5; // หมายเลขใหม่จริง (5) == 5; // หมายเลขใหม่จริง (5) === 5; // เท็จ!

ทำไมสิ่งนี้ถึงเกิดขึ้น? ใช่ ตัวเลขใดๆ ก็ตามถือเป็นอ็อบเจ็กต์ของคลาส Number แต่คุณสามารถแสดงตัวเลขเป็นตัวเลขได้ - ด้วยค่าคงที่บางค่า มีการประกาศครั้งเดียวและจะเหมือนกันกับตัวมันเองเสมอ แต่ในขณะเดียวกันเมื่อประกาศวัตถุใหม่ของคลาส Number มันจะมีค่าเท่ากับวัตถุนั้น แต่ไม่เหมือนกัน (เนื่องจากสิ่งเหล่านี้เป็นวัตถุสองชิ้นที่แตกต่างกันอย่างสิ้นเชิงของคลาส Number)

อาร์เรย์/วัตถุ

แต่สำหรับอาร์เรย์และอ็อบเจ็กต์ ตัวดำเนินการทั้งสองทำงานในลักษณะเดียวกัน โดยเปรียบเทียบเอกลักษณ์:
วาร์ ก = (); ก == (); // เท็จ === (); // เท็จ == ก; // จริง === ก; // จริง

เพื่อเปรียบเทียบอาร์เรย์และวัตถุ คุณสามารถเขียนฟังก์ชันพิเศษ:
ฟังก์ชั่น isEq(a, b)( if(a == b) return true; for(var i in a)( if(!isEq(a[i], b[i])) return false; ) for(var i ใน b)( if(!isEq(a[i], b[i])) return false; ) return true )
เลอะเทอะเล็กน้อย สองรอบ และประมาณ มีทรัพย์สินของตัวเองลืม; นั่นจะทำ

นี้<-

มีข้อผิดพลาดอีกอย่างหนึ่ง นี่คือการโอนไปยังสิ่งนี้
(function())( this == 5; // true this === 5; // false )).call(5);

นี่คือช่วงเวลา มันไม่คุ้มค่าที่จะลืมเขา

ทั้งหมด...

ทีนี้ ลองจินตนาการว่าเรากำลังเขียน superframework ของเราเอง โดยใช้โอเปอเรเตอร์ === แทน == เพียงเพราะมันสวยกว่า และมีคนพบข้อบกพร่องหลายอย่างกับเรา
func(หมายเลขใหม่(5)); (ฟังก์ชั่น())( func(นี้); )).โทร(5);

ตัวอย่างดังกล่าวดูเหมือนเป็นไปไม่ได้หรือไม่? โปรด!

เจคิวรี:
$.each(, function())( func(นี้); ));

หรือฉันต้องการขยายจำนวน
var Five = หมายเลขใหม่ (5); ห้า.a = 2; // ต้องการขยาย แต่ 5 ก็ไม่ขยาย // ที่นี่เราใช้มันด้วยวิธีใดวิธีหนึ่ง... func(Five);

เพียงเท่านี้ฉันหวังว่ามันจะเป็นประโยชน์กับใครบางคน ขอบคุณสำหรับความสนใจของคุณ

ตัวถูกดำเนินการของตัวดำเนินการเปรียบเทียบอาจเป็นค่าตัวเลขหรือสตริงก็ได้ สตริงจะถูกเปรียบเทียบตามลำดับพจนานุกรมมาตรฐานเมื่อใช้ Unicode

JavaScript อนุญาตทั้งการเปรียบเทียบที่เข้มงวดและการเปรียบเทียบกับการคัดเลือกประเภท เพื่อการเปรียบเทียบที่เข้มงวด ตัวถูกดำเนินการทั้งสองต้องเป็นประเภทเดียวกันและ:

สองสตริงจะเท่ากันอย่างเคร่งครัดหากมีลำดับอักขระที่เหมือนกัน
ตัวเลขสองตัวจะเท่ากันอย่างเคร่งครัดหากพวกมันเท่ากันในความหมายปกติของคำ +0 เท่ากับ -0 อย่างเคร่งครัด
NaN ไม่เท่ากับสิ่งใดๆ ทั้งสิ้น รวมถึง NaN ด้วย
ตัวถูกดำเนินการบูลีนสองตัวจะเท่ากันอย่างเคร่งครัดหากเป็นจริงหรือเท็จทั้งคู่
ตัวถูกดำเนินการวัตถุสองตัวจะเท่ากันอย่างเคร่งครัดหากอ้างอิงถึงวัตถุทั่วไปเดียวกัน
Null และ Undefault เท่ากัน == แต่ไม่เท่ากันอย่างเคร่งครัด ===

ตารางต่อไปนี้อธิบายตัวดำเนินการเปรียบเทียบ:

ผู้ดำเนินการ	คำอธิบาย	ตัวอย่างที่คืนค่าเป็นจริงเมื่อ var1=3, var2=4
เท่ากับ (==)	หากตัวถูกดำเนินการสองตัวไม่ใช่ประเภทเดียวกัน javascript จะแปลงประเภทและเปรียบเทียบอย่างเคร่งครัด หากตัวถูกดำเนินการใดๆ เป็นตัวเลขหรือค่าบูลีน ตัวถูกดำเนินการจะถูกแปลงเป็นตัวเลข ถ้าตัวถูกดำเนินการใดๆ เป็นสตริง ตัวที่สองจะถูกแปลงเป็นสตริง	3 == var1 "3" == var1 3 == "3"
ไม่เท่ากัน (!=)	คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากัน หากตัวถูกดำเนินการมีประเภทต่างกัน JavaScript จะแปลง	วาร์1 != 4 var1 != "5"
เท่าเทียมกันอย่างเคร่งครัด (===)	คืนค่าเป็นจริงหากตัวถูกดำเนินการเท่ากันอย่างเคร่งครัด (ดูด้านบน) โดยไม่มีการแปลงประเภท
ไม่เท่ากันอย่างเคร่งครัด (!==)	คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากันอย่างเคร่งครัด (ดูด้านบน) หรือมีประเภทต่างกัน	var2 !== 3 3 !== "3"
เพิ่มเติม (>)	คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าตัวถูกดำเนินการทางขวา
มากกว่าหรือเท่ากับ (>=)	คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการทางขวา	var2 >= var1 var1 >= 3
น้อย (<)	คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าตัวถูกดำเนินการทางขวา
น้อยกว่าหรือเท่ากับ (<=)	คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการทางขวา	var1<= var2 var2<= 5

การใช้ตัวดำเนินการเปรียบเทียบ

ตัวดำเนินการความเท่าเทียมกันมาตรฐาน (== และ !=) จะเปรียบเทียบตัวถูกดำเนินการสองตัวโดยไม่คำนึงถึงประเภท ความเสมอภาคที่เข้มงวด (=== และ !==) เปรียบเทียบตัวถูกดำเนินการที่เป็นประเภทเดียวกัน ใช้ความเสมอภาคที่เข้มงวดหากตัวถูกดำเนินการต้องมีประเภทและค่าเดียวกัน มิฉะนั้น ให้ใช้ตัวดำเนินการความเสมอภาคปกติ ซึ่งจะช่วยให้คุณสามารถทดสอบความเท่าเทียมกันของตัวถูกดำเนินการได้ แม้ว่าจะอยู่ในประเภทที่แตกต่างกันก็ตาม

เมื่อแปลงประเภท JavaScript จะแปลง String , Number , Boolean และ Object ดังนี้:

เมื่อเปรียบเทียบตัวเลขและสตริง สตริงจะถูกแปลงเป็นค่าตัวเลข ในกรณีนี้ JavaScript รับค่าตัวเลขจากตัวอักษรสตริง: "123" == 123
หากตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นบูลีน ก็จะถูกแปลงเป็น 1 หากเป็นจริง และ +0 หากเป็นเท็จ
หากเปรียบเทียบวัตถุกับตัวเลขหรือสตริง JavaScript จะพยายามรับค่าที่สอดคล้องกันสำหรับวัตถุ โดยจะแปลงวัตถุให้เป็นค่าพื้นฐาน สตริง หรือตัวเลขโดยใช้เมธอด valueOf และ toString หากไม่สามารถแปลงออบเจ็กต์ได้ ข้อผิดพลาดรันไทม์จะถูกสร้างขึ้น

เมื่อฉันเขียนด้วยจาวาสคริปต์ ฉันมักจะต้องหันไปหาเครื่องมือค้นหาเพื่อชี้แจงไวยากรณ์ของวิธีการ (และลำดับ คำจำกัดความของอาร์กิวเมนต์) ที่ทำงานกับสตริง

ในบทความนี้ ฉันจะพยายามยกตัวอย่างและคำอธิบายของวิธีการจาวาสคริปต์ที่พบบ่อยที่สุดที่เกี่ยวข้องกับสตริง วิธีการยอดนิยมจะอยู่ที่ด้านบนของบทความเพื่อความสะดวก

แปลงเป็นสตริง

คุณสามารถแปลงตัวเลข บูลีน หรือวัตถุเป็นสตริงได้

เท่ากับ myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

คุณยังสามารถดำเนินการจัดการที่คล้ายกันได้โดยใช้ฟังก์ชัน string()

เท่ากับ myNumber = 24; // 24 var myString = String(myNumber); // "24"

Nicholas Zakas กล่าวว่า: "หากคุณไม่แน่ใจเกี่ยวกับค่า (null หรือไม่ได้กำหนด) ให้ใช้ฟังก์ชัน String() เนื่องจากฟังก์ชันจะส่งกลับสตริงโดยไม่คำนึงถึงประเภทของตัวแปร"

ไม่ได้กำหนดหมายความว่าตัวแปรไม่ได้กำหนดค่าใด ๆ ก โมฆะ, - มันถูกกำหนดค่าว่าง (เราสามารถพูดได้ว่า null ถูกกำหนดให้เป็นวัตถุว่าง)

แยกสตริงออกเป็นสตริงย่อย

หากต้องการแยกสตริงออกเป็นอาร์เรย์ของสตริงย่อยคุณสามารถใช้ split() วิธีการ:

Var myString = "มา,แยกจากกัน,ที่,ลูกน้ำ";

var substringArray = myString.split(","); // ["กำลังมา", "แยกจากกัน", "ที่", "ที่", "เครื่องหมายจุลภาค"] var arrayLimited = myString.split(",", 3); // ["มา", "แยกจากกัน", "ที่"]

ตามที่บรรทัดสุดท้ายแนะนำ ค่าของอาร์กิวเมนต์ทางเลือกตัวที่สองจะกำหนดจำนวนองค์ประกอบในอาร์เรย์ที่ส่งคืน

รับความยาวสตริง

การใช้คุณสมบัติ length คุณสามารถค้นหาจำนวนอักขระ Unicode ในสตริงได้:

Var myString = "คุณค่อนข้างเป็นตัวละคร"; var stringLength = myString.length; // 25

กำหนดสตริงย่อยในสตริง

มีสองวิธีในการบรรลุแผนของคุณ:

ใช้ indexOf() :

Var stringOne = "จอห์นนี่ วัลโด แฮร์ริสัน วัลโด";

var โดยที่ Waldo = stringOne.indexOf("Waldo"); // 7

เมธอด indexOf() ค้นหาสตริงย่อย (อาร์กิวเมนต์แรกที่ส่งผ่าน) ในสตริง (จากจุดเริ่มต้นของสตริง) และส่งกลับตำแหน่งของอักขระตัวแรกที่สตริงย่อยเริ่มปรากฏในสตริง

ใช้ LastIndexOf() :

Var stringOne = "จอห์นนี่ วัลโด แฮร์ริสัน วัลโด";

var โดยที่ Waldo = stringOne.lastIndexOf("Waldo"); // 22

เมธอด LastIndexOf() ทำทุกอย่างเหมือนกัน ยกเว้นว่าจะค้นหาสตริงย่อยสุดท้ายที่เกิดขึ้นในสตริง

หากไม่พบสตริงย่อย ทั้งสองวิธีจะส่งกลับ -1 อาร์กิวเมนต์ทางเลือกที่สองระบุตำแหน่งในสตริงที่คุณต้องการเริ่มการค้นหา ดังนั้น หากอาร์กิวเมนต์ที่สองของเมธอด indexOf() คือ 5 การค้นหาจะเริ่มจากอักขระตัวที่ 5 และอักขระ 0-4 จะถูกละเว้น สำหรับ LastIndexOf() หากอาร์กิวเมนต์ที่สองคือ 5 การค้นหาจะเริ่มในทิศทางตรงกันข้าม โดยไม่สนใจอักขระที่ 6 ขึ้นไป

อาร์กิวเมนต์แรกประกอบด้วยส่วนของสตริงย่อยที่จะถูกแทนที่ อาร์กิวเมนต์ที่สองคือสตริงที่จะเข้ามาแทนที่สตริงย่อยที่จะถูกแทนที่ เฉพาะอินสแตนซ์แรกของสตริงย่อยเท่านั้นที่จะถูกแทนที่

หากต้องการแทนที่สตริงย่อยทั้งหมดที่เกิดขึ้น ให้ใช้นิพจน์ทั่วไปพร้อมกับแฟล็ก "g"

Var myString = "เธอขายปลอกกระสุนรถยนต์บนชายฝั่งยานยนต์";

var newString = myString.replace(/automotive/g, "sea");

console.log(newString); // "เธอขายเปลือกหอยที่ชายฝั่งทะเล"

อาร์กิวเมนต์ที่สองอาจรวมถึงสตริงย่อยหรือฟังก์ชันที่จะแทนที่

ค้นหาตัวละครในตำแหน่งที่กำหนด

หากต้องการทราบว่าอักขระตัวใดอยู่ในตำแหน่งที่กำหนด คุณสามารถใช้เมธอด charAt() ได้ ดังนี้

Var myString = "นกแห่งขนนก";

var whatsAtSeven = myString.charAt(7); // "ฉ"

เช่นเดียวกับในกรณีของ javascript ตำแหน่งแรกเริ่มจาก 0 ไม่ใช่ 1

หรือคุณสามารถใช้เมธอด charCodeAt() ได้ แต่คุณจะได้รับโค้ดแทนตัวอักขระ

Var myString = "นกแห่งขนนก";

var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

โปรดทราบว่ารหัสสำหรับอักษรตัวพิมพ์ใหญ่ (ตำแหน่ง 11) จะแตกต่างจากรหัสสำหรับตัวอักษรเดียวกันแต่จะเป็นตัวพิมพ์เล็ก (ตำแหน่ง 7)

การต่อสตริงในจาวาสคริปต์

โดยส่วนใหญ่ คุณจะใช้ตัวดำเนินการ (+) เพื่อเชื่อมสตริงเข้าด้วยกัน แต่คุณยังสามารถต่อสตริงเข้าด้วยกันโดยใช้เมธอด concat()

Var stringOne = "Knibb High football";

var stringTwo = stringOne.concat("กฎ"); // "กฎฟุตบอล Knibb High"

สามารถส่งสตริงหลายรายการไปยัง concat() และสตริงผลลัพธ์จะปรากฏตามลำดับที่เพิ่มลงในเมธอด concat()

Var stringOne = "Knibb";

var stringTwo = "สูง";

สำหรับทั้งเมธอด (slice() และ substring()) อาร์กิวเมนต์แรกคือตำแหน่งของอักขระที่สตริงย่อยเริ่มต้น (นับจาก 0) อาร์กิวเมนต์ที่สองคือตำแหน่งของอักขระที่สตริงย่อยสิ้นสุด และ อักขระที่กำหนดในอาร์กิวเมนต์ที่สองไม่รวมอยู่ในสตริงย่อยที่ส่งคืน

ใช้ substr() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz";

var stringTwo = stringOne.substr (5, 10); // "fghijklmno"

สำหรับเมธอด substr อาร์กิวเมนต์แรกยังระบุตำแหน่งของอักขระที่สตริงย่อยเริ่มต้นด้วย อาร์กิวเมนต์ที่สองเป็นทางเลือก แต่ในขณะเดียวกัน อาร์กิวเมนต์ที่สองระบุจำนวนอักขระที่ควรรวมไว้ในสตริงย่อย โดยเริ่มจากตำแหน่งที่เรากำหนดไว้ในอาร์กิวเมนต์แรกแล้ว เทคนิคนี้แสดงไว้อย่างดีในตัวอย่างด้านบน

การแปลงสตริงเป็นตัวพิมพ์เล็กหรือใหญ่ในจาวาสคริปต์

มีสี่วิธีในการแปลงที่จำเป็น สองเพื่อแปลงอักขระสตริงเป็นตัวพิมพ์ใหญ่

และสองเพื่อแปลงสตริงเป็นตัวพิมพ์เล็ก:

โดยทั่วไป ไม่มีความแตกต่างระหว่างวิธี locale และวิธีที่ไม่ใช่ locale อย่างไรก็ตาม "สำหรับบางภาษา เช่น ภาษาตุรกี ซึ่งตัวพิมพ์ของอักขระไม่เป็นไปตามกรณี Unicode ที่กำหนดไว้ ผลที่ตามมาของการใช้วิธีการที่ไม่ใช่ locale อาจ จะแตกต่าง" ดังนั้น ให้ปฏิบัติตามกฎต่อไปนี้: "ถ้าคุณไม่ทราบภาษาที่จะเรียกใช้โค้ด จะปลอดภัยกว่าหากใช้วิธีการระบุสถานที่"

การจับคู่รูปแบบในจาวาสคริปต์

คุณสามารถตรวจสอบการมีอยู่ของรูปแบบในสตริงได้โดยใช้ 2 วิธี

เมธอด match() ถูกเรียกบนวัตถุสตริง โดยส่งนิพจน์ทั่วไปเป็นอาร์กิวเมนต์ไปยังเมธอด match()

Var myString = "หัวจับไม้สามารถจับไม้ได้มากแค่ไหน";

var myPattern = /.huck/;

var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "ไม้สามารถดึงหัวจับไม้ได้เท่าไหร่"

ทั้งสองวิธีส่งคืนการเกิดขึ้นครั้งแรกที่ตรงกัน หากไม่พบรายการที่ตรงกัน ระบบจะคืนค่า NULL หากนิพจน์ทั่วไปมีแฟล็ก "g" ผลลัพธ์จะเป็นอาร์เรย์ที่ตรงกันทั้งหมด

คุณยังสามารถใช้เมธอด search() ซึ่งใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์และส่งกลับตำแหน่งเริ่มต้นของรูปแบบแรกที่ตรงกัน