ריצה בלופ מהאחרון לראשון בJS

שאול נ"י

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

const str = 'שלום וברכה, נא להשאיר הודעה ונחזור אליכם בהקדם';

const s = str.match(/.{1,10}(\s|$)/g);

שזה מחלק לעשר תווים (או פחות) אבל משאיר מילים שלימות

עכשיו אני רוצה לעשות פעולה על כל המשתנים המחולקים ולהריץ אותם מהאחרון לראשון לפי הסדר
ניסתי משהו כזה

const str = 'שלום וברכה, נא להשאיר הודעה ונחזור אליכם בהקדם';

const s = str.match(/.{1,10}(\s|$)/g);
for (e of s){

const a = 1
  console.log(s[s.length -0+-a])
}

השאלה איך אני עושה שבכל ריצה משתנה 'a' יעלה מספר?
או שאני בכלל לא בכיוון והשאלה איך כן עושים את זה

צדיק תמים

@שאול-נ-י לא הבנתי, מה המטרה של a?
אם אתה משתמש בforof אין צורך במשתנה אינדקס

const str = 'שלום וברכה, נא להשאיר הודעה ונחזור אליכם בהקדם';
const words = str.match(/.{1,10}(\s|$)/g);
for (const word of words.reverse()) {
    console.log(word)
}

ממליץ לקרוא על לולאות בספר של רן בר-זיק (בתשלום, משתלם מאוד לדעתי), זה יעשה לך קצת סדר...

yossiz

@שאול-נ-י אמר בריצה בלופ מהאחרון לראשון בJS:

אז מישהו כתב לי איך לחלק את זה, הנה דוגמא
str.match(/.{1,10}(\s|$)/g)

שים לב שבדרך זו יכול להיות מצב שאתה מפספס חלק מהמחרוזת המקורי, למשל אם יש רצף של יותר מ-10 תווים שאינם רווחים, או במקרה של שני סופי שורה זא"ז

דוגמה:

const regex = /.{1,10}(\s|$)/g

const works = "שלום וברכה, נא להשאיר הודעה ונחזור אליכם בהקדם";
const broken1 = "Hmm...\n\nThis is a string with 2 consecutive line breaks";
const broken2 = "This is a string with more than 10 consecutive non-space characters...";

const resWorks = works.match(regex);
const resBroken1 = broken1.match(regex);
const resBroken2 = broken2.match(regex);

console.log(resWorks.join('') === works); // true
console.log(resBroken1.join('') === broken1); // false
console.log(resBroken2.join('') === resBroken2); // false

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

ivrtikshoret

@שאול-נ-י

מה המטרה?

yossiz

@צדיק-תמים אמר בריצה בלופ מהאחרון לראשון בJS:

words.reverse

שים לב שזה עושה שינוי במערך המקורי

צדיק תמים

@yossiz צודק.
הפתרון לזה (במידה שזו לא ההתנהגות הרצויה) הוא ליצור עותק ועליו לרוץ, אפשר אפילו בצורה הזאת:

const str = 'שלום וברכה, נא להשאיר הודעה ונחזור אליכם בהקדם';
const words = str.match(/.{1,10}(\s|$)/g);
for (const word of [...words].reverse()) {
    console.log(word)
}

dovid

@שאול אני נהנה מהקוד שלך כי הוא מראה על תחכום, ועל ראש מתכנת.
מה שבעצם חיפשת זה להעלות את המשתנה a באחד בכל סיבוב.
אולם אתה מצהיר על הa בתוך הלולאה אז הוא לא יכול לזכור מה היה ערכו ב"גלגול" הקודם. צריך להכריז עליו מחוץ לולואה ועם let כי const זה לא בר עדכון.
העלאה באחד של משתנה זה פעולה פשוטה , a = a + 1, או בדרך הקצרה a++; ככה:

let a = 0
for (e of s) {
  a++;
  console.log(s[s.length - a])
}

אולם במקרה שאתה עושה עדכון מניה למשתנה במהלך הלולאה אז הרבה יותר נכון להשתמש בלולאת for רגילה, זה אחת הלולאות הוותיקות ביותר ושוריאציה שלה נמצאת כמעט בכל שפת תכנות. זה נראה ככה:

for (let a = 1; a < (s.length + 1); a++) {
  console.log(s[s.length - a])
}

בגלל הגמישות של לולאת for אז אפשר ישירות לעשות מניה הפוכה:

const s = str.match(/.{1,10}(\s|$)/g);

for (let i = s.length -1; i > -1; i--){
    console.log(s[i])
 }

מה שעשיתי זה קביעת המשתנה i למספר הגבוה, וכל פעם לרדת אחד עד האפס.
יש בעצם שלוש חלקים, אתחול (let i = s.length -1), תנאי (i > -1), ועדכון מונה (i--).
האתחול קורה פעם אחת לפני הלולאה בכל מקרה, התנאי נבדק כל פעם לפני האיטרציה (כל "סיבוב") ועדכון המונה מתרחש אחריו.

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

OdedDvir

פוסט זה נמחק!

שאול נ"י

@yossiz אמר בריצה בלופ מהאחרון לראשון בJS:

@שאול-נ-י אמר בריצה בלופ מהאחרון לראשון בJS:

אז מישהו כתב לי איך לחלק את זה, הנה דוגמא
str.match(/.{1,10}(\s|$)/g)

שים לב שבדרך זו יכול להיות מצב שאתה מפספס חלק מהמחרוזת המקורי, למשל אם יש רצף של יותר מ-10 תווים שאינם רווחים,

אכן, ואת זה לקחתי בחשבון, אך למרות זאת זה עדיך לי קודם כל משום שאני מתכוון ליישם את זה על הרבה יותר תווים (אני לא חושב שיש מילה של יותר מ-140 תווים ) וגם במקרה כזה עדיף לי שייחתך באמצע משישאיר יותר תווים

או במקרה של שני סופי שורה זא"ז

והשנייה על ידי הוספת הדגל s לרג'קס

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

Y.Excel.Access

@dovid אמר בריצה בלופ מהאחרון לראשון בJS:

אולם במקרה שאתה עושה עדכון מניה למשתנה במהלך הלולאה אז הרבה יותר נכון להשתמש בלולאת for רגילה, זה אחת הלולאות הוותיקות ביותר ושוריאציה שלה נמצאת כמעט בכל שפת תכנות.

רציתי לציין עוד מעלה על דרך זו, שבלולאת FOR המשתנה i הרץ על פני הלולאה אינו מאוחסן במשתנה רגיל, אלא הוא מאוחסן במשתנה הקרוב פיזית למעבד. כך שהמהירות אמורה לעלות משמעותית, ובנוסף גם אין צורך לחפש את המשתנה לפי כתובתו כל פעם.
כך לפחות במעבדים של פון נוימן.

משא"כ אם כותבים let a, ו ++a.

dovid

@Y-Excel-Access אמר בריצה בלופ מהאחרון לראשון בJS:

כך לפחות במעבדים של פון נוימן.

זה תלוי קודם כל באיזה מקמפל.
באופן כללי, זה נכון שככל שכותבים קוד שמתאים לכוונה זה מיקל על האופטימיזציות של המהדרים/מפרשים.

תחומים - פורום חרדי מקצועי

ריצה בלופ מהאחרון לראשון בJS