perlmod - Trực tuyến trên đám mây

CHƯƠNG TRÌNH:

TÊN

perlmod - Mô-đun Perl (gói và bảng ký hiệu)

MÔ TẢ

Is điều này các tài liệu bạn là sau?
Có những tài liệu khác có thể chứa thông tin mà bạn đang tìm kiếm:

Tài liệu này
Các gói, không gian tên và một số thông tin về các lớp của Perl.

perlnewmod
Hướng dẫn tạo mô-đun mới.

perlmodstyle
Các phương pháp hay nhất để tạo một mô-đun mới.

Gói
Perl cung cấp một cơ chế cho các không gian tên thay thế để bảo vệ các gói khỏi bị dẫm lên
biến của nhau. Trên thực tế, thực sự không có cái gọi là biến toàn cục trong
Perl. Câu lệnh gói khai báo đơn vị biên dịch đang ở trong
không gian tên. Phạm vi của khai báo gói là từ chính khai báo đến
phần cuối của khối bao quanh, "eval" hoặc tệp, tùy điều kiện nào đến trước (cùng phạm vi với
các của tôi() và địa phương() toán tử). Số nhận dạng động không đủ điều kiện sẽ nằm trong
không gian tên, ngoại trừ một số định danh nếu không đủ tiêu chuẩn, mặc định là chính
gói thay vì gói hiện tại như mô tả bên dưới. Một câu lệnh gói chỉ ảnh hưởng đến
biến động - bao gồm những biến bạn đã sử dụng địa phương() trên - nhưng không biến từ vựng
được tạo nên bởi của tôi(). Thông thường, nó sẽ là khai báo đầu tiên trong một tệp được bao gồm bởi
toán tử "do", "request" hoặc "use". Bạn có thể chuyển thành một gói trong nhiều hơn một
địa điểm; nó chỉ ảnh hưởng đến bảng ký hiệu nào được trình biên dịch sử dụng cho phần còn lại của
khối đó. Bạn có thể tham khảo các biến và xử lý tệp trong các gói khác bằng cách thêm tiền tố
mã định danh với tên gói và dấu hai chấm: $ Package :: Variable. Nếu gói
tên là null, gói "chính" được giả định. Nghĩa là, $ :: buồm tương đương với
$ main :: buồm.

Dấu phân cách gói cũ là một dấu ngoặc kép, nhưng dấu hai chấm bây giờ được ưu tiên hơn
dấu phân cách, một phần vì nó dễ đọc hơn đối với con người và một phần vì nó nhiều hơn
có thể đọc được emacs macro. Nó cũng làm cho các lập trình viên C ++ cảm thấy như họ biết những gì đang xảy ra
on - trái ngược với việc sử dụng một câu trích dẫn duy nhất làm dấu phân tách, ở đó tạo nên Ada
các lập trình viên cảm thấy như họ biết chuyện gì đang xảy ra. Bởi vì cú pháp cũ là
vẫn được hỗ trợ để tương thích ngược, nếu bạn cố gắng sử dụng một chuỗi như "Đây là
$ owner's house ", bạn sẽ truy cập vào $ owner :: s; tức là biến $ s trong gói
"chủ sở hữu", mà có thể không phải là những gì bạn muốn. Sử dụng dấu ngoặc nhọn để phân biệt, như trong "Đây là
Nhà của $ {owner} ".

Bản thân các gói có thể chứa các dấu phân tách gói, như trong $ OUTER :: INNER :: var. Cái này
Tuy nhiên, không ngụ ý gì về thứ tự tra cứu tên. Không có gói tương đối:
tất cả các ký hiệu đều là cục bộ của gói hiện tại hoặc phải đủ điều kiện từ
tên gói bên ngoài xuống. Ví dụ: không có nơi nào trong gói "OUTER" mà
$ INNER :: var tham chiếu đến $ OUTER :: INNER :: var. "INNER" đề cập đến một toàn cầu hoàn toàn riêng biệt
Gói.

