นิพจน์ทั่วไปใน JavaScript: บทนำ

อินฟอร์เมเทค ดิจิตอล » การเขียนโปรแกรม » นิพจน์ทั่วไปใน JavaScript: บทนำ

ยินดีต้อนรับสู่คู่มือฉบับสมบูรณ์เกี่ยวกับนิพจน์ทั่วไปใน JavaScript! ในบทความนี้ เราจะเจาะลึกว่านิพจน์ทั่วไปคืออะไร ใช้ใน JavaScript อย่างไร และสามารถช่วยคุณลดความซับซ้อนและเพิ่มประสิทธิภาพโค้ดของคุณได้อย่างไร ตั้งแต่พื้นฐานจนถึงตัวอย่างเชิงปฏิบัติ เราจะครอบคลุมทุกสิ่งที่คุณจำเป็นต้องรู้เพื่อเริ่มต้นใช้ประโยชน์สูงสุดจากนิพจน์ทั่วไปในโครงการ JavaScript ของคุณ มาเริ่มกันเลยดีกว่า!

บทนำสู่นิพจน์ทั่วไป

นิพจน์ปกติคือรูปแบบการค้นหาที่ใช้เพื่อค้นหาและจัดการข้อความในสตริงอักขระ ประกอบด้วยการผสมผสานระหว่างอักขระตามตัวอักษรและอักขระพิเศษ ซึ่งกำหนดกฎเกณฑ์เฉพาะในการค้นหาข้อมูลที่ตรงกันในข้อความ กฎเหล่านี้อาจรวมถึงการค้นหาอักขระเฉพาะ ช่วงอักขระ การทำซ้ำ ทางเลือก และอื่นๆ อีกมากมาย

ใน JavaScript นิพจน์ทั่วไปจะถูกสร้างขึ้นโดยใช้คลาส RegExp หรือใช้ตามความหมายที่แท้จริง /patrón/- รูปแบบเป็นนิพจน์ทั่วไปซึ่งถูกล้อมรอบด้วยเครื่องหมายทับ มาดูตัวอย่างง่ายๆ กัน:

const regex = /hola/;

 

ในตัวอย่างนี้ เราได้สร้างนิพจน์ทั่วไปที่จะค้นหาสตริง "hello" ภายในข้อความ ตอนนี้เรามีความเข้าใจพื้นฐานแล้วว่านิพจน์ทั่วไปคืออะไร ต่อไปเราลองมาสำรวจแนวคิดหลักและเทคนิคขั้นสูงสำหรับการใช้งานกับนิพจน์ทั่วไปใน JavaScript กัน

โครงสร้างพื้นฐานของนิพจน์ทั่วไป

นิพจน์ปกติใน JavaScript ประกอบด้วยองค์ประกอบหลักหลายประการที่ช่วยให้เราสามารถกำหนดรูปแบบการค้นหาที่ซับซ้อนยิ่งขึ้น องค์ประกอบเหล่านี้ได้แก่ อักขระตัวอักษร เมตาอักขระ คลาสอักขระ ตัวระบุปริมาณ จุดยึด และอื่นๆ มาดูตัวอย่างบางส่วนขององค์ประกอบเหล่านี้กัน:

ตัวอักษรภาษาอังกฤษ

อักขระตัวอักษรคืออักขระที่ถูกค้นหาตามที่ปรากฏในข้อความ ตัวอย่างเช่นนิพจน์ปกติ /hola/ จะค้นหาลำดับอักขระ “สวัสดี” ในสตริงข้อความ สิ่งสำคัญคือต้องทราบว่านิพจน์ทั่วไปนั้นต้องคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ดังนั้น /hola/ จะไม่ตรงกับ "สวัสดี" หรือ "HELLO"

เมตาอักขระ

เมตาอักขระคืออักขระพิเศษที่มีความหมายพิเศษในนิพจน์ทั่วไป ตัวอย่างเช่น เมตาอักขระ . ใช้แทนอักขระใดก็ได้ ยกเว้นการขึ้นบรรทัดใหม่ เมตาอักขระทั่วไปอีกอย่างหนึ่งคือ ^ซึ่งใช้เพื่อระบุจุดเริ่มต้นของสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /^hola/ จะตรงกับสตริงข้อความใด ๆ ที่เริ่มต้นด้วย "สวัสดี"

