JavaScript: วิธีการทำงานกับสตริง วิธีการ 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(สตริงใหม่); // "เธอขายเปลือกหอยที่ชายฝั่งทะเล"
อาร์กิวเมนต์ที่สองอาจมีเทมเพลตหรือฟังก์ชันพิเศษ คุณสามารถอ่านเพิ่มเติมได้
รับอักขระในตำแหน่งที่กำหนดในสตริง
เราสามารถรับสัญลักษณ์โดยใช้ฟังก์ชัน อักขระ():
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
เมื่อฉันเขียนด้วยจาวาสคริปต์ ฉันมักจะต้องอ้างอิงถึง เครื่องมือค้นหาเพื่อชี้แจงไวยากรณ์ของวิธีการ (และลำดับ คำจำกัดความของอาร์กิวเมนต์) ที่ทำงานกับสตริง
ในบทความนี้ฉันจะพยายามยกตัวอย่างและคำอธิบายที่พบบ่อยที่สุด วิธีการจาวาสคริปต์เกี่ยวข้องกับสตริง วิธีการยอดนิยมจะอยู่ที่ด้านบนของบทความเพื่อความสะดวก
แปลงเป็นสตริง
คุณสามารถแปลงตัวเลข บูลีน หรือวัตถุเป็นสตริงได้
เท่ากับ 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 ขึ้นไป
วิธีการแทนที่ส่วนหนึ่งของสตริง
หากต้องการแทนที่บางส่วน (หรือทั้งหมด) ของสตริง ให้ใช้เมธอด แทนที่()
Var slugger = "จอช แฮมิลตัน";
var BetterSlugger = slugger.replace("h Hamilton", "e Bautista");
console.log (ดีกว่า Slugger); // "โฮเซ่ เบาติสต้า"
อาร์กิวเมนต์แรกประกอบด้วยส่วนของสตริงย่อยที่จะถูกแทนที่ อาร์กิวเมนต์ที่สองคือสตริงที่จะเข้ามาแทนที่สตริงย่อยที่จะถูกแทนที่ เฉพาะอินสแตนซ์แรกของสตริงย่อยเท่านั้นที่จะถูกแทนที่
หากต้องการแทนที่สตริงย่อยทั้งหมดที่เกิดขึ้น ให้ใช้นิพจน์ทั่วไปพร้อมกับแฟล็ก "g"
Var myString = "เธอขายปลอกกระสุนรถยนต์บนชายฝั่งยานยนต์";
var newString = myString.replace(/automotive/g, "sea");
console.log(สตริงใหม่); // "เธอขายเปลือกหอยที่ชายฝั่งทะเล"
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 = "สูง"; var stringThree = "ฟุตบอล";
var stringFour = "กฎ";
var FinalString = stringOne.concat (stringTwo, stringThree, stringFour);
console.log(สุดท้ายสตริง); // "Knibb กฎฟุตบอลสูง"
ส่วนหนึ่งของสตริง (แยกสตริงย่อยในจาวาสคริปต์)
มีสาม
วิธีการที่แตกต่างกัน
สร้างสตริงใหม่โดยการ "ดึงออก" ส่วนหนึ่งของสตริงย่อยจากสตริงที่มีอยู่
การใช้ชิ้น() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz";
var stringTwo = stringOne.slice (5, 10); // "ฟกีจ"
Var stringOne = "พูดออกมา ฉันไม่ได้ยินคุณ"; var stringTwo = stringOne.toLocaleUpperCase(); // "พูดออกมา ฉัน"ไม่ได้ยินคุณ" var stringThree = stringOne.toUpperCase(); // "พูดมา ฉันไม่ได้ยินคุณ"
และสองเพื่อแปลงสตริงเป็นตัวพิมพ์เล็ก:
Var stringOne = "คุณไม่จำเป็นต้องตะโกน"; var stringTwo = stringOne.toLocaleLowerCase(); // "คุณไม่จำเป็นต้องตะโกน" var stringThree = stringOne.toLowerCase(); // "เธอไม่ต้องตะโกน"
โดยทั่วไป ไม่มีความแตกต่างระหว่างวิธี locale และวิธีที่ไม่ใช่ locale แต่ "สำหรับบางภาษา เช่น ภาษาตุรกี ซึ่งตัวพิมพ์ของอักขระไม่เป็นไปตามกรณี Unicode ที่จัดตั้งขึ้น ผลที่ตามมาของการใช้วิธีการที่ไม่ใช่ locale อาจเป็นได้ แตกต่าง." ดังนั้น ให้ปฏิบัติตามกฎต่อไปนี้: "ถ้าคุณไม่ทราบภาษาที่จะเรียกใช้โค้ด จะปลอดภัยกว่าหากใช้วิธีการระบุสถานที่"
การจับคู่รูปแบบในจาวาสคริปต์
คุณสามารถตรวจสอบการมีอยู่ของรูปแบบในสตริงได้โดยใช้ 2 วิธี
เมธอด match() ถูกเรียกบนวัตถุสตริง โดยส่งนิพจน์ทั่วไปเป็นอาร์กิวเมนต์ไปยังเมธอด match()
Var myString = "หัวจับไม้สามารถจับไม้ได้มากแค่ไหน";
var myPattern = /.ood/;
var myResult = myString.match(myPattern); // ["ไม้"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "ไม้สามารถดึงหัวจับไม้ได้เท่าไหร่"
และเมธอด exec() ถูกเรียกบนวัตถุ RegExp โดยส่งผ่านสตริงเป็นอาร์กิวเมนต์:
Var myString = "หัวจับไม้สามารถจับไม้ได้มากแค่ไหน";
var myPattern = /.huck/;
var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "ไม้สามารถดึงหัวจับไม้ได้เท่าไหร่"
ทั้งสองวิธีส่งคืนการเกิดขึ้นที่ตรงกันครั้งแรก หากไม่พบรายการที่ตรงกัน ระบบจะคืนค่า NULL หากนิพจน์ทั่วไปมีแฟล็ก "g" ผลลัพธ์จะเป็นอาร์เรย์ที่ตรงกันทั้งหมด
คุณยังสามารถใช้เมธอด search() ซึ่งใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์และส่งกลับตำแหน่งเริ่มต้นของรูปแบบแรกที่ตรงกัน
MyString = "ไก่"; var myStringTwo = "ไข่"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (ยกเว้น Chrome ซึ่งคืนค่า -2) whichCameFirst = myString.localeCompare("chicken"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome ส่งคืน 2)
ดังที่แสดงไว้ข้างต้น ค่าลบจะถูกส่งกลับหากสตริงต้นฉบับถูกเรียงลำดับก่อนอาร์กิวเมนต์สตริง หากอาร์กิวเมนต์สตริงถูกเรียงลำดับหลังสตริงดั้งเดิม +1 จะถูกส่งกลับ หากส่งคืนค่า null แสดงว่าทั้งสองสตริงมีค่าเท่ากัน
ฉันจะเตือนคุณทันที ใช่ บทความนี้มีข้อผิดพลาดเล็กน้อย ยินดีรับความคิดเห็น มีคำชี้แจงที่ดีอยู่ที่นั่น)
ขอให้เป็นวันที่ดี
มีโอเปอเรเตอร์ที่คล้ายกันสองตัวใน 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 - มันมีค่าเท่ากับมัน แต่ไม่เหมือนกัน (เนื่องจากทั้งสองอย่างนี้สมบูรณ์ วัตถุที่แตกต่างกันหมายเลขชั้นเรียน)
อาร์เรย์/วัตถุ
แต่สำหรับอาร์เรย์และอ็อบเจ็กต์ ตัวดำเนินการทั้งสองทำงานในลักษณะเดียวกัน โดยเปรียบเทียบเอกลักษณ์:วาร์ ก = (); ก == (); // เท็จ === (); // เท็จ == ก; // จริง === ก; // จริง
เพื่อเปรียบเทียบอาร์เรย์และวัตถุ คุณสามารถเขียนฟังก์ชันพิเศษ:
ฟังก์ชั่น 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 |
ไม่เท่ากัน (!=) | คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากัน หากตัวถูกดำเนินการมีประเภทต่างกัน JavaScript จะแปลง |
วาร์1 != 4 |
เท่าเทียมกันอย่างเคร่งครัด (===) | คืนค่าเป็นจริงหากตัวถูกดำเนินการเท่ากันอย่างเคร่งครัด (ดูด้านบน) โดยไม่มีการแปลงประเภท | |
ไม่เท่ากันอย่างเคร่งครัด (!==) | คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากันอย่างเคร่งครัด (ดูด้านบน) หรือมีประเภทต่างกัน |
var2 !== 3 |
เพิ่มเติม (>) | คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าตัวถูกดำเนินการทางขวา | |
มากกว่าหรือเท่ากับ (>=) | คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการทางขวา |
var2 >= var1 |
น้อย (<) | คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าตัวถูกดำเนินการทางขวา | |
น้อยกว่าหรือเท่ากับ (<=) | คืนค่าเป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการทางขวา |
var1<= var2 |
การใช้ตัวดำเนินการเปรียบเทียบ
ตัวดำเนินการความเสมอภาคมาตรฐาน (== และ !=) จะเปรียบเทียบตัวถูกดำเนินการสองตัวโดยไม่คำนึงถึงประเภท ความเสมอภาคที่เข้มงวด (=== และ !==) เปรียบเทียบตัวถูกดำเนินการที่เป็นประเภทเดียวกัน ใช้ความเสมอภาคที่เข้มงวดหากตัวถูกดำเนินการต้องมีประเภทและค่าเดียวกัน มิฉะนั้น ให้ใช้ตัวดำเนินการความเสมอภาคปกติ ซึ่งจะช่วยให้คุณสามารถทดสอบความเท่าเทียมกันของตัวถูกดำเนินการได้ แม้ว่าจะอยู่ในประเภทที่แตกต่างกันก็ตาม
เมื่อแปลงประเภท JavaScript จะแปลง String , Number , Boolean และ Object ดังนี้:
- เมื่อเปรียบเทียบตัวเลขและสตริง สตริงจะถูกแปลงเป็นค่าตัวเลข ในกรณีนี้ JavaScript รับค่าตัวเลขจากตัวอักษรสตริง: "123" == 123
- หากตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นบูลีน ก็จะถูกแปลงเป็น 1 หากเป็นจริง และ +0 หากเป็นเท็จ
- หากเปรียบเทียบวัตถุกับตัวเลขหรือสตริง JavaScript จะพยายามรับค่าที่สอดคล้องกันสำหรับวัตถุนั้น โดยจะแปลงวัตถุให้เป็นค่าดั้งเดิม สตริง หรือตัวเลขโดยใช้เมธอด valueOf และ toString หากไม่สามารถแปลงออบเจ็กต์ได้ ข้อผิดพลาดรันไทม์จะถูกสร้างขึ้น