Chỉ những số nhận dạng bắt đầu bằng chữ cái (hoặc dấu gạch dưới) mới được lưu trữ trong biểu tượng của gói
bàn. Tất cả các ký hiệu khác được giữ trong gói "main", bao gồm tất cả các biến dấu câu,
như $ _. Ngoài ra, khi không đủ tiêu chuẩn, các số nhận dạng STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC và SIG buộc phải nằm trong gói "chính", ngay cả khi được sử dụng cho các
mục đích hơn những mục đích tích hợp của chúng. Nếu bạn có một gói có tên "m", "s" hoặc "y", thì
bạn không thể sử dụng biểu mẫu đủ điều kiện của một số nhận dạng vì nó sẽ được diễn giải
dưới dạng đối sánh mẫu, thay thế hoặc chuyển ngữ.

Các biến bắt đầu bằng dấu gạch dưới được sử dụng để buộc vào gói chính, nhưng chúng tôi đã quyết định điều đó
hữu ích hơn cho người viết gói để có thể sử dụng dấu gạch dưới ở đầu để biểu thị
biến riêng và tên phương thức. Tuy nhiên, các biến và hàm được đặt tên với một
"_", chẳng hạn như $ _ và "sub _", vẫn bị buộc vào gói "chính". Xem thêm "Các
Cú pháp của tên biến "trong perlvar.

chuỗi ed "eval" được biên dịch trong gói trong đó eval () đã được biên dịch.
(Tuy nhiên, gán cho $ SIG {}, giả sử rằng trình xử lý tín hiệu được chỉ định nằm trong "main"
Bưu kiện. Đủ điều kiện cho tên bộ xử lý tín hiệu nếu bạn muốn có một bộ xử lý tín hiệu trong
gói.) Ví dụ, hãy kiểm tra perldb.pl trong thư viện Perl. Ban đầu nó chuyển
vào gói "DB" để trình gỡ lỗi không can thiệp vào các biến trong chương trình
bạn đang cố gắng gỡ lỗi. Tuy nhiên, tại các điểm khác nhau, nó tạm thời chuyển trở lại
gói "chính" để đánh giá các biểu thức khác nhau trong ngữ cảnh của gói "chính" (hoặc
bất cứ nơi nào bạn đến). Xem perldebug.

Ký hiệu đặc biệt "__PACKAGE__" chứa gói hiện tại, nhưng không thể (dễ dàng) được sử dụng
để xây dựng tên biến.

Xem perlsub để biết các vấn đề về phạm vi khác liên quan đến của tôi() và địa phương(), và perlref liên quan đến
đóng cửa.

Mã Bàn
Bảng ký hiệu cho một gói sẽ được lưu trữ trong hàm băm của tên đó với hai
thêm dấu hai chấm. Do đó, tên của bảng ký hiệu chính là% main ::, hay viết tắt là% ::.
Tương tự như vậy, bảng ký hiệu cho gói lồng nhau được đề cập trước đó được đặt tên là
%NGOÀI NỘI::.

Giá trị trong mỗi mục nhập của hàm băm là những gì bạn đang đề cập đến khi bạn sử dụng tên *
ký hiệu typeglob.

local * main :: foo = * main :: bar;

Ví dụ, bạn có thể sử dụng điều này để in ra tất cả các biến trong một gói. Chuẩn mực
nhưng cổ xưa bãi rác.pl thư viện và mô-đun CPAN Devel :: Symdump sử dụng điều này.

Kết quả của việc tạo các mục nhập bảng ký hiệu mới trực tiếp hoặc sửa đổi bất kỳ mục nhập nào
không phải là typeglobs chưa được xác định và có thể thay đổi giữa các lần phát hành perl.

Việc gán cho một typeglob thực hiện một phép toán răng cưa, tức là,

* tinh ranh = * richard;

gây ra các biến, chương trình con, định dạng và các xử lý tệp và thư mục có thể truy cập được thông qua
định danh "richard" cũng có thể được truy cập thông qua định danh "tinh ranh". Nếu bạn muốn
chỉ bí danh cho một biến hoặc chương trình con cụ thể, hãy chỉ định một tham chiếu thay thế:

* tinh ranh = \ $ richard;

Điều này làm cho $ richard và $ dick có cùng một biến, nhưng để lại @richard và @dick là
các mảng riêng biệt. Khéo léo hả?

Có một sự khác biệt nhỏ giữa các câu sau:

* foo = * thanh;
* foo = \ $ bar;

