ToCode
Відкрити в Telegram
1 420
Підписники
Немає даних24 години
+37 днів
-430 день
Архів дописів
1 421
כשדברים פשוטים דורשים הרבה קוד
לפני כמה ימים בפוסט שדיבר על איזה Design Pattern בריאקט נתקלתי בקטע הזה בתוך קומפוננטת ריאקט:
//...
const [loading, setLoading] = useState<boolean>(false);
const [data, setData] = useState<Item[] | null>(null);
const [error, setError] = useState<Error | undefined>(undefined);
useEffect(() => {
const fetchData = async () => {
setLoading(true);
try {
const response = await fetch("/api/users");
if (!response.ok) {
const error = await response.json();
throw new Error(\Error: ${error.error || response.status}\);
}
const data = await response.json();
setData(data);
} catch (e) {
setError(e as Error);
} finally {
setLoading(false);
}
};
fetchData();
}, []);
//...
אני יודע שזה שבור. אתם יודעים שזה שבור. ומי שכתב את הפוסט יודע שזה שבור. רשימת משתמשים שמגיעה מהרשת היא לא State של קומפוננטה, כי אי אפשר לקשור בין "כמה זמן המידע שקיבלתי מהרשת נשאר בתוקף" ל"כמה זמן הקומפוננטה נשארת על המסך".
ואני מבין. הקוד שם כי אתה רוצה לבנות דוגמה שיהיה לאנשים פשוט להבין אותה, ולא רוצה להכניס עכשיו react-query או swr כי אולי אנשים לא מכירים את הספריה הספציפית שבחרת ובשביל מה להכניס עכשיו עוד תלות. גם אני לפעמים מפשל בזה.
הבעיה האמיתית היא שהציפיות שלנו לא תואמות למציאות. אנחנו חושבים שמשיכת מידע מרחוק בריאקט צריכה להיות קלה, אבל בפועל ריאקט לא מטפל בזה ובניית מנגנון נכון של תקשורת דורשת הרבה קוד. ציפיות לא ריאליות יכולות לקלקל פוסטים אבל יש להן השפעה הרבה יותר גרועה על הערכות זמנים. מתכנתים שלא מכירים מספיק טוב את ריאקט עשויים לצפות לפתור בעיה בשורה, כשבפועל זה ייקח להם כמה ימים.
חדשות טובות? אין ממש. בעבודה עם טכנולוגיה שאנחנו לא מכירים יהיו הפתעות. לפעמים דברים שאנחנו בטוחים שצריכים להיות ממש קלים יוצאים נורא מסובכים, ולפעמים אנחנו נכתוב גירסאות לא טובות של קוד רק בגלל שמצאנו משהו שעובד ברשת ואנחנו לא רוצים להסתבך עם פיתרון יותר מסובך. בדיוק בגלל זה אנחנו תמיד צריכים לקחת מקדמי ביטחון בהערכות זמנים ולהשאיר זמן לריפקטורינג בהמשך.1 421
חמש דוגמאות קצרות לשימוש ב cat effect בסקאלה
המנגנון המובנה בסקאלה לתכנות אסינכרוני נקרא Future, והוא קצת מזכיר את Promise של JavaScript. הבעיה של הרבה אנשים עם Future היא שהוא מייצג תוצאה עתידית ולא חישוב עתידי. זה אומר שאם יש לי Future ביד אני לא יכול להריץ אותו כמה פעמים (כי החישוב כבר רץ).
מסיבה זאת נוצרו הרבה ספריות הרחבה לשפה שמאפשרות לייצר חישוב עתידי בצורה פונקציונאלית וללא Side Effects. אחת הפופולריות היא cats effect והנה חמש דוגמאות ראשונות שכתבתי עם הספריה.
שלום עולם
תוכנית סקאלה ראשונה עם cat effect היא כמובן פונקציה שמדפיסה שלום עולם:
def demo1(): IO[ExitCode] =
IO.println("Hello WOrld") >> IO.pure(ExitCode.Success)
הרעיון הראשון החדש כאן הוא שפונקציה שאפשר להריץ בצורה אסינכרונית זה בעצם פונקציה שמחזירה IO, וזה נקרא אפקט. לכן הפונקציה demo1 שמחזירה IO[ExitCode] מתאימה להרצה בצורה אסינכרונית. הסימן >> הוא דרך לחבר שני אפקטים ולהחזיר רק את התוצאה של השני, הפונקציה IO.println מייצרת אפקט שמדפיס למסך ו IO.pure מייצרת אפקט שמחזיר ערך קבוע (וכן אפשר לחשוב על אפקט בתור Promise אבל זה טיפה יותר מסובך כי אפקט אפשר גם לבטל).
שלום עולם עם המתנה
עכשיו שהבנו את הסיפור של אפקטים אפשר להמשיך ולראות איך מחברים אותם. דרך אחת לחבר אפקטים היא סימן ה >> שכבר פגשנו ואפשר לקחת אותו עוד צעד קדימה. הפונקציה IO.sleep מחזירה אפקט שמחכה, ולכן הקוד הבא:
def demo11(): IO[ExitCode] =
IO.sleep(1000.millis) >> IO.println("1") >>
IO.sleep(1000.millis) >> IO.println("2") >>
IO.sleep(1000.millis) >> IO.println("3") >>
IO.pure(ExitCode.Success)
מייצר אפקט שמחכה שניה, מדפיס 1, מחכה עוד שניה, מדפיס 2, מחכה עוד שניה, מדפיס 3 ואז מחזיר הצלחה.
דרך אחרת וקצת יותר ידידותית בסקאלה לכתוב אותו היא:
def demo2(): IO[ExitCode] =
for {
_ <- IO.sleep(1000.millis) >> IO.println("1")
_ <- IO.sleep(1000.millis) >> IO.println("2")
_ <- IO.sleep(1000.millis) >> IO.println("3")
} yield ExitCode.Success
וזו גם מאפשרת לכל אפקט להשתמש בתוצאה של האפקט שלפניו, למרות שבדוגמה הפעם לא עשיתי את זה והתעלמתי מהתוצאה של האפקט הקודם, בכך שנתתי לה את השם _.
שלום עולם במקביל
אחרי שאנחנו מבינים איך להגדיר מספר אפקטים הצעד הבא הוא להריץ אותם במקביל, בדומה ל Promise.all. ב cats effect זה קורה עם פונקציה בשם parSequence:
def demo3(): IO[ExitCode] =
List(
IO.sleep(1000.millis) >> IO.println("1"),
IO.sleep(1000.millis) >> IO.println("2"),
IO.sleep(1000.millis) >> IO.println("3")
).parSequence >> IO.pure(ExitCode.Success)
הפעם הקוד מגדיר רשימה של 3 אפקטים ומפעיל על הרשימה את parSequence. התוצאה היא הפעלה של שלושת האפקטים במקביל כך שאחרי שניה יודפסו שלוש ההודעות בסדר אקראי.
משיכת מידע מהרשת
ספריות הרחבה רבות של סקאלה שקשורות ל IO כוללת גירסה מותאמת ל cats effect, לדוגמה הספריה sttp שיודעת לשלוח בקשות HTTP. הקוד הבא בסקאלה מחזיר אפקט שפונה ל URL (בדוגמה שלי זה https://icanhazdadjoke.com/) ומחזיר את גוף התשובה בתור מחרוזת:
def randomDadJoke(): IO[String] =
HttpClientCatsBackend.resource[IO]().use { backend =>
basicRequest
.header("Accept", "application/json")
.get(uri"https://icanhazdadjoke.com/")
.response(asString)
.send(backend)
.map {response => response.body.right.get}
}
הדבר החשוב לשים לב הוא ערך ההחזרה של הפונקציה שזה IO[String] כלומר מדובר באפקט שיחזיר מחרוזת. אפשר להשתמש באפקט זה כדי להדפיס את התשובה:
def demo4(): IO[ExitCode] =
randomDadJoke().map(s => println(s)) >> IO.pure(ExitCode.Success)
משיכת מידע מהרשת במקביל
וכמובן אחרי שיש אפקט אפשר להריץ אותו במקביל כדי לקבל מספר בדיחות:
def demo5(): IO[ExitCode] =
List(
randomDadJoke().map(s => println(s)),
randomDadJoke().map(s => println(s)),
randomDadJoke().map(s => println(s))
).parSequence >> IO.pure(ExitCode.Success)1 421
חמש דוגמאות קצרות לשימוש ב cat effect בסקאלה
המנגנון המובנה בסקאלה לתכנות אסינכרוני נקרא Future, והוא קצת מזכיר את Promise של JavaScript\. הבעיה של הרבה אנשים עם Future היא שהוא מייצג תוצאה עתידית ולא חישוב עתידי\. זה אומר שאם יש לי Future ביד אני לא יכול להריץ אותו כמה פעמים (כי החישוב כבר רץ)\.
מסיבה זאת נוצרו הרבה ספריות הרחבה לשפה שמאפשרות לייצר חישוב עתידי בצורה פונקציונאלית וללא Side Effects\. אחת הפופולריות היא cats effect והנה חמש דוגמאות ראשונות שכתבתי עם הספריה\.
שלום עולם
תוכנית סקאלה ראשונה עם cat effect היא כמובן פונקציה שמדפיסה שלום עולם:
def demo1(): IO[ExitCode] \=
IO\.println("Hello WOrld") \>\> IO\.pure(ExitCode\.Success)
הרעיון הראשון החדש כאן הוא שפונקציה שאפשר להריץ בצורה אסינכרונית זה בעצם פונקציה שמחזירה IO, וזה נקרא אפקט\. לכן הפונקציה demo1 שמחזירה IO[ExitCode] מתאימה להרצה בצורה אסינכרונית\. הסימן \>\> הוא דרך לחבר שני אפקטים ולהחזיר רק את התוצאה של השני, הפונקציה IO\.println מייצרת אפקט שמדפיס למסך ו IO\.pure מייצרת אפקט שמחזיר ערך קבוע (וכן אפשר לחשוב על אפקט בתור Promise אבל זה טיפה יותר מסובך כי אפקט אפשר גם לבטל)\.
שלום עולם עם המתנה
עכשיו שהבנו את הסיפור של אפקטים אפשר להמשיך ולראות איך מחברים אותם\. דרך אחת לחבר אפקטים היא סימן ה \>\> שכבר פגשנו ואפשר לקחת אותו עוד צעד קדימה\. הפונקציה IO\.sleep מחזירה אפקט שמחכה, ולכן הקוד הבא:
def demo11(): IO[ExitCode] \=
IO\.sleep(1000\.millis) \>\> IO\.println("1") \>\>
IO\.sleep(1000\.millis) \>\> IO\.println("2") \>\>
IO\.sleep(1000\.millis) \>\> IO\.println("3") \>\>
IO\.pure(ExitCode\.Success)
מייצר אפקט שמחכה שניה, מדפיס 1, מחכה עוד שניה, מדפיס 2, מחכה עוד שניה, מדפיס 3 ואז מחזיר הצלחה\.
דרך אחרת וקצת יותר ידידותית בסקאלה לכתוב אותו היא:
def demo2(): IO[ExitCode] \=
for {
_ <\- IO\.sleep(1000\.millis) \>\> IO\.println("1")
_ <\- IO\.sleep(1000\.millis) \>\> IO\.println("2")
_ <\- IO\.sleep(1000\.millis) \>\> IO\.println("3")
} yield ExitCode\.Success
וזו גם מאפשרת לכל אפקט להשתמש בתוצאה של האפקט שלפניו, למרות שבדוגמה הפעם לא עשיתי את זה והתעלמתי מהתוצאה של האפקט הקודם, בכך שנתתי לה את השם _\.
שלום עולם במקביל
אחרי שאנחנו מבינים איך להגדיר מספר אפקטים הצעד הבא הוא להריץ אותם במקביל, בדומה ל Promise\.all\. ב cats effect זה קורה עם פונקציה בשם parSequence:
def demo3(): IO[ExitCode] \=
List(
IO\.sleep(1000\.millis) \>\> IO\.println("1"),
IO\.sleep(1000\.millis) \>\> IO\.println("2"),
IO\.sleep(1000\.millis) \>\> IO\.println("3")
)\.parSequence \>\> IO\.pure(ExitCode\.Success)
הפעם הקוד מגדיר רשימה של 3 אפקטים ומפעיל על הרשימה את parSequence\. התוצאה היא הפעלה של שלושת האפקטים במקביל כך שאחרי שניה יודפסו שלוש ההודעות בסדר אקראי\.
משיכת מידע מהרשת
ספריות הרחבה רבות של סקאלה שקשורות ל IO כוללת גירסה מותאמת ל cats effect, לדוגמה הספריה sttp שיודעת לשלוח בקשות HTTP\. הקוד הבא בסקאלה מחזיר אפקט שפונה ל URL (בדוגמה שלי זה https://icanhazdadjoke\.com/) ומחזיר את גוף התשובה בתור מחרוזת:
def randomDadJoke(): IO[String] \=
HttpClientCatsBackend\.resource[IO]()\.use { backend \=\>
basicRequest
\.header("Accept", "application/json")
\.get(uri"https://icanhazdadjoke\.com/")
\.response(asString)
\.send(backend)
\.map {response \=\> response\.body\.right\.get}
}
הדבר החשוב לשים לב הוא ערך ההחזרה של הפונקציה שזה IO[String] כלומר מדובר באפקט שיחזיר מחרוזת\. אפשר להשתמש באפקט זה כדי להדפיס את התשובה:
def demo4(): IO[ExitCode] \=
randomDadJoke()\.map(s \=\> println(s)) \>\> IO\.pure(ExitCode\.Success)
משיכת מידע מהרשת במקביל
וכמובן אחרי שיש אפקט אפשר להריץ אותו במקביל כדי לקבל מספר בדיחות:
def demo5(): IO[ExitCode] \=
List(
randomDadJoke()\.map(s \=\> println(s)),
randomDadJoke()\.map(s \=\> println(s)),
randomDadJoke()\.map(s \=\> println(s))1 421
# חמש דוגמאות קצרות לשימוש ב cat effect בסקאלה
סקאלה לא כוללת מנגנון תחבירי מובנה לקוד אסינכרוני וכך נוצרו ספריות הרחבה רבות שמנסות לגשר על הפער. cat effect היא ספריה פופולרית כזו שנראית גמישה ומתוחזקת, אבל לא בטוח כמה פשוטה ללימוד. הנה חמש דוגמאות יחסית פשוטות שעזרו לי להתחיל.
## שלום עולם
תוכנית סקאלה ראשונה עם cat effect היא כמובן פונקציה שמדפיסה שלום עולם:
def demo1(): IO[ExitCode] =
IO.println("Hello WOrld") >> IO.pure(ExitCode.Success)
הרעיון הראשון החדש כאן הוא שפונקציה שאפשר להריץ בצורה אסינכרונית זה בעצם פונקציה שמחזירה IO, וזה נקרא אפקט. לכן הפונקציה demo1 שמחזירה IO[ExitCode] מתאימה להרצה בצורה אסינכרונית. הסימן >> הוא דרך לחבר שני אפקטים ולהחזיר רק את התוצאה של השני, הפונקציה IO.println מייצרת אפקט שמדפיס למסך ו IO.pure מייצרת אפקט שמחזיר ערך קבוע (וכן אפשר לחשוב על אפקט בתור Promise אבל זה טיפה יותר מסובך כי אפקט אפשר גם לבטל).
## שלום עולם עם המתנה
עכשיו שהבנו את הסיפור של אפקטים אפשר להמשיך ולראות איך מחברים אותם. דרך אחת לחבר אפקטים היא סימן ה >> שכבר פגשנו ואפשר לקחת אותו עוד צעד קדימה. הפונקציה IO.sleep מחזירה אפקט שמחכה, ולכן הקוד הבא:
def demo11(): IO[ExitCode] =
IO.sleep(1000.millis) >> IO.println("1") >>
IO.sleep(1000.millis) >> IO.println("2") >>
IO.sleep(1000.millis) >> IO.println("3") >>
IO.pure(ExitCode.Success)
מייצר אפקט שמחכה שניה, מדפיס 1, מחכה עוד שניה, מדפיס 2, מחכה עוד שניה, מדפיס 3 ואז מחזיר הצלחה.
דרך אחרת וקצת יותר ידידותית בסקאלה לכתוב אותו היא:
def demo2(): IO[ExitCode] =
for {
_ <- IO.sleep(1000.millis) >> IO.println("1")
_ <- IO.sleep(1000.millis) >> IO.println("2")
_ <- IO.sleep(1000.millis) >> IO.println("3")
} yield ExitCode.Success
וזו גם מאפשרת לכל אפקט להשתמש בתוצאה של האפקט שלפניו, למרות שבדוגמה הפעם לא עשיתי את זה והתעלמתי מהתוצאה של האפקט הקודם, בכך שנתתי לה את השם _.
## שלום עולם במקביל
אחרי שאנחנו מבינים איך להגדיר מספר אפקטים הצעד הבא הוא להריץ אותם במקביל, בדומה ל Promise.all. ב cats effect זה קורה עם פונקציה בשם parSequence:
def demo3(): IO[ExitCode] =
List(
IO.sleep(1000.millis) >> IO.println("1"),
IO.sleep(1000.millis) >> IO.println("2"),
IO.sleep(1000.millis) >> IO.println("3")
).parSequence >> IO.pure(ExitCode.Success)
הפעם הקוד מגדיר רשימה של 3 אפקטים ומפעיל על הרשימה את parSequence. התוצאה היא הפעלה של שלושת האפקטים במקביל כך שאחרי שניה יודפסו שלוש ההודעות בסדר אקראי.
## משיכת מידע מהרשת
ספריות הרחבה רבות של סקאלה שקשורות ל IO כוללת גירסה מותאמת ל cats effect, לדוגמה הספריה sttp שיודעת לשלוח בקשות HTTP. הקוד הבא בסקאלה מחזיר אפקט שפונה ל URL (בדוגמה שלי זה https://icanhazdadjoke.com/) ומחזיר את גוף התשובה בתור מחרוזת:
def randomDadJoke(): IO[String] =
HttpClientCatsBackend.resource[IO]().use { backend =>
basicRequest
.header("Accept", "application/json")
.get(uri"https://icanhazdadjoke.com/")
.response(asString)
.send(backend)
.map {response => response.body.right.get}
}
הדבר החשוב לשים לב הוא ערך ההחזרה של הפונקציה שזה IO[String] כלומר מדובר באפקט שיחזיר מחרוזת. אפשר להשתמש באפקט זה כדי להדפיס את התשובה:
def demo4(): IO[ExitCode] =
randomDadJoke().map(s => println(s)) >> IO.pure(ExitCode.Success)
## משיכת מידע מהרשת במקביל
וכמובן אחרי שיש אפקט אפשר להריץ אותו במקביל כדי לקבל מספר בדיחות:
def demo5(): IO[ExitCode] =
List(
randomDadJoke().map(s => println(s)),
randomDadJoke().map(s => println(s)),
randomDadJoke().map(s => println(s))
).parSequence >> IO.pure(ExitCode.Success)1 421
# סוף הדרך
לפרויקט תוכנה, סוף הדרך הוא הנקודה שאף אחד כבר לא רוצה או יכול להמשיך לעבוד על הפרויקט הזה ואין סיכוי לראות בו פיצ'רים חדשים. הנה כמה מאפיינים משותפים שראיתי בפרויקטים שהגיעו לשלב הזה:
1. תשתיות (תלויות, בסיסי נתונים, שרתים) ישנות. למעשה כל כך ישנות שאין אומץ או יכולת לשדרג אותן.
2. קושי לגייס מתכנתים. בדרך כלל בגלל שפת תכנות ישנה או חדשה מדי.
3. היעדר תשתית בדיקות למוצר וותיק. כל שורת קוד שתוסיף תפגע בפונקציונאליות שמישהו איפשהו צריך.
4. חוסר יכולת לבנות את הפרויקט על מכונת פיתוח רגילה. דרישה להתקנות מיוחדות או תהליכי בניה מיוחדים.
הרבה פעמים פרויקט מגיע לסוף הדרך בגלל אפקט כדור שלג - אנחנו מנסים להתקדם בפיתוח, אבל בעיות תשתית גורמות לנו לעבוד יותר קשה על כל צעד, וההתקדמות האיטית מכריחה אותנו להשקיע יותר זמן בפיצ'רים החדשים במקום לפתור את בעיות התשתית. מתישהו מגיעה הנקודה שלכתוב את הפרויקט מחדש כבר יהיה יותר קל מלהוסיף עוד פיצ'ר. זה סוף הדרך.
1 421
# אופס הכנסתי קונסטריינט
לפני כמה שבועות התחלתי ללמוד גרמלין וגם פרסמתי כאן פוסט עם כמה דוגמאות קוד, אחת מהן היתה:
def createPost(g: GraphTraversalSource, slug: String, title: String, publishedAt: String): Vertex =
g.addV("post")
.property("slug", slug)
.property("title", title)
.property("publishedAt", LocalDateTime.parse(publishedAt, formatter))
.next()
זה נראה תמים - הקוד יוצר צומת, מגדיר שלושה מאפיינים ושומר. ועל הדרך מוסיף מגבלה משמעותית למערכת שלנו.
גרמלין היא שפת שאילתות ואפשר להשתמש בה כדי לתשאל בסיסי נתונים מרוחקים (למשל neptune שרץ בענן של AWS או קוסמוס שרץ באז'ור או ארקייד דיבי שרץ על מכונה שלכם), ובנוסף כדי לגשת לבסיסי נתונים בזיכרון שרצים באותו JVM כמו התוכנית.
בדוגמת הקוד שפרסמתי הגדרתי בסיס נתונים מוטמע שרץ בזיכרון באותו JVM כמו של התוכנית, ולכן אין בעיה לשמור אוביקטים מתוחכמים כמו תאריך באותו בסיס נתונים. ניסיון להעביר את הקוד לנפטון או בסיס נתונים מרוחק אחר ייכשל, כי גרמלין לא עושה סריאליזציה אוטומטית לתאריכים.
הכנסת קונסטריינטים (והסרתם) היא חלק טבעי מלימוד ומפיתוח מערכות בטכנולוגיות שלא עבדנו בהן בעבר. יש לזה כל מיני סיבות, בדוגמה שלי עם גרמלין חשבתי בהתחלה לבנות מערכת עם בסיס נתונים מוטמע ורק אחר כך הבנתי שעדיף לשמור את בסיס הנתונים בענן (מה שהוביל לגילוי כל האילוצים הנסתרים). זו אחת הסיבות שקשה לתת הערכות זמנים בפיתוח, ובמיוחד בפיתוח עם טכנולוגיות חדשות.
באותה נשימה צריך להגיד שהרבה פעמים שימוש ב Best Practices רגילים של פיתוח יכול להגן עלינו מחלק מהסיכונים. במקרה של הסריאליזציה של תאריכים, הקפדה על כתיבת שאילתות רק במקומות ספציפיים בקוד יכולה לעזור. במערכת אידאלית תיקון הקוד כך שאוביקט תאריך-שעה ייכתב בתור long בצירוף אזור זמן אמור להשפיע רק על שתי שורות במערכת, כי כל הקוד שקורא את שדה התאריך עובר דרך אותה שורה.1 421
# קוד מושלם
אם הייתי יודע איך יראו כל הדרישות העתידיות מהמערכת הייתי שמח לכתוב את הקוד המושלם.
בעולם האמיתי אני מעדיף להתמקד בקוד שקל לשנות אותו.
1 421
# יש לי שלושה ימים עד הראיון עבודה בריאקט - מה ללמוד?
כשהשאלה מהכותרת נשאלה ברדיט ידעתי שזה הולך להיות מעניין. אלה הטיפים המרכזיים שמצאתי שם:
1. כולם מתעסקים עם ניהול סטייט - וצריך להגיד, הסיפור של ניהול סטייט מלווה אותנו מאז שריאקט נוצרה ויישאר איתנו כל עוד לא יהיה שינוי ארכיטקטוני מאוד משמעותי בספריה.
2. הרבה אנשים מדברים על ביצועים ועל הוקים כמו useCallback, אבל פחות ממה שחשבתי. כמעט אף אחד לא מתייחס ל Concurrent Mode ול useTransition
3. אקוסיסטם הוזכר בתור טיפ אבל לא נראה שקיבל מספיק דגש. זה הגיוני כי האקוסיסטם של ריאקט עצום, אם במקרה יש לכם ניסיון עם רידאקס ואתם מתראיינים במקום שמשתמש ברידאקס זה אחלה. אבל אם המקום משתמש בזוסטנד אז השיחה תהיה משעממת. אותו דבר עם ספריות לתקשורת ואפילו עם next.js. בסוף כשמראיינים מפתחים למשרות ריאקט הדגש הוא על הליבה של ריאקט, ופחות על המסביב.
4. הרבה אנשים כן דיברו על החשיבות של פיתוח Front End באופן כללי - אם זה טייפסקריפט, היכרות טובה עם JavaScript ויכולות חדשות של השפה, ואפילו CSS ויכולות חדשות שלו.
אבל הכי חשוב לשים לב לתחילת השאלה - "אני מפתח עם שלוש שנות ניסיון בריאקט". זה בסדר גמור לעבוד שלוש שנים עם כלי בלי להבין את כל הניואנסינים שלו ובלי להשתמש בכל היכולות. חשוב וטוב לקחת מדי פעם את הזמן כדי לחזק את הידע. כותב השאלה הקציב לזה שלושה ימים והטריגר היה ראיון עבודה. אנחנו לא צריכים לחכות שלוש שנים, ולא חייבים טריגר חיצוני.
Вже доступно! Дослідження Telegram за 2025 — головні інсайти року 
