spiffy pm ดาวน์โหลด - spiffy pm ดาวน์โหลดซอร์สโค้ด

spiffy pm

ซอร์สโค้ดอื่น ๆ

1.0.0

ดาวน์โหลด

ชื่อ

Spiffy - Spiffy Perl Interface Framework สำหรับคุณ

เรื่องย่อ

package Keen;
use Spiffy -Base;
field 'mirth';
const mood => ':-)';

sub happy {
    if ($self->mood eq ':-(') {
        $self->mirth(-1);
        print "Cheer up!";
    }
    super;
}

คำอธิบาย

"Spiffy" เป็นกรอบงานและวิธีการสำหรับการเขียนโปรแกรมเชิงวัตถุ (OO) ใน Perl Spiffy ผสมผสานส่วนที่ดีที่สุดของ Exporter.pm, base.pm, mixin.pm และ SUPER.pm ไว้ในชั้นเรียน Magic Foundation เพียงหนึ่งเดียว มันพยายามแก้ไขไข่เหาและหูดทั้งหมดของ Perl OO แบบดั้งเดิมด้วยวิธีมาตรฐานที่สะอาด ตรงไปตรงมา และ (อาจจะเป็นสักวันหนึ่ง)

Spiffy ยืมแนวคิดจากภาษา OO อื่นๆ เช่น Python, Ruby, Java และ Perl 6 นอกจากนี้ยังเพิ่มลูกเล่นบางอย่างในตัวมันเองด้วย

หากคุณดู CPAN มีโมดูลที่เกี่ยวข้องกับ OO มากมาย เมื่อเริ่มต้นโปรเจ็กต์ใหม่ คุณต้องเลือกชุดโมดูลที่เหมาะสมที่สุด จากนั้นคุณจะต้องใช้โมดูลเหล่านั้นในแต่ละชั้นเรียนของคุณ ในทางกลับกัน Spiffy มีทุกสิ่งที่คุณต้องการในโมดูลเดียว และคุณจะต้องใช้มันเพียงครั้งเดียวในชั้นเรียนของคุณเท่านั้น หากคุณทำให้ Spiffy.pm เป็นคลาสพื้นฐานของคลาสที่เบสที่สุดในโปรเจ็กต์ของคุณ Spiffy จะส่งเวทมนตร์ทั้งหมดไปยังคลาสย่อยทั้งหมดของคุณโดยอัตโนมัติ ในที่สุดคุณอาจลืมไปว่าคุณกำลังใช้มันอยู่!

ความแตกต่างที่โดดเด่นที่สุดระหว่าง Spiffy และคลาสพื้นฐานเชิงวัตถุ Perl อื่น ๆ ก็คือมันมีความสามารถในการส่งออกสิ่งต่าง ๆ หากคุณสร้างคลาสย่อยของ Spiffy ทุกสิ่งที่ Spiffy ส่งออกจะถูกส่งออกโดยคลาสย่อยของคุณโดยอัตโนมัติ นอกเหนือจากสิ่งอื่นๆ ที่คุณต้องการส่งออก และถ้ามีคนสร้างคลาสย่อยของคลาสย่อยของคุณ สิ่งเหล่านี้ทั้งหมดจะถูกส่งออกโดยอัตโนมัติ เป็นต้น ให้คิดว่าเป็น "การส่งออกที่สืบทอดมา" และใช้ไวยากรณ์ข้อกำหนดของ Exporter.pm ที่คุ้นเคย

หากต้องการใช้ Spiffy หรือคลาสย่อยใดๆ ของ Spiffy เป็นคลาสพื้นฐานของคลาสของคุณ คุณจะต้องระบุอาร์กิวเมนต์ -base ให้กับคำสั่ง use

use MySpiffyBaseModule -base;

คุณยังสามารถใช้ use base 'MySpiffyBaseModule'; ไวยากรณ์และทุกอย่างจะทำงานเหมือนกันทุกประการ ข้อแม้เดียวคือต้องโหลด Spiffy.pm แล้ว นั่นเป็นเพราะ Spiffy เดินสาย base.pm ใหม่ทันทีเพื่อทำเวทมนตร์ Spiffy ทั้งหมด