คลาสตัวละคร

คลาสอักขระใช้เพื่อค้นหาอักขระใด ๆ ภายในชุดที่ระบุ ตัวอย่างเช่นนิพจน์ปกติ /[aeiou]/ จะตรงกับสระใด ๆ ในสตริงข้อความ ยังสามารถใช้ช่วงอักขระในคลาสอักขระได้อีกด้วย ตัวอย่างเช่นนิพจน์ปกติ /[a-z]/ จะตรงกับตัวอักษรพิมพ์เล็กใดๆ

ปริมาณ

ตัวระบุปริมาณใช้เพื่อระบุจำนวนการเกิดขึ้นขององค์ประกอบในนิพจน์ทั่วไป เช่น ตัวระบุปริมาณ * ระบุว่าองค์ประกอบก่อนหน้าสามารถปรากฏได้ศูนย์ครั้งหรือมากกว่า ตัวระบุปริมาณ + ระบุว่าองค์ประกอบก่อนหน้าควรปรากฏหนึ่งครั้งหรือหลายครั้ง ตัวอย่างเช่นนิพจน์ปกติ /a+/ จะตรงกับ "a" หนึ่งตัวหรือมากกว่าในสตริงข้อความ

สมอ

ใช้จุดยึดเพื่อระบุตำแหน่งของการจับคู่ภายในสตริงข้อความ เช่น จุดยึด \b ตรงกับขอบเขตของคำ ตัวอย่างเช่นนิพจน์ปกติ /bholab/ จะตรงกับคำว่า "สวัสดี" เท่านั้น คำเต็มโดยไม่ตรงกับคำยาวๆ ที่มีคำว่า “hello” เป็นส่วนหนึ่งของคำ

นี่เป็นเพียงตัวอย่างเล็กน้อยของไวยากรณ์พื้นฐานของนิพจน์ปกติใน JavaScript ในบทความนี้เราจะสำรวจแนวคิดและเทคนิคขั้นสูงเพิ่มเติมสำหรับการทำงานกับนิพจน์ปกติใน JavaScript ต่อไป

การค้นหาการจับคู่พื้นฐาน

การดำเนินการที่พบบ่อยที่สุดอย่างหนึ่งที่ดำเนินการกับนิพจน์ทั่วไปคือการค้นหาการจับคู่ในสตริงข้อความ ใน JavaScript เราสามารถใช้วิธีการนี้ได้ search() เพื่อค้นหาการจับคู่แรกของนิพจน์ทั่วไปในสตริงข้อความ มาดูตัวอย่างกัน:

const texto = "¡Hola, mundo!";
const regex = /mundo/;
const indice = texto.search(regex);
console.log(indice); // 7

ในตัวอย่างนี้เราได้ใช้วิธีการ search() เพื่อค้นหาการจับคู่แรกของนิพจน์ทั่วไป /mundo/ ในสตริงข้อความ "สวัสดีโลก!" วิธีการ search() ส่งคืนดัชนีของการจับคู่ครั้งแรกที่พบ หรือ -1 ถ้าไม่พบการจับคู่

นอกจากวิธีการ search()JavaScript ยังมีวิธีการอื่นที่มีประโยชน์สำหรับการทำงานกับนิพจน์ทั่วไป เช่น match(), replace(), split() y test()- วิธีการแต่ละวิธีมีจุดประสงค์ของตัวเองและสามารถใช้งานได้ตามความต้องการเฉพาะของคุณ

การใช้ตัวปรับเปลี่ยนและแฟล็ก

ใน JavaScript นิพจน์ทั่วไปสามารถมีตัวปรับเปลี่ยนและแฟล็กที่ช่วยให้การค้นหามีความยืดหยุ่นและกำหนดเองได้มากขึ้น ตัวปรับเปลี่ยนจะถูกเพิ่มไปที่ตอนท้ายของนิพจน์ทั่วไปและปรับเปลี่ยนพฤติกรรมของมัน ตัวปรับเปลี่ยนที่พบได้บ่อยที่สุดได้แก่:

