คำนิยาม
สตริงเป็นศูนย์หรือมากกว่าอักขระที่จัดเรียงกันวางในราคาเดียวหรือสองเท่า
'ABC' "ABC"คำพูดสองเท่าสามารถใช้ภายในสตริงใบเสนอราคาเดียว ภายในสตริงใบเสนอราคาสองเท่าสามารถใช้คำพูดเดียวได้
'key = "value"' "มันเป็นการเดินทางที่ยาวนาน"
ทั้งสองข้างต้นเป็นสายกฎหมาย
หากคุณต้องการใช้ใบเสนอราคาเดียวภายในสตริงใบเสนอราคาเดียว (หรือคำพูดสองเท่าภายในสตริงคำพูดสองครั้ง) คุณต้องนำหน้าคำพูดเดียว (หรือคำพูดสองครั้ง) ภายในเพื่อหลบหนี
'เธอพูดว่า/' สวัสดี/'?' // "เธอพูดว่า 'สวัสดี' หรือไม่" "เธอพูดว่า/" สวัสดี/"?" // "เธอพูดว่า" สวัสดี "?
เนื่องจากค่าแอตทริบิวต์ของภาษา HTML ใช้คำพูดสองเท่าหลายโครงการยอมรับว่าสตริงภาษา JavaScript ใช้คำพูดเดียวเท่านั้นและบทช่วยสอนนี้เป็นไปตามการประชุมนี้ แน่นอนว่ามันเหมาะที่จะใช้คำพูดสองครั้งเท่านั้น มันเป็นสิ่งสำคัญที่จะยึดติดกับสไตล์เดียวและไม่ผสมทั้งสองสไตล์
โดยค่าเริ่มต้นสตริงสามารถเขียนได้ในบรรทัดเดียวเท่านั้นและหากพวกเขาถูกแบ่งออกเป็นหลายบรรทัดพวกเขาจะรายงานข้อผิดพลาด
'abc' // syntaxerror: โทเค็นที่ไม่คาดคิดผิดกฎหมาย
รหัสข้างต้นแบ่งสตริงออกเป็นสามบรรทัดและ JavaScript จะรายงานข้อผิดพลาด
หากต้องแบ่งสตริงยาวออกเป็นหลายบรรทัดสามารถใช้แบ็คสแลชในตอนท้ายของแต่ละบรรทัด
var longstring = "ยาว /ยาว /ยาว /สตริง"; longstring // "สตริงยาวยาวยาว"
รหัสด้านบนแสดงให้เห็นว่าหลังจากเพิ่ม backslash สตริงที่เขียนไว้ในบรรทัดเดียวสามารถแบ่งออกเป็นหลายบรรทัดของการเขียน อย่างไรก็ตามเมื่อเอาท์พุทเอฟเฟกต์ยังคงเป็นบรรทัดเดียวและเอฟเฟกต์ก็เหมือนกับการเขียนในบรรทัดเดียวกัน โปรดทราบว่า backslash จะต้องตามด้วยอักขระใหม่และจะต้องไม่มีอักขระอื่น (เช่นช่องว่าง) มิฉะนั้นจะมีการรายงานข้อผิดพลาด
ตัวดำเนินการ concatenation (+) สามารถเชื่อมโยงสตริงบรรทัดเดียวหลายสายแยกสตริงยาวเป็นหลายบรรทัดเพื่อเขียนและมันก็เป็นบรรทัดเดียวเมื่อเอาต์พุต
var longstring = 'long' + 'ยาว' + 'ยาว' + 'สตริง';
หากคุณต้องการส่งออกสตริงหลายบรรทัดมีวิธีแก้ปัญหาที่จะใช้ความคิดเห็นหลายบรรทัด
(function () {/*line 1line 2line 3*/}). toString (). split ('/n'). slice (1, -1) .oin ('/n') // "บรรทัด 1 // บรรทัด 2 // บรรทัด 3"ในตัวอย่างข้างต้นสตริงเอาต์พุตเป็นหลายบรรทัด
หนี
Backslash (/) มีความหมายพิเศษในสตริงและใช้เพื่อแสดงถึงตัวละครพิเศษบางตัวดังนั้นจึงเรียกว่าตัวละครหลบหนี
ตัวละครพิเศษที่ต้องหลบหนีด้วยแบ็คสแลชเป็นส่วนใหญ่ดังนี้:
อักขระข้างต้นนำหน้าด้วยแบ็คสแลชซึ่งทั้งหมดเป็นตัวแทนความหมายพิเศษ
console.log ('1/n2') // 1 // 2ในรหัสข้างต้น /n หมายถึงบรรทัดใหม่และแบ่งออกเป็นสองบรรทัดเมื่อเอาท์พุท
มีการใช้งานพิเศษสามครั้งสำหรับแบ็คสแลช
(1)/HHHH
backslash ตามด้วยตัวเลขแปดแปด (000 ถึง 377) ซึ่งเป็นตัวแทนของตัวละคร HHH สอดคล้องกับจุดรหัส Unicode ของอักขระที่เกี่ยวข้องเช่น /251 แสดงถึงสัญลักษณ์ลิขสิทธิ์ เห็นได้ชัดว่าวิธีนี้สามารถส่งออก 256 อักขระเท่านั้น
(2)/xhh
/x ตามด้วยตัวเลขหกสิบหก (00 ถึง FF) ซึ่งเป็นตัวแทนของตัวละคร HH สอดคล้องกับจุดรหัส Unicode ของอักขระเช่น /xa9 แสดงถึงสัญลักษณ์ลิขสิทธิ์ วิธีนี้สามารถส่งออก 256 อักขระเท่านั้น
(3)/uxxxxx
/u ตามด้วยสี่เลขฐานสิบหก (0000 ถึง FFFFF) ซึ่งเป็นตัวแทนของตัวละคร HHHHH สอดคล้องกับจุดรหัส Unicode ของอักขระเช่น /U00A9 แสดงถึงสัญลักษณ์ลิขสิทธิ์
ด้านล่างนี้เป็นตัวอย่างของตัวละครพิเศษทั้งสามนี้ที่เขียนโดยละเอียด
'/251' // "©" '/xa9' // "©" '/u00a9' // "©"/172 '===' z '// true'/x7a '===' z '// true'/u007a '
หากใช้แบ็คสแลชก่อนที่จะมีตัวละครที่ไม่ใช่พิเศษ
'/a' // "a"
ในรหัสข้างต้น A เป็นอักขระปกติและไม่มีความหมายพิเศษในการเพิ่มแบ็คสแลชก่อนหน้านี้และ backslash จะถูกละเว้นโดยอัตโนมัติ
หากจำเป็นต้องรวมแบ็คสแลชไว้ในเนื้อหาปกติของสตริงแล้วจะต้องเพิ่มแบ็กสแลชอื่นก่อนที่แบ็คสแลชจะหลบหนี
"prev // next" // "prev/ next"
สตริงและอาร์เรย์
สตริงสามารถถือว่าเป็นอาร์เรย์อักขระดังนั้นตัวยึดวงเล็บสี่เหลี่ยมของอาร์เรย์สามารถใช้เพื่อส่งคืนอักขระในตำแหน่งที่แน่นอน (หมายเลขตำแหน่งเริ่มต้นที่ 0)
var s = 'hello'; s [0] // "h" s [1] // "e" s [4] // "o" // ใช้ตัวดำเนินการวงเล็บตาราง 'Hello' [1] // "E"
หากตัวเลขในวงเล็บเหลี่ยมเกินความยาวของสตริงหรือหากหมายเลขในวงเล็บเหลี่ยมไม่ได้ถูกส่งกลับมาจะถูกส่งคืน
'abc' [3] // undefined'abc '[-1] // undefined'abc' ['x'] // undefined
อย่างไรก็ตามนั่นคือทั้งหมดที่เกี่ยวกับความคล้ายคลึงกันระหว่างสตริงและอาร์เรย์ ในความเป็นจริงมันเป็นไปไม่ได้ที่จะเปลี่ยนอักขระตัวเดียวในสตริง
var s = 'hello'; ลบ s [0]; s // "hello" s [1] = 'a'; s // "hello" s [5] = '!'; s // "สวัสดี"
รหัสข้างต้นระบุว่าอักขระแต่ละตัวในสตริงไม่สามารถเปลี่ยนแปลงหรือเพิ่มหรือลบได้และการดำเนินการเหล่านี้จะล้มเหลวอย่างเงียบ ๆ
เหตุผลที่สตริงมีความคล้ายคลึงกับอาร์เรย์อักขระเป็นจริงเพราะเมื่อทำการทำงานของวงเล็บเหลี่ยมบนสตริงสตริงจะถูกแปลงเป็นวัตถุสตริงโดยอัตโนมัติ
คุณลักษณะความยาว
แอตทริบิวต์ความยาวส่งคืนความยาวของสตริงซึ่งไม่สามารถเปลี่ยนแปลงได้
var s = 'hello'; s.length // 5s.length = 3; s.length // 5s.length = 7; s.length // 5
รหัสข้างต้นระบุว่าแอตทริบิวต์ความยาวของสตริงไม่สามารถเปลี่ยนแปลงได้ แต่จะไม่มีข้อผิดพลาด
ชุดอักขระ
JavaScript ใช้ชุดอักขระ Unicode ซึ่งหมายความว่าภายใน JavaScript อักขระทั้งหมดจะถูกแสดงโดย Unicode
JavaScript ไม่เพียง แต่ใช้ Unicode เพื่อจัดเก็บอักขระภายในเท่านั้น แต่ยังสามารถใช้ Unicode ได้โดยตรงในโปรแกรม อักขระทั้งหมดสามารถเขียนในรูปแบบของ "/uxxxx" โดยที่ xxxx แสดงถึงการเข้ารหัส Unicode ของอักขระ ตัวอย่างเช่น /U00A9 แสดงถึงสัญลักษณ์ลิขสิทธิ์
var s = '/u00a9'; s // "©"
ตัวละครแต่ละตัวจะถูกเก็บไว้ในรูปแบบ 16 บิต (เช่น 2 ไบต์) รูปแบบ UTF-16 ภายใน JavaScript กล่าวคือความยาวอักขระของหน่วยของ JavaScript ได้รับการแก้ไขถึงความยาว 16 บิตนั่นคือ 2 ไบต์
อย่างไรก็ตาม UTF-16 มีความยาวสองความยาว: สำหรับอักขระระหว่าง U+0000 และ U+FFFF ความยาวคือ 16 บิต (เช่น 2 ไบต์); สำหรับอักขระระหว่าง U+10,000 และ U+10FFFF ความยาวคือ 32 บิต (เช่น 4 ไบต์) และสองไบต์แรกอยู่ระหว่าง 0xD800 ถึง 0xDBFF และสองไบต์สุดท้ายอยู่ระหว่าง 0xDC00 และ 0xDFFF ตัวอย่างเช่นอักขระที่สอดคล้องกันของ U+1D306 คือ?และเขียนเป็น UTF-16 ซึ่งเป็น 0xd834 0xdf06 เบราว์เซอร์จะจดจำทั้งสี่ไบต์เหล่านี้อย่างถูกต้องเป็นตัวละครตัวหนึ่ง แต่ความยาวของตัวละครภายในจาวาสคริปต์จะถูกกำหนดไว้ที่ 16 บิตเสมอและสี่ไบต์เหล่านี้จะถือว่าเป็นตัวละครสองตัว
var s = '/ud834/udf06'; s // "?" s.length // 2 /^.$/. ทดสอบ (s) // falseses.charat (0) // "" S.Charat (1) // "" S.Charcodeat (0) // 55348S.CHARCODEAT
รหัสด้านบนแสดงให้เห็นว่าสำหรับอักขระระหว่าง U+10,000 และ U+10FFFF JavaScript จะถือว่าเป็นอักขระสองตัวเสมอ (แอตทริบิวต์ความยาวของอักขระคือ 2) นิพจน์ทั่วไปที่ใช้จับคู่อักขระตัวเดียวจะล้มเหลว (JavaScript เชื่อว่ามีอักขระมากกว่าหนึ่งตัวที่นี่) วิธีการ Charat ไม่สามารถส่งคืนอักขระเดียวและวิธีการ charcodeat ส่งคืนค่าทศนิยมที่สอดคล้องกับแต่ละไบต์
ดังนั้นเมื่อจัดการกับสิ่งนี้จะต้องนำมาพิจารณา สำหรับอักขระ Unicode 4 ไบต์โดยสมมติว่า C คือหมายเลข Unicode ของตัวละคร H เป็นสองไบต์แรกและ L เป็นสองไบต์สุดท้ายความสัมพันธ์ระหว่างการแปลงระหว่างพวกเขามีดังนี้
// แปลงอักขระที่มีขนาดใหญ่กว่า U + FFFFFF จาก Unicode เป็น UTF -16H = Math.Floor ((C - 0x10000)/ 0x400) + 0xd800l = (C - 0x10000) % 0x400 + 0xDC00 // แปลงอักขระที่ใหญ่กว่า U + FFFFF + 0x10000
นิพจน์ทั่วไปต่อไปนี้สามารถรับรู้อักขระ UTF-16 ทั้งหมด
([/0-/UD7FF/UE000-/UFFF] | [/UD800-/UDBFF] [/UDC00-/UDFF]))
เนื่องจากเอ็นจิ้น JavaScript (การพูดอย่างเคร่งครัดข้อกำหนด ES5) ไม่สามารถรับรู้อักขระ Unicode ของระนาบเสริมโดยอัตโนมัติ (หมายเลขมากกว่า 0xFFFF) ฟังก์ชั่นการประมวลผลสตริงทั้งหมดจะให้ผลลัพธ์ที่ไม่ถูกต้องเมื่อพบอักขระดังกล่าว หากคุณต้องการดำเนินการที่เกี่ยวข้องกับสตริงคุณต้องพิจารณาว่าอักขระอยู่ในช่วง 0xd800 ถึง 0xdfff
ด้านล่างเป็นฟังก์ชั่นที่สามารถจัดการกับการสำรวจสตริงได้อย่างถูกต้อง
ฟังก์ชั่น getSymbols (สตริง) {var length = string.length; ดัชนี var = -1; var output = []; อักขระ var; var charcode; ในขณะที่ (++ ดัชนี <ความยาว) {อักขระ = string.charat (ดัชนี); charcode = character.charcodeat (0); if (charcode> = 0xd800 && charcode <= 0xdbff) {output.push (อักขระ+string.charat (++ ดัชนี)); } else {output.push (อักขระ); }} return output;} var symbols = getSymbols ('?'); symbols.foreach (ฟังก์ชั่น (สัญลักษณ์) {// ... });การดำเนินการสตริงอื่น ๆ เช่นการแทนที่ (string.prototype.replace), การสกัดกั้น substring (string.prototype.substring, string.prototype.slice) จะต้องได้รับการจัดการในทำนองเดียวกัน
Base64 Transcoding
Base64 เป็นวิธีการเข้ารหัสที่สามารถแปลงอักขระใด ๆ เป็นอักขระที่พิมพ์ได้ วิธีการเข้ารหัสนี้ส่วนใหญ่จะไม่ใช้เพื่อเข้ารหัส แต่เพื่อหลีกเลี่ยงอักขระพิเศษและทำให้การประมวลผลของโปรแกรมง่ายขึ้น
JavaScript Natively ให้วิธีการที่เกี่ยวข้องกับ BASE64 สองวิธี
var string = 'Hello World!'; btoa (String) // "SGVSBG8GV29YBGQH" ATOB ('SGVSBG8GV29YBGQH') // "Hello World!" สองวิธีนี้ไม่เหมาะสำหรับอักขระที่ไม่ใช่ ASCII และจะรายงานข้อผิดพลาด btoa ('hello') // domexception ที่ไม่ได้รับการตรวจสอบ: สตริงที่จะเข้ารหัสมีตัวละครนอกช่วง LATIN1 ในการแปลงอักขระที่ไม่ใช่ ASCII เป็นการเข้ารหัส Base64 จะต้องแทรกลิงค์การแปลงรหัสไว้ตรงกลางแล้วใช้วิธีทั้งสองนี้ ฟังก์ชั่น b64encode (str) {return btoa (encodeuricomponent (str));} ฟังก์ชั่น b64decode (str) {return decodeuricomponent (atob (str));} b64encode ('hello') // "juu0jujejuewjuu1jue1juje" b64decode ('juu0jujejuewjuu1jue1juje') // "สวัสดี"