Spiffy รองรับมิกซ์อินคล้าย Ruby ที่มีบทบาทคล้าย Perl6 เช่นเดียวกับ base คุณสามารถใช้อย่างใดอย่างหนึ่งต่อไปนี้:

use mixin 'MySpiffyBaseModule';
use MySpiffyBaseModule -mixin;

เวอร์ชันที่สองจะใช้ได้ก็ต่อเมื่อคลาสที่ผสมอยู่นั้นเป็นคลาสย่อยของ Spiffy เวอร์ชันแรกจะใช้ได้ในทุกกรณี ตราบใดที่ Spiffy โหลดไว้แล้ว

หากต้องการจำกัดวิธีการที่ปะปนกัน ให้ใช้บทบาท (คำแนะนำ: ทำงานเหมือนกับรายการผู้ส่งออก):

use MySpiffyBaseModule -mixin => qw(:basics x y !foo);

ใน Perl เชิงวัตถุเกือบทุกรูทีนย่อยเป็นวิธีการ แต่ละวิธีได้รับวัตถุที่ส่งผ่านไปเป็นอาร์กิวเมนต์แรก นั่นหมายความว่าแทบทุกรูทีนย่อยจะเริ่มต้นด้วยบรรทัด:

my $self = shift;

Spiffy มีกลไกตัวกรองที่เรียบง่ายและเป็นทางเลือกเพื่อแทรกบรรทัดนั้นให้กับคุณ ส่งผลให้โค้ดสะอาดขึ้น หากคุณคิดว่าวิธีการโดยเฉลี่ยมีโค้ด 10 บรรทัด นั่นก็เท่ากับ 10% ของโค้ดของคุณ! หากต้องการเปิดตัวเลือกนี้ คุณเพียงใช้ตัวเลือก - Base แทนตัวเลือก -base หรือเพิ่มตัวเลือก -selfless หากการกรองแหล่งที่มาทำให้คุณรู้สึกไม่สบายใจ อย่าใช้คุณสมบัตินี้ โดยส่วนตัวแล้วฉันพบว่ามันน่าติดตามในการเขียนโค้ดที่สะอาดและบำรุงรักษาได้

คุณสมบัติที่มีประโยชน์ของ Spiffy คือส่งออกฟังก์ชันสองรายการ: field และ const ที่สามารถใช้เพื่อประกาศแอตทริบิวต์ของคลาสของคุณ และสร้างวิธีการเข้าถึงสำหรับฟังก์ชันเหล่านั้นโดยอัตโนมัติ ข้อแตกต่างระหว่างทั้งสองฟังก์ชันคือไม่สามารถแก้ไขแอตทริบิวต์ const ได้ ดังนั้นตัวเข้าถึงจึงเร็วกว่ามาก

ด้านหนึ่งที่น่าสนใจของการเขียนโปรแกรม OO คือเมื่อเมธอดเรียกเมธอดเดียวกันจากคลาสพาเรนต์ โดยทั่วไปเรียกว่าการเรียกวิธีการขั้นสูง สิ่งอำนวยความสะดวกของ Perl ในการทำเช่นนี้นั้นน่าเกลียดมาก:

sub cleanup {
    my $self = shift;
    $self->scrub;
    $self->SUPER::cleanup(@_);
}

Spiffy ทำให้เรียกวิธีการขั้นสูงได้ง่ายสุด ๆ คุณเพียงแค่ใช้ฟังก์ชัน super คุณไม่จำเป็นต้องส่งอาร์กิวเมนต์ใดๆ ให้กับมัน เพราะอาร์กิวเมนต์จะส่งต่อให้คุณโดยอัตโนมัติ นี่คือฟังก์ชันเดียวกันกับ Spiffy:

sub cleanup {
    $self->scrub;
    super;
}

Spiffy มีวิธีการพิเศษในการแยกวิเคราะห์อาร์กิวเมนต์ที่เรียกว่า parse_arguments ซึ่งใช้สำหรับแยกวิเคราะห์อาร์กิวเมนต์ของตัวเองด้วย คุณประกาศว่าอาร์กิวเมนต์ใดเป็นบูลีน (ซิงเกิลตัน) และอาร์กิวเมนต์ใดที่จับคู่กัน โดยมีวิธีการพิเศษสองวิธีที่เรียกว่า boolean_arguments และ paired_arguments อาร์กิวเมนต์แยกวิเคราะห์จะดึงบูลีนและคู่ออกมา แล้วส่งคืนเป็นแฮชที่ไม่ระบุชื่อ ตามด้วยรายการอาร์กิวเมนต์ที่ไม่ตรงกัน