ฉัน (ไม่ไวต่อความรู้สึก)

ตัวปรับเปลี่ยน i ใช้เพื่อค้นหาโดยไม่คำนึงถึงตัวพิมพ์เล็ก/ใหญ่ ตัวอย่างเช่นนิพจน์ปกติ /hola/i จะตรงกับทั้งคำว่า “hello” และ “Hello” หรือ “HELLO”

จี (ทั่วโลก)

ตัวปรับเปลี่ยน g ใช้ในการค้นหาทั่วไปในสตริงข้อความทั้งหมดแทนที่จะหยุดที่ผลลัพธ์ที่ตรงกันครั้งแรกที่พบ ตัวอย่างเช่นนิพจน์ปกติ /a+/g จะตรงกับการเกิดขึ้นทั้งหมดของ "a" หนึ่งตัวหรือมากกว่าในสตริงข้อความ

ม. (หลายบรรทัด)

ตัวปรับเปลี่ยน m ใช้เพื่อค้นหาหลายบรรทัดภายในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /^hola/m จะตรงกับคำว่า "สวัสดี" ที่อยู่ในช่วงต้นของแต่ละบรรทัดในสตริงข้อความ

นอกเหนือจากตัวปรับเปลี่ยนแล้ว JavaScript ยังอนุญาตให้ใช้แฟล็กในนิพจน์ทั่วไปอีกด้วย แฟล็กจะถูกเพิ่มหลังเครื่องหมายทับที่สองเมื่อสร้างนิพจน์ทั่วไปโดยใช้คลาส RegExp- ธงบางส่วนที่พบได้ทั่วไป ได้แก่:

ฉัน (ไม่ไวต่อความรู้สึก)

เช่นเดียวกับตัวปรับเปลี่ยน i,ธง i ดำเนินการค้นหาโดยไม่คำนึงถึงตัวพิมพ์เล็ก/ใหญ่ ตัวอย่างเช่นนิพจน์ปกติ new RegExp("hola", "i") จะตรงกับทั้งคำว่า “hello” และ “Hello” หรือ “HELLO”

จี (ทั่วโลก)

เช่นเดียวกับตัวปรับเปลี่ยน g,ธง g ดำเนินการค้นหาทั่วโลกบนสตริงข้อความทั้งหมด ตัวอย่างเช่นนิพจน์ปกติ new RegExp("a+", "g") จะตรงกับการเกิดขึ้นทั้งหมดของ "a" หนึ่งตัวหรือมากกว่าในสตริงข้อความ

ม. (หลายบรรทัด)

เช่นเดียวกับตัวปรับเปลี่ยน m,ธง m ดำเนินการค้นหาหลายบรรทัดภายในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ new RegExp("^hola", "m") จะตรงกับคำว่า "สวัสดี" ที่อยู่ในช่วงต้นของแต่ละบรรทัดในสตริงข้อความ

การใช้ตัวดัดแปลงและแฟล็กในนิพจน์ปกติของ JavaScript มีประโยชน์อย่างมากในการปรับแต่งการค้นหาให้เหมาะสมกับกรณีต่างๆ และข้อกำหนดเฉพาะ ลองทดลองใช้และค้นพบวิธีที่คุณสามารถใช้ประโยชน์จากคุณสมบัติเหล่านี้ในโค้ดของคุณได้ อย่างเต็มที่

เมตาอักขระและอักขระพิเศษ

เมตาอักขระและอักขระพิเศษเป็นองค์ประกอบหลักในนิพจน์ทั่วไปที่ช่วยให้เราค้นหาได้อย่างมีประสิทธิภาพและยืดหยุ่นยิ่งขึ้น เราได้กล่าวถึงเมตาอักขระบางตัวไปแล้ว เช่น . y ^แต่ยังมีอีกมากมายที่คุณสามารถใช้ในนิพจน์ทั่วไปของคุณได้ มาดูเมตาอักขระและอักขระพิเศษที่พบบ่อยที่สุดบางส่วนกัน:

. (จุด)