"* foo = * bar" làm cho các typeglob tự đồng nghĩa với nhau trong khi "* foo = \ $ bar" làm cho
Các phần SCALAR của hai typeglob khác nhau đề cập đến cùng một giá trị vô hướng. Điều này có nghĩa rằng
mã sau:

$ thanh = 1;
* foo = \ $ bar; # Đặt $ foo làm bí danh cho $ bar

{
local $ bar = 2; # Hạn chế các thay đổi để chặn
in $ foo; # In '1'!
}

Sẽ in '1', vì $ foo giữ một tham chiếu đến nguyên $ thanh. Một trong những
được nhồi đi bởi "local ()" và sẽ được khôi phục khi khối kết thúc. Tại vì
các biến được truy cập thông qua typeglob, bạn có thể sử dụng "* foo = * bar" để tạo bí danh
có thể được bản địa hóa. (Nhưng lưu ý rằng điều này có nghĩa là bạn không thể có @foo riêng biệt và
@bar, v.v.)

Điều làm cho tất cả những điều này trở nên quan trọng là mô-đun Exporter sử dụng bí danh hình cầu làm
cơ chế xuất nhập khẩu. Cho dù bạn có thể bản địa hóa đúng một biến đã được
được xuất từ ​​một mô-đun phụ thuộc vào cách nó được xuất:

@EXPORT = qw ($ FOO); # Dạng thông thường, không thể bản địa hóa
@EXPORT = qw (* FOO); # Có thể được bản địa hóa

Bạn có thể giải quyết trường hợp đầu tiên bằng cách sử dụng tên đủ điều kiện ($ Package :: FOO) trong đó
bạn cần một giá trị cục bộ hoặc ghi đè nó bằng cách nói "* FOO = * Package :: FOO" trong
kịch bản.

Cơ chế "* x = \ $ y" có thể được sử dụng để chuyển và trả về các tham chiếu rẻ vào hoặc từ
các chương trình con nếu bạn không muốn sao chép toàn bộ. Nó chỉ hoạt động khi gán cho
biến động, không phải từ điển.

% some_hash = (); # không thể là của tôi ()
* some_hash = fn (\% another_hash);
fn phụ {
local * hashsym = shift;
# bây giờ sử dụng% hashsym bình thường, và bạn
# sẽ ảnh hưởng đến% another_hash của người gọi
my% nhash = (); # làm những gì bạn muốn
return \% nhash;
}

Đổi lại, tham chiếu sẽ ghi đè lên vùng băm trong bảng ký hiệu được chỉ định bởi
* some_hash typeglob. Đây là một cách hơi phức tạp để chuyển qua các tài liệu tham khảo một cách rẻ tiền
khi bạn không muốn phải nhớ các biến bỏ tham chiếu một cách rõ ràng.

Một cách sử dụng khác của bảng ký hiệu là để tạo các đại lượng vô hướng "không đổi".

* PI = \ 3.14159265358979;

Bây giờ bạn không thể thay đổi $ PI, đó có lẽ là một điều tốt. Điều này không giống nhau
như một chương trình con không đổi, có thể được tối ưu hóa tại thời điểm biên dịch. Một hằng số
chương trình con là một trong những nguyên mẫu để không nhận đối số và trả về một biểu thức hằng.
Xem perlsub để biết chi tiết về những điều này. Pragma "sử dụng hằng số" là một cách viết tắt thuận tiện cho
những cái này.

Bạn có thể nói * foo {PACKAGE} và * foo {NAME} để tìm ra tên gì và đóng gói biểu tượng * foo
mục nhập bảng đến từ. Điều này có thể hữu ích trong một chương trình con được chuyển các typeglob dưới dạng
tranh luận:

sub Identity_typeglob {
$ Gloss = shift của tôi;
print 'Bạn đã cho tôi', * {$ Gloss} {PACKAGE},
'::', * {$ bridge} {NAME}, "\ n";
}
nhận dạng_typeglob * foo;
xác định_typeglob * bar :: baz;

Bản in này

Bạn đã cho tôi chính :: foo
Bạn đã cho tôi thanh :: baz

Ký hiệu * foo {THING} cũng có thể được sử dụng để lấy tham chiếu đến các phần tử riêng lẻ
của * foo. Xem perlref.