ในที่สุด Spiffy ก็สามารถส่งออกฟังก์ชันการดีบักบางอย่าง WWW , XXX , YYY และ ZZZ ได้ แต่ละรายการสร้างการถ่ายโอนข้อมูล YAML ของอาร์กิวเมนต์ของตน WWW เตือนเอาต์พุต XXX ตายพร้อมกับเอาต์พุต YYY พิมพ์เอาต์พุต และ ZZZ สารภาพเอาต์พุต หาก YAML ไม่ตรงกับความต้องการของคุณ คุณสามารถเปลี่ยนดัมพ์ทั้งหมดเป็นรูปแบบ Data::Dumper ได้โดยใช้ตัวเลือก -dumper

นั่นมันสปิฟฟี่!

การส่งออก

Spiffy นำแนวคิดใหม่มาใช้ในภาษา Perl โมดูลที่ทำหน้าที่เป็นทั้งคลาสเชิงวัตถุและส่งออกฟังก์ชันด้วย แต่ต้องใช้แนวคิดของ Exporter.pm ไปอีกขั้นหนึ่ง มันเดินตามเส้นทาง @ISA ทั้งหมดของคลาสและให้เกียรติข้อกำหนดการส่งออกของแต่ละโมดูล เนื่องจาก Spiffy เรียกใช้โมดูลผู้ส่งออกให้ทำเช่นนี้ คุณสามารถใช้คุณลักษณะอินเทอร์เฟซแฟนซีทั้งหมดที่ผู้ส่งออกมี รวมถึงแท็กและการปฏิเสธ

Spiffy พิจารณาข้อโต้แย้งทั้งหมดที่ไม่ได้ขึ้นต้นด้วยขีดกลางเพื่อประกอบเป็นข้อกำหนดการส่งออก

package Vehicle;
use Spiffy -base;
our $SERIAL_NUMBER = 0;
our @EXPORT = qw($SERIAL_NUMBER);
our @EXPORT_BASE = qw(tire horn);

package Bicycle;
use Vehicle -base, '!field';
$self->inflate(tire);

ในกรณีนี้ Bicycle->isa('Vehicle') และทุกสิ่งที่ Vehicle และ Spiffy ส่งออกจะเข้าไปอยู่ใน Bicycle ยกเว้น field

การส่งออกจะมีประโยชน์มากเมื่อคุณได้ออกแบบระบบที่มีคลาสหลายร้อยคลาส และคุณต้องการให้คลาสทั้งหมดมีสิทธิ์เข้าถึงฟังก์ชันหรือค่าคงที่บางอย่าง

or variables. Just export them in your main base class and every subclass

จะได้ฟังก์ชั่นที่ต้องการ

คุณสามารถทำเกือบทุกอย่างที่ผู้ส่งออกทำเพราะ Spiffy มอบหมายงานให้กับผู้ส่งออก (หลังจากเพิ่มเวทย์มนตร์ Spiffy) Spiffy เสนอตัวแปร @EXPORT_BASE ซึ่งเหมือนกับ @EXPORT แต่สำหรับการใช้งานที่ใช้ -base เท่านั้น

มิกซ์อินและบทบาท

หากคุณเขียนโปรแกรม OO ใน Perl มามาก คุณอาจเคยใช้ Multiple Inheritance (MI) และถ้าคุณทำ MI มามาก คุณอาจประสบปัญหาแปลกๆ และปวดหัว บางภาษาเช่น Ruby พยายามแก้ไขปัญหา MI โดยใช้เทคนิคที่เรียกว่ามิกซ์อิน โดยพื้นฐานแล้ว คลาส Ruby ทั้งหมดจะใช้เฉพาะ Single Inheritance (SI) จากนั้นจึง มิกซ์ ฟังก์ชันจากโมดูลอื่นๆ หากจำเป็น