เมตาอักขระ . ใช้แทนอักขระใดก็ได้ ยกเว้นการขึ้นบรรทัดใหม่ ตัวอย่างเช่นนิพจน์ปกติ /h.t/ จะตรงกับคำว่า “hat,” “hot,” “hit,” และคำสามตัวอักษรอื่นๆ ที่ขึ้นต้นด้วย “h” และลงท้ายด้วย “t”

\ (แบ็กสแลช)

แบ็กสแลชใช้เพื่อหลีกเลี่ยงอักขระพิเศษในนิพจน์ทั่วไป ตัวอย่างเช่น หากคุณต้องการค้นหาจุดตัวอักษรในสตริงข้อความ คุณต้องหลีกเลี่ยงโดยใช้แบ็กสแลช นิพจน์ปกติ /www\.google\.com/ จะตรงกับสตริงข้อความ “www.google.com”

\d (ตัวเลข)

เมตาอักขระ \d ใช้เพื่อค้นหาตัวเลขใดๆ ตั้งแต่ 0 ถึง 9 ตัวอย่างเช่น นิพจน์ทั่วไป /\d+/ จะตรงกับตัวเลขหนึ่งตัวหรือมากกว่าในสตริงข้อความ

\w (ตัวอักษรและตัวเลข)

เมตาอักขระ \w ใช้เพื่อค้นหาอักขระตัวอักษรและตัวเลข (ตัวอักษรพิมพ์ใหญ่และพิมพ์เล็ก ตัวเลขและขีดล่าง) ตัวอย่างเช่นนิพจน์ปกติ /\w+/ จะจับคู่คำใด ๆ ที่มีอักขระตัวอักษรและตัวเลขหนึ่งตัวหรือมากกว่าในสตริงข้อความ

นี่เป็นเพียงตัวอย่างบางส่วนของเมตาอักขระและอักขระพิเศษที่คุณสามารถใช้ในนิพจน์ทั่วไปของคุณ เมื่อคุณคุ้นเคยกับนิพจน์ทั่วไปใน JavaScript มากขึ้น คุณจะค้นพบตัวเลือกต่างๆ มากมายสำหรับการปรับแต่งการค้นหาและการจัดการข้อความของคุณ

คลาสและช่วงของตัวละคร

คลาสอักขระเป็นองค์ประกอบสำคัญอีกประการหนึ่งในนิพจน์ทั่วไปที่ช่วยให้เราค้นหาอักขระใดๆ ภายในชุดที่ระบุได้ ใน JavaScript เราสามารถใช้เครื่องหมายวงเล็บได้ [] เพื่อกำหนดคลาสอักขระ มาดูตัวอย่างคลาสและช่วงอักขระกันบ้าง:

[เออิโอะ]

คลาสตัวละคร [aeiou] จะตรงกับสระใด ๆ ในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /[aeiou]/ จะตรงกับ "a", "e", "i", "o" หรือ "u" ในสตริงข้อความ

[az]

ช่วงของตัวละคร [a-z] จะตรงกับตัวอักษรพิมพ์เล็กในตัวอักษรภาษาอังกฤษ ตัวอย่างเช่นนิพจน์ปกติ /[a-z]/ จะตรงกับตัวอักษรพิมพ์เล็กในสตริงข้อความ

[0 9-]

ช่วงของตัวละคร [0-9] จะจับคู่กับตัวเลขใดๆ ตั้งแต่ 0 ถึง 9 ในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /[0-9]/ จะตรงกับตัวเลขหลักเดียวใดๆ

[อา-ซ่า-ซ]

คลาสตัวละคร [A-Za-z] จะตรงกับตัวอักษรพิมพ์ใหญ่หรือพิมพ์เล็กในตัวอักษรภาษาอังกฤษ ตัวอย่างเช่นนิพจน์ปกติ /[A-Za-z]/ จะตรงกับตัวอักษรใด ๆ ในสตริงข้อความ

คลาสและช่วงอักขระช่วยให้เราสามารถกำหนดชุดอักขระที่เจาะจงเพื่อค้นหาในนิพจน์ทั่วไปได้ ใช้เพื่อปรับแต่งการค้นหาให้เหมาะกับความต้องการและข้อจำกัดเฉพาะของคุณ

ตัวระบุปริมาณและการทำซ้ำ

