מאגר הוא מיקום ספציפי בזיכרון הגולמי. הוא משמש כשטח אחסון זמני לעודף נתונים בינאריים שיחידת העיבוד לא יכולה לקבל באותו רגע.
Node.js כולל מחלקה Buffer. הוא יכול להתמודד עם נתונים בינאריים בעת ניהול זרמי TCP (Transfer Control Protocol) ופעולות קריאה-כתיבה במערכת קבצים.
למד כיצד ליצור, לקרוא ולשנות את התוכן של מאגר.
יצירת מאגר
כדי ליצור מאגר ב-Node.js, תשתמש ב- alloc() אוֹ מ() שיטות. ה alloc() השיטה יוצרת מאגר חדש, ומציינת את גודלו במהלך היצירה כפרמטר הראשון והיחיד הנדרש. זה שימושי כאשר אין לך נתונים לאחסון בזמן יצירת המאגר.
ציין את פרמטר גודל המאגר בבתים כאשר אתה יוצר מאגר עם alloc() שיטה. לדוגמה:
const buf = Buffer.alloc(8);
לְנַחֵם.log (buff);
// פלט:
המחלקה Buffer מוסיפה אוטומטית אפסים כערכי מציין מיקום עבור נתונים חדשים כאשר אתה יוצר אותם עם alloc() שיטה.
המחלקה Buffer מבטאת כל ערך 0 כ 00, באמצעות פורמט הקסדצימלי. בדוגמה זו, הוא מכיל בסך הכל שמונה ערכים.
כדי לאתחל את המאגר עם ערכי מציין מיקום שונים, העבר שנייה למלא פָּרָמֶטֶר:
const buff_filled = Buffer.alloc(8, 5);
לְנַחֵם.log (buff_filled);
// פלט:
אובייקט זה מצטט חלק בזיכרון המאחסן 8 בתים של הערך 05. שים לב שלמרות שעברת מספר בתור ה למלא פרמטר, מאגרים מאחסנים נתונים בבינארי בלבד.
לאחר הקצאת זיכרון למאגר, כתוב נתונים על ידי קריאה ל- לִכתוֹב() שיטה:
const buf = Buffer.alloc(8);buf.write("v", "utf-8");
לְנַחֵם.log (buff)
// פלט:
buf.write("וה","utf-8");
לְנַחֵם.log (buff)
// פלט:
ה לִכתוֹב() השיטה משתמשת בקידוד תווים כדי להמיר את הפרמטר הראשון, באמצעות utf-8 ואז כותב את המחרוזת למאגר. הוספת תו שני למחרוזת תמלא את הבית השני.
כדי לחלץ נתונים מסוגי נתונים קיימים כמו מחרוזות או מערכים, השתמש ב- מ() שיטה. שיטה זו יוצרת מאגרים ממחרוזות ומערכים.
לדוגמה:
// מחרוזת
const stringBuf = Buffer.from('חוּט')
לְנַחֵם.log (stringBuf)
// פלט:
// מערך
const arrayBuf = Buffer.from([97, 114, 114, 97, 121], 'hex')
לְנַחֵם.log (arrayBuf);
// פלט:
ה מ() השיטה לוקחת את הקלט כפרמטר הראשון שלה, מחשבת את מספר הבתים שהיא צריכה כדי לקודד את הנתונים, ואז שולחת את התוצאה למאגר. על ידי אספקת פורמט קידוד אחר כפרמטר השני, תוכל לעקוף את קידוד ברירת המחדל (UTF-8).
העברת מספרים ל- מ() השיטה תגרום לשגיאה.
קריאת מאגר
למרות שמאגרים דומים למערכים, הם לא ניתנים לשינוי גודל ויכולים להתמודד איתם נתוני מחשב בינאריים הודות לשיטות מובנות.
מחלקת Buffer מאפשרת לנו לקרוא בתים בודדים של הנתונים שלה באמצעות תחביר הסוגריים המרובעים של JavaScript.
לדוגמה:
const myBuf = Buffer.from('שלי');
לְנַחֵם.עֵץ(MyBuf[1]);
// פלט: 105לְנַחֵם.עֵץ(MyBuf[3]);
// פלט: 101
לְנַחֵם.עֵץ(MyBuf[5]);
// פלט: לא מוגדר
בלוק הקוד שלמעלה משתמש בתחביר הסוגריים המרובעים כדי להשיג את הערכים של הבייטים הראשון והשלישי בייצוג העשרוני שלהם. ניסיון להשיג בייט לא חוקי יגרום ל-an לא מוגדר שְׁגִיאָה.
כדי לגשת לכל הנתונים שלה, מחלקת Buffer מגיעה עם שיטות toJSON() ו toString(), אשר משיגים את התוכן בשני פורמטים שונים.
ה toString() השיטה מוציאה מחרוזת כתוכן המאגר:
const myBuf = Buffer.from('שלי');
לְנַחֵם.עֵץ(myBuf.toString());
// פלט: 'שלי'const numberBuf = Buffer.from([123]);
לְנַחֵם.עֵץ(מספרBuf.toString())
// פלט: '{'
const emptyBuf = Buffer.alloc(5);
לְנַחֵם.עֵץ(ריקBuf.toString());
// פלט: '\\x00\\x00\\x00\\x00\\x00'
הקריאה הראשונה מאתחלת את המאגר עם הערך "שלי", שהקריאה ל-toString משכפלת. הדוגמה השנייה משתמשת במערך אינט אחד לאתחול, שיש לו ייצוג מחרוזת בתור "{" אופי. במקרה האחרון, מאגר עם חמישה ערכי null מחזיר את המחרוזת "\x00\x00\x00\x00\x00”. המיתר \x00 הוא הייצוג ההקסדצימלי של null.
ה toString() השיטה תמיד מוציאה את התוצאה בפורמט מחרוזת, לא משנה באיזה סוג של נתונים אתה מאתחל את המאגר.
ה .toJSON() השיטה מחזירה את הייצוג העשרוני של נתוני המאגר, ללא קשר לנתונים שבהם השתמשת כדי לאתחל את המאגר.
לדוגמה:
const myBuf = Buffer.from('שלי');
לְנַחֵם.עֵץ(myBuf.toJSON());
// פלט: { סוּג: 'בַּלָם', נתונים: [ 77, 105, 110, 101 ] }
לפלט JSON יש א סוּג נכס בשווי של בַּלָם כדי לציין את מקורו. מאפיין הנתונים שלו מאחסן מערך של עשרונים המייצגים את מערך הבתים המקורי.
שינוי מאגר
בדומה לגישה לבייטים בודדים של מאגר, אתה יכול גם לשנות בתים בודדים של תוכן של מאגר באמצעות תחביר בסוגריים מרובעים.
בעת שימוש בתחביר בסוגריים מרובעים כדי לשנות תוכן בודד, ניתן להקצות רק את הייצוג העשרוני של הערך.
לדוגמה:
myBuf[0] = 70
לְנַחֵם.עֵץ(myBuf.toString())
// פלט: 'בסדר'
מכיוון שמאגרים הם נתונים בינאריים, אינך יכול לתת מחרוזת לחלק מסוים ממאגר. אם תנסה להגדיר בתים בודדים למחרוזת, Buffer יתרגם אותו לתו ריק.
לדוגמה:
myBuf[0] = 'F';
לְנַחֵם.עֵץ(myBuf.toString());
// פלט: '\\x00ine'לחלופין, אתה יכול לשנות את כל התוכן של מאגר באמצעות לִכתוֹב() שיטה.
שקול להכניס אינדקס מחוץ לאורכו של המאגר. במקום להחזיר שגיאה, Buffer מתעלם מהאינדקס הלא חוקי ושומר על תוכן המאגר המקורי ללא פגע.
לדוגמה, נסה להגדיר את האלמנט החמישי של myBuf ל ר באמצעות הייצוג העשרוני שלו של 114:
myBuf[4] = 114;
לְנַחֵם.עֵץ(myBuf.toString());
// פלט: 'שלי'
שימו לב שה- toString() השיטה מחזירה את אותו ערך 'שלי'.
מכיוון שאינך יכול לשנות גודל של מאגר, ניסיון לכתוב יותר נתונים ממה שניתן להחזיק יגרום לביטול הנתונים הנוספים. לדוגמה:
const buf1 = Buffer.alloc(5)
buf1.write('מספר');
לְנַחֵם.עֵץ(buf1.toString())
// פלט: 'numbe'
משתמש ב toString() שיטה לאשר את נתוני המאגר, היא חוזרת 'נדהם' ולא 'מספר'. שהוא הטיעון שהוכנס בתוך לִכתוֹב() שיטה.
חוצצים כותבים בצורה סדרתית שמתחילה במדד אפס. ה לִכתוֹב() השיטה מוסיפה באופן סדרתי בתים למאגר, ומחליפה כל נתונים קודמים.
לדוגמה:
const buf2 = Buffer.alloc(6);buf2.write('חבר');
לְנַחֵם.עֵץ(buf2.toString())
// פלט: 'חבר'
buf2.write('היי');
לְנַחֵם.עֵץ(buf2.toString());
// פלט: 'himber'
הקוד שלמעלה יוצר מאגר של שישה בתים ומוסיף את המחרוזת "חבר" אליו באמצעות לִכתוֹב() שיטה.
לאחר מכן הוא מעדכן את המאגר בתוכן חדש שתופס פחות שטח זיכרון מהתוכן הקודם.
זה גורם ליצירת מחרוזת חדשה עם שני הבתים הראשונים שהוחלפו והבתים הנותרים נותרו ללא שינוי.
ממשקי API ומבני נתונים רבים משתמשים במאגרים
עכשיו אתה יודע איך ליצור מאגר, לכתוב לאחד, לקרוא את תוכנו ולשנות אותו בשיטות המתאימות.
ישנן מספר שיטות אחרות הזמינות לעבודה עם מחלקת Node.js Buffer.
אתה צריך להכיר את השיטות האלה ולהבין את Buffers כדי להבין איך מושגים שונים כמו זרמים ומערכות קבצים עובדים.