ฉันไม่ได้ถามว่าจะเรียนที่ไหน ฉันพบแหล่งข้อมูลดีๆมากมายทางออนไลน์และหนังสือ ฯลฯ

แต่ฉันจะรับมือกับพวกมันได้อย่างไร จุดเริ่มต้นของมันอยู่ที่ไหนจุดจบ? หน่วยประมวลผล regexp ล่วงหน้าเมื่อข้อความมันจะยืนอยู่เมื่อใดและลองการแข่งขันอื่น? เป็นต้น

ฉันรู้สึกอยากลองนึกภาพอักษรอียิปต์โบราณบนปิรามิดอียิปต์

ฉันคิดว่าความรู้เกี่ยวกับทฤษฎีออโตมาตามีความสำคัญต่อความเข้าใจ

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

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

แก้ไข

ความคิดเห็นบางส่วนด้านล่างยกประเด็นสำคัญ:

1. อย่าลืมว่านิพจน์ทั่วไป (ตามที่ใช้ในภาษาการเขียนโปรแกรมส่วนใหญ่) เป็นชุดของนิพจน์ทั่วไปในทฤษฎีออโตมาตะ ในขณะที่ภูมิหลังทางทฤษฎีที่ดีเป็นสถานที่ที่มีประโยชน์ในการเริ่มต้น แต่มันจะไม่บอกคุณทุกอย่าง (ขอบคุณ David Thornley)

2. ผู้วิจารณ์หลายคนบอกว่าเป็นไปได้ที่จะเรียนรู้ไวยากรณ์ต่าง ๆ ของ regex โดยไม่ต้องเรียนรู้พื้นฐานทางทฤษฎี ในขณะที่มันเป็นความจริงที่คุณสามารถเรียนรู้ไวยากรณ์โดยไม่เข้าใจวิธีการทำงานอย่างเต็มที่มันเป็นความประทับใจของฉันที่ความเข้าใจอย่างเต็มรูปแบบคือสิ่งที่ OP ดำเนินการ คำถามคือเกี่ยวกับพื้นฐานจริง: เมื่อโปรเซสเซอร์ล่วงหน้า? มันหยุดเมื่อไหร่? มันตัดสินได้อย่างไรว่ามันเข้าคู่กัน นั่นคือพื้นฐานนั่นคือทฤษฎีและเป็นไปตามทฤษฎีออโตมาตะ แน่นอนคุณสามารถขับรถยนต์โดยไม่ทราบว่าเครื่องยนต์ทำงานอย่างไร แต่ถ้าคุณถูกถามว่า "ก๊าซขับอย่างไรให้เป็นจริง" - คุณต้องพูดคุยเกี่ยวกับวิธีการสร้างเครื่องยนต์ใช่มั้ย

โดยการฝึกฝน

ฉันเรียนโดยสนุกกับการขูดเว็บ ฉันแน่ใจว่าฉันไม่ได้ทำเพื่อความสนุกเพียงอย่างเดียว

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

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

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

คุณต้องการที่จะเข้าใจ regexp เหล่านั้นเหี้ย? อ่านหนังสือเล่มนี้

จุดเริ่มต้นของมันอยู่ที่ไหนจุดจบ? หน่วยประมวลผล regexp ล่วงหน้าเมื่อข้อความมันจะยืนอยู่เมื่อใดและลองการแข่งขันอื่น? เป็นต้น

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

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

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

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

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

แทบไม่มีใครทำสิ่งนี้ด้วยเหตุผลหลายประการ ก่อนอื่นจำนวนรัฐที่คูณด้วยจำนวนอักขระที่เป็นไปได้จะทำให้ตารางการเปลี่ยนสถานะที่ใหญ่โตของ freakin แม้สำหรับนิพจน์ปกติขนาดเล็ก แน่นอนว่าส่วนใหญ่สามารถบีบอัดได้ แต่ก็ยังเป็นกฎการเปลี่ยนภาพจำนวนมาก ประการที่สองวิธีการอื่นมักจะเร็วกว่า ที่สามเรียกว่านิพจน์ "ปกติ" อยู่ในไลบรารี regexp ที่ทันสมัยไม่มีการเรียงลำดับ พวกเขาไม่ใช่ภาษาปกติเลย พวกเขามักจะได้รับการยอมรับโดยการกดออโตมาตะไม่ จำกัด ภาษาออโตมาตะ

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