Các định nghĩa chương trình con (và các khai báo, cho vấn đề đó) không nhất thiết phải
nằm trong gói có bảng ký hiệu mà chúng chiếm. Bạn có thể xác định một chương trình con
bên ngoài gói của nó bằng cách xác định rõ ràng tên của chương trình con:

gói chính;
sub Some_package :: foo {...} # & foo được định nghĩa trong Some_package

Đây chỉ là cách viết tắt để gán typeglob tại thời điểm biên dịch:

BẮT ĐẦU {* Some_package :: foo = sub {...}}

và không giống như viết:

{
gói Some_package;
foo phụ {...}
}

Trong hai phiên bản đầu tiên, phần thân của chương trình con nằm trong từ vựng trong gói chính,
không trong Some_package. Vì vậy, một cái gì đó như thế này:

gói chính;

$ Some_package :: name = "fred";
$ main :: name = "barney";

sub Some_package :: foo {
print "in", __PACKAGE__, ": \ $ name is '$ name' \ n";
}

Some_package :: foo ();

in:

trong main: $ name là 'barney'

hơn là:

trong Some_package: $ name là 'fred'

Điều này cũng có ý nghĩa đối với việc sử dụng bộ định tính SUPER :: (xem perlobj).

BẮT ĐẦU, ĐƠN VỊ, ĐÁNH DẤU, INIT và END
Năm khối mã được đặt tên đặc biệt được thực thi khi bắt đầu và khi kết thúc quá trình chạy
Chương trình Perl. Đây là các khối "BEGIN", "UNITCHECK", "CHECK", "INIT" và "END".

Các khối mã này có thể được bắt đầu bằng "sub" để tạo ra một chương trình con
(mặc dù đây không được coi là phong cách tốt). Cần lưu ý rằng những mã này chặn
không thực sự tồn tại dưới dạng các chương trình con được đặt tên (bất chấp sự xuất hiện của chúng). Điều mang lại
điều này đi là thực tế mà bạn có thể có chi tiết hơn một trong số các khối mã này trong một chương trình,
và họ sẽ nhận được tất cả các được thực hiện vào thời điểm thích hợp. Vì vậy, bạn không thể thực hiện bất kỳ
các khối mã này theo tên.

Khối mã "BEGIN" được thực thi càng sớm càng tốt, tức là thời điểm nó hoàn toàn
được xác định, ngay cả trước khi phần còn lại của tệp chứa (hoặc chuỗi) được phân tích cú pháp. Bạn có thể có
nhiều khối "BEGIN" trong một tệp (hoặc chuỗi đánh giá); họ sẽ thực hiện theo thứ tự
Định nghĩa. Bởi vì khối mã "BEGIN" thực thi ngay lập tức, nó có thể đưa vào các định nghĩa
trong số các chương trình con và các chương trình tương tự từ các tệp khác kịp thời hiển thị cho phần còn lại của biên dịch
và thời gian chạy. Sau khi "BEGIN" chạy, nó ngay lập tức không được xác định và bất kỳ mã nào mà nó sử dụng đều là
trở lại vùng bộ nhớ của Perl.

Một khối mã "END" được thực thi càng muộn càng tốt, nghĩa là sau khi perl kết thúc
đang chạy chương trình và ngay trước khi trình thông dịch được thoát ra, ngay cả khi nó đang thoát
là kết quả của một die () hàm số. (Nhưng không phải nếu nó biến thành một chương trình khác thông qua
"hành" hoặc bị thổi ra khỏi mặt nước bởi một tín hiệu - bạn phải tự mình bẫy (nếu
bạn có thể).) Bạn có thể có nhiều khối "KẾT THÚC" trong một tệp - chúng sẽ thực thi ngược lại
thứ tự của định nghĩa; nghĩa là: vào cuối cùng, ra trước (LIFO). Các khối "END" không được thực thi
khi bạn chạy perl với công tắc "-c" hoặc nếu quá trình biên dịch không thành công.

Lưu ý rằng các khối mã "END" là không được thực thi ở cuối chuỗi "eval ()": nếu có "KẾT THÚC"
các khối mã được tạo trong một chuỗi "eval ()", chúng sẽ được thực thi giống như bất kỳ
Khối mã "KẾT THÚC" của gói đó theo thứ tự LIFO ngay trước khi trình thông dịch được
đã thoát ra.

