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

ซึ่งนับว่ามากทีเดียว รายละเอียดการปรับปรุงที่สำคัญมีดังนี้
color-mixตัวอย่างที่แสดงอาร์กิวเมนต์สี 2 รายการภายในฟังก์ชันcolor-mixpinkตัวอย่างสีที่คลิกได้สำหรับสีpinkที่มีชื่อ คลิกเพื่อเปิดตัวเลือกสีเพื่อให้ปรับแต่งได้ง่ายๆvar(--undefined, [fallback value])ปรับปรุงการจัดการตัวแปรที่ไม่ได้กำหนด โดยตัวแปรที่ไม่ได้กำหนดจะเป็นสีเทา และค่าสำรองที่ใช้งานอยู่ (ในกรณีนี้คือสี HSL) จะแสดงพร้อมตัวอย่างสีที่คลิกได้hsl(…): ตัวอย่างสีที่คลิกได้อีกรายการสำหรับฟังก์ชันสีhslซึ่งช่วยให้เข้าถึงตัวเลือกสีได้อย่างรวดเร็ว177deg: นาฬิกามุมที่คลิกได้ ซึ่งช่วยให้คุณลากและแก้ไขค่ามุมแบบอินเทอร์แอกทีฟได้var(--saturation, …): ลิงก์ที่คลิกได้ไปยังคำจำกัดความของคุณสมบัติที่กำหนดเอง ซึ่งช่วยให้ข้ามไปยังการประกาศที่เกี่ยวข้องได้อย่างง่ายดาย
ความแตกต่างนั้นชัดเจนมาก เพื่อให้บรรลุเป้าหมายนี้ เราต้องสอนเครื่องมือสำหรับนักพัฒนาเว็บให้เข้าใจค่าพร็อพเพอร์ตี้ CSS ได้ดีกว่าเดิมมาก
ตัวอย่างเหล่านี้มีให้บริการอยู่แล้วไม่ใช่หรือ
แม้ว่าไอคอนแสดงตัวอย่างเหล่านี้อาจดูคุ้นเคย แต่ก็ไม่ได้แสดงอย่างสม่ำเสมอเสมอไป โดยเฉพาะในไวยากรณ์ CSS ที่ซับซ้อนดังตัวอย่างด้านบน แม้ในกรณีที่ใช้งานได้ ก็มักจะต้องใช้ความพยายามอย่างมากเพื่อให้ทำงานได้อย่างถูกต้อง
สาเหตุคือระบบวิเคราะห์ค่ามีการเติบโตอย่างเป็นธรรมชาติมาตั้งแต่ช่วงแรกๆ ของเครื่องมือสำหรับนักพัฒนาเว็บ อย่างไรก็ตาม เครื่องมือนี้ไม่สามารถตามทันฟีเจอร์ใหม่ๆ ที่น่าทึ่งที่เราได้รับจาก CSS และความซับซ้อนของภาษาที่เพิ่มขึ้นตามไปด้วย ระบบจำเป็นต้องได้รับการออกแบบใหม่ทั้งหมดเพื่อให้ทันกับวิวัฒนาการ และนั่นคือสิ่งที่เราทำ
วิธีประมวลผลค่าพร็อพเพอร์ตี้ CSS
ในเครื่องมือสำหรับนักพัฒนาเว็บ กระบวนการแสดงผลและการตกแต่งการประกาศพร็อพเพอร์ตี้ในแท็บรูปแบบจะแบ่งออกเป็น 2 ระยะที่แตกต่างกัน ดังนี้
- การวิเคราะห์โครงสร้าง ระยะเริ่มต้นนี้จะแยกการประกาศพร็อพเพอร์ตี้เพื่อระบุคอมโพเนนต์ที่สำคัญและความสัมพันธ์ของคอมโพเนนต์เหล่านั้น เช่น ในการประกาศ
border: 1px solid redระบบจะจดจำ1pxเป็นความยาวsolidเป็นสตริง และredเป็นสี - กำลังแสดงผล เมื่อต่อยอดจากการวิเคราะห์โครงสร้างแล้ว ขั้นตอนการแสดงผลจะแปลงคอมโพเนนต์เหล่านี้เป็นการแสดงผล HTML ซึ่งจะช่วยเพิ่มองค์ประกอบแบบอินเทอร์แอกทีฟและภาพที่ช่วยให้เข้าใจง่ายให้กับข้อความที่พักที่แสดง เช่น ค่าสี
redจะแสดงผลด้วยไอคอนสีที่คลิกได้ ซึ่งเมื่อคลิกแล้วจะแสดงตัวเลือกสีเพื่อให้แก้ไขได้ง่าย
นิพจน์ทั่วไป
ก่อนหน้านี้ เราอาศัยนิพจน์ทั่วไป (Regex) เพื่อแยกค่าพร็อพเพอร์ตี้สำหรับการวิเคราะห์โครงสร้าง เราเก็บรายการนิพจน์ทั่วไปไว้เพื่อจับคู่บิตของค่าพร็อพเพอร์ตี้ที่เราพิจารณาว่าเป็นการตกแต่ง ตัวอย่างเช่น มีนิพจน์ที่ตรงกับสี CSS, ความยาว, มุม, นิพจน์ย่อยที่ซับซ้อนมากขึ้น เช่น การเรียกใช้ฟังก์ชัน var และอื่นๆ เราสแกนข้อความจากซ้ายไปขวาเพื่อวิเคราะห์ค่า โดยมองหานิพจน์แรกจากรายการที่ตรงกับข้อความถัดไปอย่างต่อเนื่อง
แม้ว่าวิธีนี้จะได้ผลดีในกรณีส่วนใหญ่ แต่จำนวนเคสที่ไม่ได้ผลก็เพิ่มขึ้นเรื่อยๆ หลายปีที่ผ่านมา เราได้รับรายงานข้อบกพร่องจำนวนมากที่การจับคู่ไม่ถูกต้อง เมื่อเราแก้ไขปัญหาเหล่านั้น ซึ่งบางปัญหาก็แก้ไขได้ง่ายๆ แต่บางปัญหาก็ค่อนข้างซับซ้อน เราจึงต้องคิดใหม่เกี่ยวกับแนวทางในการป้องกันไม่ให้เกิดหนี้ทางเทคนิค มาดูปัญหาบางส่วนกัน
กำลังจับคู่ color-mix()
นิพจน์ทั่วไปที่เราใช้สำหรับฟังก์ชัน color-mix() คือดังนี้
/color-mix\(.*,\s*(?<firstColor>.+)\s*,\s*(?<secondColor>.+)\s*\)/g
ซึ่งตรงกับไวยากรณ์ต่อไปนี้
color-mix(<color-interpolation-method>, [<color> && <percentage [0,100]>?]#{2})
ลองเรียกใช้ตัวอย่างต่อไปนี้เพื่อแสดงภาพการจับคู่
const re = /color-mix\(.*,\s*(?<firstColor>.+)\s*,\s*(?<secondColor>.+)\s*\)/g;
// it works - simpler example
const simpler = re.exec('color-mix(in srgb, pink, hsl(127deg 100% 50%))');
console.table(simpler.groups);
re.exec('');
// it doesn't work - complex example
const complex = re.exec('color-mix(in srgb, pink, var(--undefined, hsl(127deg var(--saturation, 100%) 50%)))');
console.table(complex.groups);

ตัวอย่างที่ง่ายกว่านี้ก็ใช้ได้ดี อย่างไรก็ตาม ในตัวอย่างที่ซับซ้อนกว่านี้ การจับคู่ <firstColor> คือ hsl(177deg var(--saturation และการจับคู่ <secondColor> คือ 100%) 50%)) ซึ่งไม่มีความหมายเลย
เราทราบดีว่านี่เป็นปัญหา ท้ายที่สุดแล้ว CSS ในฐานะภาษาทางการนั้นไม่ใช่ภาษาปกติ ดังนั้นเราจึงได้รวมการจัดการพิเศษเพื่อจัดการกับอาร์กิวเมนต์ฟังก์ชันที่ซับซ้อนมากขึ้น เช่น ฟังก์ชัน var อย่างไรก็ตาม ดังที่คุณเห็นในภาพหน้าจอแรก วิธีนี้ยังคงใช้ไม่ได้ในบางกรณี
กำลังจับคู่ tan()
หนึ่งในข้อบกพร่องที่รายงานว่าตลกที่สุดคือเกี่ยวกับฟังก์ชันตรีโกณมิติ tan() นิพจน์ทั่วไปที่เราใช้จับคู่สีมีนิพจน์ย่อย \b[a-zA-Z]+\b(?!-) สำหรับจับคู่สีที่มีชื่อ เช่น คีย์เวิร์ด red จากนั้นเราตรวจสอบว่าส่วนที่ตรงกันเป็นสีที่มีชื่อจริงหรือไม่ และเดาว่า tan เป็นสีที่มีชื่อด้วย เราจึงตีความนิพจน์ tan() เป็นสีอย่างไม่ถูกต้อง
กำลังจับคู่ var()
มาดูอีกตัวอย่างหนึ่งกัน ฟังก์ชัน var() ที่มีฟังก์ชันสำรองซึ่งมีการอ้างอิง var() อื่นๆ: var(--non-existent, var(--margin-vertical))
นิพจน์ทั่วไปสำหรับ var() จะจับคู่กับค่านี้ได้อย่างถูกต้อง แต่จะหยุดจับคู่ที่วงเล็บปิดแรก ดังนั้นข้อความข้างต้นจึงจับคู่เป็น var(--non-existent, var(--margin-vertical) นี่เป็นข้อจำกัดตามปกติของการจับคู่นิพจน์ทั่วไป ภาษาที่ต้องใช้วงเล็บที่ตรงกันนั้นโดยพื้นฐานแล้วไม่ใช่ภาษาปกติ
เปลี่ยนไปใช้โปรแกรมแยกวิเคราะห์ CSS
เมื่อการวิเคราะห์ข้อความโดยใช้นิพจน์ทั่วไปหยุดทำงาน (เนื่องจากภาษาที่วิเคราะห์ไม่ใช่นิพจน์ทั่วไป) จะมีขั้นตอนถัดไปตามรูปแบบบัญญัติ นั่นคือใช้โปรแกรมแยกวิเคราะห์สำหรับไวยากรณ์ประเภทที่สูงกว่า สำหรับ CSS หมายถึงโปรแกรมแยกวิเคราะห์สำหรับภาษาที่ไม่มีบริบท อันที่จริง ระบบโปรแกรมแยกวิเคราะห์ดังกล่าวมีอยู่ในฐานของโค้ด DevTools อยู่แล้ว นั่นคือ Lezer ของ CodeMirror ซึ่งเป็นรากฐานของการไฮไลต์ไวยากรณ์ใน CodeMirror ซึ่งเป็นเครื่องมือแก้ไขที่คุณเห็นในแผงแหล่งที่มา โปรแกรมแยกวิเคราะห์ CSS ของ Lezer ช่วยให้เราสร้างแผนผังไวยากรณ์ (แบบไม่เป็นนามธรรม) สำหรับกฎ CSS และพร้อมให้เราใช้งาน ชัยชนะ

อย่างไรก็ตาม เราพบว่าการย้ายข้อมูลจากการจับคู่ตามนิพจน์ทั่วไปไปยังการจับคู่ตามโปรแกรมแยกวิเคราะห์โดยตรงนั้นเป็นไปไม่ได้ เนื่องจากทั้ง 2 วิธีทำงานในทิศทางตรงกันข้าม เมื่อจับคู่ส่วนต่างๆ ของค่ากับนิพจน์ทั่วไป เครื่องมือสำหรับนักพัฒนาเว็บจะสแกนอินพุตจากซ้ายไปขวา โดยพยายามค้นหารายการที่ตรงกันที่เร็วที่สุดจากรายการรูปแบบตามลำดับซ้ำๆ เมื่อใช้แผนผังไวยากรณ์ การจับคู่จะเริ่มจากล่างขึ้นบน เช่น วิเคราะห์อาร์กิวเมนต์ของการเรียกใช้ก่อน แล้วจึงพยายามจับคู่การเรียกใช้ฟังก์ชัน ให้คิดว่าเป็นการประเมินนิพจน์ทางคณิตศาสตร์ โดยคุณจะพิจารณานิพจน์ในวงเล็บก่อน จากนั้นจึงพิจารณาโอเปอเรเตอร์การคูณ แล้วจึงพิจารณาโอเปอเรเตอร์การบวก ในกรอบนี้ การจับคู่ตามนิพจน์ทั่วไปจะสอดคล้องกับการประเมินนิพจน์ทางคณิตศาสตร์จากซ้ายไปขวา เราไม่อยากเขียนระบบการจับคู่ทั้งหมดใหม่ตั้งแต่ต้น เนื่องจากมีคู่ตัวจับคู่และตัวแสดงผลที่แตกต่างกัน 15 คู่ โดยมีโค้ดหลายพันบรรทัด ซึ่งทำให้เราไม่น่าจะจัดส่งได้ในเหตุการณ์สำคัญเดียว
เราจึงคิดค้นโซลูชันที่ช่วยให้เราทำการเปลี่ยนแปลงแบบค่อยเป็นค่อยไปได้ ซึ่งเราจะอธิบายรายละเอียดเพิ่มเติมด้านล่าง พูดสั้นๆ ก็คือ เรายังคงใช้แนวทาง 2 ระยะ แต่ในระยะแรก เราพยายามจับคู่นิพจน์ย่อยจากล่างขึ้นบน (จึงขัดกับขั้นตอนของนิพจน์ทั่วไป) และในระยะที่ 2 เราจะแสดงผลจากบนลงล่าง ในทั้ง 2 ระยะ เราสามารถใช้ตัวจับคู่และตัวแสดงผลที่อิงตามนิพจน์ทั่วไปที่มีอยู่ได้โดยแทบไม่มีการเปลี่ยนแปลง จึงสามารถย้ายข้อมูลทีละรายการได้
ระยะที่ 1: การจับคู่จากล่างขึ้นบน
ระยะแรกจะทำตามที่ระบุไว้ในชื่อระยะอย่างเคร่งครัด เราจะข้ามโครงสร้างตามลำดับจากล่างขึ้นบน และพยายามจับคู่นิพจน์ย่อยที่โหนดโครงสร้างไวยากรณ์แต่ละโหนดที่เราเข้าชม หากต้องการจับคู่นิพจน์ย่อยที่เฉพาะเจาะจง ตัวจับคู่สามารถใช้นิพจน์ทั่วไปได้เหมือนกับที่ใช้ในระบบที่มีอยู่ ตั้งแต่เวอร์ชัน 128 เป็นต้นมา เรายังคงใช้ในบางกรณี เช่น สำหรับความยาวที่ตรงกัน หรืออีกวิธีหนึ่งคือ Matcher สามารถวิเคราะห์โครงสร้างของแผนผังย่อยที่รูทที่โหนดปัจจุบัน ซึ่งจะช่วยให้ตรวจจับข้อผิดพลาดทางไวยากรณ์และบันทึกข้อมูลโครงสร้างได้พร้อมกัน
ลองดูตัวอย่างแผนผังไวยากรณ์จากด้านบน

สำหรับต้นไม้นี้ ตัวจับคู่ของเราจะใช้ตามลำดับต่อไปนี้
hsl(177degvar(--saturation, 100%) 50%): ก่อนอื่น เราจะค้นหาอาร์กิวเมนต์แรกของการเรียกใช้ฟังก์ชันhslซึ่งก็คือมุม Hue เราจับคู่กับตัวจับคู่มุมเพื่อให้สามารถตกแต่งค่ามุมด้วยไอคอนมุมได้hsl(177degvar(--saturation, 100%)50%): ขั้นที่ 2 เราจะค้นพบการเรียกใช้ฟังก์ชันvarด้วยตัวจับคู่ var สำหรับการโทรดังกล่าว เราต้องการดำเนินการ 2 อย่างเป็นหลัก ดังนี้- ค้นหาการประกาศของตัวแปรและคำนวณค่าของตัวแปร แล้วเพิ่มลิงก์และป๊อปโอเวอร์ลงในชื่อตัวแปรเพื่อเชื่อมต่อกับตัวแปรตามลำดับ
- ตกแต่งการเรียกด้วยไอคอนสีหากค่าที่คำนวณได้เป็นสี จริงๆ แล้วยังมีเรื่องที่ 3 ด้วย แต่เราจะพูดถึงเรื่องนั้นในภายหลัง
hsl(177deg var(--saturation, 100%) 50%): สุดท้าย เราจะจับคู่นิพจน์การเรียกใช้สำหรับฟังก์ชันhslเพื่อให้เราตกแต่งด้วยไอคอนสีได้
นอกเหนือจากการค้นหานิพจน์ย่อยที่เราต้องการตกแต่งแล้ว จริงๆ แล้วยังมีฟีเจอร์ที่ 2 ที่เราใช้เป็นส่วนหนึ่งของกระบวนการจับคู่ด้วย โปรดทราบว่าในขั้นตอนที่ 2 เราได้กล่าวไว้ว่าเราจะค้นหาค่าที่คำนวณแล้วสำหรับชื่อตัวแปร อันที่จริง เราได้ยกระดับไปอีกขั้นและเผยแพร่ผลลัพธ์ขึ้นไปตามโครงสร้างแบบต้นไม้ และไม่ใช่แค่สำหรับตัวแปรเท่านั้น แต่ยังรวมถึงค่าสำรองด้วย เรารับประกันว่าเมื่อเข้าชมโหนดฟังก์ชัน var ระบบจะเข้าชมโหนดย่อยของโหนดดังกล่าวไว้ล่วงหน้า ดังนั้นเราจึงทราบผลลัพธ์ของฟังก์ชัน var ที่อาจปรากฏในค่าสำรองอยู่แล้ว ดังนั้นเราจึงสามารถแทนที่ฟังก์ชัน var ด้วยผลลัพธ์ได้ทันทีอย่างง่ายดายและประหยัดค่าใช้จ่าย ซึ่งช่วยให้เราตอบคำถามง่ายๆ เช่น "ผลลัพธ์ของการเรียก var นี้เป็นสีหรือไม่" ได้เหมือนที่เราทำในขั้นตอนที่ 2
ระยะที่ 2: การแสดงผลจากบนลงล่าง
สำหรับระยะที่ 2 เราจะย้อนกลับ เมื่อนำผลลัพธ์การจับคู่จากระยะที่ 1 มาใช้ เราจะแสดงผลต้นไม้เป็น HTML โดยการข้ามผ่านตามลำดับจากบนลงล่าง สำหรับแต่ละโหนดที่เข้าชม เราจะตรวจสอบว่าตรงกันหรือไม่ และหากตรงกัน ให้เรียกใช้โปรแกรมแสดงผลที่เกี่ยวข้องของ Matcher เราหลีกเลี่ยงความจำเป็นในการจัดการพิเศษสำหรับโหนดที่มีเฉพาะข้อความ (เช่น NumberLiteral "50%") โดยรวมตัวจับคู่และโปรแกรมแสดงผลเริ่มต้นสำหรับโหนดข้อความ ตัวแสดงผลจะแสดงผลโหนด HTML ซึ่งเมื่อนำมารวมกันจะสร้างการแสดงค่าพร็อพเพอร์ตี้รวมถึงการตกแต่ง

สำหรับแผนผังตัวอย่าง ลำดับการแสดงผลค่าพร็อพเพอร์ตี้จะเป็นดังนี้
- ไปที่การเรียกใช้ฟังก์ชัน
hslตรงกัน ดังนั้นให้เรียกใช้โปรแกรมแสดงผลฟังก์ชันสี โดยจะทำ 2 อย่างต่อไปนี้- คำนวณค่าสีจริงโดยใช้กลไกการแทนที่แบบทันทีสำหรับอาร์กิวเมนต์
varใดๆ แล้ววาดไอคอนสี - แสดงผลองค์ประกอบย่อยของ
CallExpressionซ้ำๆ ซึ่งจะดูแลการแสดงผลชื่อฟังก์ชัน วงเล็บ และคอมมาโดยอัตโนมัติ ซึ่งเป็นเพียงข้อความเท่านั้น
- คำนวณค่าสีจริงโดยใช้กลไกการแทนที่แบบทันทีสำหรับอาร์กิวเมนต์
- ไปที่อาร์กิวเมนต์แรกของการเรียก
hslซึ่งตรงกัน จึงเรียกใช้โปรแกรมแสดงผลมุม ซึ่งจะวาดไอคอนมุมและข้อความของมุม - ไปที่อาร์กิวเมนต์ที่ 2 ซึ่งเป็นการเรียกใช้
varซึ่งตรงกัน ดังนั้นให้เรียกใช้ตัวแปร renderer ซึ่งจะแสดงผลลัพธ์ต่อไปนี้- ข้อความ
var(ที่จุดเริ่มต้น - ชื่อตัวแปรและตกแต่งด้วยลิงก์ไปยังคำจำกัดความของตัวแปรหรือด้วยสีข้อความสีเทาเพื่อระบุว่าไม่ได้กำหนดไว้ นอกจากนี้ยังเพิ่มป๊อปโอเวอร์ลงในตัวแปรเพื่อแสดงข้อมูลเกี่ยวกับค่าของตัวแปรด้วย
- คอมมา แล้วแสดงผลค่าสำรองซ้ำๆ
- วงเล็บปิด
- ข้อความ
- ไปที่อาร์กิวเมนต์สุดท้ายของการเรียก
hslไม่ตรงกัน ดังนั้นให้แสดงผลเนื้อหาข้อความเท่านั้น
คุณสังเกตไหมว่าในอัลกอริทึมนี้ ตัวแสดงผลจะควบคุมวิธีแสดงผลโหนดย่อยของโหนดที่ตรงกันอย่างสมบูรณ์ การแสดงผลองค์ประกอบย่อยซ้ำๆ เป็นการดำเนินการเชิงรุก เคล็ดลับนี้ช่วยให้สามารถย้ายข้อมูลแบบทีละขั้นตอนจากการแสดงผลตามนิพจน์ทั่วไปไปเป็นการแสดงผลตามแผนผังไวยากรณ์ สำหรับโหนดที่จับคู่กับตัวจับคู่นิพจน์ทั่วไปแบบเดิม คุณสามารถใช้โปรแกรมแสดงผลที่เกี่ยวข้องในรูปแบบเดิมได้ ในแง่ของแผนผังไวยากรณ์ คอมโพเนนต์นี้จะรับผิดชอบในการแสดงผลซับทรีทั้งหมด และผลลัพธ์ (โหนด HTML) จะเสียบเข้ากับกระบวนการแสดงผลโดยรอบได้อย่างสมบูรณ์ ซึ่งทำให้เรามีตัวเลือกในการพอร์ต Matcher และโปรแกรมแสดงผลเป็นคู่ๆ และสลับออกทีละรายการ
ฟีเจอร์เจ๋งๆ อีกอย่างหนึ่งของโปรแกรมแสดงผลที่ควบคุมการแสดงผลของโหนดบุตรหลานที่ตรงกันคือช่วยให้เราสามารถพิจารณาความขึ้นต่อกันระหว่างไอคอนที่เรากำลังเพิ่มได้ ในตัวอย่างข้างต้น สีที่สร้างโดยฟังก์ชัน hsl จะขึ้นอยู่กับค่าสีอย่างชัดเจน ซึ่งหมายความว่าสีที่แสดงโดยไอคอนสีจะขึ้นอยู่กับมุมที่แสดงโดยไอคอนมุม หากผู้ใช้เปิดเครื่องมือแก้ไขมุมผ่านไอคอนดังกล่าวและแก้ไขมุม ตอนนี้เราสามารถอัปเดตสีของไอคอนสีแบบเรียลไทม์ได้แล้ว
ดังที่เห็นในตัวอย่างด้านบน เราใช้กลไกนี้สำหรับการจับคู่ไอคอนอื่นๆ ด้วย เช่น สำหรับ color-mix() และช่องสี 2 ช่อง หรือฟังก์ชัน var ที่แสดงผลสีจากสีสำรอง
ผลกระทบต่อประสิทธิภาพ
เมื่อเจาะลึกปัญหานี้เพื่อปรับปรุงความน่าเชื่อถือและแก้ไขปัญหาที่เกิดขึ้นมานาน เราคาดว่าประสิทธิภาพจะลดลงเมื่อพิจารณาว่าเราเริ่มใช้โปรแกรมแยกวิเคราะห์เต็มรูปแบบ สำหรับการทดสอบนี้ เราได้สร้างการเปรียบเทียบที่แสดงผลการประกาศพร็อพเพอร์ตี้ประมาณ 3.5 พันรายการ และสร้างโปรไฟล์ทั้งเวอร์ชันที่อิงตามนิพจน์ทั่วไปและเวอร์ชันที่อิงตามโปรแกรมแยกวิเคราะห์ที่มีการควบคุมปริมาณ 6 เท่าในเครื่อง M1
ตามที่เราคาดไว้ วิธีการที่อิงตามการแยกวิเคราะห์ช้ากว่าวิธีการที่อิงตามนิพจน์ทั่วไปถึง 27% สำหรับกรณีดังกล่าว แนวทางที่อิงตามนิพจน์ทั่วไปใช้เวลา 11 วินาทีในการแสดงผล และแนวทางที่อิงตามโปรแกรมแยกวิเคราะห์ใช้เวลา 15 วินาทีในการแสดงผล
เมื่อพิจารณาถึงประโยชน์ที่ได้รับจากแนวทางใหม่ เราจึงตัดสินใจที่จะดำเนินการต่อ
การรับทราบ
เราขอขอบคุณ Sofia Emelianova และ Jecelyn Yeen เป็นอย่างยิ่งที่ให้ความช่วยเหลืออันมีค่าในการแก้ไขโพสต์นี้
ดาวน์โหลดช่องทางตัวอย่าง
ลองใช้ Chrome Canary, Dev หรือ Beta เป็นเบราว์เซอร์สำหรับการพัฒนาเริ่มต้น ช่องทางเวอร์ชันตัวอย่างเหล่านี้ช่วยให้คุณเข้าถึงฟีเจอร์ล่าสุดของเครื่องมือสำหรับนักพัฒนาเว็บ, ทดสอบ API ของแพลตฟอร์มเว็บที่ล้ำสมัย และช่วยคุณค้นหาปัญหาในเว็บไซต์ก่อนที่ผู้ใช้จะพบ
ติดต่อทีมเครื่องมือสำหรับนักพัฒนาเว็บใน Chrome
ใช้ตัวเลือกต่อไปนี้เพื่อพูดคุยเกี่ยวกับฟีเจอร์ใหม่ การอัปเดต หรือสิ่งอื่นๆ ที่เกี่ยวข้องกับเครื่องมือสำหรับนักพัฒนาเว็บ
- ส่งความคิดเห็นและคำขอฟีเจอร์ถึงเราได้ที่ crbug.com
- รายงานปัญหาเกี่ยวกับเครื่องมือสำหรับนักพัฒนาเว็บโดยใช้ ตัวเลือกเพิ่มเติม > ความช่วยเหลือ > รายงานปัญหาเกี่ยวกับเครื่องมือสำหรับนักพัฒนาเว็บในเครื่องมือสำหรับนักพัฒนาเว็บ
- ทวีตไปที่ @ChromeDevTools
- แสดงความคิดเห็นในวิดีโอ YouTube เกี่ยวกับมีอะไรใหม่ในเครื่องมือสำหรับนักพัฒนาเว็บหรือวิดีโอ YouTube เกี่ยวกับเคล็ดลับสำหรับเครื่องมือสำหรับนักพัฒนาเว็บ