PERL(1)

명칭
perl - 실용적 추출과 리포트를 위한 언어

서식
perl [options] filename args

해설
perl (은)는, 임의의 텍스트 파일을 주사 해, 거기로부터 정보를 꺼내, 정보에 기 있던 리포트를 출력하기 위해서 최적화된 인터프리터 언어입니다. 또, 많은 시스템 관리 작업에 적절한 언어이기도 합니다. perl (은)는 아름다운 (작은, elegant, 최소)라고 하는 것보다는, 오히려 실용적 (사용하기 쉬운, 효율적, 완전)인 것을 목표로 하고 있습니다. perl (은)는, C, sed, awk, and sh, 의 가장 좋은 곳을 조합해 있는 (저자의 의향으로서는, 입니다만) 것으로, 이러한 언어에 친숙함이 있는 사람에게는, 용이하게 사용할 수 있겠지요. (언어 역사학자라면, csh, Pascal, 그리고 BASIC-PLUS 의 흔적에조차도 깨닫겠지요. ) 식의 서식은, C 의 것에 지극히 닮았습니다. 다른 많은 UNIX 유틸리티와 달리, perl (은)는, 데이터의 사이즈를 마음대로 제한 하는것 같은 일은 없고 (메모리가 있는 한입니다), 파일 전체를 하나의 캐릭터 라인으로서 읽어들여 버릴 수 있습니다. 재귀의 깊이에는 제한이 없습니다. 연상 배열로 사용되는 해시 테이블은, 퍼포먼스의 저하를 막기 위해, 필요에 따라서 커집니다. perl (은)는, 대량의 데이터를 매우 신속히 주사 하는 세련된 패턴 매치 테크닉을 사용합니다. 텍스트 주사에 최적화되고는 있습니다만, perl (은)는 바이너리 데이터도 취급할 수도 있어, (dbm 를 사용할 수 있다면) 연상 배열을 닮았다 dbm 파일을 만들 수 있습니다. setuid perl 스크립트는, 많은 어리석은 보안 홀을 막는 데이터 플로우(flow) 추적 기구에 의해, C 의 프로그램보다 안전합니다. 보통이라면 sed, awk, sh 를 사용하는 것 같은 문제로, 그 능력을 넘어 있거나, 좀 더 빠르게 달리게 한 없으면 안 되기도 하고, 시시한 것을 C 로 쓰고 싶지 않은 것 같은 경우에 perl 하지만 딱 맞습니다. 기존의 sed (이)나 awk 스크립트를 perl 스크립트로 하는 변환 프로그램도 있습니다. 자, 선전은 이것으로 충분하겠지요.

우선 시작해에, perl 다음의 장소로부터 스크립트를 찾습니다.

1.  명령행상의 -e 스윗치로 지정된 행.