Bên trong khối mã "KẾT THÚC", $? chứa giá trị mà chương trình sẽ chuyển đến
"lối ra()". Bạn có thể sửa đổi $? để thay đổi giá trị thoát của chương trình. Cẩn thận với việc thay đổi
$? do tình cờ (ví dụ: do chạy một cái gì đó thông qua "hệ thống").

Bên trong khối "END", giá trị của "$ {^ GLOBAL_PHASE}" sẽ là "END".

Các khối mã "UNITCHECK", "CHECK" và "INIT" hữu ích để bắt kịp quá trình chuyển đổi giữa
giai đoạn biên dịch và giai đoạn thực thi chương trình chính.

Các khối "UNITCHECK" được chạy ngay sau khi đơn vị xác định chúng đã được biên dịch. Các
tệp chương trình chính và mỗi mô-đun mà nó tải là các đơn vị biên dịch, cũng như chuỗi "eval" s,
mã thời gian chạy được biên dịch bằng cách sử dụng cấu trúc "(? {})" trong regex, các lệnh gọi tới "do FILE",
"request FILE" và mã sau khi "-e" chuyển đổi trên dòng lệnh.

Các khối "BEGIN" và "UNITCHECK" không liên quan trực tiếp đến pha của trình thông dịch.
Chúng có thể được tạo và thực thi trong bất kỳ giai đoạn nào.

Các khối mã "KIỂM TRA" được chạy ngay sau ban đầu Giai đoạn biên dịch Perl kết thúc và trước khi
thời gian chạy bắt đầu, theo thứ tự LIFO. Các khối mã "KIỂM TRA" được sử dụng trong bộ trình biên dịch Perl
để lưu trạng thái đã biên dịch của chương trình.

Bên trong khối "CHECK", giá trị của "$ {^ GLOBAL_PHASE}" sẽ là "CHECK".

Các khối "INIT" được chạy ngay trước khi thời gian chạy Perl bắt đầu thực thi, trong "first in, first
ra lệnh "(FIFO).

Bên trong khối "INIT", giá trị của "$ {^ GLOBAL_PHASE}" sẽ là "INIT".

Các khối "CHECK" và "INIT" trong mã được biên dịch bởi "request", string "do" hoặc string "eval"
sẽ không được thực thi nếu chúng xảy ra sau khi kết thúc giai đoạn biên dịch chính; Việc đó có thể
là một vấn đề trong mod_perl và các môi trường liên tục khác sử dụng các chức năng đó để
tải mã trong thời gian chạy.

Khi bạn sử dụng -n và -p chuyển sang Perl, "BEGIN" và "END" hoạt động giống như trong
ôi, như một trường hợp thoái hóa. Cả hai khối "BEGIN" và "CHECK" đều chạy khi bạn sử dụng -c
chuyển sang kiểm tra cú pháp chỉ biên dịch, mặc dù mã chính của bạn thì không.

Sản phẩm bắt đầu kiểm tra chương trình làm cho tất cả rõ ràng, cuối cùng:

#!/ usr / bin / perl

# bắt đầu kiểm tra

print "10. Mã thông thường chạy trong thời gian chạy. \ n";

KẾT THÚC {print "16. Vậy đây là phần cuối của câu chuyện. \ N"}
INIT {print "7. Các khối INIT chạy FIFO ngay trước thời gian chạy. \ N"}
ĐƠN VỊ {
print "4. Và do đó trước bất kỳ khối CHECK nào. \ n"
}
KIỂM TRA {print "6. Đây là dòng thứ sáu. \ N"}

print "Tất nhiên là nó chạy theo thứ tự. \ n";

BEGIN {print "1. Khối BEGIN chạy FIFO trong quá trình biên dịch. \ N"}
KẾT THÚC {print "15. Đọc perlmod cho phần còn lại của câu chuyện. \ N"}
CHECK {print "5. Các khối CHECK chạy LIFO sau tất cả quá trình biên dịch. \ N"}
INIT {print "8. Chạy lại điều này, sử dụng công tắc -c của Perl. \ N"}

print "12. Đây là mã chống xáo trộn. \ n";

