push#

מצרף ערך אחד או יותר לסוף של מערך.

push מוסיף כל אלמנט של LIST לסוף של ARRAY, לפי הסדר. הוא המקבילה המשלימה של pop בזנב ושל unshift / shift בראש. המערך גדל במקום; לא מוחזר מערך חדש.

תקציר#

push @arr, $val
push @arr, @more
push @arr, list, of, values
push @$aref, $val

מה מקבלים בחזרה#

מספר האלמנטים החדש ב־ARRAY לאחר הצירוף - כלומר scalar @arr כפי שהוא עומד ברגע ש־push חוזר. לא הערכים שנדחפו, לא האורך הישן, לא המערך עצמו.

my @colors = ("red");
my $n = push @colors, "blue", "green";   # $n is 3

שימושי כאשר ה־push ובדיקת האורך העוקבת היו אחרת שתי הוראות:

if (push @queue, $job > $limit) { ... }  # one call, count + test

דוגמאות#

צירוף בסיסי של ערך בודד:

my @animals = ("cat");
push @animals, "mouse";                   # ("cat", "mouse")

צירוף מספר ערכים בקריאה אחת - כל ארגומנט הופך לאלמנט משלו:

my @colors = ("red");
push @colors, "blue", "green";            # ("red", "blue", "green")

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

my @a = (1, 2);
my @b = (3, 4);
push @a, @b;                              # (1, 2, 3, 4)

משמעת תור - push בזנב, shift בראש:

my @queue;
push @queue, $job;                        # enqueue
my $next = shift @queue;                  # dequeue

משמעת מחסנית - push ו־pop באותו קצה:

my @stack;
push @stack, $frame;                      # enter
my $top = pop @stack;                     # leave

Push על מערך המוחזק בהפניה. ההפניה חייבת לעבור dereference עם @{ ... } (או הצורה הקצרה @$ref) לפני ש־push רואה מערך:

my $aref = [1, 2];
push @$aref, 3;                           # $aref now refers to [1, 2, 3]
push @{ $aref }, 4, 5;                    # same, explicit deref

ספירת אלמנטים לאחר צירוף ללא משתנה עזר:

my $size = push @log, $entry;
warn "log is large: $size entries" if $size > 1000;

מקרי קצה#

הפניה למערך זקוקה ל־deref. push $ref, $x היא שגיאת זמן הידור ב־Perl 5.24+. השתמשו ב־push @$ref, $x או push @{ $ref }, $x. תכונה ניסיונית אפשרה ארגומנט ראשון סקלרי ב־5.14–5.22 והוסרה; אל תסתמכו עליה.
ארגומנטי מערך משתטחים אוטומטית. push @a, @b מצרף את האלמנטים של @b בנפרד. כדי לצרף את @b כרשומה מקוננת בודדת אתם זקוקים להפניה למערך: push @a, \@b או push @a, [ @b ].
ארגומנטי האש גם משתטחים. push @a, %h מצרף מפתחות וערכים לסירוגין בסדר איטרציה של ההאש - כמעט אף פעם לא מה שאתם רוצים. השתמשו ב־push @a, \%h כדי לאחסן את ההאש בהפניה במקום.
הקשר רשימה אך החזרה סקלרית. push מתועד כלוקח LIST ולכן מעריך את הארגומנטים שלו בהקשר רשימה, אך הערך ש־push עצמו מפיק הוא תמיד הספירה המתקבלת. בתוך print push @a, @b הספירה היא מה שמודפס, לא המערך.
LIST ריק. push @a; (ללא ארגומנט שני) הוא no-op ומחזיר את ה־scalar @a הנוכחי. חוקי ולפעמים שימושי ל־״תן לי את הספירה בלי לשנות כלום״ - אם כי scalar @a ברור יותר.
מערכים קשורים. push על מערך קשור קורא ל־PUSH על העצם הקשור אם הוא מוגדר; אחרת הוא חוזר לקריאות STORE חוזרות באינדקסים שמקורם ב־FETCHSIZE. ראו perltie.
Autovivification. Push דרך הפניה בעלת ערך undef עושה autovivify למערך אנונימי:
```
my %index;
push @{ $index{$key} }, $value;         # $index{$key} becomes an arrayref
```
לאחר ה־push הראשון, $index{$key} מחזיק הפניה למערך המכילה את $value. זהו הניב הסטנדרטי לבניית האש־של־מערכים באופן הדרגתי.
מערך לקריאה בלבד. Push על מערך לקריאה בלבד או בעל גודל קבוע (לדוגמה אלמנט של @_ הקשור למשתנה של הקורא, או מערך שננעל עם Hash::Util::lock_value) מעלה Modification of a read-only value attempted.

הבדלים מהמקור#

תאימות מלאה עם Perl 5.42 המקורי.

ראו גם#

pop - הסרה והחזרה של האלמנט האחרון; משולב עם push להוות מחסנית
shift - הסרה והחזרה של האלמנט הראשון; משולב עם push להוות תור
unshift - תמונת הראי של push בראש המערך; מחזיר את האורך החדש באותו אופן
splice - הוספה, הסרה או החלפה של כל טווח; push @a, @b שקול ל־splice @a, scalar @a, 0, @b
scalar - אילוץ הקשר סקלר על מערך כשאתם רוצים את הספירה ללא push
@ARGV - המערך הקנוני שעליו רוב התוכניות עושות push או צורכות עם shift