Mixins สามารถมองได้ในระดับที่เรียบง่ายว่าเป็น การนำเข้า วิธีการของคลาสอื่นไปยังคลาสย่อยของคุณ แต่จากมุมมองของการนำไปใช้แล้ว นั่นไม่ใช่วิธีที่ดีที่สุดที่จะทำ Spiffy ทำในสิ่งที่ Ruby ทำ โดยจะสร้างคลาสที่ไม่ระบุชื่อที่ว่างเปล่า นำเข้าทุกอย่างลงในคลาสนั้น จากนั้นเชื่อมโยงคลาสใหม่เข้ากับเส้นทาง SI ISA ของคุณ กล่าวอีกนัยหนึ่ง ถ้าคุณพูดว่า:

package AAA;
use BBB -base;
use CCC -mixin;
use DDD -mixin;

คุณจะจบลงด้วยสายโซ่การสืบทอดเดียวของคลาสเช่นนี้:

AAA << AAA-DDD << AAA-CCC << BBB;

AAA-DDD และ AAA-CCC เป็นชื่อแพ็กเกจจริงของคลาสที่สร้างขึ้น ข้อดีของสไตล์นี้คือการผสมผสานใน CCC จะไม่ปิดบังวิธีการใดๆ ใน AAA และ DDD ก็ไม่ขัดแย้งกับ AAA หรือ CCC เช่นกัน หากคุณผสมวิธีการใน CCC ซึ่งอยู่ใน AAA เช่นกัน คุณยังคงสามารถเข้าถึงได้โดยใช้ super

เมื่อ Spiffy ผสมใน CCC มันจะดึงวิธีการทั้งหมดใน CCC ที่ไม่ได้ขึ้นต้นด้วยขีดล่าง จริงๆแล้วมันไปได้ไกลกว่านั้น หาก CCC เป็นคลาสย่อย มันจะดึงทุกวิธีที่ CCC can ทำได้ผ่านการสืบทอด นี่มันทรงพลังมาก บางทีก็ทรงพลังเกินไป

เพื่อจำกัดสิ่งที่คุณมิกซ์ Spiffy ยืมแนวคิดของบทบาทจาก Perl6 คำว่าบทบาทถูกใช้อย่างหลวมๆ ใน Spiffy เหมือนกับรายการนำเข้าที่โมดูลผู้ส่งออกใช้ และคุณสามารถใช้กลุ่ม (แท็ก) และการปฏิเสธได้ หากองค์ประกอบแรกของรายการของคุณใช้การปฏิเสธ Spiffy จะเริ่มต้นด้วยวิธีการทั้งหมดที่คลาสมิกซ์อินของคุณสามารถทำได้

use EEE -mixin => qw(:tools walk !run !:sharp_tools);

ในตัวอย่างนี้ walk และ run เป็นวิธีการที่ EEE สามารถทำได้ และ tools และ sharp_tools เป็นบทบาทของคลาส EEE คลาส EEE กำหนดบทบาทเหล่านี้อย่างไร มันง่ายมากที่จะกำหนดวิธีการที่เรียกว่า _role_tools และ _role_sharp_tools ซึ่งส่งคืนรายการวิธีการเพิ่มเติม (และอาจเป็นบทบาทอื่นๆ ด้วย!) สิ่งที่ดีในที่นี้คือ เนื่องจากบทบาทเป็นเพียงวิธีการ จึงสามารถสืบทอดได้เช่นกัน เอา Perl6 ไป เลย !

การกรอง

ด้วยการใช้แฟล็ก -Base แทน -base คุณไม่จำเป็นต้องเขียนบรรทัด:

my $self = shift;

คำสั่งนี้จะถูกเพิ่มให้กับทุกรูทีนย่อยในชั้นเรียนของคุณโดยใช้ตัวกรองแหล่งที่มา ความมหัศจรรย์นั้นง่ายและรวดเร็ว ดังนั้นจึงมีโทษด้านประสิทธิภาพเล็กน้อยสำหรับการสร้างโค้ดที่สะอาดซึ่งทัดเทียมกับ Ruby และ Python

package Example;
use Spiffy -Base;

sub crazy {
    $self->nuts;
}
sub wacky { }
sub new() {
    bless [], shift;
}