ตัวระบุปริมาณและการทำซ้ำเป็นองค์ประกอบหลักในนิพจน์ทั่วไปที่ช่วยให้เราระบุจำนวนการเกิดขึ้นขององค์ประกอบในสตริงข้อความได้ มาลองดูตัวระบุปริมาณที่พบได้บ่อยที่สุดใน JavaScript กัน:

* (ดอกจัน)

ตัวระบุปริมาณ * ระบุว่าองค์ประกอบก่อนหน้าสามารถปรากฏได้ศูนย์ครั้งหรือมากกว่า ตัวอย่างเช่นนิพจน์ปกติ /a*/ จะตรงกับตัวอักษร 'a' ศูนย์ตัวหรือมากกว่าในสตริงข้อความ

+ (เพิ่มเติม)

ตัวระบุปริมาณ + ระบุว่าองค์ประกอบก่อนหน้าควรปรากฏหนึ่งครั้งหรือหลายครั้ง ตัวอย่างเช่นนิพจน์ปกติ /a+/ จะตรงกับ "a" หนึ่งตัวหรือมากกว่าในสตริงข้อความ

- (คำถาม)

ตัวระบุปริมาณ ? ระบุว่าองค์ประกอบก่อนหน้านั้นอาจปรากฏขึ้นเป็นศูนย์หรือเพียงครั้งเดียว ตัวอย่างเช่นนิพจน์ปกติ /colou?r/ จะตรงกันทั้ง “สี” และ “สี”

{n} (จำนวน n ครั้งพอดี)

ตัวระบุปริมาณ {n} ระบุว่าองค์ประกอบก่อนหน้าจะต้องปรากฏขึ้นจำนวน n ครั้งพอดี ตัวอย่างเช่นนิพจน์ปกติ /a{3}/ จะตรงกับตัวอักษร "a" สามตัวในสตริงข้อความพอดี

{n,} (อย่างน้อย n ครั้ง)

ตัวระบุปริมาณ {n,} ระบุว่าองค์ประกอบก่อนหน้าจะต้องปรากฏอย่างน้อย n ครั้ง ตัวอย่างเช่นนิพจน์ปกติ /a{2,}/ จะตรงกับตัวอักษร 'a' สองตัวหรือมากกว่าในสตริงข้อความ

{น,ม}

ตัวระบุปริมาณ {n,m} ระบุว่าองค์ประกอบก่อนหน้าจะต้องปรากฏอย่างน้อย n ครั้งและอย่างมาก m ครั้ง ตัวอย่างเช่นนิพจน์ปกติ /a{2,4}/ จะจับคู่ตัวอักษร "a" สองตัว สามตัว หรือสี่ตัวในสตริงข้อความ

นี่เป็นเพียงตัวอย่างบางส่วนของตัวระบุปริมาณที่คุณสามารถใช้ในนิพจน์ทั่วไปของคุณ ตัวระบุปริมาณช่วยให้เราสามารถระบุรูปแบบการทำซ้ำในการค้นหาและการจัดการข้อความ ทำให้ดึงข้อมูลเฉพาะจากสตริงข้อความได้ง่ายยิ่งขึ้น

จุดยึดและขอบเขตคำ

จุดยึดและขอบเขตของคำเป็นองค์ประกอบที่ช่วยให้เราระบุตำแหน่งของการจับคู่ภายในสตริงข้อความได้ องค์ประกอบเหล่านี้มีประโยชน์มากโดยเฉพาะเมื่อเราต้องการค้นหาคำทั้งหมดหรือตรวจสอบให้แน่ใจว่าการจับคู่อยู่ที่จุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัด มาดูตัวอย่างจุดยึดและขอบเขตคำกัน:

\b (ขอบเขตคำ)

คำจำกัด \b ตรงกับขอบเขตระหว่างอักขระตัวอักษรและตัวเลขและอักขระที่ไม่ใช่ตัวอักษรและตัวเลข ตัวอย่างเช่นนิพจน์ปกติ /\bjavascript\b/ จะจับคู่เฉพาะคำว่า “javascript” เป็นคำที่สมบูรณ์เท่านั้น ไม่จับคู่คำยาวๆ ที่มี “javascript” เป็นส่วนหนึ่งของคำนั้น