END {print "14. Các khối END chạy LIFO tại thời điểm thoát. \ N"}
BEGIN {print "2. Vì vậy, dòng này xuất hiện thứ hai. \ N"}
ĐƠN VỊ {
print "3. Khối UNITCHECK chạy LIFO sau khi mỗi tệp được biên dịch. \ n"
}
INIT {print "9. Bạn sẽ thấy sự khác biệt ngay lập tức. \ N"}

print "13. Nó chỉ _looks_ giống như nó nên khó hiểu. \ n";

__KẾT THÚC__

Perl Các lớp học
Không có cú pháp lớp đặc biệt trong Perl, nhưng một gói có thể hoạt động như một lớp nếu nó cung cấp
các chương trình con để hoạt động như các phương thức. Một gói như vậy cũng có thể dẫn xuất một số phương pháp của nó từ
một lớp (gói) khác bằng cách liệt kê (các) tên gói khác trong mảng @ISA toàn cầu của nó
(phải là một gói toàn cục, không phải từ vựng).

Để biết thêm về điều này, hãy xem perlootut và perlobj.

Perl Modules
Một mô-đun chỉ là một tập hợp các chức năng liên quan trong một tệp thư viện, tức là, một gói Perl với
cùng tên với tệp. Nó được thiết kế đặc biệt để có thể tái sử dụng bởi các mô-đun khác hoặc
các chương trình. Nó có thể làm điều này bằng cách cung cấp một cơ chế để xuất một số ký hiệu của nó thành
bảng ký hiệu của bất kỳ gói nào sử dụng nó, hoặc nó có thể hoạt động như một định nghĩa lớp và
làm cho ngữ nghĩa của nó có sẵn một cách ngầm định thông qua các lời gọi phương thức trên lớp và các đối tượng của nó,
mà không cần xuất bất kỳ thứ gì một cách rõ ràng. Hoặc nó có thể làm một chút cả hai.

Ví dụ: để bắt đầu một mô-đun truyền thống, không phải OO được gọi là Some :: Mô-đun, hãy tạo một tệp
gọi là Some / Module.pm và bắt đầu với mẫu này:

gói Some :: Mô-đun; # giả định Some / Module.pm

Sử dụng nghiêm ngặt;
cảnh báo sử dụng;

BẮT ĐẦU {
yêu cầu Nhà xuất khẩu;

# đặt phiên bản để kiểm tra phiên bản
$ VERSION của chúng tôi = 1.00;

# Kế thừa từ Trình xuất để xuất các hàm và biến
@ISA của chúng tôi = qw (Nhà xuất khẩu);

# Hàm và biến được xuất theo mặc định
@EXPORT của chúng tôi = qw (func1 func2);

# Hàm và biến có thể xuất tùy chọn
@EXPORT_OK = qw của chúng tôi ($ Var1% Hashit func3);
}

# hình cầu gói đã xuất ở đây
$ Var1 của chúng tôi = '';
% Hashit của chúng tôi = ();

# hình cầu gói không được xuất sẽ truy cập vào đây
# (chúng vẫn có thể truy cập được dưới dạng $ Some :: Mô-đun :: thứ)
@more của chúng tôi = ();
$ thứ của chúng tôi = '';

# file-private lexicals ở đây, trước bất kỳ hàm nào sử dụng chúng
của tôi $ priv_var = '';
% secret_hash của tôi = ();

# đây là một hàm tệp riêng tư như một hàm đóng,
# có thể gọi là $ priv_func -> ();
$ priv_func = sub {của tôi
...
};

# thực hiện tất cả các chức năng của bạn, cho dù xuất hay không;
# nhớ đặt một cái gì đó thú vị vào {} sơ khai
sub func1 {...}
sub func2 {...}

# cái này không được xuất nhưng có thể được gọi trực tiếp
# as Some :: Module :: func3 ()
sub func3 {...}

KẾT THÚC {...} # mã dọn dẹp mô-đun tại đây (trình hủy chung)

1; # đừng quên trả về giá trị true từ tệp

Sau đó, tiếp tục khai báo và sử dụng các biến của bạn trong các hàm mà không cần bất kỳ trình độ nào. Nhìn thấy
Trình xuất khẩu và perlmodlib để biết chi tiết về cơ học và các vấn đề về kiểu dáng trong quá trình tạo mô-đun.