เหมือนกับ:

package Example;
use Spiffy -base;
use strict;use warnings;
sub crazy {my $self = shift;
    $self->nuts;
}
sub wacky {my $self = shift; }
sub new {
    bless [], shift;
}
;1;

โปรดทราบว่าวงเล็บว่างหลังรูทีนย่อย new ป้องกันไม่ให้มีการเพิ่ม $self โปรดทราบว่ามีการเพิ่มโค้ดพิเศษลงในบรรทัดที่มีอยู่เพื่อให้แน่ใจว่าหมายเลขบรรทัดจะไม่มีการเปลี่ยนแปลง

-Base ยังเปิด pragmas ที่เข้มงวดและคำเตือน และเพิ่ม '1;' ที่น่ารำคาญ เข้ากับโมดูลของคุณ

วิธีการส่วนตัว

ขณะนี้ Spiffy รองรับวิธีการส่วนตัวเมื่อคุณใช้กลไกตัวกรอง '-Base' คุณเพียงแค่ประกาศหมวดย่อยด้วยคีย์เวิร์ด my และเรียกพวกมันด้วย '$' ข้างหน้า แบบนี้:

package Keen;
use SomethingSpiffy -Base;

# normal public method
sub swell {
    $self->$stinky;
}

# private lexical method. uncallable from outside this file.
my sub stinky {
    ...
}

การแก้ไขจุดบกพร่องที่รวดเร็ว

ฟังก์ชัน XXX มีประโยชน์มากสำหรับการแก้ไขข้อบกพร่อง เนื่องจากคุณสามารถแทรกได้เกือบทุกที่ และจะถ่ายโอนข้อมูลของคุณใน YAML ที่สะอาดตา ใช้ข้อความต่อไปนี้:

my @stuff = grep { /keen/ } $self->find($a, $b);

หากคุณมีปัญหากับคำสั่งนี้ คุณสามารถแก้ไขข้อบกพร่องได้ด้วยวิธีใดวิธีหนึ่งต่อไปนี้:

XXX my @stuff = grep { /keen/ } $self->find($a, $b);
my @stuff = XXX grep { /keen/ } $self->find($a, $b);
my @stuff = grep { /keen/ } XXX $self->find($a, $b);
my @stuff = grep { /keen/ } $self->find(XXX $a, $b);

XXX นั้นง่ายต่อการใส่และถอดออก เป็นประเพณีในการทำเครื่องหมายพื้นที่โค้ดที่ไม่แน่นอนด้วย XXX ซึ่งจะทำให้มองเห็นดัมพ์การแก้ไขจุดบกพร่องได้ง่ายหากคุณลืมนำออก

WWW และ YYY ดีเพราะพวกเขาทิ้งอาร์กิวเมนต์แล้วส่งคืนอาร์กิวเมนต์ วิธีนี้ทำให้คุณสามารถแทรกมันลงในหลายๆ ที่และยังคงรันโค้ดได้เหมือนเดิม ใช้ ZZZ เมื่อคุณต้องการตายด้วยทั้งดัมพ์ YAML และการติดตามสแต็กแบบเต็ม

ฟังก์ชันการดีบักจะถูกส่งออกตามค่าเริ่มต้นหากคุณใช้ตัวเลือก -base แต่เฉพาะในกรณีที่คุณเคยใช้ตัวเลือก -XXX มาก่อนเท่านั้น หากต้องการส่งออกทั้ง 4 ฟังก์ชันให้ใช้แท็กส่งออก:

use SomeSpiffyModule ':XXX';

หากต้องการบังคับให้ฟังก์ชันการแก้ไขข้อบกพร่องใช้ Data::Dumper แทน YAML ให้ทำดังนี้

use SomeSpiffyModule -dumper;

ฟังก์ชั่นที่กระฉับกระเฉง

ส่วนนี้จะอธิบายฟังก์ชันที่ Spiffy ส่งออก ฟังก์ชัน field , const , stub และ super จะถูกส่งออกเฉพาะเมื่อคุณใช้ตัวเลือก -base หรือ -Base