^ (จุดเริ่มต้นของบรรทัด)

บทบาท ^ ใช้เพื่อระบุจุดเริ่มต้นของบรรทัดในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /^hola/ จะตรงกับคำว่า "สวัสดี" ที่อยู่ในช่วงต้นของแต่ละบรรทัดในสตริงข้อความ

$ (จบบรรทัด)

บทบาท $ ใช้เพื่อระบุจุดสิ้นสุดบรรทัดในสตริงข้อความ ตัวอย่างเช่นนิพจน์ปกติ /mundo$/ จะตรงกับคำว่า “โลก” ที่อยู่ท้ายแต่ละบรรทัดในสตริงข้อความ

\A (จุดเริ่มต้นของข้อความ)

บทบาท \A ใช้เพื่อระบุจุดเริ่มต้นของข้อความทั้งหมดในสตริงข้อความ ไม่ใช่เพียงจุดเริ่มต้นของบรรทัดเท่านั้น ตัวอย่างเช่นนิพจน์ปกติ /^\AHola/ จะตรงกับคำว่า “สวัสดี” ที่อยู่ในช่วงต้นของข้อความทั้งหมด

\Z (จบข้อความ)

บทบาท \Z ใช้เพื่อระบุจุดสิ้นสุดของข้อความทั้งหมดในสตริงข้อความ ไม่ใช่แค่จุดสิ้นสุดบรรทัดเท่านั้น ตัวอย่างเช่นนิพจน์ปกติ /Mundo\Z/ จะตรงกับคำว่า “โลก” ที่อยู่ตอนท้ายของข้อความทั้งหมด

จุดยึดและขอบเขตของคำช่วยให้เราค้นหาการจับคู่ที่ตำแหน่งเฉพาะภายในสตริงข้อความ ซึ่งอาจเป็นประโยชน์ในสถานการณ์ที่เราต้องการให้แน่ใจว่าการจับคู่อยู่ในตำแหน่งเฉพาะ

กลุ่มและการจับภาพ

การจัดกลุ่มและการจับข้อมูลเป็นองค์ประกอบขั้นสูงในนิพจน์ทั่วไป ซึ่งช่วยให้เราสามารถจัดกลุ่มนิพจน์ย่อยและจับข้อมูลไว้เพื่อใช้ในภายหลังได้ มาดูกันว่ากลุ่มและการจับภาพทำงานอย่างไร:

( ) (วงเล็บ)

วงเล็บคือ พวกเขาใช้การรวมกลุ่ม นิพจน์ย่อยในนิพจน์ทั่วไป ตัวอย่างเช่นนิพจน์ปกติ /(d{2})-(d{2})-(d{4})/ se ใช้ในการค้นหาวันที่ ในรูปแบบ "dd-mm-yyyy" กลุ่มต่างๆ ( ) มันช่วยให้เราบันทึกค่าวัน เดือน และปีแยกจากกันได้

\1, \2, \3 (อ้างอิงกลุ่ม)

การอ้างอิงกลุ่มใช้เพื่ออ้างอิงถึงกลุ่มที่จับภาพไว้ก่อนหน้านี้ในนิพจน์ทั่วไป ตัวอย่างเช่นนิพจน์ปกติ /(\w+) \1/ จะจับคู่คำใดๆ ที่ตามด้วยคำเดียวกันที่ซ้ำกัน เช่น "สวัสดี สวัสดี", "โลกโลก" เป็นต้น

?: (กลุ่มที่ไม่จับ)

สัญลักษณ์ ?: ใช้เพื่อสร้างกลุ่มที่ไม่จับภาพ กลุ่มเหล่านี้จะใช้เมื่อเราต้องการจัดกลุ่มนิพจน์ย่อย แต่เราไม่ต้องการจับผลลัพธ์ ตัวอย่างเช่นนิพจน์ปกติ /https?:\/\/(?:www\.)?google\.com/ จะตรงกับทั้ง “http://www.google.com” และ “https://google.com” แต่จะจับเฉพาะส่วนที่เกี่ยวข้องของ URL เท่านั้น