Các mô-đun Perl được đưa vào chương trình của bạn bằng cách nói

sử dụng Mô-đun;

or

sử dụng DANH SÁCH Mô-đun;

Điều này chính xác tương đương với

BEGIN {request 'Module.pm'; 'Mô-đun' -> nhập khẩu; }

or

BEGIN {request 'Module.pm'; 'Mô-đun' -> nhập (LIST); }

Như một trường hợp đặc biệt

sử dụng Module ();

chính xác tương đương với

BEGIN {request 'Module.pm'; }

Tất cả các tệp mô-đun Perl đều có phần mở rộng .PM. Toán tử "sử dụng" giả định điều này để bạn
không cần phải đánh vần "Mô-đun.pm"trong dấu ngoặc kép. Điều này cũng giúp phân biệt
mô-đun từ cũ .pl và .ph các tập tin. Tên mô-đun cũng được viết hoa trừ khi chúng
hoạt động như pragmas; pragmas là chỉ thị trình biên dịch có hiệu lực, và đôi khi
được gọi là "mô-đun thực dụng" (hoặc thậm chí "thực dụng" nếu bạn là người theo trường phái cổ điển).

Hai câu:

yêu cầu SomeModule;
yêu cầu "SomeModule.pm";

khác nhau theo hai cách. Trong trường hợp đầu tiên, bất kỳ dấu hai chấm nào trong mô-đun
tên, chẳng hạn như "Some :: Mô-đun", được dịch sang dấu phân tách thư mục trong hệ thống của bạn,
thông thường "/". Trường hợp thứ hai thì không, và sẽ phải được chỉ định theo nghĩa đen. Các
sự khác biệt khác là nhìn thấy manh mối "yêu cầu" đầu tiên trong trình biên dịch sử dụng
ký hiệu đối tượng gián tiếp liên quan đến "SomeModule", như trong "$ ob = purge SomeModule", là
lời gọi phương thức, không phải lời gọi hàm. (Vâng, điều này thực sự có thể tạo ra sự khác biệt.)

Bởi vì câu lệnh "use" ngụ ý một khối "BEGIN", việc nhập ngữ nghĩa xảy ra như
ngay sau khi câu lệnh "use" được biên dịch, trước khi phần còn lại của tệp được biên dịch. Đây là
cách nó có thể hoạt động như một cơ chế pragma và cũng như cách các mô-đun có thể khai báo
các chương trình con sau đó được hiển thị dưới dạng danh sách hoặc toán tử một ngôi đối với phần còn lại của hiện tại
tập tin. Điều này sẽ không hoạt động nếu bạn sử dụng "request" thay vì "use". Với "request", bạn có thể
gặp vấn đề này:

yêu cầu Cwd; # make Cwd :: có thể truy cập
$ đây = Cwd :: getcwd ();

sử dụng Cwd; # nhập tên từ Cwd ::
$ đây = getcwd ();

yêu cầu Cwd; # make Cwd :: có thể truy cập
$ đây = getcwd (); # Giáo sư! không có main :: getcwd ()

Nói chung, "sử dụng Mô-đun ()" được khuyến nghị thay vì "Yêu cầu Mô-đun", vì nó xác định
tính khả dụng của mô-đun tại thời điểm biên dịch, không phải ở giữa quá trình thực thi chương trình của bạn. Một
ngoại lệ sẽ là nếu hai mô-đun từng cố gắng "sử dụng" nhau và mỗi mô-đun cũng được gọi là
chức năng từ mô-đun khác đó. Trong trường hợp đó, bạn có thể dễ dàng sử dụng "request" để thay thế.

Các gói Perl có thể được lồng vào bên trong các tên gói khác, vì vậy chúng ta có thể có các tên gói
chứa "::". Nhưng nếu chúng tôi sử dụng trực tiếp tên gói đó làm tên tệp, nó sẽ tạo ra
cho các tên tệp khó sử dụng hoặc không thể sử dụng trên một số hệ thống. Do đó, nếu tên của mô-đun là,
nói, "Text :: Soundex", thì định nghĩa của nó thực sự được tìm thấy trong tệp thư viện
Text / Soundex.pm.