สนาม
กำหนดวิธีการเข้าถึงสำหรับสาขาของชั้นเรียนของคุณ:
```
package Example;
use Spiffy -Base;

field 'foo';
field bar => [];

sub lalala {
    $self->foo(42);
    push @{$self->{bar}}, $self->foo;
}
```
พารามิเตอร์แรกที่ส่งไปยัง field คือชื่อของแอตทริบิวต์ที่กำลังกำหนด Accessor สามารถกำหนดค่าเริ่มต้นที่เป็นทางเลือกได้ ค่านี้จะถูกส่งกลับหากไม่มีการตั้งค่าฟิลด์ในออบเจ็กต์
ค่าคงที่
```
const bar => 42;
```
ฟังก์ชัน const คล้ายกับ <field> แต่จะไม่เปลี่ยนรูป นอกจากนี้ยังไม่เก็บข้อมูลไว้ในออบเจ็กต์ คุณอาจต้องการให้ const เป็นค่าเริ่มต้นเสมอ ไม่เช่นนั้นวิธีการที่สร้างขึ้นจะไม่มีประโยชน์เลย
ต้นขั้ว
```
stub 'cigar';
```
ฟังก์ชั่น stub สร้างวิธีการที่จะตายพร้อมกับข้อความที่เหมาะสม แนวคิดก็คือคลาสย่อยต้องใช้เมธอดเหล่านี้เพื่อไม่ให้เมธอด stub ถูกเรียก
สุด ๆ
ถ้าฟังก์ชันนี้ถูกเรียกใช้โดยไม่มีอาร์กิวเมนต์ใดๆ มันจะเรียกใช้เมธอดเดียวกันกับที่มีอยู่ ซึ่งอยู่สูงกว่าในแผนผัง ISA โดยส่งผ่านอาร์กิวเมนต์เดียวกันทั้งหมด หากถูกเรียกพร้อมกับอาร์กิวเมนต์ มันจะใช้อาร์กิวเมนต์เหล่านั้นโดยมี $self นำหน้า กล่าวอีกนัยหนึ่ง มันใช้งานได้อย่างที่คุณคาดหวัง
```
sub foo {
    super;             # Same as $self->SUPER::foo(@_);
    super('hello');    # Same as $self->SUPER::foo('hello');
    $self->bar(42);
}

sub new() {
    my $self = super;
    $self->init;
    return $self;
}
```
super จะไม่ทำอะไรเลยหากไม่มีวิธี super สุดท้าย super จะทำสิ่งที่ถูกต้องในรูทีนย่อย AUTOLOAD

วิธีการ

ส่วนนี้แสดงรายการวิธีการทั้งหมดที่คลาสย่อยของ Spiffy สืบทอดมาโดยอัตโนมัติ

มิกซ์อิน
วิธีการมิกซ์อินคลาสขณะรันไทม์ รับข้อโต้แย้งเดียวกันกับ use mixin ... . ทำให้คลาสเป้าหมายเป็นมิกซ์อินของผู้เรียก
```
$self->mixin('SomeClass');
$object->mixin('SomeOtherClass' => 'some_method');
```
parse_arguments
วิธีนี้จะรับรายการอาร์กิวเมนต์และจัดกลุ่มให้เป็นคู่ อนุญาตให้ใช้อาร์กิวเมนต์บูลีนซึ่งอาจมีค่าหรือไม่มีก็ได้ (ค่าเริ่มต้นคือ 1) วิธีการส่งกลับการอ้างอิงแฮชของคู่ทั้งหมดเป็นคีย์และค่าในแฮช อาร์กิวเมนต์ใดๆ ที่ไม่สามารถจับคู่ได้จะถูกส่งกลับเป็นรายการ นี่คือตัวอย่าง:
```
sub boolean_arguments { qw(-has_spots -is_yummy) }
sub paired_arguments { qw(-name -size) }
my ($pairs, @others) = $self->parse_arguments(
    'red', 'white',
    -name => 'Ingy',
    -has_spots =>
    -size => 'large',
    'black',
    -is_yummy => 0,
);
```
หลังจากการเรียกนี้ $pairs จะมี:
```
{
    -name => 'Ingy',
    -has_spots => 1,
    -size => 'large',
    -is_yummy => 0,
}
```
และ @others จะมี 'red', 'white' และ 'black'
boolean_arguments
ส่งกลับรายการอาร์กิวเมนต์ที่ได้รับการยอมรับว่าเป็นบูลีน แทนที่วิธีนี้เพื่อกำหนดรายการของคุณเอง
paired_arguments
ส่งกลับรายการอาร์กิวเมนต์ที่รับรู้ว่ามีการจับคู่กัน แทนที่วิธีนี้เพื่อกำหนดรายการของคุณเอง

