Was genau macht Perls "Segen"?

Im Allgemeinen bless Mitarbeiter ein Objekt mit einer Klasse.

package MyClass;
my $object = { };
bless $object, "MyClass";

Wenn du jetzt eine Methode aufzurufen, die auf $object -, Perl-weiß, welches Paket die Suche nach der Methode.

Wenn das zweite argument ausgelassen wird, wie in deinem Beispiel, das aktuelle Paket/die Klasse verwendet wird.

Um der Klarheit Willen, Ihr Beispiel könnte wie folgt geschrieben werden:

sub new { 
  my $class = shift; 
  my $self = { }; 
  bless $self, $class; 
} 

EDIT: Siehe kixx's gut Antwort für ein wenig mehr Details.

InformationsquelleAutor der Antwort Gordon Wilson

Kurze version: es ist die Markierung, die als hash an die aktuelle Paket-namespace (also, dass dieses Paket bietet seiner Klasse Umsetzung).

InformationsquelleAutor der Antwort chaos

Werde ich die Antwort hier, da die, die hier nicht ganz auf für mich.

Perl-bless-Funktion ordnet jeder Verweis auf alle Funktionen in einem Paket.

Warum müssten wir das?

Lassen Sie uns beginnen, indem man ein Beispiel in JavaScript:

(() => {
    'use strict';

    class Animal {
        constructor(args) {
            this.name = args.name;
            this.sound = args.sound;
        }
    }

    /* [WRONG] (global scope corruption)
     * var animal = Animal({
     *     'name': 'Jeff',
     *     'sound': 'bark'
     * }); 
     * console.log(animal.name + ', ' + animal.sound); //seems good
     * console.log(window.name); // my window's name is Jeff?
     */

    //new is important!
    var animal = new Animal(
        'name': 'Jeff',   
        'sound': 'bark'
    );

    console.log(animal.name + ', ' + animal.sound); //still fine.
    console.log(window.name); //undefined
})();

Nun Streifen Weg die Klasse zu konstruieren und zu tun, ohne Sie:

(() => {
    'use strict';

    var Animal = function(args) {
        this.name = args.name;
        this.sound = args.sound;
        return this; //implicit context hashmap
    };

    // the "new" causes the Animal to be unbound from global context, and 
    //rebinds it to an empty hash map before being constructed. The state is
    // now bound to animal, not the global scope.
    var animal = new Animal({
        'name': 'Jeff',
        'sound': 'bark'
    });
    console.log(animal.sound);    
})();

Die Funktion nimmt eine hash-Tabelle der ungeordneten Eigenschaften(da es keinen Sinn macht zu haben, die zum schreiben von Eigenschaften in einer bestimmten Reihenfolge in dynamischen Sprachen in 2016) und gibt einen hash-Tabelle mit diesen Eigenschaften, oder wenn Sie vergessen haben, setzen Sie das Schlüsselwort new, wird es wieder die ganzen globalen Kontext(z.B. Fenster im browser oder global in nodejs).

Perl hat kein "dies" noch "neue", noch "Klasse", aber es kann immer noch eine Funktion, die verhält sich ähnlich. Wir müssen nicht ein Konstruktor noch ein Prototyp, aber wir werden in der Lage sein zu erstellen, neue Tiere und ändern Sie Ihre individuellen Eigenschaften.

# self contained scope 
(sub {
    my $Animal = (sub {
        return {
            'name' => $_[0]{'name'},
            'sound' => $_[0]{'sound'}
        };
    });

    my $animal = $Animal->({
        'name' => 'Jeff',
        'sound' => 'bark'
    });

    print $animal->{sound};
})->();

Nun, wir haben ein problem: Was ist, wenn wir wollen, dass das Tier führen Sie die Töne, indem Sie sich stattdessen von uns drucken, was Ihre Stimme ist. Das heißt, wir wollen eine Funktion performSound, druckt das Tier seinen eigenen sound.

Einen Weg, dies zu tun ist durch den Unterricht jedes einzelne Tier, wie es Klang. Dies bedeutet, dass jede Katze hat Ihre eigene doppelte Funktion zu performSound.

# self contained scope 
(sub {
    my $Animal = (sub {
        $name = $_[0]{'name'};
        $sound = $_[0]{'sound'};

        return {
            'name' => $name,
            'sound' => $sound,
            'performSound' => sub {
                print $sound . "\n";
            }
        };
    });

    my $animal = $Animal->({
        'name' => 'Jeff',
        'sound' => 'bark'
    });

    $animal->{'performSound'}();
})->();

Dies ist schlecht, weil performSound wird so eine völlig neue Funktion-Objekt jedes mal ein Tier aufgebaut ist. 10000 Tiere bedeutet 10000 performSounds. Wir wollen eine einzelne Funktion performSound, dass alle Tiere, sucht Ihren eigenen sound und druckt es.

(() => {
    'use strict';

    /* a function that creates an Animal constructor which can be used to create animals */
    var Animal = (() => {
        /* function is important, as fat arrow does not have "this" and will not be bound to Animal. */
        var InnerAnimal = function(args) {
            this.name = args.name;
            this.sound = args.sound;
        };
        /* defined once and all animals use the same single function call */
        InnerAnimal.prototype.performSound = function() {
            console.log(this.name);
        };

        return InnerAnimal;
    })();

    /* we're gonna create an animal with arguments in different order
       because we want to be edgy. */
    var animal = new Animal({
        'sound': 'bark',
        'name': 'Jeff'
    });
    animal.performSound(); //Jeff
})();

Hier ist, wo die parallelen zu Perl ein bisschen anhält.