Các mô-đun Perl luôn có một .PM tệp, nhưng cũng có thể có tệp thực thi được liên kết động
(thường kết thúc bằng .vì thế) hoặc các định nghĩa chương trình con tự động điền (thường kết thúc bằng .al)
liên kết với mô-đun. Nếu vậy, những điều này sẽ hoàn toàn minh bạch đối với người dùng
mô-đun. Đó là trách nhiệm của .PM tệp để tải (hoặc sắp xếp để tự động tải) bất kỳ
chức năng bổ sung. Ví dụ: mặc dù mô-đun POSIX thực hiện cả hai
tải động và tự động tải, người dùng có thể nói chỉ cần "sử dụng POSIX" để nhận tất cả.

Làm qua một vài thao tác đơn giản về mô-đun chủ đề an toàn
Perl hỗ trợ một loại luồng được gọi là luồng thông dịch (ithreads). Những chủ đề này có thể
được sử dụng một cách rõ ràng và ẩn ý.

Ithreads hoạt động bằng cách sao chép cây dữ liệu để không có dữ liệu nào được chia sẻ giữa các
chủ đề. Các luồng này có thể được sử dụng bằng cách sử dụng mô-đun "luồng" hoặc bằng cách cái nĩa() on
win32 (giả mạo cái nĩa() ủng hộ). Khi một luồng được sao chép, tất cả dữ liệu Perl sẽ được sao chép, tuy nhiên
Dữ liệu Perl không thể được sao chép tự động. Perl sau 5.8.0 có hỗ trợ cho "CLONE"
chương trình con đặc biệt. Trong "CLONE", bạn có thể làm bất cứ điều gì bạn cần làm, chẳng hạn như
xử lý sao chép dữ liệu không phải Perl, nếu cần. "CLONE" sẽ được gọi một lần dưới dạng một lớp
phương thức cho mọi gói có nó được định nghĩa (hoặc kế thừa nó). Nó sẽ được gọi trong
ngữ cảnh của luồng mới, vì vậy tất cả các sửa đổi đều được thực hiện trong khu vực mới. Hiện tại CLONE
được gọi mà không có tham số nào khác ngoài tên gói không gọi là, nhưng mã không nên
giả định rằng điều này sẽ không thay đổi, vì có khả năng trong tương lai các thông số bổ sung
sẽ được chuyển vào để cung cấp thêm thông tin về trạng thái nhân bản.

Nếu bạn muốn CLONE tất cả các đối tượng, bạn sẽ cần theo dõi chúng trên mỗi gói. Đây là
được thực hiện đơn giản bằng cách sử dụng hàm băm và Vô hướng :: Util :: làm suy yếu ().

Perl sau 5.8.7 có hỗ trợ chương trình con đặc biệt "CLONE_SKIP". Giống như "CLONE",
"CLONE_SKIP" được gọi một lần trên mỗi gói; tuy nhiên, nó được gọi ngay trước khi bắt đầu nhân bản,
và trong ngữ cảnh của luồng cha. Nếu nó trả về một giá trị true, thì không có đối tượng nào của
lớp đó sẽ được nhân bản; hoặc đúng hơn, chúng sẽ được sao chép dưới dạng các giá trị không có mã, không xác định. Vì
ví dụ: nếu trong cha mẹ có hai tham chiếu đến một hàm băm may mắn duy nhất, thì trong
con thay vào đó sẽ có hai tham chiếu đến một giá trị vô hướng không xác định. Cái này
cung cấp một cơ chế đơn giản để tạo an toàn luồng mô-đun; chỉ cần thêm "phụ CLONE_SKIP {1
} "ở đầu lớp và" DESTROY () "bây giờ sẽ chỉ được gọi một lần cho mỗi đối tượng. Trong số
tất nhiên, nếu chuỗi con cần tận dụng các đối tượng, thì một chuỗi phức tạp hơn
cách tiếp cận là cần thiết.

Giống như "CLONE", "CLONE_SKIP" hiện được gọi mà không có tham số nào khác ngoài tham số
tên gói, mặc dù điều đó có thể thay đổi. Tương tự, để cho phép mở rộng trong tương lai,
giá trị trả về phải là một giá trị 0 hoặc 1.

Sử dụng perlmod trực tuyến bằng các dịch vụ onworks.net