פירוק מחרוזת לתווים יחידים באמצעות רג'קס

[חגי]

@yossiz
אני לא רוצה להתאים "תו", אני רוצה להתאים את מה שביניהם (בעיקרון זה כלום, אבל יש רג'קס לכלום הזה), ואני מפצל באמצעות הכלום הזה, מה שמשאיר לי את כל התווים מפוצלים

אם אני מפצל באמצעות ., אז כל מה שנשאר לי הוא הכלום שבין התווים (לכן יש 10 מחרוזות ריקות, הכלום הזה נמצא גם לפני התו הראשון וגם אחרי האחרון)

[צדיק תמים]

@חגי זה כבר לא רגקס, אבל אפשר לכאורה פשוט לעשות

'abcd345'.split('') // ["a","b","c","d","3","4","5"]

[hp079]

@צדיק-תמים רק שים לב שביקשתי רג'קס בדווקא, כי הייתי צריך את זה לנוסחה שמקבלת רג'קס..

[חגי]

שמתי לב שיש תשובה יותר פשוטה ממש שכתבתי, ה-regex הבא:

()

אמור לבצע אותו דבר.

[yossiz]

@חגי

מה הפשט?

[חגי]

@yossiz טעות שלי, בעיקרון () זה רגקס להתאים NULL בתוך המחרוזת, חשבתי מregex101 שזה מתאים בדיוק כמו \b|\B, לא בדקתי את זה בדפדפן

וההסבר שלהם עונה את הכל:
1st Capturing Group () — null, matches any position

צריך עיון איך זה לא מתאים כלום, אבל באמת זה מתאים את הכל.
במקרה הזה "הכל" זה כולל גם מה שמתאים . וגם מה שמתאים \b|\B, והכל ברגקס אחד.

[upsilon01]

"asdsafs".split(/!?/)

לא חייב דווקא ! אלא כל תו שבוודאות לא יימצא בסטרינג

[צבי-ש]

@upsilon01 כתב בפירוק מחרוזת לתווים יחידים באמצעות רג'קס:

"asdsafs".split(/!?/)

לא חייב דווקא ! אלא כל תו שבוודאות לא יימצא בסטרינג

אני לא הייתי מסתמך על זה,
כל עוד לא אני הוא זה שמכניס את המחרוזת

[yossiz]

@חגי רק עכשיו הבנתי מה ההסבר לפלט של "abc.split(/()/)‎"
ההסבר שלך לצערי לא הבנתי כלל

אבל ההסבר הנכון זה מה שכתוב ב-MDN פה
וביותר אריכות פה
ולחולים הקשים שבינינו פה ופה

בקיצור ההתנהגות של split במקרה של רג'קס הוא ככה:

• אם הארגומנט הראשון של split הוא אובייקט עם מאפיין [Symbol.split] אז המימוש "מואצלת" לערך של שדה זו
• מכיון שלרג'קס יש מאפיין כזו, הוא אחראי על המימוש של split
• וכך הוא המימוש (פלוס מינוס):
  • אינדקס = 0
  • START:
  • מחפשים התאמה לרג'קס מאינדקס עד סוף המחרוזת,
  • אם הוא נמצא:
    • אינדקס קודם = אינדקס
    • אינדקס מעודכן לסוף ההתאמה
    • אם אינדקס != אינדקס קודם, מכניסים למערך התוצאות את הדברים הבאים:
      • התווים מאינדקס קודם עד לתחילת ההתאמה, כולל אם זו מחרוזת ריקה
      • התוכן של כל הקבוצות הקיימות ברג'קס, כולל אם הם מחרוזות ריקות
    • אם אינדקס == אינדקס קודם: => אינדקס++
  • GOTO START

נ.ב. ההתנהגות זהה ל-split עם מחרוזת פשוטה, חוץ מהבדל היחיד ברג'קס שזה ההוספה של התוכן של כל הקבוצות

היוצא מזה ש:

_.isEqual(
  "abc".split(/()/),
  "abc".split(/(\b|\B)/)
)
// ['a', '', 'b', '', 'c']

_.isEqual(
  "abc".split(/(?:)/),
  "abc".split(/\b|\B/)
)
// ['a', 'b', 'c']

עוד ביאור לגבי /()/
רג'קס של כלום מתאים לכל מיקום במחרוזת.
רג'קס של () הוא רג'קס של כלום בתוך קבוצה, לכן זה מתאים לכל מקום ומכיון שהוא בקובצה מקבלים גם מחרוזת ריקה בפלט

בעקרון ההסבר הזה מספיק, רק שהתבלבתי לגבי ההתנהגות הנכונה כאשר ההתאמה של החיפוש הוא למחרוזת ריקה, לכן הבאתי את כל האלגוריתם.

גם למדתי שאפשר להשתמש בכל אובייקט שיש לו שדה של [Symbol.split] ולאו דוקא רג'קס

[dovid]

@yossiz האריך מאוד בהסברים כרגיל (ואנחנו רוצים שהוא ימשיך ככה)
אבל עבור מי שרוצה את זה קצר, עיקר השאלה של @yossiz הייתה מה פשר המחרוזות הריקות. split אמור לחלק את המחרוזת כל מקום שנמצא התאמה, הקטע הריק אינו חלק מהמחרוזת אלא מההתאמה.
(אני חושב שהתיאוריה של חגי הייתה שבABC הוא פשוט מחלק גם אחרי הA אך גם לפני הB וממילא נהיה פה "חתיכת" טקסט של 0).
התשובה שמצא @yossiz היא הסוגריים, הם יוצרים קבוצה. כלומר ברגקס שמופיע בו סוגריים, כמה כזה דבר:

'abc123abc123abc'.split(/12(3)/)

בין כל abc יופיע גם חלק של 3 כי הוא קבוצה ברגקס:

['abc', '3', 'abc', '3', 'abc']

ומי שאחראי על ההחלטה המשונה (והשימושית) הזאת זה המחלקה רגקס ולא המתודה split (עיין בתשובתו של @yossiz).

ובעוד יותר קצר:
למרות שsplit לא כולל בחלוקת המחרוזת את המחלק שלה. אבל כן כולל בחלקים את הקבוצות של הרג'קס של כל מחלק...

[yossiz]

@dovid תודה
באמת אריכות דבריי לא מובנת למי שלא נכנס לתוך ראשי ומבין במה התקישיתי

התקשיתי גם איך נכנסים המחרוזות הריקות לפלט, וגם כי התבלבלתי איך באמת אמור להיות ההתנהגות כאשר יש התאמה למחרוזת ריקה, למשל אם זה בתחילת הקלט, האם מכניסים את המרוזת הריקה שלפני ההתאמה? האם מתקדמים עוד תו אחרי ההתאמה? ולמה? וכו'
מכיון שההשראה להסתבכות היו דברי חגי אז כתבתי כל הנ"ל בתשובה לדברי חגי, אבל באמת לא הכל קשור