เอ็นจิ้นนิพจน์ทั่วไปที่แท้จริงมักใช้กลยุทธ์ย้อนรอยแทน เอ็นจิ้นนิพจน์ทั่วไปที่เราสร้างขึ้นสำหรับเอ็นจิ้น JScript กว่าทศวรรษที่ผ่านมาในขณะนี้ได้รวบรวมนิพจน์ทั่วไปเป็นภาษา bytecode ซึ่งรวมถึงการใช้พื้นฐานสำหรับการจดจำลำดับและการย้อนรอยกลับสู่สถานะก่อนหน้า จากนั้นเราสร้างล่ามสำหรับภาษา bytecode

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

ฉันจะรับมือกับพวกมันได้อย่างไร

เหมือนสิ่งใหม่ ๆ :

10 Study
20 Practice
30 goto 10

ศึกษา

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

มันคือการจับคู่สตริงทั้งหมด

นิพจน์ปกติเป็นวิธีการจับคู่รูปแบบในข้อความ มันเป็นภาษาที่ประกาศตัวเองรวมอยู่ในภาษาการเขียนโปรแกรมอื่น ๆ อีกมากมาย

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

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

บางคนจะ (และควร) บ่นเกี่ยวกับประโยคก่อนหน้าของฉันด้วยการพูดอะไรบางอย่างตามสายของ:

RegEx ไม่ทำให้โปรแกรมง่ายขึ้น

มันเป็นความจริง

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

_{ให้รวมตัวอย่างบางส่วนที่ฉันเลือกเอนจิน RegEx ของ JavaScript เพราะฉันสามารถทดสอบมันได้ในเบราว์เซอร์ได้อย่างง่ายดายและเพราะฉันไม่ต้องใช้สายอักขระใด ๆ ในการหลบหนีขณะใช้ตัวอักษร RegEx}

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

if ( 'foo' == 'bar' ) doSomething();

ตัวอย่างนั้นดูดเพราะมันจะไม่ทำอะไรเลย

if ( foo == 'bar' ) doSomething();

ดีกว่ามาก ตอนนี้เราไม่ทราบล่วงหน้าว่าจะมีบางสิ่งที่จะทำหรือไม่ ตอนนี้เราสามารถเริ่มยอมรับการป้อนข้อมูลของผู้ใช้:

if ( prompt( 'Say "bar" to do something.' ) == 'bar' ) doSomething();

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

ไม่สนใจการสะกดผิดและตัวละครพิเศษ'bar' != 'BAR'และโปรแกรมเมอร์จำเป็นต้องคิดหาวิธีทดสอบว่าตัวละครตัวไหนผิด

toLowerCaseวิธีง่ายๆในการใช้งาน มันใช้งานได้อย่างยอดเยี่ยม แต่สิ่งที่เกี่ยวกับผู้ใช้ของเราที่ใช้ภาษาอังกฤษแบบอังกฤษมากกว่าภาษาอังกฤษแบบอเมริกันเมื่อคุณจับคู่something == 'color'? something == 'color' || somthing == 'colour'ตอนนี้คุณจะต้องตรงกับ

เรื่องสั้นสั้น ๆ รูปแบบง่าย ๆ เปลี่ยนเป็นรหัสซ้ำ ๆ จำนวนมากอย่างรวดเร็ว

ตัวอย่างสีสามารถจับคู่กับ:

/colou?r/.test( something )

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

เรียนที่ไหน

ภาษาส่วนใหญ่ที่ใช้นิพจน์ทั่วไปมีทรัพยากรอย่างน้อยหนึ่งรายการสำหรับไวยากรณ์เฉพาะของการใช้นิพจน์ทั่วไปภายในภาษานั้น หนึ่งสำหรับJavaScript สามารถพบได้ใน MDN

อ่านมัน
ทั้งหมดของมัน.
จากนั้นอ่านอีกครั้ง

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

การปฏิบัติ

หลังจากอ่านทั้งหมดเกี่ยวกับ RegEx คุณอาจไม่เข้าใจส่วนใหญ่ นั่นเป็นเพราะคุณไม่ได้ทำอะไรเลย

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

JS มีวิธีที่แตกต่างและเรียบง่ายในการใช้ RegEx:

string.match( regex )
regex.exec( string )
regex.test( string )

เริ่มต้นด้วยสิ่งที่ง่ายเช่น:

javascript:'color'.match(/colou?r/);

เป็นวิธีง่ายๆในการก้าวเท้าเข้าประตู เล่นกับมันทำลายมันดูสิ่งที่ตรงกันและสิ่งที่ไม่

30เมื่อคุณได้รับการติดในการปฏิบัติต่อไป คุณต้องอ่านเพื่อเรียนรู้เพิ่มเติม แต่คุณต้องฝึกฝนเพื่อเข้าใจสิ่งที่คุณเรียนรู้อย่างแท้จริง

ไบรอัน Kernighan เขียนโปรเซสเซอร์ reg อดีตที่เรียบง่ายในหนังสือรหัสที่สวยงาม ฉันรู้ว่าคุณไม่ได้มองหาแหล่งข้อมูล แต่อาจช่วยให้เห็นการใช้งานขั้นพื้นฐานได้จากภายใน

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

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

คำแนะนำของฉันคือการเริ่มต้นด้วยตัวอย่างของสิ่งที่คุณกำลังค้นหาและหลบหนี ดังนั้นในคำอื่น ๆ หากคุณกำลังมองหาสิ่งใดในวงเล็บให้ใช้ตัวอย่างของสตริงดังกล่าวหนึ่งในข้อความที่คุณกำลังค้นหา: (this is an example of something you'd want to find)

เริ่มต้นด้วยการหลีกเลี่ยงอักขระเพื่อให้คุณค้นหาตัวอักษร: \(this is an example of something you'd want to find\)

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

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

เกี่ยวกับมัน. และโอ้จงเรียนรู้และรัก \ Q ... \ E ในภาษาที่แสดงออกเป็นประจำส่วนใหญ่ \ Q บ่งบอกถึงจุดเริ่มต้นของรูปแบบตัวอักษรและ \ E ทำเครื่องหมายจุดสิ้นสุดในกรณีที่คุณต้องรับมือกับการค้นหารูปแบบที่ซับซ้อนเป็นพิเศษและไม่รู้วิธีหลบหนี นั่นช่วยชีวิตฉันได้มากกว่าสองครั้ง

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

1. มันคืออะไร? RegEx เป็นภาษาสำหรับแสดงรูปแบบการจับคู่ กล่าวคือใช้มันคุณสามารถสร้างชุดอักขระที่จดจำหรือค้นหาลวดลายในข้อความได้ สิ่งนี้มีประโยชน์อย่างไร? ในการเขียนโปรแกรมคุณสามารถบอกคอมพิวเตอร์ให้จับคู่ข้อความจากแหล่งข้อมูลบางส่วน (อินพุตผู้ใช้เว็บเพจ ฯลฯ ) และตรวจสอบว่ามีส่วนเฉพาะของข้อความอยู่หรือไม่ ตัวอย่างเช่นเครื่องหมายจุด (.) หมายถึงอักขระใด ๆ - ตัวอักษรหรือตัวเลข ตัวเลขในเครื่องหมายปีกกาแสดงถึงจำนวนของการวนซ้ำดังนั้น ". {1,30}" หมายถึงอักขระใด ๆ ซ้ำระหว่าง 1 ถึง 30 ครั้ง - กล่าวอีกนัยหนึ่งคุณไม่สามารถมีสตริงว่างได้และต้องไม่เกิน 30 ตัวละคร และมันก็ไปจากที่นั่น

2. เริ่มเรียนได้อย่างไร? เครื่องมือที่ดีที่สุดที่ฉันเคยเห็นคือExpressoแต่สำหรับ Windows เท่านั้น มันมี GUI ที่ครอบคลุมมากซึ่งคุณคลิกผ่านองค์ประกอบที่คุณต้องการเพิ่มในนิพจน์ของคุณจากนั้นผู้ทดสอบเพื่อตรวจสอบกับอินพุตต่างๆเพื่อดูผลลัพธ์ ฉันไม่เห็นอะไรที่ดีใน Mac (แต่ฉันใช้ Windows บน VMWare ดังนั้นไม่จำเป็นต้องใช้รุ่น Mac) ไม่ได้ใช้เวลามากมายในการดู Linux

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

1. : ตั้งค่าการค้นหา ... ในขณะที่คุณพิมพ์ในรูปแบบการค้นหาบนบรรทัดคำสั่งตัวแก้ไข on-the-fly จะข้ามไปที่ข้อความแรกที่ตรงกับและเน้นสิ่งที่ตรงกัน หากคุณพิมพ์สิ่งที่ทำให้ไม่ตรงกับสิ่งใดอีกต่อไป Vim จะกระโดดเคอร์เซอร์กลับไปยังตำแหน่งที่คุณอยู่เมื่อคุณเริ่มต้น
2. : set hlsearch ... สิ่งนี้บอกให้ Vim แสดงพื้นหลังที่ไฮไลต์บนข้อความทั้งหมดที่ตรงกับการค้นหา RE ปัจจุบัน

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

คุณเริ่มต้นด้วยการเปรียบเทียบสตริงพื้นฐาน ง่ายมาก แต่ก็ไม่ได้ทรงพลังเช่นกัน

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

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

จนกว่าคุณจะเข้าใจนามธรรมมากขึ้นและตระหนักว่าบางครั้งคุณต้องการคำทั้งหมดที่ลงท้ายด้วย "ize" เพื่อเปรียบเทียบเท่ากับพี่น้องของพวกเขาในการสะกดคำภาษาอังกฤษ หรือทำซ้ำสตริงบางจำนวนในบางครั้ง และแน่นอนคุณต้องรวมทุกอย่าง

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

และจากนั้นมันค่อนข้างง่ายและมีหลักการพื้นฐาน 3 ข้อต่อไปนี้:

คุณมีพื้นฐาน regexps: ตัวอักษรที่ยืนสำหรับตัวเองเรียนตัวอักษรตัวย่อที่มีประโยชน์และไม่เป็นประโยชน์สำหรับชั้นเรียนตัวละครเช่น \ d หรือ \ p {Lu} สำหรับตัวอักษรตัวพิมพ์ใหญ่

จากนั้นคุณมีความเป็นไปได้ที่จะรวมพวกมันเข้าด้วยกัน: ถ้า r1 และ r2 เป็น regexps ดังนั้นก็คือ r1r2 r1 | r2 (r1)

สุดท้าย แต่ไม่ใช่อย่างน้อยตัวดัดแปลงการซ้ำซ้อน: r? r * r + r {n, m}

นี่คือสิ่งที่คุณต้องรู้ อะไรก็ได้ที่คุณสามารถค้นหาได้เมื่อคุณต้องการ

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

ตัวอย่างเช่นRegexBuddyมีโหมดดีบักแบบภาพที่ช่วยให้คุณสามารถผ่านการดำเนินการของ regex และแสดงให้คุณเห็นผ่านไฮไลท์และข้อความอธิบายสิ่งที่เอ็นจิน regex ทำในแต่ละขั้นตอน มีวิดีโอสาธิตการดีบักบนเว็บไซต์ของพวกเขา

ทุกสิ่งที่เราสามารถให้คุณได้คือแหล่งเรียนรู้เพิ่มเติม คำถามนี้เป็นทรัพยากรตัวเอง

โดยวิธีการที่ฉันได้เรียนรู้การแสดงออกปกติค่อนข้างง่ายจากเว็บไซต์นี้: http://www.regular-expressions.info/

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

ในการทำเช่นนี้ฉันจะเปิดไฟล์ที่มีข้อความเป้าหมายใน Emacs จากนั้นใช้isearch-forward-regexpคำสั่ง ในขณะที่คุณป้อน regexp นั้น Emacs จะแสดงให้คุณเห็นว่ามันจับคู่อะไรกัน (นั่นคือส่วน "isearch")

เมื่อต้องการเรียกใช้คำสั่งใน Emacs <ESC>xisearch-forward-regexpคุณสามารถใช้

ฉันเรียนรู้การแสดงออกปกติโดยการเรียนดิ้นและวัวกระทิงซึ่งใช้ในการสร้างตัววิเคราะห์คำและตัวแยกวิเคราะห์ คุณไม่มีตัวแยกวิเคราะห์ที่ไม่มีการแสดงออกปกติและหนังสือlexx และ yaccนั้นเก่งในการเดินผ่านทฤษฎีโดยไม่ต้องเคลื่อนไหวเร็วเกินไป

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

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

คำถามนี้รวมถึงแหล่งข้อมูลเพื่อการเรียนรู้และโครงกระดูกงอที่ฉันโยนเข้าด้วยกัน

อีกต่อไปฉันพยายามทำให้แน่ใจว่าไม่มีวิธีที่ง่ายกว่าในการแก้ปัญหา / "tokenize" สตริง

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

นี่คือตัวอย่าง:

string = "Sep 22 19:57:38 host fcron[9137]: \
          Job fbsetbg -r $HOME/backgrounds/ \
          started for user user (pid 9138)"

เพื่อให้ตรงกับนาที:

string.match /^\w+\s\d+\s\d+:(\d+):\d+\s\w+\s/ # correct but bad
string.match /\d+:([^:]+):\d+/                 # correct and good

แทนที่จะพยายามหาเวลาพร้อมกับทุกอย่างอื่นลองค้นหาขอบเขตที่แตกต่างกัน

ตัวอย่างเป็นสิ่งประดิษฐ์เล็กน้อย แต่ทั้งหมดที่ฉันสามารถทำได้

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

สคริปต์จำเป็นต้องเรียกใช้กับไฟล์ต่าง ๆ มากมายในแต่ละโครงการโอเพนซอร์ส จากนั้นเรียกใช้กับโปรเจ็กต์ต่าง ๆ ที่มีสไตล์แตกต่างกัน ฉันเริ่มต้นด้วยสิ่งที่ง่ายมากเช่น%s/before/after นั้นฉันพบว่ามันจับคู่กับกรณีมากเกินไป ดังนั้นฉันจึงเพิ่มสิ่งอื่น ๆ เพื่อป้องกันไม่ให้ จากนั้นฉันก็พบโครงการต่าง ๆ โดยใช้รูปแบบไวยากรณ์ที่แตกต่างกันซึ่งต้องการการเปลี่ยนแปลงที่แตกต่างกัน

ในที่สุดฉันก็ลงเอยด้วย

• ทักษะที่ยอดเยี่ยมและความรู้เกี่ยวกับการแสดงออกปกติ
• ทักษะที่ดีกับ sed
• ช่วยเหลือโครงการโอเพ่นซอร์สมากมาย
• ได้รับกิจกรรมการสนับสนุนมากมายที่แสดงบนโปรไฟล์ GitHub ของฉัน
• อีกหนึ่งเครื่องมือ 'มีดสวิสกองทัพ' ที่ดีสำหรับแถบเครื่องมือเสมือน

และได้รับการช่วยเหลือในแนวทางนี้โดยต้องการ

• บรรลุเป้าหมายที่แท้จริงโดยไม่ต้องโกง
• ใช้ทักษะ (regex) เป็นส่วนหนึ่งของเป้าหมายที่มากขึ้นพร้อมแรงจูงใจที่มากขึ้น
• สามารถแสดงหลักฐานของทักษะที่ฉันเรียนรู้โดยการเปลี่ยนรหัสอื่น ๆ จากนั้นตรวจสอบการเปลี่ยนแปลง

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

• Ruby - http://rubular.com
• Python - https://pythex.org
• Javascript - http://scriptular.com
• Java - http://www.regexplanet.com/advanced/java/index.html
• .net - http://regexhero.net/

regexes ในหลายภาษาในเว็บไซต์เดียว

• http://regex101.com/ javascript / php / python
• http://myregextester.com/ PHP / JAVA / JS / ASP / .NET / C # / VB.NET

มุ่งเน้นไปที่กลุ่มการแข่งขัน:

• https://www.debuggex.com/

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

เมื่อฉันเรียนรู้ฉันจะตั้งเป้าหมายในการทำแบบฝึกหัด Regex สองสามข้อต่อวัน ในทางปฏิบัติสิ่งนี้มีความหมายอย่างน้อยวันละครั้งฉันจะลองดูสตริงหรือข้อความบนหน้าจอของฉันและพบกับความท้าทาย - "ฉันจะเอาที่อยู่อีเมลทั้งหมดออกจากที่นี่" หรือ "ค้นหาทั้งหมด สิ่งที่เกิดขึ้นของคำว่า 'code' ใช้เป็นคำกริยาแทนคำนาม "เป็นอย่างนั้น

การทำเช่นนั้นสำหรับสองสามสัปดาห์จะได้ผลจริง - และแน่นอนต้องมีการตรวจสอบและรีเฟรชเป็นระยะ ฉันกำลังจะครบกำหนด

ฉันพบว่าเครื่องมือออนไลน์นี้มีประโยชน์เช่นกันเพราะให้ฉันทดสอบ regex แบบเรียลไทม์: http://www.gethifi.com/tools/regex