การจัดกลุ่มและการจับค่าช่วยให้เราจัดโครงสร้างและจัดระเบียบนิพจน์ปกติของเราได้อย่างมีประสิทธิภาพและอ่านง่ายยิ่งขึ้น นอกจากนี้ยังช่วยให้สามารถจับค่าเฉพาะเพื่อนำไปใช้ในแอปพลิเคชันของเรา ในภายหลังได้อีก ด้วย

วิธีการที่มีประโยชน์สำหรับการทำงานกับนิพจน์ทั่วไป

JavaScript มีวิธีการที่มีประโยชน์หลายวิธีในการทำงานกับนิพจน์ทั่วไป วิธีการเหล่านี้ช่วยให้เราสามารถดำเนินการทั่วไป เช่น การค้นหา การแทนที่ และการแยกสตริงข้อความโดยใช้นิพจน์ทั่วไป ลองมาดูวิธีการบางส่วนเหล่านี้:

จับคู่()

วิธีการ match() ใช้เพื่อค้นหาการจับคู่ทั้งหมดของนิพจน์ทั่วไปในสตริงข้อความและส่งคืนอาร์เรย์พร้อมผลลัพธ์ ตัวอย่างเช่น:

const texto = "¡Hola, mundo!";
const regex = /o/g;
const coincidencias = texto.match(regex);
console.log(coincidencias); // ["o", "o"]

ในตัวอย่างนี้เราได้ใช้วิธีการ match() เพื่อค้นหาการจับคู่ทั้งหมดของนิพจน์ทั่วไป /o/g ในสตริงข้อความ "สวัสดีโลก!" วิธีการ match() ส่งคืนอาร์เรย์ที่มีผลการจับคู่ที่พบทั้งหมด

แทนที่ ()

วิธีการ replace() ใช้เพื่อแทนที่การจับคู่ของนิพจน์ทั่วไปในสตริงข้อความด้วยค่าใหม่ ตัวอย่างเช่น:

const texto = "¡Hola, mundo!";
const regex = /mundo/;
const nuevoTexto = texto.replace(regex, "amigo");
console.log(nuevoTexto); // "¡Hola, amigo!"

ในตัวอย่างนี้เราได้ใช้วิธีการ replace() เพื่อแทนที่การจับคู่นิพจน์ปกติ /mundo/ ในสตริงข้อความ "สวัสดีโลก!" สำหรับคำว่า “เพื่อน” วิธีการ replace() ส่งคืนสตริงข้อความใหม่พร้อมการแทนที่ที่ทำ

แยก ()

วิธีการ split() ใช้ในการแยกสตริงข้อความให้เป็นอาร์เรย์ของสตริงย่อยโดยใช้นิพจน์ทั่วไปเป็นตัวคั่น ตัวอย่างเช่น:

const texto = "Hola,mundo,amigo";
const regex = /,/g;
const subcadenas = texto.split(regex);
console.log(subcadenas); // ["Hola", "mundo", "amigo"]

ในตัวอย่างนี้เราได้ใช้วิธีการ split() การแยกสตริงข้อความ "Hello,world,friend" ออกเป็นอาร์เรย์ของสตริงย่อยโดยใช้นิพจน์ทั่วไป /,/g เป็นตัวคั่น วิธีการ split() ส่งคืนอาร์เรย์พร้อมด้วยสตริงย่อยที่เป็นผลลัพธ์

ทดสอบ()

วิธีการ test() ใช้เพื่อตรวจสอบว่านิพจน์ทั่วไปมีการตรงกันในสตริงข้อความหรือไม่ วิธีการส่งคืน true หากมีการแข่งขันและ false มิฉะนั้น. ตัวอย่างเช่น:

const texto = "Hola, mundo!";
const regex = /mundo/;
const resultado = regex.test(texto);
console.log(resultado); // true

ในตัวอย่างนี้เราได้ใช้วิธีการ test() เพื่อตรวจสอบว่านิพจน์ปกติ /mundo/ มีการตรงกันในสตริงข้อความ "Hello, world!" หรือไม่ วิธีการ test() นำกลับมา true เพราะมันมีความบังเอิญ

