นี่คือคำสั่ง perlunicode ที่สามารถเรียกใช้ในผู้ให้บริการโฮสต์ฟรีของ OnWorks โดยใช้หนึ่งในเวิร์กสเตชันออนไลน์ฟรีของเรา เช่น Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS
โครงการ:
ชื่อ
perlunicode - รองรับ Unicode ใน Perl
DESCRIPTION
ถ้ายังไม่มี ก่อนอ่านเอกสารนี้ ควรทำความคุ้นเคยกับทั้งสองอย่างก่อน
perlunitut และ perluniintro
Unicode มีจุดมุ่งหมายเพื่อ UNI-fy en-รหัส-ings ของตัวละครทั้งหมดของโลกที่ตั้งค่าเป็นเดียว
มาตรฐาน. สำหรับมาตรฐานการเข้ารหัสต่างๆ ที่มีอยู่เมื่อ Unicode เป็น
สร้างขึ้นครั้งแรก การแปลงจากแต่ละอันเป็น Unicode หมายถึงการเพิ่มค่าคงที่ให้กับแต่ละ
รหัสชี้ไปที่มาตรฐานเดิมและการแปลงกลับหมายถึงการลบแบบเดียวกัน
คงที่. สำหรับ ASCII และ ISO-8859-1 ค่าคงที่คือ 0 สำหรับ ISO-8859-5 (ซีริลลิก)
ค่าคงที่ 864; สำหรับภาษาฮีบรู (ISO-8859-8) คือ 1488; ไทย (ISO-8859-11), 3424; แล้วก็
ออกมา ทำให้ง่ายต่อการแปลงและอำนวยความสะดวกในการนำ Unicode ไปใช้
และมันก็ได้ผล ทุกวันนี้ มาตรฐานดั้งเดิมเหล่านั้นไม่ค่อยได้ใช้ คนส่วนใหญ่ใช้
Unicode
Unicode เป็นมาตรฐานที่ครอบคลุม มันระบุหลายสิ่งหลายอย่างนอกขอบเขตของ Perl
เช่น วิธีการแสดงลำดับตัวอักษร สำหรับการอภิปรายเต็มรูปแบบของทุกแง่มุมของ
Unicode ดูhttp://www.unicode.org>.
สำคัญ คำเตือน
แม้ว่าบางส่วนของส่วนนี้อาจไม่เข้าใจคุณในการอ่านครั้งแรก แต่เรา
คิดว่ามันสำคัญพอที่จะเน้นที่ gotchas บางส่วนก่อนที่จะเจาะลึกเพิ่มเติมดังนั้น
นี่ไป:
การสนับสนุน Unicode เป็นข้อกำหนดที่กว้างขวาง ในขณะที่ Perl ไม่ได้ใช้ Unicode
มาตรฐานหรือรายงานทางเทคนิคที่มาพร้อมกับปก Perl รองรับจำนวนมาก
คุณสมบัติ Unicode
นอกจากนี้ การใช้ Unicode อาจนำเสนอปัญหาด้านความปลอดภัยที่ไม่ชัดเจน อ่าน Unicode
ข้อควรพิจารณาด้านความปลอดภัยhttp://www.unicode.org/reports/tr36>.
ปลอดภัยที่สุดหากคุณ "ใช้คุณลักษณะ 'unicode_strings'"
เพื่อรักษาความเข้ากันได้แบบย้อนหลัง Perl จะไม่เปิดภายในแบบเต็ม
รองรับ Unicode เว้นแต่ว่า Pragma "ใช้คุณสมบัติ 'unicode_strings'" ระบุไว้ (นี้
จะถูกเลือกโดยอัตโนมัติหากคุณ "ใช้ 5.012" หรือสูงกว่า) หากไม่สามารถทำได้
ก่อให้เกิดความประหลาดใจที่คาดไม่ถึง ดู "ข้อผิดพลาด Unicode" ด้านล่าง
Pragma นี้ไม่มีผลกับ I/O และไม่เปลี่ยนการเป็นตัวแทนภายในของ
เฉพาะการตีความเท่านั้น ยังมีอีกหลายที่ที่ Unicode
ไม่รองรับอย่างสมบูรณ์ เช่น ในชื่อไฟล์
ชั้นอินพุตและเอาต์พุต
ใช้เลเยอร์ ":encoding(...)" เพื่ออ่านและเขียนไปยังไฟล์จัดการโดยใช้
การเข้ารหัสที่ระบุ (ดูเปิด.)
คุณควรแปลงสคริปต์ Perl ที่ไม่ใช่ ASCII และไม่ใช่ UTF-8 เป็น UTF-8
ดูการเข้ารหัส
ยังต้องใช้ "use utf8" เพื่อเปิดใช้งาน UTF-8 ในสคริปต์
หากสคริปต์ Perl ของคุณเข้ารหัสด้วยตัวมันเองใน UTF-8 Pragma "use utf8" จะต้องเป็น
รวมไว้อย่างชัดเจนเพื่อให้สามารถจดจำสิ่งนั้นได้ (ในสตริงหรือนิพจน์ทั่วไป
ตัวอักษรหรือในชื่อตัวระบุ) สัมผัส is เพียง เวลา เมื่อ an ชัดเจน "ใช้ utf8"
is จำเป็น (ดู utf8).
ตรวจพบสคริปต์ที่ทำเครื่องหมาย "BOM" และสคริปต์ UTF-16 โดยอัตโนมัติ
อย่างไรก็ตาม หากสคริปต์ Perl ขึ้นต้นด้วย Unicode "BOM" (UTF-16LE, UTF16-BE หรือ
UTF-8) หรือหากสคริปต์ดูเหมือนไม่ใช่ "BOM" ที่มีเครื่องหมาย UTF-16 ของ endianness อย่างใดอย่างหนึ่ง Perl
จะอ่านในสคริปต์อย่างถูกต้องว่าเป็นการเข้ารหัส Unicode ที่เหมาะสม ("BOM"-น้อยกว่า
UTF-8 ไม่สามารถรับรู้หรือแยกความแตกต่างจาก ISO 8859-1 หรืออื่นๆ ได้อย่างมีประสิทธิผล
การเข้ารหัสแปดบิต)
byte และ คาแรคเตอร์ อรรถศาสตร์
ก่อน Unicode การเข้ารหัสส่วนใหญ่ใช้ 8 บิต (ไบต์เดียว) ในการเข้ารหัสอักขระแต่ละตัว ดังนั้น
อักขระเป็นไบต์ และไบต์เป็นอักขระ และอาจมีเพียง 256 หรือน้อยกว่า
อักขระที่เป็นไปได้ "Byte Semantics" ในชื่อของหัวข้อนี้หมายถึงสิ่งนี้
พฤติกรรม. ไม่จำเป็นต้องแยกความแตกต่างระหว่าง "Byte" และ "Character"
จากนั้นมา Unicode ซึ่งมีที่ว่างมากกว่าหนึ่งล้านอักขระ (และ Perl ช่วยให้
มากไปกว่านั้น). ซึ่งหมายความว่าอักขระอาจต้องใช้มากกว่าหนึ่งไบต์เพื่อเป็นตัวแทน
มันและสองคำนี้ไม่เท่ากันอีกต่อไป ตัวละครมีความสำคัญเช่นไร
เอนทิตีทั้งหมด และโดยทั่วไปไม่ใช่ไบต์ที่ประกอบด้วย นั่นคือสิ่งที่เรียกว่า
“ความหมายตัวอักษร” ในหัวข้อนี้หมายถึง
Perl ต้องเปลี่ยนภายในเพื่อแยก "ไบต์" ออกจาก "อักขระ" เป็นสิ่งสำคัญที่
คุณก็เปลี่ยนความคิดของคุณเช่นกัน ถ้าคุณยังไม่ได้เปลี่ยน ดังนั้น "ไบต์" และ "อักขระ" ไม่ใช่
มีความหมายเดียวกันในใจคุณอีกต่อไป
การสร้างพื้นฐานของสตริง Perl นั้นเป็น "ตัวละคร" เสมอ การเปลี่ยนแปลง
โดยพื้นฐานแล้วการนำไปใช้นั้นไม่คิดว่าตัวละครอยู่เสมอ
เพียงไบต์เดียว
มีหลายสิ่งที่ควรทราบ:
· ฟังก์ชันการจัดการสตริง ส่วนใหญ่ ยังคงทำงานในแง่ของ
ตัวอักษร ตัวอย่างเช่น "length()" ส่งกลับจำนวนอักขระในสตริง
เหมือนเมื่อก่อน แต่จำนวนนั้นไม่จำเป็นต้องเหมือนกับจำนวน .อีกต่อไป
ไบต์ในสตริง (อาจมีไบต์มากกว่าอักขระ) อื่นๆเช่น
ฟังก์ชันต่างๆ ได้แก่ "chop()", "chomp()", "substr()", "pos()", "index()", "rindex()",
"sort()", "sprintf()" และ "write()"
ข้อยกเว้นคือ:
· "vec" เชิงบิต
· รูปแบบ "pack"/"unpack" "C" แบบไบต์
อย่างไรก็ตาม ตัวระบุ "W" ทำงานกับอักขระทั้งหมด เช่นเดียวกับตัว "U"
ตัวระบุ
· โอเปอเรเตอร์บางตัวที่โต้ตอบกับระบบปฏิบัติการของแพลตฟอร์ม
ตัวดำเนินการที่เกี่ยวข้องกับชื่อไฟล์เป็นตัวอย่าง
· เมื่อฟังก์ชันถูกเรียกจากภายในขอบเขตของ "use bytes" Pragma
เป็นไปได้ว่าคุณควรใช้สิ่งนี้เพื่อแก้ไขจุดบกพร่องเท่านั้น
· สตริง - รวมถึงคีย์แฮช - และรูปแบบนิพจน์ทั่วไปอาจมีอักขระ
ที่มีค่าลำดับที่มากกว่า 255
หากคุณใช้ตัวแก้ไข Unicode เพื่อแก้ไขโปรแกรมของคุณ อักขระ Unicode อาจเกิดขึ้น
ภายในสตริงตามตัวอักษรในการเข้ารหัส UTF-8 หรือ UTF-16 โดยตรง (อดีต
ต้องการ "BOM" หรือ "use utf8" ส่วนหลังต้องการ "BOM")
"การสร้าง Unicode" ใน perluniintro ให้วิธีอื่นในการวางอักขระที่ไม่ใช่ ASCII ใน
สตริงของคุณ
· ฟังก์ชัน "chr()" และ "ord()" ใช้ได้กับอักขระทั้งหมด
· นิพจน์ทั่วไปจับคู่อักขระทั้งหมด ตัวอย่างเช่น, "." ตรงกันทั้งหมด
อักขระแทนที่จะเป็นเพียงไบต์เดียว
· ตัวดำเนินการ "tr///" แปลอักขระทั้งหมด (โปรดทราบว่า "tr///CU"
ฟังก์ชั่นถูกลบออก สำหรับฟังก์ชันที่คล้ายกัน โปรดดูที่ "pack('U0'
...)" และ "pack('C0', ...)")
· "scalar reverse()" ย้อนกลับด้วยอักขระแทนที่จะเป็นไบต์
· ตัวดำเนินการสตริงบิต "& | ^ ~" และ (เริ่มต้นใน v5.22) "&. |. ^. ~" สามารถทำงานได้
กับอักขระที่ไม่พอดีกับไบต์ อย่างไรก็ตาม พฤติกรรมปัจจุบันมีแนวโน้มที่จะ
เปลี่ยน. คุณไม่ควรใช้โอเปอเรเตอร์เหล่านี้กับสตริงที่เข้ารหัสใน UTF-8 ถ้า
คุณไม่แน่ใจเกี่ยวกับการเข้ารหัสของสตริง ดาวน์เกรดก่อนที่จะใช้สิ่งเหล่านี้
ผู้ประกอบการ; คุณสามารถใช้ "utf8::utf8_downgrade()"
สิ่งสำคัญที่สุดคือ Perl ได้ฝึกฝน "ความหมายของอักขระ" อยู่เสมอ แต่ด้วย
การถือกำเนิดของ Unicode ซึ่งตอนนี้แตกต่างจาก "Byte Semantics"
ASCII กฎระเบียบ กับ Unicode กฎระเบียบ
ก่อน Unicode เมื่ออักขระเป็นไบต์เป็นอักขระ Perl รู้เพียง 128
อักขระที่กำหนดโดย ASCII รหัสชี้ 0 ถึง 127 (ยกเว้นภายใต้ "ใช้สถานที่")
ที่เหลือรหัสชี้ 128 ถึง 255 เป็น unassigned และพร้อมใช้งานสำหรับสิ่งที่ใช้
โปรแกรมอาจต้องการ ความหมายเดียวที่พวกเขามีคือเลขลำดับและพวกมัน
เป็นสมาชิกของคลาสอักขระที่ไม่ใช่ค่าลบ ไม่มีถือว่าเข้าคู่กัน
ตัวอย่างเช่น "\w" แต่ทั้งหมดตรงกับ "\W"
แน่นอนว่า Unicode กำหนดรหัสแต่ละจุดให้มีความหมายเฉพาะ (พร้อมกับ
ที่สูงกว่า 255) เพื่อรักษาความเข้ากันได้แบบย้อนหลัง Perl ใช้ความหมาย Unicode เท่านั้น
เมื่อมีข้อบ่งชี้ว่า Unicode เป็นสิ่งที่ตั้งใจไว้ มิฉะนั้นจะไม่ใช่ ASCII
จุดรหัสยังคงถือว่าไม่มีการกำหนด
ต่อไปนี้คือวิธีที่ Perl รู้ว่าสตริงควรถือเป็น Unicode:
· ภายในขอบเขตของ "use utf8"
หากโปรแกรมทั้งหมดเป็น Unicode (ระบุโดยใช้ 8-bit Uนิโคด Tการแปลงร่าง
Format) ดังนั้นสตริงทั้งหมดภายในจะต้องเป็น Unicode
· ภายในขอบเขตของ "ใช้คุณลักษณะ 'unicode_strings'"
Pragma นี้ถูกสร้างขึ้นเพื่อให้คุณสามารถบอก Perl ได้อย่างชัดเจนว่าการดำเนินการดำเนินการ
ภายในขอบเขตคือการใช้กฎ Unicode การดำเนินการเพิ่มเติมได้รับผลกระทบจากที่ใหม่กว่า
เพิร์ล ดู "ข้อผิดพลาด Unicode""
· ภายในขอบเขตของ "use 5.012" หรือสูงกว่า
สิ่งนี้เปิดโดยปริยาย "ใช้คุณลักษณะ 'unicode_strings'"
· ภายในขอบเขตของ "use locale 'not_characters'" หรือ "use locale" และปัจจุบัน
โลแคลเป็นโลแคล UTF-8
อดีตถูกกำหนดเพื่อบ่งบอกถึงการจัดการ Unicode; และอันหลังระบุ Unicode
locale ดังนั้นการตีความ Unicode ของสตริงทั้งหมดภายในนั้น
· เมื่อสตริงมีจุดโค้ดแบบ Unicode เท่านั้น
Perl ไม่เคยยอมรับจุดโค้ดที่สูงกว่า 255 โดยที่พวกเขาไม่เป็น Unicode ดังนั้นการใช้งานของพวกเขา
หมายถึง Unicode สำหรับสตริงทั้งหมด
· เมื่อสตริงมี Unicode ชื่อจุดโค้ด "\N{...}"
โครงสร้าง "\N{...}" อ้างอิงถึงจุดโค้ด Unicode อย่างชัดเจน แม้ว่าจะเป็นหนึ่ง
ที่อยู่ใน ASCII ด้วย ดังนั้นสตริงที่ประกอบด้วยจะต้องเป็น Unicode
· เมื่อสตริงมาจากแหล่งภายนอกที่ทำเครื่องหมายเป็น Unicode
ตัวเลือกบรรทัดคำสั่ง "-C" สามารถระบุได้ว่าอินพุตบางอย่างของโปรแกรมคือ
Unicode และค่าของสิ่งนี้สามารถอ่านได้ด้วยรหัส Perl ของคุณ โปรดดู "${^UNICODE}" ใน
เพิร์ลวาร์
· เมื่ออัพเกรดสตริงเป็น UTF-8
ฟังก์ชัน "utf8::utf8_upgrade()" สามารถใช้อย่างถาวรได้ (เว้นแต่
ต่อมา "utf8::utf8_downgrade()" ถูกเรียก) ทำให้สตริงได้รับการปฏิบัติเหมือน
Unicode
· มีวิธีการเพิ่มเติมสำหรับรูปแบบนิพจน์ทั่วไป
รูปแบบที่คอมไพล์ด้วยตัวปรับแต่ง "/u" หรือ "/a" จะถือเป็น Unicode
(แม้ว่าจะมีข้อจำกัดบางประการเกี่ยวกับ "/a") ภายใต้ตัวแก้ไข "/d" และ "/l"
มีข้อบ่งชี้อื่นๆ อีกหลายประการสำหรับ Unicode ดู "ตัวแก้ไขชุดอักขระ" ใน
เพิร์ล
โปรดทราบว่าสิ่งที่กล่าวมาทั้งหมดจะถูกแทนที่ภายในขอบเขตของ "use bytes"; แต่คุณควร
ใช้ Pragma นี้เพื่อแก้จุดบกพร่องเท่านั้น
โปรดทราบด้วยว่าการโต้ตอบบางอย่างกับระบบปฏิบัติการของแพลตฟอร์มไม่เคยใช้ Unicode
กฎระเบียบ
เมื่อกฎ Unicode มีผลบังคับใช้:
· ตัวดำเนินการแปลกรณีใช้ตารางการแปลกรณี Unicode
โปรดทราบว่า "uc()" หรือ "\U" ในสตริงที่มีการสอดแทรก จะแปลเป็นตัวพิมพ์ใหญ่ในขณะที่
"ucfirst" หรือ "\u" ในสตริงที่มีการสอดแทรก แปลเป็น titlecase ในภาษาที่
สร้างความแตกต่าง (ซึ่งเทียบเท่ากับตัวพิมพ์ใหญ่ในภาษาที่ไม่มี
ความแตกต่าง)
มีโมดูล CPAN "Unicode::Casing" ซึ่งช่วยให้คุณกำหนดของคุณเองได้
การแมปที่จะใช้ใน "lc()", "lcfirst()", "uc()", "ucfirst()" และ "fc" (หรือของพวกเขา
เวอร์ชันอินไลน์สตริงที่มีเครื่องหมายอัญประกาศคู่ เช่น "\U") (ก่อน Perl 5.16 นี้
ฟังก์ชันการทำงานมีให้บางส่วนในแกน Perl แต่ได้รับความทุกข์ทรมานจากจำนวน
ข้อเสียที่ผ่านไม่ได้ ดังนั้นจึงเขียนโมดูล CPAN แทน)
· คลาสอักขระในนิพจน์ทั่วไปจับคู่ตามคุณสมบัติของอักขระ
ระบุไว้ในฐานข้อมูลคุณสมบัติ Unicode
"\w" สามารถใช้จับคู่สำนวนญี่ปุ่นได้ เช่น และ "[[:digit:]]" a
หมายเลขเบงกาลี
· อาจใช้คุณสมบัติ Unicode ที่มีชื่อ สคริปต์ และช่วงบล็อก (เช่น วงเล็บ
คลาสอักขระ) โดยใช้โครงสร้าง "\p{}" "จับคู่คุณสมบัติ" และ "\P{}"
ปฏิเสธ "ไม่ตรงกับคุณสมบัติ"
ดู "คุณสมบัติอักขระ Unicode" สำหรับรายละเอียดเพิ่มเติม
คุณสามารถกำหนดคุณสมบัติอักขระของคุณเองและใช้ในนิพจน์ทั่วไปได้
ด้วยโครงสร้าง "\p{}" หรือ "\P{}" ดู "คุณสมบัติอักขระที่กำหนดโดยผู้ใช้" สำหรับข้อมูลเพิ่มเติม
รายละเอียด
ขยาย อักษร เครือข่ายวิสาหกิจ (ตรรกะ ตัวอักษร)
พิจารณาตัวละคร พูดว่า "H" อาจปรากฏขึ้นพร้อมกับเครื่องหมายต่างๆ เช่น an
สำเนียงเฉียบพลันหรือ circumflex หรือตะขอต่างๆ, วงกลม, ลูกศร, เป็นต้น, บน, ล่าง, ถึง
ด้านใดด้านหนึ่ง ฯลฯ. มีความเป็นไปได้มากมายในภาษาต่างๆ ในโลก
จำนวนของชุดค่าผสมนั้นเป็นเรื่องทางดาราศาสตร์และหากมีอักขระสำหรับแต่ละตัว
รวมกันแล้ว ในไม่ช้ามันก็จะใช้อักขระที่เป็นไปได้มากกว่าหนึ่งล้านตัวของ Unicode ดังนั้น
Unicode ใช้แนวทางที่แตกต่างออกไป: มีอักขระสำหรับฐาน "H" และอักขระ
สำหรับแต่ละคะแนนที่เป็นไปได้ และสิ่งเหล่านี้สามารถรวมกันได้หลากหลายเพื่อให้ได้เหตุผลขั้นสุดท้าย
อักขระ. ดังนั้น อักขระตรรกะ -- สิ่งที่ดูเหมือนจะเป็นอักขระตัวเดียว -- สามารถเป็น a
ลำดับของอักขระมากกว่าหนึ่งตัว มาตรฐาน Unicode เรียกสิ่งเหล่านี้ว่า
"กลุ่มกราฟแบบขยาย" (ซึ่งเป็นรุ่นที่ปรับปรุงแล้วซึ่งไม่ได้ใช้มากแล้ว
"คลัสเตอร์กราฟ"); Perl จัดเตรียมโครงสร้างนิพจน์ทั่วไป "\X" เพื่อให้ตรงกับสิ่งนั้น
ตามลำดับอย่างครบถ้วน
แต่ความตั้งใจของ Unicode คือการรวมมาตรฐานและแนวทางปฏิบัติของชุดอักขระที่มีอยู่และ
มาตรฐานที่มีอยู่ก่อนแล้วหลายตัวมีอักขระตัวเดียวที่มีความหมายเหมือนกับบางตัว
ชุดค่าผสมเหล่านี้ เช่น ISO-8859-1 ซึ่งมีค่อนข้างน้อย ตัวอย่างเช่น "LATIN
CAPITAL LETTER E WITH ACUTE" มีอยู่แล้วในมาตรฐานนี้เมื่อ Unicode เข้ามา
Unicode จึงเพิ่มเข้าไปในละครเป็นอักขระตัวเดียว แต่ตัวละครตัวนี้
ถือว่า Unicode เทียบเท่ากับลำดับที่ประกอบด้วยอักขระ
"LATIN CAPITAL LETTER E" ตามด้วยอักขระ "COMBINING ACUTE ACCENT"
"LATIN CAPITAL LETTER E WITH ACUTE" เรียกว่าอักขระ "pre-composed" และ
ความเท่าเทียมกันกับลำดับ "E" และ "COMBINING ACCENT" เรียกว่า canonical
ความเท่าเทียมกัน อักขระที่เขียนไว้ล่วงหน้าทั้งหมดมีการสลายตัว (เป็น
ลำดับที่เท่ากัน) และประเภทการสลายตัวเรียกอีกอย่างว่าบัญญัติ สตริงอาจ
จะประกอบด้วยอักขระ precomposed ให้มากที่สุดหรืออาจประกอบด้วย
ตัวละครที่ย่อยสลายทั้งหมด Unicode เรียกสิ่งเหล่านี้ตามลำดับ "Normalization Form
ประกอบด้วย" (NFC) และ "Normalization Form Decomposed" โมดูล "Unicode::Normalize"
มีฟังก์ชันที่แปลงระหว่างทั้งสอง สตริงอาจมีทั้งประกอบด้วย
อักขระและอักขระที่สลายตัว โมดูลนี้สามารถใช้เพื่อทำให้เป็นหนึ่งเดียวหรือ
อื่น ๆ
คุณอาจพบสตริงในรูปแบบที่เทียบเท่าเหล่านี้ ขณะนี้มี
ไม่มีอะไรใน Perl 5 ที่เพิกเฉยต่อความแตกต่าง ดังนั้นคุณจะต้องจัดการมันเป็นพิเศษ
คำแนะนำทั่วไปคือการแปลงอินพุตของคุณเป็น "NFD" ก่อนดำเนินการต่อไป
ดูรายละเอียดเพิ่มเติมได้ที่http://unicode.org/reports/tr15/>.
Unicode คาแรคเตอร์ อสังหาริมทรัพย์
(ครั้งเดียวที่ Perl พิจารณาลำดับของรหัสแต่ละจุดเป็น single
อักขระตรรกะอยู่ในโครงสร้าง "\X" ตามที่กล่าวไว้ข้างต้น ดังนั้น
"อักขระ" ในการสนทนานี้หมายถึงจุดโค้ด Unicode เดียว)
คุณสมบัติอักขระ Unicode เกือบทั้งหมดสามารถเข้าถึงได้ผ่านนิพจน์ทั่วไปโดย
ใช้โครงสร้าง "\p{}" "จับคู่คุณสมบัติ" และ "\P{}" "ไม่ตรงกับคุณสมบัติ" สำหรับ
การปฏิเสธของมัน
ตัวอย่างเช่น "\p{Uppercase}" จะจับคู่อักขระตัวเดียวกับ Unicode "ตัวพิมพ์ใหญ่"
คุณสมบัติ ในขณะที่ "\p{L}" จับคู่อักขระใดๆ ที่มี "General_Category" ของ "L" (ตัวอักษร)
คุณสมบัติ (ดู "General_Category" ด้านล่าง) ไม่จำเป็นต้องใช้วงเล็บสำหรับอักษรตัวเดียว
ชื่อคุณสมบัติ ดังนั้น "\p{L}" จึงเทียบเท่ากับ "\pL"
เป็นทางการมากขึ้น "\p{Uppercase}" จะจับคู่อักขระตัวเดียวที่มี Unicode "ตัวพิมพ์ใหญ่"
ค่าคุณสมบัติคือ "จริง" และ "\P{ตัวพิมพ์ใหญ่}" ตรงกับอักขระใดๆ ที่มี "ตัวพิมพ์ใหญ่"
ค่าคุณสมบัติเป็น "เท็จ" และสามารถเขียนเป็น "\p{Uppercase=True}" และ
"\p{ตัวพิมพ์ใหญ่=เท็จ}" ตามลำดับ
พิธีการนี้จำเป็นเมื่อคุณสมบัติไม่ใช่ไบนารี นั่นคือถ้าพวกเขาสามารถรับมือได้มากขึ้น
มีค่ามากกว่าแค่ "จริง" และ "เท็จ" ตัวอย่างเช่น คุณสมบัติ "Bidi_Class" (ดู
"ประเภทอักขระสองทิศทาง" ด้านล่าง) สามารถรับค่าต่างๆ ได้หลายค่า เช่น
"ซ้าย" "ขวา" "ช่องว่าง" และอื่นๆ เพื่อให้ตรงกับสิ่งเหล่านี้ เราต้องระบุทั้ง
ชื่อคุณสมบัติ ("Bidi_Class") และค่าที่จับคู่กับ ("ซ้าย", "ขวา" เป็นต้น).
ทำได้ดังตัวอย่างข้างต้น โดยให้องค์ประกอบทั้งสองคั่นด้วยค่าเท่ากัน
เครื่องหมาย (หรือแทนกัน ทวิภาค) เช่น "\p{Bidi_Class: Left}"
คุณสมบัติอักขระที่กำหนดด้วย Unicode ทั้งหมดอาจเขียนในรูปแบบผสมเหล่านี้ของ
"\p{คุณสมบัติ=ค่า}" หรือ "\p{คุณสมบัติ:ค่า}"แต่ Perl มีคุณสมบัติเพิ่มเติมบางอย่าง
ที่เขียนเฉพาะในรูปแบบเดียว เช่นเดียวกับทางลัดรูปแบบเดียวสำหรับไบนารีทั้งหมด
คุณสมบัติและอื่น ๆ บางอย่างที่อธิบายไว้ด้านล่าง ซึ่งคุณอาจละเว้นชื่อคุณสมบัติและ
ตัวคั่นเท่ากับหรือเครื่องหมายทวิภาค
คุณสมบัติอักขระ Unicode ส่วนใหญ่มีคำพ้องความหมายอย่างน้อยสองคำ (หรือนามแฝง หากคุณต้องการ): a
อันสั้นที่พิมพ์ง่ายกว่าและอันยาวที่สื่อความหมายมากกว่าและด้วยเหตุนี้
ง่ายต่อการเข้าใจ ดังนั้นคุณสมบัติ "L" และ "Letter" ข้างต้นจึงเทียบเท่ากันและ can
ใช้แทนกันได้ ในทำนองเดียวกัน "Upper" เป็นคำพ้องสำหรับ "Uppercase" และเราทำได้
ได้เขียน "\p{Uppercase}" เทียบเท่ากับ "\p{Upper}" นอกจากนี้ยังมีโดยทั่วไป
คำพ้องความหมายต่างๆ สำหรับค่าคุณสมบัติที่สามารถเป็นได้ สำหรับคุณสมบัติไบนารี "True" มี 3
คำพ้องความหมาย: "T", "ใช่" และ "Y"; และ "เท็จ" มี "F", "ไม่" และ "N" ตามลำดับ แต่จะ
ระมัดระวัง. รูปแบบย่อของค่าสำหรับคุณสมบัติหนึ่งอาจไม่มีความหมายเหมือนกัน
แบบสั้นอีกแบบหนึ่ง ดังนั้น สำหรับคุณสมบัติ "General_Category" "L" หมายถึง "จดหมาย"
แต่สำหรับคุณสมบัติ "Bidi_Class" "L" หมายถึง "ซ้าย" รายการทรัพย์สินทั้งหมดและ
คำพ้องความหมายอยู่ใน perluniprops
ความแตกต่างของตัวพิมพ์ใหญ่/ตัวพิมพ์เล็กในชื่อคุณสมบัติและค่านั้นไม่เกี่ยวข้อง ดังนั้น "\p{Upper}"
หมายถึงสิ่งเดียวกับ "\p{upper}" หรือแม้แต่ "\p{UpPeR}" ในทำนองเดียวกันคุณสามารถเพิ่มหรือ
ลบขีดล่างที่ใดก็ได้ตรงกลางคำ เพื่อให้มีค่าเท่ากัน
ถึง "\p{U_p_p_e_r}" และพื้นที่สีขาวไม่เกี่ยวข้องติดกับอักขระที่ไม่ใช่คำเช่น
เป็นเครื่องหมายวงเล็บปีกกาและเครื่องหมายเท่ากับหรือตัวคั่นทวิภาค ดังนั้น "\p{ Upper }" และ "\p{ Upper_case
: Y }" ก็เทียบเท่ากับสิ่งเหล่านี้เช่นกัน อันที่จริง พื้นที่สีขาวและแม้แต่ขีดกลางก็สามารถทำได้
เพิ่มหรือลบได้ทุกที่ ดังนั้นแม้แต่ "\p{ Up-per case = Yes}" ก็เทียบเท่า ทั้งหมดนี้
เรียกว่า "การจับคู่แบบหลวม" โดย Unicode สถานที่ไม่กี่แห่งที่ใช้การจับคู่ที่เข้มงวดกว่าคือ
ตรงกลางของตัวเลข และในคุณสมบัติส่วนขยายของ Perl ที่ขึ้นต้นหรือลงท้ายด้วย an
ขีดเส้นใต้ การจับคู่ที่เข้มงวดยิ่งขึ้นใส่ใจเกี่ยวกับพื้นที่สีขาว (ยกเว้นที่อยู่ติดกับคำที่ไม่ใช่คำ
อักขระ) ยัติภังค์ และขีดล่างที่ไม่ใช่ภายใน
คุณยังสามารถใช้การปฏิเสธได้ทั้งใน "\p{}" และ "\P{}" โดยการใส่เครื่องหมายคาเร็ต ("^") ระหว่าง
วงเล็บปีกกาแรกและชื่อคุณสมบัติ: "\p{^Tamil}" เท่ากับ "\P{Tamil}"
คุณสมบัติเกือบทั้งหมดมีภูมิคุ้มกันต่อการจับคู่ที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ กล่าวคือ เติม "/i"
ตัวแก้ไขนิพจน์ทั่วไปจะไม่เปลี่ยนแปลงสิ่งที่ตรงกัน มีสองชุดคือ
ได้รับผลกระทบ ชุดแรกคือ "Uppercase_Letter", "Lowercase_Letter" และ
"Titlecase_Letter" ซึ่งทั้งหมดตรงกับ "Cased_Letter" ภายใต้ "/i" ที่ตรงกัน และที่สอง
ชุดคือ "ตัวพิมพ์ใหญ่" "ตัวพิมพ์เล็ก" และ "ตัวพิมพ์ใหญ่" ซึ่งทั้งหมดตรงกับ "ตัวพิมพ์" ใต้ "/i"
การจับคู่ ชุดนี้ยังรวมถึงชุดย่อย "PosixUpper" และ "PosixLower" ซึ่งทั้งสองอย่าง
ภายใต้ "/i" ตรงกับ "PosixAlpha" (ความแตกต่างระหว่างเซตเหล่านี้คือบางสิ่ง
เช่น เลขโรมัน มาทั้งตัวพิมพ์ใหญ่และตัวพิมพ์เล็กจึงเรียกว่า "ตัวพิมพ์" แต่ไม่ใช่
ถือว่าเป็นตัวอักษร ดังนั้นจึงไม่ใช่ "Cased_Letter")
ดู "เหนือจุดโค้ด Unicode" สำหรับการพิจารณาพิเศษเมื่อจับคู่ Unicode
คุณสมบัติเทียบกับจุดที่ไม่ใช่รหัส Unicode
ทั่วไป_หมวดหมู่
อักขระ Unicode ทุกตัวถูกกำหนดหมวดหมู่ทั่วไปซึ่งก็คือ "ปกติที่สุด
การแบ่งประเภทของตัวละคร" (จากhttp://www.unicode.org/reports/tr44>).
วิธีการเขียนแบบผสมเหล่านี้เหมือนกับ "\p{General_Category=Number}" (สั้น:
"\p{gc:n}") แต่ Perl ให้ทางลัดที่ทุกอย่างผ่านเท่ากันหรือ
ละเว้นตัวคั่นทวิภาค ดังนั้นคุณสามารถเขียน "\pN" แทนได้
ต่อไปนี้คือรูปแบบสั้นและยาวของค่าที่คุณสมบัติ "หมวดหมู่ทั่วไป" สามารถมีได้:
สั้นยาว
จดหมาย L
LC, L& Cased_Letter (นั่นคือ: [\p{Ll}\p{Lu}\p{Lt}])
Lu ตัวพิมพ์ใหญ่_จดหมาย
L ตัวพิมพ์เล็ก_จดหมาย
lt Titlecase_Letter
Lm Modifier_จดหมาย
แท้จริง Other_Letter
เอ็ม มาร์ค
Mn ไม่เว้นวรรค_Mark
Mc Spacing_มาร์ค
ฉัน Enclose_Mark
N จำนวน
Nd Decimal_Number (เช่นตัวเลข)
Nl ตัวอักษร_หมายเลข
ไม่มี Other_Number
P เครื่องหมายวรรคตอน (เช่น Punct)
Pc Connector_เครื่องหมายวรรคตอน
Pd Dash_เครื่องหมายวรรคตอน
Ps Open_เครื่องหมายวรรคตอน
Pe Close_เครื่องหมายวรรคตอน
Pi Initial_เครื่องหมายวรรคตอน
(อาจจะทำตัวเหมือน Ps หรือ Pe ขึ้นอยู่กับการใช้งาน)
Pf Final_เครื่องหมายวรรคตอน
(อาจจะทำตัวเหมือน Ps หรือ Pe ขึ้นอยู่กับการใช้งาน)
Po อื่นๆ_เครื่องหมายวรรคตอน
สัญลักษณ์ S
Sm Math_สัญลักษณ์
Sc สกุลเงิน_สัญลักษณ์
Sk Modifier_สัญลักษณ์
อื่นๆ_สัญลักษณ์
ตัวแยก Z
Zs Space_Separator
Zl Line_Separator
Zp ย่อหน้า_ตัวคั่น
C อื่นๆ
การควบคุมซีซี (เช่น Cntrl)
รูปแบบ Cf
Cs ตัวแทน
ร่วมส่วนตัว_ใช้
Cn ยังไม่ได้มอบหมาย
คุณสมบัติตัวอักษรเดี่ยวจับคู่อักขระทั้งหมดในคุณสมบัติย่อยสองตัวอักษร
ขึ้นต้นด้วยอักษรตัวเดียวกัน "LC" และ "L&" มีความพิเศษ: ทั้งสองเป็นนามแฝงสำหรับชุด
ประกอบด้วยทุกอย่างที่ตรงกับ "Ll", "Lu" และ "Lt"
แบบสองทิศทาง คาแรคเตอร์ ประเภท
เพราะสคริปต์ต่างกันในทิศทาง (ฮีบรูและอารบิกเขียนถึง
ซ้าย ตัวอย่าง) Unicode ให้คุณสมบัติ "Bidi_Class" บางส่วนของค่านี้
คุณสมบัติสามารถมี:
คุณค่า ความหมาย
L ซ้ายไปขวา
LRE การฝังจากซ้ายไปขวา
LRO ซ้ายไปขวาแทนที่
R จากขวาไปซ้าย
AL อักษรอาหรับ
RLE การฝังจากขวาไปซ้าย
RLO แทนที่จากขวาไปซ้าย
รูปแบบทิศทางป๊อป PDF
TH หมายเลขยุโรป
ตัวแยก ES ยุโรป
ET เทอร์มิเนเตอร์ยุโรป
เลขอารบิก
CS ตัวคั่นทั่วไป
NSM เครื่องหมายไม่เว้นวรรค
BN ขอบเขตเป็นกลาง
ตัวคั่นย่อหน้า B
ตัวแยกส่วน S
WS ช่องว่าง
ON เป็นกลางอื่น ๆ
คุณสมบัตินี้เขียนในรูปแบบประสมเสมอ ตัวอย่างเช่น "\p{Bidi_Class:R}"
จับคู่อักขระที่ปกติจะเขียนจากขวาไปซ้าย ไม่เหมือนกับ "General_Category"
คุณสมบัติ คุณสมบัตินี้สามารถมีค่าเพิ่มในรุ่น Unicode ในอนาคต เหล่านั้น
รายการด้านบนประกอบด้วยชุดที่สมบูรณ์สำหรับ Unicode หลายรุ่น แต่มีการเพิ่มรุ่นอื่น
ใน Unicode 6.3; คุณสามารถค้นหาสิ่งที่อยู่ใน perluniprops ได้ตลอดเวลา และ
<http://www.unicode.org/reports/tr9/> อธิบายวิธีการใช้งาน
สคริปต์
ภาษาของโลกเขียนด้วยสคริปต์ต่างๆ มากมาย ประโยคนี้ (เว้นแต่คุณจะ
อ่านเป็นการแปล) เขียนเป็นภาษาละตินในขณะที่ภาษารัสเซียเขียนเป็นภาษาซิริลลิกและ
ภาษากรีกเขียนเป็นภาษากรีก ภาษาญี่ปุ่นส่วนใหญ่ในฮิระงะนะหรือคะตะคะนะ มีมากมาย
ขึ้น
คุณสมบัติ Unicode "Script" และ "Script_Extensions" ให้สิ่งที่สคริปต์กำหนดอักขระ
อยู่ใน ทั้งสองคุณสมบัติสามารถระบุได้ด้วยรูปแบบการประสมเช่น "\p{Script=Hebrew}"
(ย่อ: "\p{sc=hebr}") หรือ "\p{Script_Extensions=Javanese}" (ย่อ: "\p{scx=java}") ใน
นอกจากนี้ Perl ยังจัดเตรียมทางลัดสำหรับชื่อคุณสมบัติ "สคริปต์" ทั้งหมด คุณสามารถละเว้น
ทุกอย่างขึ้นไปผ่านเท่ากับ (หรือทวิภาค) และเพียงแค่เขียน "\p{Latin}" หรือ
"\P{ซีริลลิก}". (ไม่เป็นความจริงสำหรับ "Script_Extensions" ซึ่งจำเป็นต้องเป็น
เขียนในรูปประกอบ)
ความแตกต่างระหว่างคุณสมบัติทั้งสองนี้เกี่ยวข้องกับอักขระที่ใช้ในหลายตัว
สคริปต์ ตัวอย่างเช่น ตัวเลข '0' ถึง '9' ถูกใช้ในหลายส่วนของโลก
สิ่งเหล่านี้ถูกวางไว้ในสคริปต์ชื่อ "สามัญ" มีการใช้อักขระอื่นเพียงไม่กี่ตัว
สคริปต์ ตัวอย่างเช่น "KATAKANA-HIRAGANA DOUBLE HYPHEN" ใช้ได้ทั้งภาษาญี่ปุ่น
สคริปต์ Katakana และ Hiragana แต่ไม่มีที่ไหนเลย คุณสมบัติ "สคริปต์" วางทั้งหมด
อักขระที่ใช้ในหลายสคริปต์ในสคริปต์ "ทั่วไป" ในขณะที่
คุณสมบัติ "Script_Extensions" จะใส่สคริปต์ที่ใช้ในสคริปต์เพียงไม่กี่ตัวในแต่ละ
สคริปต์เหล่านั้น ในขณะที่ยังคงใช้ "สามัญ" สำหรับผู้ที่ใช้ในสคริปต์จำนวนมาก ดังนั้นทั้งสองสิ่งนี้
จับคู่:
"0" =~ /\p{sc=Common}/ # Matches
"0" =~ /\p{scx=Common}/ # Matches
และเฉพาะนัดแรกของการแข่งขันเหล่านี้:
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Common} # รายการที่ตรงกัน
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Common} # ไม่ตรงกัน
และเฉพาะสองนัดสุดท้ายของการแข่งขันเหล่านี้:
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Hiragana} # ไม่ตรงกัน
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Katakana} # ไม่ตรงกัน
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Hiragana} # แมทช์
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Katakana} # แมตช์
ดังนั้น "Script_Extensions" จึงเป็น "สคริปต์" ที่ได้รับการปรับปรุง ซึ่งมีอักขระน้อยลงใน
สคริปต์ "ทั่วไป" และสคริปต์อื่นๆ ตามลำดับ เป็นสิ่งใหม่ใน Unicode
เวอร์ชัน 6.0 และข้อมูลมีแนวโน้มที่จะเปลี่ยนแปลงอย่างมากในรุ่นต่อๆ มา เช่น สิ่งต่างๆ
ได้รับการจัดเรียงออก รหัสใหม่น่าจะใช้ "Script_Extensions" และไม่ธรรมดา
"สคริปต์".
(อันที่จริง นอกจาก "Common" แล้ว สคริปต์ "Inherited" ยังมีอักขระที่ใช้ใน
หลายสคริปต์ เหล่านี้เป็นอักขระตัวดัดแปลงที่สืบทอดค่าสคริปต์ของ
ตัวละครควบคุม สิ่งเหล่านี้บางส่วนถูกใช้ในหลาย ๆ สคริปต์ ดังนั้นให้ไปที่ "Inherited"
ทั้งใน "สคริปต์" และ "Script_Extensions" มีการใช้คำอื่นๆ เพียงไม่กี่สคริปต์ เช่นเดียวกับ
ใน "Inherited" ใน "Script" แต่ไม่ใช่ใน "Script_Extensions")
ควรเน้นว่า Unicode มีชุดตัวเลขที่แตกต่างกันหลายชุด ได้แก่
เทียบเท่ากับ 0-9 และสามารถจับคู่โดย "\d" ในนิพจน์ทั่วไป หากใช้ใน
ภาษาเดียวเท่านั้น พวกเขาอยู่ใน "สคริปต์" และ "Script_Extension" ของภาษานั้น ถ้า
มันถูกใช้ในมากกว่าหนึ่งสคริปต์ โดยจะอยู่ใน "sc=Common" แต่ถ้าเป็น
ใช้ในหลายสคริปต์ควรอยู่ใน "scx=Common"
รายการสคริปต์ทั้งหมดและทางลัดอยู่ใน perluniprops
ใช้ of "คือ" อุปสรรค
สำหรับความเข้ากันได้แบบย้อนหลัง (กับ Perl 5.6) คุณสมบัติทั้งหมดสามารถเขียนได้โดยไม่ต้องใช้
รูปแบบประสมที่กล่าวถึงจนถึงขณะนี้อาจมี "Is" หรือ "Is_" นำหน้าชื่อ ดังนั้น
ตัวอย่างเช่น "\P{Is_Lu}" เท่ากับ "\P{Lu}" และ "\p{IsScript:Arabic}" เท่ากับ
"\p{อาหรับ}".
Blocks
นอกจาก สคริปต์, Unicode ยังกำหนด บล็อก ของตัวละคร ความแตกต่างระหว่าง
สคริปต์และบล็อกคือแนวคิดของสคริปต์มีความใกล้ชิดกับภาษาธรรมชาติมากขึ้นในขณะที่
แนวคิดของบล็อกคือการจัดกลุ่มเทียมตามกลุ่มของ Unicode
อักขระที่มีค่าลำดับที่ต่อเนื่องกัน ตัวอย่างเช่น บล็อก "ภาษาละตินพื้นฐาน" คือทั้งหมด
อักขระที่มีลำดับอยู่ระหว่าง 0 ถึง 127 รวมอยู่ด้วย กล่าวอีกนัยหนึ่ง ASCII
ตัวอักษร สคริปต์ "ละติน" มีตัวอักษรบางตัวจากสิ่งนี้และอีกหลายตัว
บล็อก เช่น "Latin-1 Supplement", "Latin Extended-A", เป็นต้นแต่ไม่ได้มีทั้งหมด
ตัวละครจากบล็อกเหล่านั้น ไม่มีตัวอย่างเช่นมีตัวเลข 0-9
เนื่องจากตัวเลขเหล่านี้ใช้ร่วมกันในหลาย ๆ สคริปต์และด้วยเหตุนี้จึงอยู่ในสคริปต์ "ทั่วไป"
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสคริปต์เทียบกับบล็อก โปรดดู UAX#24 "คุณสมบัติ Unicode Script":
<http://www.unicode.org/reports/tr24>
คุณสมบัติ "Script" หรือ "Script_Extensions" น่าจะเป็นคุณสมบัติที่คุณต้องการใช้
เมื่อประมวลผลภาษาธรรมชาติ คุณสมบัติ "บล็อก" อาจมีประโยชน์ในบางครั้งใน
การทำงานกับน็อตและสลักเกลียวของ Unicode
ชื่อบล็อกจะจับคู่ในรูปแบบผสม เช่น "\p{Block: Arrows}" หรือ
"\p{Blk=ฮีบรู}". ไม่เหมือนกับคุณสมบัติอื่นๆ ส่วนใหญ่ มีเพียงไม่กี่ชื่อบล็อกที่มี Unicode-
กำหนดชื่อย่อ แต่ Perl มีทางลัด (เล็กน้อย ไม่แนะนำอีกต่อไป):
คุณสามารถพูดได้ เช่น "\p{In_Arrows}" หรือ "\p{In_Hebrew}"
สำหรับความเข้ากันได้แบบย้อนหลัง อาจข้ามคำนำหน้า "ใน" หากไม่มีความขัดแย้งในการตั้งชื่อ
ด้วยสคริปต์หรือคุณสมบัติอื่น ๆ และคุณยังสามารถใช้คำนำหน้า "เป็น" แทนในสิ่งเหล่านั้น
กรณี แต่อย่าทำเช่นนี้กับโค้ดใหม่เพราะโค้ดของคุณอาจพังในรุ่นใหม่ๆ และ
สิ่งนี้ได้เกิดขึ้นแล้ว: มีช่วงเวลาหนึ่งใน Unicode รุ่นแรกๆ เมื่อ
"\p{Hebrew}" จะตรงกับ ปิดกั้น ภาษาฮิบรู; ตอนนี้มันไม่ได้
การใช้คำนำหน้า "ใน" ช่วยหลีกเลี่ยงความคลุมเครือนี้ แต่ Unicode เวอร์ชันใหม่ยังคงดำเนินต่อไป
เพื่อเพิ่มคุณสมบัติใหม่ที่ชื่อขึ้นต้นด้วย "ใน" มีความเป็นไปได้ที่หนึ่งใน
สักวันหนึ่งจะขัดแย้งกับการใช้งานของคุณ เนื่องจากนี่เป็นเพียงส่วนขยายของ Perl
ชื่อของ Unicode จะมีความสำคัญเหนือกว่าและรหัสของคุณจะใช้งานไม่ได้ นอกจากนี้ Unicode ยังเป็น
อิสระในการเพิ่มสคริปต์ที่ชื่อขึ้นต้นด้วย "ใน"; ที่จะทำให้เกิดปัญหา
ดังนั้นจึงชัดเจนกว่าและดีที่สุดที่จะใช้รูปแบบผสมเมื่อระบุบล็อก และมั่นใจ
นั่นคือสิ่งที่คุณต้องการจะทำจริงๆ ในกรณีส่วนใหญ่ สคริปต์คือสิ่งที่คุณต้องการ
แทน.
รายการบล็อกทั้งหมดและทางลัดอยู่ใน perluniprops
อื่นๆ อสังหาริมทรัพย์
มีคุณสมบัติมากกว่าคุณสมบัติพื้นฐานมากมายที่อธิบายไว้ที่นี่ รายการที่สมบูรณ์
อยู่ใน perluniprops
Unicode กำหนดคุณสมบัติทั้งหมดในรูปแบบผสม ดังนั้นคุณสมบัติรูปแบบเดียวทั้งหมดจึงเป็น
ส่วนขยายของ Perl สิ่งเหล่านี้ส่วนใหญ่เป็นเพียงคำพ้องความหมายสำหรับ Unicode แต่บางคำก็
นามสกุลจริงรวมทั้งหลายตัวที่อยู่ในรูปแบบผสม และอีกไม่กี่อย่างของ
สิ่งเหล่านี้ได้รับการแนะนำโดย Unicode (inhttp://www.unicode.org/reports/tr18>).
ส่วนนี้ให้รายละเอียดเกี่ยวกับส่วนขยายทั้งหมดที่ไม่ใช่แค่คำพ้องความหมายสำหรับคำประสม-
สร้างคุณสมบัติ Unicode (สำหรับคุณสมบัติเหล่านั้น คุณจะต้องอ้างถึง Unicode
มาตรฐานhttp://www.unicode.org/reports/tr44>.
"\p{ทั้งหมด}"
ซึ่งตรงกับทุกจุดรหัสที่เป็นไปได้ เทียบเท่ากับ "qr/./s" ไม่เหมือนทั้งหมด
ตรงกับคุณสมบัติ "\p{}" อื่นที่ไม่ได้กำหนดโดยผู้ใช้ จะไม่มีการสร้างคำเตือนหากสิ่งนี้
เป็นคุณสมบัติที่จับคู่กับจุดรหัสที่ไม่ใช่ Unicode (ดู "นอกเหนือจากรหัส Unicode
คะแนน" ด้านล่าง)
"\p{Alnum}"
ตรงกับอักขระ "\p{Alphabetic}" หรือ "\p{Decimal_Number}" ใดๆ
"\p{ใดๆ}"
ซึ่งตรงกับจุดโค้ด Unicode 1_114_112 จุดใดๆ มันเป็นคำพ้องความหมายสำหรับ
"\p{Unicode}".
"\p{ASCII}"
ตรงกับอักขระ 128 ตัวในชุดอักขระ US-ASCII ซึ่งก็คือ a
ชุดย่อยของ Unicode
"\p{มอบหมายแล้ว}"
ตรงกับจุดรหัสที่กำหนด นั่นคือจุดรหัสใด ๆ ที่มีหมวดหมู่ทั่วไป
ไม่ใช่ "Unassigned" (หรือเทียบเท่า ไม่ใช่ "Cn")
"\p{ว่าง}"
สิ่งนี้เหมือนกับ "\h" และ "\p{HorizSpace}": อักขระที่เปลี่ยนการเว้นวรรค
แนวนอน
"\p{Decomposition_Type: Non_Canonical}" (สั้น: "\p{Dt=NonCanon}")
จับคู่อักขระที่มีการสลายตัวแบบไม่เป็นบัญญัติ
ส่วน "คลัสเตอร์ Graphem แบบขยาย (อักขระลอจิก)" ที่กล่าวถึงข้างต้น
การสลายตัวตามบัญญัติ อย่างไรก็ตาม อักขระอื่น ๆ อีกมากมายมีประเภทที่แตกต่างกันของ
การสลายตัว การสลายตัวที่ "เข้ากันได้" หรือ "ไม่เป็นที่ยอมรับ" ลำดับที่
รูปแบบการสลายตัวเหล่านี้ไม่ถือว่าเทียบเท่าตามบัญญัติบัญญัติก่อน
ตัวละครประกอบ ตัวอย่างคือ "SUPERSCRIPT ONE" มันค่อนข้างจะเหมือนกับ a
ตัวเลขปกติ 1 แต่ไม่ตรงทั้งหมด การแตกตัวเป็นเลข 1 เรียกว่า a
การสลายตัวที่ "เข้ากันได้" โดยเฉพาะการสลายตัวที่ "สุดยอด" มีหลายอย่าง
การสลายตัวที่เข้ากันได้ดังกล่าว (ดูhttp://www.unicode.org/reports/tr44>),
รวมทั้งที่เรียกว่า "คู่กัน" ซึ่งหมายถึงการย่อยสลายแบบเบ็ดเตล็ดบางชนิด
ที่ไม่เข้ากับหมวดหมู่การสลายตัวอื่นๆ ที่ Unicode ได้เลือกไว้
โปรดทราบว่าอักขระ Unicode ส่วนใหญ่ไม่มีการสลายตัว ดังนั้นจึงมีการสลายตัว
ประเภทคือ "ไม่มี"
เพื่อความสะดวกของคุณ Perl ได้เพิ่มประเภทการสลายตัว "Non_Canonical" เพื่อหมายถึง
การสลายตัวที่เข้ากันได้หลายอย่าง
"\p{กราฟ}"
จับคู่อักขระที่เป็นกราฟิก ในทางทฤษฎี นี่หมายถึงตัวละครที่อยู่บน
เครื่องพิมพ์จะทำให้หมึกถูกใช้
"\p{ฮอริซสเปซ}"
สิ่งนี้เหมือนกับ "\h" และ "\p{Blank}": อักขระที่เปลี่ยนระยะห่าง
แนวนอน
"\p{ใน=*}"
นี่คือคำพ้องความหมายสำหรับ "\p{Present_In=*}"
"\p{PerlSpace}"
สิ่งนี้เหมือนกับ "\s" ที่จำกัดไว้สำหรับ ASCII คือ "[ \f\n\r\t]" และเริ่มต้นใน
Perl v5.18 แท็บแนวตั้ง
Mnemonic: พื้นที่ของ Perl (ดั้งเดิม)
"\p{PerlWord}"
ซึ่งเหมือนกับ "\w" ซึ่งจำกัดไว้สำหรับ ASCII คือ "[A-Za-z0-9_]"
Mnemonic: คำของ Perl (ดั้งเดิม)
"\p{โพซิก...}"
มีหลายสิ่งเหล่านี้ ซึ่งเทียบเท่า โดยใช้สัญกรณ์ "\p{}" สำหรับ
คลาส Posix และอธิบายไว้ใน "คลาสอักขระ POSIX" ใน perlrecharclass
"\p{Present_In: *}" (สั้น: "\p{ใน=*}")
คุณสมบัตินี้ใช้เมื่อคุณต้องการทราบว่าอักขระในเวอร์ชัน Unicode คืออะไร
"*" ด้านบนหมายถึงหมายเลขเวอร์ชัน Unicode สองหลัก เช่น 1.1 หรือ 4.0 หรือ
"*" ยังสามารถเป็น "Unassigned" ได้ คุณสมบัตินี้จะตรงกับจุดรหัสซึ่ง
การจัดการขั้นสุดท้ายได้รับการตัดสินเมื่อปล่อย Unicode ที่กำหนดโดยเวอร์ชัน
ตัวเลข; "\p{Present_In: Unassigned}" จะจับคู่โค้ดพอยท์ที่มีความหมาย
ที่ยังไม่ได้รับมอบหมาย
ตัวอย่างเช่น "U+0041" "LATIN CAPITAL LETTER A" มีอยู่ใน Unicode ตัวแรก
รีลีสที่มีให้ ซึ่งคือ 1.1 ดังนั้นคุณสมบัตินี้จึงเป็นจริงสำหรับเวอร์ชัน "*" ที่ถูกต้องทั้งหมด
ในทางกลับกัน "U+1EFF" ไม่ได้ถูกกำหนดจนถึงเวอร์ชัน 5.1 เมื่อกลายเป็น "LATIN ."
อักษรตัวเล็ก Y พร้อมลูป" ดังนั้น "*" ตัวเดียวที่จะจับคู่ได้คือ 5.1, 5.2 และ
ต่อมา
Unicode ให้คุณสมบัติ "อายุ" ซึ่งเป็นที่มา ปัญหาของวัย
คือการตีความอย่างเข้มงวดของมัน (ซึ่ง Perl ใช้) ให้ตรงกับที่แม่นยำ
ปล่อยความหมายของโค้ดพอยท์เข้ามา ดังนั้น "U+0041" จะจับคู่ได้เพียง 1.1 เท่านั้น
และ "U+1EFF" เท่านั้น 5.1 นี่ไม่ใช่สิ่งที่คุณต้องการ
การใช้งานที่ไม่ใช่ Perl บางอย่างของคุณสมบัติ Age อาจเปลี่ยนความหมายเป็น
เช่นเดียวกับคุณสมบัติ Perl "Present_In"; เพียงแค่ตระหนักถึงสิ่งนั้น
ความสับสนอีกประการหนึ่งกับคุณสมบัติทั้งสองนี้คือคำจำกัดความไม่ใช่ว่า
จุดรหัสได้รับ ที่ได้รับมอบหมายแต่ความหมายของโค้ดพอยท์นั้นคือ
แน่นอน. นี่เป็นเพราะว่าจุดรหัส 66 จุดจะถูกยกเลิกการมอบหมายเสมอ ดังนั้น
"อายุ" สำหรับพวกเขาคือเวอร์ชัน Unicode ที่มีการตัดสินใจที่จะทำให้พวกเขาเป็นเช่นนั้น
ตัวอย่างเช่น "U+FDD0" จะถูกยกเลิกการกำหนดให้กับตัวละครอย่างถาวรและการตัดสินใจ
ที่ทำในเวอร์ชัน 3.1 ดังนั้น "\p{Age=3.1}" จะจับคู่อักขระนี้ด้วย
ทำ "\p{Present_In: 3.1}" ขึ้นไป
"\p{พิมพ์}"
ซึ่งตรงกับอักขระที่เป็นกราฟิกหรือว่างเปล่า ยกเว้นตัวควบคุม
"\p{SpacePerl}"
ซึ่งเหมือนกับ "\s" รวมถึงนอกเหนือจาก ASCII
Mnemonic: Space ที่แก้ไขโดย Perl (ไม่รวมแถบแนวตั้งจนกว่า
v5.18 ซึ่งทั้งมาตรฐาน Posix และ Unicode พิจารณาพื้นที่สีขาว)
"\p{หัวเรื่อง}" และ "\p{ชื่อเรื่อง}"
ภายใต้การจับคู่ที่คำนึงถึงขนาดตัวพิมพ์ ทั้งคู่จับคู่จุดรหัสเดียวกันกับ "\p{General
Category=Titlecase_Letter}" ("\p{gc=lt}") ข้อแตกต่างคือภายใต้ "/i" caseless
ตรงกัน สิ่งเหล่านี้ตรงกับ "\p{Cased}" ในขณะที่ "\p{gc=lt}" ตรงกัน
"\p{Cased_Letter")
"\p{ยูนิโค้ด}"
ซึ่งตรงกับจุดโค้ด Unicode 1_114_112 จุดใดๆ "\p{ใดๆ}".
"\p{VertSpace}"
สิ่งนี้เหมือนกับ "\v": อักขระที่เปลี่ยนระยะห่างในแนวตั้ง
"\p{คำ}"
ซึ่งเหมือนกับ "\w" ซึ่งรวมถึงอักขระมากกว่า 100_000 ตัวที่เกิน ASCII
"\p{XPosix...}"
มีหลายคลาสซึ่งเป็นคลาส Posix มาตรฐานที่ขยายให้เต็ม
ช่วง Unicode มีการอธิบายไว้ใน "คลาสอักขระ POSIX" ใน perlrecharclass
ผู้ใช้กำหนด คาแรคเตอร์ อสังหาริมทรัพย์
คุณสามารถกำหนดคุณสมบัติอักขระไบนารีของคุณเองโดยกำหนดรูทีนย่อยที่มีชื่อ
เริ่มต้นด้วย "In" หรือ "Is" (คุณลักษณะทดลอง "(?[ ])" ใน perlre ให้ an
ทางเลือกที่ช่วยให้คำจำกัดความที่ซับซ้อนมากขึ้น) รูทีนย่อยสามารถกำหนดในใดๆ
บรรจุุภัณฑ์. คุณสมบัติที่ผู้ใช้กำหนดสามารถใช้ในนิพจน์ทั่วไป "\p{}" และ
"\P{}" สร้าง; หากคุณกำลังใช้คุณสมบัติที่ผู้ใช้กำหนดจากแพ็คเกจอื่นที่ไม่ใช่
คุณต้องระบุแพ็คเกจในโครงสร้าง "\p{}" หรือ "\P{}"
# สมมติว่าคุณสมบัติ Is_Foreign กำหนดไว้ใน Lang ::
แพ็คเกจหลัก; # ต้องระบุชื่อแพ็คเกจคุณสมบัติ
ถ้า ($txt =~ /\p{Lang::IsForeign}+/) { ... }
แพคเกจแลง; # ไม่ต้องระบุชื่อแพ็คเกจทรัพย์สิน
ถ้า ($txt =~ /\p{IsForeign}+/) { ... }
โปรดทราบว่าเอฟเฟกต์เป็นเวลาคอมไพล์และไม่เปลี่ยนรูปเมื่อกำหนดแล้ว อย่างไรก็ตาม รูทีนย่อย
ถูกส่งผ่านพารามิเตอร์ตัวเดียว ซึ่งเท่ากับ 0 หากการจับคู่แบบตรงตามตัวพิมพ์เล็กและตัวพิมพ์ใหญ่มีผลและไม่ใช่
ศูนย์หากการจับคู่แบบไม่มีกรณีมีผล รูทีนย่อยอาจคืนค่าที่แตกต่างกัน
ขึ้นอยู่กับค่าของแฟล็ก และค่าหนึ่งชุดจะมีผลบังคับสำหรับ
การจับคู่ที่ตรงตามตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ทั้งหมด และอีกชุดสำหรับการจับคู่ที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ทั้งหมด
โปรดทราบว่าหากนิพจน์ทั่วไปเสีย Perl จะตายแทนที่จะเรียก
รูทีนย่อยเมื่อชื่อของรูทีนย่อยถูกกำหนดโดยข้อมูลที่เสีย
รูทีนย่อยต้องส่งคืนสตริงที่มีรูปแบบพิเศษ โดยมีการขึ้นบรรทัดใหม่อย่างน้อยหนึ่งรายการ
เส้นที่แยกจากกัน แต่ละบรรทัดจะต้องเป็นอย่างใดอย่างหนึ่งต่อไปนี้:
· เลขฐานสิบหกเดียวที่แสดงถึงจุดรหัสที่จะรวม
· เลขฐานสิบหกสองตัวคั่นด้วยช่องว่างแนวนอน (ช่องว่างหรือตาราง
อักขระ) แสดงถึงช่วงของจุดโค้ดที่จะรวมไว้
· สิ่งที่ต้องรวม นำหน้าด้วย "+": คุณสมบัติอักขระในตัว (นำหน้าด้วย
"utf8::") หรืออักขระที่ผู้ใช้กำหนด (รวมถึงชื่อแพ็กเกจ) ที่มีคุณสมบัติครบถ้วน
คุณสมบัติ เพื่อแสดงอักขระทั้งหมดในคุณสมบัตินั้น เลขฐานสิบหกสองตัว
คะแนนสำหรับช่วง; หรือจุดรหัสฐานสิบหกเดียว
· สิ่งที่ไม่รวม นำหน้าด้วย "-": คุณสมบัติอักขระที่มีอยู่ (นำหน้าด้วย
"utf8::") หรืออักขระที่ผู้ใช้กำหนด (รวมถึงชื่อแพ็กเกจ) ที่มีคุณสมบัติครบถ้วน
คุณสมบัติ เพื่อแสดงอักขระทั้งหมดในคุณสมบัตินั้น เลขฐานสิบหกสองตัว
คะแนนสำหรับช่วง; หรือจุดรหัสฐานสิบหกเดียว
· สิ่งที่จะปฏิเสธ คำนำหน้า "!": คุณสมบัติอักขระที่มีอยู่ (นำหน้าด้วย
"utf8::") หรืออักขระที่ผู้ใช้กำหนด (รวมถึงชื่อแพ็กเกจ) ที่มีคุณสมบัติครบถ้วน
คุณสมบัติ เพื่อแสดงอักขระทั้งหมดในคุณสมบัตินั้น เลขฐานสิบหกสองตัว
คะแนนสำหรับช่วง; หรือจุดรหัสฐานสิบหกเดียว
· สิ่งที่จะตัดกัน นำหน้าด้วย "&": คุณสมบัติอักขระที่มีอยู่ (นำหน้า
โดย "utf8::") หรืออักขระที่ผู้ใช้กำหนด (รวมถึงชื่อแพ็คเกจ) ที่มีคุณสมบัติครบถ้วน
คุณสมบัติ สำหรับอักขระทั้งหมดยกเว้นอักขระในคุณสมบัติ สอง
รหัสเลขฐานสิบหกชี้สำหรับช่วง หรือจุดรหัสฐานสิบหกเดียว
ตัวอย่างเช่น เพื่อกำหนดคุณสมบัติที่ครอบคลุมทั้งพยางค์ภาษาญี่ปุ่น (ฮิรางานะและ
คะตะคะนะ) คุณสามารถกำหนดได้
ย่อย InKana {
กลับ <
3040\t309F
30A0\t30FF
END
}
ลองนึกภาพว่าเครื่องหมายสิ้นสุด here-doc อยู่ที่จุดเริ่มต้นของบรรทัด ตอนนี้คุณสามารถใช้
"\p{InKana}" และ "\P{InKana}"
คุณสามารถใช้ชื่อคุณสมบัติบล็อกที่มีอยู่ได้:
ย่อย InKana {
ส่งคืน <<'END';
+utf8::อินฮิระงะนะ
+utf8::InKatakana
END
}
สมมติว่าคุณต้องการจับคู่เฉพาะอักขระที่จัดสรร ไม่ใช่ช่วงบล็อกดิบ: in
กล่าวอีกนัยหนึ่งคุณต้องการลบอักขระที่ไม่ได้กำหนด:
ย่อย InKana {
ส่งคืน <<'END';
+utf8::อินฮิระงะนะ
+utf8::InKatakana
-utf8::IsCn
END
}
การปฏิเสธมีประโยชน์สำหรับการกำหนดคลาสที่ถูกปฏิเสธ (เซอร์ไพรส์!)
ย่อย InNotKana {
ส่งคืน <<'END';
!utf8::อินฮิรางานะ
-utf8::InKatakana
+utf8::IsCn
END
}
ซึ่งจะตรงกับจุดโค้ดที่ไม่ใช่ Unicode ทั้งหมด เนื่องจากทุกจุดไม่ได้อยู่ใน Kana คุณ
สามารถใช้ทางแยกเพื่อแยกสิ่งเหล่านี้ ถ้าต้องการ ดังตัวอย่างที่แก้ไขนี้แสดง:
ย่อย InNotKana {
ส่งคืน <<'END';
!utf8::อินฮิรางานะ
-utf8::InKatakana
+utf8::IsCn
&utf8::อะไรก็ได้
END
}
&utf8::ใดๆ ต้องเป็นบรรทัดสุดท้ายในคำจำกัดความ
ทางแยกใช้โดยทั่วไปเพื่อรับอักขระทั่วไปที่จับคู่โดยสองตัว (หรือมากกว่า)
ชั้นเรียน สิ่งสำคัญคือต้องจำไว้ว่าอย่าใช้ "&" สำหรับชุดแรก ที่จะ
ตัดกันโดยไม่มีอะไรเลย เกิดเป็นเซตว่าง
ไม่เหมือนกับการจับคู่คุณสมบัติ "\p{}" ที่ไม่ได้กำหนดโดยผู้ใช้ จะไม่มีการสร้างคำเตือนหากสิ่งเหล่านี้
คุณสมบัติถูกจับคู่กับจุดโค้ดที่ไม่ใช่ Unicode (ดู "นอกเหนือจากจุดโค้ด Unicode"
ด้านล่าง)
ผู้ใช้กำหนด กรณี แมป (สำหรับ ร้ายแรง แฮกเกอร์ เท่านั้น)
สัมผัส ลักษณะ มี รับ ลบออก as of Perl 5.16. โมดูล CPAN "Unicode::Casing" มีให้
ฟังก์ชันการทำงานที่ดีขึ้นโดยไม่มีข้อเสียที่คุณลักษณะนี้มี หากคุณกำลังใช้ Perl
ก่อนหน้า 5.16 คุณลักษณะนี้ได้รับการบันทึกไว้อย่างสมบูรณ์ที่สุดในเวอร์ชัน 5.14 ของพ็อดนี้:
<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
คาแรคเตอร์ การเข้ารหัส สำหรับ อินพุต และ เอาท์พุต
ดูการเข้ารหัส
Unicode ปกติ การแสดงออก การสนับสนุนตลอดการใช้งาน ชั้น
รายการต่อไปนี้ของคุณลักษณะที่รองรับ Unicode สำหรับนิพจน์ทั่วไปจะอธิบายทั้งหมด
คุณสมบัติปัจจุบันได้รับการสนับสนุนโดยตรงโดย core Perl การอ้างอิงถึง "ระดับ N" และ
หมายเลขมาตราอ้างอิงถึงมาตรฐานทางเทคนิค Unicode #18, "Unicode Regular
Expressions" เวอร์ชัน 13 ตั้งแต่เดือนสิงหาคม 2008
· ระดับ 1 - รองรับ Unicode พื้นฐาน
RL1.1 สัญกรณ์ฐานสิบหก - เสร็จแล้ว [1]
คุณสมบัติ RL1.2 - เสร็จสิ้น [2][3]
คุณสมบัติความเข้ากันได้ของ RL1.2a - เสร็จสิ้น [4]
RL1.3 การลบและทางแยก - ทดลอง [5]
RL1.4 ขอบเขตคำอย่างง่าย - เสร็จสิ้น [6]
RL1.5 Simple Loose Matches - เสร็จสิ้น [7]
RL1.6 ขอบเขตของเส้น - ขาดหายไป [8][9]
RL1.7 คะแนนรหัสเสริม - เสร็จสิ้น [10]
[1] "\N{U+...}" และ "\x{...}"
[2] "\p{...}" "\P{...}"
[3] รองรับไม่เพียงแต่รายการขั้นต่ำ แต่คุณสมบัติอักขระ Unicode ทั้งหมด (ดู Unicode
คุณสมบัติตัวละครด้านบน)
[4] "\d" "\D" "\s" "\S" "\w" "\W" "\X" "[:พร็อพ:]" "[:^พร็อพ:]"
[5] คุณลักษณะทดลองที่เริ่มต้นใน v5.18 "(?[...])" ทำได้สำเร็จ
ดู "(?[ ])" ใน perlre หากคุณไม่ต้องการใช้คุณลักษณะทดลอง คุณสามารถ
ใช้อย่างใดอย่างหนึ่งต่อไปนี้:
· นิพจน์ทั่วไปมองไปข้างหน้า
คุณสามารถเลียนแบบการลบชั้นเรียนโดยใช้ lookahead ตัวอย่างเช่น UTS#18 . คืออะไร
อาจเขียนว่า
[{บล็อก=กรีก}-[{ไม่ได้มอบหมาย}]]
ใน Perl สามารถเขียนได้ดังนี้:
(?!\p{ไม่ได้มอบหมาย})\p{บล็อก=กรีก}
(?=\p{มอบหมาย})\p{บล็อก=กรีก}
แต่ในตัวอย่างนี้ คุณอาจต้องการจริงๆ
\p{กรีก}
ซึ่งจะจับคู่อักขระที่ได้รับมอบหมายซึ่งเป็นที่รู้จักว่าเป็นส่วนหนึ่งของสคริปต์ภาษากรีก
· โมดูล CPAN "Unicode::Regex::Set"
มันใช้การจัดกลุ่ม UTS#18 ทางแยก การรวมและการถอดออกทั้งหมด
(การลบ) ไวยากรณ์
· "คุณสมบัติของตัวละครที่กำหนดโดยผู้ใช้"
"+" สำหรับยูเนียน, "-" สำหรับการลบ (set-difference), "&" สำหรับทางแยก
[6] "\b" "\B"
[7] โปรดทราบว่า Perl ทำการพับเต็มตัวพิมพ์ในการจับคู่ ไม่ใช่ Simple:
ตัวอย่างเช่น "U+1F88" เทียบเท่ากับ "U+1F00 U+03B9" แทนที่จะเป็น "U+1F80"
ความแตกต่างนี้มีความสำคัญกับอักษรตัวพิมพ์ใหญ่กรีกบางตัวเป็นหลัก
ตัวแก้ไข: การพับตัวพิมพ์เต็มตัวจะสลายตัวอักษร ในขณะที่ตัวพิมพ์แบบธรรมดา-
การพับจะแมปกับอักขระตัวเดียว
[8] Perl ถือว่า "\n" เป็นตัวคั่นเริ่มต้นและสิ้นสุดบรรทัด Unicode ระบุเพิ่มเติม
อักขระที่ควรตีความ
เหล่านี้คือ:
VT U+000B (\v ใน C)
FF U+000C (\f)
CR U+000D (\r)
เนล ยู+0085
แอลเอส ยู+2028
PS U+2029
"^" และ "$" ในรูปแบบนิพจน์ทั่วไปควรจะตรงกันทั้งหมด แต่
อย่า อักขระเหล่านี้ไม่ได้เช่นกัน แต่ควรส่งผลต่อ "<>" $. และบรรทัดสคริปต์
หมายเลข
นอกจากนี้ ไม่ควรแยกบรรทัดภายใน "CRLF" (เช่น ไม่มีบรรทัดว่างระหว่าง
"\r" และ "\n") สำหรับ "CRLF" ให้ลองใช้เลเยอร์ ":crlf" (ดู PerlIO)
[9] แต่ "Unicode::LineBreak" สามารถใช้ได้
โมดูลนี้จัดหาตัวแบ่งบรรทัดที่สอดคล้องกับ UAX#14 "Unicode Line Breaking
อัลกอริทึม"http://www.unicode.org/reports/tr14>.
[10] UTF-8/UTF-EBDDIC ที่ใช้ใน Perl ไม่เพียงอนุญาต "U+10000" ถึง "U+10FFFF" แต่ยัง
เกิน "U+10FFFF"
· ระดับ 2 - รองรับ Unicode แบบขยาย
RL2.1 Canonical Equivalents - ไม่มี [10] [11]
RL2.2 Default Grapheme Clusters - ไม่มี [12]
RL2.3 ขอบเขตของคำเริ่มต้น - เสร็จสิ้น [14]
RL2.4 การจับคู่แบบหลวมเริ่มต้น - หายไป [15]
คุณสมบัติชื่อ RL2.5 - เสร็จสิ้น
คุณสมบัติตัวแทน RL2.6 - หายไป
[10] ดู UAX#15 "Unicode Normalization Forms"
[11] มี Unicode::Normalize แต่ไม่รวมกับ regexes
[12] มี \X และ \b{gcb} แต่เราไม่มี "คลัสเตอร์กราฟ
โหมด"
[14] ดู UAX#29, ขอบเขตของคำ
[15] ครอบคลุมในบทที่ 3.13 (ใน Unicode 6.0)
· ระดับ 3 - รองรับเฉพาะตัว
RL3.1 เครื่องหมายวรรคตอนที่ปรับแต่ง - MISSING
RL3.2 คลัสเตอร์ Grapheme ที่ปรับแต่ง - ขาดหายไป [17] [18]
RL3.3 ขอบเขตคำที่ปรับแต่งได้ - MISSING
RL3.4 การจับคู่หลวมที่ปรับแต่ง - ไม่มี
RL3.5 ช่วงที่ปรับแต่ง - MISSING
การจับคู่บริบท RL3.6 - ขาดหายไป [19]
RL3.7 การแข่งขันที่เพิ่มขึ้น - MISSING
( RL3.8 การแชร์ชุด Unicode )
RL3.9 ชุดการแข่งขันที่เป็นไปได้ - MISSING
RL3.10 การจับคู่แบบพับ - ขาดหายไป [20]
RL3.11 ตัวจับคู่ย่อย - MISSING
[17] ดู UAX#10 "อัลกอริทึมการเรียง Unicode"
[18] มี Unicode::Collate แต่ไม่ได้รวมเข้ากับ regexes
[19] มี (?<=x) และ (?=x) แต่มองไปข้างหน้าหรือมองข้างหลัง
ควรดูนอกสตริงย่อยเป้าหมาย
[20] ต้องการการจับคู่ที่ไม่ละเอียดอ่อนสำหรับคุณลักษณะทางภาษาศาสตร์อื่นๆ
กว่ากรณี; เช่น ฮิรางานะถึงคาตาคานะกว้างและ
ฮั่นที่แคบและเรียบง่ายถึงฮั่นดั้งเดิม (ดู UTR#30
"การพับตัวละคร")
Unicode การเข้ารหัส
อักขระ Unicode ถูกกำหนดให้กับ รหัส จุดซึ่งเป็นตัวเลขที่เป็นนามธรรม เพื่อใช้สิ่งเหล่านี้
ตัวเลข การเข้ารหัสต่างๆ เป็นสิ่งจำเป็น
· UTF-8
UTF-8 คือการเข้ารหัสแบบอิสระที่มีความยาวผันแปรได้ (1 ถึง 4 ไบต์) ในส่วนใหญ่
ของเอกสารของ Perl รวมถึงที่อื่นในเอกสารนี้ คำว่า "UTF-8" หมายถึง
"UTF-EBCDIC" ด้วย แต่ในส่วนนี้ "UTF-8" หมายถึงการเข้ารหัสที่ใช้กับ .เท่านั้น
แพลตฟอร์ม ASCII เป็น superset ของ US-ASCII 7 บิต ดังนั้นทุกอย่างที่เข้ารหัสใน ASCII จึงมี
การแสดงที่เหมือนกันเมื่อเข้ารหัสใน UTF-8
ตารางต่อไปนี้มาจาก Unicode 3.2
รหัส คะแนน ไบต์ที่ 1 ไบต์ที่ 2 ไบต์ที่ 3 ไบต์ที่ 4 ไบต์
U+0000..U+007F 00..7F
U+0080..U+07FF * C2..DF 80..BF
U+0800..U+0FFF E0 * A0..BF 80..BF
U+1000..U+CFF E1..EC 80..BF 80..BF
U+D000..U+D7FF ED 80..9F 80..BF
U+D800..U+DFFF ++++ utf16 ตัวแทนไม่ใช่ utf8 ตามกฎหมาย ++++
U+E000..U+FFFF EE..EF 80..BF 80..BF
U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF
U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
สังเกตช่องว่างที่มีเครื่องหมาย "*" ก่อนรายการไบต์หลายรายการด้านบน เหล่านี้คือ
เกิดจากกฎหมาย UTF-8 ที่หลีกเลี่ยงการเข้ารหัสที่ไม่สั้นที่สุด: ในทางเทคนิคแล้ว เป็นไปได้ที่
UTF-8 เข้ารหัสจุดโค้ดเดียวในรูปแบบต่างๆ แต่ที่ห้ามไว้อย่างชัดเจน
และควรใช้การเข้ารหัสที่สั้นที่สุด (และนั่นคือสิ่งที่ Perl ทำ)
อีกวิธีในการดูผ่านบิต:
รหัส คะแนน ไบต์ที่ 1 ไบต์ที่ 2 ไบต์ที่ 3 ไบต์ที่ 4 ไบต์
0aaaaaa 0aaaaaa
00000bbbbbaaaaaa110bbbbb 10aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
คคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคคค
00000dddccccccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
อย่างที่คุณเห็น ไบต์ต่อเนื่องทั้งหมดเริ่มต้นด้วย "10" และบิตนำหน้าของ
ไบต์เริ่มต้นจะบอกจำนวนไบต์ที่มีในอักขระที่เข้ารหัส
ข้อกำหนด UTF-8 ดั้งเดิมอนุญาตให้ใช้ได้ถึง 6 ไบต์ เพื่อให้สามารถเข้ารหัสตัวเลขได้
สูงสุด "0x7FFF_FFFF" Perl ยังคงอนุญาตสิ่งเหล่านั้นและขยายออกไปถึง13
ไบต์ในการเข้ารหัสโค้ดชี้ให้เห็นถึงสิ่งที่สามารถใส่ลงในคำ 64 บิตได้ อย่างไรก็ตาม Perl will
เตือนหากคุณส่งออกสิ่งเหล่านี้ว่าไม่สามารถพกพาได้ และอยู่ภายใต้อินพุต UTF-8 ที่เข้มงวด
โปรโตคอลพวกเขาเป็นสิ่งต้องห้าม
· UTF-EBCDIC
เช่นเดียวกับ UTF-8 แต่ปลอดภัย EBCDIC ในลักษณะที่ UTF-8 ปลอดภัย ASCII ซึ่งหมายความว่าทั้งหมด
อักขระพื้นฐาน (ซึ่งรวมถึงอักขระทั้งหมดที่เทียบเท่า ASCII (เช่น "A"
"0", "%", เป็นต้น) เหมือนกันทั้งใน EBCDIC และ UTF-EBCDIC)
UTF-EBCDIC ใช้กับแพลตฟอร์ม EBCDIC จุดรหัส Unicode ที่ใหญ่ที่สุดใช้เวลา 5 ไบต์
เพื่อแสดง (แทนที่จะเป็น 4 ใน UTF-8) และ Perl ขยายได้สูงสุด 7 ไบต์ถึง
เข้ารหัส pode ชี้ไปที่สิ่งที่สามารถใส่ในคำแบบ 32 บิต (แทนที่จะเป็น 13 ไบต์และ a
คำ 64 บิตใน UTF-8)
· UTF-16, UTF-16BE, UTF-16LE, ตัวแทน และ "BOM" (เครื่องหมายคำสั่งไบต์)
รายการต่อไปนี้ส่วนใหญ่เป็นข้อมูลอ้างอิงและความรู้ Unicode ทั่วไป Perl
ไม่ได้ใช้โครงสร้างเหล่านี้ภายใน
เช่นเดียวกับ UTF-8 UTF-16 เป็นการเข้ารหัสแบบความกว้างตัวแปร แต่โดยที่ UTF-8 ใช้โค้ด 8 บิต
หน่วย UTF-16 ใช้หน่วยรหัส 16 บิต จุดรหัสทั้งหมดใช้พื้นที่ 2 หรือ 4 ไบต์ใน
UTF-16: รหัสจุด "U+0000..U+FFFF" ถูกเก็บไว้ในหน่วย 16 บิตเดียวและรหัส
ชี้ "U+10000..U+10FFFF" ในหน่วย 16 บิตสองหน่วย กรณีหลังกำลังใช้ ตัวแทน,
หน่วย 16 บิตแรกคือ สูง ตัวแทนและที่สองคือ ต่ำ
ตัวแทน.
ตัวแทนเสมือนเป็นจุดรหัสที่ตั้งไว้เพื่อเข้ารหัสช่วง "U+10000..U+10FFFF" ของ
โค้ด Unicode ชี้เป็นคู่ของหน่วย 16 บิต ดิ สูง ตัวแทน เป็นช่วง
"U+D800..U+DBFF" และ ต่ำ ตัวแทน คือช่วง "U+DC00..U+DFFF" ตัวแทน
การเข้ารหัสคือ
$สูง = ($uni - 0x10000) / 0x400 + 0xD800;
$lo = ($uni - 0x10000) % 0x400 + 0xDC00;
และการถอดรหัสคือ
$uni = 0x10000 + ($สูง - 0xD800) * 0x400 + ($lo - 0xDC00);
เนื่องจากเป็น 16 บิต UTF-16 จึงขึ้นอยู่กับลำดับไบต์ สามารถใช้ UTF-16 ได้เอง
สำหรับการคำนวณในหน่วยความจำ แต่ถ้าจำเป็นต้องมีการจัดเก็บหรือถ่ายโอน UTF-16BE
ต้องเลือกการเข้ารหัส (big-endian) หรือ UTF-16LE (little-endian)
สิ่งนี้ทำให้เกิดปัญหาอีกอย่างหนึ่ง: ถ้าคุณเพิ่งรู้ว่าข้อมูลของคุณเป็น UTF-16 แต่
คุณไม่ทราบว่า endianness ใด? Byte Order Marks หรือ "BOM" เป็นวิธีแก้ปัญหา
นี้. อักขระพิเศษถูกสงวนไว้ใน Unicode เพื่อทำหน้าที่เป็นคำสั่งไบต์
เครื่องหมาย: อักขระที่มีจุดโค้ด "U+FEFF" คือ "BOM"
เคล็ดลับคือถ้าคุณอ่าน "BOM" คุณจะรู้ลำดับไบต์เพราะถ้าเป็น
เขียนบนแพลตฟอร์ม big-endian คุณจะอ่านไบต์ "0xFE 0xFF" แต่ถ้าเป็น
เขียนบนแพลตฟอร์ม little-endian คุณจะอ่านไบต์ "0xFF 0xFE" (และถ้า
แพลตฟอร์มต้นทางกำลังเขียนในแพลตฟอร์ม ASCII UTF-8 คุณจะอ่านไบต์
"0xEF 0xBB 0xBF")
วิธีการทำงานของเคล็ดลับนี้คืออักขระที่มีจุดโค้ด "U+FFFE" ไม่ใช่
ควรอยู่ในอินพุตสตรีม ดังนั้นลำดับของไบต์ "0xFF 0xFE" จึงไม่คลุมเครือ
""BOM" แสดงในรูปแบบ little-endian และไม่สามารถเป็น "U+FFFE" แสดงใน
รูปแบบบิ๊กเอนด์".
ตัวแทนเสมือนไม่มีความหมายใน Unicode นอกการใช้งานเป็นคู่เพื่อเป็นตัวแทนของผู้อื่น
จุดรหัส อย่างไรก็ตาม Perl อนุญาตให้แสดงเป็นรายบุคคลภายในสำหรับ
ตัวอย่างโดยพูดว่า "chr(0xD801)" เพื่อให้โค้ดทั้งหมดชี้ ไม่ใช่แค่โค้ดที่ใช้ได้สำหรับ
การแลกเปลี่ยนแบบเปิดเป็นตัวแทนได้ Unicode กำหนดความหมายสำหรับพวกเขาเช่น
"General_Category" ของพวกเขาคือ "Cs" แต่เนื่องจากการใช้งานค่อนข้างอันตราย Perl
จะเตือน (โดยใช้หมวดคำเตือน "ตัวแทน" ซึ่งเป็นหมวดย่อยของ "utf8")
หากพยายามทำสิ่งต่าง ๆ เช่นใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ตรงกัน
อย่างไม่แยแสหรือส่งออกไป (แต่อย่าลองทำกับ Perls ก่อน 5.14)
· UTF-32, UTF-32BE, UTF-32LE
ตระกูล UTF-32 ค่อนข้างเหมือนกับตระกูล UTF-16 ยกเว้นว่าหน่วยเป็น
32 บิต ดังนั้นจึงไม่จำเป็นต้องใช้รูปแบบตัวแทน UTF-32 เป็นความกว้างคงที่
การเข้ารหัส ลายเซ็น "BOM" คือ "0x00 0x00 0xFE 0xFF" สำหรับ BE และ "0xFF 0xFE 0x00
0x00" สำหรับ LE
· UCS-2, UCS-4
การเข้ารหัสแบบความกว้างคงที่แบบเดิมที่กำหนดโดยมาตรฐาน ISO 10646 UCS-2 เป็น 16 บิต
การเข้ารหัส ต่างจาก UTF-16 UCS-2 ไม่สามารถขยายเกิน "U+FFFF" ได้ เนื่องจากไม่
ใช้ตัวแทนเสมือน UCS-4 คือการเข้ารหัสแบบ 32 บิต ซึ่งทำงานเหมือนกับ UTF-32 (the
ความแตกต่างที่ UCS-4 ห้ามไม่ให้ตัวแทนเสมือนหรือจุดรหัสที่มากกว่า
"0x10_FFFF")
· UTF-7
การเข้ารหัสที่ปลอดภัยเจ็ดบิต (ไม่ใช่แปดบิต) ซึ่งมีประโยชน์หากการขนส่งหรือการจัดเก็บ
ไม่ปลอดภัยแปดบิต กำหนดโดย RFC 2152
ไม่ใช่ตัวละคร รหัส จุด
จุดรหัส 66 จุดถูกกันใน Unicode เป็น "จุดรหัสที่ไม่ใช่อักขระ" ทั้งหมดนี้มี
"Unassigned" ("Cn") "General_Category" และจะไม่มีการกำหนดอักขระใด ๆ ให้กับ
พวกเขา. คือ 32 จุดรหัสระหว่าง "U+FDD0" และ "U+FDEF" รวมและ 34
จุดรหัส:
U+FFFF ยู+FFFF
U+1FFFE ยู+1FFFF
U+2FFFE ยู+2FFFF
...
ยู+เอฟเฟ่ ยู+เอฟเฟฟ
U+FFFF ยู+FFFF
U+10FFFE ยู+10FFFF
จนกระทั่ง Unicode 7.0 ไม่มีอักขระเป็น "ที่ต้องห้าม เพื่อใช้ในการแลกเปลี่ยนแบบเปิดของ
ข้อมูลข้อความ Unicode" เพื่อให้โค้ดที่ประมวลผลสตรีมเหล่านั้นสามารถใช้จุดโค้ดเหล่านี้ได้
เป็นทหารรักษาการณ์ที่สามารถผสมกับข้อมูลตัวละครและจะเป็น
แยกจากข้อมูลนั้นได้ (เน้นด้านบนและในย่อหน้าถัดไปจะเพิ่มใน
เอกสารนี้.)
Unicode 7.0 เปลี่ยนถ้อยคำให้เป็น "ไม่ แนะนำ สำหรับใช้งานในที่โล่ง
การแลกเปลี่ยนข้อมูลข้อความ Unicode" มาตรฐาน 7.0 กล่าวต่อไปว่า:
"หากได้รับ noncharacter ในการแลกเปลี่ยนแบบเปิด แอปพลิเคชันไม่จำเป็นต้อง
ตีความไปในทางใดทางหนึ่ง อย่างไรก็ตาม เป็นแนวปฏิบัติที่ดีที่จะยอมรับว่าเป็น
ไม่ใช่อักขระและดำเนินการตามความเหมาะสม เช่น แทนที่ด้วย "U+FFFD"
อักขระทดแทนเพื่อระบุปัญหาในข้อความ ไม่แนะนำให้
เพียงแค่ลบจุดรหัสที่ไม่ใช่อักขระออกจากข้อความดังกล่าว เนื่องจากศักยภาพ
ปัญหาด้านความปลอดภัยที่เกิดจากการลบอักขระที่ไม่ได้ตีความ (ดูข้อความสอดคล้อง
C7 ในหัวข้อ 3.2 ข้อกำหนดด้านความสอดคล้อง และรายงานทางเทคนิค Unicode #36
"ข้อควรพิจารณาด้านความปลอดภัย Unicode"
<http://www.unicode.org/reports/tr36/#Substituting_for_Ill_Formed_Subsequences>)"
การเปลี่ยนแปลงนี้เกิดขึ้นเพราะพบว่าเครื่องมือทางการค้าต่างๆ เช่น บรรณาธิการ หรือ
สำหรับสิ่งต่าง ๆ เช่นการควบคุมซอร์สโค้ดถูกเขียนขึ้นเพื่อไม่ให้จัดการ
ไฟล์โปรแกรมที่ใช้โค้ดเหล่านี้ชี้นำ แทบไม่ใช้งานได้เลย
โดยสิ้นเชิง! และนั่นก็ไม่เคยมีเจตนา พวกมันถูกสร้างมาให้ใช้งานได้ตลอด
แอปพลิเคชันหรือชุดแอปพลิเคชันความร่วมมือตามความประสงค์
หากคุณกำลังเขียนโค้ด เช่น เอดิเตอร์ นั้นควรจะสามารถจัดการใดๆ ได้
ข้อมูลข้อความ Unicode คุณไม่ควรใช้รหัสเหล่านี้ชี้ตัวเองและแทน
อนุญาตให้พวกเขาป้อนข้อมูล หากคุณต้องการทหารรักษาการณ์ พวกเขาควรจะเป็นสิ่งที่
ไม่ใช่ Unicode ที่ถูกกฎหมาย สำหรับข้อมูล UTF-8 คุณสามารถใช้ไบต์ 0xC1 และ 0xC2 เป็นหน่วยพิทักษ์ได้ เช่น
พวกเขาไม่เคยปรากฏใน UTF-8 ที่มีรูปแบบที่ดี (มีค่าเทียบเท่าสำหรับ UTF-EBCDIC) คุณสามารถ
ยังเก็บจุดรหัส Unicode ของคุณในตัวแปรจำนวนเต็มและใช้ค่าลบเป็น
ยาม
หากคุณไม่ได้เขียนเครื่องมือดังกล่าว คุณจะยอมรับอักขระที่ไม่ใช่อักขระเป็นอินพุตหรือไม่ก็ขึ้นอยู่กับ
คุณ (แม้ว่ามาตรฐานจะไม่แนะนำคุณ) หากคุณทำการตรวจสอบสตรีมอินพุตอย่างเข้มงวด
ด้วย Perl จุดรหัสเหล่านี้ยังคงถูกห้าม นี่คือการรักษาถอยหลัง
ความเข้ากันได้ (มิฉะนั้น ช่องโหว่ด้านความปลอดภัยที่อาจเกิดขึ้นสามารถเปิดขึ้นได้
แอปพลิเคชันที่เขียนโดยสมมติว่าไม่มีอักขระจะถูกกรองออกก่อน
ไปถึงตอนนี้ได้โดยไม่มีการเตือนล่วงหน้า) เพื่อทำการตรวจสอบอย่างเข้มงวด
คุณสามารถใช้เลเยอร์ ":encoding('UTF-8')" ได้
Perl ยังคงเตือนต่อไป (โดยใช้หมวดคำเตือน "nonchar" ซึ่งเป็นหมวดย่อยของ
"utf8") หากมีความพยายามในการส่งออกอักขระที่ไม่ใช่อักขระ
เกิน Unicode รหัส จุด
จุดโค้ด Unicode สูงสุดคือ "U+10FFFF" และ Unicode กำหนดเฉพาะการดำเนินการกับโค้ด
ชี้ขึ้นผ่านสิ่งนั้น แต่ Perl ทำงานบนรหัสชี้ขึ้นสูงสุดที่อนุญาต
หมายเลขที่ไม่ได้ลงนามบนแพลตฟอร์ม อย่างไรก็ตาม Perl จะไม่ยอมรับสิ่งเหล่านี้จากการป้อนข้อมูล
สตรีมยกเว้นว่ามีการใช้กฎหละหลวม และจะเตือน (โดยใช้หมวดคำเตือน
"non_unicode" ซึ่งเป็นหมวดหมู่ย่อยของ "utf8") หากมีเอาต์พุต
เนื่องจากกฎ Unicode ไม่ได้กำหนดไว้บนจุดโค้ดเหล่านี้ หากการดำเนินการที่กำหนดด้วย Unicode
เสร็จสิ้นแล้ว Perl ใช้สิ่งที่เราเชื่อว่าเป็นกฎที่สมเหตุสมผล ในขณะที่โดยทั่วไปเตือน
โดยใช้หมวดหมู่ "non_unicode" ตัวอย่างเช่น "uc("\x{11_0000}")" จะสร้าง a . ดังกล่าว
คำเตือน ส่งคืนพารามิเตอร์อินพุตเป็นผลลัพธ์ เนื่องจาก Perl กำหนดตัวพิมพ์ใหญ่ของ
ทุกโค้ดที่ไม่ใช่ Unicode ชี้ไปที่โค้ดพอยต์เอง (ทุกกรณีเปลี่ยน
การดำเนินการ ไม่ใช่แค่ตัวพิมพ์ใหญ่ ทำงานในลักษณะนี้)
สถานการณ์ที่มีคุณสมบัติ Unicode ตรงกันในนิพจน์ทั่วไป "\p{}" และ
"\P{}" สร้างเทียบกับจุดโค้ดเหล่านี้ไม่ชัดเจนและเป็นอย่างไร
จัดการได้เปลี่ยนไปเมื่อเราได้รับประสบการณ์
ความเป็นไปได้อย่างหนึ่งคือถือว่าการจับคู่กับจุดโค้ดเหล่านี้ไม่ได้กำหนดไว้ แต่ตั้งแต่
Perl ไม่มีแนวคิดของการจับคู่ที่ไม่ได้กำหนด แต่จะแปลงสิ่งนี้เป็นความล้มเหลวหรือ
"เท็จ". เกือบจะเป็นอย่างนั้น แต่ก็ไม่ใช่สิ่งที่ Perl ทำจาก v5.14 (เมื่อใช้รหัสเหล่านี้
คะแนนมักจะเชื่อถือได้) จนถึง v5.18 ความแตกต่างคือ Perl ปฏิบัติต่อทุกคน
"\p{}" จับคู่ว่าล้มเหลว แต่ "\P{}" ทั้งหมดตรงกันว่าสำเร็จ
ปัญหาหนึ่งของสิ่งนี้คือมันนำไปสู่ผลลัพธ์ที่ไม่คาดคิดและสับสนในบางอย่าง
กรณี:
chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # ล้มเหลวเมื่อ <= v5.18
chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # ล้มเหลว! บน <= v5.18
กล่าวคือ ถือว่าทั้งสองแมตช์ไม่ได้กำหนด และแปลงเป็นเท็จ (เพิ่ม a
คำเตือนในแต่ละ). กรณีแรกเป็นผลที่คาดหวัง แต่กรณีที่สองมีแนวโน้ม
counterintuitive: "ทั้งสองจะเป็นเท็จได้อย่างไรเมื่อเป็นส่วนเสริม" ปัญหาอื่น
คือการใช้งานได้ปรับคุณสมบัติ Unicode ให้เหมาะสมที่สุดแล้ว
การดำเนินการที่มีอยู่ง่ายกว่าและเร็วกว่าซึ่งไม่ส่งคำเตือน เราเลือกที่จะไม่ทอดทิ้ง
การเพิ่มประสิทธิภาพเหล่านั้น ซึ่งช่วยให้การแข่งขันส่วนใหญ่ สร้างคำเตือน
สำหรับเหตุการณ์ที่ไม่น่าจะเป็นไปได้ที่มีการจับคู่จุดโค้ด Unicode ด้านบน
จากปัญหาเหล่านี้ การเริ่มใน v5.20 สิ่งที่ Perl ทำคือจัดการกับ non-Unicode
โค้ดชี้เป็นอักขระ Unicode ที่ไม่ได้กำหนดโดยทั่วไป และจับคู่ตามนั้น
(หมายเหตุ: Unicode มีจุดโค้ดที่ไม่ได้กำหนดผิดปกติ เช่น มีโค้ดที่ไม่ใช่อักขระ
คะแนนและคะแนนที่เมื่อได้รับมอบหมายแล้วจะถูกลิขิตให้เขียนว่า
ซ้ายตามที่เป็นภาษาอาหรับและฮิบรู Perl ถือว่าไม่มีจุดโค้ดที่ไม่ใช่ Unicode ใด ๆ
คุณสมบัติผิดปรกติ)
ในกรณีส่วนใหญ่ Perl จะส่งคำเตือนเมื่อจับคู่จุดโค้ด Unicode ด้านบน
เทียบกับคุณสมบัติ Unicode เมื่อผลลัพธ์เป็น "TRUE" สำหรับ "\p{}" และ "FALSE" สำหรับ "\P{}"
ตัวอย่างเช่น:
chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # ล้มเหลว ไม่มีการเตือน
chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # สำเร็จพร้อมคำเตือน
ในทั้งสองตัวอย่างนี้ อักขระที่จับคู่ไม่ใช่ Unicode ดังนั้น Unicode จึงไม่
กำหนดว่าควรจับคู่อย่างไร เห็นได้ชัดว่าไม่ใช่เลขฐานสิบหก ASCII ดังนั้นตัวอย่างแรก
เห็นได้ชัดว่าควรล้มเหลว และเป็นเช่นนั้นโดยไม่มีการเตือนล่วงหน้า แต่ก็เป็นที่ถกเถียงกันอยู่ว่าข้อที่สอง
ตัวอย่างควรมีไม่ได้กำหนด ดังนั้นผลลัพธ์ "FALSE" ดังนั้นจึงมีการตักเตือน
ดังนั้นคำเตือนจึงถูกยกขึ้นสำหรับกรณีที่น้อยกว่าใน Perls ก่อนหน้านี้และเฉพาะเมื่อ what
ผลที่ได้คือสามารถโต้แย้งได้ ปรากฎว่าไม่มีการเพิ่มประสิทธิภาพใดๆ ที่ทำโดย Perl
(หรือมีแนวโน้มว่าจะเคยทำ) ทำให้ข้ามคำเตือนไปจึงแก้ทั้งสองอย่าง
ปัญหาของแนวทางก่อนหน้าของ Perl ทรัพย์สินที่ใช้บ่อยที่สุดที่ได้รับผลกระทบจาก
การเปลี่ยนแปลงนี้คือ "\p{Unassigned}" ซึ่งเป็นรูปแบบย่อสำหรับ
"\p{General_Category=Unassigned}". เริ่มต้นใน v5.20 จุดโค้ดที่ไม่ใช่ Unicode ทั้งหมดจะเป็น
ถือว่า "ไม่ได้มอบหมาย" ในรุ่นก่อนหน้านี้ แมตช์ล้มเหลวเพราะผลลัพธ์คือ
ถือว่าไม่ได้กำหนด
ที่เดียวที่ไม่เตือนเมื่อควรจะเป็นคือถ้า
การเพิ่มประสิทธิภาพทำให้ไม่พยายามจับคู่รูปแบบทั้งหมดด้วยซ้ำ ตัวอย่างเช่น Perl
อาจพบว่าสำหรับสตริงที่ตรงกับรูปแบบนิพจน์ทั่วไปบางอย่าง string
จะต้องมีสตริงย่อย "foobar" ก่อนทำการแข่งขัน Perl อาจมองหา
สตริงย่อยนั้น และหากไม่พบ จะล้มเหลวในการจับคู่ทันทีโดยไม่ได้ลองใช้งานจริง
ดังนั้นจึงไม่มีการสร้างคำเตือนแม้ว่าสตริงจะมีจุดโค้ด Unicode ด้านบน
ลักษณะการทำงานนี้เป็น "ทำในสิ่งที่ฉันหมายถึง" มากกว่าใน Perls ก่อนหน้าสำหรับแอปพลิเคชันส่วนใหญ่ แต่
มันจับปัญหาน้อยลงสำหรับรหัสที่ต้องปฏิบัติตาม Unicode อย่างเคร่งครัด ดังนั้น
มีโหมดการทำงานเพิ่มเติมเพื่อรองรับรหัสดังกล่าว โหมดนี้คือ
เปิดใช้งานหากรูปแบบนิพจน์ทั่วไปถูกคอมไพล์ภายในขอบเขตคำศัพท์ที่
คลาสคำเตือน "non_unicode" เป็นอันตรายถึงชีวิต พูดโดย:
ใช้คำเตือน FATAL => "non_unicode"
(ดูคำเตือน). ในโหมดการทำงานนี้ Perl จะเพิ่มคำเตือนสำหรับการแข่งขันทั้งหมด
เทียบกับจุดโค้ดที่ไม่ใช่ Unicode (ไม่ใช่แค่จุดที่สามารถโต้แย้งได้) และจะข้าม
การเพิ่มประสิทธิภาพที่อาจทำให้คำเตือนไม่แสดงผล (ตอนนี้ก็ยังไม่ใช่
เตือนหากไม่ได้พยายามจับคู่เหมือนในตัวอย่าง "foobar" ด้านบน)
โดยสรุปแล้ว Perl ปกติแล้วจะถือว่าจุดโค้ดที่ไม่ใช่ Unicode เป็น Unicode ทั่วไปที่ไม่ได้กำหนด
รหัสชี้สำหรับการจับคู่นิพจน์ทั่วไป เพิ่มคำเตือนเฉพาะเมื่อสามารถโต้แย้งได้
ผลลัพธ์ควรเป็นอย่างไร อย่างไรก็ตาม หากคำเตือนนี้ทำให้ถึงแก่ชีวิต มันไม่ใช่
ข้ามไป
มีข้อยกเว้นประการหนึ่งสำหรับทั้งหมดนี้ "\p{All}" ดูเหมือนคุณสมบัติ Unicode แต่มันคือ a
ส่วนขยาย Perl ที่ถูกกำหนดให้เป็นจริงสำหรับจุดโค้ดที่เป็นไปได้ทั้งหมด ไม่ว่าจะเป็น Unicode หรือไม่ ดังนั้น
ไม่มีการเตือนเมื่อจับคู่สิ่งนี้กับจุดโค้ดที่ไม่ใช่ Unicode (ก่อน
ถึง v5.20 เป็นคำพ้องความหมายที่แน่นอนสำหรับ "\p{Any}" โค้ดที่ตรงกันจะชี้ 0 ถึง 0x10FFFF)
ความปลอดภัย ผลกระทบ of Unicode
ขั้นแรก อ่านข้อควรพิจารณาด้านความปลอดภัย Unicodehttp://www.unicode.org/reports/tr36>.
นอกจากนี้ โปรดทราบสิ่งต่อไปนี้:
· UTF-8 . ผิดรูปแบบ
น่าเสียดายที่ข้อกำหนดดั้งเดิมของ UTF-8 ทำให้มีที่ว่างสำหรับการตีความ
ของจำนวนไบต์ของเอาต์พุตที่เข้ารหัสที่ควรสร้างจากอินพุตเดียว Unicode
อักขระ. พูดอย่างเคร่งครัด ลำดับที่สั้นที่สุดที่เป็นไปได้ของไบต์ UTF-8 ควรเป็น
สร้างขึ้นเพราะไม่เช่นนั้นอาจมีบัฟเฟอร์อินพุตล้นที่
รับการสิ้นสุดการเชื่อมต่อ UTF-8 Perl จะสร้าง UTF-8 ที่สั้นที่สุดเสมอ
และเมื่อเปิดคำเตือน Perl จะเตือนเกี่ยวกับความยาวที่ไม่สั้นที่สุด UTF-8 พร้อมกับอื่นๆ
ความผิดปกติเช่นตัวแทนเสมือนซึ่งไม่ใช่จุดรหัส Unicode ที่ถูกต้องสำหรับ
แลกเปลี่ยนกัน.
· การจับคู่รูปแบบนิพจน์ทั่วไปอาจทำให้คุณประหลาดใจหากคุณไม่คุ้นเคย
ยูนิโค้ด เริ่มต้นใน Perl 5.14 ตัวปรับแต่งรูปแบบหลายตัวพร้อมให้ควบคุม
นี้เรียกว่าตัวดัดแปลงชุดอักขระ รายละเอียดอยู่ใน "ชุดตัวละคร
ตัวแก้ไข" ใน perlre
ตามที่กล่าวไว้ในที่อื่น Perl มีเท้าข้างหนึ่ง (สองกีบ?) ที่ปลูกไว้ในแต่ละโลกทั้งสอง:
โลกเก่าของ ASCII และโลแคลแบบไบต์เดียว และโลกใหม่ของ Unicode อัปเกรดเมื่อ
จำเป็น. หากรหัสเดิมของคุณไม่ได้ใช้ Unicode อย่างชัดแจ้ง จะไม่มีการเปลี่ยนอัตโนมัติ
ถึง Unicode ควรเกิดขึ้น
Unicode in Perl on EBCDI
รองรับ Unicode บนแพลตฟอร์ม ECDIC ดู เพอเลลบิก
เว้นแต่จะมีการกล่าวถึงประเด็น ASCII กับ EBCDIC โดยเฉพาะ การอ้างอิงถึง UTF-8
การเข้ารหัสในเอกสารนี้และที่อื่นๆ ควรอ่านว่าหมายถึง UTF-EBCDIC บน EBCDIC
แพลตฟอร์ม ดู "Unicode และ UTF" ใน perlebcdic
เนื่องจาก UTF-EBCDIC นั้นคล้ายกับ UTF-8 มาก ความแตกต่างส่วนใหญ่จึงถูกซ่อนจากคุณ
"use utf8" (และไม่ใช่แบบ "use utfebcdic") ประกาศว่าสคริปต์อยู่ใน
การเข้ารหัส Unicode 8 บิต "ดั้งเดิม" ของแพลตฟอร์ม (คล้ายกับเลเยอร์ ":utf8")
สถานที่
ดู "Unicode และ UTF-8" ใน perllocale
เมื่อ Unicode ไม่ ไม่ เกิดขึ้น
ยังมีอีกหลายที่ที่สามารถให้ Unicode (ในการเข้ารหัสบางอย่างหรืออย่างอื่น) เป็น
ข้อโต้แย้งหรือได้รับเป็นผลหรือทั้งสองอย่างในภาษา Perl แต่ก็ไม่ใช่ทั้งๆ ที่ Perl จะมี
วิธีมากมายในการป้อนข้อมูลและส่งออกใน Unicode และ "จุดเข้าใช้งาน" อื่น ๆ อีกสองสามอย่างเช่น
@ARGV อาร์เรย์ (ซึ่งบางครั้งสามารถตีความได้ว่าเป็น UTF-8)
ต่อไปนี้เป็นอินเทอร์เฟซดังกล่าว โปรดดู "ข้อผิดพลาด Unicode" ด้วย ทั้งหมดนี้
อินเทอร์เฟซ Perl ในปัจจุบัน (ณ v5.16.0) เพียงแค่ถือว่าสตริงไบต์ทั้งสองเป็นอาร์กิวเมนต์
และผลลัพธ์หรือสตริง UTF-8 หากใช้ Pragma "เข้ารหัส" (เลิกใช้แล้ว)
เหตุผลหนึ่งที่ Perl ไม่พยายามแก้ไขบทบาทของ Unicode ในสถานการณ์เหล่านี้
คือคำตอบนั้นขึ้นอยู่กับระบบปฏิบัติการและระบบไฟล์เป็นอย่างมาก
ตัวอย่างเช่น ชื่อไฟล์สามารถเป็น Unicode ได้หรือไม่และเข้ารหัสแบบใดกันแน่ is
ไม่ใช่แนวคิดแบบพกพาอย่างแน่นอน ในทำนองเดียวกันสำหรับ "qx" และ "system": . จะดีเพียงใด
"อินเทอร์เฟซบรรทัดคำสั่ง" (และอันไหนในนั้น) จัดการ Unicode
· "chdir", "chmod", "chown", "chroot", "exec", "link", "lstat", "mkdir", "rename",
"rmdir", "stat", "symlink", "truncate", "unlink", "utime", "-X"
· %ENV
· "glob" (หรือที่รู้จักว่า "<*>")
· "เปิด", "opendir", "sysopen"
· "qx" (หรือที่รู้จักว่าตัวดำเนินการ backtick), "ระบบ"
· "readdir", "ลิงก์อ่าน"
เค้ก "ยูนิโคด บัก"
คำว่า "จุดบกพร่อง Unicode" ถูกนำไปใช้กับความไม่สอดคล้องกับจุดรหัสใน
บล็อก "Latin-1 Supplement" นั่นคือระหว่าง 128 ถึง 255 โดยไม่มีการระบุสถานที่
ไม่เหมือนกับอักขระหรือโค้ดโค้ดอื่นๆ ทั้งหมด อักขระเหล่านี้อาจแตกต่างกันมาก
ความหมายขึ้นอยู่กับกฎที่มีผล (อักขระที่มีจุดรหัสสูงกว่า255
บังคับกฎ Unicode ในขณะที่กฎสำหรับอักขระ ASCII จะเหมือนกันทั้ง ASCII
และกฎ Unicode)
ภายใต้กฎ Unicode อักขระ Latin1 ตัวบนเหล่านี้จะถูกตีความเป็นจุดโค้ด Unicode
ซึ่งหมายความว่ามีความหมายเดียวกันกับตัวควบคุม Latin-1 (ISO-8859-1) และ C1
ตามที่อธิบายไว้ใน "กฎ ASCII กับกฎ Unicode" ภายใต้กฎ ASCII จะได้รับการพิจารณา
เป็นอักขระที่ไม่ได้กำหนด
นี้สามารถนำไปสู่ผลลัพธ์ที่ไม่คาดคิด ตัวอย่างเช่น ความหมายของสตริงสามารถเกิดขึ้นได้ในทันใด
เปลี่ยนหากมีการเพิ่มจุดโค้ดที่สูงกว่า 255 ซึ่งจะเปลี่ยนกฎจาก ASCII เป็น
ยูนิโค้ด ตัวอย่างเช่น ให้พิจารณาโปรแกรมต่อไปนี้และผลลัพธ์ของโปรแกรม:
$ perl -le'
ไม่มีคุณลักษณะ 'unicode_strings';
$s1 = "\xC2";
$s2 = "\x{2660}";
สำหรับ ($s1, $s2, $s1.$s2) {
พิมพ์ /\w/ || 0;
}
'
0
0
1
หากไม่มี "\w" ใน "s1" หรือใน "s2" เหตุใดการเรียงต่อกันจึงมี
ความผิดปกตินี้เกิดจากความพยายามของ Perl ที่จะไม่รบกวนโปรแกรมเก่าที่ไม่ได้ใช้
Unicode ควบคู่ไปกับความต้องการของ Perl ในการเพิ่มการสนับสนุน Unicode อย่างราบรื่น แต่ผลลัพธ์
กลับกลายเป็นว่าไม่ราบรื่น (อีกอย่างจะเลือกเตือนเมื่อเรื่องอย่าง
สิ่งนี้เกิดขึ้น ดู "การเข้ารหัส :: คำเตือน")
เพิ่ม "ใช้คุณสมบัติ 'unicode_strings'" โดยเริ่มใน Perl v5.12 เพื่อแก้ไขปัญหานี้
ปัญหา. มันส่งผลกระทบต่อสิ่งเหล่านี้:
· เปลี่ยนตัวพิมพ์ของสเกลาร์ นั่นคือ ใช้ "uc()", "ucfirst()", "lc()" และ
"lcfirst()" หรือ "\L", "\U", "\u" และ "\l" ในบริบทที่มีเครื่องหมายอัญประกาศคู่ เช่น ปกติ
การแทนที่นิพจน์
ภายใต้ "unicode_strings" ที่เริ่มต้นใน Perl 5.12.0 โดยทั่วไปจะใช้กฎ Unicode
ดู "lc" ใน perlfunc สำหรับรายละเอียดเกี่ยวกับวิธีการทำงานนี้ร่วมกับส่วนอื่นๆ
แพรกมา
· ใช้การจับคู่นิพจน์ทั่วไปแบบไม่มีกรณี ("/i")
เริ่มต้นใน Perl 5.14.0 นิพจน์ทั่วไปที่คอมไพล์ภายในขอบเขตของ
"unicode_strings" ใช้กฎ Unicode แม้ว่าจะดำเนินการหรือคอมไพล์เป็นค่าปกติที่ใหญ่กว่า
นิพจน์ที่อยู่นอกขอบเขต
· จับคู่คุณสมบัติต่างๆ ในนิพจน์ทั่วไป
คุณสมบัติเหล่านี้คือ "\b" (ไม่มีเครื่องหมายวงเล็บปีกกา), "\B" (ไม่มีเครื่องหมายวงเล็บปีกกา), "\s", "\S", "\w",
"\W" และคลาสอักขระ Posix ทั้งหมด ยกเว้น "[[:ascii:]]".
เริ่มต้นใน Perl 5.14.0 นิพจน์ทั่วไปที่คอมไพล์ภายในขอบเขตของ
"unicode_strings" ใช้กฎ Unicode แม้ว่าจะดำเนินการหรือคอมไพล์เป็นค่าปกติที่ใหญ่กว่า
นิพจน์ที่อยู่นอกขอบเขต
· ใน "quotemeta" หรือเทียบเท่าในบรรทัด "\Q"
เริ่มต้นใน Perl 5.16.0 กฎการเสนอราคาที่สอดคล้องกันจะใช้ภายในขอบเขตของ
"unicode_strings" ตามที่อธิบายไว้ใน "quotemeta" ใน perlfunc ก่อนหน้านั้นหรือภายนอก
ขอบเขตไม่มีจุดโค้ดที่สูงกว่า 127 ในสตริงที่เข้ารหัส UTF-8 แต่เป็นไบต์
สตริงที่เข้ารหัส จุดรหัสระหว่าง 128-255 จะถูกยกมาเสมอ
จากข้างบนจะเห็นได้ว่าเอฟเฟกต์ของ "unicode_strings" เพิ่มขึ้นหลายเท่า
Perl เปิดตัว (และการสนับสนุนของ Perl สำหรับ Unicode ยังคงปรับปรุงต่อไป เป็นการดีที่สุดที่จะใช้
รุ่นล่าสุดที่มีอยู่เพื่อให้ได้ผลลัพธ์ที่สมบูรณ์และแม่นยำที่สุด)
โปรดทราบว่า "unicode_strings" จะถูกเลือกโดยอัตโนมัติหากคุณ "ใช้ 5.012" หรือสูงกว่า
สำหรับ Perls ที่เก่ากว่าที่อธิบายไว้ข้างต้น หรือเมื่อสตริงถูกส่งผ่านไปยังฟังก์ชัน
นอกขอบเขตของ "unicode_strings" ดูหัวข้อถัดไป
พระเดช Unicode in Perl (หรือ ไม่บังคับ Unicode in เพิร์ล)
บางครั้ง (ดู "เมื่อ Unicode ไม่เกิดขึ้น" หรือ "Unicode Bug"") มีสถานการณ์
โดยที่คุณเพียงแค่บังคับสตริงไบต์ให้เป็น UTF-8 หรือในทางกลับกัน มาตรฐาน
โมดูลการเข้ารหัสสามารถใช้สำหรับสิ่งนี้ หรือการเรียกระดับต่ำ "utf8::upgrade($bytestring)"
และ "utf8::downgrade($utf8string[, FAIL_OK])"
โปรดทราบว่า "utf8::downgrade()" อาจล้มเหลวหากสตริงมีอักขระที่ไม่พอดี
เป็นไบต์
การเรียกฟังก์ชันใดฟังก์ชันหนึ่งบนสตริงที่อยู่ในสถานะที่ต้องการอยู่แล้วจะถือเป็นการไม่ดำเนินการ
"กฎ ASCII กับกฎ Unicode" ให้วิธีการทั้งหมดที่สตริงถูกสร้างขึ้นเพื่อใช้ Unicode
กฎระเบียบ
การใช้ Unicode in XS
ดู "การสนับสนุน Unicode" ใน perlguts สำหรับการแนะนำ Unicode ที่ระดับ XS และ
"การสนับสนุน Unicode" ใน perlapi สำหรับรายละเอียด API
แฮ็ค Perl ไปยัง งาน on ก่อน Unicode รุ่น (สำหรับ มาก ร้ายแรง แฮกเกอร์ เท่านั้น)
โดยค่าเริ่มต้น Perl มาพร้อมกับ Unicode เวอร์ชันล่าสุดที่รองรับในตัว แต่เป้าหมายคือ
เพื่อให้คุณสามารถเปลี่ยนไปใช้อันใดอันหนึ่งก่อนหน้านี้ได้ อย่างไรก็ตาม ใน Perls v5.20 และ v5.22 นั้น
เวอร์ชันแรกสุดที่ใช้งานได้คือ Unicode 5.1 Perl v5.18 สามารถจัดการได้ก่อนหน้านี้ทั้งหมด
รุ่นที่
ดาวน์โหลดไฟล์ใน Unicode เวอร์ชันที่ต้องการจากเว็บไซต์ Unicode
<http://www.unicode.org>). สิ่งเหล่านี้ควรแทนที่ไฟล์ที่มีอยู่ใน lib/ยูนิคอร์ ที่
ต้นไม้ต้นทางของ Perl ปฏิบัติตามคำแนะนำใน README.perl ในไดเร็กทอรีนั้นเพื่อเปลี่ยนบางอย่าง
ของชื่อแล้วสร้าง Perl (ดู INSTALL)
แจง รหัส จาก เพิร์ล-5.6.X
Perls ที่เริ่มต้นใน 5.8 มีรูปแบบ Unicode ที่แตกต่างจาก 5.6 ใน 5.6 โปรแกรมเมอร์เคยเป็น
จำเป็นต้องใช้ Pragma "utf8" เพื่อประกาศว่าขอบเขตที่กำหนดคาดว่าจะจัดการกับ
ข้อมูล Unicode และต้องตรวจสอบให้แน่ใจว่ามีเพียงข้อมูล Unicode เท่านั้นที่เข้าถึงขอบเขตนั้น ถ้าคุณ
มีรหัสที่ใช้งานได้กับ 5.6 คุณจะต้องมีการปรับเปลี่ยนบางอย่างต่อไปนี้เพื่อ
รหัสของคุณ ตัวอย่างถูกเขียนขึ้นเพื่อให้โค้ดทำงานต่อไปภายใต้ 5.6 ดังนั้น
คุณควรปลอดภัยที่จะลองใช้มัน
· filehandle ที่ควรอ่านหรือเขียน UTF-8
ถ้า ($] > 5.008) {
binmode $fh, ":การเข้ารหัส(utf8)";
}
· สเกลาร์ที่จะส่งต่อไปยังส่วนขยายบางส่วน
ไม่ว่าจะเป็น "Compress::Zlib", "Apache::Request" หรือส่วนขยายใดๆ ที่ไม่มีการกล่าวถึง
Unicode ใน manpage คุณต้องตรวจสอบให้แน่ใจว่าแฟล็ก UTF8 ถูกถอดออก บันทึก
ว่าในขณะที่เขียนนี้ (มกราคม 2012) โมดูลที่กล่าวถึงไม่ได้
UTF-8-ทราบ โปรดตรวจสอบเอกสารเพื่อตรวจสอบว่ายังคงเป็นจริงหรือไม่
ถ้า ($] > 5.008) {
ต้องการการเข้ารหัส;
$val = เข้ารหัส::encode_utf8($val); #ทำออคเต็ท
}
· สเกลาร์ที่เราได้กลับมาจากการต่อเติม
หากคุณเชื่อว่าสเกลาร์กลับมาเป็น UTF-8 คุณน่าจะต้องการแฟล็ก UTF8 มากที่สุด
คืนค่า:
ถ้า ($] > 5.008) {
ต้องการการเข้ารหัส;
$val = เข้ารหัส::decode_utf8($val);
}
· สิ่งเดียวกัน ถ้าคุณแน่ใจว่าเป็น UTF-8
ถ้า ($] > 5.008) {
ต้องการการเข้ารหัส;
เข้ารหัส::_utf8_on($val);
}
· เสื้อคลุมสำหรับ DBI "fetchrow_array" และ "fetchrow_hashref"
เมื่อฐานข้อมูลมีเพียง UTF-8 ฟังก์ชันหรือเมธอดของ wrapper จะเป็นวิธีที่สะดวก
เพื่อแทนที่การเรียก "fetchrow_array" และ "fetchrow_hashref" ทั้งหมดของคุณ ฟังก์ชั่นห่อหุ้ม
ยังช่วยให้ปรับให้เข้ากับการปรับปรุงในอนาคตในไดรเวอร์ฐานข้อมูลของคุณได้ง่ายขึ้น บันทึก
ว่าในขณะที่เขียนนี้ (มกราคม 2012) DBI ไม่มีวิธีมาตรฐานในการ
จัดการกับข้อมูล UTF-8 โปรดตรวจสอบเอกสารของ DBI เพื่อตรวจสอบว่ายังคงอยู่หรือไม่
จริง
การดึงข้อมูลย่อย {
# $สิ่งที่เป็น fetchrow_{array,hashref} คืออะไร
ของฉัน($ตัวเอง, $sth, $อะไร) = @_;
ถ้า ($] <5.008) {
คืนค่า $sth->$what;
} else {
ต้องการการเข้ารหัส;
ถ้า (wantarray) {
@arr ของฉัน = $sth->$what;
สำหรับ (@arr) {
กำหนด && /[^\000-\177]/ && เข้ารหัส::_utf8_on($_);
}
กลับมา @arr;
} else {
$ret ของฉัน = $sth->$what;
ถ้า (อ้างอิง $ ret) {
สำหรับ $k ของฉัน (คีย์ %$ret) {
กำหนด
&& /[^\000-\177]/
&& เข้ารหัส::_utf8_on($_) สำหรับ $ret->{$k};
}
คืนค่า $ret;
} else {
กำหนด && /[^\000-\177]/ && เข้ารหัส::_utf8_on($_) สำหรับ $ret;
คืนค่า $ret;
}
}
}
}
· สเกลาร์ขนาดใหญ่ที่คุณรู้จักสามารถบรรจุ ASCII . ได้เท่านั้น
สเกลาร์ที่มีเฉพาะ ASCII และทำเครื่องหมายเป็น UTF-8 บางครั้งอาจลากมาที่ .ของคุณ
โปรแกรม. หากคุณรู้จักสถานการณ์ดังกล่าว เพียงลบแฟล็ก UTF8:
utf8::downgrade($val) ถ้า $] > 5.008;
ใช้ perlunicode ออนไลน์โดยใช้บริการ onworks.net