JavaScript neue Betreiber ist nicht optional, ohne es, "diese" inside-Objekt-Methoden korrumpiert globalen Gültigkeitsbereich:

(() => {
    //'use strict'; // uncommenting this prevents corruption and raises an error instead.

    var Person = function() {
        this.name = "Sam";
    };
//   var wrong = Person(); // oops! we have overwritten window.name or global.main.
//   console.log(window.name); // my window's name is Sam?
    var correct = new Person; //person's name is actually stored in the person now.

})();

Wollen wir eine-Funktion, die für jedes Tier, das aussieht bis das Tier den eigenen sound statt hardcoding es bei der Konstruktion.

Segen lässt uns ein Paket benutzen, wie der Prototyp der Objekte. Auf diese Weise, das Objekt bewusst ist, das "Paket" - es ist "auf", und wiederum können die Funktionen im Paket "erreicht in" die spezifische Instanzen, die erstellt wurden, aus dem Konstruktor der "Paket-Objekt":

package Animal;
sub new {
    my $packageRef = $_[0];
    my $name = $_[1]->{'name'};
    my $sound = $_[1]->{'sound'};

    my $this = {
        'name' => $name,
        'sound' => $sound
    };   

    bless($this, $packageRef);
    return $this;
}

# all animals use the same performSound to look up their sound.
sub performSound {
    my $this = shift;
    my $sound = $this->{'sound'};
    print $sound . "\n";
}

package main;
my $animal = Animal->new({
    'name' => 'Cat',
    'sound' => 'meow'
});
$animal->performSound();

Zusammenfassung/TL;DR:

Perl hat keine "dieser", "Klasse", noch "neue". Segen eines Objekts zu einem Paket bietet das Objekt eine Referenz auf das Paket, und beim aufrufen von Funktionen in das Paket, Ihre Argumente werden ausgeglichen durch 1 slot, und das erste argument($_[0] oder shift) entspricht javascript ist "das". In der turn, können Sie etwas simulieren, JavaScript, prototype model.

Leider macht es unmöglich(nach meinem Verständnis) um "neue Klassen zur Laufzeit, wie Sie benötigen, jede "Klasse" ein eigenes Paket, in der Erwägung, dass in javascript, müssen Sie nicht die Pakete an alle, die als "neue" Schlüsselwort macht eine anonyme hashmap für Sie zu nutzen, wie ein Paket zur Laufzeit können Sie neue Funktionen hinzufügen und entfernen von Funktionen on the fly.

Dort sind einige Perl-Bibliotheken erstellen Ihre eigene Art und Weise der überbrückung dieser Einschränkung in der Aussagekraft, wie Elche.

Warum die Verwirrung?:

Weil der Pakete. Unsere intuition sagt uns, binden Sie das Objekt an eine hashmap mit seinen " Prototypen. Dies ermöglicht es uns, erstellen Sie "Pakete" zur Laufzeit wie JavaScript können. Perl nicht über eine solche Flexibilität(zumindest nicht eingebaut, Sie haben, Sie zu erfinden oder es aus anderen Modulen), und im Gegenzug die Laufzeit Ausdruckskraft behindert wird. Man nennt es "segnen" ist nicht viel begünstigt weder.

Was wir tun wollen:

Etwas wie dieses, aber verbindlich, um den Prototyp der Karte rekursive und werden implizit an das Vorbild, anstatt Sie explizit zu machen.

Hier ist ein naiver Versuch: das Problem ist, dass "aufrufen" nicht wissen", was es genannt", so kann es genauso gut ein universal-perl-Funktion "objectInvokeMethod(Objekt, Methode)", die prüft, ob das Objekt die Methode, oder dessen Prototyp ist, oder dessen Prototyp hat es, bis es das Ende erreicht, und findet es, oder nicht (prototypische inheritence). Perl hat schöne eval Magie zu tun, aber ich überlasse, die für etwas, was ich versuchen zu tun können, später.

Egal, hier ist die Idee:

(sub {

    my $Animal = (sub {
        my $AnimalPrototype = {
            'performSound' => sub {
                return $_[0]->{'sound'};
            }
        };

        my $call = sub {
            my $this = $_[0];
            my $proc = $_[1];

            if (exists $this->{$proc}) {
                return $this->{$proc}->();
            } else {
                return $this->{prototype}->{$proc}->($this, $proc);
            }
        };

        return sub {
            my $name = $_[0]->{name};
            my $sound = $_[0]->{sound};

            my $this = { 
                'this' => $this,
                'name' => $name,
                'sound' => $sound,
                'prototype' => $AnimalPrototype,
                'call' => $call                
            };
        };
    })->();

    my $animal = $Animal->({
        'name' => 'Jeff',
        'sound'=> 'bark'
    });
    print($animal->{call}($animal, 'performSound'));
})->();

Trotzdem hoffentlich jemand finden diesen Beitrag nützlich.

InformationsquelleAutor der Antwort Dmitry

Zum Beispiel, wenn Sie sicher sein können, dass jeder Fehler Objekt ein gesegnetes hash, Sie können (endlich!) füllen Sie den fehlenden code im Fehler::print_me Methode:

 package Bug;
 sub print_me
 {
     my ($self) = @_;
     print "ID: $self->{id}\n";
     print "$self->{descr}\n";
     print "(Note: problem is fatal)\n" if $self->{type} eq "fatal";
 }

Nun, wenn die print_me-Methode aufgerufen wird, über eine Referenz auf hash, der ist gesegnet, die in der Fehler-Klasse, die $self variable extrahiert die Referenz, die war als erstes argument übergeben und dann die print-Anweisungen Zugriff auf die verschiedenen Einträge der seligen hash.

InformationsquelleAutor der Antwort Bimlesh Sharma