JavaScript: วิธีการทำงานกับสตริง งานเกี่ยวกับฟังก์ชันสำหรับการทำงานกับสตริงในฟังก์ชัน JavaScript Jquery สำหรับการทำงานกับสตริง
สตริงคือลำดับของอักขระตั้งแต่หนึ่งตัวขึ้นไปที่สามารถประกอบด้วยตัวอักษร ตัวเลข และสัญลักษณ์อื่นๆ ใน JavaScript เป็นประเภทข้อมูลที่ไม่เปลี่ยนรูปแบบที่ง่ายที่สุด
สตริงช่วยให้คุณสามารถแสดงและจัดการข้อความได้ และข้อความเป็นวิธีหลักในการสื่อสารและส่งข้อมูลบนเว็บ ดังนั้นสตริงจึงเป็นหนึ่งในแนวคิดหลักของการเขียนโปรแกรม
บทช่วยสอนนี้จะสอนวิธีสร้างและดูเอาต์พุตสตริง เชื่อมต่อสตริง และจัดเก็บไว้ในตัวแปร นอกจากนี้คุณยังจะได้เรียนรู้เกี่ยวกับกฎการใช้เครื่องหมายคำพูด เครื่องหมายอะพอสทรอฟี และการขึ้นบรรทัดใหม่ใน JavaScript
การสร้างและการดูสตริง
มีสามวิธีในการสร้างสตริงใน JavaScript: สามารถเขียนด้วยเครื่องหมายคำพูดเดี่ยว ('), เครื่องหมายคำพูดคู่ (') หรือ backticks (`) แม้ว่าบางครั้งสคริปต์จะมีสตริงทั้งสามประเภท แต่ควรใช้เครื่องหมายคำพูดเพียงประเภทเดียวเท่านั้นภายในบรรทัดเดียว
สตริงที่มีเครื่องหมายคำพูดเดี่ยวและคู่เป็นสิ่งเดียวกันโดยพื้นฐานแล้ว ไม่มีแบบแผนเกี่ยวกับการใช้เครื่องหมายคำพูดประเภทใดประเภทหนึ่ง แต่โดยทั่วไปแนะนำให้ใช้ประเภทใดประเภทหนึ่งอย่างสม่ำเสมอในสคริปต์โปรแกรม
"สตริงนี้ใช้เครื่องหมายคำพูดเดี่ยว";
"สตริงนี้ใช้เครื่องหมายคำพูดคู่";
วิธีที่สามและใหม่ล่าสุดในการสร้างสตริงเรียกว่าเทมเพลตลิเทอรัล ตัวอักษรเทมเพลตจะเขียนไว้ภายใน backquotes (หรือที่เรียกว่า backticks) และทำงานเหมือนกับสตริงทั่วไป โดยมีคุณลักษณะพิเศษบางประการที่เราจะกล่าวถึงในบทความนี้
`สตริงนี้ใช้ backticks.`;
วิธีที่ง่ายที่สุดในการดูผลลัพธ์ของสตริงคือการป้อนลงในคอนโซลโดยใช้ console.log()
console.log("นี่คือสตริงในคอนโซล");
นี่คือสตริงในคอนโซล
อีกวิธีง่ายๆ ในการสืบค้นค่าของสตริงคือผ่านป๊อปอัปของเบราว์เซอร์ ซึ่งสามารถเรียกใช้ได้โดยใช้ alert():
alert("นี่คือสตริงในการแจ้งเตือน");
บรรทัดนี้จะเปิดหน้าต่างการแจ้งเตือนในเบราว์เซอร์พร้อมข้อความต่อไปนี้:
นี่คือสตริงในการแจ้งเตือน
เมธอด alert() ถูกใช้ไม่บ่อยนัก เนื่องจากจำเป็นต้องปิดการแจ้งเตือนอย่างต่อเนื่อง
การจัดเก็บสตริงในตัวแปร
ตัวแปรใน JavaScript เป็นชื่อคอนเทนเนอร์ที่เก็บค่าโดยใช้คีย์เวิร์ด var, const หรือ let สามารถกำหนดสตริงให้กับตัวแปรได้
const newString = "นี่คือสตริงที่กำหนดให้กับตัวแปร";
ขณะนี้ตัวแปร newString มีสตริงที่สามารถอ้างอิงและแสดงได้โดยใช้คอนโซล
console.log(สตริงใหม่);
นี่คือสตริงที่กำหนดให้กับตัวแปร
ด้วยการกำหนดสตริงให้กับตัวแปร คุณไม่จำเป็นต้องพิมพ์สตริงใหม่ทุกครั้งที่คุณต้องการส่งออก ทำให้ทำงานกับสตริงภายในโปรแกรมได้ง่ายขึ้น
การต่อสตริง
การต่อสตริงเป็นกระบวนการรวมสตริงตั้งแต่สองสตริงขึ้นไปเข้าเป็นสตริงใหม่เดียว การต่อข้อมูลทำได้โดยใช้ตัวดำเนินการ + สัญลักษณ์ + ยังเป็นตัวดำเนินการบวกในการดำเนินการทางคณิตศาสตร์อีกด้วย
ตัวอย่างเช่น ลองเชื่อมสตริงสั้นๆ สองสตริงเข้าด้วยกัน:
"ทะเล" + "ม้า";
ม้าน้ำ
การต่อข้อมูลจะรวมส่วนท้ายของสตริงหนึ่งเข้ากับจุดเริ่มต้นของสตริงอื่นโดยไม่ต้องเว้นวรรค หากต้องการให้มีช่องว่างระหว่างบรรทัด จะต้องเพิ่มที่ท้ายบรรทัดแรก
"ทะเล" + "ม้า";
ม้าน้ำ
การต่อข้อมูลช่วยให้คุณสามารถเชื่อมต่อสตริงและตัวแปรด้วยค่าสตริงได้
const favePoem = "บทกวีที่ฉันชอบคือ " + บทกวี + " โดย " + ผู้แต่ง "";
สามารถใช้สตริงใหม่จากการต่อข้อมูลในโปรแกรมได้
ตัวแปรที่มีตัวอักษรเทมเพลต
คุณลักษณะอย่างหนึ่งของตัวอักษรเทมเพลตคือความสามารถในการรวมนิพจน์และตัวแปรในสตริง แทนที่จะต่อข้อมูล คุณสามารถใช้ไวยากรณ์ $() เพื่อแทรกตัวแปรได้
บทกวี const = "มหาสมุทรอันกว้างใหญ่";
ผู้เขียน const = "ปาโบล เนรูด้า";
const favePoem = `บทกวีที่ฉันชอบคือ $(poem) โดย $(author).`;
บทกวีที่ฉันชอบคือ The Wide Ocean โดย Pablo Neruda
ไวยากรณ์นี้ช่วยให้คุณได้รับผลลัพธ์เดียวกัน ตัวอักษรเทมเพลตทำให้การต่อสตริงง่ายขึ้น
ตัวอักษรสตริงและค่าสตริง
ดังที่คุณอาจสังเกตเห็นว่าสตริงทั้งหมดเขียนด้วยเครื่องหมายคำพูดหรือเครื่องหมายย้อนกลับ แต่เมื่อส่งออก สตริงนั้นจะไม่มีเครื่องหมายคำพูด
"เหนือทะเล";
นอกเหนือจากทะเล
ตัวอักษรสตริงคือสตริงตามที่ปรากฏในซอร์สโค้ด รวมถึงเครื่องหมายคำพูดด้วย ค่าสตริงคือสตริงที่ปรากฏในเอาต์พุต (โดยไม่มีเครื่องหมายคำพูด)
ในตัวอย่างนี้ "Beyond the Sea" เป็นค่าสตริง และ Beyond the Sea เป็นค่าสตริง
การข้ามเครื่องหมายคำพูดและอะพอสทรอฟีในสตริง
เนื่องจากเครื่องหมายคำพูดถูกใช้เพื่อแสดงสตริง จึงมีกฎพิเศษสำหรับการใช้เครื่องหมายอะพอสทรอฟีและเครื่องหมายคำพูดในสตริง ตัวอย่างเช่น JavaScript จะตีความเครื่องหมายอะพอสทรอฟีที่อยู่ตรงกลางของสตริงที่มีเครื่องหมายคำพูดเดี่ยวเป็นเครื่องหมายคำพูดเดี่ยวปิด และพยายามอ่านส่วนที่เหลือของสตริงที่ต้องการเป็นโค้ด
ลองพิจารณาตัวอย่างนี้:
const BrokenString = "ฉันเป็นสายที่ขาด";
console.log(หักสตริง);
ไม่ทราบ: โทเค็นที่ไม่คาดคิด (1:24)
สิ่งเดียวกันนี้จะเกิดขึ้นหากคุณพยายามใช้เครื่องหมายคำพูดคู่ภายในสตริงเครื่องหมายคำพูดคู่ ล่ามจะไม่สังเกตเห็นความแตกต่าง
เพื่อหลีกเลี่ยงข้อผิดพลาดดังกล่าว คุณสามารถใช้:
- ไวยากรณ์สตริงที่แตกต่างกัน
- สัญลักษณ์หลบหนี
- ตัวอักษรเทมเพลต
ไวยากรณ์สตริงทางเลือก
วิธีที่ง่ายที่สุดในการแก้ไขปัญหานี้คือการใช้ไวยากรณ์ตรงกันข้ามกับที่คุณใช้ในสคริปต์ ตัวอย่างเช่น ใส่สตริงที่มีเครื่องหมายอะพอสทรอฟีในเครื่องหมายคำพูดคู่:
“เราใช้เครื่องหมายอะพอสทรอฟี่ในเครื่องหมายคำพูดคู่อย่างปลอดภัย”
สตริงที่มีเครื่องหมายคำพูดสามารถอยู่ในเครื่องหมายคำพูดเดี่ยวได้:
"แล้วเขาก็พูดว่า "สวัสดีชาวโลก!";
ด้วยการรวมเครื่องหมายคำพูดเดี่ยวและคู่เข้าด้วยกัน คุณสามารถควบคุมการแสดงเครื่องหมายคำพูดและเครื่องหมายอะพอสทรอฟี่ภายในสตริงได้ อย่างไรก็ตาม สิ่งนี้จะส่งผลต่อความสอดคล้องของไวยากรณ์ในไฟล์โปรเจ็กต์ ทำให้ยากต่อการบำรุงรักษา
หนีตัวละคร \
เมื่อใช้เครื่องหมายแบ็กสแลช JavaScript จะไม่ตีความเครื่องหมายคำพูดเป็นเครื่องหมายคำพูดปิด
การรวมกัน \' จะถือเป็นเครื่องหมายอัญประกาศเดี่ยวและ \" เป็นเครื่องหมายคำพูดคู่เสมอ โดยไม่มีข้อยกเว้น
ซึ่งช่วยให้สามารถใช้อะพอสทรอฟีในสตริงที่มีเครื่องหมายคำพูดเดี่ยว และเครื่องหมายคำพูดสามารถใช้ในสตริงที่มีเครื่องหมายคำพูดคู่ได้
"เรา\"ใช้เครื่องหมายอะพอสทรอฟีอย่างปลอดภัยในเครื่องหมายคำพูดเดี่ยว\"
"แล้วเขาก็พูดว่า \"สวัสดีชาวโลก!\"";
วิธีนี้ดูเลอะเทอะเล็กน้อย แต่จำเป็นหากบรรทัดเดียวกันมีทั้งเครื่องหมายอัญประกาศเดี่ยวและเครื่องหมายคำพูดคู่
ตัวอักษรเทมเพลต
ตัวอักษรเทมเพลตถูกกำหนดโดยเครื่องหมายย้อนกลับ ดังนั้นทั้งเครื่องหมายคำพูดคู่และเครื่องหมายอะพอสทรอฟีจึงสามารถใช้ได้อย่างปลอดภัยโดยไม่ต้องปรับแต่งใดๆ เพิ่มเติม
`เราใช้เครื่องหมายอะพอสทรอฟีและ "เครื่องหมายคำพูด" ในเทมเพลตตามตัวอักษรอย่างปลอดภัย`;
ตัวอักษรเทมเพลตไม่เพียงแต่หลีกเลี่ยงข้อผิดพลาดเมื่อแสดงเครื่องหมายคำพูดและเครื่องหมายอะพอสทรอฟีเท่านั้น แต่ยังให้การสนับสนุนนิพจน์อินไลน์และบล็อกหลายบรรทัด ตามที่กล่าวไว้ในส่วนถัดไป
หลายบรรทัดและขึ้นบรรทัดใหม่
ในบางสถานการณ์จำเป็นต้องแทรกอักขระขึ้นบรรทัดใหม่หรือตัวแบ่งบรรทัด อักขระหลีก \n หรือ \r จะช่วยแทรกบรรทัดใหม่ลงในเอาต์พุตโค้ด
const threeLines = "นี่คือสตริง\nที่ขยายข้าม\nสามบรรทัด";
นี่คือสตริง
ที่ทอดยาวไปทั่ว
สามบรรทัด
สิ่งนี้จะแยกเอาต์พุตออกเป็นหลายบรรทัด อย่างไรก็ตาม หากมีบรรทัดที่ยาวในโค้ด จะทำให้ใช้งานและอ่านได้ยาก หากต้องการแสดงหนึ่งสตริงบนหลายบรรทัด ให้ใช้ตัวดำเนินการต่อข้อมูล
const threeLines = "นี่คือสตริง\n" +
"ที่ทอดข้าม\n" +
"สามบรรทัด";
คุณยังสามารถหลีกการขึ้นบรรทัดใหม่ได้โดยใช้อักขระหลีก \
const threeLines = "นี่คือสตริง\n\
ที่ครอบคลุม\n\
สามบรรทัด";
บันทึก: ไม่แนะนำวิธีนี้เนื่องจากอาจทำให้เกิดปัญหากับเบราว์เซอร์บางตัวได้
หากต้องการให้โค้ดของคุณอ่านได้ ให้ใช้ตัวอักษรเทมเพลต วิธีนี้จะกำจัดการต่อข้อมูลและการยกเว้นอักขระ
const threeLines = `นี่คือสตริง
ที่ทอดยาวไปทั่ว
สามบรรทัด.`;
นี่คือสตริง
ที่ทอดยาวไปทั่ว
สามบรรทัด
เนื่องจากฐานโค้ดที่แตกต่างกันอาจใช้มาตรฐานที่แตกต่างกัน สิ่งสำคัญคือต้องทราบวิธีทั้งหมดในการขึ้นบรรทัดใหม่และสร้างสตริงหลายบรรทัด
บทสรุป
ตอนนี้คุณรู้หลักการพื้นฐานของการทำงานกับสตริงใน JavaScript แล้ว คุณสามารถสร้างสตริงและตัวอักษรเทมเพลต ดำเนินการต่อข้อมูลและสำรวจเส้นทาง และกำหนดสตริงให้กับตัวแปรได้
แท็ก:เมื่อฉันเขียนด้วยจาวาสคริปต์ ฉันมักจะต้องหันไปหาเครื่องมือค้นหาเพื่อชี้แจงไวยากรณ์ของวิธีการ (และลำดับ คำจำกัดความของอาร์กิวเมนต์) ที่ทำงานกับสตริง
ในบทความนี้ ฉันจะพยายามยกตัวอย่างและคำอธิบายของวิธีการจาวาสคริปต์ที่พบบ่อยที่สุดที่เกี่ยวข้องกับสตริง วิธีการยอดนิยมจะอยู่ที่ด้านบนของบทความเพื่อความสะดวก
แปลงเป็นสตริง
คุณสามารถแปลงตัวเลข บูลีน หรือวัตถุเป็นสตริงได้
เท่ากับ 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(สตริงใหม่); // "เธอขายเปลือกหอยที่ชายฝั่งทะเล"
อาร์กิวเมนต์ที่สองอาจรวมถึงสตริงย่อยหรือฟังก์ชันที่จะแทนที่
ค้นหาตัวละครในตำแหน่งที่กำหนด
หากต้องการทราบว่าอักขระตัวใดอยู่ในตำแหน่งที่กำหนด คุณสามารถใช้เมธอด 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 = "สูง"; 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 = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring (5, 10); // "ฟกิจ"
สำหรับทั้งเมธอด (slice() และ substring()) อาร์กิวเมนต์แรกคือตำแหน่งของอักขระที่สตริงย่อยเริ่มต้น (นับจาก 0) อาร์กิวเมนต์ที่สองคือตำแหน่งของอักขระที่สตริงย่อยสิ้นสุด และ อักขระที่กำหนดในอาร์กิวเมนต์ที่สองไม่รวมอยู่ในสตริงย่อยที่ส่งคืน
ใช้ substr() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr (5, 10); // "fghijklmno"
สำหรับเมธอด substr อาร์กิวเมนต์แรกยังระบุตำแหน่งของอักขระที่สตริงย่อยเริ่มต้นด้วย อาร์กิวเมนต์ที่สองเป็นทางเลือก แต่ในขณะเดียวกัน อาร์กิวเมนต์ที่สองระบุจำนวนอักขระที่ควรรวมไว้ในสตริงย่อย โดยเริ่มจากตำแหน่งที่เรากำหนดไว้ในอาร์กิวเมนต์แรกแล้ว เทคนิคนี้แสดงไว้อย่างดีในตัวอย่างด้านบน
การแปลงสตริงเป็นตัวพิมพ์เล็กหรือใหญ่ในจาวาสคริปต์
มีสี่วิธีในการแปลงที่จำเป็น สองเพื่อแปลงอักขระสตริงเป็นตัวพิมพ์ใหญ่
Var stringOne = "พูดออกมา ฉันไม่ได้ยินคุณ"; var stringTwo = stringOne.toLocaleUpperCase(); // "พูดออกมา ฉัน"ไม่ได้ยินคุณ" var stringThree = stringOne.toUpperCase(); // "พูดมา ฉันไม่ได้ยินคุณ"
และสองเพื่อแปลงสตริงเป็นตัวพิมพ์เล็ก:
Var stringOne = "คุณไม่จำเป็นต้องตะโกน"; var stringTwo = stringOne.toLocaleLowerCase(); // "คุณไม่จำเป็นต้องตะโกน" var stringThree = stringOne.toLowerCase(); // "เธอไม่ต้องตะโกน"
โดยทั่วไป ไม่มีความแตกต่างระหว่างวิธี locale และวิธี non-locale อย่างไรก็ตาม "สำหรับบางภาษา เช่น ภาษาตุรกี ซึ่งตัวพิมพ์ของอักขระไม่เป็นไปตามกรณี Unicode ที่กำหนดไว้ ผลที่ตามมาจากการใช้วิธี non-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() ซึ่งใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์และส่งกลับตำแหน่งเริ่มต้นของรูปแบบแรกที่ตรงกัน
Var myString = "สมมติ"; var patternLocation = myString.search(/ume/); // 3
หากไม่พบรายการที่ตรงกัน เมธอดจะส่งกลับ -1
การเปรียบเทียบสองสายสำหรับการเรียงลำดับในภายหลัง
เมื่อต้องการเปรียบเทียบสองสตริงตามลำดับการจัดเรียงของโลแคล คุณสามารถใช้เมธอด localeCompare เมธอด localeCompare ส่งกลับค่าที่เป็นไปได้สามค่า
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 ได้แก่ สตริงย่อย (), ซับสเตร(), ชิ้น()และฟังก์ชั่น regexp.
ในจาวาสคริปต์ 1.0 และ 1.1 สตริงย่อย ()เป็นเพียงวิธีง่ายๆ ในการเลือกส่วนของสตริงที่ใหญ่กว่า เช่น ให้เลือกเส้น กดจาก การแสดงออก, ใช้ "นิพจน์".สตริงย่อย (2,7). พารามิเตอร์ตัวแรกของฟังก์ชันคือดัชนีอักขระที่การเลือกเริ่มต้นขึ้น ในขณะที่พารามิเตอร์ตัวที่สองคือดัชนีอักขระที่การเลือกสิ้นสุดลง (ไม่รวม): สตริงย่อย (2,7)รวมถึงดัชนี 2, 3, 4, 5 และ 6
ใน JavaScript 1.2 ฟังก์ชัน ซับสเตร(), ชิ้น()และ regexpสามารถใช้เพื่อแยกสตริงได้
ซับสเตร()มีพฤติกรรมเช่นเดียวกับ ส่วนย่อยภาษา Pearl โดยที่พารามิเตอร์แรกระบุดัชนีอักขระที่การเลือกเริ่มต้น ในขณะที่พารามิเตอร์ตัวที่สองระบุความยาวของสตริงย่อย หากต้องการทำงานเหมือนกับในตัวอย่างก่อนหน้านี้ คุณต้องใช้ "นิพจน์".substr(2,5). โปรดจำไว้ว่า 2 คือจุดเริ่มต้น และ 5 คือความยาวของสตริงย่อยที่เป็นผลลัพธ์
เมื่อใช้กับสตริง ชิ้น()มีพฤติกรรมคล้ายกับฟังก์ชัน สตริงย่อย (). อย่างไรก็ตาม มันมีประสิทธิภาพมากกว่ามาก สามารถทำงานกับอาเรย์ทุกประเภท ไม่ใช่แค่สตริง ชิ้น()ยังใช้การชดเชยเชิงลบเพื่อเข้าถึงตำแหน่งที่ต้องการโดยเริ่มจากจุดสิ้นสุดของบรรทัด "การแสดงออก".slice(2,-3)จะส่งกลับสตริงย่อยที่พบระหว่างอักขระตัวที่สองและอักขระตัวที่สามจากท้ายสุด และกลับมากดอีกครั้ง
วิธีสุดท้ายและเป็นสากลที่สุดในการทำงานกับสตริงย่อยคือการทำงานผ่านฟังก์ชันนิพจน์ทั่วไปใน JavaScript 1.2 อีกครั้ง โดยให้ความสนใจกับตัวอย่างเดียวกัน นั่นคือสตริงย่อย "กด"ที่ได้รับจากสตริง "การแสดงออก":
เขียน("นิพจน์".match(/press/));
วัตถุในตัว สตริง
วัตถุ สตริงนี่คือการดำเนินการวัตถุของค่าสตริงดั้งเดิม ตัวสร้างของมันดูเหมือนว่า:
สตริงใหม่( ความหมาย?)
ที่นี่ ความหมายนิพจน์สตริงใดๆ ที่ระบุค่าดั้งเดิมของวัตถุ หากไม่ได้ระบุ ค่าดั้งเดิมของออบเจ็กต์จะเป็น ""
คุณสมบัติของวัตถุ String:
ตัวสร้างตัวสร้างที่สร้างวัตถุ จำนวนอักขระต่อบรรทัด ต้นแบบการอ้างอิงถึงต้นแบบคลาสอ็อบเจ็กต์วิธีการวัตถุสตริงมาตรฐาน
ส่งกลับอักขระในตำแหน่งที่กำหนดในสตริง ส่งกลับรหัสของอักขระที่อยู่ในตำแหน่งที่กำหนดในสตริง ส่งกลับการต่อกันของสตริง สร้างสตริงจากอักขระที่ระบุด้วยโค้ด Unicode ส่งกลับตำแหน่งของการเกิดขึ้นครั้งแรกของสตริงย่อยที่ระบุ ส่งกลับตำแหน่งของการเกิดขึ้นครั้งสุดท้ายของสตริงย่อยที่ระบุ เปรียบเทียบสองสตริงตามภาษาของระบบปฏิบัติการ จับคู่สตริงกับนิพจน์ทั่วไป จับคู่สตริงกับนิพจน์ทั่วไปและแทนที่สตริงย่อยที่พบด้วยสตริงย่อยใหม่ จับคู่สตริงกับนิพจน์ทั่วไป ดึงส่วนหนึ่งของสตริงและส่งกลับสตริงใหม่ แยกสตริงออกเป็นอาร์เรย์ของสตริงย่อย ส่งกลับสตริงย่อยที่กำหนดโดยตำแหน่งและความยาว ส่งกลับสตริงย่อยที่ระบุโดยตำแหน่งเริ่มต้นและสิ้นสุด แปลงตัวอักษรทั้งหมดของสตริงเป็นตัวพิมพ์เล็ก โดยคำนึงถึงภาษาของระบบปฏิบัติการ แปลงตัวอักษรทั้งหมดในสตริงเป็นตัวพิมพ์ใหญ่ตามภาษาของระบบปฏิบัติการ แปลงตัวอักษรทั้งหมดในสตริงเป็นตัวพิมพ์เล็ก แปลงวัตถุให้เป็นสตริง แปลงตัวอักษรทั้งหมดในสตริงเป็นตัวพิมพ์ใหญ่ ส่งกลับค่าดั้งเดิมของวัตถุวิธีการที่ไม่ได้มาตรฐานของวัตถุ String
สร้างบุ๊กมาร์ก HTML ( ). ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็ก . สร้างไฮเปอร์ลิงก์ HTML () ล้อมสตริงไว้ในแท็ก . ล้อมสตริงไว้ในแท็กคุณสมบัติความยาว
ไวยากรณ์ : วัตถุ.ความยาว คุณลักษณะ: (DontEnum, DontDelete, อ่านอย่างเดียว)มูลค่าทรัพย์สิน ความยาวคือจำนวนอักขระในบรรทัด สำหรับสตริงว่างค่านี้จะเป็นศูนย์
วิธีการยึดเหนี่ยว
ไวยากรณ์ : วัตถุ.สมอ( ชื่อ) ข้อโต้แย้ง: ชื่อ ผลลัพธ์: ค่าสตริงวิธี สมอ วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ เมธอดนี้ใช้ร่วมกับเมธอด document.write และ document.writeln เพื่อสร้างบุ๊กมาร์กในเอกสาร HTML โดยมีการระบุ ชื่อ. ตัวอย่างเช่น ตัวดำเนินการ document.write("My text".anchor("Bookmark")) เทียบเท่ากับตัวดำเนินการ document.write(" ข้อความของฉัน") .
วิธีการใหญ่
ไวยากรณ์ : วัตถุ.ใหญ่() ผลลัพธ์: ค่าสตริงวิธี ใหญ่ส่งคืนสตริงที่ประกอบด้วย วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความเป็นแบบอักษรขนาดใหญ่ ตัวอย่างเช่น คำสั่ง document.write("My text".big()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีกระพริบตา
ไวยากรณ์ : วัตถุ.กะพริบ() ผลลัพธ์: ค่าสตริงวิธี กระพริบตาส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความเป็นแบบอักษรกะพริบ แท็กเหล่านี้ไม่ได้เป็นส่วนหนึ่งของมาตรฐาน HTML และรองรับเฉพาะเบราว์เซอร์ Netscape และ WebTV เท่านั้น ตัวอย่างเช่น คำสั่ง document.write("My text".blink()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีการตัวหนา
ไวยากรณ์ : วัตถุ.ตัวหนา() ผลลัพธ์: ค่าสตริงวิธี ตัวหนาส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความด้วยแบบอักษรตัวหนา ตัวอย่างเช่น ตัวดำเนินการ document.write("My text".bold()) จะแสดงบรรทัด ข้อความของฉัน .
วิธีการถ่าน
ไวยากรณ์ : วัตถุ.charAt( ตำแหน่ง) ข้อโต้แย้ง: ตำแหน่งนิพจน์ตัวเลขใดๆ ผลลัพธ์: ค่าสตริงวิธี อักขระส่งคืนสตริงที่ประกอบด้วยอักขระที่อยู่ในที่กำหนด ตำแหน่งค่าสตริงดั้งเดิม วัตถุ. ตำแหน่งอักขระบรรทัดจะมีหมายเลขตั้งแต่ศูนย์ถึง วัตถุ. -1. หากตำแหน่งอยู่นอกช่วงนี้ สตริงว่างจะถูกส่งกลับ ตัวอย่างเช่น คำสั่ง document.write("String".charAt(0)) จะพิมพ์อักขระ C ไปที่หน้าจอเบราว์เซอร์
วิธีการ charCodeAt
ไวยากรณ์ : วัตถุ.charCodeAt( ตำแหน่ง) ข้อโต้แย้ง: ตำแหน่งนิพจน์ตัวเลขใดๆ ผลลัพธ์: ค่าตัวเลขวิธี อักขระส่งกลับตัวเลขเท่ากับรหัส Unicode ของอักขระที่อยู่ในที่กำหนด ตำแหน่งค่าสตริงดั้งเดิม วัตถุ. ตำแหน่งอักขระบรรทัดจะมีหมายเลขตั้งแต่ศูนย์ถึง วัตถุ. -1. หากตำแหน่งอยู่นอกช่วงนี้ ก็จะส่งกลับ น่าน. ตัวอย่างเช่น ตัวดำเนินการ document.write("String".charCodeAt(0).toString(16)) จะแสดงรหัสฐานสิบหกของตัวอักษรรัสเซีย "C" บนหน้าจอเบราว์เซอร์: 421
วิธีการเชื่อมต่อ
ไวยากรณ์ : วัตถุ.คอนแคต( บรรทัด0, บรรทัดที่ 1, , สตริงN) ข้อโต้แย้ง: บรรทัด0, บรรทัดที่ 1, , สตริงNนิพจน์สตริงใดๆ ผลลัพธ์: ค่าสตริงวิธี เชื่อมต่อส่งคืนสตริงใหม่ที่เป็นการต่อกันของสตริงดั้งเดิมและอาร์กิวเมนต์ของเมธอด วิธีนี้เทียบเท่ากับการดำเนินการ
วัตถุ + บรรทัด0 + บรรทัดที่ 1 + + สตริงNตัวอย่างเช่น ตัวดำเนินการ document.write("Frost and sun.".concat("Wonderful day")) จะแสดงบรรทัด Frost และ sun บนหน้าจอเบราว์เซอร์ มันเป็นวันที่ยอดเยี่ยม
วิธีการคงที่
ไวยากรณ์ : วัตถุ.ที่ตายตัว() ผลลัพธ์: ค่าสตริงวิธี ที่ตายตัวส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ เมธอดนี้ใช้ร่วมกับเมธอด document.write และ document.writeln เพื่อแสดงข้อความในฟอนต์เทเลไทป์ ตัวอย่างเช่น คำสั่ง document.write("My text".fixed()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีสีฟอนต์
ไวยากรณ์ : วัตถุ.fontcolor(สี) ข้อโต้แย้ง: สีนิพจน์สตริง ผลลัพธ์: ค่าสตริงวิธี สีตัวอักษรส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก สี> . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความในสีที่ระบุ ตัวอย่างเช่น คำสั่ง document.write("My text".fontcolor("red")) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีขนาดตัวอักษร
ไวยากรณ์ : วัตถุ.ขนาดตัวอักษร( ขนาด) ข้อโต้แย้ง: ขนาดนิพจน์ตัวเลข ผลลัพธ์: ค่าสตริงวิธี ขนาดตัวอักษรส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความในขนาดตัวอักษรที่ระบุ ตัวอย่างเช่น คำสั่ง document.write("My text".fontsize(5)) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีการ fromCharCode
ไวยากรณ์ : String.fromCharCode( รหัส1, รหัส2, , รหัสN) ข้อโต้แย้ง: รหัส1, รหัส2, , รหัสNนิพจน์ตัวเลข ผลลัพธ์: ค่าสตริงวิธี จากCharCodeสร้างสตริงใหม่ (แต่ไม่ใช่วัตถุสตริง) ที่เชื่อมต่ออักขระ Unicode กับรหัส รหัส1, รหัส2, , รหัสN.
นี่เป็นวิธีคงที่ของวัตถุ สตริงดังนั้นคุณไม่จำเป็นต้องสร้างวัตถุสตริงโดยเฉพาะเพื่อเข้าถึง ตัวอย่าง:
Var s = String.fromCharCode(65, 66, 67); // s เท่ากับ "ABC"
วิธีดัชนีของ
ไวยากรณ์ : วัตถุ.ดัชนีของ( สตริงย่อย[,เริ่ม]?) ข้อโต้แย้ง: สตริงย่อยนิพจน์สตริงใดๆ เริ่มนิพจน์ตัวเลขใดๆ ผลลัพธ์: ค่าตัวเลขวิธี ดัชนีของกลับตำแหน่งแรก สตริงย่อยในค่าสตริงดั้งเดิม วัตถุ. วัตถุ เริ่ม เริ่ม เริ่ม เริ่มมากกว่า วัตถุ วัตถุ
การค้นหาจะดำเนินการจากซ้ายไปขวา มิฉะนั้นวิธีนี้จะเหมือนกับวิธีการนี้ ตัวอย่างต่อไปนี้นับจำนวนครั้งของรูปแบบสตริงย่อยในสตริง str
ฟังก์ชั่นเกิดขึ้น(str, รูปแบบ) ( var pos = str.indexOf(pattern); for (var count = 0; pos != -1; count++) pos = str.indexOf(pattern, pos + pattern.length); return count ; )
วิธีตัวเอียง
ไวยากรณ์ : วัตถุ.ตัวเอียง() ผลลัพธ์: ค่าสตริงวิธี ตัวเอียงส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความในแบบอักษรตัวเอียง ตัวอย่างเช่น ตัวดำเนินการ document.write("My text".italics()) จะแสดงบรรทัด ข้อความของฉัน .
วิธีการ LastIndexOf
ไวยากรณ์ : วัตถุ.lastIndexOf( สตริงย่อย[,เริ่ม]?) ข้อโต้แย้ง: สตริงย่อยนิพจน์สตริงใดๆ เริ่มนิพจน์ตัวเลขใดๆ ผลลัพธ์: ค่าตัวเลขวิธี LastIndexOfส่งคืนตำแหน่งสุดท้าย สตริงย่อยในค่าสตริงดั้งเดิม วัตถุ วัตถุ. -1. หากได้รับอาร์กิวเมนต์เพิ่มเติม เริ่มจากนั้นทำการค้นหาโดยเริ่มจากตำแหน่ง เริ่ม; ถ้าไม่เช่นนั้นให้มาจากตำแหน่ง 0 เช่น จากอักขระตัวแรกของบรรทัด ถ้า เริ่มลบจากนั้นจะเท่ากับศูนย์ ถ้า เริ่มมากกว่า วัตถุ. -1 จากนั้นจะถือว่าเท่ากัน วัตถุ. -1. หากอ็อบเจ็กต์ไม่มีสตริงย่อยนี้ ค่า -1 จะถูกส่งกลับ
การค้นหาจะดำเนินการจากขวาไปซ้าย มิฉะนั้นวิธีนี้จะเหมือนกับวิธีการนี้ ตัวอย่าง:
Var n = "วาฬขาว".lastIndexOf("ปลาวาฬ"); // n เท่ากับ 6
วิธีการเชื่อมโยง
ไวยากรณ์ : วัตถุ.ลิงค์( ยูริ) ข้อโต้แย้ง: ยูรินิพจน์สตริงใดๆ ผลลัพธ์: ค่าสตริงวิธี ลิงค์ส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุอยู่ในแท็ก uri"> ไม่มีการตรวจสอบว่าสตริงต้นฉบับถูกล้อมอยู่ภายในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับเมธอด document.write และ document.writeln เพื่อสร้างไฮเปอร์ลิงก์ในเอกสาร HTML ที่ระบุ ยูริ. ตัวอย่างเช่น คำสั่ง document.write("My Text".link("#Bookmark")) เทียบเท่ากับคำสั่ง document.write("My Text")
วิธีการเปรียบเทียบสถานที่
ไวยากรณ์ : วัตถุ.localeเปรียบเทียบ( บรรทัดที่ 1) ข้อโต้แย้ง: บรรทัดที่ 1นิพจน์สตริงใดๆ ผลลัพธ์: ตัวเลขสนับสนุน
วิธี สถานที่เปรียบเทียบเปรียบเทียบสองสตริงโดยคำนึงถึงการตั้งค่าระดับชาติของระบบปฏิบัติการ จะส่งกลับ -1 หากเป็นค่าดั้งเดิม วัตถุน้อย เส้น1, +1 ถ้ามากกว่านั้น เส้น1และ 0 หากค่าเหล่านี้เท่ากัน
วิธีการจับคู่
ไวยากรณ์ : วัตถุ.จับคู่( นายทะเบียน) ข้อโต้แย้ง: นายทะเบียน ผลลัพธ์: อาร์เรย์ของสตริงวิธี จับคู่ นายทะเบียน วัตถุ. ผลลัพธ์ของการจับคู่คืออาร์เรย์ของสตริงย่อยที่พบหรือ โมฆะหากไม่มีการแข่งขัน โดยที่:
- ถ้า นายทะเบียนไม่มีตัวเลือกการค้นหาทั่วโลก ดังนั้นวิธีการจะถูกดำเนินการ นายทะเบียน.ผู้บริหาร(วัตถุ) และผลลัพธ์จะถูกส่งกลับ อาร์เรย์ผลลัพธ์ประกอบด้วยสตริงย่อยที่พบในองค์ประกอบที่มีดัชนี 0 และองค์ประกอบที่เหลือประกอบด้วยสตริงย่อยที่สอดคล้องกับนิพจน์ย่อย นายทะเบียนอยู่ในวงเล็บ
- ถ้า นายทะเบียนมีตัวเลือกการค้นหาทั่วโลก จากนั้นจึงระบุวิธีการ นายทะเบียน.ผู้บริหาร(วัตถุ) จะถูกดำเนินการตราบเท่าที่พบรายการที่ตรงกัน ถ้า n คือจำนวนรายการที่ตรงกัน ผลลัพธ์จะเป็นอาร์เรย์ขององค์ประกอบ n ที่มีสตริงย่อยที่พบ คุณสมบัติ นายทะเบียน.ดัชนีล่าสุดกำหนดหมายเลขตำแหน่งในสตริงต้นทางโดยชี้ไปที่อักขระตัวแรกหลังจากพบรายการที่ตรงกันล่าสุด หรือ 0 หากไม่พบรายการที่ตรงกัน
ก็ควรจะจำไว้ว่าวิธีการ นายทะเบียน.ผู้บริหารเปลี่ยนคุณสมบัติของวัตถุ นายทะเบียน. ตัวอย่าง:
แทนที่วิธีการ
ไวยากรณ์ : วัตถุ.แทนที่( นายทะเบียน,เส้น) วัตถุ.แทนที่( นายทะเบียน,การทำงาน) ข้อโต้แย้ง: นายทะเบียนนิพจน์สตริงนิพจน์ทั่วไป การทำงานชื่อฟังก์ชันหรือการประกาศฟังก์ชัน ผลลัพธ์: ขึ้นบรรทัดใหม่วิธี แทนที่ตรงกับนิพจน์ทั่วไป นายทะเบียนด้วยค่าสตริงดั้งเดิม วัตถุและแทนที่สตริงย่อยที่พบด้วยสตริงย่อยอื่นๆ ผลลัพธ์ที่ได้คือสตริงใหม่ ซึ่งเป็นสำเนาของสตริงเดิมที่มีการแทนที่ วิธีการแทนที่ถูกกำหนดโดยตัวเลือกการค้นหาทั่วโลกใน นายทะเบียนและประเภทของอาร์กิวเมนต์ที่สอง
ถ้า นายทะเบียนไม่มีตัวเลือกการค้นหาส่วนกลาง จากนั้นจะทำการค้นหาสำหรับสตริงย่อยแรกที่ตรงกัน นายทะเบียนและมันถูกแทนที่ ถ้า นายทะเบียนมีตัวเลือกการค้นหาทั่วโลก จากนั้นสตริงย่อยทั้งหมดที่ตรงกัน นายทะเบียนและพวกมันจะถูกแทนที่
เส้นจากนั้นแต่ละสตริงย่อยที่พบจะถูกแทนที่ด้วยสตริงย่อยนั้น ในกรณีนี้ บรรทัดอาจมีคุณสมบัติวัตถุต่อไปนี้ RegExpเช่น $1 , , $9 , LastMatch , LastParen , leftContext และ rightContext ตัวอย่างเช่น ตัวดำเนินการ document.write("Delicious apples, Juicy apples.".replace(/apples/g, "pears")) จะแสดงบรรทัด Delicious pears, Juicy pears บนหน้าจอเบราว์เซอร์
ถ้าข้อโต้แย้งที่สองคือ การทำงานจากนั้นแต่ละสตริงย่อยที่พบจะถูกแทนที่ด้วยการเรียกใช้ฟังก์ชันนี้ ฟังก์ชันมีอาร์กิวเมนต์ดังต่อไปนี้ อาร์กิวเมนต์แรกคือสตริงย่อยที่พบ ตามด้วยอาร์กิวเมนต์ที่ตรงกับนิพจน์ย่อยทั้งหมด นายทะเบียนซึ่งอยู่ในวงเล็บ อาร์กิวเมนต์สุดท้ายคือตำแหน่งของสตริงย่อยที่พบในสตริงต้นทาง นับจากศูนย์ และอาร์กิวเมนต์สุดท้ายคือสตริงต้นทางนั่นเอง ตัวอย่างต่อไปนี้แสดงวิธีการใช้วิธีการ แทนที่คุณสามารถเขียนฟังก์ชันเพื่อแปลงฟาเรนไฮต์เป็นเซลเซียสได้ สถานการณ์ที่กำหนด
ฟังก์ชัน myfunc($0,$1) ( return (($1-32) * 5 / 9) + "C"; ) function f2c(x) ( var s = String(x); return s.replace(/(\d+( \.\d*)?)F\b/, myfunc); ) document.write(f2c("212F"));
จะแสดงบรรทัด 100C บนหน้าจอเบราว์เซอร์
โปรดทราบว่าวิธีนี้จะเปลี่ยนคุณสมบัติของวัตถุ นายทะเบียน.
แทนที่ตัวอย่าง
แทนที่การเกิดขึ้นทั้งหมดของสตริงย่อยในสตริง
บ่อยครั้งคุณจะต้องแทนที่สตริงหนึ่งด้วยสตริงอื่น:
Var str = "foobarfoobar"; str=str.replace(/foo/g,"xxx"); // ผลลัพธ์จะเป็น str = "xxxbarxxxbar";
วิธีการค้นหา
ไวยากรณ์ : วัตถุ.ค้นหา( นายทะเบียน) ข้อโต้แย้ง: นายทะเบียนนิพจน์ทั่วไปใดๆ ผลลัพธ์: นิพจน์ตัวเลขวิธี ค้นหาตรงกับนิพจน์ทั่วไป นายทะเบียนด้วยค่าสตริงดั้งเดิม วัตถุ. ผลลัพธ์ของการจับคู่คือตำแหน่งของสตริงย่อยแรกที่พบ นับจากศูนย์ หรือ -1 หากไม่มีรายการที่ตรงกัน ในเวลาเดียวกันตัวเลือกการค้นหาทั่วโลกใน นายทะเบียนจะถูกละเลยและคุณสมบัติ นายทะเบียนห้ามเปลี่ยน. ตัวอย่าง:
วิธีการแบ่งส่วน
ไวยากรณ์ : วัตถุ.ชิ้น( เริ่ม [,จบ]?) ข้อโต้แย้ง: เริ่มและ จบนิพจน์ตัวเลขใดๆ ผลลัพธ์: ขึ้นบรรทัดใหม่วิธี ชิ้น วัตถุ, จากตำแหน่ง เริ่มเพื่อวางตำแหน่ง จบโดยไม่รวมมัน ถ้า จบ เริ่มและไปจนสุดบรรทัดเดิม
ตำแหน่งอักขระบรรทัดจะมีหมายเลขตั้งแต่ศูนย์ถึง วัตถุ. -1. หากมีค่า เริ่ม วัตถุ. +เริ่ม. หากมีค่า จบเป็นค่าลบ จากนั้นจะถูกแทนที่ด้วย วัตถุ. +จบ. กล่าวอีกนัยหนึ่ง อาร์กิวเมนต์เชิงลบจะถือเป็นการชดเชยจากจุดสิ้นสุดของสตริง
ผลลัพธ์คือค่าสตริง ไม่ใช่วัตถุสตริง ตัวอย่างเช่น คำสั่ง document.write("ABCDEF".slice(2,-1)) จะพิมพ์สตริง CDE ไปยังหน้าจอเบราว์เซอร์
วิธีการเล็กๆ
ไวยากรณ์ : วัตถุ.เล็ก() ผลลัพธ์: ค่าสตริงวิธี เล็กส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความเป็นแบบอักษรขนาดเล็ก ตัวอย่างเช่น คำสั่ง document.write("My text".small()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีการแยก
ไวยากรณ์ : วัตถุ.แยก( ตัวคั่น [,ตัวเลข]?) ข้อโต้แย้ง: ตัวคั่นสตริงหรือนิพจน์ทั่วไป ตัวเลขนิพจน์ตัวเลข ผลลัพธ์: อาร์เรย์สตริง (object อาร์เรย์)วิธี แยกทำลายค่าดั้งเดิม วัตถุไปยังอาร์เรย์ของสตริงย่อยแล้วส่งคืน การแบ่งเป็นสตริงย่อยทำได้ดังนี้ สตริงต้นฉบับจะถูกสแกนจากซ้ายไปขวาเพื่อค้นหา ตัวคั่น. เมื่อพบแล้ว สตริงย่อยจากส่วนท้ายของตัวคั่นก่อนหน้า (หรือจากจุดเริ่มต้นของบรรทัดหากนี่เป็นรายการแรกของตัวคั่น) ไปยังจุดเริ่มต้นของตัวคั่นที่พบจะถูกเพิ่มลงในอาร์เรย์สตริงย่อย ดังนั้นตัวคั่นจึงไม่ปรากฏในข้อความของสตริงย่อย
อาร์กิวเมนต์เพิ่มเติม ตัวเลขระบุขนาดที่เป็นไปได้สูงสุดของอาร์เรย์ผลลัพธ์ หากมีการระบุไว้แล้วหลังจากเลือกแล้ว ตัวเลขวิธีการสตริงย่อยออกแม้ว่าการสแกนสตริงต้นฉบับจะยังไม่เสร็จสิ้นก็ตาม
ตัวคั่นสามารถระบุเป็นสตริงหรือเป็นนิพจน์ทั่วไปได้ มีหลายกรณีที่จำเป็นต้องพิจารณาเป็นพิเศษ:
ตัวอย่างต่อไปนี้ใช้นิพจน์ทั่วไปเพื่อระบุแท็ก HTML เป็นตัวคั่น ผู้ดำเนินการ
จะแสดงบรรทัดข้อความ ตัวหนา และตัวเอียงบนหน้าจอเบราว์เซอร์
วิธีการนัดหยุดงาน
ไวยากรณ์ : วัตถุ.โจมตี() ผลลัพธ์: ค่าสตริงวิธี โจมตีส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก
. ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความในแบบอักษรขีดทับ ตัวอย่างเช่น คำสั่ง document.write("My text".strike()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีการย่อย
ไวยากรณ์ : วัตถุ.ย่อย() ผลลัพธ์: ค่าสตริงวิธี ย่อยส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความเป็นตัวห้อย ตัวอย่างเช่น คำสั่ง document.write("My text".sub()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธีการย่อย
ไวยากรณ์ : วัตถุ.substr( ตำแหน่ง [,ความยาว]?) ข้อโต้แย้ง: ตำแหน่งและ ความยาวนิพจน์ตัวเลข ผลลัพธ์: ค่าสตริงวิธี ส่วนย่อยส่งกลับสตริงย่อยของค่าดั้งเดิมของสตริง วัตถุเริ่มต้นด้วยสิ่งนี้ ตำแหน่งและประกอบด้วย ความยาวตัวอักษร ถ้า ความยาวไม่ได้ระบุ ดังนั้นสตริงย่อยจะถูกส่งกลับโดยเริ่มจากสตริงที่กำหนด ตำแหน่งและไปจนสุดบรรทัดเดิม ถ้า ความยาวเป็นลบหรือศูนย์ ระบบจะส่งกลับสตริงว่าง
ตำแหน่งอักขระบรรทัดจะมีหมายเลขตั้งแต่ศูนย์ถึง วัตถุ. -1. ถ้า ตำแหน่งมากกว่าหรือเท่ากับ วัตถุ. จากนั้นส่งคืนสตริงว่าง ถ้า ตำแหน่งเป็นลบ จากนั้นจึงตีความว่าเป็นการชดเชยจากท้ายบรรทัด กล่าวคือ ถูกแทนที่ด้วย วัตถุ.+ตำแหน่ง.
บันทึก. ถ้า ตำแหน่งเป็นค่าลบ Internet Explorer จะแทนที่ด้วย 0 โดยไม่ตั้งใจ ดังนั้นจึงไม่ควรใช้ตัวเลือกนี้ด้วยเหตุผลด้านความเข้ากันได้
วาร์ src = "abcdef"; var s1 = src.substr(1, 3); // "bcd" var s2 = src.substr(1); // "bcdef" var s3 = src.substr(-1); // "f" แต่ใน MSIE: "abcdef"
วิธีการสตริงย่อย
ไวยากรณ์ : วัตถุ.สตริงย่อย( เริ่ม [,จบ]) ข้อโต้แย้ง: เริ่มและ จบนิพจน์ตัวเลข ผลลัพธ์: ค่าสตริงวิธี สตริงย่อยส่งกลับสตริงย่อยของค่าดั้งเดิมของสตริง วัตถุ, จากตำแหน่ง เริ่มเพื่อวางตำแหน่ง จบโดยไม่รวมมัน ถ้า จบไม่ได้ระบุ จากนั้นจะมีการส่งคืนสตริงย่อย โดยเริ่มจากตำแหน่ง เริ่มและไปจนสุดบรรทัดเดิม
ตำแหน่งอักขระบรรทัดจะมีหมายเลขตั้งแต่ศูนย์ถึง วัตถุ. -1. อาร์กิวเมนต์เชิงลบหรือเท่ากับ น่านถูกแทนที่ด้วยศูนย์ ถ้าอาร์กิวเมนต์ยาวกว่าความยาวของสตริงเดิม ก็จะถูกแทนที่ด้วยอาร์กิวเมนต์นั้น ถ้า เริ่มมากกว่า จบแล้วพวกเขาก็เปลี่ยนสถานที่ ถ้า เริ่มเท่ากับ จบจากนั้นจะส่งกลับสตริงว่าง
ผลลัพธ์คือค่าสตริง ไม่ใช่วัตถุสตริง ตัวอย่าง:
วาร์ src = "abcdef"; var s1 = src.substring(1, 3); // "bc" var s2 = src.substring(1, -1); // "a" var s3 = src.substring(-1, 1); // "ก"
วิธีการซุป
ไวยากรณ์ : วัตถุ.จีบ() ผลลัพธ์: ค่าสตริงวิธี จีบส่งคืนสตริงที่ประกอบด้วยค่าสตริงดั้งเดิม วัตถุ, อยู่ในแท็ก . ไม่มีการตรวจสอบว่าสตริงต้นฉบับอยู่ในแท็กเหล่านี้แล้วหรือไม่ วิธีการนี้ใช้ร่วมกับวิธีการ document.write และ document.writeln เพื่อแสดงข้อความเป็นตัวยก ตัวอย่างเช่น คำสั่ง document.write("My text".sup()) จะแสดงสตริง My text บนหน้าจอเบราว์เซอร์
วิธี toLocaleLowerCase
ไวยากรณ์ : วัตถุ.toLocaleLowerCase() ผลลัพธ์: ขึ้นบรรทัดใหม่สนับสนุน: รองรับ Internet Explorer ตั้งแต่เวอร์ชัน 5.5 ไม่รองรับ Netscape Navigator
วิธี ถึง LocaleLowerCaseส่งคืนสตริงใหม่โดยแทนที่ตัวอักษรทั้งหมดของสตริงเดิมด้วยตัวพิมพ์เล็ก โดยคำนึงถึงการตั้งค่าภาษาของระบบปฏิบัติการ อักขระที่เหลือของสตริงต้นฉบับจะไม่เปลี่ยนแปลง สายเดิมยังคงเหมือนเดิม โดยทั่วไปวิธีนี้จะส่งกลับผลลัพธ์เดียวกันกับ ; ความแตกต่างจะเกิดขึ้นได้ก็ต่อเมื่อการเข้ารหัสภาษาขัดแย้งกับกฎ Unicode สำหรับการแปลงตัวพิมพ์ใหญ่เป็นตัวพิมพ์เล็ก
วิธีการ toLocaleUpperCase
ไวยากรณ์ : วัตถุ.toLocaleUpperCase() ผลลัพธ์: ขึ้นบรรทัดใหม่สนับสนุน: รองรับ Internet Explorer ตั้งแต่เวอร์ชัน 5.5 ไม่รองรับ Netscape Navigator
วิธี ไปยัง LocaleUpperCaseส่งคืนสตริงใหม่โดยแทนที่ตัวอักษรทั้งหมดของสตริงเดิมด้วยตัวพิมพ์ใหญ่ โดยคำนึงถึงการตั้งค่าภาษาของระบบปฏิบัติการ อักขระที่เหลือของสตริงต้นฉบับจะไม่เปลี่ยนแปลง สายเดิมยังคงเหมือนเดิม โดยทั่วไปวิธีนี้จะส่งกลับผลลัพธ์เดียวกันกับ ; ความแตกต่างจะเกิดขึ้นได้ก็ต่อเมื่อการเข้ารหัสภาษาขัดแย้งกับกฎ Unicode สำหรับการแปลงอักษรตัวพิมพ์เล็กเป็นอักษรตัวพิมพ์ใหญ่
วิธี toLowerCase
ไวยากรณ์ : วัตถุ.toLowerCase() ผลลัพธ์: ขึ้นบรรทัดใหม่วิธี ถึงตัวพิมพ์เล็กส่งคืนสตริงใหม่โดยแทนที่ตัวอักษรทั้งหมดของสตริงเดิมด้วยตัวพิมพ์เล็ก อักขระที่เหลือของสตริงต้นฉบับจะไม่เปลี่ยนแปลง สายเดิมยังคงเหมือนเดิม ตัวอย่างเช่น คำสั่ง document.write("String object".toLowerCase()) จะพิมพ์สตริงอ็อบเจ็กต์สตริงไปที่หน้าจอเบราว์เซอร์
สวัสดีทุกคนที่ได้ตัดสินใจอย่างถี่ถ้วนในการเรียนรู้ภาษาที่เน้นต้นแบบ ครั้งสุดท้ายที่ฉันบอกคุณเกี่ยวกับ และวันนี้เราจะแยกวิเคราะห์สตริง JavaScript เนื่องจากในภาษานี้องค์ประกอบข้อความทั้งหมดเป็นสตริง (ไม่มีรูปแบบแยกต่างหากสำหรับอักขระ) คุณจึงสามารถเดาได้ว่าส่วนนี้มีส่วนสำคัญในการเรียนรู้ไวยากรณ์ js
นั่นคือเหตุผลที่ในเอกสารนี้ฉันจะบอกคุณว่าองค์ประกอบสตริงถูกสร้างขึ้นอย่างไร มีวิธีการและคุณสมบัติใดบ้าง วิธีการแปลงสตริงอย่างถูกต้อง เช่น แปลงเป็นตัวเลข วิธีแยกสตริงย่อยที่ต้องการและอีกมากมาย นอกจากนี้ผมจะแนบตัวอย่างโค้ดโปรแกรมด้วย ตอนนี้มาลงมือทำธุรกิจกันดีกว่า!
ไวยากรณ์ตัวแปรสตริง
ในภาษา js ตัวแปรทั้งหมดจะถูกประกาศโดยใช้คีย์เวิร์ด var จากนั้นประเภทของตัวแปรที่ประกาศจะถูกกำหนด ขึ้นอยู่กับรูปแบบของพารามิเตอร์ อย่างที่คุณจำได้จาก JavaScript ไม่มีการพิมพ์ที่หนักแน่น นั่นคือสาเหตุว่าทำไมจึงมีสถานการณ์เช่นนี้อยู่ในโค้ด
เมื่อเริ่มต้นตัวแปร ค่าสามารถจัดเฟรมเป็น double, single และตั้งแต่ปี 2015 เป็นต้นไป ในรูปแบบเครื่องหมายคำพูดเดี่ยวที่บิดเบี้ยว ด้านล่างนี้ฉันได้แนบตัวอย่างของแต่ละวิธีในการประกาศสตริง
ฉันต้องการให้ความสนใจเป็นพิเศษกับวิธีที่สาม มันมีข้อดีหลายประการ
ด้วยความช่วยเหลือ คุณสามารถทำการขึ้นบรรทัดใหม่ได้อย่างง่ายดาย และจะมีลักษณะดังนี้:
การแจ้งเตือน (`หลาย
กำลังโอนครับ
และวิธีที่ 3 ให้คุณใช้โครงสร้าง $(…) ได้ จำเป็นต้องใช้เครื่องมือนี้ในการแทรกการแก้ไข อย่าเพิ่งตกใจไป ตอนนี้ฉันจะบอกคุณว่ามันคืออะไร
ขอบคุณ $(…) คุณสามารถแทรกไม่เพียงแต่ค่าตัวแปรลงในสตริงเท่านั้น แต่ยังดำเนินการทางคณิตศาสตร์และตรรกะด้วยวิธีการโทรฟังก์ชัน ฯลฯ ทั้งหมดนี้เรียกว่าคำเดียว - การแก้ไข ดูตัวอย่างการนำแนวทางนี้ไปใช้
| 1 2 3 | ปากกาวาร์ = 3; ดินสอ var = 1; alert(`$(ปากกา) + $(pencil*5) = $(pen + ดินสอ)`); |
ปากกาวาร์ = 3; ดินสอ var = 1; alert(`$(ปากกา) + $(pencil*5) = $(pen + ดินสอ)`);
เป็นผลให้นิพจน์ "3 + 1*5 = 8" ปรากฏบนหน้าจอ
สำหรับสองวิธีแรกในการประกาศสตริงนั้นไม่มีความแตกต่างกัน
เรามาพูดถึงตัวละครพิเศษกันสักหน่อย
ภาษาโปรแกรมหลายภาษามีอักขระพิเศษที่ช่วยจัดการข้อความในสตริง สิ่งที่มีชื่อเสียงที่สุดในหมู่พวกเขาคือการขึ้นบรรทัดใหม่ (\n).
เครื่องมือที่คล้ายกันทั้งหมดเริ่มต้นด้วยเครื่องหมายแบ็กสแลช (\) และตามด้วยตัวอักษรภาษาอังกฤษ
ด้านล่างนี้ฉันได้แนบตารางเล็กๆ ที่แสดงอักขระพิเศษบางตัวมาด้วย
เรามีวิธีการและคุณสมบัติมากมาย
นักพัฒนาภาษาจัดเตรียมวิธีการและคุณสมบัติมากมายเพื่อลดความซับซ้อนและเพิ่มประสิทธิภาพการทำงานกับสตริง และด้วยการเปิดตัวมาตรฐานใหม่ที่เรียกว่า ES-2015 เมื่อปีที่แล้ว รายการนี้จึงเต็มไปด้วยเครื่องมือใหม่ๆ
ความยาว
ฉันจะเริ่มต้นด้วยคุณสมบัติยอดนิยมซึ่งช่วยในการค้นหาความยาวของค่าของตัวแปรสตริง นี้ ความยาว. มันถูกใช้ในลักษณะนี้:
var string = "ยูนิคอร์น";
การแจ้งเตือน (string.length);
คำตอบจะแสดงหมายเลข 9 คุณสมบัตินี้สามารถนำไปใช้กับค่าได้ด้วยตัวเอง:
"ยูนิคอร์น".ความยาว;
ผลลัพธ์จะไม่เปลี่ยนแปลง
อักขระ()
วิธีนี้ช่วยให้คุณสามารถแยกอักขระเฉพาะจากข้อความได้ ฉันขอเตือนคุณว่าการนับเลขเริ่มต้นจากศูนย์ ดังนั้นหากต้องการแยกอักขระตัวแรกออกจากสตริงคุณต้องเขียนคำสั่งต่อไปนี้:
var string = "ยูนิคอร์น";
การแจ้งเตือน (string.charAt(0));.
อย่างไรก็ตาม ผลลัพธ์ที่ได้จะไม่ใช่ประเภทอักขระ แต่จะยังถือว่าเป็นสตริงตัวอักษรตัวเดียว
จาก toLowerCase() ถึง UpperCase()
วิธีการเหล่านี้ควบคุมตัวพิมพ์ เมื่อเขียนโค้ด "เนื้อหา"
ถึงUpperCase()คำทั้งหมดจะแสดงเป็นตัวพิมพ์ใหญ่
หากต้องการผลตรงกันข้าม คุณควรใช้ "เนื้อหา" ถึงตัวพิมพ์เล็ก().
ดัชนีของ()
เครื่องมือยอดนิยมและจำเป็นสำหรับการค้นหาสตริงย่อย สำหรับอาร์กิวเมนต์ คุณต้องป้อนคำหรือวลีที่คุณต้องการค้นหา และเมธอดจะส่งคืนตำแหน่งขององค์ประกอบที่พบ หากไม่พบข้อความที่ค้นหา “-1” จะถูกส่งกลับไปยังผู้ใช้
| 1 2 3 4 | var text = "จัดระเบียบการค้นหาดอกไม้!"; alert(text.indexOf("สี")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18 |
var text = "จัดระเบียบการค้นหาดอกไม้!"; alert(text.indexOf("สี")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18
โปรดทราบว่า LastIndexOf() จะทำสิ่งเดียวกัน แต่จะค้นหาจากส่วนท้ายของประโยคเท่านั้น
การสกัดสตริงย่อย
สำหรับการดำเนินการนี้ มีการสร้างวิธีที่เหมือนกันโดยประมาณสามวิธีใน js
มาดูกันก่อนครับ สตริงย่อย (เริ่มต้น, สิ้นสุด)และ ชิ้น (เริ่มต้น, สิ้นสุด). พวกเขาทำงานเหมือนกัน อาร์กิวเมนต์แรกกำหนดตำแหน่งเริ่มต้นที่การแยกจะเริ่มต้น และอาร์กิวเมนต์ที่สองรับผิดชอบจุดหยุดสุดท้าย ในทั้งสองวิธี สตริงจะถูกแยกออกโดยไม่รวมถึงอักขระที่อยู่ในตำแหน่งสิ้นสุด
var text = "บรรยากาศ"; การแจ้งเตือน (text.substring(4)); // จะแสดงการแจ้งเตือน “ทรงกลม”(text.substring(2, 5)); //แสดงการแจ้งเตือน "mos"(text.slice(2, 5)); // แสดง "mos"
ตอนนี้เรามาดูวิธีที่สามซึ่งเรียกว่า ซับสเตร(). นอกจากนี้ยังต้องมี 2 อาร์กิวเมนต์: เริ่มและ ความยาว.
รายการแรกระบุตำแหน่งเริ่มต้น และรายการที่สองระบุจำนวนอักขระที่จะแยก เพื่อติดตามความแตกต่างระหว่างเครื่องมือทั้งสามนี้ ฉันใช้ตัวอย่างก่อนหน้านี้
var text = "บรรยากาศ";
การแจ้งเตือน (text.substr(2, 5)); // แสดง "mosfe"
เมื่อใช้วิธีการรับสตริงย่อยในรายการ คุณสามารถลบอักขระที่ไม่จำเป็นออกจากองค์ประกอบบรรทัดใหม่ที่โปรแกรมใช้งานได้
ตอบ()
วิธีการนี้ช่วยแทนที่อักขระและสตริงย่อยในข้อความ นอกจากนี้ยังสามารถใช้เพื่อดำเนินการแทนที่ทั่วโลกได้ แต่ในการดำเนินการนี้ คุณจะต้องรวมนิพจน์ทั่วไปด้วย
ตัวอย่างนี้จะแทนที่สตริงย่อยในคำแรกเท่านั้น
var text = "บรรยากาศบรรยากาศ"; var newText = text.replace("Atmo", "Strato") alert(newText) // ผลลัพธ์: บรรยากาศสตราโตสเฟียร์
และในการใช้งานซอฟต์แวร์นี้ เนื่องจากแฟล็กนิพจน์ทั่วไป "g" จะมีการแทนที่ทั่วโลก
var text = "บรรยากาศบรรยากาศ"; var newText = text.replace(/Atmo/g,"Strato") การแจ้งเตือน (newText) // ผลลัพธ์: สตราโตสเฟียร์ สตราโตสเฟียร์
มาทำการแปลงกัน
JavaScript มีการแปลงประเภทออบเจ็กต์เพียงสามประเภทเท่านั้น:
- ตัวเลข;
- สตริง;
- บูลีน
ในสิ่งพิมพ์ปัจจุบันฉันจะพูดถึง 2 เรื่องเนื่องจากความรู้เกี่ยวกับสิ่งเหล่านี้มีความจำเป็นมากกว่าสำหรับการทำงานกับสตริง
การแปลงตัวเลข
หากต้องการแปลงค่าขององค์ประกอบให้เป็นรูปแบบตัวเลขอย่างชัดเจน คุณสามารถใช้ได้ ตัวเลข (ค่า).
นอกจากนี้ยังมีสำนวนที่สั้นกว่า: +"999".
var a = ตัวเลข("999");
การแปลงสตริง
ดำเนินการโดยฟังก์ชัน เตือนตลอดจนการโทรที่ชัดเจน สตริง(ข้อความ).
สวัสดี! ในบทนี้ เราจะมาดูกันว่าคุณสามารถสร้างสตริงและฟังก์ชันสำหรับการทำงานกับสตริงใน JavaScript ได้อย่างไร ตามหลักการแล้ว ใน JavaScript ตัวแปรข้อความใดๆ จะเป็นสตริง เนื่องจาก JavaScript ไม่ใช่ภาษาการเขียนโปรแกรมที่เน้นการพิมพ์อย่างยิ่ง (อ่านเกี่ยวกับประเภทข้อมูล) และเพื่อทำงานกับสตริงจึงใช้คลาส String:
Var name1 = "ทอมมี่";
ดังนั้นให้ใช้ตัวสร้าง String:
Var name1 = สตริงใหม่ ("ทอมมี่");
วิธีแรกส่วนใหญ่จะใช้อาจเป็นเพราะมันสั้นกว่า
คลาส String สำหรับการทำงานกับสตริงมีชุดคุณสมบัติและฟังก์ชันที่ค่อนข้างใหญ่ซึ่งคุณสามารถดำเนินการจัดการต่างๆ ด้วยสตริงได้
ความยาวสาย
คุณสมบัติ length ช่วยให้คุณสามารถกำหนดความยาวของสตริงได้ คุณสมบัตินี้ส่งคืนตัวเลข:
Var hello1 = "สวัสดีชาวโลก"; document.write("ในบรรทัด "" + hello + "" " + hello1.length + " ตัวอักษร");
ค้นหาในสตริง
ในการค้นหาสตริงย่อยบางสตริงในสตริง ฟังก์ชัน indexOf() (ส่งคืนดัชนีของสตริงย่อยที่เกิดขึ้นครั้งแรก) และ LastIndexOf() (ส่งคืนดัชนีของสตริงย่อยที่เกิดขึ้นครั้งล่าสุด) ฟังก์ชันเหล่านี้รับสองอาร์กิวเมนต์:
- สตริงย่อยที่ต้องการค้นหาจริงๆ
- อาร์กิวเมนต์ทางเลือกที่ระบุอักขระที่จะใช้ค้นหาสตริงย่อยในสตริง
ฟังก์ชันทั้งสองนี้ส่งคืนตัวเลข ซึ่งเป็นดัชนีของอักขระที่สตริงย่อยเริ่มต้นในสตริง หากไม่พบสตริงย่อย ตัวเลข -1 จะถูกส่งกลับ ดังนั้นฟังก์ชันเหล่านี้จึงถูกใช้ในตัวดำเนินการเชิงตรรกะ เนื่องจากตามกฎแล้ว คุณเพียงแค่ต้องตรวจสอบว่าสตริงมีสตริงย่อยหรือไม่ จากนั้นในกรณีนี้ ผลลัพธ์ของฟังก์ชันเหล่านี้จะถูกเปรียบเทียบกับ -1
Var str1 = "สวัสดีวาสยา!"; var podstr = "เพชร"; if(str.indexOf(podstr) == -1)( document.write("ไม่พบสตริงย่อย"); ) else ( document.write("พบสตริงย่อย"); )
ในตัวอย่าง ข้อความ “ไม่พบสตริงย่อย” จะปรากฏขึ้น เนื่องจากสตริง “Peter” ไม่มีอยู่ในสตริง “Hello Vasya!”
ฟังก์ชันประกอบด้วย, beginningWith, สิ้นสุดด้วย
วิธีการที่ทันสมัยกว่า str.includes(substr, pos) จะคืนค่าเป็นจริงหากสตริง str มีสตริงย่อยย่อย หรือคืนค่าเป็น false หากไม่มี
นี่เป็นทางเลือกที่เหมาะสมหากเราต้องตรวจสอบว่ามีการแข่งขันหรือไม่ แต่ตำแหน่งนั้นไม่จำเป็น:
Alert("Widget with id".includes("Widget")); // true alert("Hello".includes("Bye")); // เท็จ
อาร์กิวเมนต์ที่สองที่เป็นทางเลือกสำหรับ str.includes ช่วยให้คุณสามารถเริ่มการค้นหาในตำแหน่งที่ต้องการ:
Alert("คนแคระ".รวม("id")); // true alert("Midget".includes("id", 3)); // false การค้นหาเริ่มต้นจากตำแหน่งที่ 3
เมธอด str.startsWith และ str.endsWith จะตรวจสอบตามลำดับว่าสตริงขึ้นต้นและลงท้ายด้วยสตริงที่ระบุหรือไม่:
Alert("Widget".startsWith("Wid")); // จริง "Wid" - จุดเริ่มต้นของ "Widget" alert("Widget".endsWith("get"); // จริง "get" - ลงท้ายด้วย "Widget"
การเลือกสตริงย่อย
ในการตัดสตริงย่อยออกจากสตริง จะใช้ฟังก์ชันต่างๆ เช่น substr() และ substring()
ฟังก์ชั่น substring() รับ 2 อาร์กิวเมนต์:
- ตำแหน่งเริ่มต้นของอักขระในบรรทัด โดยเริ่มจากบรรทัดที่จะตัดออก
- ตำแหน่งสิ้นสุดที่ควรตัดแต่งสตริง
ฟังก์ชัน substr() ยังใช้ดัชนีเริ่มต้นของสตริงย่อยเป็นพารามิเตอร์ที่ 1 และความยาวของสตริงย่อยเป็นพารามิเตอร์ที่ 2:
Var hello1 = "สวัสดีชาวโลก ลาก่อนโลก"; var bye1 = hello1.substr(12, 2); document.write(bye1);//ก่อน
และหากไม่ได้ระบุพารามิเตอร์ตัวที่ 2 บรรทัดจะถูกตัดทอนจนสุด:
Var hello1 = "สวัสดีชาวโลก ลาก่อนโลก"; var bye1 = hello1.substr(12); document.write(บาย1); //ลาก่อนความสงบ
การควบคุมตัวพิมพ์เล็ก
หากต้องการเปลี่ยนตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่ ให้ใช้ฟังก์ชัน toLowerCase() (เพื่อแปลงอักขระเป็นตัวพิมพ์เล็ก กล่าวคือ ตัวอักษรทั้งหมดจะมีขนาดเล็ก) และ toUpperCase() (เพื่อแปลงอักขระเป็น ตัวพิมพ์ใหญ่คือตัวอักษรทั้งหมดจะใหญ่)
Var hello1 = "สวัสดีจิม"; document.write(hello1.toLowerCase() + "
"); //สวัสดี Jim document.write(hello1.toUpperCase() + "
"); //สวัสดีจิม
รับสัญลักษณ์ตามดัชนี
ในการค้นหาอักขระเฉพาะในสตริงตามดัชนี จะใช้ฟังก์ชัน charAt() และ charCodeAt() ฟังก์ชันทั้งสองนี้ใช้ดัชนีอักขระเป็นอาร์กิวเมนต์:
Var hello1 = "สวัสดีจิม"; document.write(hello1.charAt(3) + "
"); //ใน document.write(hello1.charCodeAt(3) + "
"); //1080
แต่หากฟังก์ชัน charAt() ส่งคืนอักขระเองอันเป็นผลมาจากการทำงานเท่านั้น ฟังก์ชัน charCodeAt() จะส่งคืนโค้ด Unicode ที่เป็นตัวเลขของอักขระนี้
การลบช่องว่าง
หากต้องการลบช่องว่างในสตริง ให้ใช้ฟังก์ชัน trim():
Var hello1 = "สวัสดีจิม"; var beforeLen = hello1.length; hello1 = hello1.trim(); var afterLen = hello1.length; document.write("ความยาวบรรทัดสูงสุด: " + beforeLen + "
"); //15 document.write("ความยาวของบรรทัดหลัง: " + afterLen + "
"); //10
การต่อสายอักขระ
ฟังก์ชั่น concat() ช่วยให้คุณสามารถเชื่อม 2 สายเข้าด้วยกัน:
วาร์ hello1 = "สวัสดี"; var world1 = "วาสยา"; hello1 = hello1.concat (world1); document.write(สวัสดี); //สวัสดีวาสยา
การแทนที่สตริงย่อย
ฟังก์ชันแทนที่ () ช่วยให้คุณสามารถแทนที่สตริงย่อยหนึ่งด้วยอีกสตริงหนึ่งได้:
Var hello1 = "สวัสดีตอนบ่าย"; hello1 = hello1.replace("วัน", "เย็น"); เอกสาร. เขียน (hello1); //สวัสดีตอนเย็น
อาร์กิวเมนต์แรกของฟังก์ชันระบุว่าควรแทนที่สตริงย่อยใด และอาร์กิวเมนต์ที่ 2 ระบุว่าควรแทนที่สตริงย่อยใด
การแยกสตริงออกเป็นอาร์เรย์
ฟังก์ชัน split() ช่วยให้คุณสามารถแยกสตริงออกเป็นอาร์เรย์ของสตริงย่อยได้โดยใช้ตัวคั่นเฉพาะ คุณสามารถใช้สตริงที่ส่งผ่านไปยังวิธีการ:
Var mes = "วันนี้อากาศดีมาก"; var stringArr = mes.split(" "); สำหรับ (var str1 ใน stringArr) document.write(stringArr + "
");
การเปรียบเทียบสตริง
นอกจากนี้ เมื่อเปรียบเทียบสตริง คุณควรคำนึงถึงตัวพิมพ์เล็กด้วย ตัวพิมพ์ใหญ่มีขนาดเล็กกว่าตัวอักษรตัวเล็ก และตัวอักษร e อยู่นอกตัวอักษรโดยทั่วไป
งาน
การเปลี่ยนตัวพิมพ์ของตัวอักษรตัวสุดท้ายในสตริง
เขียนฟังก์ชัน LastLetterStr(str) ที่จะเปลี่ยนตัวพิมพ์ของตัวอักษรตัวสุดท้ายให้กลายเป็นตัวพิมพ์ใหญ่
ตรวจสอบสแปม
เขียนฟังก์ชัน provSpam(str) ที่จะตรวจสอบสตริงว่ามีสตริงย่อยอยู่หรือไม่: “spam”, “sex”, “xxx” และส่งคืนค่าจริงหากมีข้อมูลสตริงย่อย และคืนค่าเป็นเท็จเป็นอย่างอื่น
ค้นหาหมายเลข
เขียนฟังก์ชัน extrNum(str) ที่จะรับตัวเลขจากสตริง หากสตริงมีตัวเลข และฟังก์ชัน number ควรส่งคืน ตัวอย่างเช่น มีบรรทัด "120 UAH" ที่ต้องส่งคืนจากบรรทัด 120
และเพื่อเน้นย้ำสิ่งนี้ โปรดดูวิดีโอเกี่ยวกับการทำงานกับสตริงใน JavaScript