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

[chagold]

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

כיון שיש פער של זמן בין שליחת הנתונים לשרת - והקבלה חזרה . קורה שיש באגים.
לדוגמא, אני מעדכן שדה מערך ריק והוספתי איבר. (לצורך הדוגמא פער של שניה בין השליחה לקבלה)
בשניה 0 נשלח לשרת עם איבר אחד.
בשניה 0.5 נשלח לשרת עם 2 איברים.
בשניה 1 חזר מה ששלחתי ב-0, והוא חזר עם איבר 1. אז הוא עדכן את המידע בקליינט עם איבר אחד, במקום שתים. רק עוד חצי שניה תחזור התגובה לבקשה הבאה עם 2 איברים.
מה שקורה שכשבשניה 1.1 שלחתי שוב עדכון, במקום לשלוח את המערך עם 2 איברים, הוא שולח אותו רק עם איבר אחד.

איך אני ניגש לפתור את זה?
תודה.

[dovid]

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

let sendToServer = null;
     
function send() {
     const taskUpdate = fetch('/dagim/kumkum', {method: 'POST', body: JSON.stringify(xyz)})
                                        .then(x => x.json())
                                        .then(data => {
                                            if(taskUpdate == sendToServer) 
                                                updateUI(data);
                                        });
    sendToServer = taskUpdate;
}

אפשרות יותר פשוטה להבנה:

let dataUiAsString = null;

function send() {
    const localStrData = JSON.stringify(...);
    dataUiAsString = localStrData;
    const data = await fetch('/dagim/kumkum').then(x => x.json())ף

    if (dataUiAsString == localStrData)
        updateUI(data);
}

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

עד פה זה פתרון בהנחה ש:
א. אנחנו רוצים לאפשר לUI להמשיך לעשות שינוי עוד לפני תשובת השרת על השינוי שכבר נעשה.
ב. תשובת השרת המלאה נחוצה מעבר לאישור, כי הוא כופה תיקונים על הקלט.
(שני ההחות קצת סותרות, כי בד"כ שהשרת מחליט שינויין אז קשה לבנות על מצב בלתי בשל ולהמשיך לעבוד איתו, אך כמובן זה תלוי מה היקף והחפיפה של התיקונים והשינויים).

[dovid]

@chagold הקודים שכתבתי לא היו תקינים כי כתבתי ישירות פה, כעת ערכתי בעורך קוד ותיקנתי כמה טעויות והעתקתי לפה.

[chagold]

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

[dovid]

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

[chagold]

@dovid כתב בקצב עדכון נתונים מהיר לשרת, ווידוא קבלת המידע בחזרה לאחר כל העדכונים:

הקאלבק האחרון תמיד כן יקרה

לא הבנתי. אם שרת כפה שינוי איך הוא יקרה? הרי הוא לא שווה למה שנשלח?

[dovid]

@chagold כתב בקצב עדכון נתונים מהיר לשרת, ווידוא קבלת המידע בחזרה לאחר כל העדכונים:

הרי הוא לא שווה למה שנשלח

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

[chagold]

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