[perl] 펄의“축복”은 정확히 무엇을 하는가?

여기에있는 사람들이 나를 위해 클릭하지 않았기 때문에 여기에 답변을 드리겠습니다.

Perl의 bless 함수는 모든 참조를 패키지 내의 모든 함수와 연관시킵니다.

왜 이것이 필요할까요?

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
})();

이제 클래스 구성을 제거하고 그것없이 할 수 있습니다.

(() => {
    '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);
})();

이 함수는 정렬되지 않은 속성의 해시 테이블을 가져옵니다 (2016 년에 동적 언어로 특정 순서로 속성을 작성 해야하는 것은 의미가 없으므로). 해당 속성이있는 해시 테이블을 반환하거나 새 키워드를 잊어 버린 경우 전체 전역 컨텍스트를 반환합니다 (예 : 브라우저의 창 또는 nodejs의 전역).

Perl에는 “this”나 “new”, “class”가 없지만 여전히 비슷한 기능을 수행 할 수 있습니다. 우리에게는 생성 자나 프로토 타입이 없지만, 원하는대로 새 동물을 만들고 개별 속성을 수정할 수 있습니다.

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

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

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

이제 우리는 문제가 있습니다 : 우리가 동물의 목소리를 인쇄하는 대신 동물이 스스로 소리를 내도록하려면 어떻게해야합니까? 즉, 동물의 소리를 출력하는 performSound 함수가 필요합니다.

이를 수행하는 한 가지 방법은 각 동물에게 소리를내는 방법을 가르치는 것입니다. 즉, 각 Cat에는 소리를 수행하기위한 고유 한 복제 기능이 있습니다.

# 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'}();
})->();

동물을 만들 때마다 performSound가 완전히 새로운 함수 객체로 지정되기 때문에 이것은 나쁩니다. 10000 동물은 10000 PerformSounds를 의미합니다. 우리는 그들 자신의 소리를 찾아서 인쇄하는 모든 동물들이 사용하는 단일 함수 performSound를 원합니다.

(() => {
    '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
})();

여기에 Perl 종류와의 평행이 멈추는 곳이 있습니다.

JavaScript의 새로운 연산자는 선택 사항이 아니며 객체 메소드 내부의 “this”가 전역 범위를 손상시킵니다.

(() => {
    // '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.

})();

우리는 건설 할 때 하드 코딩하지 않고 그 동물의 소리를 찾는 각 동물에 대해 하나의 기능을 원합니다.

축복을 통해 패키지를 객체의 프로토 타입으로 사용할 수 있습니다. 이런 방식으로 객체는 “참조 된” “패키지”를 인식하고 패키지의 함수가 해당 “패키지 객체”의 생성자에서 생성 된 특정 인스턴스에 “도달”할 수 있습니다.

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();

요약 / TL; DR :

Perl에는 “this”, “class”또는 “new”가 없습니다. 패키지에 객체를 축복하면 해당 객체에 패키지에 대한 참조가 제공되고 패키지에서 함수를 호출 할 때 인수가 1 슬롯만큼 오프셋되고 첫 번째 인수 ($ _ [0] 또는 shift)는 다음과 같습니다. 자바 스크립트의 “this”. 결과적으로 JavaScript 프로토 타입 모델을 다소 시뮬레이션 할 수 있습니다.

불행히도 런타임에 “새 클래스”를 만드는 것은 불가능합니다. 각 “클래스”에는 자체 패키지가 있어야하지만 자바 스크립트에서는 패키지가 전혀 필요하지 않습니다. 새로운 함수를 추가하고 즉시 함수를 제거 할 수있는 런타임에 패키지로 사용할 수 있도록 익명의 해시 맵을 구성합니다.

무스 (Mose)와 같은 표현성의 한계를 극복하는 고유 한 방식을 만드는 일부 Perl 라이브러리가 있습니다.

왜 혼란? :

패키지로 인해. 직관은 객체를 프로토 타입이 포함 된 해시 맵에 바인딩하도록 지시합니다. 이를 통해 JavaScript와 같이 런타임에 “패키지”를 만들 수 있습니다. Perl은 그러한 유연성을 갖지 못하고 (적어도 내장되어 있지 않거나, 그것을 개발하거나 다른 모듈에서 가져와야 함) 런타임 표현력이 저해됩니다. 그것을 “축복”이라고 부르는 것도 그다지 호의적이지 않습니다.

우리가하고 싶은 것 :

이와 같은 것이지만 프로토 타입 맵을 재귀 적으로 바인딩하고 명시 적으로 수행하지 않고 암시 적으로 프로토 타입에 바인딩해야합니다.

여기에는 순진한 시도가 있습니다. 문제는 “호출”이 “호출”을 모르기 때문에 객체에 메소드가 있는지 확인하는 범용 perl 함수 “objectInvokeMethod (object, method)”일 수도 있습니다. 또는 프로토 타입이 있거나 끝에 도달하여 찾을 수있을 때까지 (프로토 타입 상속) 프로토 타입이 있습니다. Perl은 훌륭한 평가 마법을 가지고 있지만 나중에 시도해 볼 수있는 것을 남겨 두겠습니다.

어쨌든 여기 아이디어가 있습니다.

(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'));
})->();

어쨌든 누군가이 게시물이 유용하다는 것을 알기를 바랍니다.

답변

perl -MDevel::Peek -wE'
    package Pack  { sub func { return { a=>1 } } };
    package Class { sub new  { return bless { A=>10 } } };
    $vp  = Pack::func(); print Dump $vp;   say"---";
    $obj = Class->new;   print Dump $obj'

SV = 0x12d5540에서 IV (0x12d5530)
  REFCNT = 1
  플래그 = (ROK)
  RV = 0x12a5a68
  SV = 0x12a5a68에서 PVHV (0x12ab980)
    REFCNT = 1
    플래그 = (SHAREKEYS)
    ...
      SV = 0x12a5cf0에서 IV (0x12a5ce0)
      REFCNT = 1
      플래그 = (IOK, pIOK)
      IV = 1
---
SV = 0x12cb8c8에서 IV (0x12cb8b8)
  REFCNT = 1
  플래그 = (PADMY, ROK)
  RV = 0x12c26b0
  SV = 0x12c26b0에서 PVHV (0x12aba00)
    REFCNT = 1
    플래그 = (OBJECT, SHAREKEYS)
    STASH = 0x12d5300 "클래스"
    ...
      SV = 0x12c26c8에서 IV (0x12c26b8)
      REFCNT = 1
      플래그 = (IOK, pIOK)
      IV = 10