Perl/서브루틴 페이지의 소스 보기
마지막으로 [b]
-- Loading page list... --
내용출력
로그인[l]
Diary
[f]
최근변경내역
[r]
페이지목록[i]
횡설수설[2]
게시판[3]
링크
수정할 수 없습니다: Perl/서브루틴 는 읽기 전용 페이지입니다.
[[Perl]]의 subroutine <toc> == # perlsub document 요약 == * Perldoc:perlsub 5.12.1 기준 === # 개요 === 서브루틴 선언하기 {{{#!vim perl sub NAME; # 정의하기 전에 미리 선언하기 ("forward" declaration) sub NAME(PROTO); # 마찬가지인데, 프로토타입 제시 sub NAME : ATTRS; # 속성 제시 sub NAME(PROTO) : ATTRS; # 프로토타입, 속성 제시 sub NAME BLOCK # 선언과 정의를 함께 sub NAME(PROTO) BLOCK # 마찬가지인데, 프로토타입 제시 sub NAME : ATTRS BLOCK # 속성 제시 sub NAME(PROTO) : ATTRS BLOCK # 프로토타입, 속성 제시 }}} 런타임에 익명 서브루틴 정의하기: {{{#!vim perl $subref = sub BLOCK; # $subref = sub (PROTO) BLOCK; # 프로토타입 제시 $subref = sub : ATTRS BLOCK; # 속성 제시 $subref = sub (PROTO) : ATTRS BLOCK; # 프로토타입과 속성 제시 }}} 서브루틴 임포트하기: {{{#!vim perl use MODULE qw(NAME1 NAME2 NAME3); }}} 서브루틴 호출하기: {{{#!vim perl NAME(LIST); # 괄호를 사용하면 앞에 &는 생략 가능 NAME LIST; # 미리 선언되어 있거나 임포트한 경우는 괄호 생략가능 &NAME(LIST); # 프로토타입 무시하기 &NAME; # 현재 @_ 변수를 호출된 서브루틴에서 사용할 수 있게 함 }}} * 인수는 @_ 로 전달됨 === # 설명 === 사용자가 정의하는 서브루틴: * 메인 프로그램 내 아무 곳에나 있을 수 있다 * <code>do</code>, <code>require</code>, <code>use</code> 를 사용하여 다른 파일에서 로드할 수 있다 * <code>eval</code> 또는 익명 서브루틴을 사용하여 실행 시간에 생성할 수 있다 * 서브루틴의 이름 또는 CODE 레퍼런스를 담고 있는 변수를 사용하여 간접적으로 호출할 수도 있다 Perl에서의 함수 호출과 리턴값 모델: * 함수에 넘겨지는 인자는 스칼라들의 리스트 하나로 구성되어 넘겨진다. * 함수가 호출자에게 리턴하는 것도 스칼라들의 리스트 하나이다 * 호출과 리턴 때 배열과 해쉬들은 하나로 합쳐지면서 각각의 속성을 잃게 된다. 참조에 의한 호출을 하여 이 점을 방지할 수 있다. * (함수function 중에 명시적인 return 구문이 없는 것을 서브루틴subroutine이라고 하는 경우도 있는데<footnote(Pascal 등)>, Perl에서는 함수와 서브루틴엔 아무런 차이가 없다) 넘겨진 인자들은 <code>@_</code> 배열을 통해 접근할 수 있다. * 예: 인자가 두 개였다면 각각은 <code>$_[0]</code>, <code>$_[1]</code>에 담긴다 * <code>@_</code> 배열 자체는 지역 변수이지만, 이 배열의 원소들은 실제 스칼라 실인자들의 별칭(alias)으로 되어 있다. <code>$_[0]</code> 원소를 변경하면, 대응되는 실인자도 변경된다 (만일 실인자가 변경 불가능한 것이라면 에러가 난다). * 인자가 배열 또는 해쉬의 원소인데 함수가 호출하는 시점에 존재하지 않는 원소였다면, 함수 내에서 그 원소의 값을 변경하거나 그 원소의 레퍼런스를 취하는 경우에(또한, 그런 경우에만) 생성된다. ** 오래된 Perl 버전의 경우는 무조건 생성된다. * <code>@_</code> 배열 전체에 새로운 값을 할당하면 별칭이 제거되며, 인자들은 변경되지 않는다. <code>return</code> 구문: * 서브루틴을 종료하고 빠져나올 때 사용된다. * 추가로 리턴값을 명시해 줄 수 있다. ** 이 리턴값은 서브루틴을 호출한 문맥(리스트, 스칼라, 보이드)에 따라 적절한 문맥으로 평가된다. * 리턴값을 명시하지 않은 경우 ** 리스트 문맥에서는 빈 리스트 반환 ** 스칼라 문맥에서는 undefined 값 ** 보이드 문맥에서는 아무것도 반환하지 않음 * 하나 이상의 집합적 자료들(배열과 해쉬)을 리턴할 경우, 이 자료들은 하나의 리스트로 평탄화(flatten)되어 반환된다 * <code>return</code> 구문이 없고, 마지막 구문이 표현식인 경우 그 식의 값이 반환된다. ** 마지막 구문이 <code>foreach</code>, <code>while</code> 같은 루프 제어 구조인 경우는 반환값이 명세되어 있지 않다 * 빈 서브루틴은 빈 리스트를 반환한다. Perl에는 이름 있는 형식 인자<footnote(C 등에서 함수 정의할 때 <code>foo(int i, char c)</code>에서 i와 c같은 것들)>를 지원하지 않는다. * 보통은 <code>my()</code> 리스트에 할당해서 사용한다. * private으로 선언되지 않은 변수들은 전역 변수들이다. * private 변수를 만드는 자세한 내용은 아래 섹션들 참조 * 개별적인 패키지 내의 함수들에서 사용되는 protected 환경을 만드는 법은 Perldoc:perlmod 의 Packages 섹션을 참조 예: {{{#!vim perl sub max { my $max = shift(@_); foreach $foo (@_) { $max = $foo if $max < $foo; } return $max; } $bestday = max($mon,$tue,$wed,$thu,$fri); }}} {{{#!vim perl # 공백으로 시작하는 줄은 앞 줄에 이어지는 줄로 취급하여 한 줄을 구성 sub get_line { $thisline = $lookahead; # 전역 변수! LINE: while (defined($lookahead = <STDIN>)) { if ($lookahead =~ /^[ \t]/) { $thisline .= $lookahead; } else { last LINE; } } return $thisline; } $lookahead = <STDIN>; # 첫번째 라인을 읽음 while (defined($line = get_line())) { ... } }}} 인자에 이름을 붙이기 위해서 프라이빗 변수 리스트에 할당: {{{#!vim perl sub maybeset { my($key, $value) = @_; $Foo{$key} = $value unless $Foo{$key}; } }}} 할당은 값을 복사하여 이뤄지기 때문에, 위의 코드는 참조에 의한 호출을 값에 의한 호출로 전환하는 효과도 있다. 이렇게 전환하지 않는 경우 함수는 @_의 값을 그 자리에서 변경함으로써 호출자 쪽의 값을 바꿀 수 있다. {{{#!vim perl upcase_in($v1, $v2); # $v1과 $v2의 값이 바뀐다 sub upcase_in { for (@_) { tr/a-z/A-Z/ } } }}} 당연히 상수나 리터럴은 바꿀 수 없다. 시도할 경우 에러가 난다: {{{#!vim perl upcase_in("frederick"); }}} 인자를 함수 내에서 변경하는 것보다는, 사본을 가지고 작업한 후 리턴하는 형태로 작성하는 게 훨씬 더 안전하다: {{{#!vim perl ($v3, $v4) = upcase($v1, $v2); # 여기서는 $v1과 $v2의 값이 바뀌지 않는다 sub upcase { return unless defined wantarray; # void context, do nothing my @parms = @_; for (@parms) { tr/a-z/A-Z/ } return wantarray ? @parms : $parms[0]; } }}} Perl에서는 모든 인자가 <code>@_</code>에 담긴 하나의 평탄한 파라메터 리스트로 보이기 때문에, upcase()의 정의를 바꿀 필요 없이 다음과 같이 호출할 수도 있다: {{{#!vim perl @newlist = upcase(@list1, @list2); @newlist = upcase( split /:/, $var ); }}} 그러나, '''다음과 같이 하면 안 된다''': {{{#!vim perl (@a, @b) = upcase(@list1, @list2); }}} 리턴되는 리스트도 평탄화되기 때문에, 반환하는 모든 것이 <code>@a</code>에 담기고 <code>@b</code>는 빈 채로 남는다. 이에 대한 대안은 "Pass by Reference"를 참조 서브루틴을 호출할 때 명시적으로 <code>&</code> 접두어를 붙일 수 있다. * 최신 Perl에서는 <code>&</code>는 생략가능하다 * 서브루틴이 미리 선언된 경우는 괄호도 생략가능하다 * <code>&</code>가 필수적인 경우: ** defined()나 undef()의 인자로 넣는 경우처럼, 서브루틴의 이름 자체를 지칭할 경우 ** <code>&$subref()</code> 또는 <code>&{$subref}()</code> 구조를 사용하여 이름이나 레퍼런스를 통한 간접 호출을 하는 경우. 이 것은 <code>$subref->()</code> 표기법을 사용하여 피할 수 있다. * 자세한 것은 Perldoc:perlref 참조 서브루틴이 재귀적으로 호출되는 경우: * <code>&</code>를 붙인 형태로 호출할 경우, 인자 리스트를 생략할 수 있으며, 생략하면 호출하는 시점의 <code>@_</code> 배열이 서브루틴에 보이게 된다. 이것은 효율적이지만<footnote([[주인장]] 생각으로는 아마도 호출되는 서브루틴을 위해서 다시 @_ 변수를 세팅하지 않아도 되기 때문이 아닐까 싶다)> 초심자는 피하고 싶을 수 있다: {{{#!vim perl &foo(1,2,3); # 인자 세 개를 전달 foo(1,2,3); # 위와 동 foo(); # 빈 리스트를 전달 &foo(); # 위와 동 &foo; # foo()는 현재 인자목록을 그대로 취한다, foo(@_)와 동일하다 !! foo; # 서브루틴이 미리 선언된 경우에는(또한 그 경우에만) foo()와 동일하다 # 미리 선언되지 않았다면 bareword "foo"이다. }}} <code>&</code>를 붙인 형태는 인자 리스트를 생략가능하게 만들어주는 것 이외에도, 프로토타입 체크를 하지 않도록 하는 기능도 있다 * 부분적으로는 역사적인 이유로, 부분적으로는 편리하게 꼼수를 쓸 수 있게 하기 위함 * 자세한 건 "Prototypes" 섹션 참조 이름이 대문자로만 구성된 서브루틴 * 관례적(엄격하진 않음)으로, 이벤트 발생시 Perl 런타임 시스템에 의해 간접적으로 호출되는 서브루틴임을 의미한다. * 예: <code>AUTOLOAD</code>, <code>CLONE</code>, <code>DESTROY</code>, Perldoc:perltie Perldoc:PerlIO::via 에 언급되는 함수들. <code>BEGIN</code>, <code>UNITCHECK</code>, <code>CHECK</code>, <code>INIT</code>, <code>END</code> * 서브루틴이라기보다는, 이름이 있는 특수한 코드 블록이라 볼 수 있다. * 한 패키지 안에 이런 블록들을 둘 수 있고, 명시적으로 호출할 수는 '''없다'''. * 자세한 것은 Perldoc:perlmod 의 "BEGIN, UNITCHECK, CHECK, INIT and END" 섹션 참조 ==== # my()를 통한 프라이빗 변수 ( Private Variables via my() ) ==== {{{#!vim perl my $foo; # $foo를 렉시컬 지역 변수로 선언 my (@wid, %get); # 변수들의 리스트를 지역 변수로 선언 my $foo = "flurp"; # $foo를 렉시컬로 선언하고 초기화 my @oof = @bar; # @oof를 렉시컬로 선언하고 초기화 my $x : Foo = $y; # 속성이 명시됨 }}} '''경고''': my 선언에서 속성 리스트를 사용하는 것은 개발 중인 기능이며, 시맨틱이나 인터페이스가 차후에 변경될 수 있다. Perldoc:attributes , Perldoc:Attribute::Handlers 참조. <code>my</code> 연산자 * 나열된 변수들을 다음과 같은 스코프 안에서만 사용가능하게 한정한다: ** 자신을 둘러싼 블록 ** 조건문 (if/unless/elsif/else) ** 루프 (for/foreach/while/untile/continue) ** 서브루틴 ** <code>eval</code> ** do/require/use 의 대상 파일 ** 둘 이상의 변수를 나열할 때는 괄호로 둘러싸야 함 ** 나열된 각 원소는 모두 적법한 lvalue여야 함 ** 문자와 숫자로 조합된 식별자만이 렉시컬 스코프로 지정될 수 있다 *** <code>$/</code> 등과 같은 빌트인 변수들은 <code>local</code> 키워드를 사용하여 지역화되어야 한다. <code>local</code> 연산자를 사용하여 생성된 동적 변수와 달리, <code>my</code>를 사용하여 선언한 렉시컬 변수는 호출된 서브루틴을 비롯한 외부로부터 완전히 감추어진다. * 이것은 설령 서브루틴이 자기 자신을 호출한 경우에도 마찬가지이다 - 각각의 호출은 각각 자신만의 사본을 사용한다. 어떤 지점을 정적으로 둘러싸고 있는 스코프 내에서 선언된 <code>my</code> 변수는 볼 수 있다. 오직 동적 스코프만 차단된다. * 다음 코드에서 <code>bumpx()</code> 함수는 렉시컬 $x 변수에 접근할 수 있다. <code>my</code>와 <code>sub</code> 가 동일한 스코프에 나타나기 때문이다: {{{#!vim perl my $x = 10; sub bumpx { $x++ } }}} 그러나 <code>eval()</code>구문은 이 구문이 평가되는 스코프 내에 있는 렉시컬 변수를, eval() 자신 내부에서 다시 선언하면서 변수의 이름을 감춰버리지 않는 이상은, 접근할 수 있다. Perldoc:perlref 참조. 원한다면 my()의 파라메터 리스트에 값을 할당함으로써 변수를 초기화할 수 있다. * 변수를 선언할 때 초기화 값이 주어지지 않는 경우는 undefined 값을 가지고 생성된다. * 서브루틴의 입력 파라메터에 이름을 부여할 때 사용: {{{#!vim perl $arg = "fred"; # "전역" 변수 $n = cube_root(27); print "$arg thinks the root is $n\n"; sub cube_root { my $arg = shift; # 변수이름은 아무래도 상관없다 $arg **= 1/3; return $arg; } fred thinks the root is 3 }}} <code>my</code>는 단지 변경자일 뿐이라서, my의 인자 리스트에 있는 변수에 값을 할당할 때 변수가 스칼라인지 배열인지 여부에 영향을 주지 않는다 * 아래 두 코드는 둘 다 우변에 리스트 문맥을 전달한다 {{{#!vim perl my ($foo) = <STDIN>; # WRONG? my @FOO = <STDIN>; }}} * 반면 아래 코드는 스칼라 문맥을 전달한다. {{{#!vim perl my $foo = <STDIN>; }}} * 다음 경우는 한 변수만 선언한다 {{{#!vim perl my $foo, $bar = 1; # 잘못 }}} ** 이는 아래 코드와 동일한 효과를 낸다: {{{#!vim perl my $foo; $bar = 1; }}} 선언된 변수는 현재 구문이 끝난 후에야 사용할 수 있다. * 새로운 $x 를 기존의 $x 의 값으로 초기화한다: {{{#!vim perl my $x = $x; }}} * 아래 식은 기존의 $x의 값이 우연히 123일 경우를 제외하고는 거짓이 된다: {{{#!vim perl my $x = 123 and $x == 123 }}} 제어문의 경우는 실행되는 블록 뿐 아니라 조건식이 있는 부분도 같은 스코프의 일부이다. * 다음 반복문에서 $line의 스코프는 선언한 부분부터 <code>continue</code> 절까지 포함한 루프 전체: {{{#!vim perl while (my $line = <>) { $line = lc $line; } continue { print $line; } }}} * 다음 조건문에서 $answer의 스코프는 선언한 부분부터 <code>elsif</code>와 <code>else</code>를 전부 포함한 조건문 전체: {{{#!vim perl if ((my $answer = <STDIN>) =~ /^yes$/i) { user_agrees(); } elsif ($answer =~ /^no$/i) { user_disagrees(); } else { chomp $answer; die "'$answer' is neither 'yes' nor 'no'"; } }}} * 변경자가 붙은 구문 내에서 변수의 스코프에 관한 것은 Perldoc:perlsyn""의 "Simple statements" 섹션 참조 <code>foreach</code> 루프의 경우 * 기본적으로는 인덱스 변수를 <code>local</code>을 사용한 것처럼 스코프를 동적으로 조정한다<footnote(즉 패키지(전역) 변수를 인덱스 변수로 사용하더라도 루프가 끝나면 원래의 값으로 되돌아감)> * 인덱스 변수가 <code>my</code>로 선언되거나, 이미 그 이름의 렉시컬 변수가 존재할 경우는, 새로운 렉시컬 변수를 생성하여 사용한다. * 다음 루프에서, $i의 스코프는 루프가 끝나는 지점까지이며, <code>some_function()</code> 안에서는$i에 접근할 수 없다 {{{#!vim perl for my $i (1, 2, 3) { some_function(); } }}} 렉시컬 변수를 사용하는 걸 장려 * 패키지 변수(언제나 전역인)를 묵시적으로 사용하는 걸 감지하기 위하여 다음과 같이 하면: {{{#!vim perl use strict 'vars'; }}} * 이 지점부터 둘러싼 블록이 끝날 때까지 사용되는 변수들은 렉시컬 변수이거나 <code>our</code> 또는 <code>use vars</code>를 사용하여 미리 선언되었거나, 이름에 패키지 이름까지 포함한 형태로<footnote(<code>$패키지이름::변수이름</code>의 형태, 예: <code>$main::str</code>)> 적어주어야 한다. * 안쪽 블록에서 <code>no strict 'vars'</code>를 하여 이 제한을 다시 없앨 수 있다. <code>my</code>의 컴파일타임과 런타임 효과 * 컴파일 타임 - 컴파일러가 체크함 ** <code>use strict 'vars'</code>를 사용할 때 에러가 나지 않게 함 ** 클로져를 만들 때 필수. Perldoc:perlref 참조. <footnote([[Perl/Closure]]도 참조)> * 런타임 - 실제 초기화는 런타임에 적절한 시기에 이뤄진다 <code>my</code>로 선언한 변수는 어느 패키지에도 속하지 않으므로, "fully qualified name"<footnote(<code>$패키지이름::변수이름</code>의 형태, 예: <code>$main::str</code>)>을 쓸 수 없다. * 패키지 변수를 렉시컬로 선언하는 것도 허용되지 않는다: {{{#!vim perl my $pack::var; # 에러! 허용되지 않는 문법 }}} * 동일한 이름의 렉시컬 변수가 있더라도 동적 변수(패키지 변수 또는 전역 변수라고 알려진)는 <code>::</code>를 사용한 fully qualified 표기법을 써서 접근할 수 있다: {{{#!vim perl package main; local $x = 10; my $x = 20; print "$x and $::x\n"; # "20 and 10" 출력 }}} my 변수를 파일의 가장 바깥쪽 스코프에서 선언하여, 파일 외부의 동일한 식별자를 가진 변수들을 숨길 수 있다. * C에서 파일 레벨에 선언된 static 변수와 유사 * 블록 바깥쪽에서 호출할 수 없는 private 서브루틴을 만들고 싶다면, 익명 서브루틴 레퍼런스를 담는 렉시컬 변수를 선언: ** 이 레퍼런스가 모듈 내 어떤 함수에서 리턴되지 않는 이상은 모듈 외부에서는 이 서브루틴을 볼 수 없다. 이 서브루틴의 이름이 패키지의 심볼 테이블에 들어있지 않기 때문이다. 렉시컬 변수는 <code>$some_pack::secret_version</code>과 같은 식으로 접근할 수 없다는 걸 상기하라. {{{#!vim perl my $secret_version = '1.001-beta'; my $secret_sub = sub { print $secret_version }; &$secret_sub(); }}} * 오브젝트 메쏘드의 경우에는 이런 식으로 할 수 없다. 모든 오브젝트 메쏘드는 어떤 패키지의 심볼 테이블 안에 존재해야 나중에 찾을 수 있기 때문이다. 이 문제를 우회하기 위한 내용은 Perldoc:perlref""의 "Function Templates" 섹션을 참조 ==== # 영구 private 변수 ( Persistent Private Variables ) ==== 영구적으로 값이 보존되는(persistent) 변수를 만드는 데는 * Perl 5.10부터는 <code>state</code> 사용 * 5.10 이전 버전과 호환성을 유지하기 위해서는 closure 이용 ===== # state()를 통한 영구 변수 ( Persistent variables via state() ) ===== <code>my</code>가 들어갈 자리에 대신 <code>state</code> 키워드 사용 * perl 5.9.4 부터 * 먼저 <code>feature</code> 프라그마를 쓰거나, 원-라이너로 실행할 때는 <code>-E</code>를 사용하라<footnote(<code>perl -e "스크립트"</code>의 -e 대신 -E 를 사용하라는 이야기)>. Perldoc:feature 참조. * 다음 코드는 gimme_another()가 호출될 때마다 1씩 증가하는 카운터를 관리한다: {{{#!vim perl use feature 'state'; sub gimme_another { state $x; return ++$x } }}} * <code>$x</code>도 렉시컬 변수이고, 이 서브루틴 밖에서는 접근할 수 없다. * 변수를 선언하면서 동시에 스칼라값을 할당하는 경우(<code>state $x=42</code>와 같이) 이 할당은 처음 한 번만 실행된다. 이후에는 무시된다. 스칼라가 아닌 변수의 경우에 어떻게 동작하는지는 정의되지 않았다.<footnote(Strawberry Perl 5.10 에서는 배열 변수에 state를 선언하니 에러가 났음)> ===== # closure를 통한 영구 변수 ( Persistent variables with closures ) ===== 렉시컬 변수는 C 언어에서 auto 변수와 비슷하나, * 가비지 컬렉션이 적용된다. * Perl의 렉시컬 변수는 스코프를 빠져나갔다고 반드시 회수되는 건 아니다. 더 오래 유지되는 다른 무엇인가가 그 렉시컬 변수의 존재를 인지하고 있는 상태라면, 그 변수도 회수되지 않고 남아 있게 된다. * C 언어에서는 오토 변수의 포인터를 리턴하는 건 심각한 실수인 반면, Perl에서는 렉시컬 변수의 레퍼런스를 되돌려주거나 저장해 둘 수 있다. C에서 함수 내 정적(static) 변수와 같은 효과를 내도록 하는 법 * 렉시컬 스코핑과 정적 라이프타임을 동시에 갖게 됨 * 전체 함수를 외부에서 블록으로 감싸고, 정적 변수로 쓸 변수를 함수보다는 바깥쪽이고 블록보다는 안쪽인 영역에서 선언 {{{#!vim perl { my $secret_val = 0; sub gimme_another { return ++$secret_val; } } # $secret_val은 블록 바깥쪽에서는 접근할 수 없다 # 그러나 gimme_another의 매 호출 사이에도 값이 계속 유지된다 }}} * 이 함수가 <code>require</code>나 <code>use</code>를 통해 불릴 때는 상관이 없는데, 메인 프로그램 내에 있을 경우는 이 함수를 호출하기 전에 <code>my</code> 선언이 먼저 실행되도록 배치해야 한다. 이 블록 전체를 메인 프로그램 앞부분에 두거나, <code>BEGIN</code> 블록을 사용한다, Perldoc:perlmod""의 "BEGIN, UNITCHECK, CHECK, INIT and END" 섹션 참조 {{{#!vim perl BEGIN { my $secret_val = 0; sub gimme_another { return ++$secret_val; } } }}} 가장 바깥쪽 스코프(파일 스코프)에서 선언된 렉시컬 변수는 C 언어에서 파일 스태틱<footnote(static 으로 선언된 전역 변수)>와 유사하게 동작한다. * 그 파일 내의 모든 함수에서 사용 가능 * 파일 외부에서는 접근할 수 없음 * 모듈 내에서 공용으로 사용하는 private 변수를 만들 때 사용 가능 ==== # local()을 통한 임시값 ( Temporary Values via local() ) ==== '''경고''': 일반적으로는 <code>local</code> 대신 <code>my</code>를 사용하라, 그것이 더 빠르고 안전하다. * 불가피한 경우는 전역 특수 변수나 전역 파일핸들, 심볼 테이블을 직접 접근할 때 등이다 * 호출되는 서브루틴 쪽에서도 변수값을 볼 수 있어야 할 때 <code>local</code>이 많이 사용됨 {{{#!vim perl # 값의 지역화 local $foo; # $foo를 동적으로 지역화 local (@wid, %get); # 변수의 리스트를 지역화 local $foo = "flurp"; # $foo를 지역화하고 초기화 local @oof = @bar; # @oof를 지역화하고 초기화 local $hash{key} = "val"; # 특정 해쉬 엔트리에 지역화된 값을 설정 delete local $hash{key}; # 현재 블록에서만 이 엔트리를 삭제 local ($cond ? $v1 : $v2); # 다양한 형태의 L밸류가 지역화를 지원한다 # 심볼의 지역화 local *FH; # $FH, @FH, %FH, &FH ... 를 지역화 local *merlyn = *randal; # 이제 $merlyn 은 실제로는 $randal # @merlyn 은 실제로는 @randal, 등등 local *merlyn = 'randal'; # 위와 동일: 'randal' 은 *randal 로 승격됨 local *merlyn = \$randal; # $merlyn 만 별칭으로 만들고, @merlyn 등 나머지는 아니다 }}} <code>local</code>은 나열된 변수들을 둘러싸고 있는 블록, <code>eval</code>, <code>do 파일</code>에 "지역적"이 되게 하며, 그 블록 내에서 호출하는 다른 서브루틴 내에도 적용되도록 한다. * 전역 변수(즉 패키지 변수)에 일시적인 임시값을 할당 * 지역 변수를 생성하는게 ''아니다'' * 동적 스코핑(dynamic scoping)이라 불림 ** 반면에 렉시컬 스코핑은 <code>my</code>를 사용하여 하며, C의 auto 선언과 유사하게 동작한다. 단순 변수 뿐 아니라 몇 가지 유형의 L밸류들이 지역화될 수 있다: * 해쉬와 배열의 엘리먼트, 슬라이스 * 조건식 (결과가 지역화될 수 있는 형태인 경우) * 심볼릭 레퍼런스 * 이 경우 단순 변수와 마찬가지로, 동적 스코프를 적용받는 새로운 값을 생성한다. 하나 이상의 변수나 식이 <code>local</code>에 주어질 때는 괄호로 둘러쌀 것 * 괄호 안의 인자 리스트에 있는 변수들의 현재 값을 숨겨진 스택에 저장해 두고, 블록이나 서브루틴, eval 등을 빠져나갈 때 그 값을 복원한다. * 스코프 내에서 다른 서브루틴을 호출할 경우 그 서브루틴에서도 지역화된 값을 참조할 수 있게 된다. 반대로 원래의 전역 변수의 값에는 접근할 수 없다 * 인자 리스트에 할당을 함으로써 초기화를 할 수 있다. (초기화하지 않을 경우 undef 값이 들어있는 상태로 생성됨) <code>local</code>은 런타임 연산자이므로, 루프를 돌 때마다 실행된다. 따라서 루프 바깥쪽에서 지역화를 하는 게 더 효율적이다. ===== # local()의 문법에 관하여 ( Grammatical note on local() ) ===== <code>local</code>은 L밸류 표현식에 적용되는 변경자이며, 지역화된 변수에 할당을 할 때 스칼라로 간주될지 리스트로 간주될지에 영향을 주지 않는다. 따라서 * 다음 두 구문은 우변에 리스트 문맥을 적용한다: {{{#!vim perl local($foo) = <STDIN>; local @FOO = <STDIN>; }}} * 다음 구문은 우변에 스칼라 문맥을 적용한다: {{{#!vim perl local $foo = <STDIN>; }}} ===== # 특수 변수들의 지역화 ( Localization of special variables ) ===== 특수 변수를 지역화할 경우, 새로운 값을 부여하지만 그 변수의 특수한 기능은 사라지지 않는다. 즉 그 기능과 관련된 부수작용(side-effects)들은 지역화된 값에 따라서 동작한다. * 이 특성 때문에 다음과 같은 것이 가능하다: {{{#!vim perl # FILE의 전체 내용을 $slurp에 저장 { local $/ = undef; $slurp = <FILE>; } }}} 반면 이 특성 때문에 어떤 값들은 지역화하는 데 제한이 있다. * perl 5.9.0 이후 코드에서는 다음 구문을 실행하면 ''Modification of a read-only value attempted'' 에러를 내며 죽는다. $1 변수는 특수 변수이며 읽기 전용이기 때문이다: {{{#!vim perl local $1 = 2; }}} * 다음 코드도 유사한데 좀 더 원인을 찾기 어렵다: {{{#!vim perl sub f { local $_ = "foo"; print } for ($1) { # 이 지점에서 $_ 는 $1의 별칭이고, $1은 특수 변수이며 읽기전용이다 f(); } }}} * 이 상황의 대안은 다음 섹션 참조 '''경고''': tie된 배열과 해쉬를 지역화하는 건 지금까지 설명한 것처럼 동작하지 않는다. 이런 코드를 사용하는 것을 피할 것. (개별 원소를 지역화하는 것은 괜찮음) 이에 관해서는 Perldoc:perl58delta""의 "Localising Tied Arrays and Hashes Is Broken" 섹션 참조. ===== # glob 지역화 ( Localization of globs ) ===== 다음 구문은 현재 패키지에 <code>name</code> glob을 위한 완전히 새로운 심볼 테이블 엔트리를 생성한다: {{{#!vim perl local *name; }}} * 이 glob 슬롯에 들어있는 모든 변수($name, @name, %name, &name, <code>name</code>파일핸들)가 동적으로 리셋된다 * 이 변수들에 의해 수행되는 모든 특수기능(magic)들이 사라지게된다. ** 예를 들어 <code>local */</code>는 "입력 레코드 구분자"<footnote(input record seperator, <code>$/</code>)>의 내부 값에 영향을 미치지 않는다. * 특히, 디폴트 스칼라 변수인 $_에 완전히 새로운 값을 할당하면서, 위 섹션에서 언급했듯이 $_가 특수한 값을 담고 있는 경우 발생할 수 있는 문제점을 피하려면, <code>local $_</code> 대신에 <code>local */</code>를 사용해야 한다. ** perl 5.9.1 부터는 $_의 렉시컬 형태(<code>my $_</code>로 선언한다)를 써서 이 문제를 완전히 피할 수 있다. ===== # 구조형 변수의 원소 지역화 ( Localization of elements of composite types ) ===== 구조형 변수(배열 또는 해쉬)의 원소를 지역화할 때, * 그 원소의 이름을 가지고 지역화 대상으로 삼는다 ** <code>local()</code>이 적용되는 스코프가 끝났을 때, <code>local()</code>에서 명명했던 이름을 키값으로 하는 해쉬원소의 기존 값이 복원된다. 배열의 경우는 명명됐던 인덱스에 해당하는 원소의 값이 복원된다. * <code>local()</code>이 적용된 상태에서 원소가 제거되었을 경우(해쉬에서 <code>delete()</code>를 쓰거나 배열에<code>shift</code>를 하는 경우처럼), 복원될 때 배열이 확장될 수 있고 이 때 중간에 끼인 원소들은 undef 값을 갖게 된다. ** 다음 코드를 실행하면: {{{#!vim perl %hash = ( 'This' => 'is', 'a' => 'test' ); @ary = ( 0..5 ); { local($ary[5]) = 6; local($hash{'a'}) = 'drill'; while (my $e = pop(@ary)) { print "$e . . .\n"; last unless $e > 3; } if (@ary) { $hash{'only a'} = 'test'; delete $hash{'a'}; } } print join(' ', map { "$_ $hash{$_}" } sort keys %hash),".\n"; print "The array has ",scalar(@ary)," elements: ", join(', ', map { defined $_ ? $_ : 'undef' } @ary),"\n"; }}} ** 다음과 같이 출력된다.<footnote(배열의 경우 3번 인덱스와 4번 인덱스에 해당하는 원소가 블록 내의 pop에 의해 제거되었다가, 5번 인덱스의 원소가 원래의 값으로 복원되면서 중간의 두 원소는 undef 값으로 채워졌다. 해쉬에서는 'a'키에 해당하는 원소가 지역화된 후 delete에 의해 지워졌다가 블록이 끝나면서 복원되었다)> {{{#!vim 6 . . . 4 . . . 3 . . . This is a test only a test. The array has 6 elements: 0, 1, 2, undef, undef, 5 }}} 존재하지 않는 원소에 대해 local()을 사용할 경우 어떻게 동작할 것인지는 향후에 변경될 수 있다. ===== # 구조형 변수의 원소를 지역화 후 삭제 ( Localized deletion of elements of composite types ) ===== <blockquote> 주인장 주: perl 5.12 부터 지원하는 기능으로, 5.10에서는 마지막 예제 코드를 실행하면 설명과 다른 결과가 나옴 </blockquote> <code>delete local $array[$idx]</code> 또는 <code>delete local $hash{$key}</code>를 사용하여 구조형 변수의 원소를 현재 블록에서만 제거하고 블록이 끝난 후 복원할 수 있다. * 이 구문들은 지역화하기 전에 담겨 있던 값을 반환한다. * 다음 코드와 동등하다. 단 다음 코드들에서 <code>local</code>의 스코프가 <code>do</code> 블록으로 한정된다는 것이 다르다<footnote(delete local *** 형태로 쓸 경우는 local의 스코프가 이 구문이 있는 블록이니까, do {} 블록보다 하나 바깥쪽 블록에 해당된다)>: {{{#!vim perl # 배열의 경우 do { my $val = $array[$idx]; local $array[$idx]; delete $array[$idx]; $val } # 해쉬의 경우 do { my $val = $hash{key}; local $hash{key}; delete $hash{key}; $val } }}} * 슬라이스에도 사용할 수 있다: {{{#!vim perl my %hash = ( a => [ 7, 8, 9 ], b => 1, ); { my $a = delete local $hash{a}; # $a 는 [ 7, 8, 9 ] # %hash 는 (b => 1) { my @nums = delete local @$a[0, 2]; # @nums 은 (7, 9) # $a 는 [ undef, 8 ] ($a[2]는 완전히 사라졌고 $a[0]은 undef으로 채워졌다) $a[0] = 999; # 이 값은 스코프가 끝나면서 제거될 것이다 } # $a 는 [ 7, 8, 9 ] } # %hash is back to its original state }}} ==== # L밸류 서브루틴 ( Lvalue subroutines ) ==== '''경고''': L밸류 서브루틴은 실험적인 기능이고, Perl 버전이 변경되면서 구현이 바뀔 수 있음 서브루틴이 수정가능한 값을 반환하게 하는 게 가능하다 * 서브루틴을 선언할 때 L밸류를 반환한다고 선언: {{{#!vim perl my $val; sub canmod : lvalue { # return $val; 이건 동작하지 않는다. "return"을 쓰지 말 것 $val; } sub nomod { $val; } canmod() = 5; # $val에 할당된다 nomod() = 5; # 에러 }}} 좌변의 서브루틴과 우변의 문맥은, 좌변의 서브루틴을 호출하는 자리를 스칼라로 바꿨을 때 적용되는 것과 같이 적용된다: * 다음의 좌우 두 서브루틴은 스칼라 문맥에서 호출된다: {{{#!vim perl data(2,3) = get_data(3,4); }}} * 다음 경우는 모든 서브루틴이 리스트 문맥에서 호출된다: {{{#!vim perl (data(2,3)) = get_data(3,4); (data(2),data(3)) = get_data(3,4); }}} L밸류 서브루틴은 '''실험적인''' 기능이다 * 편해보이지만, 여러 가지 이유로 인해 사용에 주의를 기울여야 한다 * return 키워드를 사용할 수 없고, 서브루틴 스코프의 밖으로 나가기 전에 값을 전달해야 한다. 이것 자체가 문제는 아닌데, 다중으로 중첩된 루프 내에서 명시적으로 리턴하는 것이 불가능해진다. * 캡슐화를 어기게 된다. 보통 뮤테이터<footnote(setter 메쏘드)>는 자신이 보호하는 속성값을 설정하기 전에 이 값이 올바른지 체크를 하는데, L밸류 서브루틴은 그럴 수 없다: {{{#!vim perl my $some_array_ref = []; # 뮤테이터가 보호해 줄까?? sub set_arr { # 보통의 뮤테이터 my $val = shift; die("expected array, you supplied ", ref $val) unless ref $val eq 'ARRAY'; $some_array_ref = $val; } sub set_arr_lv : lvalue { # L밸류 뮤테이터 $some_array_ref; } # set_arr_lv는 다음과 같은 코드를 방지할 수 없다! set_arr_lv() = { a => 1 }; }}} ==== # 심볼테이블 엔트리 넘겨주기 (typeglobs) ( Passing Symbol Table Entries (typeglobs) ) ==== '''경고''': 이 섹션에 나오는 방법은 오래된 버전의 Perl에서는 참조에 의한 호출을 흉내낼 수 있는 유일한 방법이었다. 최신 버전의 Perl에서도 여전히 동작하긴 하지만, 레퍼런스를 사용하는 새로운 방법이 일반적으로 더 쉽다. 배열 같은 변수의 값이 아니라 이름을 서브루틴에 넘겨주어서, 서브루틴에서 그 변수의 지역화된 복사본이 아니라 원본 자체를<footnote(원문에는 global copy of it 이라고 나오는데 전역화된 복사본이라는 표현도 이상해서...)> 수정할 수 있도록 하고 싶은 경우 * <code>*foo</code>처럼, 이름 앞에 별표를 붙여서 그 이름에 해당되는 모든 오브젝트를 참조할 수 있다. * 이것을 "typeglob"라고 부른다 타입글로브를 평가하면, 파일핸들, 포맷, 서브루틴을 포함하여 그 이름을 가진 모든 오브젝트를 나타내는 스칼라값을 생산한다. 타입글로브에 뭔가를 할당하면, 할당된 것을 타입글로브에 언급된 이름이 참조하게 된다. {{{#!vim perl sub doubleary { local(*someary) = @_; foreach $elem (@someary) { $elem *= 2; } } doubleary(*foo); doubleary(*bar); }}} 스칼라는 원래부터 참조에 의해 전달되므로, 이런 방법을 사용하지 않고 명시적으로 <code>$_[0]</code>등을 참조함으로써 스칼라 인자의 값을 수정할 수 있다. 배열도 배열의 모든 원소를 스칼라로 전달함으로써 그 원소들을 수정할 수 있다. 그러나 배열에 <code>push</code>, <code>pop</code> 등을 수행하거나 배열의 크기를 바꾸기 위해서는 타입글로브 또는 레퍼런스를 사용하여야 한다. 이 방법은 하나의 리스트에 다수의 배열을 담아 전달할 때도 유용하다. 일반적으로는 다수의 배열을 인자로 넘길 경우는 모든 배열의 값들이 하나의 리스트로 합쳐져서 각각의 배열을 분리할 수 없기 때문이다. 타입글로브에 대한 더 자세한 것은 Perldoc:perldata""의 "Typeglobs and Filehandles" 섹션 참조 ==== # 여전히 local()을 사용해야 하는 경우들 ( When to Still Use local() ) ==== <code>my</code>가 있지만 여전히 <code>local</code> 연산자가 빛을 발하는 세 가지 경우가 있으며, 이 때는 my 대신에 local을 '''사용해야만 한다''' 1. 전역 변수, 특히 $_에 임시값을 줄 때 * <code>@ARGV</code>나 특수문자변수들은 <code>local()</code>을 사용하여 지역화하여야 한다. * 아래 코드는 /etc/motd 파일을 읽고, 등호로 이루어진 라인들을 구분자로 삼아서 여러 덩어리로 분리한 후 @Fields 배열에 담는다: {{{#!vim perl { local @ARGV = ("/etc/motd"); local $/ = undef; local $_ = <>; @Fields = split /^\s*=+\s*$/; } }}} * 특히, $_에 값을 할당하는 루틴 안에서는 $_를 지역화하는 것이 중요하다. <code>while</code> 조건문 안에서는 묵시적으로 할당하는 곳을 살펴보라<footnote(마지막 문장은 "Look out for implicit assignments in while conditionals."인데 뜻이 애매하다. <code>while (<STDIN>) { }</code> 형태의 경우 일단 $_가 자동으로 로컬라이즈되지 않는다. 따라서 그런 곳에서 명시적으로 <code>while (local $_ = <STDIN>)</code>처럼 로컬라이즈를 해주는 것이 좋다는 뜻인 것 같기도 한데, 그럴 거면 차라리 <code>my $_ = ...</code>처럼 my를 쓰는 게 나을 것이다. 아니면 이런 루프 안에서 다시 $_를 변경하는 구문을 넣을 경우 local을 써 주는 게 필수적이라는 뜻 같기도 한데, 어쨌거나 주인장은 정확한 해석을 못 하겠음)> 2. 지역화된 파일핸들,디렉토리핸들,함수를 생성해야 할 때 * 자신만의 파일핸들이 필요한 함수는 완전한 타입글로브를 대상으로 <code>local()</code>을 사용하여야 한다. 이것은 새로운 심볼 테이블 엔트리를 생성할 때 사용할 수 있다: {{{#!vim perl sub ioqueue { local (*READER, *WRITER); # my가 아니다! pipe (READER, WRITER) or die "pipe: $!"; return (*READER, *WRITER); } ($head, $tail) = ioqueue(); }}} * 익명 심볼 테이블 엔트리를 생성하는 방법은 Perldoc:Symbol 참조 * 타입글로브에 레퍼런스를 할당하면 별칭(alias)가 생성되며, 이것은 지역화된 함수(또는 정확히는 지역화된 별칭)을 생성하는 데 사용된다: {{{#!vim perl { local *grow = \&shrink; # 이 블록이 끝날 때까지만 grow(); # 실제로는 shrink()를 호출한다 move(); # 만일 move() 안에서 grow()를 호출한다면 그때도 shrink()가 호출된다 } grow(); # 진짜 grow()를 호출 }}} * 함수의 이름을 가지고 함수를 조작하는 것에 대해 더 자세한 내용은 Perldoc:perlref""의 "Function Templates" 섹션 참조 3. 배열이나 해쉬의 원소 하나를 임시로 변경하고 싶을 때 * 집합적 데이타의 원소 하나만 지역화할 수 있다. * 보통은 동적 데이타를 대상으로<footnote(원문은 "dynamics". 정확히는 동적 스코프의 영향을 받는 전역변수를 대상으로라는 의미인 듯)> 사용: {{{#!vim perl { local $SIG{INT} = 'IGNORE'; funct(); # 인터럽트 불가능한 상태로 수행 } # 여기서 인터럽트 가능여부가 자동으로 복원된다 }}} * 렉시컬 데이타에도 사용가능 * Perl 5.5 이전 버전에서는 예상대로 동작하지 않을 수 있음 ==== # 참조에 의한 전달 ( Pass by Reference ) ==== 둘 이상의 배열 또는 해쉬를 함수에 전달하거나 함수로부터 반환받으면서 그것들의 속성까지 유지되기를 바란다면 명시적인 참조에 의한 전달을 사용해야 한다. * 레퍼런스에 대한 자세한 내용은 Perldoc:perlref 참조 몇가지 예제 * 여러 개의 배열을 함수에 전달하고 각 배열에 <code>pop</code>을 수행한 후 그렇게 뽑아낸 원소들의 리스트를 반환: {{{#!vim perl @tailings = popmany ( \@a, \@b, \@c, \@d ); sub popmany { my $aref; my @retlist = (); foreach $aref ( @_ ) { push @retlist, pop @$aref; } return @retlist; } }}} * 해쉬들을 함수에 전달하여 모든 해쉬에 공통으로 들어있는 키들의 리스트를 반환: {{{#!vim perl @common = inter( \%foo, \%bar, \%joe ); sub inter { my ($k, $href, %seen); # locals foreach $href (@_) { while ( $k = each %$href ) { $seen{$k}++; } } return grep { $seen{$_} == @_ } keys %seen; } }}} 여기까지는 일반적인 리스트 반환 메커니즘을 사용했다. 해쉬를 전달하거나 리턴하고 싶은 경우는 어떻게 할 것인가? 하나의 해쉬만 리턴하거나, 해쉬들이 병합되어도 상관없다면 이런 일반적인 호출 형태도 상관없다. 문제가 되는 경우: {{{#!vim perl (@a, @b) = func(@c, @d); 또는 (%a, %b) = func(%c, %d); }}} * 위 코드는 <code>@a</code>와 <code>%a</code>에 모든 리턴값이 들어가고 <code>@b</code>와 <code>%b</code>는 깨끗이 비게 된다. 또한 함수는 두 개의 분리된 배열이나 해쉬를 전달받을 수 없고, 항상 하나의 긴 리스트 <code>@_</code>를 받는다. 레퍼런스를 사용하여서, 아주 보기 좋진 않더라도 더 깔끔한 코드를 만들 수 있다. * 두 개의 배열 레퍼런스를 인자로 받고, 두 개의 배열 레퍼런스를 반환하는데 이 때 원소의 갯수가 큰 순으로 반환하는 함수: {{{#!vim perl ($aref, $bref) = func(\@c, \@d); print "@$aref has more than @$bref\n"; sub func { my ($cref, $dref) = @_; if (@$cref > @$dref) { return ($cref, $dref); } else { return ($dref, $cref); } } }}} * 이렇게도 할 수 있다: {{{#!vim perl (*a, *b) = func(\@c, \@d); print "@a has more than @b\n"; sub func { local (*c, *d) = @_; if (@c > @d) { return (\@c, \@d); } else { return (\@d, \@c); } } }}} ** 여기서는 타입글로브를 써서 심볼 테이블의 별칭을 만들었다. 그러나 이런 방식은 좀 미묘한 구석이 있고, <code>my</code> 변수들을 사용하고 있다면 제대로 동작하지 않는다. 심볼 테이블에는 전역 변수(<code>local</code>로 지역화한 경우라도)만 들어있기 때문이다. 파일핸들을 전달하려고 할 때는 <code>*STDOUT</code>처럼 타입글로브를 그대로(bare typeglob) 쓸 수도 있고, 타입글로브의 레퍼런스를 쓸 수도 있다: {{{#!vim perl splutter(\*STDOUT); sub splutter { my $fh = shift; print $fh "her um well a hmmm\n"; } $rec = get_rec(\*STDIN); sub get_rec { my $fh = shift; return scalar <$fh>; } }}} 새로운 파일핸들을 생성할 경우는 다음과 같이 할 수 있다. 이 때는 레퍼런스가 아니라 있는 그대로의(bare) *FH를 넘기는 것에 유의하라 {{{#!vim perl sub openit { my $path = shift; local *FH; return open (FH, $path) ? *FH : undef; } }}} <blockquote> 주인장 코멘트: openit()을 호출하는 쪽에서는 <code>*IN = openit()</code>와 같이 파일핸들 타입글로브를 쓸 수도 있는데, 이 경우 openit()이 undef을 반환할 경우 경고가 뜬다. 최신 Perl에서는 파일핸들을 스칼라변수에 담아 쓸 수 있으므로, <code>my $in = openit()</code>와 같이 사용하는 것이 낫지 싶다. </blockquote> ==== # 프로토타입 ( Prototypes ) ==== Perl은 함수 프로토타입을 사용하여 매우 제한된 종류나마 컴파일타임에 인자를 체크하는 것을 지원한다. * 다음과 같이 선언할 경우, <code>mypush</code>는 <code>push()</code>와 똑같은 형태의 인자를 받는다: {{{#!vim perl sub mypush (\@@) }}} * 함수 선언은 컴파일 타임에 보여야 한다<footnote(예를 들어 use로 불러온 모듈 내에 있는 함수 선언의 프로토타입은 체크가 되지만 require로 불러오면 안 된다)> * 프로토타입은 신식 스타일, 즉 <code>&</code>를 함수명 앞에 쓰지 않는 스타일로 함수를 호출할 때만 영향을 끼친다. * <code>\&foo</code>와 같은 서브루틴 레퍼런스나 <code>&{$subref}</code>또는 <code>$subref->()</code>와 같은 간접 호출에는 적용되지 않는다. * 메쏘드 호출<footnote(객체지향 방식으로 작성된 코드에서)>도 프로토타입의 영향을 받지 않는다. 실제로 호출될 함수가 무엇인지는 상속 관계에 따라 달라지므로 컴파일 시간에 결정할 수 없기 때문이다. 프로토타입 기능의 주 목적은 서브루틴을 내장함수들처럼 동작하도록 정의할 수 있게 하는 것이다 * 대응되는 내장함수와 거의 정확히 동일하게 구문이 해석되는 함수들의 프로토타입 예제: {{{#!vim 아래와 같이 선언하고 아래와 같이 호출함 sub mylink ($$) mylink $old, $new sub myvec ($$$) myvec $var, $offset, 1 sub myindex ($$;$) myindex &getstring, "substr" sub mysyswrite ($$$;$) mysyswrite $buf, 0, length($buf) - $off, $off sub myreverse (@) myreverse $a, $b, $c sub myjoin ($@) myjoin ":", $a, $b, $c sub mypop (\@) mypop @array sub mysplice (\@$$@) mysplice @array, 0, 2, @pushme sub mykeys (\%) mykeys %{$hashref} sub myopen (*;$) myopen HANDLE, $name sub mypipe (**) mypipe READHANDLE, WRITEHANDLE sub mygrep (&@) mygrep { /foo/ } $a, $b, $c sub myrand (;$) myrand 42 sub mytime () mytime }}} 백슬래쉬가 붙은 프로토타입 문자들은, 실인자가 정확히 그 문자로 시작해야 함을 의미한다. <code>@_</code>에 담겨 전달되는 값은 그 실인자 앞에 <code>\</code>를 붙여 얻은 레퍼런스가 된다. * <code>\[]</code> 표기를 사용하여 여러 인자 타입에 동시에 백슬래쉬를 적용할 수 있다: {{{#!vim perl sub myref (\[$@%&*]) }}} * 위와 같이 선언된 함수는 아래와 같이 호출할 수 있다: {{{#!vim myref $var myref @array myref %hash myref &sub myref *glob }}} * 실제로 myref()로 넘어가는 첫번째 인자는 스칼라,배열,해쉬,코드,글로브의 레퍼런스가 된다. 백슬래쉬가 붙지 않은 프로토타입 문자들은 특별한 의미를 갖는다 * <code>@</code>와 <code>%</code>는 남아있는 인자 전부를 모아서 사용하고, 리스트 문맥을 강제한다 * <code>$</code>는 스칼라 문맥을 강제한다. * <code>&</code>는 익명 서브루틴을 요구한다. 이 익명 서브루틴이 첫번째 인자일 경우는 <code>sub</code>키워드나, 뒤에 오는 컴마를 생략할 수 있다<footnote(<code>grep { 코드 } 리스트</code>에서 <code>{ 코드 }</code>가 이렇게 익명 서브루틴을 넘기는 것이다)> * <code>*</code>는 서브루틴이 bareword, 상수, 스칼라 식, 타입글로브, 타입글로브의 레퍼런스 등을 받아들일 수 있음을 의미한다. ** 서브루틴 쪽에서는 넘어온 인자를 단순한 스칼라 값 또는 (타입글로브 또는 타입글로브의 레퍼런스를 전달한 경우) 타입글로브의 레퍼런스로 받는다. ** 이 인자들을 언제나 타입글로브 레퍼런스로 변환하려면 Symbol::qualify_to_ref()를 사용하라: {{{#!vim perl use Symbol 'qualify_to_ref'; sub foo (*) { my $fh = qualify_to_ref(shift, caller); ... } }}} 세미콜론(;)은 필수적인 인자와 선택적인 인자를 구분한다. * 나머지 인자를 전부 취하게 되는 <code>@</code>나 <code>%</code> 앞에는 쓸 필요가 없다.<footnote(주인장 생각에는, 나머지 인자를 전부 취하는 게 문제가 아니라 '빈 리스트'를 인자로 받아도 문제가 없는 게 핵심인 듯하다. 예를 들어 프로토타입이 <code>$$$</code>면 반드시 스칼라 3개를 인자로 받아야 하고 <code>$$;$</code>면 2개 또는 3개를 받을 수 있다. 하지만 프로토타입이 <code>$$@</code>인 경우는 스칼라 2개만 인자로 넘겨받아도 에러가 나지 않고 마지막 @는 빈 리스트로 간주된다. 따라서 굳이 <code>$$;@</code>라고 쓸 필요가 없다)> 프로토타입의 가장 마지막 자리 또는 세미콜론 바로 앞자리에 <code>$</code>가 들어갈 경우 그 대신에 <code>_</code>를 쓸 수 있다 * 만일 호출할 때 인자가 없다면 <code>$_</code>가 대신 쓰이게 된다. 위 테이블에서 마지막 세 가지 예제가 구문해석기에 의해 어떻게 해석되는지 유의하라: * <code>mygrep()</code>은 순수하게 리스트 연산자로만 해석된다. * <code>myrand()</code>는 <code>rand()</code>와 같은 단항 우선순위를 갖는 단항연산자로만 해석된다 * <code>mytime()</code>은 <code>time()</code>처럼 순수하게 인자가 없는 연산자로 해석된다 ** 따라서 다음 코드는 <code>mytime() + 2</code>를 얻게 된다. 프로토타입이 없었다면 <code>mytime(2)</code>로 해석되었을 것이다: {{{#!vim perl mytime +2; }}} <code>&</code>와 관련된 흥미로운 것은, 이게 제일 앞자리에 주어질 경우 이것을 사용하여 새로운 문법을 생성할 수 있다는 것이다: * 이 코드는 "unphooey"를 출력한다. {{{#!vim perl sub try (&@) { my($try,$catch) = @_; eval { &$try }; if ($@) { local $_ = $@; &$catch; } } sub catch (&) { $_[0] } try { die "phooey"; } catch { /phooey/ and print "unphooey\n"; }; }}} 다음은 Perl의 <code>grep</code> 연산자를 새로 구현한 코드: {{{#!vim perl sub mygrep (&@) { my $code = shift; my @result; foreach $_ (@_) { push(@result, $_) if &$code; } @result; } }}} 일부 펄 유저들은 프로토타입에 알파벳과 숫자를 사용한 이름을 쓸 수 있기를 원한다. * 이런 문자숫자 조합은 차후에 이름이 부여된 형식인자(named,formal parameter)가 펄에 추가될 때를 위해 남겨져 있다. * 현재의 방식의 주 목표는 모듈을 작성하는 사람이 모듈 사용자에게 더 좋은 사용법을 제공할 수 있게 하려는 것이다. * 현재는 프로토타입 자리에 이런 알파벳과 숫자를 사용할 경우 "Illegal character in prototype"이라는 경고가 뜬다. ** 오래된 버전의 Perl에서는 접두어가 올바른 프로토타입일 경우 이렇게 알파벳과 숫자가 들어간 프로토타입을 쓸 수 있었다. 당시 그런 프로토타입을 썼던 코드들의 대부분이 수정되고 나면 향후 Perl 버전에서는 경고 대신 치명적 에러가 나도록 고쳐질 것이다.<footnote(이건 고쳐질 일이 없다는 얘기려나... 세상을 떠도는 구버전 Perl 코드들을 언제 다 살펴본다고..?)> 기존에 있던 함수에 프로토타입을 도입하여 개선하려 하지 말고, 새로운 함수를 만들어 프로토타입을 적용하는 게 최선일 것이다. * 프로토타입을 적용함으로써 리스트 문맥과 스칼라 문맥의 구분을 사용자가 모르는 새 강제하게 될 수 있기 때문이다 * 예: ** 함수가 오직 하나의 인자만 받아야 한다고 결정했다고 하자: {{{#!vim perl sub func ($) { my $n = shift; print "you gave me $n\n"; } }}} ** 만일 누군가 기존에 이 함수를 배열이나, 리스트를 반환하는 식을 인자로 주어 호출했었다면: {{{#!vim perl func(@foo); func( split /:/ ); }}} ** 프로토타입을 사용한 이후엔 위 코드의 인자 앞에 자동으로 <code>scalar</code>가 붙게 된다. *** 원소가 하나인 <code>@foo</code>가 전달되지 않고, @foo의 원소의 갯수인 <code>1</code>이 전달된다. *** <code>split</code>이 스칼라 문맥에서 호출되게 되어, <code>@_</code> 인자리스트를 엉망으로 만들 것이다 ==== # 상수 함수 ( Constant Functions ) ==== 프로토타입이 <code>()</code>인 함수들은 인라인함수가 될 가능성이 있다. * 함수를 최적화 및 상수폴딩<footnote(constant folding, 효율성을 위해서 상수들로 표현된 식을 미리 평가하여 상수 결과로 치환해 놓는 것)>한 후의 결과가 상수값이거나, 다른 레퍼런스가 없고 렉시컬 스코프를 갖는 스칼라인 경우, <code>&</code>를 붙이지 않은 형태의 함수호출 자리에 치환되어 사용된다. * <code>&</code>를 붙인 형태의 호출은 인라인이 되지 않는다 * 상수를 선언하는 쉬운 방법은 Perldoc:constant 참조 다음 함수들은 모두 인라인될 것이다: {{{#!vim perl sub pi () { 3.14159 } # 정확한 값은 아니고 근사치. sub PI () { 4 * atan2 1, 1 } # 최대한 정확하며, 인라인함수가 된다! sub ST_DEV () { 0 } sub ST_INO () { 1 } sub FLAG_FOO () { 1 << 8 } sub FLAG_BAR () { 1 << 9 } sub FLAG_MASK () { FLAG_FOO | FLAG_BAR } sub OPT_BAZ () { not (0x1B58 & FLAG_MASK) } sub N () { int(OPT_BAZ) / 3 } sub FOO_SET () { 1 if FLAG_MASK & FLAG_FOO } }}} 다음 함수들은 인라인되지 않는다. 더 안쪽 스코프가 있고, 상수폴딩의 결과가 하나의 상수로 나오지 않기 때문이다: {{{#!vim perl sub foo_set () { if (FLAG_MASK & FLAG_FOO) { 1 } } sub baz_val () { if (OPT_BAZ) { return 23; } else { return 42; } } }}} 인라인이 될 가능성이 있는 서브루틴을 재정의할 경우, 필수적인 경고<footnote(원문은 mandatory warning. <code>use warnings</code> 프라그마를 사용하지 않아도 경고가 발생함)>가 발생한다. (이 경고를 이용해서 특정 서브루틴이 상수로 간주되는지 여부를 확인할 수 있다) * 미리 컴파일된 함수호출이, 함수가 재정의되기 전에 가지고 있었던 값을 얻게될 우려가 있기 때문. * 서브루틴을 재정의해야 하는 경우, 서브루틴이 인라인이 되지 않는 것을 확실히 해 두라 ** <code>()</code> 프로토타입을 없애던가 (이 경우 호출 인터페이스가 달라지니 주의) ** 인라인이 되지 못하도록 방해함: {{{#!vim perl sub not_inlined () { 23 if $]; } }}} ==== # 내장 함수 오버라이드 ( Overriding Built-in Functions ) ==== 많은 내장 함수들을 오버라이드할 수 있다. * 그러나 타당한 이유가 있을 때에만 하고, 자주 하는 것도 지양할 것 * 보통은 어떤 패키지에서 Unix 계열이 아닌 시스템에서 제대로 동작하지 않는 내장 함수의 기능을 모방하는데 사용함 오버라이딩은 컴파일 타임에 함수를 모듈로부터 임포트하는 형태로 이뤄진다 -- 단지 호출 전 미리 선언하는 것만으로는 충분하지 못하다. * <code>use subs</code> 프라그마를 쓰면 import 문법을 사용하여 서브루틴을 미리 선언하고 내장 함수를 오버라이드할 수 있다: {{{#!vim perl use subs 'chdir', 'chroot', 'chmod', 'chown'; chdir $somewhere; sub chdir { ... } }}} 기존 내장함수를 참조하려는 의도를 명백하게 나타내려면, 내장 함수의 이름 앞에 특수한 패키지 한정자인 <code>CORE::</code>를 붙인다. * 예: 현재 패키지에 어디선가 불러온 <code>&open()</code>서브루틴이 있더라도, <code>CORE::open()</code>은 언제나 내장 함수 <code>open()</code>을 가리킨다. * 이 형태는 정규적인 함수 호출처럼 보이지만 실제로는 그렇지 않다, <code>\&CORE::open</code>과 같은 식으로 레퍼런스를 얻을 수 없다. 일반적으로 라이브러리 모듈들은 <code>open</code>이나 <code>chdir</code>과 같은 내장 함수의 이름을 기본 <code>@EXPORT</code> 리스트에 포함해서 익스포트하지 말아야 한다. * 다른 사용자의 네임스페이스에서 예상하지 못한 의미의 변경을 초래할 수 있기 때문이다. * 대신 <code>@EXPORT_OK</code> 목록에 넣어서 사용자가 그 이름을 명시적으로 임포트하여 쓸 수 있게 한다. ** 다음과 같이 선언하여 명시적으로 <code>open</code>을 불러와서 오버라이드할 수 있다: {{{#!vim perl use Module 'open'; }}} ** 다음과 같이 하면 오버라이드하는 함수들을 제외하고 디폴트 목록만 임포트한다: {{{#!vim perl use Module; }}} 위의 메커니즘은 임포트를 요청한 패키지 내에서만 오버라이드가 이뤄진다. 만일 네임스페이스의 경계를 넘어서 모든 곳에서 내장함수를 오버라이드하고자 하길 원한다면, 서브루틴을 특별한 네임스페이스인 <code>CORE::GLOBAL::</code> 안으로 임포트한다. * <code>glob</code> 연산자를 오버라이드하여 정규표현식을 인식할 수 있도록 한 예: {{{#!vim perl package REGlob; require Exporter; @ISA = 'Exporter'; @EXPORT_OK = 'glob'; sub import { my $pkg = shift; return unless @_; my $sym = shift; my $where = ($sym =~ s/^GLOBAL_// ? 'CORE::GLOBAL' : caller(0)); $pkg->export($where, $sym, @_); } sub glob { my $pat = shift; my @got; if (opendir my $d, '.') { @got = grep /$pat/, readdir $d; closedir $d; } return @got; } 1; }}} ** 위 코드를 사용하는 예: {{{#!vim perl #use REGlob 'GLOBAL_glob'; # 모든 네임스페이스에서 glob()을 오버라이드하는 경우 package Foo; use REGlob 'glob'; # Foo:: 안에서만 glob()을 오버라이드 print for <^[a-z_]+\.pm\$>; # 이름이 소문자로만 된 프라그마 모듈들을 출력 }}} ** 위 예의 첫번째 라인에서처럼 <code>glob</code>을 전역적으로 오버라이드할 경우 모든 네임스페이스에서 glob의 동작이 변경되게 되며, 그 네임스페이스를 담당하는 모듈 쪽에서 그 사실을 인지하지 못 할 수 있다. 따라서 이런 오버라이드는 꼭 필요한 경우에만 극도로 주의를 기울여서 행하라. ** 위 예의 <code>REGlob</code>은 perl의 <code>glob</code>을 오버라이드하기 위해 필요한 모든 기능을 제공하고 있지는 않다. 내장 glob은 스칼라 또는 리스트 문맥에서 호출되었을 때 서로 다르게 동작한다. 사실 많은 perl 내장 함수들이 이렇게 문맥에 따라 다르게 동작하며, 오버라이드할 경우 이런 동작을 지원해주어야 한다. <code>glob</code>을 오버라이드하며 모든 기능을 지원하는 예는 표준 라이브러리에 있는 <code>File::DosGlob</code>을 살펴보라. 내장 함수를 오버라이드할 경우, 대체되는 함수도 가능하면 내장 함수의 문법을 그대로 쓸 수 있게 작성해야 한다. * 적절한 프로토타입을 사용 * 내장 함수의 프로토타입을 알아보기 위해서는 <code>prototype</code> 함수에 <code>"CORE::내장함수이름"</code> 인자를 넣으면 된다. (Perldoc:perlfunc""의 "prototype" 참조) 어떤 내장 함수(<code>system</code>이나 <code>chomp</code> 등)는 사용 문법을 프로토타입으로 표현할 수 없다. 이런 함수를 오버라이드할 경우는 그 함수의 원래의 문법을 완벽하게 모방할 수 없을 것이다. 내장 <code>do</code>, <code>require</code>, <code>glob</code>은 오버라이드 할 수는 있으나, 그 함수들의 특수한 기능들 때문에, 함수의 문법이 보존된다. 따라서 오버라이드하는 대체함수를 위한 프로토타입을 정의할 필요가 없다. (다만 <code>do BLOCK</code> 문법을 오버라이드하는 것을 불가능하다) <code>require</code>는 이 외에도 특별한 기능이 있다: <code>require Foo::Bar</code>의 형태로 오버라이드한 함수를 호출하면, 그 함수에 @_에 담겨서 실제로 전달되는 인자는 <code>"Foo/Bar.pm"</code>이다. Perldoc:perlfunc""의 "require"를 참조하라. 위에서 보았듯이 <code>glob</code>을 오버라이드하면 글롭 연산자 <code><*></code>도 같이 오버라이드된다. 비슷하게, <code>readline</code> 함수를 오버라이드하면 이와 동등한 I/O연산자 <code><파일핸들></code>도 오버라이드된다. 또한 <code>readpipe</code>을 오버라이드하면 <code>``</code>와 <code>qw//</code> 연산자도 오버라이드된다. 끝으로, 일부 내장함수(<code>exists</code> 또는 <code>grep</code> 등)은 오버라이드할 수 없다. ==== # 자동 로드 ( Autoloading ) ==== 정의되지 않은 서브루틴을 호출할 경우 곧바로 치명적 에러가 발생하며 종료된다. (메쏘드로 사용되는 서브루틴의 경우 클래스 패키지와 그 상위클래스 어디에도 그 메쏘드가 없는 경우도 마찬가지) * 그러나 <code>AUTOLOAD</code> 서브루틴이 그 패키지 또는 원래 서브루틴을 검색하는 데 사용되는 패키지 중에 정의되어 있을 경우, 이 서브루틴이 호출되며 원래의 서브루틴에 넘어갈 인자가 이 서브루틴으로 넘어간다. * 원래 서브루틴의 fully qualified된 이름은 <code>AUTOLOAD</code> 루틴이 있는 패키지에 속한 <code>$AUTOLOAD</code> 전역 변수에 담긴다. * 예외적으로 존재하지 않는 <code>import</code> 또는 <code>unimport</code>메쏘드를 호출하는 것은 그냥 무시된다. 많은 경우 <code>AUTOLOAD</code> 루틴은 eval()을 사용하여 원래 요청된 서브루틴의 정의를 로드한 후, AUTOLOAD의 스택프레임을 삭제할 수 있는 특별한 형태의 goto()를 사용하여 그 서브루틴을 실행한다. (예를 들어 Perldoc:AutoLoader 에 문서화되어 있는 표준 모듈의 소스를 참조하라) 하지만 단순히 원래의 서브루틴의 흉내만 내고 전혀 정의하지 않을 수도 있다. * 정의되지 않은 함수는 <code>system</code>을 호출하여 실행하도록 하는 예: {{{#!vim perl sub AUTOLOAD { my $program = $AUTOLOAD; $program =~ s/.*:://; system($program, @_); } date(); who('am', 'i'); ls('-l'); }}} ** 각 함수를 저렇게 호출할 것을 미리 선언하면 괄호까지 생략가능하다: {{{#!vim perl use subs qw(date who ls); date; who "am", "i"; ls '-l'; }}} 더 복잡한 예는 표준 Perldoc:Shell""에서 볼 수 있다, 여기서는 존재하지 않는 서브루틴 호출은 외부 프로그램을 호출하는 것으로 취급된다. 이런 자동 로드 메커니즘은 모듈 작성자가 자신의 모듈을 자동으로 로드할 수 있는 파일들로 분리하는 것을 돕기 위해 존재한다. Perldoc:AutoLoader"", Perldoc:AutoSplit"", Perldoc:SelfLoader"", Perldoc:perlxs 등을 참조하라. ==== # 서브루틴 속성 ( Subroutine Attributes ) ==== <blockquote> <color(red,이 섹션의 내용은 주인장도 잘 모르는 부분이라, 번역에 오류가 있을 가능성이 높습니다)> </blockquote> 서브루틴의 선언이나 정의에는 그 서브루틴과 연관된 속성을 나열해 줄 수 있다. * 이런 속성 목록이 존재할 경우, <code>use attributes</code> 프라그마를 사용한 것처럼 목록을 콜론 또는 공백을 구분자로 해서 각각을 나눈 후에 처리된다. * 현재 지원되는 속성들에 대해서는 Perldoc:attributes 참조 * 구식 방법은 <code>use attrs</code>와는 달리, <code>sub : 속성리스트</code> 형태의 문법은 꼭 서브루틴 정의 안에 있어야 되는 게 아니라 미리 선언하는 곳에 있어도 된다. 각 속성의 명칭들은 간단한 식별자로서 사용할 수 있는 형태여야 한다 ('_' 문자를 제외하고는 구두점을 쓸 수 없다). 각 속성에는 파라메터 리스트가 뒤에 붙을 수 있으며, 괄호가 정확하게 중첩되었는지만 체크된다. 올바른 문법의 예: (실제 이런 이름의 속성 자체는 존재하지 않지만) {{{#!vim perl sub fnord (&\%) : switch(10,foo(7,3)) : expensive; sub plugh () : Ugly('\(") :Bad; sub xyzzy : _5x5 { ... } }}} 올바르지 않은 문법의 예: {{{#!vim perl sub fnord : switch(10,foo(); # 괄호의 좌우 쌍이 맞지 않음 sub snoid : Ugly('('); # 괄호의 좌우 쌍이 맞지 않음 sub xyzzy : 5x5; # "5x5"는 올바른 식별자가 아님 sub plugh : Y2::north; # "Y2::north"는 간단한 식별자가 아님 sub snurt : foo + bar; # "+"는 콜론도 공백도 아님 }}} 속성 리스트는 그 서브루틴과 속성을 연결시키는 코드에 상수 문자열 리스트 형태로 전달된다. 특히 위의 두번째 예문은 다음과 같이 해석되고 수행된다: {{{#!vim perl use attributes __PACKAGE__, \&plugh, q[Ugly('\(")], 'Bad'; }}} 속성 목록의 더 자세한 내용과 사용법에 대해서는 Perldoc:attributes""와 Perldoc:Attribute::Handlers 참조 === # 참고 === * 레퍼런스와 클로저에 관해서는 Perldoc:perlref""의 "Function Templates" 참조 * Perl에서 C 서브루틴을 호출하는 것은 Perldoc:perlxs 참조 * C에서 Perl 서브루틴을 호출하는 것은 Perldoc:perlembed 참조 * 함수들을 여러 분리된 파일로 포장하는 것은 Perldoc:perlmod 참조 * 자신의 시스템에 표준으로 제공되는 라이브러리 모듈들은 Perldoc:perlmodlib 참조 * OOP에서 객체 메쏘드 호출을 하는 법은 Perldoc:perltoot 참조 == # 다른 문서들에서 == === # 선언 순서 === 서브루틴 정의와 사용의 순서<footnote(Beginning Perl, Chapter 08)> * setup();처럼 괄호를 붙여주면 나중에 정의할 수 있다. ** &setup;처럼 쓸 수도 있다 - Perl 4에서의 형태 * setup; 과 같은 bareword 형태로 호출하기 위해서는 그 전에 서브루틴 정의가 있어야 한다. * forward definition(pre-declaring) {{{#!vim perl sub setup; # 이름만 선언 # 또는 use subs qw(setup get_input 등등); setup; # 사용 sub setup { ... } # 실제 정의 }}} 동일한 이름의 서브루틴이 둘 이상 있으면, 나중의 것이 적용된다.<footnote(Learning Perl, Chapter 04)> Perl의 built-in function 과 동일한 이름의 서브루틴을 호출하는 경우는 반드시 "&"가 필요하다. 이런 이유로, Learning Perl에서는 "Perl의 모든 내장 함수의 이름을 알고 있지 않다면" 항상 "&"를 붙일 것을 권장한다.<footnote(Learning Perl, Chapter 04)> '''그러나 최근 경향은 "&"를 앞에 붙이지 않는 것이다.'''<footnote([https://www.socialtext.net/perl5/index.cgi?subroutines_called_with_the_ampersand Subroutines called with the ampersand / Perl 5 Wiki], [https://github.com/aero/perl_docs/wiki/Learning-perl-5th-review 거침없이 배우는 펄(learning perl 5th 한글번역판) 비평 - perl_docs - GitHub])> === # [#context] Context === wantarray<footnote(Beginning Perl, Chapter 08)> * 리스트 문맥에서 수행 중이라면 true * 스칼라 문맥이었다면 false * void 문맥이었다면 undef 주인장이 네이버 까페에 쓴 [http://cafe.naver.com/perlstudy/542 다양한 상황에서 컨텍스트 확인]도 참고할 것: {{{#!vim perl sub foo { my $wa = wantarray; if ( not defined $wa ) { # 정의되지 않는다면 void 문맥 print "void context\n"; } elsif ( $wa ) { # 값이 참이면 list 문맥 print "list context\n"; } else { # 정의되었으나 거짓이면 scalar 문맥 print "scalar context\n"; } return 3; # 어쨌거나 리턴값은 3 } my $scalar; my @array; foo(); # void ( foo() ); # void () = foo(); # list $scalar = foo(); # scalar print "scalar = [$scalar]\n"; # 3 ( $scalar ) = foo(); # list print "scalar = [$scalar]\n"; # 3 $scalar = ( foo() ); # scalar !! print "scalar = [$scalar]\n"; # 3 $scalar = ( () = foo() ); # list print "scalar = [$scalar]\n"; # 1 !! @array = foo(); # list print "array = ", join(":", @array), "\n"; # ( 3 ) $array[foo()] = 10; # scalar print "array = ", join(":", @array), "\n"; # ( 3, undef, undef, 10 ) @array[foo()] = 20; # list print "array = ", join(":", @array), "\n"; # ( 3, undef, undef, 20 ) }}} === # Prototype === 파라메터의 갯수와 종류를 명시할 수 있다.<footnote(Beginning Perl, Chapter 08)> * 서브루틴을 호출하기 전에 프로토타입을 볼 수 있어야 하므로, 정의를 먼저 해 주던가 forward definition이 필요하다. 이 경우 실제 정의하는 부분과 프로토타입이 일치해야 함 {{{#!vim perl sub sum_of_two_squares ($$); print sum_of_two_squares($first, $second),"\n"; # print sum_of_two_squares($first, $second, 0),"\n"; <- 이건 에러 sub sum_of_two_squares ($$) { my ($a,$b) = (shift, shift); return $a**2+$b**2; } }}} === # 인자로 레퍼런스 넘겨주기 === 호출하는 쪽에서 레퍼런스를 명시적으로 넘길 수도 있고 {{{#!vim perl my $a = 5; increment(\$a); }}} 프로토타입에 "\"+"변수타입심볼 형태로 적어주면 자동으로 레퍼런스를 취한다 {{{#!vim perl sub increment(\$); my $a = 5; increment($a); sub increment(\$) { my $reference = shift; $$reference++; } }}} === # 인자로 파일핸들 넘겨주기 === [[/파일]] 참조 === # Named parameter === 해쉬 형태로 인자 넘겨주기 - 어차피 받는 쪽은 @_로 받음. * 인자의 순서를 신경쓸 필요가 없음. * 인자의 갯수가 많고, optional한 경우에 매우 유용하다. {{{#!vim perl logon(username => $name, password => $pass, host => $hostname); sub logon { die "Parameters to logon should be even" if @_ % 2; my %args = @_; # 넘어온 인자로 해쉬 구성 print "Logging on to host $args{hostname}\n"; ... } }}} === # 서브루틴의 레퍼런스 === 선언 {{{#!vim perl sub something { print "Wibble!\n" } my $ref = \&something; # 익명 서브루틴 my $ref = sub { print "Wibble!\n" }; }}} 호출 {{{#!vim perl &{$ref}; &{$ref}(@parameters); &$ref(@parameters); # 아래의 형태를 권장 $ref->(); $ref->(@parameters); }}} === # Closure === * [[/Closure]] 참조 스코프를 벗어난 렉시컬 변수를 참조하는 서브루틴<footnote(Intermediate Perl, Chapter 07)> 콜백 함수의 예:<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl use File::Find; # 현재 디렉토리 이하의 파일들 모두의 크기의 합을 구함 my $total_size = 0; # File::Find 모듈은 $total_size에 접근할 수 없지만, # 그 모듈이 콜백 함수로 호출하는 익명 서브루틴은 $total_size에 접근할 수 있다. find(sub { $total_size += -s if -f }, '.'); print $total_size, "\n"; }}} 클로져 안에서 접근하는 변수들은, 그 서브루틴의 레퍼런스가 존재하는 한 그 변수들도 계속 유지된다.<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl use File::Find; my $callback; { my $count = 0; $callback = sub { print ++$count, ": $File::Find::name\n" }; } # 이 시점에서 $count는 스코프를 벗어나지만, (따라서 접근할 수는 없지만) # $callback이 레퍼런스 하는 익명 서브루틴에 의해 참조되므로 레퍼런스 카운트가 0이 아니고, # 저 익명 서브루틴의 레퍼런스가 존재하는 한 메모리에 여전히 존재한다. find($callback, '.'); }}} === # 서브루틴을 반환하는 서브루틴 === 서브루틴의 레퍼런스를 반환하는 서브루틴<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl use File::Find; sub create_find_callback_that_counts { my $count = 0; return sub { print ++$count, ": $File::Find::name\n" }; } my $callback = create_find_callback_that_counts( ); # bin/ 아래의 파일들은 1번부터 번호가 부여되고 print "my bin:\n"; find($callback, 'bin'); # lib/ 아래의 파일들은 bin/ 파일의 마지막 번호 다음부터 번호가 부여된다. # 동일한 $count를 사용하기 때문 print "my lib:\n"; find($callback, 'lib'); # 아래의 경우는, 서로 다른 $count 인스턴스를 사용하기 때문에 각각 번호가 1부터 부여된다. my $callback1 = create_find_callback_that_counts( ); my $callback2 = create_find_callback_that_counts( ); print "my bin:\n"; find($callback1, 'bin'); print "my lib:\n"; find($callback2, 'lib'); }}} 둘 이상의 서브루틴을 반환하는 예:<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl use File::Find; sub create_find_callbacks_that_sum_the_size { my $total_size = 0; # 두 개의 익명 서브루틴이 $total_size를 공유 return(sub { $total_size += -s if -f }, sub { return $total_size }); } ## set up the subroutines my %subs; foreach my $dir (qw(bin lib man)) { my ($callback, $getter) = create_find_callbacks_that_sum_the_size( ); # bin, lib, man 세 디렉토리에 대하여 각각 별개의 콜백 서브루틴과 getter가 생성된다. $subs{$dir}{CALLBACK} = $callback; $subs{$dir}{GETTER} = $getter; } ## gather the data for (keys %subs) { find($subs{$_}{CALLBACK}, $_); } ## show the data for (sort keys %subs) { my $sum = $subs{$_}{GETTER}->( ); print "$_ has $sum bytes\n"; } }}} === # closure variable를 static local variable로 쓰기 === named subroutine에서 렉시컬 변수의 레퍼런스를 유지하는 경우<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl { # naked block 안에서 my $count; sub count_one { ++$count } sub count_so_far { return $count } } # 이 시점에서 $count는 스코프를 벗어났기 때문에 직접 접근할 수는 없지만 # count_one과 count_so_far는 closure이고 블록 밖에서도 유지가 되므로 # 그 안에서는 계속 $count를 사용 가능하다 count_one( ); count_one( ); count_one( ); print 'we have seen ', count_so_far( ), " coconuts!\n"; # 3 coconuts }}} 초기값을 따로 주어야 하는 경우는 주의<footnote(Intermediate Perl, Chapter 07)> {{{#!vim perl { # 이 블록은 count_down()을 호출하는 시점보다 먼저 나와야 한다. # countdown의 초기값을 먼저 10으로 만들어주어야 하기 때문 my $countdown = 10; sub count_down { $countdown-- } sub count_remaining { $countdown } } count_down( ); count_down( ); count_down( ); print 'we're down to ', count_remaining( ), " coconuts!\n"; }}} 아니면 해당 블록을 BEGIN 블록으로 지정 {{{#!vim perl BEGIN { my $countdown = 10; sub count_down { $countdown-- } sub count_remaining { $countdown } } }}} === # 서브루틴을 인자로 넘기기 === 물론 서브루틴의 레퍼런스를 인자로 넘길 수도 있지만... Perldoc:map, Perldoc:grep, Perldoc:sort 등과 같이 인라인 블록으로 전달하고 싶은 경우<footnote(Mastering Perl, Chapter 09)> * 서브루틴 프로토타입을 반드시 써주어야 함. ("&"을 사용) * 예: (아래 코드의 주석은 [[주인장]]이 책의 내용을 참고하여 추가한 것이라서 틀렸을 수 있음) {{{#!vim perl use List::Util; # reduce 라는 서브루틴은 인자로 서브루틴과 리스트를 받아서, 서브루틴을 사용하여 리스트의 원소들로부터 스칼라 하나를 생성한다. my $sum = reduce { $a + $b } @list; # 모든 원소의 합을 구하는 경우 # reduce 의 구현 package List::Util; sub reduce (&@) { my $code = shift; no strict 'refs'; return shift unless @_ > 1; use vars qw($a $b); my $caller = caller; # reduce 를 호출한 쪽에서 바라보는 $a와 $b는 호출한 쪽 패키지의 패키지 변수이다. # reduce 안에서 사용하는 $a와 $b는 렉시컬 변수이다. # 따라서 이 둘을 서로 alias 해주어야 함 # local()을 해 주지 않으면 호출한 쪽의 패키지 변수 $a, $b 가 계속 여기에 alias되어 있어서 곤란하다. local(*{$caller."::a"}) = \my $a; local(*{$caller."::b"}) = \my $b; $a = shift; foreach (@_) { $b = $_; $a = &{$code}(); print "now a = $a, b = $b\n"; } $a; } }}} * 주인장 생각으로는 $a와 $b를 my 변수로 선언하고 있기 때문에, use vars 구문은 사실 없어도 상관없어 보인다. 실제로 없애고 테스트해도 잘 동작하고... == # 기타 == * [[/컨텍스트]] * [[/익명서브루틴의재귀호출]] * [http://www.effectiveperlprogramming.com/blog/1406 Understand why you probably don’t need prototypes | The Effective Perler] - 프로토타입에 관한 얘기 * [http://www.effectiveperlprogramming.com/blog/1408 Make grep-like syntax | The Effective Perler] * [http://www.effectiveperlprogramming.com/blog/1401 Return error objects instead of throwing exceptions | The Effective Perler] * [http://ko.perlmaven.com/variable-number-of-parameters Perl 서브루틴의 가변 길이 파라메터 -- Perl Maven] == # Comments == <longcomments(100)> ---- [[컴퓨터분류]]
Perl/서브루틴
페이지로 돌아가기 |
다른 수정본 보기
![[첫화면으로]](/raymundo_logo.jpg){kind=logo}
Perl/서브루틴 페이지의 소스 보기Perl/서브루틴 페이지의 소스 보기