นี่เป็นเพียงบางส่วนของวิธีการที่พบได้บ่อยที่สุดในการทำงานกับนิพจน์ทั่วไปใน JavaScript วิธีการแต่ละวิธีมีจุดประสงค์ของตัวเองและสามารถใช้งานได้ตามความต้องการเฉพาะของคุณ ทดลองใช้งานพวกมันแล้วค้นพบว่ามันสามารถทำให้การทำงานกับนิพจน์ทั่วไปของคุณง่ายและรวดเร็วยิ่งขึ้นได้อย่างไร

คำถามที่พบบ่อย

นิพจน์ปกติ (Regular expressions) ใน JavaScript คืออะไร?นิพจน์ปกติใน JavaScript คือรูปแบบการค้นหาที่ใช้ในการค้นหาและจัดการข้อความในสตริงอักขระ

จะสร้างนิพจน์ทั่วไปใน JavaScript ได้อย่างไร? นิพจน์ทั่วไปใน JavaScript ถูกสร้างขึ้นโดยใช้คลาส RegExp หรือใช้ตามความหมายที่แท้จริง /patrón/.

ความแตกต่างระหว่างตัวปรับเปลี่ยนและแฟล็กในนิพจน์ทั่วไปคืออะไร ตัวปรับเปลี่ยนจะถูกเพิ่มไปที่ตอนท้ายของนิพจน์ทั่วไปและปรับเปลี่ยนพฤติกรรมของมัน แฟล็กจะถูกเพิ่มหลังเครื่องหมายทับที่สองเมื่อสร้างนิพจน์ทั่วไปโดยใช้คลาส RegExp.

ความแตกต่างระหว่างวิธีการคืออะไร match() และวิธีการ test()? วิธีการ match() ใช้เพื่อค้นหาการจับคู่ทั้งหมดของนิพจน์ทั่วไปในสตริงข้อความ และส่งคืนอาร์เรย์พร้อมผลลัพธ์ วิธีการ test() ใช้เพื่อตรวจสอบว่านิพจน์ทั่วไปมีการตรงกันในสตริงข้อความหรือไม่ และส่งคืนค่าบูลีน

ฉันจะจับค่าเฉพาะต่างๆ โดยใช้กลุ่มในนิพจน์ทั่วไปได้อย่างไร กลุ่มต่างๆ ( ) ในนิพจน์ทั่วไปช่วยให้คุณสามารถจับนิพจน์ย่อยที่ต้องการเจาะจงได้ จากนั้นคุณสามารถอ้างอิงกลุ่มเหล่านี้ได้โดยใช้การอ้างอิง \1, \2ฯลฯ

ฉันสามารถใช้วิธีการใดเพื่อทำงานกับนิพจน์ทั่วไปใน JavaScript ได้บ้าง? วิธีการที่มีประโยชน์บางอย่างสำหรับการทำงานกับนิพจน์ทั่วไปใน JavaScript ได้แก่ match(), replace(), split() y test()- วิธีการแต่ละวิธีมีจุดประสงค์ของตัวเองและสามารถใช้งานได้ตามความต้องการเฉพาะของคุณ

ข้อสรุป

นิพจน์ปกติ (Regular expressions) เป็นเครื่องมือที่มีประสิทธิภาพสำหรับการทำงานกับข้อความใน JavaScript การเข้าใจพื้นฐานไวยากรณ์ และเทคนิคขั้นสูงของนิพจน์ปกติจะช่วยให้คุณสามารถค้นหา แทนที่ และจัดการสตริงข้อความได้อย่างมีประสิทธิภาพและแม่นยำ ตั้งแต่การจับคู่พื้นฐานไปจนถึงการใช้ตัวดัดแปลง กลุ่ม และวิธีการที่มีประโยชน์อื่นๆ คุณได้เรียนรู้วิธีการใช้นิพจน์ปกติให้เกิดประโยชน์สูงสุดในโปรเจกต์ JavaScript ของคุณแล้ว

อย่าลืมฝึกฝนและทดลองใช้รูปแบบและกรณีการใช้งานที่แตกต่างกันเพื่อเสริมสร้างความเข้าใจและความคุ้นเคยกับนิพจน์ทั่วไป อย่าลังเลที่จะใช้นิพจน์ทั่วไปเพื่อปรับปรุงประสิทธิภาพและคุณภาพของโค้ดของคุณ!