2.  명령행상에서, 최초로 지정된 파일의 내용. (#! 의 표기를 서포트하는 시스템은, 인터프리터를 이렇게 해 기동합니다)

3.  표준 입력으로부터 암묵중에 읽힙니다. 이것은, 파일명의 지정이 하나 도 없는 경우에만 일합니다. -- 표준 입력 스크립트에 인수를 건네주려면 , 스크립트명으로서 명시적으로 - 를 지정하지 않으면 안됩니다.

스크립트를 찾아내면(자), perl (은)는 내부 형식에 컴파일 해, 스크립트가 문법적으로 올바르면 그것을 실행합니다.

  옵션
주의: 최초로 이 섹션을 읽어도 의미를 모를지도 모릅니다. 간단한 레퍼런스로서 전반 부분이 되어 있습니다.

한 글자 옵션은, 다음에 계속되는 옵션과 붙여도 괜찮습니다. #! 구조를 사용하는 스크립트를 기동하려면 하나의 인수 밖에 용서되지 않는거야 그리고, 특히 편리합니다. 례:
	#! /usr/bin/perl -spi.bak	# -s -p -i.bak 와 같다
	. . .
이하의 옵션이 있습니다:

-0숫자
    레코드 separator ($/)를 8 진수로 지정합니다. 숫자가 없으면 누르캐라크타가 separator가 됩니다. 다른 명령행 스윗치는, 전에 두는지, 혹은 숫자의 뒤에 잇습니다. 예를 들면, 눌 캐릭터를 종단으로 한 파일명을 표시 가능한 버젼의 find (이)라면, 이와 같이 쓸 수 있습니다.
        find .  -name '*.bak' -print0 | perl -n0e unlink
    00 은 특수한 값으로, perl (은)는 파일을 패러그래프 모드로 읽어들입니다. 0777 이라고 하는 값을 사용하면(자), 이 값의 캐릭터는 없기 때문에, 파일 전체를 읽어들입니다.

-a  -n (이)나 -p 옵션과 함께 이용해, 오트스프릿트모드를 ON 로 합니다. -n (이)나 -p 옵션으로 자동적으로 생성되는 while 루프의 안쪽의 최초의 곳에서, @F 배열에 대해서 암묵의 split 명령이 행해집니다.
    	perl -ane 'print pop(@F), "\n";'
    (은)는, 다음의 예와 동등하게 됩니다.
    	while (<>) {
    		@F = split(' ');
    		print pop(@F), "\n";
    	}

-c  perl 스크립트의 문법을 체크해, 실행하지 않고 종료합니다.

-d  perl 디버거의 아래에서 스크립트를 실행합니다. 디버그의 섹션을 참조해 주세요.

-D숫자
    디버그 플래그를 세트 합니다. 스크립트가 어떻게 실행될까를 보려면 , -D14 (을)를 사용합니다. (이것은 디버그 기능을 perl 에 짜넣어 컴파일 했을 때에게만 동작합니다. ) -D1024 도 유용한 값으로, 컴파일 된 문법 트리를 리스트 합니다. -D512 를 사용하면(자), 컴파일 된 정규 표현을 출력합니다.

-e 명령행
    일행 스크립트를 입력하는 경우에 사용할 수 있습니다. 복수행 스크립트를 조립하려면 , 복수의 -e 명령을 지정하면 할 수 있습니다. -e 하지만 주어지면(자), perl (은)는 인수의 리스트중에서 스크립트 파일명을 찾지 않습니다.

-i확장자(extension)
    <> 구조로 처리되는 파일을 그 자리에서 수정하는 것을 지정합니다. 입력 파일을 rename 해, 출력 파일을 전의 이름으로 오픈해, 출력 파일을 print 문의 디폴트 출력으로 하는 것으로 처리됩니다. 확장자(extension)가 주어지면, 백업파일의 이름으로서 원래의 파일명에 그 확장자(extension)를 더한 것이 사용됩니다. 확장자(extension)가 주어지지 않으면, 백업파일은 작성되지 않습니다. "perl -p -i.bak -e "s/foo/bar/;" . . . " 를 실행하는 것은, 다음의 스크립트와 같습니다.
    	#! /usr/bin/perl -pi.bak
    	s/foo/bar/;
    이것은 이하의 것과도 동등하게 됩니다.
    	#! /usr/bin/perl
    	while (<>) {
    		if ($ARGV ne $oldargv) {
    			rename($ARGV, $ARGV .  '.bak');
    			open(ARGVOUT, ">$ARGV");
    			select(ARGVOUT);
    			$oldargv = $ARGV;
    		}
    		s/foo/bar/;
    	}
    	continue {
    	    print;	# 전의 이름의 파일에 출력한다
    	}
    	select(STDOUT);
    다만, -i (을)를 이용한 방법에서는, 파일명이 변경되었을 때 각을 알기 위해서(때문에) $ARGV 와 $oldargv 를 비교할 필요가 없다고 하는 점이 다릅니다. 실제로는 파일 핸들로서 ARGVOUT 가 셀렉트 되어 사용됩니다. STDOUT 하지만 디폴트 출력의 파일 핸들로서 보존되어 루프의 나중에 되돌려지는 것에 주의해 주세요.

    입력 파일 모두에게 추가를 행하는 경우나, 행 번호를 리셋트 하거나 하는 경우, 각 입력 파일의 마지막을 알기 위해서(때문에) `eof'를 사용할 수가 있습니다. (eof 의 예를 참조해 주세요)

-I디렉토리
    -P (와)과 함께 이용해 C 프리프로세서에 인클루드 파일의 위치를 알립니다. 디폴트에서는, /usr/include 와 /usr/lib/perl 를 검색합니다.

-l8진수
    줄 끝 처리를 자동적으로 행합니다. 이것에는 두 개의 효과가 있습니다. 우선, -n (이)나 -p (와)과 함께 사용되는 것으로, 행 터미네이터를 자동적으로 제외합니다. 둘째는, $\ 가, 8 진수 (을)를 세트 해, print 문이 모두 마지막에 줄 끝 문자를 적는다고 하는 것입니다. 8 진수 하지만 생략 되었을 경우는, $\ 에 $/ 의 현재의 값을 세트 합니다. 예를 들면, 행을 80 자리수에 잘라 가지런히 하기 위해서(때문에)는:
    	perl -lpe 'substr($_, 80) = ""'
    $\ = $/ 라고 하는 대입은 명령행 스윗치가 처리될 때에 행해지므로, -l 스윗치에 -0 하지만 계속될 때는, 입력 레코드 separator와 출력 레코드 separator가 다를 수도 있기로 주의해 주세요.
    	gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
    이것은, $\ 에 개행을 세트 해,$/ 에는 눌 캐릭터를 세트 합니다.

-n  스크립트의 전후에 아래에 나타내는 루프가 있는 것으로서 perl (을)를 기동합니다. 이렇게 하면(자), 인수의 파일 전부에 대해 "sed -n" 또는 awk 와 같은 반복이 행해집니다:
    	while (<>) {
    		. . . 		# 여기에 스크립트가 옵니다
    	}
    디폴트로 입력행의 출력은 되지 않는 것에 주의해 주세요. 출력하고 싶으면 -p (을)를 참조해 주세요. 이하는, 1 주간보다 낡은 파일 모든 것을 삭제하는 효율적인 방법입니다.
    	find .  -mtime +7 -print | perl -nle 'unlink;'
    이 경우, 파일이 발견될 때마다 프로세스를 개시할 필요가 없기 때문에, find 의 -exec 스윗치를 사용하는 것보다 빨라집니다.

-p  스크립트의 전후에 아래에 나타내는 루프가 있는 것으로서 perl (을)를 기동합니다. 이렇게 하면(자), 인수의 파일 전부에 대해 sed 와 같은 반복이 행해집니다:
    	while (<>) {
    		. . . 		# 여기에 스크립트가 옵니다
    	} continue {
    		print;
    	}
    입력행은 자동적으로 출력되는 것에 주의해 주세요. 출력을 억제하고 싶으면, -n 스윗치를 사용해 주세요. -p (은)는, -n 스윗치에 우선합니다.

-P  perl 에 의한 컴파일의 전에 C 프리프로세서를 통합니다. (perl 의 코멘트도 cpp 의 인스트럭션도 # 의 캐릭터로 시작되므로, 코멘트를 C 프리프로세서가 이해하는 단어, 예를 들면 "if" 나 "else" 나 "define" 로 시작해는 되지 않습니다. )

-s  명령행상에서, 스크립트명과 파일명의 인수 (또는 --)의 사이에 있는 각 스윗치에 켜져 기본적인 해석을 행합니다. 스윗치가 발견되면(자), @ARGV 로부터 제외해져 대응하는 변수를 perl 스크립트내에서 세트 합니다. 이하의 스크립트에서는, -xyz 스윗치를 붙여 스크립트를 기동했을 때 만,"true" 를 출력합니다.
    	#! /usr/bin/perl -s
    	if ($xyz) { print "true\n"; }

-S  스크립트를 찾는데, 환경 변수 PATH 를 이용합니다 (스크립트명이 / 로 시작되지 않는 한). 통상은,#! (을)를 서포트하지 않는 머신에 대해 #! (을)를 에뮤레이트 하기 위해서 이용됩니다. 다음과 같은 사용법입니다:
    	#! /usr/bin/perl
    	eval "exec /usr/bin/perl -S $0 $*"
    		if $running_under_some_shell;
    시스템은 1 행 째를 무시해, 스크립트를 /bin/sh 에 건네줍니다. /bin/sh 는 perl 스크립트를 셸 스크립트로서 실행하려고 합니다. 쉘은 2 행 째 (을)를 통상의 쉘 명령로서 실행해, perl 인터프리터를 기동한다 됩니다. 시스템에 따라서는 $0 은 반드시 풀 패스명이 되지 않기 때문에, -S (을)를 이용해 perl 에 필요하면 스크립트를 찾도록(듯이) 지시합니다. perl 하지만 스크립트를 찾아낸 뒤, 해석을 행합니다만, 변수 $running_under_some_shell 가 실로 될 것은 없기 때문에, 2 행 째를 무시합니다. 파일명 등에 포함되는 스페이스를 올바르게 취급하려면 ,$* 보다 ${1+"$@"} (분)편이 좋을 것입니다가, csh 가 해석하는 경우에는 동작하지 않습니다. csh 는 아니고 sh 로 기동하려면 , 어느 시스템에서는 #! 행을, perl 로 무시되는 코론에만 고쳐 쓸 필요가 있을지도 모릅니다. 그 외의 시스템에서는 이 방법은 사용하지 못하고, 다음과 같이, csh, sh, perl 목아래에서 도 동작하는 것 같은, 매우 주위 장황한 방법을 취할 필요가 있습니다:
    	eval '(exit $? 0)' && eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
    	& eval 'exec /usr/bin/perl -S $0 $argv:q'
    		if 0;

-u  스크립트의 컴파일의 뒤, perl (은)는 코어덤프 합니다. 이 코어덤프로부터, `undump'프로그램(제공하고 있지 않습니다)을 이용해 실행 가능 파일로 변환할 수 있습니다. 이렇게 하면(자), 디스크 소비가 증가하는 대신에 (실행 파일을 strip 하면 최소로 할 수 있습니다), 스타트 업이 빨라집니다. (그러나, 나의 머신에서는 "hello world" 의 실행 형식이 약 200K 의 크기 (이)가 됩니다. ) 실행 형식을 set-id 프로그램으로서 달리게 한다면, 통상의 perl 는 아니고 아마 taintperl 를 이용해 컴파일 해야 합니다. 덤프 하기 전에 실행하고 싶은 스크립트가 있는 경우는, 대신에 dump 연산자를 사용해 주세요. 주의 : undump 를 사용할 수 있을지 어떨지는 플랫폼에 의존하므로, perl 의 이식에 따라서는 이용할 수 없는 것도 있을지도 모릅니다.

-U  안전하지 않은 조작을 가능하게 합니다. 현재의 곳,"안전하지 않다" 조작이란, 슈퍼 유저 권한에서의 실행시에 디렉토리를 unlink 하는 것, 및 더러운 체크로 경고가 나오는 것 같은 setuid 프로그램을 달리게 하는 것 뿐입니다.

-v  perl 의 버젼과 패치 레벨을 출력합니다.

-w  한 번만 나오는 식별자, 세트 하기 전에 사용되는 스칼라 변수에 대해서, 경고를 냅니다. 써브루틴이 재정의되었을 때, 정의되어 있지 않은 파일 핸들의 참조 (이)가 있을 때, 리드온리-로 오픈한 파일 핸들에 기입하려고 했을 때에도 경고를 냅니다. 수치에서는 없을 것 같은 값에 == 를 사용했을 때나, 써브루틴이 100 회 이상 재귀 했을 때에도 경고를 냅니다.

-x디렉토리
    스크립트가 메세지에 파묻히고 있는 것을 perl 에 알립니다. #! 그리고 시작되어,"perl" 라고 하는 캐릭터 라인을 포함한 최초의 행이 나타난다 까지는, 쓰레기로서 무시됩니다. 그 행으로 지정한 의미가 있는 스윗치는 모두 적용됩니다 (다만 통상의 #! 처리와 같이, 스윗치의 덩어리 하나 뿐입니다). 디렉토리명을 지정하면(자), perl 는 스크립트를 실행하기 전에 그 디렉토리로 옮깁니다. -x 스윗치는, 선두의 쓰레기를 버릴 뿐입니다. 스크립트의 뒤에 쓰레기가 있는 경우는, 스크립트는 __END__ 그리고 끝내지 않으면 안됩니다 (바란다면, 스크립트로 뒤의 쓰레기의 일부 또는 전부를 파일 핸들 DATA 경유로 처리하는 것이 가능합니다).

  데이터의 형태와 오브젝트

perl 에는 3 종류의 데이터형이 있는: 스칼라, 스칼라 배열, 및 연상 배열입니다. 통상의 배열은 첨자가 숫자입니다만, 연상 배열의 경우는 캐릭터 라인입니다.

perl 에 있어서의 연산이나 값의 해석은, 연산이나 값의 문맥(문맥)으로부터의 요구 에 자주 의존합니다. 주된 문맥은 세 개: 즉 캐릭터 라인, 수치, 배열입니다. 연산안에는, 배열을 요구하는 문맥에서는 배열을, 그렇지 않으면 스칼라치를 돌려주는 것도 있습니다. (그러한 연산자에 대해서는 문서내의 그 연산자의 곳에 기재되어 있습니다. ) 스칼라치를 돌려주는 연산자는, 문맥이 캐릭터 라인 혹은 수치의 어느 쪽을 요구하고 있을까는 고려합니다만, 스칼라 변수 및 스칼라치는 캐릭터 라인 혹은 수치의 문맥의 적절한 (분)편으로 해석됩니다. 스칼라는 그것이 눌 캐릭터 라인 혹은 0 이 아니면 논리적으로 진이라고 해석됩니다. 연산자가 돌려주는 논리치는, 진정한 경우는 1, 가짜의 경우는 0 또는 '' (눌 캐릭터 라인)입니다.

실제로는, 눌 캐릭터에는 2종류있습니다. define 와 undefined 입니다. undefined 의 눌 캐릭터 라인은, 에러, 파일 종단, 초기화되어 있지 않은 변수나 배열 요소를 참조하려고 했을 때 등, 실제의 값이 존재하지 않는 경우에 돌아갑니다. undefined 의 눌 캐릭터 라인은, 최초로 거기에 액세스 했을 때에 defined 가 된다 일이 있습니다만, 그 전에 defined() 연산자를 이용해 값이 defined 화도 인지를 알 수가 있습니다.

스칼라 변수에의 참조는, 그것이 배열의 일부에서 만나도, 항상 '$' 그리고 시작합니다. 즉 이러합니다:
    $days	# 단순한 스칼라 변수
    $days[28]	# 배열 @days 의 29 번째의 요소
    $days{'Feb'}# 연상 배열의 값의 하나
    $#days	# 배열 @days 의 마지막 첨자
그러나, 배열 전부나 일부의 취득은 '@'로 시작합니다:
    @days	# ($days[0], $days[1],. . .  $days[n])
    @days[3,4,5]# @days[3. . 5] 로 같다
    @days{'a', 'c'}# ($days{'a'}, $days{'c'})와 같다
그리고, 연상 배열 전부를 취급하려면 '%'로 시작합니다:
    %days	# (key1, val1, key2, val2 . . . )

이것들 8 개(살)은 모두 좌변치로서 취급할 수가 있습니다. 즉, 대입 가능 그렇다고 하는 것입니다. (게다가 어느 문맥에서는 대입 조작 자체도 좌변치가 될 수 있습니다. -- s, tr, chop 의 예를 참조해 주세요. ) 스칼라에의 대입을 행하면(자), 우변을 스칼라의 문맥으로 평가하는데 대해, 배열이나 배열의 일부에의 대입은 우변을 배열의 문맥으로 평가합니다.

배열 @days 의 길이를 csh (와)과 같이 "$#days" 로 평가해도 괜찮습니다. (실제로는, 통상 0 번째의 요소가 있으므로, 배열의 길이가 아니고, 마지막 요소 의 첨자가 됩니다. ) $#days 에 대입하면(자), 배열의 길이가 바뀝니다. 이 방법에 따라 배열을 작게 해도, 실제로는 값은 파괴되지 않습니다. 벌써 작게 한 배열을 크게 하면(자), 원래 있던 요소가 원래대로 돌아갑니다. 커질 것 같은 배열을 미리 크게 해 두면(자), 효율을 얼마인가 잘 할 수도 있습니다. (배열을 크게 하려면 , 배열의 최후를 넘는 요소에 대 입을 행하는 방법도 있습니다. 이 방법과 $#whatever 에 대입하는 방법과의 차이는, 사이의 요소에 눌이 세트 되는 것입니다) 배열을 줄여 비우려면 , 누르리스트 ()를 대입하면 할 수 있습니다. 다음의 두 개는 완전히 동등이 됩니다.
	@whatever = ();
	$#whatever = $[ - 1;

배열을 스칼라의 문맥으로 평가하면(자), 배열의 길이가 돌아갑니다. 다음의 식은 항상 진이 됩니다:
	scalar(@whatever) == $#whatever - $[ + 1;
연상 배열을 스칼라의 문맥으로 평가하면(자), 배열이 요소를 포함한 경우 한편 그 경우에 한정해 진정한 값을 돌려줍니다. (요소가 있는 경우에 돌아가는 값은, 사용하고 있는 bucket 의 수 및 allocate야 라고 있는 bucket 의 수로부터 완성되는 캐릭터 라인으로,/ 그리고 단락지어집니다. )

다차원 배열은 직접은 서포트되고 있지 않습니다만, 연상 배열을 이용해 복수의 첨자를 에뮤레이트 하는 방법에 대해서는,$; 변수의 항을 참조해 주세요. 다차원의 첨자를 1 차원의 첨자로 변환하는 써브루틴을 쓰는 일도 할 수 있습니다.

각각의 데이터형에 응해, 각각의 이름 공간이 있습니다. 충돌을 걱정한다 무사히, 같은 이름을 스칼라 변수, 배열, 연상 배열, 파일 핸들, 써브루틴명, 또는 label에 붙일 수가 있습니다. 변수나 배열에의 참조는 항상 '$', '@', '%' 그리고 시작되므로,"예약" 어는 변수명에 대해서는 실제로는 사용 가능합니다. (그러나, label나 파일 핸들에 대해서는 예약어(reserved word)는 사용할 수 없습니다. 특수한 캐릭터로 시작되지 않기 때문입니다.
힌트: open(log,'logfile')보다 open(LOG,'logfile')를 사용하는 것이 좋습니다. 대문자의 파일 핸들명을 사용하면(자), 읽기 쉬움도 향상해, 장래의 예약어(reserved word)가 되는 것이라는 충돌도 피할 수가 있기 때문입니다. ) 대문자 소문자의 구별은 중요합니다 --"FOO", "Foo", "foo" 는 모두 다르다 이름입니다. 알파벳으로 시작되는 이름은 숫자나 밑줄을 포함해도 괜찮습니다. 알파벳으로 시작되지 않는 이름은 1 캐릭터에 한정됩니다. 예를 들면,"$%" 나 "$$" 입니다. (대부분의 한 글자명은 perl 의 예약 변수로서 의미가 있습니다. 자세한 것은 잠시 후에 말합니다. )

수치 캐릭터 라인은 통상의 부동 소수점이나 정수의 형식에서 지정합니다.
    12345
    12345.67
    . 23E-10
    0xffff	# 16 진
    0377	# 8 진
    4_294_967_296
캐릭터 라인은 싱글 쿼트 또는 더블 쿼트로 단락지어집니다. 동작은 쉘에 있어서의 쿼트와 잘 닮았습니다. 더블 쿼트로 둘러싸인 캐릭터 라인에는 backslash나 변수의 치환이 행해집니다. 싱글 쿼트로 둘러싸인 캐릭터 라인에는 행해지지 않습니다 (\'와 \\ 를 제외합니다). 통상의 backslash 규칙이 개행이나 탭등의 캐릭터를 나타내는데 사네, 더욱 이하의 조금 바뀐 형식도 사용할 수 있습니다:
	\t		탭
	\n		개행
	\r		리턴
	\f		form feed
	\b		백 스페이스
	\a		알람 (벨)
	\e		이스케이프
	\033		8진캐릭터
	\x1b		16진캐릭터
	\c[		컨트롤 캐릭터
	\l		다음의 캐릭터를 소문자로 합니다
	\u		다음의 캐릭터를 대문자로 합니다
	\L		\E 까지를 소문자로 합니다
	\U		\E 까지를 대문자로 합니다
	\E		대소 캐릭터의 수식의 끝
개행을 직접 캐릭터 라인에 기입할 수도 있습니다. 즉, 캐릭터 라인은 시작되었다 행과 다른 행으로 끝날 수가 있게 됩니다. 이것은 편리합니다만, 마지막에 쿼트를 잊으면(자), 쿠트함 벗기고 되어 떨어진 다른 행을 찾아낼 때까지 perl (은)는 에러를 보고하지 않을 것입니다. 캐릭터 라인내의 변수 치환은 스칼라 변수, 통상의 배열, 배열의 일부에 한정됩니다. (바꾸어 말하면(자),$ 나 @ 로 시작되는 식별자와 거기에 괄호로 둘러싸인 첨자가 어느 경우만입니다. ) 다음의 코드는 "The price is $100. " 를 출력합니다.
    $Price = '$100';# 해석되지 않습니다
    print "The price is $Price.\n";# 해석됩니다
후에 계속되는 알파벳이나 숫자와 구별하기 위해서, 식별자를 {} 로 둘러싼다 일이 생기는 것을 기억해 두어 주세요. 또, 싱글 쿼트는 식별자로서 유효한 캐릭터이기 (위해)때문에, 싱글 쿼트로 둘러싸인 캐릭터 라인은, 전의 단어와는 공백에서 단락지어져 없으면 안 되는 것도 기억해 둡시다 (패키지의 항을 참조해 주세요).

프로그램의 그 시점에서의 행 번호와 파일명을 나타낸다 __LINE__ 와 __FILE__ 라고 하는 두 개의 특수한 캐릭터가 있습니다. 이것들은 독립한 토큰으로서의 보고 사용할 수 있어 캐릭터 라인중에 기입할 수 없습니다. 한층 더 토큰 __END__ 는, 실제의 파일이 종료하기 전으로, 스크립트 의 논리적인 종료를 나타내기 위해서(때문에) 사용할 수 있습니다. 나머지의 텍스트는 모두 무시됩니다만, 파일 핸들 DATA 로부터 읽을 수가 있습니다. (파일 핸들 DATA 는, 메인 스크립트로부터 마셔 데이터를 읽어들일 수 있습니다만, require 된 파일이나 평가된 캐릭터 라인으로부터는 읽어들일 수 없습니다. ) ^D 와 ^Z 의 두 개의 컨트롤 캐릭터는 __END__ 와 동의가 됩니다.

문법적으로 해석 불가능한 단어는, 그것이 싱글 쿼트로 둘러싸여 있다 인가와 같이 다루어집니다. 이 때문에, 알파벳, 숫자, 밑줄만으로부터 되어, 단어는 알파벳으로 시작되지 않으면 안됩니다. 파일 핸들이나 label와 같이, 소문자만으로부터 되는 알몸의 단어는, 장래의 예약어(reserved word)와 충돌하는 위험이 있습니다. -w 스윗치를 사용하면, perl 는 그러한 단어에 대해 경고해 줍니다.

배열치를 더블 쿼트로 둘러싸인 캐릭터 라인에 넣었을 경우는, 배열의 전요소를 $" 변수로 지정되는 단락 (디폴트는 공백)으로 연결해 한데 합쳤다 캐릭터 라인이 됩니다. (3.0 이전의 버젼의 perl 에서는,@ 은 더블 쿼트로 둘러싸인 캐릭터 라인 안의 메타캐라크타는 아니었기 때문에, @array, $array[EXPR], @array[LIST], $array{EXPR}, @array{LIST} 의 캐릭터 라인에의 삽입은, 배열이 프로그램의 어디선가 참조되고 있는 경우, 혹은 예약되고 있다 경우에게만 일어납니다. ) 다음의 두 개는 동등하게 됩니다.
	$temp = join($", @ARGV);
	system "echo $temp";
	system "echo @ARGV";
검색 패턴 (이것에도 더블 쿼트와 같은 치환이 행해집니다)에 두어서는, 애매한 경우가 있습니다. /$foo[bar]/ 는 /${foo}[bar]/ ([bar]는 정규 표현의 캐릭터 클래스)입니까, 그렇지 않으면 /${foo[bar]}/ ([bar]는 배열 @foo 의 첨자)일까요. @foo 가 존재하지 않으면, 그것은 분명하게 캐릭터 클래스입니다. @foo 가 존재한다면, perl 는 [bar]에 대해 생각해 대체로의 경우 올바른 유추를 합니다. 그것이 잘못되어 있거나 당신이 단지 편집광이라면, 상기와 같이 안괄호 {} 를 넣는 것으로, 올바른 해석을 시킬 수가 있습니다.

행 지향의 인용법은 쉘과 같은 문법에 근거하고 있습니다. << 의 후에 인용문의 마지막을 나타내는 캐릭터 라인을 지정하면(자), 현재행으로부터 그 캐릭터 라인 하지만 나타날 때까지의 행 모든 것이 그 값이 됩니다. 마지막을 나타내는 캐릭터 라인은 식별자 (단어)에서도, 쿼트 된 텍스트에서도 괜찮습니다. 쿼트 되고 있는 텍스트의 경우, 통상 쿠트로 둘러싸는 경우와 같이 쿼트의 종류가 텍스트의 취급 방법을 결정합니다. 쿠트되어 있지 않은 식별자 (은)는 더블 쿼트 되고 있는 경우와 같은 동작이 됩니다. (스페이스를 들어갈 수 있었을 경우, 그것은 유효한 눌 식별자로서 다루어져 최초의 공행에 매치 합니다. --아래의 Merry Christmas 의 예를 봐 주세요. ) 마지막을 나타내는 캐릭터 라인은 그 만큼으로 (쿼트 되지 않고, 공백을 전후 조림 하지않고서) 쓰여지지 않으면 안됩니다.
	print <<EOF;		# 전의예와 같습니다
The price is $Price.
EOF
	print <<"EOF";		# 위의 예와 같습니다
The price is $Price.
EOF
	print << x 10;		# 눌 식별자가 마지막을 나타냅니다
Merry Christmas!
	print <<`EOC`;		# 명령을 실행합니다
echo hi there
echo lo there
EOC
	print <<foo, <<bar;	# 스택에 쌓을 수가 있습니다
I said foo.
foo
I said bar.
bar
배열의 리터럴은, 개개의 값을 콤마로 단락지어, 리스트를 괄호로 둘러쌉니다:
	(LIST)
배열치를 요구하지 않는 문맥에서는,C 의 콤마 연산자와 같이, 마지막 요점 소의 값이 배열의 값이 됩니다. 예를 들면,
    @foo = ('cc', '-E', $bar);
(은)는 배열 foo 에 전배열치를 대입합니다만,
    $foo = ('cc', '-E', $bar);
(은)는 변수 bar 의 값을 변수 foo 에 대입합니다. 변수로서 실제로 존재하는 배열의 스칼라의 문맥으로서의 값은, 배열의 길이가 되는 것에 주의해 주세요. 다음의 예에서는 $foo 에 3 를 대입합니다:
    @foo = ('cc', '-E', $bar);
    $foo = @foo;		# $foo (은)는 3 이 됩니다
배열 리터럴의 괄호를 닫기 전에 여분의 콤마가 있어도 괜찮아, 이하와 같이 쓸 수 있습니다:
    @foo = (
	1,
	2,
	3,
    );
리스트가 평가될 때, 리스트의 요소는 모두 배열의 문맥으로서 평가되어 결과적으로 얻을 수 있는 배열치에, 개개의 요소가 리스트의 멤버로 있었는지와 같이 리스트에 삽입됩니다. 예를 들어,@foo 의 모든 요소,@bar 의 모든 요소, 써브루틴 SomeSub 하지만 돌려주는 모든 요소를 포함한 리스트--이하
    (@foo,@bar,&SomeSub) 중(안)에서는, 배열의 식별을 할 수 없게 됩니다.

리스트의 값은 통상의 배열과 같게 첨자를 붙여 사용할 수 있습니다. 례:
	$time = (stat($file))[8];	# stat (은)는 배열치를 돌려줍니다
	$digit = ('a','b','c','d','e','f')[$digit-10];
	return (pop(@foo),pop(@foo))[0];

배열의 리스트는, 그 모든 요소가 좌변치일 때 한계 대입 가능합니다:
    ($a, $b, $c) = (1, 2, 3);
    ($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);
마지막 요소는 배열이나 연상 배열이어도 괜찮습니다:
    ($a, $b, @rest) = split;
    local($a, $b, %rest) = @_;
실제로는, 리스트의 어디에 배열을 넣어도 괜찮습니다만, 리스트중의 최초의 배열이 모든 값을 묻어 버리므로, 그 후의 요소는 눌의 값이 됩니다. 이것은 local() 에 두어 편리할지도 모릅니다.

연상 배열의 리터럴은, 키와 값으로 해서 해석되는 값의 조를 포함하고 있습니다:
    # 상기 map 에의 대입과 같다
    %map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
스칼라의 문맥에의 배열의 대입은, 대입의 우변의 식에 의해 생성된다 요소의 수를 돌려줍니다:
	$x = (($foo,$bar) = (3,2,1));	# $x 에 2 나오지 않게 3 를 세트

알아 두지 않으면 안 되는 몇개의 유사 리터럴이 있습니다. 캐릭터 라인을 `` (저엑센트) 로 둘러쌌을 경우, 정확히 더블 쿼트와 같은 변수 치환이 행해집니다. 다음에 쉘안과 같이, 명령이라고 해석되어 그 명령의 출력이 이 의사 리터럴의 값이 됩니다. 스칼라의 문맥에서는, 전출력으로부터 완성되는 하나의 캐릭터 라인이 돌려주어집니다. 배열의 문맥에서는, 출력의 각 행이 각각 하나의 요소가 된 배열치 하지만 돌려주어집니다. (행 터미네이터를 바꾸고 싶은 경우에는,$/ 을 세트 할 수 있습니다. ) 명령은 의사 리터럴이 평가될 때마다 실행됩니다. 커멘드의 반환값 (은)는,$? 에 돌려주어집니다 ($? 의 해석에 대해서는 예약 변수의 섹션을 참조해 주세요). csh 의 경우와 달리, 돌려주어지는 데이터에 치환은 행해지지 않습니다 -- 개행은 개행으로서 남습니다. 어느 쉘과도 달라, 싱글 쿼트로 둘러싸도 명령내의 변수명은 해 석 되어 버립니다. $ (을)를 쉘에 건네주려면 , backslash가 필요합니다.

열쇠 괄호 <> 에 둘러싸인 파일 핸들을 평가하면(자), 그 파일로부터 다음의 행을 읽어들입니다 (개행이 포함되기 (위해)때문에 EOF 까지는 결코 가짜에 되지 않습니다. EOF 에서는 undefined 치가 돌아갑니다). 통상은 그 값을 변수에 대입할 필요가 있습니다만, 하나만 자동적으로 대입이 일어나는 상황이 있습니다. 입력 심볼만이 while 루프의 조건문안에 있는 경우는(그리고 이 경우에 한해), 값은 변수 "$_" 에 자동적으로 대입됩니다. (기묘하게 생각할지도 모릅니다만, 대부분의 perl 스크립트에 대해, 이 구문을 사용하게 되겠지요. ) 어쨌든, 다음의 예는 모두 동등이 됩니다.
    while ($_ = <STDIN>) { print; }
    while (<STDIN>) { print; }
    for (;<STDIN>;) { print; }
    print while $_ = <STDIN>;
    print while <STDIN>;
파일 핸들 STDIN, STDOUT, STDERR (은)는 예약되고 있습니다. (파일 핸들 stdin, stdout, stderr 그렇지만 동작합니다만, 패키지 중(안)에서는 글로벌은 아니고 로컬인 식별자 (으)로서 해석되므로, 일하지 않습니다. ) 이외의 파일 핸들은, open 함수로 작성할 수 있습니다.

배열을 찾는 문맥 중(안)에서 <FILEHANDLE> 가 사용되면(자), 모든 입력행 의 일행이 한 요소인 배열이 돌아갑니다. 이 방법으로*거대*인 데이터 공간이 간단 에 만들어지므로, 주의해 사용해 주세요.

누르파이르한돌 <> 은 특수해, sed 나 awk 의 동작을 에뮤레이트 하기 위해서 사용할 수 있습니다. <> (으)로부터의 입력에는, 표준 입력이나 명령행에 늘어놓을 수 있었던 전파일이 들어갑니다. 동작의 방법은 이렇게 됩니다. <> 의 최초의 평가에서는, ARGV 배열이 체크되어 그것이 눌이라고, $ARGV[0] 은 표준 입력을 오픈하는 '-' 에 세트 됩니다. 다음에 ARGV 배열이 파일명의 리스트로서 처리됩니다. 다음의 루프는,
	while (<>) {
		. . . 			# 각 행에 대한 코드
	}
이하의 유사 코드와 동등하게 됩니다.
	unshift(@ARGV, '-') if $#ARGV < $[;
	while ($ARGV = shift) {
		open(ARGV, $ARGV);
		while (<ARGV>) {
			. . . 		# 각 행에 대한 코드
		}
	}
전자는, 쓰는 것이 귀찮지 않다고 하는 것만으로, 똑같이 동작합니다. 실제로는, 전자에서도 배열 ARGV 를 shift 해, 현재의 파일명을 변수 ARGV 에 대입합니다. 내부에서는, 파일 핸들 ARGV 를 사용합니다 --<> 는, 마술적인 <ARGV> 멈춘 구동의입니다. (위의 유사 코드에서는,<ARGV> 을 마술적이지 않은 것으로서 취급하므로, 움직이지 않습니다)

파일명의 리스트의 배열이 남아 있는 한, 최초의 것 <> 의 전에 @ARGV 를 변경할 수가 있습니다. 행 번호 ($. )(은)는 입력이 하나의 큰 파일인것 같이 증가해 갑니다. (파일마다행 번호를 리셋트 하는 방법에 대해서는 eof 의 예를 참조해 주세요. )

@ARGV 에 스스로 파일의 리스트를 세트 하고 싶은 경우는, 그렇게 해서 주세요. 스크립트에 스윗치를 건네주고 싶은 경우, 스크립트의 앞쪽에 다음과 같은 루프를 두는 것으로 할 수 있습니다:
	while ($_ = $ARGV[0], /^-/) {
		shift;
	    last if /^--$/;
		/^-D(. *)/ && ($debug = $1);
		/^-v/ && $verbose++;
		. . . 		# 다른 스윗치
	}
	while (<>) {
		. . . 		# 각 행에 대한 코드
	}
<> 심볼은 1회만*가짜*를 돌려줍니다. 그 후, 한번 더 부르면(자), 다른 @ARGV 리스트를 처리하고 있으면(자) 간주라고, @ARGV 가 세트되어 있지 않은 경우는 STDIN (으)로부터 입력되게 됩니다.

열쇠 괄호안의 캐릭터 라인이 스칼라 변수에의 참조일 때 (예를 들면 <$foo>), 그 변수의 내용이 읽어들여야 할 파일 핸들명이 됩니다.

열쇠 괄호안의 캐릭터 라인이 파일 핸들은 아닐 때, 검색 (glob)된다 파일 패턴이라고 해석되어 문맥에 의해 파일명의 배열 또는 리스트안의 다음의 파일이 돌려주어집니다. 최초로 $ 의 해석의 1 레벨이 행해집니다만,<$foo> 는 전의 단락으로 설명된 것 같은 간접 파일 핸들이 되기 (위해)때문에 사용할 수 없습니다. 강제적으로 파일명 검색이라고 해석시키고 찢어지면 <${foo}> 와 같이 안괄호 {} 를 삽입할 수 있습니다. 례:
	while (<*. c>) {
		chmod 0644, $_;
	}
(은)는 이하와 등가입니다.
	open(foo, "echo *. c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
	while (<foo>) {
		chop;
		chmod 0644, $_;
	}
실제, 현재로서는 이와 같이 실장되고 있습니다. (이것은, 머신상에 /bin/csh 가 없으면, 공백을 포함한 파일명에서는 움직이지 않는 것을 의미합니다. ) 물론, 위의 조작을 행하는 제일 짧은 방법은,
	chmod 0644, <*. c>;
입니다.

  문법

perl 스크립트는, 일련의 선언과 명령로부터 됩니다. perl 중(안)에서 선언되지 않으면 안 되는 것은, 리포트 포맷과 써브루틴입니다. 이러한 선언의 자세한 설명은 아래의 섹션을 참조해 주세요. 초기화되어 있지 않은 유저가 작성한 오브젝트는, 그것이 대입과 같이 명시적으로 정의될 때까지는, 눌 또는 0 의 값이다고 보입니다. 명령열이 각 입력행에 대해서 실행된다 sed (이)나 awk 스크립트와 달리, 명령열은 한 번만 실행됩니다. 입력 파일 (또는 복수의 파일)의 각 행에 대해 반복을 실시하려면 명시적으로 루프를 마련하지 않으면 안됩니다만, 주목하는 파일, 행을 보다 좋게 컨트롤 할 수가 있습니다. ( 실은, 올바르지는 않습니다 -- -n (이)나 -p 스윗치로, 암묵의 루프를 행할 수가 있습니다. )

선언은, 명령을 쓸 수가 있는 장소라면 어디에라도 쓸 수가 있습니다만, 명령 실행의 기본적인 흐름에는 영향을 주지 않습니다 -- 선언은, 컴파일시인 만큼 밖에 영향을 주지 않습니다. 통상, 모든 선언은 스크립트의 최초인가 마지막 어딘가에 둡니다.

perl (은)는, 대부분의 부분에 있어 자유형식 언어입니다. (유일한 예외는 포맷 선언으로, 이유는 실로 명백합니다. ) 코멘트는,# 캐릭터로 지시받아 줄 끝까지됩니다. /* */ 그렇다고 하는 C 의 코멘트를 사용하려고 하면(자), 문맥에 의해 제산 또는 패턴 매치라고 해석되므로, 그런 것은하지 마세요.

  복합문
perl 그럼, 복수의 명령열을 안괄호 {} 로 둘러싸는 것으로, 하나의 커멘드로서 취급하게 되어, 이것을 블록이라고 부릅니다.

다음과 같은 복합 명령은, 플로우(flow) 컨트롤에 사용됩니다:
	if (EXPR) BLOCK
	if (EXPR) BLOCK else BLOCK
	if (EXPR) BLOCK elsif (EXPR) BLOCK . . .  else BLOCK
	LABEL while (EXPR) BLOCK
	LABEL while (EXPR) BLOCK continue BLOCK
	LABEL for (EXPR; EXPR; EXPR) BLOCK
	LABEL foreach VAR (ARRAY) BLOCK
	LABEL BLOCK continue BLOCK
C 나 Pascal 와 달리, 이것들은 문장은 아니고*블록*으로서 정의되고 있는 와 (와)과에 주의해 주세요. 이것은, 안괄호 {} 가, 필요한 일을 의미합니다 -- 하나의 문장을 두는 것은 용서되지 않습니다. 안괄호 {} 없음으로 쓰고 싶은 경우는, 다른 방법이 있습니다. 이하는 모두 동등을 행합니다:
	if (! open(foo)) { die "Can't open $foo: $! "; }
	die "Can't open $foo: $! " unless open(foo);
	open(foo) || die "Can't open $foo: $! ";	# foo 가 아니면 마지막
	open(foo) ?  'hi mom' : die "Can't open $foo: $! ";
				# 마지막 것은, 조금 이그조틱

if 문장은 단순합니다. *블록*은, 항상 안괄호 {} 로 둘러싸이기 (위해)때문에, else 하지만, 어느 if 에 걸리는가 하는 애매함은 생기지 않습니다. unless (을)를 if 대신에 사용하면(자), 역의 의미가 됩니다.

while 문장은, 식이 진 (눌 캐릭터 라인 또는 0 이 아니다)인 한, 블록을 계속 실행합니다. 식별자와 코론으로부터 되는 label를 붙일 수도 있습니다. label는 루프 제어문 next, last, redo (이하를 참조) 에 의해 지시하는 루프의 이름이 됩니다. continue 블록이 있으면(자), 조건문이 재평가되기 전에 반드시 실행되어 C 에 있어서의 for 루프의 3번째의 부분과 같이됩니다. 이렇게 해, 비록 next 문장으로 계속되었을 경우에서도 루프 변수는 인크리먼트(increment) 할 수 있게 됩니다 (C 의 "continue" 문과 같다).

while 하지만 until (으)로 옮겨지면(자) 테스트의 의미는 거꾸로 됩니다만, 조건 판단은 최초의 루프 의 전에 행해집니다.

if (이)나 while 문장에서는,"(EXPR)" 를 블록에 옮겨놓을 수가 있어 블록의 마지막 명령의 값이 진이라면, 조건 판단은 진이 됩니다.

for 루프는, 대응한다 while (와)과 완전히 똑같이 동작합니다:
	for ($i = 1; $i < 10; $i++) {
		. . .
	}
(은)는, 이하와 같게 됩니다.
	$i = 1;
	while ($i < 10) {
		. . .
	} continue {
		$i++;
	}

foreach 루프는, 통상의 배열치에 대해, 배열의 각 요소를 변수 VAR 에 순서에 세트 하면서 반복합니다. 그 변수는, 루프에 대해서 암묵중에 로컬이며, 그 이전의 값은 루 프를 빠지면(자) 원의 값으로 돌아옵니다. "foreach" 키워드는, 실은 "for" 키워드와 같아, "foreach" 를 가독성을 위해서(때문에),"for" 를 간결함을 위해서(때문에) 사용할 수가 있습니다. VAR 가 생략 되면(자),$_ 가 각 치에 세트 됩니다. ARRAY 가 실제의 배열 (배열을 돌려주는 식은 아니고)의 경우, 루프내의 VAR 를 변 갱 하는 것에 의해, 배열의 각 요소를 변경할 수가 있습니다. 례:
	for (@ary) { s/foo/bar/; }
	foreach $elem (@elements) {
		$elem *= 2;
	}
	for ((10,9,8,7,6,5,4,3,2,1,'BOOM')) {
		print $_, "\n"; sleep(1);
	}
	for (1..15) { print "Merry Christmas\n"; }
	foreach $item (split(/:[\\\n:]*/, $ENV{'TERMCAP'})) {
		print "Item: $item\n";
	}

블록 그것 자신 (label가 붙어 있어도, 붙지 않아도)은, 한 번 만 실행되는 루프와 등가입니다. 그러니까, 블록을 빠지거나 재실행하기 위해서, 모든 루프 제어문을 사용한다 일이 생깁니다. continue 블록도 붙일 수 있습니다. 이 구성은, case 구조를 작성하려면 특히 유용합니다.
	foo: {
		if (/^abc/) { $abc = 1; last foo; }
		if (/^def/) { $def = 1; last foo; }
		if (/^xyz/) { $xyz = 1; last foo; }
		$nothing = 1;
	}
동등의 것을 기술할 방법이, 이미 얼마든지 있으므로, perl 에는 공식의 switch 문이 없습니다. 상기의 것에 가세해,
	foo: {
		$abc = 1, last foo  if /^abc/;
		$def = 1, last foo  if /^def/;
		$xyz = 1, last foo  if /^xyz/;
		$nothing = 1;
	}
또는
	foo: {
		/^abc/ && do { $abc = 1; last foo; };
		/^def/ && do { $def = 1; last foo; };
		/^xyz/ && do { $xyz = 1; last foo; };
		$nothing = 1;
	}
또는
	foo: {
		/^abc/ && ($abc = 1, last foo);
		/^def/ && ($def = 1, last foo);
		/^xyz/ && ($xyz = 1, last foo);
		$nothing = 1;
	}
한층 더
	if (/^abc/)
		{ $abc = 1; }
	elsif (/^def/)
		{ $def = 1; }
	elsif (/^xyz/)
		{ $xyz = 1; }
	else
		{$nothing = 1;}
(와)과도 쓸 수 있습니다. 이것들은 모두 내부에서 switch 구조에 최적화되기 (위해)때문에, perl 는 직접 목적의 문장에 점프 하므로, 같은 단순한 스칼라 변수를 == 이나 eq 나 상기와 같은 패턴 매치로 판정하는 한, 50 개의 elsif 를 사용해도 perl 가 많이 의 불필요한 문장을 실행하는 것은, 이라고 하는 걱정은 불필요해집니다. (어느 특정의 case 스테이트먼트가 최적화되고 있는지 어떤지에 흥미가 있다면, -D1024 스윗치를 붙여 실행전에 문법 트리를 표시할 수가 있습니다. )

  단문
단문만이 그 부작용이 평가되는 식이 됩니다. 어느 단문도 블록의 마지막 문장이 아닌 한, 세미콜론으로 끝나지 않으면 되지 않습니다. 마지막 문장에서는, 세미콜론은 없어도 괜찮습니다. (그런데도, 블록이 일행 이상을 포함하고 있다면, 세미콜론은 있는 것이 바람직합니다)

어느 단문도, 세미콜론으로 끝나기 전에 하나의 수식자를 계속할 수가 있습니다. 가능한 수식자는 이하와 같습니다:
	if EXPR
	unless EXPR
	while EXPR
	until EXPR
if (와)과 unless 수식자는 외관 그대로의 의미가 있습니다. while (와)과 until 수식자도 외관 그대로의 의미 (조건문이 초에 평가됩니다)입니다만, do 블록이나 do 써브루틴 명령을 붙일 수 있었을 때에는 달라, 조건식이 평가되기 전에 한 번만 실행됩니다. 이것은, 이하와 같은 루프를 기술할 수 있도록(듯이) 하기 (위해)때문입니다:
	do {
		$_ = <STDIN>;
		. . .
	} until $_ eq ". \n";
(후술의 do 연산자를 참조. 수식자는, 어느 것도 루프 label를 가질 수 없기 때문에, 후에 쓰여진 루프 제어 명령은 이 구조에서는 움직이지 않는 것에 조심해 주세요. 아무쪼록. )

  식
perl 의 식은, 거의 C 의 식과 같게 동작합니다만, 차이를 여기에 말합니다.

이하가 perl 에 있어, C 에 없는 것입니다:

**  지수 연산자.

**= 지수 대입 연산자.

()  배열을 눌에 초기화하기 위해서 사용하는, 누르리스트.

.   2 개의 캐릭터 라인의 결합 연산자.

.   결합 대입 연산자.

eq  캐릭터 라인의 동치성 (== 는 수치의 동치성). 기억하기 위해서(때문에)는,"eq" 가 캐릭터 라인이다고 생각하면 좋습니다. (상황에 따라,== 가 캐릭터 라인과 수치의 양쪽 모두의 동치성을 나타낸다 awk 에 익숙해 있는 사람은, 여기에서는 명시해야 하는 것에 조심해 주세요 ! )

ne  캐릭터 라인의 비동치성 (! = (은)는 수치의 비동치성).

lt  캐릭터 라인의 less than

gt  캐릭터 라인의 greater than

le  캐릭터 라인의 less than or equal

ge  캐릭터 라인의 greater than or equal

cmp 캐릭터 라인의 비교. -1, 0, 1 을 돌려줍니다.

<=> 수치의 비교. -1, 0, 1 을 돌려줍니다.

=~  연산에는, 검색, 변경을 디폴트로 캐릭터 라인 "$_" 에 대해서 실시하는 것 (이)가 있습니다. 이 연산자를 이용하면(자), 다른 캐릭터 라인에 대해서 그 연산을 합니다. 오른쪽의 인수는, 검색 패턴, 치환, 변환입니다. 왼쪽의 인수는, 디폴트의 "$_" 대신에 검색, 치환, 변환이 행해지는 대상이 되는 것입니다. 반환값은, 연산의 성공 여부를 나타냅니다. ( 오른쪽의 인수가 검색 패턴, 치환, 변환 이외의 식이라면, 실행시에 검색 패턴 (으)로서 해석됩니다만, 패턴은 식이 평가될 때에 컴파일 되고차라 안 되기 때문에, 명시적인 검색보다 효율적이 아닙니다. ) 이 연산자의 우선도는 단항 마이너스 연산자 (-), autoincrement/decrement (++, --)보다 낮고, 다른 어느 연산자보다 높아집니다.

!   반환값이 부정되는 것을 제외해 =~ 것과 같습니다.

x   반복 연산자. 왼쪽 오퍼랜드를 오른쪽 오퍼랜드로 지정한 회수만 반복한 캐릭터 라인을 돌려줍니다. 배열의 문맥에서는, 왼쪽 오퍼랜드가 괄호에 들어간 리스트의 경우, 리스트를 반복합니다.
    	print '-' x 80;		# 데쉬의 열을 출력합니다
    	print '-' x80;		# 부정, x80 는 식별자
    	print "\t" x ($tab/8), ' ' x ($tab%8);	# 탭에 변환
    	@ones = (1) x 80;		# 80 개 1 이 줄선 배열
    	@ones = (5) x @ones;		# 전요소를 5 에 세트

x=  반복 대입 연산자. 스칼라 에 대해서만 동작합니다.

.   범위 연산자. 문맥에 의해, 실제는 두 개가 다른 연산자가 됩니다. 배열의 문맥에서는, 왼쪽의 값으로부터 오른쪽의 값까지 한개씩수를 늘린 배열을 돌려줍니다. 이것은,"for (1..10)" 라고 하는 루프나 배열의 시작 (slice)을 행할 때 편리합니다.

    스칼라의 문맥에서는,. . (은)는 논리치를 돌려줍니다. 이 연산자는, flip-flop 와 같이 두 개의 값을 받아, sed 나 awk 나 여러가지 에디터의 행 범위 (comma) 연산자를 에뮤레이트 합니다. 각 . . 연산자는 그것 자신의 논리치를 보관 유지해, 왼쪽의 오퍼랜드가 가짜인 한 가짜가 됩니다. 왼쪽의 오퍼랜드가 실로 되면(자), 범위 연산자는, 오른쪽의 오퍼랜드가 실로 될 때까지 진이 됩니다. 그 후, 범위 연산자가 다시 가짜가 됩니다. (다음에 범위 지정 연산자가 평가될 때까지, 가짜로는 되지 않습니다. 실로 된 것과 같은 평가를 실시했을 때 (awk와 같이)에 오른쪽의 오퍼랜드를 테스트 해, 가짜가 되는 일이 있습니다만, 한 번은 진을 돌려줍니다. 다음의 평가까지 오른쪽의 오퍼랜드를 테스트하고 싶지 않으면 (sed 와 같이), 둘 (으)로 하는 대신에 세 개의 닷 (. . . )(을)를 사용해 주세요. ) 오른쪽의 오퍼랜드는, 연산자가 "가짜" 상태인 동안은, 평가되지 않고, 왼쪽의 오퍼랜드는 연산자가 "진" 인 동안은 평가되지 않습니다. || (이)나 && 보다 우선도는 약간 낮아집니다. 반환값은, 가짜에서는 눌 캐릭터 라인에, 진에서는 (1으로 시작된다) 연속한 수에 됩니다. 이 수는, 범위 지정마다 리셋트 됩니다. 연속한 범위의 마지막 수는, 캐릭터 라인 'E0'를 가지고 있어, 수치에는 영향 섬 선이, 종점을 제외하고 싶은 경우에 검색의 계기가 됩니다. 숫자가 1 보다 커지는 것을 기다리는 것으로, 시점을 제외할 수가 있습니다. 스칼라 . . 의 양쪽 모두의 오퍼랜드가 정적인 경우, 오퍼랜드는 암묵의 집에 현재의 행 번호를 나타낸다 $. 변수와 비교할 수 있습니다. 례:
    스칼라 연산자로서는:
        if (101 . .  200) { print; }	# 100행대를 출력합니다
        next line if (1 . .  /^$/);	# 헤더행을 읽어 날립니다
        s/^/> / if (/^$/ . .  eof());	# 본체를 쿼트 합니다
    배열로서는:
        for (101 . .  200) { print; }	# $_ 를 100회초 가리킵니다
        @foo = @foo[$[ . .  $#foo];	# 고가의 노 오퍼레이션
        @foo = @foo[$#foo-4 . .  $#foo];	# 마지막 5 요소를 꺼냅니다

-x  파일 테스트. 이 단항 연산자는 하나의 인수로서 파일명 또는 파일 핸들을 취 , 그 파일에 대해, 무엇인가가 진인지 어떤지를 보는 것입니다. 인수가 생략 되면(자),$_ 를 조사합니다만, 예외로서 -t 는 STDIN (을)를 조사합니다. 진정한 경우는 1 을, 가짜의 경우는 ''를 돌려주어, 파일이 존재하고 있지 않는 경우 (은)는, undefined 의 값을 돌려줍니다. 우선도는, 논리치나 관계 연산자보다 높아집니다만, 산술 연산자보다 낮아져 연산자는 이하와 같습니다:
    	-r	파일을 실효 uid/gid 로 읽어들일 수 있다.
    	-w	파일에 실효 uid/gid 로 기입할 수 있다.
    	-x	파일을 실효 uid/gid 로 실행할 수 있다.
    	-o	파일의 소유자가, 실효 uid 이다.
    	-R	파일을 열매 uid/gid 로 읽어들일 수 있다.
    	-W	파일을 열매 uid/gid 로 기입할 수 있다.
    	-X	파일을 열매 uid/gid 로 실행할 수 있다.
    	-O	파일의 소유자가, 열매 uid 이다.
    	-e	파일이 존재한다.
    	-z	파일 사이즈가 0 이다.
    	-s	파일 사이즈가 0 이 아니다 (사이즈를 돌려준다).
    	-f	파일은 프레인 파일이다.
    	-d	파일은 디렉토리이다.
    	-l	파일은 기호 연결이다.
    	-p	파일은 이름 첨부 파이프 (FIFO)이다.
    	-S	파일은 소켓이다.
    	-b	파일은 블록 특수 파일이다.
    	-c	파일은 캐릭터 특수 파일이다.
    	-u	파일에는 setuid 비트가 서 있다.
    	-g	파일에는 setgid 비트가 서 있다.
    	-k	파일에는 sticky 비트가 서 있다.
    	-t	파일 핸들이 tty 에 오픈되고 있다.
    	-T	파일은 텍스트 파일이다.
    	-B	파일은 바이노리필드이다 (-T 의 역).
    	-M	스크립트를 개시한 시점에서의 파일의 낡음(단위는 날).
    	-A	액세스 시각과 같다.
    	-C	inode 변경 시각과 같다.
    파일 퍼미션 연산자 -r, -R, -w, -W, -x, -X 의 해석은, 단지 파일의 모드와 유저의 uid, gid 에 근거합니다. 다른 이유로, 실제로 파일을 읽어, 써, 실행을 할 수 없는 것이 있을지도 알려지지 않습니다. 또, 차려인 안 되는 것은, 슈퍼 유저에게 있어 -r, -R, -w, -W 는 항상 1 을 돌려주어, 그 모드로 몇개의 실행 비트가 서 있으면, -x, -X 도 항상 1 을 돌려준다고 하는 곳(중)입니다. 따라서, 슈퍼 유저가 실행하는 스크립트는, 파일의 실제의 모드를 결정 위해(때문에) stat()를 실행하거나 일시적으로 다른 uid 를 세울 필요가 있을까 도 알려지지 않습니다.

    례:

    	while (<>) {
    		chop;
    		next unless -f $_;	# 특수 파일을 무시
    		. . .
    	}
    -s/a/b/ 라고 해도, 부정한 치환을 하는 것은 아닌 것에 주의해 주세요. -exp($foo)로 하면(자), 기대 대로에 움직입니다만,-- 마이너스의 뒤가 한 글자 의 경우, 파일 테스트라고 해석됩니다.

    -T 와 -B 는 이하와 같이 동작합니다. 파일의 선두의 블록 근처에, 이상한 컨트롤 코드나 메타캐라크타와 같은, 이상한 캐릭터가 있는지 없는지를 조사합니다. 이상한 캐릭터가 (10%이상) 발견되면(자), 그것은 -B 파일, (이)가 아니면 -T 파일이 됩니다. 최초의 블록에 눌이 포함되는 파일도 바이노리필드로 간주해집니다. -T 나 -B 가 파일 핸들에 사용되면(자), 최초의 블록이 아니고, 그 때의 표준 입력 버퍼를 조사할 수 있습니다. 누르파일(사이즈 0 의 파일)의 경우나 파일 핸들을 테스트하고 있어 , 그것이 EOF 인 경우, -T 와 -B 는 모두 진을 돌려줍니다.

모든 파일 테스트 (와 stat 연산자)는, 안 다라 인 하나 _ 로부터 완성되는 특수 파일 핸들이 주어지면(자), 시스템 콜을 보존하는 것에 따라서, 그 직전에 행해진 파일 테스트 (또는 stat 연산자)로 사원
 stat 구조체가 사용됩니다. (이 _ 의 기능은 -t 에서는 동작하지 않고, lstat 와 -l 가 stat 구조체에 열매 파일이 아니고, 기호 연결의 값을 남기는 것을 기억해 두지 않으면 안됩니다. ) 례:
	print "Can do.\n" if -r $a || -w _ || -x _;
	stat($filename);
	print "Readable\n" if -r _;
	print "Writable\n" if -w _;
	print "Executable\n" if -x _;
	print "Setuid\n" if -u _;
	print "Setgid\n" if -g _;
	print "Sticky\n" if -k _;
	print "Text\n" if -T _;
	print "Binary\n" if -B _;

C 에 있어, perl 에 없는 걸:

단항 &
    주소 연산자

단항 *
    "주소를 통한"참조 연산자

(TYPE)
    형태 변환 연산자.

C 와 같이, perl (은)는, 연산자에의 인수가 모두, 정적이어, 부작용이 없는 경우만 컴파일시에 있다 정도의 식의 평가를 행해 버립니다. 특히, 변수 치환을 행하지 않는 리터럴간에서의 캐릭터 라인의 결합은, 컴파일시에 행해집니다. backslash의 해석도 컴파일시에 일어납니다.
	'Now is the time for all' .  "\n" .
	'good men to come to. '
이것은 전부, 내부에서는 하나의 캐릭터 라인으로 되어 버립니다.

++ 연산자에는 조금 확장한 세공이 베풀어지고 있습니다. 수치 변수나 수치 문맥으로서 사용된 변수를 인크리먼트(increment) 하면(자), 통 상의 인크리먼트(increment)가 됩니다만, 변수가 눌이 아닌 캐릭터 문맥으로서 만 사용되어 와 있어, 패턴 /^[a-zA-Z]*[0-9]*$/ 에 매치 하는 경우는, 각 캐릭터의 범위를 캬 리 첨부로 보존해, 캐릭터로서 인크리먼트(increment) 됩니다:
	print ++($foo = '99');	# prints '100'
	print ++($foo = 'a0');	# prints 'a1'
	print ++($foo = 'Az');	# prints 'Ba'
	print ++($foo = 'zz');	# prints 'aaa'
-- 연산자에는, 이러한 세공은 없습니다.

(배열의 문맥에 있어서의) 범위 연산자는, 최대치와 최소치가 캐릭터 라인의 경우에, 세공한 자동 인크리먼트(increment) 알고리즘을 사용합니다. 모든 알파벳 캐릭터를 얻으려면 ,
    @alphabet = ('A' .. 'Z'); 16 진수를 얻으려면 ,
    $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15]; 초에 0 을 붙인 일자를 얻으려면 ,
    @z2 = ('01' .. '31'); print @z2[$mday]; (이)라고 쓸 수 있습니다. (마지막에 지정된 값이, 세공한 인크리먼트(increment)의 생성하는 시퀀스에 포함되지 않은 경우, 다음의 값이 마지막에 지정된 값보다 길어질 때까지 시크에 스를 계속합니다. )

|| (와)과 && 는, 0 이나 1 을 돌려주는 C 의 그것과는 달라, 마지막에 평가된 값을 돌려줍니다. 그러니까, 홈 디렉토리를 찾아내는 이식성의 높은 방법은, 이렇게 됩니다.
	$home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
	    (getpwuid($<))[7] || die "You're homeless! \n";

전술의 리터럴이나 변수에 맞춘 이후시에로 설명하는 연산은 식중에서 항으로서 사용할 수 있습니다. 이러한 연산의 몇인가는, 인수에*리스트*를 취합니다. 리스트는, 스칼라나 배열치로부터 됩니다. 배열치가 리스트안에 있으면(자), 그 자리소에 삽입된 것처럼 개개의 값이 리스트 의 안에 포함되어, 긴 일차원 배열치를 만들게 됩니다. *리스트* 의 요소는 콤마로 단락지어지지 않으면 안됩니다. 인수를 괄호로 둘러싸도 둘러싸지 않아도, 연산을 리스트 할 수 있습니다. 이것은 함수 호출과 같이 단항 연산자로서 연산을 사용할 수가 있는 것을 의미합니다. 함수 호출로서 사용하려면 , 같은 행의 다음의 토큰은 왼쪽 괄호가 아니면 되어 선. (공백이 간에는님이라고 해도 괜찮습니다. ) 그러한 함수는, 예상되는 대로 최우선이 됩니다. 왼쪽 괄호를 가지고 있지 않은 토큰이 계속된다고 하면, 그것은 단항 연산자로, 리스트 연산자인지 어떤지에 의해, 우선도가 정해집니다. 리스트 연산자는 가장 우선도가 낮아집니다. 모든 단항 연산자는, 관계 연산자보다 우선됩니다만, 산술 연산자보다 우선도는 낮아집니다. 우선도의 섹션을 참조해 주세요.

스칼라나 배열의 문맥으로 사용되는 연산자의 경우, 실패하면(자) 일반적으로, 스칼라 문맥에서는 undefined 치를 돌려주어, 배열의 문맥에서는 누르리스트를 돌려줍니다. 그러나,*리스트를 스칼라로 변환하는 일반적인 규칙은 없는* 이라고 하는 것을 잊지 말아 주세요. 각각의 연산자는, 어느 종의 스칼라를 돌려주는 것이 가장 적당한가를 결정합니다. 어느 연산자는, 배열의 문맥으로서 돌려주어지는 것 같은 리스트의 길이를 반환 조작에 성공한 회수를 돌려주는 연산자 등도 있습니다. 일반적으로, 일관성을 요구하지 않으면, 연산자는 요구하는 것을 돌려줍니다.

/PATTERN/
    m/PATTERN/ 를 참조해 주세요.

? PATTERN?
    이것은, reset 연산자 호출동안에서 1회 밖에 매치 하지 않는 것을 제외하면, /pattern/ 검색과 완전히 같습니다. 이것은 예를 들면, 한 무리의 파일 중(안)에서, 각 파일에 최초로 무엇인가가 출현하는 것 (을)를 보고 싶을 때, 편리한 최적화입니다. 그 때의 패키지에 로컬인 ?? 패턴만은, 리셋트 됩니다.

accept(NEWSOCKET, GENERICSOCKET)
    accept 시스템 콜과 같은 것을 합니다. 성공하면(자) 진을, 실패하면(자) 가짜를 돌려줍니다. 프로세스간 통신의 섹션의 예를 참조해 주세요.

alarm(SECONDS)

alarm SECONDS
    지정한 초수 (실제로는, 1 을 뺀 것)가 경과한 뒤, 자신의 프로세스에 SIGALRM 를 전합니다. 즉, alarm(15)라면, 14 초 이상 지난 어떤 시점에 SIGALRM 를 일으킵니다. 한 번에 하나의 타이머 밖에 카운트 되지 않습니다. 불려 갈 때마다 그 이전의 타이머는 무효가 되어, 인수 0 으로 호출하면(자) 이전의 타이머를 캔슬해 (이)라고, 새로운 타이머는 시동하지 않습니다. 반환값은, 직전의 타이머의 남은 시간입니다.

atan2(Y, X)
    Y/X 의 arctangent를 -π 로부터 π 의 범위에서 돌려줍니다.

bind(SOCKET, NAME)
    bind 시스템 콜과 같은 것을 합니다. 성공하면 진을, 실패하면 가짜를 돌려줍니다. NAME 는, 소켓에 맞은 적절한 형태의 pack 된 주소가 아니면 안됩니다. 프로세스간 통신의 섹션의 예를 참조해 주세요.

binmode(FILEHANDLE)

binmode FILEHANDLE
    바이노리필드와 텍스트 파일을 구별하는 operating system상 그리고, 그 파일을 "바이너리" 로서 읽히도록(듯이) 합니다. 바이너리 모드로 읽히지 않는 파일은, CR LF 가 입력시에 LF 에 변환 되어 출력시에는, LF 가 CR LF 에 변환됩니다. binmode 는, UNIX 에서는 무효입니다. FILEHANDLE 가 식 때는, 값이 파일 핸들의 이름으로서 다루어집니다.

caller(EXPR)

caller
    현재의 써브루틴 호출의 문맥을 돌려줍니다:
    	($package, $filename, $line) = caller;
    EXPR가 있으면(자), 디버거가 스택 트레이스에 출력해 사용하는 확장 정보도 돌려줍니다. EXPR의 값은, 현재의 써브루틴의 전에 몇 개의 call 프레임이 있을까를 가리킵니다.

chdir(EXPR)

chdir EXPR
    동작하고 있는 디렉토리를, 만약 할 수 있다면 EXPR 로 변경합니다. EXPR가 생략 되면(자), 홈 디렉토리가 됩니다. 성공하면 1 을, 실패하면 0 을 돌려줍니다. die 의 예를 참조해 주세요.

chmod(LIST)

chmod LIST
    파일의 리스트의 퍼미션을 변경합니다. 리스트의 최초의 요소는, 수치 모드가 아니면 안됩니다. 성공한 파일의 수를 돌려줍니다.
    	$cnt = chmod 0755, 'foo', 'bar';
    	chmod 0755, @executables;

chop(LIST)

chop(VARIABLE)

chop VARIABLE

chop
    캐릭터 라인의 마지막 캐릭터를 깎아, 깎아진 캐릭터를 돌려줍니다. 기본적으로는, 입력된 레코드의 끝부터 개행 캐릭터를 제외하기 위해서(때문에) 사용됩니다 하지만, 캐릭터 라인의 카피를 스캔 하는 것은 아니기 때문에, s/\n// 보다 효율적입니다. VARIABLE 를 생략 하면(자),$_ 를 chop 합니다. 례:
    	while (<>) {
    		chop;	# 마지막 필드의 \n 를 제외한다
    		@array = split(/:/);
    		. . .
    	}
    실제로는, 대입을 포함한 좌변치의 어떠한 것도 chop 할 수 있습니다.
    	chop($cwd = `pwd`);
    	chop($answer = <STDIN>);
    리스트를 chop 하면(자) 모든 요소가 chop 되어 마지막에 chop 된 값이 돌려주어집니다.

chown(LIST)

chown LIST
    파일의 리스트의 소유자 (와 소유 그룹)를 바꿉니다. 리스트의 최초의 두 개의 요소는 수치로 나타낸 uid 와 gid 가 이 순서로 지정되고 없으면 안됩니다. 변경에 성공한 파일의 수를 돌려줍니다.
    	$cnt = chown $uid, $gid, 'foo', 'bar';
    	chown $uid, $gid, @filenames;
    이하는, passwd 파일로부터 수치가 아닌 uid 를 검색하는 예입니다:
    	print "User: ";
    	$user = <STDIN>;
    	chop($user);
    	print "Files: "
    	$pattern = <STDIN>;
    	chop($pattern);
    open(pass, '/etc/passwd')
    		|| die "Can't open passwd: $! \n";
    	while (<pass>) {
    		($login, $pass, $uid, $gid) = split(/:/);
    		$uid{$login} = $uid;
    		$gid{$login} = $gid;
    	}
    	@ary = <${pattern}>;	# 파일을 얻습니다
    	if ($uid{$user} eq '') {
    		die "$user not in passwd file";
    	}
    	else {
    		chown $uid{$user}, $gid{$user}, @ary;
    	}

chroot(FILENAME)

chroot FILENAME
    동명의 시스템 콜과 같은 것을 합니다. 이것이 무엇을 하는지 모른다고 해도, 신경쓰지 말아 주세요. FILENAME 를 생략 하면(자),$_ 에 chroot 합니다.

close(FILEHANDLE)

close FILEHANDLE
    파일 핸들에 묶을 수 있었던 파일이나 파이프를 클로우즈 합니다. 다른 파일을 오픈하려고 하고 있는 경우는, FILEHANDLE 를 닫는다 필요가 없습니다. 오픈했을 때에 전의 파일을 클로우즈 해 준다 (으)로부터입니다. ( open (을)를 참조해 주세요) 그러나, 명시적으로 입력 파일의 클로우즈를 하면(자) 행 카운터 ($. )(이)가 리셋트 되는데 대해, open 때에 행해지는 암묵의 클로우즈에서는, 리셋트 되지 않습니다. 또, 다음에 파이프의 출력을 보고 싶은 경우는, 파이프를 클로우즈 하면(자) 파이프로 기동된 프로세스의 완료를 기다립니다. 파이프를 명시적으로 클로우즈 하면(자), 명령 정보의 반환값이 $? 에 넣을 수 있습니다. 례:
    	open(OUTPUT, '|sort >foo');	# sort 에 파이프
    	. . . 	# print stuff to output
    	close OUTPUT;		# sort 의 종료를 기다립니다
    	open(INPUT, 'foo');	# sort의 결과를 얻습니다
    FILEHANDLE 는 실제의 파일 핸들명을 주는 식에서도 괜찮습니다.

closedir(DIRHANDLE)

closedir DIRHANDLE
    opendir()로 오픈된 디렉토리를 클로우즈 합니다.

connect(SOCKET, NAME)
    connect 시스템 콜과 같은 것을 합니다. 성공하면(자) 진을, 실패하면(자) 가짜를 돌려줍니다. NAME 는 소켓에 맞은 적당한 형태의 패키지 주소가 아니면 되지 않습니다. 프로세스간 통신의 섹션의 예를 참조해 주세요.

cos(EXPR)

cos EXPR
    EXPR (라디안으로 표현)의 코사인을 돌려줍니다. EXPR 를 생략 하면(자) $_ 의 코사인을 취합니다.

crypt(PLAINTEXT, SALT)
    C 프로그램 라이브러리의 crypt() 함수와 정확하게 똑같이 encrypt 된 캐릭터 라인 (을)를 돌려줍니다. 패스워드 파일을 조사해, 볼품없는 패스워드를 찾아내는데 편리합니다. 흰 모자를 쓰고 있는 놈만이 이것을 하지 않으면 안됩니다.

dbmclose(ASSOC_ARRAY)

dbmclose ASSOC_ARRAY
    dbm 파일과 연상 배열의 관계를 해제합니다. 연상 배열에 남아 있는 값은, dbm 파일의 캐쉬에 무엇이 들어가 있을까 (을)를 알고 싶기 때문에 않으면, 의미가 없는 것이 됩니다. 이 함수는, ndbm 를 사용하는 경우에게만 유용합니다.

dbmopen(ASSOC, DBNAME, MODE)
    dbm 나 ndbm 파일과 연상 배열을 연결시킵니다. ASSOC 는 연상 배열의 이름입니다. (통상의 open 와 달리, 최초의 인수는 파일 핸들과 같이 보여도, 파일 핸들이*없습니다*). DBNAME 는, (.dir 나 .pag 의 확장자(extension)를 제외한) 데이타베이스의 이름입니다. 데이타베이스가 존재하지 않으면(umask로 수식된) MODE 로 지정되었다 프로텍션으로 작성합니다. 낡은 dbm 함수 밖에 서포트하지 않는 시스템에서는, 프로그램 중(안)에서 하나의 dbmopen 밖에 용서되지 않을지도 모릅니다. dbm 도 ndbm 도 없는 시스템에서는, dbmopen 호출은 치명적인 에러를 생

    지금까지의 dbmopen 로 관련지을 수 있었던 연상 배열의 값은 없어집니다. dbm 파일 가운데, 어느 양의 값은 메모리에 캐쉬됩니다. 디폴트로 그 양은 64 입니다만, dbmopen 의 전에 연상 배열의 가베지 엔트리의 수를 미리 확보해 두는 것으로, 늘릴 수가 있습니다. 필요하면, reset 명령로 캐쉬를 플래시 할 수가 있습니다.

    dbm 파일에의 기입해 허가를 가지고 있지 않은 경우, 연상 배열 변수를 읽어내는 것만으로, 그것을 세트 할 수 없습니다. 기입할 수 있는지 어떤지를 테스트하고 싶으면, 파일 테스트를 사용하는지, 에러를 트랩 할 수 있는 eval 중(안)에서, 더미의 배열 엔트리를 세트 하려고 해 봐 주세요.

    keys()나 valuse()와 같은 함수는, 큰 dbm 파일을 사용했을 때에, 거대한 배열치를 돌려줄지도 모릅니다. 큰 dbm 파일로 반복을 할 때는, each() 함수를 사용하는 것이 좋을지도 모릅니다. 례:
    	# 히스토리 파일의 오프셋(offset)를 표시합니다
    	dbmopen(HIST, '/usr/lib/news/history', 0666);
    	while (($key, $val) = each %HIST) {
    		print $key, ' = ', unpack('L', $val), "\n";
    	}
    	dbmclose(HIST);

defined(EXPR)

defined EXPR
    좌변치 EXPR 가, 실제로 값을 가지고 있는지 어떤지를 나타내는 논리치를 돌려줍니다. 많은 연산으로, 파일 종단, 초기화되어 있지 않은 변수, 시스템 우류 등 의 예외 처리 조건으로 undefined 치가 돌려주어집니다. 이 함수는, 진짜 눌 캐릭터 라인을 돌려줄지도 모르는 조작, 특히 배열 요소를 참조 하는 조작 시에, 미정도리의 눌 캐릭터 라인이라고 정의된 눌 캐릭터 라인의 판별을 가능하게 합니다. 배열이나 써브루틴이 존재하는지 어떤지를 조사할 수도 있습니다. 예약이 끝난 변수를 사용할 때는, 직관적으로 기대하는 것 같은 결과가 된다고는 프로텍션되어 없습니다. 례:
    	print if defined $switch{'D'};
    	print "$val\n" while defined($val = pop(@ary));
    	die "Can't readlink $sym: $! "
    		unless defined($value = readlink $sym);
    	eval '@foo = ()' if defined(@foo);
    	die "No XYZ package defined" unless defined %_XYZ;
    	sub foo { defined &$bar ?  &$bar(@_) : die "No bar"; }
    undef 도 참조해 주세요.

delete $ASSOC{KEY}
    지정한 연상 배열로부터, 지정한 값을 삭제합니다. 삭제된 값이 돌아갑니다만, 아무것도 삭제되지 않았던 경우는 undefined 치가 돌아갑니다. $ENV{} 로부터 삭제하면(자), 환경 변수를 변경합니다. dbm 파일에 묶을 수 있었던 배열을 삭제하면(자), dbm 파일로부터 그 항 눈을 삭제합니다.

    이하의 예는, 연상 배열의 모든 값을 삭제합니다:
    	foreach $key (keys %ARRAY) {
    		delete $ARRAY{$key};
    	}
    (그러나, reset 명령을 사용하는 것이 빠를 것입니다. undef %ARRAY 라면 좀 더 빠를 것입니다)

die(LIST)

die LIST
    eval 의 밖에서, LIST 의 값을 STDERR 에 표시해, 그 때의 $! (errno)의 값으로 종료 (exit)합니다. $! 하지만 0 이라면, ($? >> 8) (`command` 의 스테이터스)의 값으로 종료합니다. ($? >> 8)이 0 이라면, 255 로 종료합니다. eval 중(안)에서는, 에러 메세지는 $@ 에 담겨 eval 는 undefined 값으로 종료합니다.

    동등의 예:
    die "Can't cd to spool: $! \n"
    		unless chdir '/usr/spool/news';
    	chdir '/usr/spool/news' || die "Can't cd to spool: $! \n"

    EXPR 의 값이 개행으로 끝나지 않는 경우, 스크립트의 현재의 행 번호와 (만약 있으면) 입력행 번호가 출력되어 개행이 더해집니다. 힌트: ", stopped" 를 메세지에 가세해 두면(자), "at foo line 123" 를 더해졌을 때에 알기 쉬워지므로 좋다 그렇지. 스크립트 "canasta" 를 달리게 하고 있다고 하면(자),
    	die "/etc/games is no good";
    	die "/etc/games is no good, stopped";
    (은)는, 아마
    	/etc/games is no good at canasta line 123.
    	/etc/games is no good, stopped at canasta line 123.
    (와)과 출력됩니다. exit (을)를 참조해 주세요.

do BLOCK
    BLOCK 내에서 지정된 집, 마지막 명령의 값을 돌려줍니다. 루프 수식자에 수식되었을 때는, 루프 조건을 테스트하기 전에 BLOCK 가 한 번 실행됩니다. (다른 문장에서는, 루프 수식자는, 조건을 시작해에 테스트합니다. )

do SUBROUTINE (LIST)
    sub 그리고 선언된 써브루틴을 실행해, SUBROUTINE 로 마지막에 평가된 식의 값 (을)를 돌려줍니다. 그 이름의 써브루틴이 없는 경우, 치명적 에러를 일으킵니다. (써브루틴이 존재하고 있는지 어떤지를 판정하고 싶으면,"defined" 연산자를 사용하는 것이 좋을 것입니다. ) 배열을 리스트의 일부로서 건네주고 싶으면, 각 배열 전에 배열의 길이를 붙여 건네주는 것이 좋을 것입니다. ( 뒤에 나오는 써브루틴의 섹션을 참조해 주세요. ) "do EXPR" 의 형태와의 혼란을 피하기 (위해)때문에, 괄호는 필요합니다.

    SUBROUTINE 는, 하나의 스칼라 변수에서도 괜찮습니다. 그 경우, 실행되는 써브루틴명은, 변수로부터 얻을 수 있습니다.

    다른 (선호된다) 형태로서 ampersand(&) & 를 앞에 두고 붙이는 &foo(@args)의 같게, 써브루틴을 불러도 괜찮습니다. 인수를 건네주지 않으면, 괄호를 사용할 필요는 없습니다. 괄호를 생략 하면(자), 써브루틴에는 @_ 배열은 건네받지 않습니다. & 형태는, defined 나 undef 연산자에 써브루틴을 지시하는데도 사용됩니다:
    	if (defined &$var) { &$var($parm); undef &$var; }

do EXPR
    파일명으로서 EXPR 의 값을 사용해, perl 스크립트로서 파일의 내용을 실행합니다. 이것은 기본적으로 perl 써브루틴 프로그램 라이브러리로부터 써브루틴을 인클루드 한다고 하는 사용법을 합니다.
    	do 'stat.pl';
    (은)는,
    	eval `cat stat.pl`;
    (와)과 거의 같습니다. 다른 것은, 보다 효율적으로, 보다 간결해, 에러 메세지중의 현재 파일명 (은)는 올바르고, 커런트 디렉토리에 stat.pl 가 없으면 -I 그리고 지정된 프로그램 라이브러리를 모두 찾는다고 하는 것입니다. (예약 변수의 섹션중의 @INC 배열을 참조해 주세요). 그러나, 호출마다 파일을 다시 해석하는 것은 같아서, 루프의 안쪽에서 이 파일을 사용한다면, 기동 시간은 조금 불필요하게 걸린다고 해도, -P 와 #include 를 사용하는 것이 좋을 것입니다. (이 #include 를 사용하는 문제점은, cpp 가 # 코멘트를 인식해 주지 않는다 일입니다. --도망갈 길은, 코멘트 단독으로서 ";#" 를 사용하는 것입니다. ) 다음의 것은 등가는 아닌 것에 주의해 주세요:
    	do $foo;	# 파일을 eval 합니다
    	do $foo();	# 써브루틴을 부릅니다
    프로그램 라이브러리 routine의 인클루드로서는, "require" 연산자가 보다 좋은 일을 기억해 두어 주세요.

dump LABEL
    즉시 코어덤프 합니다. 원래, 이것은, 프로그램의 시작해에 모든 변수를 초기화한 후에 덤프 된 코어를 undump 프로그램을 사용해 실행 바이너리를 만들기 위해서(때문에) 있습니다. 새로운 바이너리가 실행될 때,"goto LABEL" 를 실행하는 것으로부터 시작됩니다 (goto 가 받는 모든 제한은 적용됩니다). 코어덤프로 멈추었는데로부터, goto 로 다시 시작된다고 생각하면 좋습니다. LABEL 가 생략 되면(자), 프로그램은 선두로부터 재스타트 합니다. 경고: 덤프 되었을 때에 open 되고 있던 어느 파일도, 프로그램이 재생했을 때에는 이제(벌써) open 되지 않고, perl의 옆에서는 혼란할 가능성이 있습니다. -u 도 참조해 주세요.

    례:
    	#! /usr/bin/perl
    	require 'getopt.pl';
    	require 'stat.pl';
    	%days = (
    	    'Sun', 1,
    	    'Mon', 2,
    	    'Tue', 3,
    	    'Wed', 4,
    	    'Thu', 5,
    	    'Fri', 6,
    	    'Sat', 7);
    	dump QUICKSTART if $ARGV[0] eq '-d';
        QUICKSTART:
    	do Getopt('f');

each(ASSOC_ARRAY)

each ASSOC_ARRAY
    연상 배열의 다음의 키와 값의 2 개의 요소로부터 완성되는 배열을 차례차례 돌려주어, 그것을 반복할 수가 있습니다. 각 엔트리는 랜덤과 같이 보이는 순서로 돌려주어집니다. 배열 전부가 읽혔을 때, 눌 배열 (대입되면(자) FALSE(0) 치가 된다) 하지만 돌려주어집니다. 그 후, 다음의 each()의 호출로 반복을 다시 시작합니다. 반복 정보는, 배열로부터 모든 요소를 읽어들이는 것에 의해서만 리셋트 할 수 있습니다. 반복동안은, 배열을 변경 해서는 안됩니다. 각 연상 배열에 대해 한개씩 반복 정보가 있어, 프로그램중의 모든 each(), keys(), values() 함수 호출로 공유됩니다. 다음의 예는, 순서는 다른 것의 printenv 프로그램과 같이 환경 변수를 표시합니다:
    	while (($key, $value) = each %ENV) {
    		print "$key=$value\n";
    	}
    keys() 함수와 values() 함수도 참조해 주세요.

eof(FILEHANDLE)

eof()

eof 다음에 FILEHANDLE 를 읽었을 때 파일 종단인지, 또는 FILEHANDLE 가 오픈되어 있지 않을 때, 1 을 돌려줍니다. FILEHANDLE 는 실제의 파일 핸들명을 값에 가지는 식에서도 괜찮습니다. (이 함수는, 실제로는 한 글자 읽어들여서는, ungetc 하므로, 대화적인 문맥에서는 그만큼 유용하지는 않습니다. ) 인수 없음의 eof 는, 마지막에 읽은 파일의 eof 상태를 돌려줍니다. 하늘의 괄호 ()는, 명령행으로 지정된 파일군으로부터 된다 의사 파일을 가리킵니다. 즉, eof()는 while (<>)의 안쪽에서 마지막 파일의 종단을 검출할 경우에 의미가 있습니다. while (<>) 루프 중(안)에서 각 파일을 조사하고 싶을 때는, eof(ARGV) 또는 괄호가 없는 eof 를 사용해 주세요. 례:
    	# 마지막 파일의 맨 마지막 줄의 직전에 데쉬를 삽입합니다
    	while (<>) {
    		if (eof()) {
    			print "--------------\n";
    		}
    		print;
    	}
    	# 각 입력 파일마다, 행 번호를 리셋트 합니다
    	while (<>) {
    		print "$.\t$_";
    		if (eof) {	# Not eof().
    			close(ARGV);
    		}
    	}

eval(EXPR)

eval EXPR

eval BLOCK
    EXPR 는 해석되어 하나의 작은 perl 프로그램인것 같이 실행됩니다. perl 프로그램의 문맥 중(안)에서 실행되므로, 어느 변수 설정, 써브루틴, 포맷 정의도 그 후에 남습니다. 반환값은, 꼭 써브루틴과 같게, 마지막에 평가된 식이 돌아갑니다. 문법 에러나 실행시 에러가 있는지, die 문이 있으면, eval 에 의해 undefined 하지만 돌아가,$@ 에 에러 메세지가 세트 됩니다. 만약 에러가 없으면,$@ 은 눌 캐릭터 라인인 것이 프로텍션됩니다. EXPR를 생략 하면(자),$_ 를 평가합니다. 마지막 세미콜론은 모두 식으로부터 제외해집니다.

    eval 홍역 해, 치명적 에러까지 트랩 하므로, (dbmopen 나 symlink와 같이) 있는 기능이 실장되고 있는지 어떤지를 결정하기에는 편리한 일을 기억해 두어 주세요. die 연산자가 예외를 일으키도록(듯이) 사용되는 것은, perl 의 예외 트랩 기구 이기도 합니다.

    실행되는 코드가 변함없으면, 그 번에 재컴파일 되는 시간을 비 보다는, 실행시 에러를 트랩 하는 eval-BLOCK 의 형태를 취하는 것이 좋다 일지도 모릅니다. 어떤 에러도 일어나면 $@ 에 메세지가 돌아갑니다. EXPR 와 같은, 싱글 쿼트 된 캐릭터 라인을 평가하면(자), 같은 효과가 있습니다만, eval-BLOCK 의 형태에서는 컴파일시에 문법 에러를 보고하는데 대해, eval-EXPR 의 형태에서는 $@ 을 통해 실행시에 문법 에러를 보고하는 점이 다릅니다. eval-EXPR 의 형태는, 최초로 성공했을 때에 eval-BLOCK 에 최적화됩니다. (e 수식자를 사용했을 경우, 치환되는 측은 싱글 쿼트 된 캐릭터 라인과 보여 같은 최적화가 일어납니다. ) 례:
    	# 0 제산을 치명적 에러로 하지 않습니다
    	eval { $answer = $a / $b; }; warn $@ if $@;
    	# 첫회 사용후, 같은 것에 최적화됩니다.
    	eval '$answer = $a / $b'; warn $@ if $@;
    	# 컴파일시 에러
    	eval { $answer = };
    	# 실행시 에러
    	eval '$answer =';	# sets $@

exec(LIST)

exec LIST
    LIST 안에 하나 이상의 인수가 있는지, LIST 가 하나 이상의 값을 가지는 배열이라면, 리스트의 인수를 붙여 execvp()를 부릅니다. 하나의 스칼라 인수 뿐이라면, 인수에 쉘의 메타캐라크타가 있는지 어떤지 (을)를 조사합니다. 있으면, 해석을 위해서(때문에) 인수를 통째로 "/bin/sh -c" 에 건네주어, 없으면, 인수는 단어에 split 되어 execvp()에 직접 건네받습니다. 그 쪽이 효율이 좋기 때문입니다. 주의: exec (와 system)는 출력 버퍼를 플래시 하지 않기 때문에, 출력이 없어지는 것을 피하기 위해서(때문에) $| 를 세트 할 필요가 있을지도 모릅니다. 례:
    	exec '/bin/echo', 'Your arguments are: ', @ARGV;
    	exec "sort $outfile | uniq";

    만약, 최초의 인수를 정말로 실행하고 싶기 때문에 않고, 실행하려고 하고 있다 프로그램의 이름을 사칭 하고 싶은 것뿐이라면, 정말로 달리게 하고 싶은 프로그램을 변수에 할당해, LIST 의 전에 변수의 이름을 콤마를 붙이지 않고 두도록(듯이) 지정할 수 있습니다. (이것은, 비록 단일 스칼라 밖에 리스트에 없어도, 항상 많은 값을 가진다 리스트로서 LIST 의 해석을 강제합니다. ) 례:
    	$shell = '/bin/csh';
    	exec $shell '-sh';		# 로그인 쉘의 행세를 합니다

exit(EXPR)

exit EXPR
    EXPR 를 평가해, 즉시 그 값으로 종료합니다. 례:
    	$ans = <STDIN>;
    	exit 0 if $ans =~ /^[Xx]/;
    die (을)를 참조해 주세요. EXPR 가 생략 되면(자), 값 0 상태로 종료합니다.

exp(EXPR)

exp EXPR
    e 의 EXPR 승을 돌려줍니다. EXPR 를 생략 하면(자), exp($_)를 돌려줍니다.

fcntl(FILEHANDLE, FUNCTION, SCALAR)
    fcntl(2) 함수의 실장입니다. 올바른 함수 정의를 얻으려면 , 아마
    	require "fcntl.ph";	# 아마 /usr/local/lib/perl/fcntl.ph
    (을)를 시작해에 써 두지 않으면 되지 않을 것입니다. 만약, fcntl.ph 가 존재하지 않는지, 혹은 올바른 정의가되어 있지 않은 경우, <sys/fcntl.h> (와)과 같은 C 의 헤더 파일에 근거해, 스스로 어떻게든 하지 않으면 안됩니다. (perl kit 로부터 오는 h2ph 로 불리는 perl 스크립트가 있어, 이것을 도와 주겠지요) 인수의 처리와 반환값을 돌려주는 것은, 이 후에 쓰여져 있는 ioctl 와 같이 동작합니다. fcntl 는, fcntl(2)가 실장되어 있지 않은 머신으로 사용되면(자) 치명적 에러를 일으킵니다.

fileno(FILEHANDLE)

fileno FILEHANDLE
    파일 핸들에 대한 파일 기술자를 돌려줍니다. select()의 비트 맵을 구성하는데 편리합니다. FILEHANDLE 가 식이라고, 그 값이 파일 핸들의 이름이라고 해석됩니다.

flock(FILEHANDLE, OPERATION)
    파일 핸들에 대해 flock(2)를 부릅니다. OPERATION 의 정의에 대해서는, flock(2)의 메뉴얼을 참조해 주세요. 성공하면 진을, 실패하면 가짜를 돌려줍니다. flock(2)가 실장되어 있지 않은 머신으로 사용하면(자), 치명적 에러가 됩니다. 이하는, BSD 시스템의 메일 박스에 메일을 추가합니다.
    	$LOCK_SH = 1;
    	$LOCK_EX = 2;
    	$LOCK_NB = 4;
    	$LOCK_UN = 8;
    	sub lock {
    	    flock(MBOX, $LOCK_EX);
    	    # 기다리고 있는 동안에, 다른 누군가가 추가한다
    	    # 경우를 위해서(때문에)...
    	    seek(MBOX, 0, 2);
    	}
    	sub unlock {
    	    flock(MBOX, $LOCK_UN);
    	}
    	open(MBOX, ">>/usr/spool/mail/$ENV{'USER'}")
    		|| die "Can't open mailbox: $! ";
    	do lock();
    	print MBOX $msg,"\n\n";
    	do unlock();

fork
    fork() 시스템 콜을 실행합니다. parent process에 아이의 pid 를 돌려주어, child process에는 0 을 돌려줍니다. 주의: 플래시되어 있지 않은 버퍼는, 양쪽 모두의 프로세스로 플래시 되지 않고 남습니다. 이것은 이중 출력을 피하기 위해서(때문에),$| 를 세트 할 필요가 있을 지도 모르다고 하는 것을 의미합니다.

getc(FILEHANDLE)

getc FILEHANDLE

getc
    FILEHANDLE 에 묶을 수 있었던 입력 파일로부터, 다음의 캐릭터를 돌려줍니다. EOF 에서는 눌을 돌려줍니다. FILEHANDLE 를 생략 하면(자), STDIN 로부터 읽어들여

getlogin
    현재의 로그인 상황을 /etc/utmp 로부터 얻을 수 있으면, 그것을 돌려줍니다. 얻을 수 있지 않으면, getpwuid 를 사용해 주세요.
        $login = getlogin || (getpwuid($<))[0] || "Somebody";

getpeername(SOCKET)
    SOCKET 접속의 저쪽 편의 pack 된 sockaddr 주소를 돌려줍니다.
    	# 내부 sockaddr
    	$sockaddr = 'S n a4 x8';
    	$hersockaddr = getpeername(S);
    ($family, $port, $heraddr) =
    			unpack($sockaddr, $hersockaddr);

getpgrp(PID)

getpgrp PID
    지정된 PID 에 대한 현재의 프로세스 그룹을 돌려줍니다. 현재의 프로세스에서는 0 입니다. getpgrp(2)가 실장되어 있지 않은 머신으로 사용하면(자), 치명적 에러가 됩니다. EXPR 가 생략 되면(자), 현재의 프로세스의 프로세스 그룹이 돌아갑니다.

getppid
    parent process의 프로세스 ID 를 돌려줍니다.

getpriority(WHICH, WHO)
    프로세스, 프로세스 그룹, 유저의 현재의 priority를 돌려줍니다. (getpriority(2)를 참조해 주세요. ) getpriority(2)를 실장하고 있지 않는 머신으로 사용하면(자) 치명적 에러가 됩니다.

getpwnam(NAME)

getgrnam(NAME)

gethostbyname(NAME)

getnetbyname(NAME)

getprotobyname(NAME)

getpwuid(UID)

getgrgid(GID)

getservbyname(NAME, PROTO)

gethostbyaddr(ADDR, ADDRTYPE)

getnetbyaddr(ADDR, ADDRTYPE)

getprotobynumber(NUMBER)

getservbyport(PORT, PROTO)

getpwent

getgrent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent(STAYOPEN)

setnetent(STAYOPEN)

setprotoent(STAYOPEN)

setservent(STAYOPEN)

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent
    이러한 routine는, 시스템 프로그램 라이브러리중의 동명의 함수를 실행합니다. 배열의 문맥 중(안)에서는, 이러한 각 get routine의 반환값은, 이하와 같이 됩니다:
    	($name, $passwd, $uid, $gid,
    	   $quota, $comment, $gcos, $dir, $shell) = getpw. . .
    	($name, $passwd, $gid, $members) = getgr. . .
    	($name, $aliases, $addrtype, $length, @addrs) = gethost. . .
    	($name, $aliases, $addrtype, $net) = getnet. . .
    	($name, $aliases, $proto) = getproto. . .
    	($name, $aliases, $port, $proto) = getserv. . .
    (만약 엔트리가 존재하지 않으면, 누르리스트가 됩니다. )

    스칼라의 문맥에서는, name 에 의한 검색이 아닌 경우에는 name 를 얻을 수 있어 name 에 의한 검색의 경우에는 name 이외를 얻을 수 있습니다. (엔트리가 존재하지 않는 경우는, undefined 치가 됩니다. ) 례:
    	$uid = getpwnam
    	$name = getpwuid
    	$name = getpwent
    	$gid = getgrnam
    	$name = getgrgid
    	$name = getgrent
    	타
    getgr. . . (이)가 돌려주는 $menbers 치는, 공백에서 단락지어진 그룹 멤버의 로그인명의 리스트입니다.

    gethost. . . 함수에서는, h_errno 변수가 C 로 서포트되고 있으면, 함수의 콜이 실패했을 때 $? (을)를 개입시켜 돌려주어집니다. 성공한 함수 콜이 돌려주는 @addrs 치는, 상당하는 시스템 프로그램 라이브러리 호출에 돌려주어진 raw address 의 리스트입니다. 인터넷 도메인 (INET)에서는, 각 주소는 4 바이트장으로 이하와 같이 쓰면(자) unpack 할 수 있습니다.
    	($a, $b, $c, $d) = unpack('C4', $addr[0]);

getsockname(SOCKET)
    pack 된, SOCKET 접속의 이 쪽편의 sockaddr 주소를 돌려줍니다.
    	# An internet sockaddr
    	$sockaddr = 'S n a4 x8';
    	$mysockaddr = getsockname(S);
    ($family, $port, $myaddr) =
    			unpack($sockaddr, $mysockaddr);

getsockopt(SOCKET, LEVEL, OPTNAME)
    요구한 소켓의 옵션을 돌려줍니다. 에러의 경우는 undefined 를 돌려줍니다.

gmtime(EXPR)

gmtime EXPR
    time 함수에 돌려주어졌을 때 각을, Greenwich timezone 로서 9 요소의 배열에 변환합니다. 통상은 다음과 같이 사용합니다:
    ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) =
    						gmtime(time);
    모든 배열 요소는 수치로, 구조체 tm 로부터 직접 얻을 수 있는 것입니다. 이것에 의해 $mon 는 0. . 11 의 범위에서 $wday 는 0. . 6 의 범위인 것에 됩니다. EXPR 를 생략 하면(자), gmtime(time)를 실행합니다.

goto LABEL
    LABEL 라고 하는 label를 붙일 수 있었던 문장을 찾아, 거기로부터 실행을 재개합니다. 현재로서는, 프로그램의 본체내에서 do {} 구조의 안쪽이 상자로 되어 있지 않은 문장 밖에 갈 수 없습니다. 이 문장은 효율적으로는 실장되지 않고, sed-to-perl 번역 프로그램을 간단하게 할 수 있도록(듯이) 하기 위한(해)만 있습니다. 번역되었다 sed 스크립트의 일관성의 서포트는 합니다만, 이 시멘틱스를 내가 언제 변경할지 모르기 때문에, 스스로의 책임으로 사용해 주세요. 전혀 사용하지 않는 것이 좋을 것입니다.

grep(EXPR, LIST)
    LIST 의 각 요소에 대해서 (로컬에는 각 요소를 $_ 에 세트), EXPR 를 평가해, 식이 진이다고 평가된 요소만으로부터 되는 배열을 돌려줍니다. 스칼라의 문맥에서는, 식이 실로 된 회수를 수치로 돌려줍니다.
    	@foo = grep(! /^#/, @bar);    # 코멘트를 제외합니다
    $_ (은)는 배열치에의 참조이므로, 배열의 요소를 변경하는 경우에 사용할 수 있는 것을 기억해 둡시다. 이것은 편리합니다만, LIST 가 이름의 붙은 배열이 아니면 이상한 결과를 일으키게 됩니다.

hex(EXPR)

hex EXPR
    10 진치 EXPR 를 16 진캐릭터 라인으로 해 돌려줍니다. (0 또는 0x 로 시작되는 캐릭터 라인을 해석한다면, oct()를 참조해 주세요. ) EXPR 를 생략 하면(자) $_ 를 사용합니다.

index(STR, SUBSTR, POSITION)

index(STR, SUBSTR)
    STR 중(안)에서, POSITION 나 그 이후에 최초로 SUBSTR 가 나타나는 위치를 돌려줍니다. POSITION 를 생략 하면(자), 캐릭터 라인의 선두로부터 검색합니다. 반환값은, 0 이나 $[ 변수로 설정된 것이 베이스가 됩니다. SUBSTR 가 발견되지 않으면 베이스로부터 1 을 뺀 값을 돌려주어, 통상 -1 에 됩니다.

int(EXPR)

int EXPR
    EXPR 의 정수부를 돌려줍니다. EXPR 가 생략 되면(자),$_ 를 사용합니다.

ioctl(FILEHANDLE, FUNCTION, SCALAR)
    이것은, ioctl(2) 함수를 실장하고 있습니다. 올바른 함수 정의를 얻으려면 , 아마 초의 (분)편으로
    	require "ioctl.ph";	# 아마 /usr/local/lib/perl/ioctl.ph
    (이)라고 쓰지 않으면 되지 않을 것입니다. ioctl.ph 가 존재하지 않는지, 또는 올바르게 정의되어 있지 않은 경우, <sys/ioctl.h> (와)과 같은 C 의 헤더 파일로부터 자기 자신으로 어떻게든 하는거야 차면 되지 않습니다. (perl 킷에 있는 h2ph 라고 하는 스크립트가 이 도움이 되겠지요. ) SCALAR 는, FUNCTION에 의존해, 참조 또는 기입이 됩니다. FUNCTION --SCALAR 의 캐릭터 라인치에의 포인터는, 실제의 ioctl 호출의 제 3 인수에게 건네집니다. (SCALAR 가 캐릭터 라인치가 아니고 수치였을 경우, 캐릭터 라인치에의 포인터가 아니고 수치 그 자체가 건네받습니다. 이것이 진인 것을 프로텍션하려면 , 이 스칼라를 사용하기 전에 0 을 더해 주세요. ) ioctl()에 사용되는 구조체의 값을 취급하려면 , pack() 함수와 unpack() 함수가 편리합니다. 다음의 예는, DEL 에 erase 캐릭터를 세트 합니다.
    	require 'ioctl.ph';
    	$sgttyb_t = "ccccs";		# chars 4 개와 short 1 개
    	if (ioctl(STDIN, $TIOCGETP, $sgttyb)) {
    		@ary = unpack($sgttyb_t, $sgttyb);
    		$ary[2] = 127;
    		$sgttyb = pack($sgttyb_t, @ary);
    		ioctl(STDIN, $TIOCSETP, $sgttyb)
    			|| die "Can't ioctl: $! ";
    	}
    ioctl (와 fcntl)의 반환값은 이하와 같습니다:
    	OS 의 반환값 :perl의 반환값:
    	  -1  undefined 치
    	  0캐릭터 라인 "0 but true"
    	  그 이외 그 수
    이와 같이, perl 는 성공시에 진을, 실패시에 가짜를 돌려줍니다만,
     operating system로부터 돌려주어지는 실제의 값도 간단하게 판정할 수가 있습니다:
    	($retval = ioctl(...)) || ($retval = -1);
    	printf "System returned %d\n", $retval;

join(EXPR, LIST)

join(EXPR, ARRAY)
    분할되고 있는 LIST 나 ARRAY 의 캐릭터 라인을, 필드 구분자로서 값 EXPR 를 끼운 하나의 캐릭터 라인에 연결해, 그 캐릭터 라인을 돌려줍니다. 례:
    $_ = join(':',
    		$login, $passwd, $uid, $gid, $gcos, $home, $shell);
    split (을)를 참조해 주세요.

keys(ASSOC_ARRAY)

keys ASSOC_ARRAY
    이름이 붙은 연상 배열의 모든 키로부터 되는 보통 배열을 돌려줍니다. 키는, 외관상 랜덤인 순서로 돌려주어집니다만, values() 함수나 each() 함수 (이것에 의해 연상 배열은 변경되지 않습니다)(이)가 생성하는 것과 같은 순서가 됩니다. 이하는, 환경 변수를 표시하는 다른 방법입니다:
    	@keys = keys %ENV;
    	@values = values %ENV;
    	while ($#keys >= 0) {
    		print pop(@keys), '=', pop(@values), "\n";
    	}
    키로 정렬 하면(자):
    	foreach $key (sort(keys %ENV)) {
    		print $key, '=', $ENV{$key}, "\n";
    	}

kill(LIST)

kill LIST
    프로세스의 리스트에 시그널을 보냅니다. 리스트의 최초의 요소는, 보내지는 시그널이 아니면 안됩니다. 시그널 송신에 성공한 프로세스의 수를 돌려줍니다.
    	$cnt = kill 1, $child1, $child2;
    	kill 9, @goners;
    시그널이 부의 경우, 프로세스 대신에 프로세스 그룹을 kill 합니다. (System V에서는, 부의 프로세스 번호는 프로세스 그룹도 kill 합니다만, 호환성은 없습니다. ) 쿼트로 묶어진 시그널명도 사용할 수 있습니다.

last LABEL

last
    last 명령은, (루프내에서 사용되는 것 같은) C 의 break 문장을 닮아 있어, 해당하는 루프를 즉시 종료합니다. LABEL 가 생략 되면(자), 이 명령은 가장 안쪽의 루프를 빠집니다. continue 블록이 있었다고 해도, 실행되지 않습니다:
    	line: while (<STDIN>) {
    		last line if /^$/;	# 헤더가 끝나면(자) 빠집니다
    		. . .
    	}

length(EXPR)

length EXPR
    EXPR 의 값의 캐릭터 라인장을 돌려줍니다. EXPR 를 생략 하면(자),$_ 의 길이를 돌려줍니다.

link(OLDFILE, NEWFILE)
    OLDFILE 에 링크 된 NEWFILE 를 작성합니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려줍니다.

listen(SOCKET, QUEUESIZE)
    listen 시스템 콜과 같은 것을 행합니다. 성공하면(자) 진을, 실패하면(자) 가짜를 돌려줍니다. 프로세스간 통신의 섹션의 예를 참조해 주세요.

local(LIST)
    닫은 블록, 써브루틴, eval,"do" 에 국소적인 변수 리스트를 선언합니다. 리스트 된 모든 요소는 좌변치로서 타당한 것이 아니면 안됩니다. 이 연산자는, LIST 내의 그 시점에서의 변수를 숨은 스택에 보존해, 블록이나 써브루틴이나 eval 를 빠질 때 되돌리도록(듯이) 동작합니다. 이것은, 불린 써브루틴도 글로벌 변수가 아니고, 로컬 변수를 참조하는 것을 의미합니다. 그러한 차면, LIST 에 대입해 로컬 변수를 초기화해도 괜찮습니다. (초기치가 특정의 값으로 해서 주어지지 않으면, undefined 치로서 생성됩니다. ) 보통, 이것은 써브루틴의 파라미터에 이름을 붙이는데 사용됩니다. 례:
    	sub RANGEVAL {
    		local($min, $max, $thunk) = @_;
    		local($result) = '';
    		local($i);
    		# 아마 $thunk 는 $i 를 참조하고 있습니다
    		for ($i = $min; $i < $max; $i++) {
    			$result . = eval $thunk;
    		}
    		$result;
    	}
    	if ($sw eq '-v') {
    	    # 글로벌인 배열로 로컬인 배열을 초기화합니다
    	    local(@ARGV) = @ARGV;
    	    unshift(@ARGV,'echo');
    	    system @ARGV;
    	}
    	# @ARGV 가 바탕으로 되돌려집니다
    	# 일시적으로 digits 라고 하는 연상 배열에 추가를 하고 있습니다.
    	if ($base12) {
    		# (주의: 이것이 효율적이라고 말하고 싶은 것은 아닙니다)
    		local(%digits) = (%digits, 't', 10, 'e', 11);
    		do parse_num();
    	}
    local()는 실행시의 명령로, 루프 종료시에 전부를 한 번에 해방할 때까지는, 루프를 통과할 때마다 실행되어 매회 스택을 소비해 갈 것입니다.

localtime(EXPR)

localtime EXPR
    time 함수에 돌려주어졌을 때 각을, 로컬 타임 존으로서 해석된 9 요소의 배열로 변환합니다. 통상 다음과 같이 사용됩니다:
    ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) =
    						localtime(time);
    모든 배열 요소는 숫자로, 구조체 tm 로부터 직접 얻을 수 있던 것입니다. 이것에 의해 $mon 는 0. . 11 의 범위에서 $wday 는 0. . 6 의 범위인 것에 됩니다. EXPR 를 생략 하면(자), localtime(time)를 실행합니다.

log(EXPR)

log EXPR
    EXPR 의 (바닥이 e 의) 대수를 돌려줍니다. EXPR 를 생략 하면(자),$_ 의 log 를 돌려줍니다.

lstat(FILEHANDLE)

lstat FILEHANDLE

lstat(EXPR)

lstat SCALARVARIABLE
    stat() 함수와 같은 것을 실행합니다만, 기호 연결에서는 가리키고 있다 앞의 파일 대신에 기호 연결 자신 상태를 돌려줍니다. 기호 연결이 실장되어 있지 않은 시스템에서는, 통상의 stat 를 실행합니다.

m/PATTERN/gio

/PATTERN/gio
    패턴 매치에 맞는 캐릭터 라인을 검색해, 진 (1)이나 가짜 ('')를 돌려줍니다. =~ (이)나 ! ~ (을)를 개입시킨 캐릭터 라인의 지정이 없으면, 캐릭터 라인 $_ 이 검색됩니다. (=~ 로 지정된 캐릭터 라인은, 좌변치일 필요는 없습니다. 식의 평가 결과에서도 괜찮습니다가,=~ 는 어느 쪽인가 하면 우선도가 높은 일을 기억해 두어 주세요. ) 정규 표현의 섹션을 참조해 주세요.

    / 하지만 단락 캐릭터인 경우, 초의 'm'는 생략 가능합니다. 'm'가 있으면(자), 영숫자 이외 목의 캐릭터에서도 단락으로 할 수 있습니다. 이것은, 특히 '/'를 포함한 UNIX 의 패스명에의 매치에 편리합니다. 마지막 단락의 뒤에 옵션 캐릭터 'i'가 계속되면(자), 매칭이 대문자 소문자의 구별 없게 행해집니다. PATTERN 는, 스칼라 변수에의 참조를 포함하고 있어도 자주(잘), 그것은 패턴 검색 하지만 평가될 때마다 삽입됩니다 (패턴은 recompile 됩니다). ( $)(와)과 $| 는 캐릭터 라인 종단의 테스트로 보이기 (위해)때문에, 삽입은 행해지지 않습니다. ) 패턴을 한 번만 컴파일 시키고 싶은 경우는, 뒤의 단락 캐릭터 의 후에 "o" 를 더해 주세요. 이것에 의해, 여분의 실행시 재컴파일을 피할 수 있으므로, 삽입하고 싶은 값이 스크립트가 움직이고 있는 마나카, 변함없을 때에는 편리합니다. PATTERN 가 눌 캐릭터에 평가되었을 때는, 마지막에 성공한 정규 표현이 대신에 사용됩니다.

    배열치가 필요한 문맥으로 사용되면(자), 패턴 매치는 패턴 중(안)에서 매치 한 subexpression 를 괄호로 묶은 것 즉, ($1, $2, $3. . . ) (으)로부터 되는 배열을 돌려줍니다. 이 경우, 실제로는 $1, $2 등을 세트는*하지 않고*, $+, $`, $&, $'도 세트 하지 않습니다. 매치이 실패하면(자), 눌 배열이 돌아갑니다. 매치이 성공해도 괄호가 없으면 배열치 (1)가 돌아갑니다.

    례:
        open(tty, '/dev/tty');
        <tty> =~ /^y/i && do foo();	# y 라면 foo 를 실행
        if (/Version: *([0-9. ]*)/) { $version = $1; }
        next if m#^/usr/spool/uucp#;
        # 풍족하지 않은 사람의 grep
        $arg = shift;
        while (<>) {
    	    print if /$arg/o;	# 한 번만 컴파일
        }
        if (($F1, $F2, $Etc) = ($foo =~ /^(\S+) \s+(\S+) \s*(. *)/))
    이 마지막 예는, $foo 를 최초의 2어와 남아에 split 해, 세 개의 필드 (을)를 $F1, $F2, $Etc 에 대입합니다. 어떤 것인가의 변수가 대입되었을 경우, 즉 패턴이 매치 했을 경우, 이 조건은 진이 됩니다.

    "g" 수식자는, 글로벌 패턴 매치의 지정입니다--즉, 캐릭터 라인 중(안)에서 가능한 한 많은 매치을 행합니다. 어떻게 행동할까는, 문맥에 의존합니다. 배열의 문맥에서는, 정규 표현 중(안)에서 모든 괄호에 매치 한 캐릭터 라인의 리스트를 돌려줍니다. 괄호가 없으면, 패턴 전체를 둘러싸는 괄호가 있을까 (와)과 같이 매치 한 캐릭터 라인 모든 리스트를 돌려줍니다. 스칼라의 문맥에서는, 캐릭터 라인을 통해 매치 할 때마다*진*을 돌려주어, 매치 하지 않았을 때*가짜*를 돌려줍니다. (말 있고 돌아가면(자), 마지막에 테스트했다 장소를 기억하고 있어, 거기로부터 다시 검색을 시작한다고 하는 것입니다. ) 마지막 매치으로부터 캐릭터 라인이 변경되어 있지 않은 것을 가정하고 있습니다. 매치과 성냥의 사이에 캐릭터 라인을 변경하는 것은, 미정도리인 동작을 일으킨다 일지도 모릅니다. (실제로는 substr()를 사용해, 전문자열의 길이를 바꾸지 않고 로 그 자리에서 변경한다 (이)라면, 할 수 있습니다. 그러나, 일반적으로는 그러한 변경은 s///g 를 사용해야 합니다. ) 례:
    	# 배열의 문맥
    	($one, $five, $fifteen) = (`uptime` =~ /(\d+\.\d+) /g);
    	# 스칼라의 문맥
    	$/ = ""; $* = 1;
    	while ($paragraph = <>) {
    	    while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
    		$sentences++;
    	    }
    	}
    	print "$sentences\n";

mkdir(FILENAME, MODE)
    FILENAME 로 지정된 디렉토리를, (umask 로 수식된) MODE 로 지정 된 퍼미션으로 작성합니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려주어,$! (errno)(을)를 세트 합니다.

msgctl(ID, CMD, ARG)
    System V IPC 함수의 msgctl 를 부릅니다. CMD 가 &IPC_STAT 라면, ARG 는 돌려주어진 msqid_ds 구조를 보관 유지하는 변수가 아니면 안됩니다. ioctl 와 같이, 에러 때는 undefined 치를, 0 때 에는 "0 but true" 를, 이 아니면 실제의 반환값을 돌려줍니다.

msgget(KEY, FLAGS)
    System V IPC 함수의 msgget 를 부릅니다. 성공시는 메시지 큐 ID 를, 에러가 일어나면 undefined value 를 돌려줍니다.

msgsnd(ID, MSG, FLAGS)
    System V IPC 함수의 msgsnd 를 불러, 메세지 MSGS 를 메시지 큐 ID 에 송신합니다. MSG 는, pack("L", $type)로 만들어지는 long integer 의 메세지형으로 시작하지 않으면 안됩니다. 성공하면 진을, 에러가 일어난다 (와)과 가짜를 돌려줍니다.

msgrcv(ID, VAR, SIZE, TYPE, FLAGS)
    System V IPC 함수 msgrcv 를 불러, 메시지 큐 ID 로부터 메세지를 받아들여, 최대 메세지 사이즈 SIZE 로 변수 VAR 에 격납합니다. 메세지를 받아들이면(자), VAR 에 최초로 격납된 것이 메세지형 되어, VAR 의 최대장은, SIZE 에 메세지형의 사이즈를 더한 것에 되는 것에 주의해 주세요. 성공하면(자) 진을, 에러에서는 가짜를 돌려줍니다.

next LABEL

next
    next 명령은, C 의 continue 문장과 같게, 루프의 다음의 반복을 시작합니다.
    	line: while (<STDIN>) {
    		next line if /^#/;	# 코멘트를 버립니다
    		. . .
    	}
    위의 예로 continue 블록이 있으면(자), 행을 버려졌을 경우에서도 실행되는 것을 기억해 두어 주세요. LABEL 가 생략 되면(자), 이 명령은 가장 안쪽의 루프를 계속합니다.

oct(EXPR)

oct EXPR
    10 진수 EXPR 를, 8 진캐릭터 라인으로 해 돌려줍니다. (EXPR가 0x 로 시작되는 캐릭터 라인이라면, 10 진 대신에 16 진으로서 변환합니다. ) 이하는, 10 진, 8 진, 16 진의 표준적인 기법을 취급합니다.
    	$val = oct($val) if $val =~ /^0/;
    EXPR 가 생략 되면(자),$_ 를 사용합니다.

open(FILEHANDLE, EXPR)

open(FILEHANDLE)

open FILEHANDLE
    EXPR 로 주어진 파일명의 파일을 오픈해, FILEHANDLE 에 묶어 붙입니다. FILEHANDLE 가 식의 경우, 그 값을 실제로 파일 핸들이 요구하는 이름 (으)로서 사용합니다. EXPR 가 생략 되면(자), FILEHANDLE 와 동명의 스칼라 변수가 보관 유지하는 값이 파일명이 됩니다. 파일명의 전에 "<" 를 붙이는지, 아무것도 붙이지 않는 경우, 파일은 입력용에 오픈됩니다. 파일명이 ">" 로 시작되면(자), 파일은 출력용으로 오픈됩니다. 파일명이 ">>" 로 시작되면(자), 파일은 추가 기입용으로 오픈됩니다. ('>'나 '<'의 전에 '+'를 붙이면(자), 파일을 읽고 쓰기 양용으로 할 수 있습니다. ) 파일명이 "|" 로 시작되면(자), 파일명은 출력이 파이프 된다 명령라고 해석되어 파일명이 "|" 로 끝나면(자), 입력이 파이프 되는 명령라고 해석됩니다. (입출력공파이프 하는 명령은 필요가 없을 것입니다. ) '-'를 오픈하면(자) STDIN (을)를,'>-'를 오픈하면(자) STDOUT (을)를 오픈합니다. open 는 성공했을 때, 0 이 아닌 값을, 실패했을 때 undefined 치를 돌려줍니다. open 가 파이프를 포함한 경우, 반환값은 서브 프로세스의 pid 가 됩니다. 례:
    	$article = 100;
    	open article || die "Can't find article $article: $! \n";
    	while (<article>) {. . .
    open(LOG, '>>/usr/spool/news/twitlog');
    					# (로그 보존)
    open(article, "caesar <$article |");
    					# 기사를 decrypt
    open(extract, "|sort >/tmp/Tmp$$");
    					# $$ (은)는 현재의 프로세스
    	# 인수 리스트의 파일을, 그것이 인클루드 하는 것도
    	# 포함해 처리합니다
    	foreach $file (@ARGV) {
    		do process($file, 'fh00');	# no pun intended
    	}
    	sub process {
    		local($filename, $input) = @_;
    		$input++;		# 캐릭터 라인 인크리먼트(increment)
    		unless (open($input, $filename)) {
    			print STDERR "Can't open $filename: $! \n";
    			return;
    		}
    while (<$input>) {		# 간접 지정에 주의
    			if (/^#include "(. *)"/) {
    				do process($1, $input);
    				next;
    			}
    			. . . 		# 계속된다
    		}
    	}
    Bourne shell 의 관습에 의해, EXPR 는 ">&" 로 시작하는 것 같은 지정도 할 수 있습니다. 그 경우, 캐릭터 라인의 나머지는 파일 핸들 (숫자라면 파일 기술자)의 이름이라고 해석되어 dup 해 open 합니다. >>, <, +>, +>>, +< 의 후에 & 를 사용해도 괜찮습니다. 지정하는 모드는, 원의 파일 핸들의 모드와 일치하고 있지 않으면 되지 않습니다. 이하는, STDOUT (와)과 STDERR (을)를 보존해, 리디렉트를 행해, 그 후로 써 되돌립니다:
    	#! /usr/bin/perl
    	open(SAVEOUT, ">&STDOUT");
    	open(SAVEERR, ">&STDERR");
    	open(STDOUT, ">foo.out") || die "Can't redirect stdout";
    	open(STDERR, ">&STDOUT") || die "Can't dup stdout";
    	select(STDERR); $| = 1;		# 버퍼링 하지 않습니다
    	select(STDOUT); $| = 1;		# 버퍼링 하지 않습니다
    	print STDOUT "stdout 1\n";	# 이것이나 서브 프로세스로
    	print STDERR "stderr 1\n"; 	# 동작합니다
    	close(STDOUT);
    	close(STDERR);
    	open(STDOUT, ">&SAVEOUT");
    	open(STDERR, ">&SAVEERR");
    	print STDOUT "stdout 2\n";
    	print STDERR "stderr 2\n";
    명령 "-" 로 파이프를 오픈한다, 즉 "|-" (이)나 "-|" 를 오픈하면(자), 암묵중에 fork 되어 open 의 반환값으로서 parent process에는, child process의 pid 가 돌려주어져 child process에는 0 이 돌려주어집니다. (open 가 성공했는지 어떠했는지는, defined($pid)를 사용하고 판단해 주세요. ) 파일 핸들은, 부모에게 있어 보통 거동을 합니다만, 아이에게는 STDOUT/STDIN 에 파이프 된 파일 핸들의 i/o 가 됩니다. child process로 파일 핸들이 오픈되지 않고,--새롭고 파일 핸들은, 새롭다 STDIN (으)로부터 STDOUT 에의 파이프가 됩니다. 잘 사용되는 것은, 보통 파이프의 오픈과 같이, 파이프 명령의 실행 상태를 컨트롤 하고 싶을 때, setuid 된 프로그램을 달리게 할 때, 쉘 명령로 메타캐라크타의 체크를 할 필요가 없을 때입니다. 다음의 두 개는, 각각 어느 정도 동등합니다:
    	open(FOO, "|tr '[a-z]' '[A-Z]'");
    	open(FOO, "|-") || exec 'tr', '[a-z]', '[A-Z]';
    	open(FOO, "cat -n '$file'|");
    	open(FOO, "-|") || exec 'cat', '-n', $file;
    파이프 된 파일 핸들을 명시적으로 close 하면(자), parent process는 child process가 종료하는 것을 기다리게 되어,$? 에 상태를 돌려줍니다. fork 를 실시하는 조작에서는, 양쪽 모두의 프로세스로 플래시 되지 않는 버퍼가 그대로 남는 것에 주의해 주세요. 이것은, 이중 출력을 피하기 위해서(때문에) $| 를 세트 하는 것이 좋은 일을 의미합니다.

    open 에게 건네진 파일명은, 전후의 공백이 제외해집니다. 의도적으로 이상한 캐릭터를 포함한 파일명을 가지는 파일을 오픈하고 싶을 때는, 전후의 공백도 이와 같이 지켜 줄 필요가 있습니다:
            $file =~ s#^(\s)#. /$1#;
            open(FOO, "< $file\0");

opendir(DIRHANDLE, EXPR)
    EXPR 라는 이름의 디렉토리를 readdir(), telldir(), seekdir(), rewinddir(), closedir()로 처리할 수 있도록(듯이) 오픈합니다. 성공하면(자) 진을 돌려줍니다. DIRHANDLE 는, FILEHANDLE (와)는 별개의 그것 자신의 이름 공간을 가집니다.

ord(EXPR)

ord EXPR
    EXPR 의 최초의 캐릭터의 ASCII치를 수치로 돌려줍니다. EXPR 가 생략 되면(자),$_ 를 사용합니다.

pack(TEMPLATE, LIST)
    배열 또는 값의 리스트를 인수에 취해, 바이너리 구조체에 팩 해, 구조체를 포함한 캐릭터 라인을 돌려줍니다. TEMPLATE 는 값의 순서와 형태를 주는 캐릭터의 시퀀스로, 이하와 같이 됩니다:
    	A	ASCII 캐릭터 라인(스페이스가 padding 된다)
    	a	ASCII 캐릭터 라인(눌이 padding 된다)
    	c	signed char
    	C	unsigned char
    	s	signed short
    	S	unsigned short
    	i	signed integer
    	I	unsigned integer
    	l	signed long
    	L	unsigned long
    	n	short ("network" order)
    	N	long ("network" order)
    	f	단정밀도 부동 소수점 (native format)
    	d	배정밀도 부동 소수점 (native format)
    	p	캐릭터 라인에의 포인터
    	v	short ("VAX" (little-endian) order)
    	V	long ("VAX" (little-endian) order)
    	x	null byte
    	X	Back up a byte
    	@	절대 위치에까지 눌로 묻는다
    	u	uuencode 된 캐릭터 라인
    	b	비트 캐릭터 라인 (vec()와 같은 승순).
    	B	비트 캐릭터 라인 (내림차순).
    	h	16 진캐릭터 라인 (저 nybble 가 앞).
    	H	16 진캐릭터 라인 (고 nybble 가 앞).
    어느 캐릭터도 반복해 회수를 나타내는 수를 계속할 수가 있습니다. "a", "A", "b", "B", "h", "H" 이외의 형태에서는, pack 함수는 LIST 로부터 회수를 지정된 수만큼 값을 받습니다. 반복해 수라고 해 * 를 사용하면(자), 남아 모든 분만큼 반복합니다. "a" 와 "A" 의 형태는 값 하나 밖에 취하지 않습니다만, 반복 지정을 캐릭터 라인장 (으)로서 pack 하므로, 눌이나 공백에서의 padding 가 필요하게 됩니다. (unpack 할 때는,"A" 는, 후에 계속되는 공백을 깎습니다만,"a" 는 하지 않습니다. ) 같이"b" 와 "B" 필드는, 지정한 bit length를 pack 합니다. "h" 와 "H" 필드는, 지정한 길이의 nybbles 를 팩 합니다. 실수 (float 와 double)는, 그 머신의 기계어 포맷만입니다. 부동 소수점 포맷 관계의 다양성과 표준의 "network" 표현이 없는 것으로부터, 교환할 수 없습니다. 이것은, 어느 머신으로 pack 된 부동 소수점 데이터는, 다른 머신에서는, 비록 양쪽 모두가 IEEE 부동 소수점수(실수) 연산을 실시하고 있어도 (메모리 표현의 endian 는 IEEE 의 사양에는 없으니까), 읽을 수 없을지도 모른다고 하는 것을 의미합니다. perl 는, 모든 수치계산을 내부적으로는 double 를 이용해 double -> float -> double 라고 하는 변환은 정밀도를 잃을 것이라고 하는 것에 주의해 주세요 (즉, unpack("f", pack("f", $foo))는 일반적으로 $foo 로는 되지 않습니다).
    례:
    	$foo = pack("cccc", 65,66,67,68);
    	# foo 는 "ABCD"
    	$foo = pack("c4", 65,66,67,68);
    	# 위와 같다
    	$foo = pack("ccxxcc", 65,66,67,68);
    	# foo 는 "AB\0\0CD"
    	$foo = pack("s2", 1,2);
    	# little-endian 의 "\1\0\2\0"
    	# big-endian 의 "\0\1\0\2"
    	$foo = pack("a4","abcd","x","y","z");
    	# "abcd"
    	$foo = pack("aaaa","abcd","x","y","z");
    	# "axyz"
    	$foo = pack("a14","abcdefg");
    	# "abcdefg\0\0\0\0\0\0\0"
    	$foo = pack("i9pl", gmtime);
    	# 실제의 tm 구조체 (적어도 나의 시스템에서는)
    	sub bintodec {
    	    unpack("N", pack("B32", substr("0" x 32 .  shift, -32)));
    	}
    일반적으로 unpack 함수에서도 같은 템플릿이 사용됩니다.

pipe(READHANDLE, WRITEHANDLE)
    상당하는 시스템 콜과 같이 한 벌의 접속된 파이프를 오픈합니다. 파이프로 연결된 프로세스의 루프를 설정할 때는, 주의 깊게 하지 않으면 데드 록을 일으키는 일이 있는 것에 조심해 주세요. 거기에 더해, perl 의 파이프는 표준 입력의 버퍼링을 사용하므로, 어플리케이션에 의는은,$| 을 세트 해 명령마다 WRITEHANDLE 를 플래시 할 필요가 있을지도 모릅니다. [perl 버젼 3.0 패치 레벨 9 이상이 필요]

pop(ARRAY)

pop ARRAY
    배열의 마지막 값을 꺼내, 배열의 길이를 1 만 짧게 합니다.
    	$tmp = $ARRAY[$#ARRAY--];
    같은 결과가 됩니다. 배열에 요소가 없는 경우는, undefined 치를 돌려줍니다.

print(FILEHANDLE LIST)

print(LIST)

print FILEHANDLE LIST

print LIST

print
    캐릭터 라인 또는, 콤마 단락의 캐릭터 라인의 리스트를 표시합니다. 성공하면(자), 0 이외를 돌려줍니다. FILEHANDLE 는, 파일 핸들의 이름을 보관 유지한 스칼라 변수명에서도 괜찮습니다. 이것에 의해 1 레벨의 간접 지정을 할 수 있습니다. (주의: FILEHANDLE 가 변수로 다음의 토큰이 항의 경우,+ 를 삽입할까 인수에 괄호를 붙이지 않으면 연산자로서 해석의 실수를 할지도 모릅니다. ) FILEHANDLE 가 생략 되면(자), 디폴트로 표준 출력 (또는 마지막에 select 된 출력 채널-- select()를 참조해 주세요)에 출력합니다. LIST 가 생략 되면(자),$_ 를 STDOUT 에 출력합니다. 디폴트 출력 채널을 STDOUT 이외로 설정하려면 , select 연산자를 사용해 주세요. print 는 LIST 를 취하므로, LIST 안의의 것은 뭐든지 배열의 문맥으로 평가되어 써브루틴 호출이라면 배열의 문맥으로 평가된 식을 가지게 되는 것을 기억해 둡시다. 또, print 키워드의 뒤에 왼쪽 괄호를 둘 때는, 대응하는 오른쪽 괄호가 print 의 인수의 끝을 나타낸다 --즉 + 을 삽입하는지, 괄호를 모든 인수에 붙인다 의 나오지 않으면, 왼쪽 괄호를 두어서는 안됩니다.

printf(FILEHANDLE LIST)

printf(LIST)

printf FILEHANDLE LIST

printf LIST
    "print FILEHANDLE sprintf(LIST)" 와 동등합니다.

push(ARRAY, LIST)
    ARRAY (@ 는 생략 가능)를 스택으로서 취급해, LIST 의 값을 ARRAY 의 끝에 추가합니다. ARRAY 의 길이는, LIST 의 길이만 증가합니다. 이것은, 이하와 같은 것이 됩니다.
        for $value (LIST) {
    	    $ARRAY[++$#ARRAY] = $value;
        }
    하지만, 보다 효율적입니다.

q/STRING/

qq/STRING/

qx/STRING/
    이것은, 실제로는 함수가 아닙니다만, 쿼트 된 캐릭터 라인에 backslash를 많이 너무 두는 것 를 피하기 위한, 단순한 간략 기법입니다. q 연산자는 싱글 쿼트를 생성해, qq 연산자는 더블 쿼트를 생성합니다. qx 연산자는, 박크크트를 생성합니다. 영숫자가 아닌 캐릭터라면, 개행을 포함해 뭐든지,/ 대신에 단락지어 캐릭터 (으)로 할 수 있습니다. 단락이 (인가 { 라면, 종료의 단락은, 대응한다 )인가 } 가 됩니다. (내장하기 캐릭터로서의 } 에는 통상 대로 가 필요하게 됩니다. ) 례:
    	$foo = q! I said, "You said, 'She said it. '"! ;
    	$bar = q('This is it. ');
    	$today = qx{ date };
    	$_ . = qq
    *** The previous line contains the naughty word "$&".\n
    		if /(ibm|apple|awk)/;      # :-)

rand(EXPR)

rand EXPR

rand
    랜덤인 0 으로부터 EXPR 까지의 소수점수를 돌려줍니다. (EXPR 는 정이 아니면 안됩니다. ) EXPR 가 생략 되면(자), 0 에서 1 의 범위의 값이 돌려주어집니다. srand()를 참조해 주세요.

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

read(FILEHANDLE, SCALAR, LENGTH)
    지정된 FILEHANDLE 로부터, LENGTH 바이트의 데이터를 읽어들여, 변수 SCALAR 에 격납합니다. 실제로 읽어들일 수 있었던 바이트수를 돌려주어, 에러의 경우는 undef 를 돌려줍니다. SCALAR 는 실제로 읽힌 길이에 맞추어, 신축합니다. 읽은 데이터를 캐릭터 라인의 초가 아니고, 다른 장소에 격납하기 위해서, OFFSET 를 지정할 수도 있습니다. 이것은, 실제로는 stdio 의 fread 콜로 실장되고 있습니다. 진짜 read 시스템 콜을 사용하려면 , sysread 를 참조해 주세요.

readdir(DIRHANDLE)

readdir DIRHANDLE
    opendir()에 오픈된 디렉토리내의, 다음의 디렉토리 엔트리를 돌려줍니다. 배열의 문맥 중(안)에서 사용하면(자), 남아 모든 디렉토리 엔트리를 돌려줍니다. 엔트리가 남지 않은 경우, 스칼라의 문맥에서는 undefined 가, 배열의 문맥에서는 누르리스트를 돌려줍니다.

readlink(EXPR)

readlink EXPR
    기호 연결이 실장되고 있으면, 기호 연결의 값을 돌려줍니다. 실장되어 있지 않으면, 치명적 에러를 돌려줍니다. 시스템 우류가 일어났을 때는, undefined 치를 돌려주어,$! (errno)(을)를 세트 합니다. EXPR 를 생략 하면(자),$_ 를 사용합니다.

recv(SOCKET, SCALAR, LEN, FLAGS)
    소켓으로부터 메세지를 받아들입니다. 지정한 SOCKET 파일 핸들 (으)로부터, LENGTH 바이트의 데이터를 받아, 변수 SCALAR 에 격납합니다. sender 의 주소를 돌려주어, 에러의 경우는 undefined 치를 돌려줍니다. SCALAR 는, 실제로 읽힌 길이에 맞추어, 신축합니다. 동명의 시스템 콜과 같은 플래그를 이용합니다.

redo LABEL

redo
    redo 명령은, 조건을 재평가하는 것 없이 , 루프 블록의 커멘드를 재개합니다. continue 블록이 있어도 실행되지 않습니다. LABEL 가 생략 되면(자), 가장 안쪽의 루프를 참조합니다. 통상 이 명령은, 입력된 내용에 대해, 자기 자신을 속이는 것 같은 프로그램으로 사용됩니다:
    	# 단순화 한 Pascal 의 코멘트 제거
    	# (경고: 캐릭터 라인중에는 { 이나 } 는 없는 것과 가정하고 있습니다)
    	line: while (<STDIN>) {
    		while (s|({. *}. *){. *}|$1 |) {}
    		s|{. *}| |;
    		if (s|{. *| |) {
    			$front = $_;
    			while (<STDIN>) {
    				if (/}/) {	# 코멘트 종료?
    					s|^|$front{|;
    					redo line;
    				}
    			}
    		}
    		print;
    	}

rename(OLDNAME, NEWNAME)
    파일명을 변경합니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려줍니다. 파일 시스템의 경계를 넘어 일하지 않습니다.

require(EXPR)

require EXPR

require
    EXPR 나 EXPR 가 주어지지 않으면 $_ 으로 지정된, 프로그램 라이브러리 파일을 인클루드 합니다. 이하와 같은 써브루틴과 같은 의미가 됩니다:
    	sub require {
    	    local($filename) = @_;
    	    return 1 if $INC{$filename};
    	    local($realfilename, $result);
    	    ITER: {
    		foreach $prefix (@INC) {
    		    $realfilename = "$prefix/$filename";
    		    if (-f $realfilename) {
    			$result = do $realfilename;
    			last ITER;
    		    }
    		}
    		die "Can't find $filename in \@INC";
    	    }
    	    die $@ if $@;
    	    die "$filename did not return true value" unless $result;
    	    $INC{$filename} = $realfilename;
    	    $result;
    	}
    같은 이름으로 지정된 파일은, 두 번은 인클루드 되지 않는 것에 주의해 주세요. 어느 초기화 코드의 기동도 성공한 것 가리키기 (위해)때문에, 파일의 마지막 문장으로, 진을 돌려주지 않으면 안됩니다. 그러니까, 관습적으로 그러한 파일은, 반드시 진을 돌려준다고 하는 것이 확실하지 않으면,"1;" 로 끝나도록(듯이) 합니다.

reset(EXPR)

reset EXPR

reset
    일반적으로 루프의 끝에 변수를 클리어 하는데 continue 블록 중(안)에서 사용되어 다시 그것이 일하도록(듯이) ?? 검색을 리셋트 합니다. 식은 1 캐릭터씩 나누어 리스트 한 것 (하이픈으로 범위 지정)로서 해석됩니다. 그러한 캐릭터의 하나로 시작되는 변수나 배열은 보고초기 상태에 리셋트 됩니다. 식을 생략 하면(자), 한 번만 매치 하는 검색 (? pattern? )(을)를 리셋트 해, 다시 매치 하도록(듯이) 합니다. 현패키지내의 변수와 검색만을 리셋트 합니다. 항상 1 을 돌려줍니다. 례:
        reset 'X';	# 모든 X 변수를 리셋트 합니다
        reset 'a-z';# 소문자의 변수 모든 것을 리셋트 합니다.
        reset;	# ?? 검색을 리셋트 합니다.
    주의: ARGV 나 ENV 를 지워 버리기 (위해)때문에,"A-Z" 를 리셋트 한다 의는 권유받지 않습니다.

    dbm 연상 배열에 reset 를 사용해도, dbm 파일을 변경하지 않습니다. (그러나, perl 가 캐쉬한 엔트리는 모두 플래시 하므로, dbm 파일을 공유하고 있는 경우는, 편리합니다. 편리하지 않을지도 모릅니다만. )

return LIST
    지정한 값으로, 써브루틴으로부터 돌아갑니다. (써브루틴은, 자동적으로 마지막에 평가된 식의 값을 돌려주는 것에 주의해 주세요. 이것은, 선호되는 방법입니다--명시적인 return 의 사용으로, 약간 늦어집니다. )

reverse(LIST)

reverse LIST
    배열의 문맥에서는, LIST 의 요소를 역순에 늘어놓은 배열을 돌려줍니다. 스칼라의 문맥에서는, LIST 의 최초의 요소의 바이트열을 역순으로 했다 캐릭터 라인을 돌려줍니다.

rewinddir(DIRHANDLE)

rewinddir DIRHANDLE
    DIRHANDLE 에 관계되어, readdir()로 읽기 시작하는 현재 위치를, 디렉토리의 선두에 세트 합니다.

rindex(STR, SUBSTR, POSITION)

rindex(STR, SUBSTR)
    STR 내에서, SUBSTR 가 마지막에 나타나는 위치를 돌려주는 것 외는, index 와 완전히 같게 동작합니다. POSITION 가 지정되면(자), 그 위치 전으로 마지막에 나타난 위치를 돌려줍니다.

rmdir(FILENAME)

rmdir FILENAME
    FILENAME 로 지정된 디렉토리가 하늘이라면 소거합니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려주어,$! (errno)(을)를 세트 합니다. FILENAME 가 생략 되면(자),$_ 를 사용합니다.

s/PATTERN/REPLACEMENT/gieo
    패턴에 맞는 캐릭터 라인을 검색해, 발견되면(자) 치환 텍스트에 옮겨놓아, 치환이 행해진 수를 돌려줍니다. (이)가 아니면, 가짜 (0)를 돌려줍니다. "g" 는 옵션입니다. 만약 있으면, 매치 한 패턴은 모두 치환되는 것을 의미합니다. "i" 도 옵션입니다. 만약 있으면, 매칭은 대문자 소문자의 구별 없게 행해지는 것을 의미합니다. "e" 도 옵션입니다. 만약 있으면, 치환 캐릭터 라인은 더블 쿼트로 둘러싸인 캐릭터 라인과 같이라고 하는 것보다, 식으로서 평가되지 않으면 안 되는 것을 의미합니다. 영숫자가 아닌 캐릭터라면 뭐든지,/ 에 옮겨놓아 단락 캐릭터로 할 수 있습니다. 싱글 쿼트가 사용되면(자), 치환 캐릭터 라인 중(안)에서 변수의 삽입이 행해지지 않습니다 (e 수식자는 이것에 우선합니다). 박크크트 ` 가 사용되면(자), 치환 캐릭터 라인은 명령로서 실행되어 그 출력이 실제의 치환 텍스트로서 사용되게 됩니다. PATTERN 가 <>, ()그리고 단락지어지면(자), REPLACEMENT 는, 그것 자신의 쿼트를 가져, 그것은 <>, ()에서 만나도, 그렇지 않아도 좋게 됩니다. 예를 들면, s(foo)(bar)나 s<foo>/bar/ 와 같이. =~ (이)나 ! ~ 연산자를 개입시키는 캐릭터 라인 지정이 되지 않았을 때는,$_ 캐릭터 라인이 검색, 치환됩니다. (=~ 로 지정된 캐릭터 라인은, 스칼라 변수, 배열의 요소, 그것들에의 대입등으로 없으면 안됩니다. 즉 좌변치라고 하는 것입니다. ) 패턴이, 캐릭터 라인의 끝을 테스트하는 $ 이 아니고, 변수로 보이는 $ 을 포함한다 경우는, 그 변수가 실행시에 패턴에 삽입됩니다. 첫회만 변수가 삽입되어 컴파일 되는 패턴을 사용하고 싶으면, 끝에 "o" 를 붙여 주세요. PATTERN 가 눌 캐릭터 라인에 평가되었을 때는, 대신에 마지막에 성공한 정규 표현 하지만 사용됩니다. 정규 표현의 섹션을 참조해 주세요. 례:
        s/\bgreen\b/mauve/g;	# wintergreen 를 변경하지 않습니다
        $path =~ s|/usr/bin|/usr/local/bin|;
        s/Login: $foo/Login: $bar/; # 실행시 패턴
        ($foo = $bar) =~ s/bar/foo/;
        $_ = 'abc123xyz';
        s/\d+/$&*2/e;		# 'abc246xyz'가 된다
        s/\d+/sprintf("%5d",$&) /e;	# 'abc  246xyz'가 된다
        s/\w/$& x 2/eg;		# 'aabbcc  224466xxyyzz'가 된다
        s/([^ ]*) *([^ ]*)/$2 $1/;	# 초의 2 필드를 교환
    (마지막 예에서는 \ 대신에 $ 를 사용하고 있는 것에 주의. 정규 표현의 섹션을 참조해 주세요. )

scalar(EXPR)
    EXPR 를 강제적으로 스칼라의 문맥으로 해석시켜, EXPR 의 값을 돌려줍니다.

seek(FILEHANDLE, POSITION, WHENCE)
    FILEHANDLE 의 포인터를, 꼭 stdio 의 fseek()와 같이 임의의 위치로 합니다. FILEHANDLE 는, 파일 핸들의 이름을 주는 식에서도 괜찮습니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려줍니다.

seekdir(DIRHANDLE, POS)
    DIRHANDLE 에 대해 readdir()가 읽는 현재 위치를 세트 합니다. POS 는, telldir()가 돌려주는 값이 아니면 안됩니다. 상당하는 시스템 프로그램 라이브러리 routine 같이, directory compaction 에 대해 (은)는 같은 주의가 필요합니다.

select(FILEHANDLE)

select
    현재 select 된 파일 핸들을 돌려줍니다. FILEHANDLE 가 주어지면(자), 출력용의 현재의 디폴트 파일 핸들을 세트 합니다. 이것에는 두 개의 효과가 있습니다. 하나는, 파일 핸들이 없다 write (이)나 print 하지만, 디폴트로 이 FILEHANDLE 에 행해진다고 하는 것입니다. 둘째는, 출력에 관련하는 변수 참조가, 이 출력 채널을 참조한다 그렇다고 하는 것입니다. 예를 들면, form 포맷의 선두를, 하나 이상의 출력 채널에 세트 해야 할 때, 다음과 같이 하면 좋을 것입니다:
    	select(REPORT1);
    	$^ = 'report1_top';
    	select(REPORT2);
    	$^ = 'report2_top';
    FILEHANDLE 는, 실제의 파일 핸들의 이름을 주는 식에서도 괜찮습니다. 이와 같이:
    	$oldfh = select(STDERR); $| = 1; select($oldfh);

select(RBITS, WBITS, EBITS, TIMEOUT)
    이것은, 비트 마스크를 지정해 select 시스템 콜을 호출합니다. 비트 마스크는, 이하와 같이 fileno()나 vec()를 사용해 작성됩니다.
    	$rin = $win = $ein = '';
    	vec($rin, fileno(STDIN), 1) = 1;
    	vec($win, fileno(STDOUT), 1) = 1;
    	$ein = $rin | $win;
    많은 파일 핸들을 select 하고 싶을 때는, 써브루틴을 썼다 (분)편이 좋을지도 모릅니다.
    	sub fhbits {
    	    local(@fhlist) = split(' ',$_[0]);
    	    local($bits);
    	    for (@fhlist) {
    		vec($bits, fileno($_), 1) = 1;
    	    }
    	    $bits;
    	}
    	$rin = &fhbits('STDIN TTY SOCK');
    통상의 사용법은,
    	($nfound, $timeleft) =
    	  select($rout=$rin, $wout=$win, $eout=$ein, $timeout);
    또, 무엇인가가 ready 가 될 때까지 블록 해 두려면 , 이렇게 됩니다.
    $nfound = select($rout=$rin, $wout=$win,
    				$eout=$ein, undef);
    비트 마스크는 모두 undef 에도 할 수 있습니다. TIMEOUT 는 초에 지정되어 소수점수에서도 괜찮습니다. 주의: 모든 실장으로 $timeleft 를 돌려줄 수 있는 것은 아닙니다. 할 수 없는 경우, 항상 주어진 $timeout 에 동일한 값의 $timeleft 를 돌려줍니다.

semctl(ID, SEMNUM, CMD, ARG)
    System V IPC 함수의 semctl 를 호출합니다. CMD 가 &IPC_STAT 인가 &GETALL 라면, ARG 는 돌아가 온 semid_ds 구조체인가, semaphore치 배열을 보관 유지하는 변수가 아니면 안됩니다. ioctl 같이, 에러의 경우 undefined 치가, 0 의 경우 "0 but true" 가, 그 이외의 경우 실제의 반환값이 돌려주어집니다.

semget(KEY, NSEMS, SIZE, FLAGS)
    System V IPC 함수 semget 를 호출합니다. semaphore id 를 돌려주어, 에러의 경우는 undefined 치를 돌려줍니다.

semop(KEY, OPSTRING)
    시그널이나 wait 와 같은 semaphore 조작을 실행하는 System V IPC 함수 semop (을)를 호출합니다. OPSTRING 는, semop 구조체에 pack 된 배열이 아니면 안됩니다. 각 semop 구조체는 'pack("sss", $semnum, $semop, $semflag)'로 생성할 수 있습니다. semaphore 조작의 수는, OPSTRING 의 길이에 의합니다. 성공하면(자) 진을, 에러에서는 가짜를 돌려줍니다. 예로서 이하의 코드에서는 semaphore id $semid 의 semaphore $semnum 를 기다립니다.
    	$semop = pack("sss", $semnum, -1, 0);
    	die "Semaphore trouble: $! \n" unless semop($semid, $semop);
    semaphore에 시그널을 보내려면,"-1" 를 "1" 으로 합니다.

send(SOCKET, MSG, FLAGS, TO)

send(SOCKET, MSG, FLAGS)
    소켓에 메세지를 보냅니다. 동명의 시스템 콜과 같은 플래그를 이용합니다. 접속되어 있지 않은 소켓에서는, 발송지를 TO 로서 지정하지 않으면 되지 않습니다. 보낸 캐릭터수를 돌려줍니다. 에러의 경우는 undefined 치를 돌려줍니다.

setpgrp(PID, PGRP)
    지정한 PID 의 경향 프로세스 그룹을 세트 합니다. PID 는, 경향 프로세스에서는 0 입니다. setpgrp(2)가 실장되어 있지 않은 머신에서는, 치명적 에러가 됩니다.

setpriority(WHICH, WHO, PRIORITY)
    프로세스, 프로세스 그룹, 유저의 경향 priority를 세트 합니다. (setpriority(2)를 참조해 주세요. ) setpriority(2)가 실장되어 있지 않은 머신에서는, 치명적 에러가 됩니다.

setsockopt(SOCKET, LEVEL, OPTNAME, OPTVAL)
    리퀘스트 된 소켓 옵션을 세트 합니다. 에러에서는 undefined 를 돌려줍니다. 인수를 건네주고 싶기 때문에 없으면, OPTVAL 는 undef 치를 지정해도 괜찮습니다.

shift(ARRAY)

shift ARRAY

shift
    배열의 최초의 요소를 배열로부터 제외해, 그 요소를 돌려줍니다. 배열은 1 만 짧아져, 다른 모든 요소는 어긋납니다. 배열에 요소가 없을 때는, undefined 치를 돌려줍니다. ARRAY 를 생략 하면(자), 메인 프로그램에서는 @ARGV 배열을 shift 해, 써브루틴에서는 @_ 배열을 shift 합니다. (이것은, 사전적으로 결정되어 있습니다) unshift(), push(), pop()를 참조해 주세요. shift()와 unshift()는, push()와 pop()가 배열의 우단에 행하는 것과 같은 것을, 배열의 좌단으로 행합니다.

shmctl(ID, CMD, ARG)
    System V IPC 함수 shmctl 를 호출합니다. CMD 가 &IPC_STAT 때, ARG 는, 돌려주어진 shmid_ds 구조체를 보관 유지하는 변수가 아니면 안됩니다. ioctl 같은 반환값을 돌려줍니다. 에러에서는 undefined 치를, 0 에서는 "0 but true" 를, 그 이외에서는 실제의 값을 돌려줍니다.

shmget(KEY, SIZE, FLAGS)
    System V IPC 함수 shmget 를 호출합니다. 공유 메모리의 세그먼트(segment) id 를 돌려줍니다. 에러에서는, undefined 치를 돌려줍니다.

shmread(ID, VAR, POS, SIZE)

shmwrite(ID, STRING, POS, SIZE)
    Syste V 의 공유 메모리세그먼트 ID 를, 위치 POS 로부터 시작된다 사이즈 SIZE 에서 attach 해, copy in/out 해, detach 하는 것으로, 읽기 (와)과 기입을 행합니다. 읽기시, VAR 는 읽혀진 데이터를 보관 유지하는 변수가 아니면 되지 않습니다. 기입시에, STRING 가 너무 길면(자), SIZE 바이트만이 사용됩니다. STRING 가 너무 짧으면(자), SIZE 바이트를 묻는데 눌이 기입해집니다. 성공하면(자) 진을, 에러에서는 가짜를 돌려줍니다.

shutdown(SOCKET, HOW)
    소켓 접속을 HOW 로 지시받은 유파의 의식에 따라 셧다운 합니다. 동명의 시스템 콜과 같게 HOW 를 해석합니다.

sin(EXPR)

sin EXPR
    EXPR (라디안으로 표현)의 싸인을 돌려줍니다. EXPR 를 생략 하면(자) $_ 의 싸인을 취합니다.

sleep(EXPR)

sleep EXPR

sleep
    EXPR 초간 스크립트를 멈춥니다. EXPR 가 없으면 영구히 멈춥니다. 프로세스에 SIGALRM 를 보내는 것으로, 끼어들어집니다. 실제로 sleep 한 초수를 돌려줍니다. sleep()는, 자주 alarm()를 사용해 실장되고 있으므로, 아마 alarm()와 sleep()는 혼재시킬 수 없을 것입니다.

socket(SOCKET, DOMAIN, TYPE, PROTOCOL)
    지정된 종류의 소켓을 오픈해, 파일 핸들 SOCKET 에 묶습니다. DOMAIN, TYPE, PROTOCOL 는, 동명의 시스템 콜과 같게 지정합니다. perl 프로그램 라이브러리 파일로부터 간단하게 적당한 값을 얻으려면 , h2ph 를 sys/soket.h 에 대해서 실행할 필요가 있을지도 모릅니다. 성공하면(자) 진을 돌려줍니다. 프로세스간 통신의 섹션의 예를 참조해 주세요.

socketpair(SOCKET1, SOCKET2, DOMAIN, TYPE, PROTOCOL)
    지정된 도메인의 지정된 형태로, 무명의 소켓 페어를 생성합니다. DOMAIN, TYPE, PROTOCOL 는, 동명의 시스템 콜과 같이 지정합니다. 실장되어 있지 않은 경우는, 치명적 에러가 됩니다. 성공하면(자) 진을 돌려줍니다.

sort(SUBROUTINE LIST)

sort(LIST)

sort SUBROUTINE LIST

sort BLOCK LIST

sort LIST
    LIST 를 정렬 해, 소트 끝난 배열치를 돌려줍니다. 존재하지 않는 배열치는, 깎아집니다. SUBROUTINE 나 BLOCK 가 생략 되면(자), 표준적인 캐릭터의 비교에 의한 순서로 정렬 합니다. 0 보다 작은 정수, 0, 0 보다 큰 정수를 돌려주는 것 같은 SUBROUTINE 의 이름 (을)를 지정하면(자), 배열의 요소의 늘어놓는 방법에 따라 순서에 다시 늘어놓습니다. (<=> 와 cmp 연산자는, 이러한 routine에서는 매우 편리합니다) SUBROUTINE 는, 스칼라 변수명에서도 괜찮습니다. 그 값으로 해서 사용한다 써브루틴의 이름이 들어가 있으면 좋습니다. SUBROUTINE 명 대신에, BLOCK 를 지정해, 무명의 인 라인 정렬 써브루틴으로서 이용할 수도 있습니다.

    효율을 자주(잘) 하기 위한(해), 통상의 써브루틴 호출 코드를 우회도로 하고 있습니다. 그 때문에, 다음과 같은 영향이 있습니다. 써브루틴은 재귀적이어 안되어, 비교되는 2 요소는 @_ 을 개입시켜가 아니고, $a 와 $b 를 개입시켜 써브루틴에게 건네집니다. (이하의 예를 참조해 주세요. ) 이것들은 참조 인도이므로, $a 나 $b 를 변경 해서는 안됩니다.

    례:
    	# 사전순서의 정렬
    	@articles = sort @files;
    	# 같은 것이지만, 명시적인 정렬 routine
    	@articles = sort {$a cmp $b} @files;
    	# 같은 것이지만 역순
    	@articles = sort {$b cmp $a} @files;
    	# 수치적으로 승순으로 정렬
    	@articles = sort {$a <=> $b} @files;
    	# 수치적으로 내림차순으로 정렬
    	@articles = sort {$b <=> $a} @files;
    	# 명시적으로 써브루틴명을 사용한 정렬
    	sub byage {
    	    $age{$a} <=> $age{$b};	# 정수와 가정
    	}
    	@sortedclass = sort byage @class;
    	sub reverse { $b cmp $a; }
    	@harry = ('dog','cat','x','Cain','Abel');
    	@george = ('gone','chased','yz','Punished','Axed');
    	print sort @harry;
    		# AbelCaincatdogx 와 출력
    	print sort reverse @harry;
    		# xdogcatCainAbel 와 출력
    	print sort @george, 'to', @harry;
    		# AbelAxedCainPunishedcatchaseddoggonetoxyz 와 출력

splice(ARRAY, OFFSET, LENGTH, LIST)

splice(ARRAY, OFFSET, LENGTH)

splice(ARRAY, OFFSET)
    배열로부터 OFFSET 와 LENGTH 로 지정된 요소를 제외해, LIST 의 요소와 바꿔 넣습니다. 배열로부터 제외해진 요소를 돌려줍니다. 배열은 필요에 따라서 신축됩니다. LENGTH 를 생략 하면(자), OFFSET 로부터 앞은 모두 제외해집니다. 이하는 모두 동등이 됩니다. ($[ == 0 이라고 가정했을 경우)
    	push(@a, $x, $y) splice(@a, $#a+1, 0, $x, $y)
    	pop(@a) splice(@a,-1)
    	shift(@a) splice(@a, 0,1)
    	unshift(@a, $x, $y) splice(@a, 0,0, $x, $y)
    	$a[$x] = $ysplice(@a, $x, 1, $y);
    다음의 예에서는, 배열장은 배열 전에게 건네지면(자) 가정하고 있습니다:

    	sub aeq {	# compare two array values
    		local(@a) = splice(@_, 0, shift);
    		local(@b) = splice(@_, 0, shift);
    		return 0 unless @a == @b;	# 같은 길이?
    		while (@a) {
    		    return 0 if pop(@a) ne pop(@b);
    		}
    		return 1;
    	}
    	if (&aeq($len, @foo[1..$len], 0+@bar, @bar)) { ... }

split(/PATTERN/, EXPR, LIMIT)

split(/PATTERN/, EXPR)

split(/PATTERN/)

split
    캐릭터 라인을 캐릭터 라인의 배열로 나누어, 그 배열을 돌려줍니다. (배열의 문맥이 아닌 경우, 발견된 필드의 수를 돌려주어, split 한 것은 @_ 배열에 넣습니다. (배열의 문맥에서는, 패턴 단락으로서 ?? (을)를 사용하는 것으로 강제적으로 @_ 에 split 당합니다만, 그런데도 배열치를 돌려줍니다. )) EXPR 를 생략 하면(자),$_ 캐릭터 라인을 split 합니다. PATTERN 도 생략 하면(자), 공백 캐릭터 (/[ \t\n]+/)로 split 합니다. PATTERN 에 매치 하는 것은 뭐든지 필드를 나누는 단락이라고 해석됩니다. (단락은 1 캐릭터보다 길어도 좋은 것에 주의해 주세요. ) LIMIT 가 지정되면(자), 그것을 넘지 않는 수에 split 됩니다 (적은 경우도 있습니다). LIMIT 가 지정되지 않으면 후에 계속되는 누르피르드는 제외해집니다 (pop()를 사용하는 사람은 잘 기억해 두는 것이 좋을 것입니다). 눌 캐릭터에 매치 하는 패턴 (누르파탄 // 과 혼동하지 마세요. // (은)는 눌 캐릭터에 매치 하는 패턴의 하나에 지나지 않습니다. )(은)는, 매치 하는 모든 점으로 EXPR 를 한 글자씩에 split 합니다. 예를 들면:
    	print join(':', split(/ */, 'hi there'));
    (은)는,'h:i:t:h:e:r:e'를 출력합니다.

    LIMIT 파라미터는, 행을 부분적으로 split 하는 것에 사용됩니다.
    	($login, $passwd, $remainder) = split(/:/, $_, 3);
    (리스트에 대입할 때, LIMIT 가 생략 되고 있으면(자) perl 는 불필요한 동작을 피하기 위해서(때문에) 리스트의 변수의 수부터 하나 큰 LIMIT 를 줍니다. 상기의 리스트에서는 LIMIT 는 디폴트로 4 였다는 두입니다. 시간에 제한이 있는 어플리케이션에서는, 정말로 필요한 수이상의 필드에 (은)는 split 하지 않게 해야 합니다. )

    PATTERN 가 괄호를 포함할 때는, 단락으로서 매치 하는 캐릭터 라인에 의해, 더욱 배열 요소가 작성됩니다.

        split(/([,-])/,"1-10, 20");

    (은)는 이하의 배열치를 만듭니다.

        (1, '-', 10, ', ', 20)

    패턴 /PATTERN/ 는, 실행시로 바뀌는 패턴을 지정하는 식에서 옮겨놓고 가능합니다. (실행시 컴파일을 1회로 하고 싶으면, /$variable/o 를 사용해 주세요. ) 특별한 케이스로서 공백 (' ')을 지정하면(자), 인수 없음으로 split 한다 경우와 같습니다만, 선두에 공백이 있어도 누르피르드는 만들어지지 않습니다. 즉 split(' ')는, awk 의 디폴트의 동작을 에뮤레이트 할 수가 있는 것으로, split(/ /) (은)는 선두에 공백이 있으면(자), 최초로 그 수만큼 누르피르드를 만듭니다.

    례:
    	open(passwd, '/etc/passwd');
    	while (<passwd>) {
    ($login, $passwd, $uid, $gid, $gcos, $home, $shell)
    			= split(/:/);
    		. . .
    	}
    (위의 예의 $shell 는 개행 캐릭터를 포함합니다. chop()를 참조해 주세요. ) join (을)를 참조해 주세요.

sprintf(FORMAT, LIST)
    통상의 printf 변환으로 포맷 되는 캐릭터 라인을 돌려줍니다. * 캐릭터는 서포트되고 있지 않습니다.

sqrt(EXPR)

sqrt EXPR
    EXPR 의 평방근을 돌려줍니다. EXPR 를 생략 하면(자),$_ 의 평방근을 돌려줍니다.

srand(EXPR)

srand EXPR
    rand 연산자를 위해서(때문에), 난수용의 seed 를 세트 합니다. EXPR 를 생략 하면(자), srand(time)를 실행합니다.

stat(FILEHANDLE)

stat FILEHANDLE

stat(EXPR)

stat SCALARVARIABLE
    EXPR 라는 이름의 파일이나 FILEHANDLE 로 오픈된 파일의 정보를 나타내는 13 요소의 배열을 돌려줍니다. stat 가 실패하면(자) 누르리스트를 돌려줍니다. 보통 다음과 같이 사용합니다:
        ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size,
           $atime, $mtime, $ctime, $blksize, $blocks)
               = stat($filename);
    stat 에 특수 파일 핸들 _ 을 건네주면(자), stat 는 실행되지 않고 마지막에 행해진 stat 나 파일 테스트로 사용된 stat 구조체의 내용을 돌려줍니다. 례:
    	if (-x $file && (($d) = stat(_)) && $d < 0) {
    		print "$file is executable NFS file\n";
    	}
    (이 예는, NFS 하에서 디바이스 번호가 부가 되는 머신에서만 동작합니다. )

study(SCALAR)

study SCALAR

study
    SCALAR (지정하지 않으면 $_)에 대해, 그것이 다음으로 변경되기 전에 많은 패턴 매치를 예상해 미리 실시합니다. 검색을 하는 패턴의 성질이나 수, 검색되는 캐릭터 라인중의 캐릭터의 출현 빈도 분포 에 따라서는, 시간을 절약할 수 있을지도 모르고, 할 수 없을지도 모릅니다. --아마 이것을 사용했을 경우와 사용하지 않는 경우로, 실행시 어느 쪽이 빠른가를 비교해 보고 싶겠지요. 많은 짧은 정수 캐릭터 라인(보다 복잡한 패턴의 정수부를 포함한다)를 스캔 하는 루프로 가장 혜택을 받을 수 있겠지요. 한 번에 하나의 study 밖에 효과가 없습니다. --다른 스칼라를 study 그러자(면), 먼저 study 한 것은 "unstudied" 가 되어 버립니다. (study 의 동작의 방법은 다음과 같습니다: 검색되는 캐릭터 라인의 모든 캐릭터의 링크 리스트를 만듭니다. 그렇다면 예를 들면, 어디에 'k'의 캐릭터가 있을지를 모두 아는 것입니다. 몇개의 C 의 프로그램과 영문으로부터 작성된 통계 빈도표에 근거해, 각 검색 몬지에 도착해, 가장 빈도가 적다 캐릭터를 선택합니다. 이 "빈도가 적다" 캐릭터를 조사합니다. )

    다음의 예는, 어느 패턴을 포함한 모든 행의 전에 인덱스를 포함한 엔트리를 삽입합니다:
    	while (<>) {
    		study;
    		print ".IX foo\n" if /\bfoo\b/;
    		print ".IX bar\n" if /\bbar\b/;
    		print ".IX blurfl\n" if /\bblurfl\b/;
    		. . .
    		print;
    	}
    /\bfoo\b/ 를 검색할 때,'f'는 'o'보다 빈도가 적기 때문에,$_ 중(안)에서 'f'를 포함한 위치가 찾아집니다. 일반적으로, 병적인 경우를 제외해, 이것은 매우 잘됩니다. 유일, 최초의 시점에서 링크 리스트를 작성하기 위해서 걸리는 이상의 시간을 절약할 수 있을지가 문제가 됩니다.

    실행할 때까지 알지 않는 캐릭터 라인을 검색해야 하는 경우, 전루프를 하나의 캐릭터 라인으로서 해석해 eval 하는 것으로, 모든 패턴을 매회 재컴파일 하는 것을 피할 수가 있는 것을 기억해 둡시다. 거기에 더해 전파일이 1 레코드가 되도록(듯이) $/ 를 undef 하면(자), 몹시 빨라져, fgrep 와 같이 특수화 한 프로그램보다 빨라지는 일도 많습니다. 이하의 예는, 파일의 리스트 (@files)와 단어의 리스트 (@words)를 검색해, 매치 하는 파일명을 출력합니다:
    	$search = 'while (<>) { study;';
    	foreach $word (@words) {
    	    $search . = "++\$seen{\$ARGV} if /\\b$word\\b/;\n";
    	}
    	$search . = "}";
    	@ARGV = @files;
    	undef $/;
    	eval $search;		# 이것은(메모리 부족해) 울음 그렇게
    	$/ = "\n";		# 보통 입력 단락에 되돌리자
    	foreach $file (sort keys(%seen)) {
    	    print $file, "\n";
    	}

substr(EXPR, OFFSET, LEN)

substr(EXPR, OFFSET)
    EXPR 로부터 부분 캐릭터 라인을 꺼내, 그것을 돌려줍니다. $[ (을)를 세트 하지 않는 한, 최초의 캐릭터는 오프셋(offset) 0 입니다. OFFSET 가 부라고, 캐릭터 라인의 끝부터 OFFSET 만 멀어진 위치로부터 시작합니다. LEN 를 생략 하면(자), 종단까지의 모든 캐릭터 라인을 돌려줍니다. substr() 함수는 좌변치로서도 사용할 수 있습니다. 그 경우 EXPR 는 좌변치 (이)가 아니면 안됩니다. LEN 보다 짧은 것을 대입하면(자), 캐릭터 라인은 짧아져, 긴 것을 대입하면(자) 그것을 포함할 수 있도록(듯이) 길어집니다. 캐릭터 라인을 같은 길이에 유지하기 위해서(때문에)는, sprintf()를 사용해 패딩 또는 잘라서 버림을 해야 할지도 모릅니다.

symlink(OLDFILE, NEWFILE)
    OLDFILE 에의 기호 연결 NEWFILE 를 작성합니다. 성공하면(자) 1 을, 실패하면(자) 0 을 돌려줍니다. 기호 연결을 서포트하지 않는 시스템에서는, 실행시에 치명적 에러 됩니다. 이것을 체크하려면 , eval 를 사용합니다:
    	$symlink_exists = (eval 'symlink("","");', $@ eq '');

syscall(LIST)

syscall LIST
    리스트의 최초의 요소로 지정된 것에, 나머지의 요소를 인수로서 붙여, 시스템 콜을 호출합니다. 실장되어 있지 않으면 치명적 에러가 됩니다. 인수는 다음과 같이 해석됩니다: 주어진 인수가 숫자라면, 인수는 정수로서 건네받습니다. 그렇지 않으면, 캐릭터 라인에의 포인터가 건네받습니다. 결과가 받아들이도록(듯이), 기입해져야 할 캐릭터 라인을 충분히 길게 해 두는 것은, 당신의 책임입니다. 숫자의 인수가 리터럴이 아니고, 그것까지 숫자의 문맥으로 해석되어 없었던 것이라면, 강제적으로 숫자에 보이도록(듯이), 0 을 더할 필요가 있을지도 모릅니다.
    	# h2ph 를 실행해 둘 필요가 있을지도 모릅니다
    	require 'syscall.ph';
    	syscall(&SYS_write, fileno(STDOUT), "hi there\n", 9);

sysread(FILEHANDLE, SCALAR, LENGTH, OFFSET)

sysread(FILEHANDLE, SCALAR, LENGTH)
    시스템 콜 read(2)를 사용해, 지정한 FILEHANDLE 로부터 LENGTH 바이트의 데이터를 읽어들여, 변수 SCALAR 에 격납합니다. 이것은 표준 입출력을 경유하지 않기 때문에, read 와 혼재해 사용하면(자), 혼란할지도 모릅니다. 실제로 읽힌 바이트수를 돌려줍니다. 에러의 경우는 undef 를 돌려줍니다. SCALAR 는 실제로 읽힌 길이에 의해 신축합니다. 캐릭터 라인의 초가 아니고 도중에 데이터를 격납하도록(듯이), OFFSET 를 지정할 수 있습니다.

system(LIST)

system LIST
    "exec LIST" 와 완전히 같은 것을 행합니다만, 차이는 최초로 fork 가 실행되어, parent process는 child process가 종료하는 것을 기다리는 것입니다. 인수의 처리는, 인수의 수에 의해 바뀌는 것에 주의해 주세요. 반환값은, wait()로 돌아가는 프로그램의 종료시 스테이터스가 됩니다. 실제의 종료시 스테이터스를 얻으려면 , 256 으로 나누어 주세요. exec (을)를 참조.

syswrite(FILEHANDLE, SCALAR, LENGTH, OFFSET)

syswrite(FILEHANDLE, SCALAR, LENGTH)
    시스템 콜 write(2)를 사용해, 지정한 FILEHANDLE 에 변수 SCALAR 로부터 LENGTH 바이트의 데이터를 기입합니다. 이것은 표준 입출력을 경유하지 않기 때문에, print 와 혼재해 사용하면(자), 혼란할지도 모릅니다. 실제로 기입해진 바이트수를 돌려줍니다. 에러의 경우는 undef 를 돌려줍니다. OFFSET 로, 캐릭터 라인의 초가 아니고 도중부터 데이터를 읽도록(듯이) 지정할 수 있습니다.

tell(FILEHANDLE)

tell FILEHANDLE

tell
    FILEHANDLE 의 현재의 파일 위치를 돌려줍니다. FILEHANDLE 는, 실제의 파일 핸들의 이름을 주는 식에서도 괜찮습니다. FILEHANDLE 를 생략 하면(자), 마지막에 읽은 파일을 사용합니다.

telldir(DIRHANDLE)

telldir DIRHANDLE
    DIRHANDLE 에 대해 readdir() routine의 현재의 위치를 돌려줍니다. 이 값은, 디렉토리의 특정의 위치를 액세스 하기 위해서, seekdir()의 인수에 사용합니다. 상당하는 시스템 프로그램 라이브러리 routine 같이, directory compaction 에 대해 (은)는 같은 주의가 필요합니다.

time
    1970 년 1 월 1 일 00:00:00 (UTC)부터의 통산의 초수(윤초없음)를 돌려줍니다. gmtime()나 localtime()에 사용할 수가 있습니다.

times
    현재의 프로세스와 child process의 유저, 시스템 시간(초)부터 되는 4 요소의 배열을 돌려줍니다.

        ($user, $system, $cuser, $csystem) = times;

tr/SEARCHLIST/REPLACEMENTLIST/cds

y/SEARCHLIST/REPLACEMENTLIST/cds
    SEARCHLIST 에 있는 캐릭터가 출현하면(자), 모두 REPLACEMENTLIST 의 상당한다 캐릭터로 변환합니다. 변환 또는 삭제된 캐릭터의 수를 돌려줍니다. =~ (이)나 ! ~ 연산자를 개입시킨 캐릭터 라인의 지정을 하지 않았던 경우,$_ 캐릭터 라인이 변환됩니다. (=~ 로 지정한 캐릭터 라인은, 스칼라 변수나 배열의 요소나 그것들에의 대입 (이)가 아니면 안됩니다. 즉, 좌변치라는 것이 됩니다. ) sed 신자를 위해서(때문에), tr 의 별명 y 하지만 준비되어 있습니다. SEARCHLIST 가 [], <>, ()그리고 단락지어지고 있으면(자), REPLACEMENTLIST 은, 그것 자신의 쿼트를 가져, 그것은 [], <>, ()에서 만나도, 그렇지 않아도 좋게 됩니다. 예를 들면, tr[A-Z][a-z] 또는 tr(+-*/) /ABCD/ 와 같이 됩니다.

    c 수식자가 지정되면(자), SEARCHLIST 의 캐릭터 세트는 보간 됩니다. d 수식자가 지정되면(자), SEARCHLIST 로 지정된 캐릭터로 REPLACEMENTLIST 에 대응하는 것이 없는 것은 모두, 삭제됩니다. (이것은, SEARCHLIST 로 발견된 것을 뭐든지 삭제해 버린다 같은 tr 프로그램의 거동보다, 약간 유연합니다. ) s 수식자가 지정되면(자), 변환되어 같은 캐릭터가 계속되었을 때, 그것을 1 캐릭터로 줄입니다.

    d 수식자가 사용되면(자), REPLACEMENTLIST 는 항상 지정된 대로 해석됩니다. 그 이외의 경우로, REPLACEMENTLIST 가 SEARCHLIST 보다 짧을 때는, 같은 길이가 될 때까지 마지막 캐릭터가 반복해집니다. REPLACEMENTLIST 가 눌이라고, SEARCHLIST 가 카피됩니다. 이것은, 어느 클래스에 포함되는 캐릭터를 카운트 하거나 있는 클래스의 캐릭터의 중복을 줄일 때 편리합니다.

    례:
        $ARGV[1] =~ y/A-Z/a-z/;	# 소문자에 통일합니다
        $cnt = tr/*/*/;		# $_ 안의 * 를 셉니다
        $cnt = tr/0-9//;		# $_ 안의 숫자를 셉니다
        tr/a-zA-Z//s;	# bookkeeper -> bokeper
        ($HOST = $host) =~ tr/a-z/A-Z/;
        y/a-zA-Z/ /cs;	# 알파벳 이외를 1 캐릭터의 공백으로 합니다
        tr/\200-\377/\0-\177/;# 8 비트째를 지웁니다

truncate(FILEHANDLE, LENGTH)

truncate(EXPR, LENGTH)
    FILEHANDLE 나 EXPR 의 이름의 파일을 지정한 길이에 절약합니다. 시스템에 truncate 가 실장되어 있지 않으면 치명적 에러가 됩니다.

umask(EXPR)

umask EXPR

umask
    프로세스에 umask 를 세트 해, 변경전의 값을 돌려줍니다. EXPR 가 생략 되면(자), 단지 현재의 umask 를 돌려줍니다.

undef(EXPR)

undef EXPR

undef
    EXPR 의 값을 undefined 로 합니다. 이것은 좌변치가 아니면 안됩니다. 스칼라치, 배열 전체, 써브루틴명 (& 를 사용한다)의 경우에서만 사용할 수 있습니다. (undef 는, 아마 대부분의 예약 변수, dbm 배열치에서는 기대하는 동작이 되지 않습니다. ) undef 는, 항상 undefined 치를 돌려줍니다. EXPR 를 생략 할 수도 있습니다. 그 경우는 아무것도 undef 되지 않습니다만, 그런데도 undefined 치를 얻을 수 있습니다. 예를 들면, 써브루틴으로부터 return 할 때입니다. 례:
    	undef $foo;
    	undef $bar{'blurfl'};
    	undef @ary;
    	undef %assoc;
    	undef &mysub;
    	return (wantarray ?  () : undef) if $they_blew_it;

unlink(LIST)

unlink LIST
    리스트에 포함되는 파일을 삭제합니다. 삭제에 성공한 파일의 수를 돌려줍니다.
    	$cnt = unlink 'a', 'b', 'c';
    	unlink @goners;
    	unlink <*.bak>;
    주의: unlink 는, 자신이 슈퍼 유저로 perl 에 -U 플래그를 붙이고 있는 경우를 제외하면(자) 디렉토리를 소거는 하지 않습니다. 이러한 조건이 모였다고 해도, 디렉토리의 unlink 는 시스템에 데미지를 주는 일이 있으므로, 조심해 주세요. 대신에 rmdir 를 사용해 주세요.

unpack(TEMPLATE, EXPR)
    unpack 는 pack 의 역을 행하는: 구조체를 나타내는 캐릭터 라인을 인수에 취해, 그것을 배열치에 출력해, 배열치를 돌려줍니다. (스칼라의 문맥에서는, 생성된 최초의 값만을 돌려줍니다. ) TEMPLATE 는, pack 함수와 완전히 같은 포맷이 됩니다. 이하는, substr 를 실행하는 써브루틴입니다:
    	sub substr {
    		local($what, $where, $howmuch) = @_;
    		unpack("x$where a$howmuch", $what);
    	}
    그리고,
    	sub ord { unpack("c",$_[0]); }
    그렇다고 하는 것도 있습니다. 더욱, 필드의 앞에 %<숫자> 의 첨자를 붙이는 것으로, 항목 그 자체 대신에, 항목의<숫자>비트의 체크 섬을 갖고 싶으면 말하는 지정이 됩니다. 디폴트는, 16 비트의 체크 섬입니다. 다음의 예로, System V 의 sum 프로그램과 같은 수가 계산됩니다:
    	while (<>) {
    	    $checksum += unpack("%16C*", $_);
    	}
    	$checksum %= 65536;

unshift(ARRAY, LIST)
    시점에 의해, shift 의 역, 또는 push 의 역을 행합니다. LIST 를 배열 전에 덧붙여 새로운 배열의 요소의 수를 돌려줍니다.
    	unshift(ARGV, '-e') unless $ARGV[0] =~ /^-/;

utime(LIST)

utime LIST
    리스트의 각 파일의 액세스 시각과 최종 변경 시각을 바꿉니다. 리스트의 최초의 두 개의 요소에는,*수치*로 나타내진 액세스 시각이라고 변경 시각이 이 순서로 들어가 있지 않으면 안됩니다. 변경에 성공한 파일의 수가 돌아갑니다. 각 파일의 inode 변경 시각에는 현재 시간이 세트 됩니다. 이하는,"touch" 명령의 예입니다:
    	#! /usr/bin/perl
    	$now = time;
    	utime $now, $now, @ARGV;

values(ASSOC_ARRAY)

values ASSOC_ARRAY
    이름 첨부 연상 배열의 모든 값으로부터 되는 보통 배열을 돌려줍니다. 값은, 외관상 랜덤인 순서로 돌아가는 것처럼 보입니다만, 같은 연상 배열에 대해서, keys() 함수나 each() 함수가 생성하는 것과 같은 순서가 됩니다. keys()와 each()를 참조해 주세요.

vec(EXPR, OFFSET, BITS)
    캐릭터 라인을 unsigned integer 의 벡터로서 취급해, 지정했다 비트 필드의 값을 돌려줍니다. 대입도 할 수 있습니다. BITS는, 2 의 누승으로 1 에서 32 까지 나오지 않으면 안됩니다.

    vec()에 생성된 벡터는, 논리 연산자 |, &, ^ 그리고 조작할 수가 있어 양쪽 모두의 오퍼랜드가 캐릭터 라인 때, 비트 벡터 연산을 하는 것으로 간주해집니다. 낡은 프로그램을 지키기 위해서, 프로그램중에 적어도 하나의 vec()가 없으면 이 해석은 이루어지지 않습니다.

    비트 벡터를 0 이나 1 의 캐릭터 라인이나 배열로 변환하려면 , 이하를 사용해 주세요:
    	$bits = unpack("b*", $vector);
    	@bits = split(//, unpack("b*", $vector));
    비트의 정확한 길이를 안다면,* 대신에 사용할 수가 있습니다.

wait
    child process가 종료하는 것을 기다려, 죽은 프로세스의 pid 를 돌려줍니다. child process가 없을 때는,-1 을 돌려줍니다. 종료시 스테이터스는 $? 에 돌려주어집니다.

waitpid(PID, FLAGS)
    특정의 child process가 종료하는 것을 기다려, 죽은 프로세스의 pid 를 돌려줍니다. 그러한 child process가 없으면,-1 을 돌려줍니다. 종료시 스테이터스는 $? 에 돌려주어집니다. 다음과 같이 쓰면(자),
    	require "sys/wait.h";
    	. . .
    	waitpid(-1, &WNOHANG);
    어느 프로세스에 대해서도, non-blocking wait 를 실행할 수 있습니다. non-blocking wait 는, waitpid (2) 인가, 또는 wait4 (2) 시스템 콜을 서포트하고 있는 머신에서만 사용할 수 있습니다. 그러나, FLAGS 0 에서의 특수한 pid 의 wait 는 어디에서라도 실장되고 있습니다. (perl 는, 종료했지만 perl 스크립트에는 받아들여지지 않았다 프로세스의 스테이터스치를 기억하고 있는 것으로 시스템 콜을 에뮤레이트 합니다. )

wantarray
    현재 실행하고 있는 써브루틴의 문맥이 배열치라면 진을 돌려줍니다. 스칼라의 문맥으로 보이면, 가짜를 돌려줍니다.
    	return wantarray ?  () : undef;

warn(LIST)

warn LIST
    "die" 와 같은 메세지를 표준 에러 출력에 냅니다만, 종료하지 않습니다.

write(FILEHANDLE)

write(EXPR)

write
    지정한 파일에, 관련지을 수 있었던 포맷을 사용해, 포맷 레코드 (복수행도 가능)를 기입합니다. 디폴트로, 포맷은 파일 핸들과 같은 이름을 가지는 것에 됩니다만,$~ 변수에 포맷의 이름을 명시적으로 할당하는 것으로, 현재의 출력 채널 ( select (을)를 참조해 주세요)에 대한 포맷을 세트 해도 괜찮습니다.

    최상정도의 form 생성은 자동적으로 행해집니다: 포맷 된 레코드에 대해서, 현재의 페이지에 충분한 빈 곳이 없다 경우, 페이지 넘기기가 기입해져, 다음의 페이지로 옮깁니다. 새로운 페이지의 헤더에는, 특별한 페이지 선두 포맷이 사용되어 그 후 레코드가 기입해집니다. 디폴트로 페이지 선두 포맷은, 파일 핸들의 이름에 "_TOP" 를 덧붙인 것이 됩니다만, 파일 핸들이 select 되고 있을 때는,$^ 변수에 이름을 할당한다 일로, 좋아하는 포맷을 동적으로 세트 해도 괜찮습니다. 현재의 페이지에 남아 있는 행수는, 변수 $- 에 보관 유지되고 있습니다만, 0 을 세트 하는 것이로, 강제적으로 새로운 페이지로 옮길 수가 있습니다.

    FILEHANDLE 가 지정되지 않으면 현재의 디폴트 출력 채널에 출력됩니다. 디폴트 출력은, 기동시 STDOUT 그렇지만, select 연산자로 변경할 수 있습니다. FILEHANDLE 가 EXPR 때, 그 식이 실행시에 평가되어 결과의 캐릭터 라인이 FILEHANDLE 의 이름으로서 이용됩니다. 포맷에 대한 자세한 것은, 후술의 포맷의 섹션을 참조해 주세요.

    write 는 read 의*역이 아닌*것으로 주의해 주세요.

  우선도
perl 의 연산자는 다음과 같은 결합 규칙과 우선도를 가지고 있습니다:
없음 print printf exec system sort reverse
 chmod chown kill unlink utime die return
왼쪽에서 오른쪽 ,
오른쪽에서 왼쪽 = += -= *= 등
오른쪽에서 왼쪽 ? :
없음 . .
왼쪽에서 오른쪽 ||
왼쪽에서 오른쪽 &&
왼쪽에서 오른쪽 | ^
왼쪽에서 오른쪽 &
없음 == ! = <=> eq ne cmp
없음 < > <= >= lt gt le ge
없음 chdir exit eval reset sleep rand umask
없음 -r -w -x 등
왼쪽에서 오른쪽 << >>
왼쪽에서 오른쪽 + -
왼쪽에서 오른쪽 * / % x
왼쪽에서 오른쪽 =~ ! ~
오른쪽에서 왼쪽 !  ~ 단항의―
오른쪽에서 왼쪽 **
없음 ++ --
왼쪽에서 오른쪽 '('
초의 (분)편으로 말한 것처럼, 리스트를 인수로 하는 연산자 (print 외)나, 임의의 단항 연산자 (chdir 외)의 바로 후에 같은 행의 다음의 토큰으로서 왼쪽 괄호가 있는 경우, 괄호안의 연산자와 인수는, 꼭 통상의 함수 호출과 같게 재우선으로 간주해집니다. 례:
	chdir $foo || die;# (chdir $foo) || die
	chdir($foo) || die;# (chdir $foo) || die
	chdir ($foo) || die;# (chdir $foo) || die
	chdir +($foo) || die;# (chdir $foo) || die
그러나,* 는 || 보다 우선도가 높기 때문에:
	chdir $foo * 20;# chdir ($foo * 20)
	chdir($foo) * 20;# (chdir $foo) * 20
	chdir ($foo) * 20;# (chdir $foo) * 20
	chdir +($foo) * 20;# chdir ($foo * 20)
	rand 10 * 20;# rand (10 * 20)
	rand(10) * 20;# (rand 10) * 20
	rand (10) * 20;# (rand 10) * 20
	rand +(10) * 20;# rand (10 * 20)
괄호가 없으면 print, sort, chmod 라고 하는 리스트를 인수에 가지는 연산자는, 연산자의 좌측을 보고 있을까 우측을 보고 있을까에 의해, 매우 높지도 매우 낮지도 됩니다. 예를 들면, 다음의 예로
	@ary = (1, 3, sort 4, 2);
	print @ary;		# 1324 를 출력
sort 의 우측의 콤마는, sort 의 전에 평가됩니다만, 좌측의 콤마는, 다음에 평가됩니다. 바꾸어 말하면(자), 리스트를 인수에 취하는 연산자는, 거기에 계속되는 모든 인수를 줍는 경향에 있어, 전의 식에 따라 단일의 명령어와 같이 행동합니다. 괄호에 주의 깊지 않으면 안 되는 것을 기억해 두어 주세요:
	# 이것들을 평가하면(자), print 를 실행하기 전에 exit 합니다.
	print($foo, exit);	# 분명하게 하고 싶은 것과는 다릅니다
	print $foo, exit;	# 이것도 그렇게
	# 이것들은, exit 를 평가하기 전에 print 를 실행합니다.
	(print $foo), exit;	# 이것은 하고 싶은 것입니다
	print($foo), exit;	# 이것도 그렇게
	print ($foo), exit;	# 한층 더 이것도
또, 이것은
	print ($foo & 255) + 1, "\n";
아마 한번 봐 기대하는 동작과는 다른 것을 실행하겠지요.

  써브루틴
써브루틴은 다음과 같이 선언됩니다:
    sub NAME BLOCK

routine에게 건네진 모든 인수는, 배열 @_ 에 들어갑니다. 이것은, ($_[0], $_[1], . . . )입니다. 배열 @_ 은 로컬 배열입니다만, 그 값은 실제의 스칼라 파라미터에의 참조 (이)가 됩니다. 써브루틴의 반환값은, 마지막 식이 평가되었을 때의 값으로, 배열치에도 스칼라치로도 될 수 있습니다. 또, 리턴문은 반환값을 지정해 써브루틴을 빠지게도 사용됩니다. 로컬 변수를 작성하려면 , local 연산자를 참조해 주세요.

써브루틴은, do 연산자인가 또는 & 연산자를 사용해 불립니다.
례:
	sub MAX {
		local($max) = pop(@_);
		foreach $foo (@_) {
			$max = $foo if $max < $foo;
		}
		$max;
	}
	. . .
	$bestday = &MAX($mon, $tue, $wed, $thu, $fri);
례:
	# 행을 취득해, 공백에서 시작되는 행은
	# 계속의 행으로서 결합됩니다.
	sub get_line {
		$thisline = $lookahead;
		line: while ($lookahead = <STDIN>) {
			if ($lookahead =~ /^[ \t]/) {
				$thisline . = $lookahead;
			}
			else {
				last line;
			}
		}
		$thisline;
	}
	$lookahead = <STDIN>;	# 최초의 행을 취득합니다
	while ($_ = do get_line()) {
		. . .
	}
인수에 이름을 붙이려면 , 로컬 리스트에의 배열의 대입을 사용합니다:
	sub maybeset {
		local($key, $value) = @_;
		$foo{$key} = $value unless $foo{$key};
	}
대입은 값을 카피하므로, 이것은 참조 호출을 call by value 방편으로 바꾸는 효과도 있습니다.

써브루틴은 재귀적으로 호출할 수 있습니다. 써브루틴이 & 의 형태를 사용해 불려 갈 때, 인수 리스트는 생략 할 수 있습니다. 생략 되면(자), 써브루틴에는 @_ 배열이 세트 되지 않습니다; 그 대신해, 호출시에 @_ 배열은, 써브루틴에는 가시가 됩니다.
	do foo(1,2,3);		# 세 개의 인수를 건네줍니다
	&foo(1,2,3);		# 상과 같습니다
	do foo();		# 누르리스트를 건네줍니다
	&foo();			# 상과 같습니다
	&foo;			# 인수를 건네주지 않습니다--보다 효율적

  참조 인도
써브루틴에 배열의 값을 건네주는 것이 아니라, 그 이름을 건네주어, 써브루틴 하지만 로컬인 카피에 대해서는 아니게 글로벌인 배열을 변경할 수 있도록(듯이) 하고 싶을 때가 있겠지요. perl 에서는 이름을 가지는 모든 오브젝트에 대해서, 그 이름의 전에 * 를 붙여 참조할 수 있는: *foo 와 같이. 이것이 평가되면(자), 파일 핸들, 포맷, 써브루틴을 포함한, 그 이름을 가지는 모든 오브젝트를 나타내는 스칼라치가 됩니다. local() 연산자에 대입되었을 때, 그 이름이 거기에 대입된 * 값을 참조하게 됩니다. 례:
	sub doubleary {
	    local(*someary) = @_;
	    foreach $elem (@someary) {
		$elem *= 2;
	    }
	}
	do doubleary(*foo);
	do doubleary(*bar);
*name 에의 대입은 현재 local() 중(안)에서 밖에 권유받지 않습니다. 실제로는 *name 에의 대입은 어디서에서도 할 수 있습니다만, 그 이전의 *name 에의 참조가 영원히 꼬리를 이을지도 모릅니다. 이것에 의해 곤란한 일이 될지도 모르고, 안 될지도 모릅니다.

스칼라는 벌써 참조 인도입니다만, 이 메카니즘을 이용하지 않아도, 관심이 있는 $_[nnn] 에의 명시적인 참조를 실시하는 것으로, 스칼라의 인수를 변경할 수가 있습니다. 모든 요소를 스칼라로 건네주는 것으로, 모든 배열의 요소를 변경하는 것이 할 수 있습니다만, push 나 pop, 배열의 사이즈의 변경에는 * 메카니즘을 사용하지 않으면 안됩니다. 어떤 경우라도,* 메카니즘은 아마, 보다 효율이 좋을 것입니다.

*name 치는 표시 불능인 바이너리 데이터를 포함하므로, print 의 인수 또는 printf (이)나 sprintf 의 %s 인수로서 사용되면(자), 표시를 깨끗이 하기 위한(해) '*name'와 말하는 값이 됩니다.

통상 LIST 메카니즘은 모든 배열치를 merge 해 버려, 개개의 배열을 꺼낼 수 없게 되어 버리므로, 배열을 변경하고 싶지 않다고 해도, 이 메카니즘은 하나의 LIST 에 많은 배열을 건네주는데 편리합니다.

  정규 표현
패턴 매치로 사용되는 패턴은, 버젼 8 regexp routine로 공급 되고 있는 것과 같은 정규 표현입니다. (실제, 이 routine는 Henry Spencer 의 자유에 재배포 가능한 재실장 V8 routine (으)로부터 빼내 사용되고 있습니다. ) 거기에 더해, \w 는 영숫자 ("_" 를 포함한다)에 매치 해, \W 는 비영숫자에 매치 합니다. 단어 경계는 \b 에, 비단어 경계는 \B 에. 공백 캐릭터는 \s 에, 비공백 캐릭터는 \S 에. 숫자는 \d 에, 비숫자는 \D 에 매치 합니다. \w, \s, \d 는 캐릭터 클래스에서도 사용할 수 있습니다. 또, \n, \r, \f, \t, \NNN 는 통상과 같은 의미가 됩니다. 캐릭터 클래스 중(안)에서는, \b 는 단어 경계가 아니고, 백 스페이스를 나타냅니다. 선택 후보는,| 그리고 단락짓습니다. 괄호 구조 ( . . . )(을)를 사용하면(자), \<숫자> 는 그 숫자 번째의 부분 캐릭터 라인에 매치 합니다. (패턴의 밖에서는, 숫자의 전에 \ 대신에 항상 $ 을 이용하지 않으면 되지 않습니다. $<숫자> (와 $`, $&, $')의 유효 범위는, 닫은 블록의 끝인가, eval 캐릭터 라인인가, 다음의 패턴 매치까지됩니다. \<숫자> 기술은, 풀어에 현재의 패턴의 밖에 작용합니다만, 거기에 의지해 (은)는 안됩니다. ) 괄호는 좋아할 뿐(만큼) 많이 사용해 괜찮습니다. 9 개 이상의 부분 캐릭터 라인이 있으면(자), 변수 $10, $11, ... 하지만 대응하는 부분 캐릭터 라인을 참조합니다. 후방 참조 전에 적어도 그 수의 왼쪽 괄호가 있으면(자), 패턴 중(안)에서는, \10, \11 등이 부분 캐릭터 라인을 후방 참조합니다. 그렇지 않으면 (이전과의 호환성을 위해서(때문에)) \10 는 \010 의 백 스페이스와 같은, \11 는 \011 의 탭과 같은과 같이 됩니다. (\1 로부터 \9 는 항상 후방 참조입니다. )

$+ (은)는, 마지막 괄호로 매치 한 것을 돌려줍니다. $& (은)는, 매치 한 캐릭터 라인 전체를 돌려줍니다. ($0 가 같은 것을 돌려주고 있었습니다만, 지금은 다릅니다. ) $` (은)는 매치 한 캐릭터 라인의 전의 전문자열을 돌려줍니다. $'는 매치 한 캐릭터 라인의 뒤의 전문자열을 돌려줍니다. 례:
	s/^([^ ]*) *([^ ]*)/$2 $1/;	# 최초의 2어를 교환
	if (/Time: (. . ):(. . ):(. . )/) {
		$hours = $1;
		$minutes = $2;
		$seconds = $3;
	}
디폴트로,^ 캐릭터는 캐릭터 라인의 선두에,$ 캐릭터는 캐릭터 라인의 최후 (또는 마지막 개행 캐릭터의 전)에 매치 하는 것이 보장되고 있어 perl (은)는 캐릭터 라인이 일행 밖에 포함하지 않다고 하는 가정 아래에서, 어느 최적화를 행하고 있습니다. 개행이 파묻혔을 경우의 것 ^ 이나 $ 의 행동은, 모순을 일으키겠지요. 그러나,^ 가 캐릭터 라인내의 임의의 개행의 뒤에,$ 가 개행 전에 매치 하는 듯 , 캐릭터 라인을 복수행 버퍼로서 사용하고 싶은 경우가 있을지도 모릅니다. 약간의 오버헤드를 각오 하면, 변수 $* 에 1 을 세트 하는 것으로, 그것이 생깁니다. $* (을)를 0 으로 다시 설정하면, perl (은)는 원래의 동작으로 돌아옵니다.

복수행의 치환을 준비로 하기 위해서(때문에),. 캐릭터는 개행 캐릭터에는 매치 하지 않습니다 (비록 $* 이 0 이어도). 특히 다음의 예에서는, 개행 캐릭터가 $_ 캐릭터 라인에 남습니다:
	$_ = <STDIN>;
	s/. *(some_string). */$1/;
개행 캐릭터가 필요하지 않으면, 다음의 어떤 것인지를 시험해 주세요.
	s/. *(some_string). *\n/$1/;
	s/. *(some_string)[^\000]*/$1/;
	s/. *(some_string)(. |\n)*/$1/;
	chop; s/. *(some_string). */$1/;
	/(some_string)/ && ($_ = $1);
정규 표현의 어느 요소의 다음에도 안괄호로 둘러싼 숫자를 {n, m} 의 형태로 둘 수가 있어 n 로 요소가 매치 하는 최소의 회수를, m 로 최대의 회수를 지정합니다. {n} 의 형태는,{n, n} 와 동등해, 정확하게 n 회에 매치 합니다. {n,} 의 형태는, n 회이상으로 매치 합니다. (안괄호가 다른 문맥안에 나왔을 경우는, 통상의 캐릭터로서 다루어집니다. ) * 수식자는 {0,} 으로+ 수식자는 {1,} 으로? 수식자는 {0,1} 으로 동등이 됩니다. n 와 m 의 사이즈에는 제한이 없습니다만, 큰 숫자는 보다 많은 메모리를 소비하겠지요.

perl 그럼, \b, \w, \n 와 같은 backslash가 붙는 메타캐라크타는, 모두 영숫자인 것 (을)를 깨달아지겠지요. 다른 정규 표현 언어와는 달라, 영숫자가 아닌 backslash 심볼은 없습니다. 따라서, \\, \(, \), \<, \>, \{, \} 라고 하는 것 같은 것은 모두, 메타캐라크타가 아니고, 캐릭터 그 자체로서 해석됩니다. 이것에 의해, 메타캐라크타에 포함되는 것은 아닐까 걱정으로 되는 것 같은 캐릭터 라인을 패턴에 사용해, 인용하는 것이 용이하게 됩니다. 영숫자가 아닌 모든 캐릭터의 인용은, 이와 같이 합니다:
	$pattern =~ s/(\W) /\\$1/g;

  포맷
write 연산자로 사용하는 출력 레코드 포맷은, 다음과 같이 선언합니다:
    format NAME =
    FORMLIST
    .
NAME 를 생략 하면(자),"STDOUT" 포맷이 정의됩니다. FORMLIST 는 복수행으로부터 완성되어, 각 행은 다음의 세 개의 형태의 언젠가됩니다:

1.  코멘트

2.  하나의 출력행의 포맷을 나타낸다 "picture" 행

3.  picture 행에 값을 주는 인수행

picture 행은, 그 중에 값이 치환되는 특정의 필드를 제외하면, 외형 그대로 출력됩니다. 각 picture 필드는,@ 인가 ^ 로 시작됩니다. @ 필드 (배열의 선두의 것 @ 과 혼란하지 않게)는 통상의 경우 그리고,^ 필드는 기본적인 복수행 텍스트 블록을 묻는데 사용됩니다. 필드의 길이는,<, >, | 의 반복으로 묻는 것으로 지정해, 각각 왼쪽 맞춤, 오른쪽 대어 센터링을 의미합니다. 오른쪽 대고의 별도인 형태로서# 캐릭터를 (거기에 . (을)를 붙여도 좋다) 숫자 필드의 지정으로서 사용할 수도 있습니다. (@ 의 것인지 비교적 ^ 을 사용하면(자), undefined 인 필드가 공백이 됩니다. ) 이러한 필드에게 줄 수 있었던 값이 개행을 포함하면(자), 개행까지의 텍스트 만이 출력됩니다. 특수 필드 @* 는 복수행의 값의 출력에 사용됩니다. 그 행에 쓰여져 있는 것은 @* 뿐 아니라는 안됩니다.

값은, 다음의 행으로 지정되어 picture 필드와 같은 순서가 됩니다. 값은 콤마로 단락지어지지 않으면 안됩니다.

@ (이)가 아니고 ^ 로 시작되는 picture 필드는, 특별한 취급이 됩니다. 지정하는 값은, 텍스트 캐릭터 라인이 들어가 있는 스칼라 변수명이 아니면 안됩니다. perl (은)는, 필드에 넣어질 뿐(만큼) 많은 텍스트를 넣어 변수가 다음에 참조 될 때 다음이 출력되도록(듯이), 캐릭터 라인의 선두로부터 그 텍스트를 깎습니다. 통상, 텍스트의 블록을 출력하려면 , 수직인 스택안에 필드 의 일련을 넣어 사용합니다. 전부를 넣으려면 텍스트가 너무 길 때, 그러한 차면 마지막 필드를 . . . 그리고 끝나게 할 수도 있습니다. 변수 $: 를 좋아하는 캐릭터의 리스트로 하는 것으로, 텍스트를 분할하는 캐릭터를 바꿀 수가 있습니다.

^ 필드를 사용하면(자), 가변장의 레코드를 생성하므로, 텍스트의 포맷을 짧게 하고 싶을 때, 치르다 (~) 캐릭터를 행의 어디엔가 들어갈 수 있어 공행을 억제할 수가 있습니다. (가독성을 높이기 (위해)때문에, 보통은 할 수 있으면 유쿠토우에 들어갈 수 있어야 합니다. ) 치르다는 출력시에는 공백에 변환됩니다. 첫째에 이어 둘째의 치르다를 쓰면(자), 행중의 모든 필드가 없어질 때까지, 그 행을 반복합니다. (여러가지 @ 의 필드를 사용할 때, 주는 식은 언제나 같은 값은 아닌 것이 좋을 것입니다. )

례:
# /etc/passwd 파일의 형식
format STDOUT_TOP =
                        Passwd File
Name                Login    Office   Uid   Gid Home
------------------------------------------------------------------
.
format STDOUT =
@<<<<<<<<<<<<<<<<<< @||||||| @<<<<<<@>>>> @>>>> @<<<<<<<<<<<<<<<<<
$name,              $login,  $office, $uid, $gid, $home
.
# 버그 리포트 형식
format STDOUT_TOP =
                        Bug Reports
@<<<<<<<<<<<<<<<<<<<<<<<     @|||         @>>>>>>>>>>>>>>>>>>>>>>>
$system,                      $%,         $date
------------------------------------------------------------------
.
format STDOUT =
Subject: @<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
         $subject
Index: @<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       $index,                       $description
Priority: @<<<<<<<<<< Date: @<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
          $priority,        $date,   $description
From: @<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
      $from,                         $description
Assigned to: @<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
             $programmer,            $description
~                                    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                     $description
~                                    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                     $description
~                                    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                     $description
~                                    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                     $description
~                                    ^<<<<<<<<<<<<<<<<<<<<<<<...
                                     $description
.
같은 출력 채널에 대해서, write 를 사용해 출력을 혼합할 수 있습니다 하지만,$- (페이지의 나머지행수)를 스스로 만지지 않으면 안됩니다.

대부분이 공백의 필드가 많이 있을 때, 레코드간에 reset 연산자를 사용하는 것을 생각해야 합니다. 효율적이다고 할 뿐만 아니라, 다른 필드를 더해 버려, 0 에 하는 것을 잊어 버린다고 하는 버그를 막을 수가 있습니다.

  프로세스간 통신
perl 의 프로세스간 통신(IPC)의 능력은 Berkeley 의 소켓 기구에 기초를 두고 있습니다. 소켓이 없으면, 이 섹션은 무시할 수 있습니다. 이 호출은, 동명의 시스템 콜에 상당합니다만, 두 개의 이유로 대체로 인수는 다릅니다. 첫째는, perl 의 파일 핸들은 C 파일 기술자란 다른 동작을 한다고 하는 것입니다. 둘째는, perl 는 캐릭터 라인의 길이를 알고 있으므로, 그 정보를 건네주지 않아도 좋다고 하는 것입니다. 이하가 클라이언트의 샘플 (미테스트)입니다:
	($them, $port) = @ARGV;
	$port = 2345 unless $port;
	$them = 'localhost' unless $them;
	$SIG{'INT'} = 'dokill';
	sub dokill { kill 9, $child if $child; }
	require 'sys/socket.ph';
	$sockaddr = 'S n a4 x8';
	chop($hostname = `hostname`);
	($name, $aliases, $proto) = getprotobyname('tcp');
	($name, $aliases, $port) = getservbyname($port, 'tcp')
		unless $port =~ /^\d+$/;
($name, $aliases, $type, $len, $thisaddr) =
					gethostbyname($hostname);
	($name, $aliases, $type, $len, $thataddr) = gethostbyname($them);
	$this = pack($sockaddr, &AF_INET, 0, $thisaddr);
	$that = pack($sockaddr, &AF_INET, $port, $thataddr);
	socket(S, &PF_INET, &SOCK_STREAM, $proto) || die "socket: $! ";
	bind(S, $this) || die "bind: $! ";
	connect(S, $that) || die "connect: $! ";
	select(S); $| = 1; select(stdout);
	if ($child = fork) {
		while (<>) {
			print S;
		}
		sleep 3;
		do dokill();
	}
	else {
		while (<S>) {
			print;
		}
	}
이것이 서버측입니다:
	($port) = @ARGV;
	$port = 2345 unless $port;
	require 'sys/socket.ph';
	$sockaddr = 'S n a4 x8';
	($name, $aliases, $proto) = getprotobyname('tcp');
	($name, $aliases, $port) = getservbyname($port, 'tcp')
		unless $port =~ /^\d+$/;
	$this = pack($sockaddr, &AF_INET, $port, "\0\0\0\0");
	select(NS); $| = 1; select(stdout);
	socket(S, &PF_INET, &SOCK_STREAM, $proto) || die "socket: $! ";
	bind(S, $this) || die "bind: $! ";
	listen(S, 5) || die "connect: $! ";
	select(S); $| = 1; select(stdout);
	for (;;) {
		print "Listening again\n";
		($addr = accept(NS, S)) || die $! ;
		print "accept ok\n";
		($af, $port, $inetaddr) = unpack($sockaddr, $addr);
		@inetaddr = unpack('C4', $inetaddr);
		print "$af $port @inetaddr\n";
		while (<NS>) {
			print;
			print NS;
		}
	}

  예약 변수
다음의 변수명은, perl 에 있어 특별한 의미가 있습니다. 이러한 집몇인가는 알파벳의 심볼에도 해도 좋았습니다만, reset "a-zA-Z" 로 예약 변수까지 지워져 버리는 것 같은 일로 하고 싶지 않았습니다. 그 때문에, 이러한 이상한 심볼명에 골치를 썩이지 않으면 되지 않을 것입니다. 그 중 많게는 조리가 선 니모닉크 (기억 방법)로, 쉘의 것과 유사가 되어 있습니다.

$_  입력 및 패턴 검색의 디폴트. 다음의 조는 각각 동등합니다:
    	while (<>) {. . . 	# while 중(안)에서 마셔 동등
    	while ($_ = <>) {. . .
    	/^Subject:/
    	$_ =~ /^Subject:/
    	y/a-z/A-Z/
    	$_ =~ y/a-z/A-Z/
    	chop
    	chop($_)
    (기억하는 방법: 밑줄은 실행된다고 안다. )

$.  마지막에 읽힌 파일 핸들의 현재의 행 번호. 읽어내기 전용. 명시적인 파일 핸들의 close 에서만 행 번호가 리셋트 되는 것을 기억해 두어 주세요. <> (은)는 명시적인 close 를 행하지 않기 때문에, ARGV 파일 전부를 통해 행 번호 하지만 증가해 갑니다 (eof 의 예를 참조해 주세요). (기억하는 방법: 많은 프로그램은 . (을)를 현재행 번호의 의미로 사용한다. )

$/  입력 레코드의 단락 캐릭터. 디폴트는 개행. 눌 캐릭터 라인에 세트 되면(자) 공행을 단락으로서 취급하는 일도 포함해, awk 의 RS 변수와 같은 기능을 합니다. 복수 캐릭터에 세트 하면(자) 복수 캐릭터 단락에 매치 시킬 수가 있습니다. 파일에 공행이 연속해 있을 때, 이 변수를 "\n\n" 에 세트 하면(자),"" 에 세트 하는 경우와 조금 다른 의미를 가지는 것에 주의해 주세요. "" 에 세트 하면(자), 둘인가 그 이상이 연속한 공행을 하나의 공행으로서 취급합니다. "\n\n" 에 세트 하면(자), 공행의 뒤에 비록 개행 캐릭터가 계속되고 있어도, 다음의 단락에 포함되어 있는 것과 맹목적으로 해석됩니다. (기억하는 방법: / 은 시를 쿼트 할 때 행 경계의 단락으로서 사용할 수 있다. )

$,  print 연산자를 위한 출력 필드 단락 캐릭터. 통상은, print 연산자는 단지 콤마 단락으로 지정한 필드를 출력합니다. 보다 awk (을)를 닮은 거동을 시키기 위해서(때문에)는, 필드간에 출력하는 캐릭터를 지정한다 awk 의 OFS 변수와 같은 것을, 이 변수를 세트 해 주세요. (기억하는 방법: print문에 , 가 있을 때 출력해야할 것. )

$"" $, (와)과 닮아 있습니다만, 이 변수가 다른 점은,"" 그리고 둘러싸였다 캐릭터 라인 (또는 동일한 삽입 캐릭터)에 삽입되는 배열치에 적용되는 것입니다. 디폴트는 공백 캐릭터입니다. (기억하는 방법: 이것은 명백. )

$\  print 연산자의 출력 레코드 separator 캐릭터. 통상 print 연산자는, 후에 개행이나 레코드 separator 캐릭터를 계속되지 않았다고 추정해, 단지 콤마 단락의 지정 필드를 출력합니다. 보다 awk (을)를 닮은 거동을 시키기 위해서(때문에)는, print 의 끝나에 출력하는 캐릭터를 지정한다 awk 의 ORS 변수와 같은 것을 이 변수에 세트 해 주세요. (기억하는 방법: print 의 끝에 \n 를 더하는 대신에 $\ 를 세트. ) / 에도 닮습니다만, perl (으)로부터 "얻는다" 것입니다. )

$#  숫자의 출력을 위한 출력 포맷. 이 변수는 awk 의 OFMT 변수를 반만큼 계승하고 있습니다. 그러나 awk (와)과 perl 그럼, 실제로 무엇이 숫자인가 하는 개념이 다른 것이 자주 있습니다. 초기치도,%. 6g 가 아니고 %. 20g 이므로, awk 의 값을 얻으려면 , 명시적으로 $# 를 세트 할 필요가 있습니다. (기억하는 방법: # 은 숫자의 기호. )

$%  현재 select 되고 있는 출력 채널의 현재의 페이지 번호. (기억하는 방법: % 는 nroff 에 있어서의 페이지 번호. )

$=  현재 select 되고 있는 출력 채널의 현재의 페이지장 (출력 가능행). 디폴트는 60. (기억하는 방법: = 은 평행선. )

$-  현재 select 되고 있는 출력 채널의 페이지의 나머지행수. (기억하는 방법: 1 페이지의 행수 - 출력이 끝난행수)

$~  현재 select 되고 있는 출력 채널의 현재의 리포트 포맷명. 디폴트는, 파일 핸들명. (기억하는 방법: $^ 의 동료. )

$^  현재 select 되고 있는 출력 채널의 현재의 페이지 선두 포맷명. 디폴트는, 파일 핸들명에 "_TOP" 를 더한 것. (기억하는 방법: 선두 페이지를 가리킨다. )

$|  0 이 아닌 값을 세트 하면(자), 현재 select 되고 있는 출력 채널에 write 나 print 가 행해질 때마다 플래시 합니다. 디폴트는 0. 통상 STDOUT (은)는, 단말에 출력할 때 하행 버퍼가 사용되어 그 이외에서는 블록 버퍼가 사용되는 것에 주의해 주세요. 이 변수를 세트 하는 것은, perl 스크립트를 rsh 의 기로 달리게 하고 있을 때 등 , 파이프에 출력하고 있을 때에, 출력이 일어날 때에 확인하고 싶은 경우에 편리합니다. (기억하는 방법: 파이프를 항상 작동시켜 두고 싶다. )

$$  perl 하지만 달리게 하고 있는 스크립트의 프로세스 번호. (기억하는 방법: 쉘과 같다. )

$?  마지막에 close 한 파이프나 (``) 명령나 system 연산자의 반환값. 이것은, wait() 시스템 콜이 돌려주는 스테이터스이므로, 서브 프로세스의 종료치는 실제는 ($? >> 8)입니다. 프로세스를 종료시킨 시그널이 있었을 경우,$? & 255 는 어느 시그널인지, dump 된 core 가 있는지 어떤지를 돌려줍니다. (기억하는 방법: sh 나 ksh 와 같다. )

$&  마지막에 성공한 패턴 매치로 매치 한 캐릭터 라인. (블록내나 현재의 블록으로 닫은 eval 에서의 매치은 포함되지 않습니다. ) (기억하는 방법: 있는 에디터의 것 & 과 같다. )

$`  마지막에 패턴 매치에 성공한 패턴의 전에 있는 캐릭터 라인. (블록내나 현재의 블록으로 닫은 eval 에서의 매치은 포함되지 않습니다. ) (기억하는 방법: ` 은 대체로 쿼트 된 캐릭터 라인의 전. )

$'  마지막에 패턴 매치에 성공한 패턴의 뒤에 있는 캐릭터 라인. (블록내나 현재의 블록으로 닫은 eval 에서의 매치은 포함되지 않습니다. ) (기억하는 방법: '는 대체로 쿼트 된 캐릭터 라인의 뒤. ) 례:
    	$_ = 'abcdefghi';
    	/def/;
    	print "$`:$&:$'\n";  	# abc:def:ghi 를 출력

$+  마지막에 검색한 패턴의 마지막 괄호에 매치 합니다. 이것은, 복수 후보의 패턴 매치로 어느 쪽으로 매치 할지 모른다 때에 편리합니다. 례:
        /Version: (. *) |Revision: (. *)/ && ($rev = $+);
    (기억하는 방법: 정으로, 전방을 보는 것. )

$*  캐릭터 라인내에서, 복수행의 매치을 행할 때 1 을 세트 해, 패턴 매치의 최적화의 목적으로, 단일행을 포함한 캐릭터 라인이라고 perl 에 결정하고 치는 것에 시킬 때 0 으로 합니다. $* 하지만 0 때에 복수의 개행을 포함한 캐릭터 라인의 패턴 매치를 하면(자), 혼란한 결과가 됩니다. 디폴트는 0. (기억하는 방법: * 은 복수의 것에 매치 한다. ) 이 변수는,^ 이나 $ 의 해석에 영향을 주는 것만으로 있기로 주의해 주세요. 개행의 리터럴은, when $* == 0 이라고 해도 검색할 수 있습니다.

$0  perl 기동한 스크립트의 파일명을 보관 유지하고 있습니다. $0 수식자에의 대입은, ps(1) 프로그램의 인수의 부분을 참조해 주세요. (기억하는 방법: sh 나 ksh 와 같다)

$<숫자>
    마지막에 행한 패턴 매치로 대응하는 숫자 번째의 괄호의 서브 패턴. 상자가 된 블록내에서 이미 종료한 패턴 매치의 수는 포함되지 않습니다. (기억하는 방법: \숫자와 같다. )

$[  배열중의 최초의 요소나 부분 캐릭터 라인의 최초의 캐릭터의 첨자. 디폴트는 0 입니다만, index()나 substr() 함수의 첨자의 붙이는 방법이나 평가에 관해서, perl (을)를 awk (나 Fortran) 의 동작에 시키려면 , 이 변수에 1 을 세트 하는 것으로 할 수 있습니다. (기억하는 방법: [ 은 첨자의 시작. )

$]  "perl -v" 로 출력되는 캐릭터 라인. 이것은, perl 인터프리터가 올바른 버젼의 범위에서 스크립트를 실행하고 있는지 어떤지를 결정하기 위해서(때문에), 스크립트의 초의 (분)편으로 사용됩니다. 수치의 문맥으로 사용되면(자), 버젼 + 패치 레벨 / 1000 을 돌려줍니다. 례:
    	# getc가 시중드는지 어떤지를 조사합니다
            ($version, $patchlevel) =
    		 $] =~ /(\d+\.\d+). *\nPatch level: (\d+)/;
            print STDERR "(No filename completion available. ) \n"
    		 if $version * 1000 + $patchlevel < 2016;
    또, 수치로 사용되면(자),
    	warn "No checksumming! \n" if $] < 3.019;
    (기억하는 방법: 이 버젼의 perl 는 right(올바른, 오른쪽) 괄호에 들어가고 있어? )

$;  다차원 배열 에뮬레이션때의 첨자의 단락. 연상 배열의 요소를 다음과 같이 참조할 때,
    	$foo{$a, $b, $c}
    실제로는
    	$foo{join($;, $a, $b, $c)}
    (을)를 의미합니다만,
    	@foo{$a, $b, $c}		# 슬라이스--@ 에 주의
    (이)라고 써서는 안됩니다.
    	($foo{$a}, $foo{$b}, $foo{$c})
    (을)를 의미하게 되어 버리기 때문입니다. 디폴트는 "\034" 로, awk 의 SUBSEP 와 같습니다. 키로서 바이너리 데이터를 사용하면(자),$; 로서 안전한 값은 없을 것이라고 말한다 일을 조심해 주세요. (기억하는 방법: 콤마 (문법상 첨자의 단락)는 세미콜론의 반. 이것은, 조금 심하다. 그렇지만,$, 는 다른 것 좀 더 중요한 일로 놓치고 있으므로. )

$!  수치의 문맥으로 사용하면(자), 통상의 경고의 캐릭터 라인과 함께 errono 의 현재의 값을 돌려줍니다. (이것은, 시스템 우류와 같이 특별한 에러를 제외하면(자),$! 의 값에 의존한 동작을 시켜선 안 된다고 하는 것을 의미합니다. ) 캐릭터 라인의 문맥으로 사용하면(자), 상당하는 시스템 우류 캐릭터 라인을 돌려줍니다. errno 를 세트 하기 위해서 $! 에 대입할 수가 있습니다. 예를 들면, 에러 번호 n 에 대해서 $! 하지만 캐릭터 라인을 돌려주고 싶을 때나, die 연산자에 종료치를 세트 하고 싶을 때 등입니다. (기억하는 방법: 도대체 무엇이 폭발했어? )

$@  마지막에 평가한 명령로부터 오는 perl 의 문법 에러 메세지. 눌이라면, 마지막 평가가, 정상적으로 해석, 실행된 것이 됩니다 (기동된 연산은 보통 형태로 실패했을지도 모릅니다). (기억하는 방법: 문법 에러는 어디에 "애트 (at where)" ? )

$<  현재의 프로세스의 열매 uid. (기억하는 방법: setuid 로 달리게 하고 있을 때,*어디에서* 온 uid 인가. )

$>  현재의 프로세스의 실효 uid. 례:
    	$< = $>;	# 실효 uid 에 열매 uid 를 세트 합니다
    	($<,$>) = ($>,$<);	# 열매 uid 와 실효 uid 를 교환합니다
    (기억하는 방법: setuid 로 달리게 하고 있을 때,*행선지의* uid. ) 주의: $< 와 $> 는 setreuid()를 서포트하고 있는 머신으로 만 교환할 수 있습니다.

$(  현재의 프로세스의 열매 gid. 동시에 복수 그룹의 멤버가 되는 것을 서포트한 머신으로, 속하고 있는 그룹의 공백 단락의 리스트를 얻을 수 있습니다. 최초의 수는 getgid()가 돌려주는 것으로, 나머지가 getgroups()가 돌려주는 것입니다. 나머지안에는 최초의 수치와 같은 것도 포함되어 있을지도 모릅니다. (기억하는 방법: 괄호는 GROUP 에 사용된다. setgid 스크립트를 달리게 하고 있을 때, 열매 gid 는 LEFT(남아 있는, 왼쪽)의 그룹. )

$)  현재의 프로세스의 실효 gid. 동시에 복수 그룹의 멤버가 되는 것을 서포트한 머신으로, 속하고 있는 그룹의 공백 단락의 리스트를 얻을 수 있습니다. 최초의 수는 getegid()가 돌려주는 것으로, 나머지가 getgroups()가 돌려주는 것입니다. 나머지안에는 최초의 수치와 같은 것도 포함되어 있을지도 모릅니다. (기억하는 방법: 괄호는 GROUP 에 사용된다. setgid 스크립트를 달리게 하고 있을 때, 실효 gid 는 당신의 RIGHT(올바른, 오른쪽의) 그룹. )

    주의: $<, $>, $(, $)는, 상당하는 set[re][ug]id() routine를 서포트하고 있는 머신으로만 세트 할 수 있습니다. $(와 $)(은)는 setregid()를 서포트하고 있는 머신으로만 교환할 수 있습니다.

$:  format 의 (^ 로 시작된다) 계속 필드를 묻도록(듯이) 캐릭터 라인을 나눈다 때의 직전의 캐릭터 라인 세트. 디폴트는 " \n-" 로, 공백이나 하이픈으로 나눌 수 있습니다. (기억하는 방법: 시에서는 "코론" 하행의 일부)

$^D 디버그 플래그의 현재의 값. (기억하는 방법: -D 스윗치의 값. )

$^F 최대 시스템 파일 기술자수. 통상은 2. 시스템 파일 기술자는, child process에게 건네집니다만, 그것보다 숫자가 위의 파일 기술자는 건네받지 않습니다. open 하는 동안은, 비록 open 에 실패했다고 해도, 시스템 파일 기술자는 보존됩니다. open 가 시도되기 전에, 통상의 기술자는 close 됩니다.

$^I 파일을 그 자리에서 변경하는 경우의 확장자(extension)의 값. 그 자리에서 변경할 수 없게 하려면 , 이 변수를 undef 합니다. (기억하는 방법: -i 스윗치의 값)

$^L 개페이지 하기 위해서 출력하는 포맷. 디폴트는 \f 입니다.

$^P 디버거가, 자기 자신을 디버그 하지 않기 위해(때문에) 클리어 하는 내부 플래그. 이것을 클리어 해 두면(자), 디버그를 불가능하게하게 한다고 생각됩니다.

$^T 스크립트가 달리기 시작했을 때 각을, epoch 로부터의 초에 보관 유지합니다. -M , -A , -C 파일 테스트로 돌려주어진 값은, 이 변수의 값에 근거하고 있습니다.

$^W 경고 스윗치의 현재의 값. (기억하는 방법: -w 스윗치에 관계한다. )

$^X argv[0] 으로부터 오는, 기동된 perl 자신의 이름.

$ARGV
    <> (으)로부터 읽어들이고 있을 때, 읽기중의 파일명을 보관 유지합니다.

@ARGV
    배열 ARGV 는, 스크립트에게 건네진 명령행 인수를 보관 유지합니다. $ARGV[0] 은 명령명이 아니고, 최초의 인수이므로, $#ARGV 는 일반적으로 인수의 수 -1 입니다. 명령명에 대해서는,$0 을 참조해 주세요.

@INC
    배열 INC 는, perl 스크립트가 "do EXPR" 나 "require" 로 평가될 때 찾아져야 할 디렉토리의 리스트를 보관 유지합니다. 초기치로서 -I 명령행 스윗치의 인수, 이것에 계속되어 디폴트의 perl 프로그램 라이브러리 (아마 "/usr/share/perl"), 이것에 계속되어 커런트 디렉토리를 나타낸다 ". " 입니다.

%INC
    연상 배열 INC 는,"do" 나 "require" 를 개입시켜 잉크 루 드 되는 각 파일명을 위한 엔트리를 포함하고 있습니다. 키는, 지정한 파일명으로, 값은 실제로 파일이 발견되었다 위치의 값입니다. 이 배열은,"require" 명령이 주는 파일이 이미 인클루드가 끝난 상태인지 어떤지를 결정하는데 사용됩니다.

$ENV{expr}
    연상 배열 ENV 는, 현재의 환경 변수를 보관 유지하고 있습니다. ENV 에 값을 설정하면(자), child process의 환경이 바뀝니다.

$SIG{expr}
    연상 배열 SIG 는, 각 시그널 핸들러를 세트 하는데 사용됩니다. 례:
    	sub handler {	# 제일 인수는 시그널명
    		local($sig) = @_;
    		print "Caught a SIG$sig--shutting down\n";
    		close(LOG);
    		exit(0);
    	}
    	$SIG{'INT'} = 'handler';
    	$SIG{'QUIT'} = 'handler';
    	. . .
    	$SIG{'INT'} = 'DEFAULT';	# 디폴트 동작에 되돌린다
    	$SIG{'QUIT'} = 'IGNORE';	# SIGQUIT 를 무시한다
    SIG 배열은, perl 스크립트로 실제로 시그널용으로 세트 된 값을 보관 유지하고 있습니다.

  패키지
perl 는, 패키지간에 다른 이름 공간 가지는 메카니즘을 준비하고 있어, 각각의 변수가 부딪치지 않게, 패키지를 지키고 있습니다. 디폴트로, perl 스크립트는 패키지 "main" 로서 컴파일을 시작합니다. package 선언을 사용하는 것에 의해, 이름 공간을 바꿀 수가 있습니다. 패키지 선언의 유효 범위는, 선언 그것 자신으로부터, 닫은 블록의 종단까지 입니다 (local() 연산자와 같은 유효 범위). 보통 "require" 연산자에 의해 인클루드 된 파일안의 최초의 선언으로서 사용됩니다. 복수 개소에서 동일 패키지에 들어갈 수가 있습니다; 블록중에서 컴파일러가 어느 심볼 테이블을 사용할까에 영향을 줄 뿐입니다. 다른 패키지의 변수나 파일 핸들은, 식별자의 전에 패키지명과 싱글 쿼트를 붙이는 것으로, 참조할 수 있습니다. 패키지명이 눌의 경우,"main" 라고 해석됩니다.

캐릭터로 시작되는 식별자는, 패키지 심볼 테이블에 보존됩니다. 그 이외의 모든 심볼은, 패키지 "main" 에 보관 유지됩니다. 더욱, 식별자 STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC, SIG 는, 비록 편입의 변수, 함수와 다른 목적으로 사용되었다고 해도, 강제적으로 패키지 "main" 에 속하는 것으로서 다루어집니다. 만일,"m", "s", "y" 로 불리는 패키지를 가지고 있었다고 하면(자), 패턴 매치, 대입, 변환으로서 해석되므로, 식별자를 적합한 형태로 사용하지 못하는 것에 주의합시다.

eval 된 캐릭터 라인은, eval 가 컴파일 된 패키지내에서 컴파일 됩니다. (그러나, $SIG{} 에의 대입은, main 패키지로 지정되었다 시그널 핸들러라고 해석됩니다. 패키지내에서 시그널 핸들러를 가지고 싶은 경우, 시그널 핸들러명을 적절히 지정해 주세요. ) 예를 들면, perl 프로그램 라이브러리내의 perldb.pl 를 조사해 봅시다. 이것은 초에 DB 패키지에 바뀌어, 디버거가 디버그 하려고 해 있는 스크립트내의 변수를 변경하지 않게 되어 있습니다. 그러나, 여러가지 시점에서, main 패키지의 문맥의 여러가지 식을 평가하기 위해서, 이것은 main 패키지에 일시적으로 돌아오고 있습니다.

패키지의 심볼 테이블은, 패키지명의 전에 밑줄이 붙은 연상 배열에 저축할 수 있게 됩니다. 연상 배열의 각 엔트리의 값은, *name 표기를 사용할 때에 참조하려고 하고 있는 것이 됩니다. 실제, 다음의 예는 같은 효과 (물론 main 패키지의 경우)가 있습니다만, 최초의 것이 컴파일시에 심볼 테이블을 보므로, 보다 효율이 좋아집니다:
	local(*foo) = *bar;
	local($_main{'foo'}) = $_main{'bar'};
예를 들면, 이하에 의해 패키지내의 모든 변수를 출력할 수 있습니다. 이것은 perl 프로그램 라이브러리의 dumpvar.pl 로부터 취하고 있습니다:
	package dumpvar;
	sub main'dumpvar {
	    ($package) = @_;
	    local(*stab) = eval("*_$package");
	    while (($key, $val) = each(%stab)) {
	        {
	            local(*entry) = $val;
	            if (defined $entry) {
	                print "\$$key = '$entry'\n";
	            }
	            if (defined @entry) {
	                print "\@$key = (\n";
	                foreach $num ($[ .. $#entry) {
	                    print "  $num\t'", $entry[$num],"'\n";
	                }
	                print ") \n";
	            }
	            if ($key ne "_$package" && defined %entry) {
	                print "\%$key = (\n";
	                foreach $key (sort keys(%entry)) {
	                    print "  $key\t'", $entry{$key},"'\n";
	                }
	                print ") \n";
	            }
	        }
	    }
	}
비록 써브루틴이 패키지 dumpvar 로 컴파일 된다고 해도, 써브루틴명이 패키지 "main" 에 삽입되도록(듯이), 써브루틴명의 전에 패키지명을 적지 않으면 안 되는 것에 주의해 주세요.

  스타일
각각의 프로그래머는, 포맷에 관해서 물론 자기 자신의 취향이 있겠지만, 자신의 프로그램을 읽기 쉽고하기 위한 일반적인 가이드 라인이 있습니다.

1.  있는 것을 특별한 방법으로*완성되는*으로부터라고 해, 그렇게 해야 한다 그 말은 없습니다. perl (은)는, 하나의 일을 할 경우에, 몇개의 방법이 있도록(듯이) 설계되고 있다 의로, 가장 읽기 쉬운 것을 선택하도록(듯이) 생각해 주세요. 예를 들면
        open(FOO, $foo) || die "Can't open $foo: $! "; (은)는,
        die "Can't open $foo: $! " unless open(FOO, $foo); 보다 좋습니다. 왜냐하면, 후자의 방법은 문장의 주제를 수식자내에 숨기고 있기 때문입니다. 한편,
        print "Starting analysis\n" if $verbose; 하
        $verbose && print "Starting analysis\n"; 보다 좋습니다. 주가 되는 것은, 유저가 -v 를 쳤는지 어떠했는지에서는 없기 때문입니다.

    같이 연산자가 디폴트의 인수를 가정하고 있다고 해도, 그것은 디폴트를 이용하지 않으면 안 된다고 하는 것이 아닙니다. 디폴트라는 것은, 약간의 프로그램을 쓰는, 게으름뱅이의 시스템 프로그래머를 위해서(때문에) 있습니다. 읽기 쉬운 프로그램을 하고 싶으면, 인수를 붙이도록(듯이) 해 주세요.

    같은 일로서 여기저기에서 괄호를 생략 할 수 있다 그 말은, 이하와 같이 쓰라고 말하는 것이 아닙니다:
    	return print reverse sort num values array;
    	return print(reverse(sort num (values(%array))));
    의심스러울 때는, 괄호를 붙여 주세요. 어쩌면, 호기심인 배가, vi 로 % 키를 두드릴지도 모릅니다.

    비록 의심스럽지 않았다고 해도, 자신의 다음에 그 코드를 관리하는 인간의 정신 위생상 바람직하며, 그 사람이 잘못한 것에 괄호를 붙일 가능성도 많이 있습니다.

2.  무리하게 억지 써, 루프의 선두나 마지막으로 종료하려고 하지 말아 주세요. perl 에는, 한가운데로부터에서도 빠질 수 있도록(듯이) "last" 연산자가 준비되어 있으니까. 조금은 보고 내도, 보다 보기 쉬워지도록(듯이) 해 주세요:
        line:
    	for (;;) {
    	    statements;
    	last line if $foo;
    	    next line if /^#/;
    	    statements;
    	}

3.  루프 label를 사용하는 것을 공무늬 말아 주세요--다중 루프의 누락이고가로 오도록(듯이) 하기 위한(해) 뿐만이 아니고, 가독성을 높이기 위해서(때문에) 있으니까. 마지막 예를 참조해 주세요.

4.  가반성이기 때문에, 모든 머신에는 실장되어 있지 않은 기능을 사용할 때는, 실패하지 않는지 어떤지, eval 중(안)에서 구성을 확인해 봐 주세요. 어느 버젼이나 패치 레벨로 특정의 사양이 실장되고 있을까를 알고 있다면,$] 을 조사해, 실장되고 있는지 어떤지를 확인할 수 있습니다.

5.  기억하기 쉬운 식별자를 선택해 주세요.

6.  일관성을 갖게합시다.

  디버그
perl 에 -d 스윗치를 붙여 기동하면(자), 디버그 모니터의 기로 스크립트가 달립니다. 최초의 실행문의 앞에서 일시정지해, 이하와 같은 명령 입력을 재촉합니다:

h   헬프 메세지를 출력한다.

T   스택 트레이스.

s   싱르스텝. 다음의 문장의 초에 이를 때까지를 실행합니다.

n   차. 써브루틴 콜내에서는 멈추지 않고 , 다음의 문장에 이를 때까지 실행합니다.

f   종료. 현재의 써브루틴이 종료할 때까지, 문장을 계속 실행합니다.

c   계속. 다음의 breakpoint에 이를 때까지 실행합니다.

c line
    지정한 행까지 실행합니다. 지정한 행에, 일회뿐의 breakpoint를 삽입합니다.

<CR>
    마지막에 실행한 n 또는 s 를 반복합니다.

l min+incr
    min 행 눈으로부터 incr+1 행을 표시합니다. min 를 생략 하면(자), 마지막에 표시한 나머지로부터 시작합니다. incr 를 생략 하면(자), 전회의 incr 치가 사용됩니다.

l min-max
    지정 범위내의 행을 표시합니다.

l line
    지정행을 표시합니다.

l   다음의 윈도우를 표시합니다.

-   전의 윈도우를 표시합니다.

w line
    그 행과 전후의 윈도우를 표시합니다.

l subname
    써브루틴을 표시합니다. 긴 써브루틴의 경우는, 초의 (분)편만을 표시합니다. 그 이상 표시하려면 ,"l" 를 사용해 주세요.

/pattern/
    정규 표현의 전방 검색. 마지막 / 은 생략 가능합니다.

? pattern?
    정규 표현의 후방 검색. 마지막 ? (은)는 생략 가능합니다.

L   breakpoint 또는 액션의 설정된 행을 표시합니다.

S   모든 써브루틴명을 표시합니다.

t   트레이스 모드를 on/off 하는 타글.

b line condition
    breakpoint를 세트 합니다. line 를 생략 하면(자), 실행 되려고 하고 있는 행에 세트 됩니다. condition 가 지정되면(자), breakpoint의 문장에 이를 때마다 condition 가 평가되어 condition 가 진정한 때만 브레이크합니다. breakpoint는 실행문의 선두에만 세트 할 수 있습니다.

b subname condition
    breakpoint를 써브루틴의 최초의 실행문에 세트 합니다.

d line
    breakpoint를 삭제합니다. line 를 생략 하면(자), 실행하려고 하고 있는 행의 breakpoint가 삭제됩니다.

D   모든 breakpoint를 삭제합니다.

a line command
    행에 액션을 세트 합니다. backslash의 직후에 개행하면, 복수행 명령도 입력할 수 있습니다.

A   모든 행의 액션을 삭제합니다.

< command
    디버거가 prompt를 내기 전에 실행하는 액션을 세트 한다. backslash의 직후에 개행하면, 복수행 명령도 입력할 수 있습니다.

> command
    명령을 입력해 스크립트 실행으로 옮길 때에, prompt의 뒤에 실행하는 액션을 세트 합니다. backslash의 직후에 개행하면, 복수행 명령도 입력할 수 있습니다.

V package
    패키지내의 모든 변수를 리스트 합니다. 디폴트는, 메인 패키지입니다.

!  number
    디버그 명령의 재실행을 행합니다. number 가 생략 되면(자), 직전의 명령을 재실행합니다.

!  -number
    몇이나 전의 명령을 재실행합니다.

H -number
    마지막 n 개의 명령을 표시합니다. 1 캐릭터보다 긴 명령을 리스트 합니다. number 를 생략 하면(자), 모든 것을 리스트 합니다.

q or ^D
    종료합니다.

command
    명령을 perl 의 문장으로서 실행합니다. 부족한 세미콜론은 보충해집니다.

p expr
    "print DB'OUT expr" 와 같은 것입니다. DB'OUT 파일 핸들은, 어디에 STDOUT 가 리디렉트 되고 있을까 에 관련되지 않고, /dev/tty 에 오픈됩니다.

디버거를 변경하고 싶을 때는, perldb.pl 파일을 perl 의 프로그램 라이브러리 (으)로부터, 커런트 디렉토리에 카피해, 필요에 따라서 수정해 주세요. (명령행에 -I. (을)를 붙이지 않으면 되지 않을 것입니다. ) 초기화 코드를 포함한 .perldb 파일을 설정하는 것으로, 커스터마이즈가 할 수 있습니다. 예를 들면, 이하와 같은 앨리어스(alias)를 만들 수가 있습니다:
    $DB'alias{'len'} = 's/^len(. *) /p length($1)/';
    $DB'alias{'stop'} = 's/^stop (at|in) /b/';
    $DB'alias{'. '} =
      's/^\. /p "\$DB\'sub(\$DB\'line) :\t", \$DB\'line[\$DB\'line]/';

  setuid 스크립트
perl (은)는, 안전한 setuid 스크립트나 setgid 스크립트를 간단하게 쓸 수 있도록(듯이) 디자인되고 있습니다. 스크립트의 각 행이 몇번이나 치환되는 쉘과는 달라, perl (은)는, 숨겨졌다 "(뜻)이유가 알지 않는 걸" 를 줄여, 보다 전통적인 평가 기구를 사용하고 있습니다. 거기에 더해 이 언어는 짜넣어 기구를 보다 많이 갖추고 있어, 목적을 달성한다 위해(때문에) 외부의 (즉 신뢰할 수 없을 가능성이 있다) 프로그램에 의지하지 않으면 안 되는 것은, 거의 없습니다.

패치가 맞지 않은 4.2 또는 4.3bsd 커널에서는, setuid 스크립트는 본질적으로 위험을 배고 있습니다만, 이 커널의 기능은 무효로 할 수 있습니다. 이 경우, perl 스크립트에 (무의미한) setuid/gid 비트가 붙어 있으면(자), perl (은)는 setuid 와 setgid 기구를 에뮤레이트 할 수 있습니다. 커널의 기능이 무효가 아닌 경우, perl (은)는 setuid 스크립트가 안전하지 않은 것을 시끄럽게 호소하겠지요. 커널의 setuid 스크립트 기능을 무효로 하는지, 그렇지 않으면 스크립트에 C 의 나팔을 씌울 필요가 있겠지요.

perl 가 setuid 스크립트를 실행하고 있을 때, 분명한 트랩에 빠져 있지 않게 특별한 주위를 기울입니다. (몇개의 점으로, perl 스크립트는 동등의 C 프로그램보다 안전합니다. ) 명령행 인수와 환경 변수와 입력은,"더러움" 로 간주해져 서브 쉘을 기동하는 명령나, 파일, 디렉토리, 프로세스를 변경하는 것 같은 명령 중(안)에서는, 직접도 간접적으로도 사용되지 않습니다. 그 이전에 더러워진 값을 참조한 것 같은 식 중(안)에서 세트 된 변수도, 또 더러워져 있는 것 됩니다. (더러워진 값이 변수에 영향을 주는 것이, 비록 논리적으로 불가능하다고 해도)
예를 들면:
	$foo = shift;			# $foo 는 더러워져 있습니다
	$bar = $foo,'bar';		# $bar 도 더러워져 있습니다
	$xxx = <>;			# 더러워져 있습니다
	$path = $ENV{'PATH'};	# 더러워져 있습니다만, 이하를 봐 주세요
	$abc = 'abc';			# 더러워져 있지 않습니다
	system "echo $foo";		# 위험합니다
	system "/bin/echo", $foo;	# 안전합니다 (sh를 사용하지 않기 때문에)
	system "echo $bar";		# 위험합니다
	system "echo $abc";		# PATH 가 세트 될 때까지,
					# 안전하지는 않습니다
	$ENV{'PATH'} = '/bin:/usr/bin';
	$ENV{'IFS'} = '' if $ENV{'IFS'} ne '';
	$path = $ENV{'PATH'};		# 더러워져 있지 않습니다
	system "echo $abc";		# 이미 더러워져 있지 않습니다!
	open(FOO,"$foo");		# OK
	open(FOO,">$foo"); 		# 안됩니다
	open(FOO,"echo $foo|");	# 안되지만..
	open(FOO,"-|") || exec 'echo', $foo;	# OK
	$zzz = `echo $foo`;		# 위험.  zzz 는 더러워져 있습니다.
	unlink $abc, $foo;		# 위험
	umask $foo;			# 위험
	exec "echo $foo";		# 위험
	exec "echo", $foo;		# 안전 (sh 를 사용하지 않습니다)
	exec "sh", '-c', $foo;	# 안전이라고 보여져 버리는, 오호
더러움은, 각 스칼라치와 관계하므로, 배열의 요소는 더러워져 있는 것도, 더러워지지 않은 것도 있습니다.

무엇인가 안전하지 않은 것을 하려고 하면(자), "Insecure dependency" 라든지 "Insecure PATH" 라고 하는 것 같은 치명적 에러가 됩니다. 그런데도, 위험한 시스템 콜이나 exec 를 쓸 수가 있습니다만, 상기의 마지막 예의 같은 일을 명시적으로 행했을 경우에 한정한다고 하는 것을 기억해 두어 주세요. 서브 패턴을 참조하는 것도, 더러움의 기구를 피하는 것이 할 수 있습니다 --perl (은)는,$1, $2 등을 사용한 부분 캐릭터 라인의 참조에서는, 자신이 하고 있는 것을 알고 있을 것이라고 해석합니다. 다음과 같은 패턴의 경우입니다:
	$ARGV[0] =~ /^-P(\w+)$/;
	$printer = $1;		# 더러워져 있지 않습니다
이것은, \w+ 가 쉘의 메타캐라크타에 매치 하지 않기 때문에, 우선 안전합니다. . + (을)를 사용하면(자) 위험하겠지만, perl (은)는 거기까지 조사하지 않기 때문에, 패턴 지정에는 주위를 기울여야 합니다. 이것은, 파일 조작을 하고 싶을 때에 ($> 를 $< 과 같게 하지 않으면), 유저가 주는 파일명을 더럽히지 않기 위한 유일한 기구입니다.

더러워진 값을 사용하는 것을 신경쓰지 않는 것 같은 다른 조작에서도 트러블을 일으키는 경우가 있습니다. 유저가 준 파일명을 취급하는 파일 테스트는, 신중하게 사용해 주세요. 할 수 있으면,$> = $< 과 같이 세트 한 다음에 open 해 주세요. perl 그럼, 더러워진 파일을 오픈해 읽어내는 것이 제한되지 않기 때문에, 출력하는 내용에 대해서는 주의해 주세요. 더러움의 기구는, 어리석은 실수를 막도록(듯이) 만들어지고 있는 것에서 만나며, 생각할 필요가 없어지도록(듯이) 하기 위한(해)가 아닙니다.

환경

HOME
    chdir 에 인수가 없을 때에 사용됩니다.

LOGDIR
    chdir 에 인수가 없고, HOME 가 세트되어 있지 않을 때에 사용됩니다.

PATH
    서브 프로세스를 실행할 때, 및 -S 가 사용되었을 때는 스크립트를 찾을 때에 사용됩니다.

PERLLIB
    표준 프로그램 라이브러리나 커런트 디렉토리를 보기 전에, perl 프로그램 라이브러리 파일을 찾는 디렉토리의 코론 단락의 리스트입니다.

PERLDB
    디버거 코드를 얻는데 사용되는 명령입니다. 세트 되어 없으면
        require 'perldb.pl' (을)를 사용합니다.

이것들을 따로 하면(자), perl (은)는, 스크립트 실행시로 child process에게 건네진 환경 변수 밖에 사용하지 않습니다. 그러나, setuid 로 달리고 있는 스크립트는, 속지 않게 하기 위해서 무엇보다 먼저 이하의 행을 실행해 두는 것이 좋을 것입니다:
    $ENV{'PATH'} = '/bin:/usr/bin';    # 필요한 패스를 입금시킵시다
    $ENV{'SHELL'} = '/bin/sh' if $ENV{'SHELL'} ne '';
    $ENV{'IFS'} = '' if $ENV{'IFS'} ne '';

저자
Larry Wall <lwall@netlabs.com>
MS-DOS 에의 이식 Diomidis Spinellis <dds@cc.ic.ac.uk>

관련 파일
/tmp/perl-eXXXXXX -e 명령을 위한 임시 파일

관련 항목
a2p    awk 로부터 perl 에의 변환 프로그램
s2p    sed 로부터 perl 에의 변환 프로그램

진단
compile error는, 에러의 행 번호와 다음에 있어야 할 토큰인가, 또는 조사할 수 있었던 토큰의 형태를 가르쳐 줍니다. ( -e 스윗치로 perl 에게 건네진 스크립트의 경우, 각 -e 하지만 일행으로 꼽힙니다. )

setuid 스크립트에는, 더욱 "Insecure dependency" 와 같은 에러 메세지를 일으킨다고 하는 제약이 있습니다. setuid 스크립트의 섹션을 참조해 주세요.

트랩
awk 에 익숙한 유저는, 이하에 특별히 주위를 기울이지 않으면 안됩니다:

*   perl 그럼, (블록의 마지막을 제외하다) 모든 단문의 뒤에 세미콜론이 필요합니다. 개행은 문장의 단락이 아닙니다.

*   if 나 while 에는, 안괄호 {} 가 필요합니다.

*   perl 그럼, 변수는 $ 인가 @ 로 시작됩니다.

*   배열의 첨자는,$[ 을 세트 하지 않으면 0 으로 시작됩니다. substr()와 index()의 캐릭터 위치도 같습니다.

*   배열의 첨자가 숫자일까 캐릭터 라인일까를 결정하지 않으면 안됩니다.

*   연상 배열은, 참조하는 것 만으로는 존재하게 되지 않습니다.

*   비교 시에는, 캐릭터 라인 비교인가, 수치 비교인지를 결정하지 않으면 안됩니다.

*   입력행을 읽어들인 것 만으로는, split 하행인 깨지지 않습니다. 스스로 split 해, 배열에 넣지 않으면 안됩니다. 그리고, split 연산자는, 다른 인수를 취합니다.

*   현재의 입력행은, 통상 $0 은 아니고 $_ 입니다. 일반적으로 개행 코드는 제외해지지 않습니다. ($0 는 실행된 프로그램명입니다. )

*   $<숫자> 는, 필드의 참조가 아닙니다--마지막에 매치 했다 패턴의 부분 캐릭터 라인을 참조합니다.

*   print 문장은 $, 이라고 $\ 를 설정하지 않으면, 필드 단락이나 레코드 단락을 출력하지 않습니다.

*   파일에 출력하기 전에는, 오픈하지 않으면 안됩니다.

*   범위 연산자는 ". . " 이며, 콤마가 아닙니다. (콤마 연산자는, C 와 같은 동작입니다. )

*   매치 연산자는,"~" 가 아니고 "=~" 입니다. ("~" 는 C 와 같이 보수의 연산자입니다. )

*   지수 연산자는,"^" 가 아니고 "**" 연산자입니다. ("^" 는, C 와 같이 XOR 연산자입니다. )

*   결합 연산자는 ". " 이며, 눌 캐릭터 라인이 아닙니다. (눌 캐릭터 라인을 사용하면(자) 3 번째의 것 / 이 제산 연산자라고 해석되기 (위해)때문에, "/pat/ /pat/" 가 해석 불능이 됩니다. --토큰 해석은, 실제
     /, ?, < (와)과 같은 연산자에서는 문맥에 약간 민감합니다. 그리고, 실은,. 자신은 숫자의 초가 될 수 있습니다. )

*   next, exit, continue 의 동작은 다릅니다.

*   다음의 변수의 동작은 다릅니다.
    	  Awk	Perl
    	  ARGC	$#ARGV
    	  ARGV[0]	$0
    	  FILENAME$ARGV
    	  FNR	$.  - 무엇인가
    	  FS	(뭐든지 좋다)
    	  NF	$#Fld 과소와 같은 것
    	  NR	$.
    	  OFMT	$#
    	  OFS	$,
    	  ORS	$\
    	  RLENGTH	length($&)
    	  RS	$/
    	  RSTART	length($`)
    	  SUBSEP	$;

*   의심스러울 때는, awk 의 프로그램을 a2p 에 통해, 나온 것 봐 주세요.

C 에 세뇌된 프로그래머는, 다음 일을 특별히 명심해 언덕 없으면 되어 선:

*   if 나 while 에는, 안괄호 {} 가 필요합니다.

*   "else if" 가 아니고,"elsif" 를 사용하지 않으면 안됩니다.

*   break (이)나 continue (은)는, 각각 last (이)나 next (이)가 됩니다.

*   switch 문은 없습니다.

*   perl 그럼, 변수는 $ 인가 @ 로 시작됩니다.

*   printf 에는 * 은 실장되고 있지 않습니다.

*   코멘트는,/* 이 아니고 # 로 시작됩니다.

*   누구의 주소를 얻을 수도 있습니다.

*   ARGV 는 대문자가 아니면 안됩니다.

*   link, unlink, rename 등의 시스템 콜은, 성공시에 0 나오는거야 구, 비 0 을 돌려줍니다.

*   시그널 핸들러는, 숫자는 아니고 시그널명을 취급합니다.

경험 풍부한 sed 프로그래머는, 다음 일을 명심해 두지 않으면 안됩니다:

*   치환의 후방 참조에서는, \ 가 아니고 $ 를 사용합니다.

*   파탄맛치메타캐라크타 (, ), | 의 전에는 backslash를 붙이지 않습니다.

*   범위 연산자는, 콤마가 아니고 . . 입니다.

날카로운 shell 프로그래머는, 다음 일을 명심해 두지 않으면 안됩니다:

*   `` 연산자의 명령내에서는, ''고기구등라고 없으면 변수 치환이 행해집니다.

*   `` 연산자는 csh 와 달리, 반환값의 변환을 하지 않습니다.

*   쉘 (특히 csh)는, 각 명령행으로 복수 레벨의 치환을 행합니다. perl (은)는,"", ``, <>, // 와 같이 정해진 구조에 대해서만, 치환이 행해집니다.

*   쉘은, 스크립트를 한 번에 약간 해석합니다. perl (은)는, 모든 프로그램을 실행전에 컴파일 합니다.

*   인수는,$1, $2,.. (이)가 아니고, @ARGV 를 개입시켜 이용할 수 있습니다.

*   환경은, 변수로서 자동적으로 이용 가능하다고는 되지 않습니다.

정정과 추가
perl 의 책, Programming Perl 에는 이하와 같은 생략과 누락이 있습니다.

5 페이지의 예
	eval "/usr/bin/perl
(은)는, 이하가 아니면 안됩니다.
	eval "exec /usr/bin/perl

195 페이지의 System V 의 sum 상당한 프로그램은, 지극히 작은 파일 그리고 밖에 동작하지 않습니다. 큰 파일에서는, 이하를 사용해 주세요.
	undef $/;
	$checksum = unpack("%32C*",<>) % 32767;

alarm 와 sleep 에 관한 기술은, 시그널 SIGALARM 라고 말하고 있습니다만, SIGALRM 가 아니면 안됩니다.

$/ 의 초기치를 세트 한다 -0 스윗치는, 이 책이 출판 후에 perl 에 추가되었습니다.

-l 스윗치에서는, 자동 줄 끝 처리를 행하게 되어 있습니다.

qx// 구조는 backslash `` 와 동의입니다.

$0 (은)는, ps (1) 의 인수 표시를 변경하기 위해서, 대입 가능해졌습니다.

새롭다 @###. ## 포맷은, 포맷의 기술로부터 우연히 생략 되었습니다.

s///ee 가 치환식의 다중 평가를 일으키는 것이, 출판시에 알려져 있지 않았습니다. 이것은, 사양이라고 해석되어야 합니다.

(LIST) x $count 는, 배열의 반복을 실행합니다.

정규 표현에는, 괄호의 수에 제한이 없어져 있습니다.

더블 쿼트 "" 의 문맥에서는, 더욱 이하의 이스케이프가 서포트 되고 있습니다: \e, \a, \x1b, \c[, \l, \L, \u, \U, \E 마지막 5 개의 제어 코드는, 대문자 소문자의 변환입니다.

$/ 변수에는, 복수의 단락 캐릭터를 세트 할 수 있습니다.

통상의 패턴 매치에 g 수식자를 사용할 수 있습니다. 이것에 의해, 캐릭터 라인으로부터 복수의 매치을 검색하는 것으로, 패턴 매치를 반복합니다.

$^T 를 제외해, 모든 $^X 변수가 증가하고 있습니다.

FILEHANDLE 에 대한 디폴트의 페이지 선두 포맷은, top 가 아니고 FILEHANDLE_TOP 가 되어 있습니다.

eval {} 와 sort {} 구조는, version 4.018 으로 추가되었습니다.

pack 와 unpack 의 v 와 V (little endian) 템플릿 옵션은, vertion 4.019 로 추가되었습니다.

버그

perl 형태의 캐스트, atof(), sprintf()와 같은 여러가지 조작은, 머신의 정의에 좌우됩니다.

어느 스트림로, stdio 가 각 read 나 write 의 사이에 seek 나 eof 를 필요로 하는 경우, perl (은)는 그처럼 합니다. (이것은, sysread()와 syswrite()에는 적용되지 않습니다. )

어느 편입 데이터 타입도 제멋대로인 사이즈 제한은 가지고 있지 않습니다 (메모 리사이즈는 별도입니다)(이)가, 그런데도 얼마 정도는 한계는 있습니다: 식별자는 255 캐릭터 이상에는 할 수 없고, -S 를 사용할 때, PATH 의 요소는 255 를 넘어서는 안됩니다. 정규 표현은, 내부적으로 32767 바이트를 넘을 수 없습니다.

perl (은)는, 실은 병리학적 절충 주의의 잡동사니 리스타 (Pathologically Eclectic Rubbish Lister) 입니다만, 내가 그렇게 말했다고는 누구에게도 이야기하지 말아 주세요.