ข้อโต้แย้ง

เมื่อคุณ use โมดูล Spiffy หรือคลาสย่อยของโมดูล คุณสามารถส่งผ่านรายการอาร์กิวเมนต์ได้ อาร์กิวเมนต์เหล่านี้ถูกแยกวิเคราะห์โดยใช้วิธี parse_arguments ที่อธิบายไว้ข้างต้น อาร์กิวเมนต์พิเศษ -base ใช้เพื่อทำให้แพ็คเกจปัจจุบันเป็นคลาสย่อยของโมดูล Spiffy ที่ใช้งานอยู่

พารามิเตอร์ที่ไม่ได้จับคู่จะทำหน้าที่เหมือนรายการนำเข้าปกติ เช่นเดียวกับที่ใช้กับโมดูลผู้ส่งออก

การใช้ SPIFFY กับ BASE.PM

วิธีที่เหมาะสมในการใช้โมดูล Spiffy เป็นคลาสพื้นฐานคือการใช้พารามิเตอร์ -base ในคำสั่ง use สิ่งนี้แตกต่างจากโมดูลทั่วไปที่คุณต้องการ use base

package Something;
use Spiffy::Module -base;
use base 'NonSpiffy::Module';

ตอนนี้การติดตามว่า Spiffy คืออะไรและไม่ใช่อะไรอาจเป็นเรื่องยาก ดังนั้น Spiffy จึงถูกสร้างขึ้นมาเพื่อทำงานกับ base.pm จริงๆ คุณสามารถพูดได้ว่า:

package Something;
use base 'Spiffy::Module';
use base 'NonSpiffy::Module';

use base ยังมีประโยชน์มากเมื่อคลาสของคุณไม่ใช่โมดูลจริง (ไฟล์แยกต่างหาก) แต่เป็นเพียงแพ็คเกจในบางไฟล์ที่โหลดไปแล้ว base จะทำงานไม่ว่าคลาสจะเป็นโมดูลหรือไม่ก็ตาม ในขณะที่ไวยากรณ์ -base ไม่สามารถทำงานได้เช่นนั้น เนื่องจาก use จะพยายามโหลดโมดูลเสมอ

base.pm คำเตือน

เพื่อให้ Spiffy ทำงานกับ base.pm ได้ จึงมีการเล่นกลอุบายสกปรก Spiffy swaps base::import พร้อมเวอร์ชันของตัวเอง หากโมดูลฐานไม่ใช่ Spiffy Spiffy จะเรียก base::import ดั้งเดิม หากโมดูลฐานเป็น Spiffy Spiffy จะดำเนินการในตัวเอง

มีข้อแม้สองประการ

ต้องโหลด Spiffy ก่อน
หากไม่ได้โหลด Spiffy และเรียกใช้ use base บนโมดูล Spiffy Spiffy จะตายพร้อมกับข้อความที่เป็นประโยชน์ที่บอกให้ผู้เขียนอ่านเอกสารนี้ นั่นเป็นเพราะ Spiffy จำเป็นต้องทำการสลับการนำเข้าล่วงหน้า
หากคุณได้รับข้อผิดพลาดนี้ เพียงใส่คำสั่งเช่นนี้ไว้ข้างหน้าในโค้ดของคุณ:
```
use Spiffy ();
```
ไม่มีการผสม
base.pm สามารถรับข้อโต้แย้งได้หลายข้อ และสิ่งนี้ใช้ได้กับ Spiffy ตราบใดที่คลาสพื้นฐานทั้งหมดเป็น Spiffy หรือคลาสทั้งหมดไม่ใช่ Spiffy หากผสมกัน สปิฟฟี่จะตาย ในกรณีนี้เพียงใช้คำสั่ง use base แยกต่างหาก