תיחום

our

מצהיר על כינוי בתיחום לקסיקלי למשתנה חבילה.

our אינה יוצרת משתנה חדש. היא מציגה שם בתוך התיחום הלקסיקלי הנוכחי המתייחס למשתנה החבילה בעל אותו שם בחבילה הנוכחית. למשך אותו תיחום, השם הלא־מוסמך חוקי תחת use strict 'vars', וכל קריאה או כתיבה דרכו פוגעות במשתנה החבילה הבסיסי.

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

תקציר

our $x;
our ($a, $b, $c);
our @EXPORT_OK = qw(foo bar);
our $VERSION : shared = '1.00';

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

our מחזירה את רשימת המשתנים שלה, כך שהיא יכולה להופיע בכל מיקום ביטוי שבו my יכולה:

(our $x, our $y) = (1, 2);
our $count = 0;

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

תיחום ומהו הכינוי בפועל

הכינוי חי ב־בלוק הלקסיקלי העוטף, בדיוק כמו my ו־state. הוא מסתיים בסוגר המסולסל הסוגר של אותו בלוק (או בסוף הקובץ עבור הצהרה ברמת על). מחוץ לתיחום, השם הלא־מוסמך אינו חוקי עוד תחת use strict 'vars' - משתנה החבילה עצמו אינו נגוע ועדיין נגיש דרך השם המוסמך במלואו שלו.

package Foo;
use strict;

$Foo::foo = 23;

{
    our $foo;        # alias to $Foo::foo
    print $foo;      # 23
}

print $Foo::foo;     # 23 - the package variable is unaffected
print $foo;          # error: requires explicit package name

מכיוון ש־our היא כינוי למשתנה חבילה, החבילה קבועה בנקודת ההצהרה, לא בנקודת השימוש. החלפת חבילות עם package באמצע התיחום אינה כובלת מחדש את הכינוי:

package Foo;
our $bar;            # declares $Foo::bar for the rest of this scope
$bar = 20;

package Bar;
print $bar;          # 20 - still refers to $Foo::bar

our מול my

our ו־my נראות דומות על הדף ומבולבלות כל הזמן. הן עושות דברים הפוכים.

• my יוצרת משתנה פרטי רענן החי רק בתוך התיחום הלקסיקלי שלו. אין לו שם בטבלת הסמלים של אף חבילה ושום דבר מחוץ לתיחום אינו יכול להגיע אליו.

• our יוצרת כינוי בתיחום לקסיקלי למשתנה חבילה ציבורי. המשתנה חי בטבלת הסמלים; כל קוד אחר שיודע את השם המוסמך במלואו שלו יכול לקרוא או לכתוב אליו.

יש להשתמש ב־my בברירת מחדל. יש לפנות ל־our כאשר רוצים בכוונה מצב גלובלי לחבילה: רשימות יצואן של מודול (our @EXPORT, our @EXPORT_OK), our $VERSION, האש תצורה ברמת החבילה שצפוי שקוד אחר יגע בו, או our @ISA המסורתי לירושה.

package My::Module;

our $VERSION   = '1.23';
our @EXPORT_OK = qw(frobnicate);
our @ISA       = ('Exporter');

כל אחד מהשמות הללו הוא כינוי ל־$My::Module::VERSION, @My::Module::EXPORT_OK, @My::Module::ISA - בדיוק מה ש־Exporter ו־UNIVERSAL::isa מחפשים.

our מול local

local ו־our מופיעות יחד לעיתים קרובות והן משלימות, לא חלופיות.

• our הופכת את משתנה החבילה לנגיש תחת שמו הלא־מוסמך בתוך תיחום לקסיקלי. היא אינה שומרת או משחזרת את הערך.

• local שומרת את הערך הנוכחי של משתנה חבילה ומסדרת ששחזורו יקרה כשהתיחום הדינמי העוטף יסתיים. היא אינה הופכת את השם לחוקי תחת use strict 'vars'.

הזיווג הניבי - שינוי זמני של גלובל חבילה בתוך תת־שגרה - משתמש בשתיהן:

sub with_verbose {
    our $verbose;        # make the unqualified name legal here
    local $verbose = 1;  # save old value, restore on return
    do_work();
}

our מול state

state היא ההצהרה הלקסיקלית האחרת. היא יוצרת משתנה פרטי שערכו נשמר לאורך קריאות לתת־שגרה העוטפת. our אינה חולקת אף אחד מהמנגנונים האלה - המשתנה שלה ציבורי ואין לו סמנטיקה לכל קריאה. יש לבחור state ל־memoization לכל תת־שגרה, our למצב גלובלי לחבילה.

תיחום ההצהרה עצמה

כמו my, state, ו־local, our יכולה להופיע בכל מקום שביטוי יכול (מחוץ לאינטרפולציית מחרוזת). ההצהרה נכנסת לתוקף מיד - אפילו בתוך אותו משפט - כך שהמשתנה מספק את use strict 'vars' מההצהרה והלאה. אך ההצהרה אינה מכסה רטרואקטיבית שימושים קודמים של אותו שם באותו משפט:

package main;
my $x = 2;
foo($x, our $x = $x + 1, $x);   # foo() receives (2, 3, 2)
foo($x, our $z = 5, $z);        # foo() receives (3, 5, 5)

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

ההצהרה גם מאפשרת להתייחס למשתנה החבילה בצד ימין של המאתחל של עצמה, דבר ש־my אינה מאפשרת:

my  $foo = $foo;   # error under strict: undeclared $foo on RHS
our $foo = $foo;   # fine: RHS $foo is the package variable

משתנים מרובים ומציינים

יותר ממשתנה אחד דורש סוגריים:

our ($bar, $baz);

בתוך רשימה בסוגריים, undef הוא מציין מקום חוקי המשליך את הערך המתאים של השמת רשימה:

our ( undef, $min, $hour ) = localtime;

הצהרות חוזרות

הצהרות our מרובות עם אותו שם באותו תיחום לקסיקלי מותרות כאשר הן בחבילות שונות - כל אחת כובלת מחדש את הכינוי למשתנה של חבילתה:

use warnings;

package Foo;
our $bar;            # declares $Foo::bar for the rest of this scope
$bar = 20;

package Bar;
our $bar = 30;       # declares $Bar::bar - aliases the Bar variable
print $bar;          # 30

הצהרת our שנייה לאותו שם באותה חבילה ותיחום היא מיותרת בלבד - היא כובלת מחדש לאותו משתנה. תחת use warnings Perl מדווח עליה כמו שהוא מדווח על my חוזר, אך אין משתנה רענן ושום דבר אינו מוסתר:

use warnings;
package Bar;
our $bar = 30;
our $bar;            # warning, but still the same $Bar::bar
print $bar;          # 30

תכונות ו־TYPE

our מקבלת את תחביר ההצהרה המלא של my:

our $x : shared;
our MyType $obj;
our $VERSION : shared = '1.00';

TYPE כבול כיום ל־pragma של fields. תכונות מעובדות על ידי ה־pragma של attributes (ומאז 5.8.0, על ידי Attribute::Handlers). ראו את ה־pragma של attributes עבור סט התכונות הסטנדרטיות. קוד ברמת משתמש רגילה משתמש לעיתים נדירות באחת מהן.

דוגמאות

פתיחת מודול - השימוש הנפוץ ביותר בהרבה:

package My::Thing;
use strict;
use warnings;

our $VERSION   = '0.01';
our @ISA       = ('Exporter');
our @EXPORT_OK = qw(thingify);

הצהרה והשמה בצעד אחד:

package Cfg;
our $timeout = 30;   # same as $Cfg::timeout = 30

דריסה זמנית של גלובל חבילה בתוך קריאה:

sub quiet_run {
    our $verbose;
    local $verbose = 0;
    run_one_job();
}

כינוי בין־חבילתי - הצהרה ב־Foo, שימוש ב־Bar:

package Foo;
our $shared = 'hello';

package Bar;
# $shared here still refers to $Foo::shared, because the lexical
# alias was introduced while the current package was Foo.
print $shared;       # hello

רשימה בסוגריים עם מציין מקום:

our ( undef, $min, $hour, undef, $mon, $year ) = localtime;

מקרי קצה

• our אינה יוצרת את המשתנה. היא מצהירה על כינוי. משתנה החבילה קיים מהרגע שמשהו משים אליו (או לוקח הפניה אליו); our $x; לבדה אינה מקצה משבצת חדשה בטבלת הסמלים.

• הכינוי לקסיקלי, המשתנה לא. עזיבת תיחום ה־our מסיימת את הכינוי, לא את המשתנה. תיחום אחר בקובץ אחר המצהיר על our $x; באותה חבילה רואה את אותו אחסון.

• פתרון באותו משפט. רק הופעות של השם אחרי הצהרת ה־our במשפט משתמשות בכינוי. הופעות מוקדמות יותר שומרות על הכבילה הקודמת שלהן (ראו דוגמת foo() לעיל).

• חבילה, לא החבילה הנוכחית בשימוש. הכינוי כבול לחבילה התקפה בנקודת ההצהרה. החלפת חבילה מאוחר יותר אינה מכוונת אותו מחדש.

• לא אותו דבר כמו use vars. use vars '$x' הופך את $x לחוקי תחת strict לשאר ה־חבילה, ללא קשר לתיחום. our $x הוא לקסיקלי. עדיף our; use vars הוא ישן.

• לא pragma בתיחום קובץ. our $x; ברמת על בקובץ מכסה עד סוף הקובץ, שהוא תיחום לקסיקלי - אך require של אותו קובץ ממקום אחר אינו מרחיב את הכינוי לתיחום של הקובץ הדורש.

• סמנטיקת תכונה ו־TYPE עדיין מתפתחת. כל דבר מעבר ל־: shared בקוד משתמש הוא נדיר; יש לקרוא את התיעוד של ה־pragmas attributes ו־fields לפני שמסתמכים עליהם.

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

תואם במלואו ל־Perl 5.42 במקור.

ראו גם

• my - מצהיר על משתנה לקסיקלי פרטי; הבחירה בברירת מחדל כשרוצים משתנה חדש

• local - תיחום דינמי לערך זמני של משתנה חבילה; זווג עם our כשצריך גם חוקיות strict וגם שמירה/שחזור

• state - מצהיר על משתנה לקסיקלי פרטי הנשמר לאורך קריאות לתת־שגרה העוטפת

• package - קובע את החבילה הנוכחית, שזה מה ש־our יוצרת כינוי אליו

• use - טוען מודולים בזמן הידור; use strict 'vars' הוא ה־pragma שהופך את our להכרחית מלכתחילה

• undef - מציין מקום חוקי בתוך רשימת our בסוגריים להשליך ערך בהשמה