홍길동과 108 장수들

 김정환입니다.천리안에서 퍼온 것입니다.perl 강좌에 도움을 줄것입니다.


안녕하세요 유니텔의 intour 나우누리의 필lit 전종필입니다.

     저의 Perl이야기  1, 2, 3,  4를 읽어 주신  여러분께 감사드립니다. 
     Perl이야기 5편을 시작하다가 갑자기  그 동안 적었던 이야기들을 되
     돌아 보고 싶더군요. 그래서  노동절을 전후하여 저의 Perl이야기 1, 
     2, 3, 4를  모두 훑어 보았습니다. 그랬더니,  정말 너무 부끄럽더군
     요. 제 실력을  스스로도 잘 아는 바이지만, 오자,  부족한 설명, 잘 
     못된 예제....
     그래서 만사 제쳐놓고 수정, 보완한 합본을 만들었습니다.

     부산에 계시는  유니텔의 챌린저님께는 특별히  더 죄송합니다. 저의 
     졸작을 프린트까지 하셨는데 이제야 보정판을 올렸으니 말입니다. 그 
     외에 그런분이 또 계시다면, 다시 한번, 아울러 사죄하는 바입니다.


보충, 정정에 덧붙여...

     설명이 너무 간략한 것들은  보충을 하였고 오자는 발견된대로 정정하였습니다. 
     이러한 것은 치명적인 것이 아니기에 여기에 모두 적는것은 피하겠습니다. 단지 
     아래처럼 잘 못된 예제, 설명 등은  제가 자칫 두들겨 맞을수도 있기에 미리 자
     수하는 바입니다. 광명이 보이는군요.

     (1) "9. PERL에서의 연산자(operator) - 논리 연산자"의 뒷부분에 보면

          $a <= $b || $max = $a;  # C라면 if( a > b ) max = a; 겠지요.

     가 있습니다. 이  식은 잘못되어 있습니다.왜냐하면 연산자  =는 ||보다 계산상 
     우선 순위가 늦습니다. 그래서  위의 명령은 $a <= $b ||  $max 가 먼저 계산이 
     됩니다. 그 다음의 = $a 부분은 쓰레기이지요.
     수정된 식은

          $a <= $b || ($max = $a);

     입니다. 잘 못된 예제에 사과 말씀 드립니다.

     (2) not, xor, and, or등의 논리연산자는 Perl 5.x에서부터 사용됩니다.

     (3) 파일 다루기중  파일에 쓰기에 관한 이야기에서  console인 STDIN에 쓴다고 
     잘 못 설명하였습니다. STDIN을 STDOUT으로 정정하였습니다.

     (4) 문자열의 일치에 대한 설명중 대소문자 구분을 하지 않도록하는 옵션인 i옵
     션에 대해 이야기  하면서 "/the/뒤에 i 자 하나가  매미처럼 붙어 있죠 ?"라고 
     하는 부분이 있습니다. 이 중 the를 World로 정정합니다.


     Perl의 소스를  번역, 실행해주는 interpreter는 아래의  장소에 올려져 있습니
     다. 아직 받지 않으신분들은 받으셔서  프로그램을 직접 만들어 보세요. 재미있
     습니다.

          유니텔: 공개자료실-인터넷통신자료 310번 - 도스용 4.x
          유니텔: 공개자료실-인터넷통신자료 304번 - Win95용 Beta3

          나우누리: 공개자료실-프로그래밍-유틸리티 107번 - 도스용 4.x
          나우누리: 공개자료실-프로그래밍-유틸리티 108번 - Win95용 Beta3


            ========================================================


==========================
     Perl언어 이야기.
==========================

     PERL은 PRACTICAL EXTRACTION AND REPORT LANGUAGE라는 INTERPRETER로서 문서파
     일을 읽고 필요한 정보들을  추출(EXTRACTION), 그 정보들을 바탕으로 REPORT를 
     출력하는 일을 하는데 아주 잘 맞는 언어입니다. 유닉스 플랫폼의 깡통들에서는 
     시스템 관리를 위하여 사용하기도 한다는데,  저는 유닉스라고는 LINUX를 한 열
     흘정도 쓰다가 X-WINDOW를 까는데 결국 실패한 죄로 유닉스는 겨우 냄새밖에 맡
     지 못한 사람이라 그 쪽에서는 사용을 해보지 못했습니다.

     C++언어를 조금 공부한 일이 있어서  PERL을 배우는데 도움이 되었습니다. 사실 
     '배운다'할 것까지도 없지만요....

     PERL의 도사들(미국살람, 영국살람, 등등)은 이 언어가 C, sed, awk, sh등의 특
     징들을 결합한 것이어서 그러한 언어를 아는 사람들은 배우기가 쉽다고 하는데, 
     굳이 그런 정도가 아니라도 배우는데 큰 지장은 없으리라 봅니다. 우리 나라 사
     람들 머리가 어디 보통입니까 ?

     근래 Internet의 부상과 더불어 혜성처럼 나타난 WWW, 그리고 홈 페이지 작성에 
     대한 열기,  심지어는 어린이에게도 인터넷을  교육환경으로 제공하려는 최근의 
     노력들을 감안할 때, 홈 페이지  작성을 위하여 HTML만을 사용한다는 것은 분명 
     부족한 감이 많습니다. CGI (COMMON  GATEWAY INTERFACE)를 말하고자 하는 겁니
     다.

     WWW의 CGI구현에는 여러 방법이 있을  수 있겠지요. 그중 하나인 .EXE파일을 만
     들어서 하는 방법은 COMPILER를 사용하며 또 매우 정교한 재주를 사용해야 하기 
     때문에 구현과 DEBUGGING에 매우 많은  시간이 필요하고 또 소스를 고칠 때마다 
     COMPILE을 반복하는 일 때문에 아주 짜증이 나기도 합니다.
     다른 방법으로는 COMPILE이 아닌  INTERPRETING을 하는 언어를 사용하는 것인데 
     COMPILER로 만든 .EXE 파일보다 느리기는  하지만 그다지 큰 프로그램이 아니고
     서는 큰 차이를 느낄 수 없는 데다 DEBUGGING후 실행까지의 시간이 가히 '눈 깜
     짝할 새'라서 정말 실용적이라 할 수 있겠습니다.
     PERL은 더구나 HTML과 같은 문서를 다루는데 아주 강력한 기능을 가지고 있으므
     로 CGI구현을  위한 최적의  언어라 할  수 있으며,  UNIX, MVS,  VMS, MS-DOS, 
     Macintosh, OS/2, Amiga, Windows NT 등 여러 가지 Operating system에 Porting
     되어 있으므로 소스파일의 이식성이 뛰어나  홈 페이지 구성 시에 차후 서버 프
     로그램이나 Operating system의 변화에도 부담을  주지 않아 좋고, 또 PERL프로
     그램 자체가 프리웨어인 관계로 Internet상에서  얼마든지 구할 수 있으니 그야
     말로 꿩 먹고 알 먹고 둥지 털어 불쏘시개까지 하는 식이지요. (물론 진짜 그렇
     게는 하지 않습니다. 환경을 살려야죠...)

     자바가 어쩌고,,, 이런 세상에 웬  구석기형의 언어냐고 타박하실 분도 계실 줄 
     압니다. 그러나 생각해 보십시오. 자바가  소위 '경향'인 것은 틀림없지만 현재 
     주류라고 할 수 있을까요 ?  자바는 32 비트 기반의 o/s에서 브라우징이 가능한 
     것으로 알고 있습니다. 우리 나라에서  개인을 제외한 기업, 특히 중소기업들의 
     대부분의 업무환경이 32 비트 오퍼레이팅 시스템일까요 ? 첨단 기술을 습득하고 
     보조를 맞추어 가야 하는 것은 컴퓨터 하는 사람의 자세임이 틀림없지만 여러분
     의 홈 페이지에 접속할 수많은 잠재 고객들의 사정을 가늠해 보는 것은 또한 비
     지니스 맨의 의무입니다.  아직도, 그리고 향후 얼마동안은,  16 비트 환경에서 
     일하는 여러분의 고객들을 생각하시고 perl을 그냥 지나치지 마십시오.

     C, C++같은 언어를 써보신 분들은  그 언어에서 문자열과 메모리의 관리가 얼마
     나 짜증나는 일인지 아실 겁니다. PERL은 그런 게 없어요.

     여러 번에 걸친 debugging으로  완벽해진 Perl 프로그램을 실행파일로 전환하고 
     싶을 때가 오면 어떡하느냐고요 ? Internet상에서 찾으면 Perl compiler도 있습
     니다. 때가 되면 찾아보세요.

     장점을 들려면 한이 없으니 이 정도에서 그쳐야겠습니다.

     읽어 가시면서 의문 나는 점이나 잘못된 점 지적해주시면 감사하겠습니다.

     앞으로의 이야기는  전후가 중복되는 것이라도 필요하면  다시 적도록 하겠습니
     다. 그래서 가능한 읽어나가면서 전의  내용을 뒤적이지 않도록 하려합니다. 물
     론 보장은 없지만....

     덧붙일 말쌈은 저의 Perl 이야기는 언어의 기초를 다지는 정도에서 그칠 것이고 
     그 이상의 이야기는 저의 실력이 늘고 또 기회가 생기면 다시 시작될 수 있겠다
     는 겁니다. 하오니  기초를 넘어선 이야기는 스스로  공부하시고 당분간은 묻지 
     말아달라는 부탁입니다.

     감사합니다.

     *** 도스용 PERL을 PKUNZIP 하실때는  ROOT DIRECTORY에서 -d 옵션을 주고 하신
     후 생성되는 DIRECTORY이름을 NCD와 같은  것을 이용하여 PERL이라고 재명명 해
     주세요.

     전 종 필 (나우: 필lit  유니: intour, intour@unitel.co.kr)




1. 첫 번째 프로그램 - Hello World.
=================================
     언제나 그렇듯이 첫 프로그램은 바로 이겁니다.

          # hello.pl

          print "Hello World\n";

     이 것이 프로그램의  전부. print는 다음의 문자열, 숫자,  변수 등을 STDOUT에 
     출력합니다. 참 쉽군요.

     \n : C++의 \n과 같은 역할로써 커서를 다음줄 앞으로 보내는 겁니다.
          (new line)
     #  : 이 문자 이후부터 끝까지는 perl로부터 무시됩니다. 주석문이죠.
          주석문을 잘 써 놓으면 나중에 프로그램을 읽을 때 쉽게 이해가 되겠죠.
     ;  : 한 명령문은 언제나 ;(colon)으로 끝납니다. 이것이 빠지면 다음 명령
          라인에 error가 발생합니다.

     hello.pl은 짐작하시다시피 평범한  ascii 파일(text파일)입니다. 따라서 dos의 
     edit와 같은 프로그램으로 편집하면 되겠죠.


2. 그래서, 그 파일을 어쩌란 말이냐 ?? - perl 프로그램의 실행.
=============================================================

     dos prompt상에서,

          perl hello.pl 

     하면 됩니다. 물론 perl.exe가 PATH환경이나  현재 directory에 있다는 가정 하
     에서죠. 그러면 화면상에,

          C:\PERL>perl hello.pl
          Hello World

          C:\PERL>

     이라고 되겠지....우 !

     ******( Windows NT에서의 실행 )******
     Windows NT에서는 install.cmd를 실행시키고 난 후에 perl hello.pl이라고 하면 
     문제없이 실행이 됩니다. 도스창을 열고 실행해 보세요.
     *************************************

3. 악 ! 근데 이건 머시냐 ??? - 첫 ERROR MESSAGE ??.
=============================================

          DOS/4GW Professional Protected Mode Run-time  Version 1.97
          Copyright (c) Rational Systems, Inc. 1990-1994

     DOS용 PERL은 1  Mbytes의 한계를 극복하고 원활한 실행을  돕기 위한 Rational 
     Systems,  Inc의  DOS  EXTENDER를  사용합니다. 위의  출력내용은  단순히  그 
     product의 선전내용일 뿐이니 문제 될 것은 없지만 그다지 매일 보고 싶은 것은 
     아니겠죠. 참을 수 없는 사람들은:

          SET DOS4G=QUIET

     하면 조용해집니다.

     또, 어떤 경우에는

          DOS/4GW Professional fatal error (1307): not enough memory

     라는 Message가 나오고 실행이 전혀 되지  않을 수도 있는데, 이 것은 아마 EMS 
     그리고/또는 Smartdrv가 차지하고 있는  Memory부분을 DOS EXTENDER가 껄떡대다
     가 한대 두들겨 맞고서 내는 신음소리일 겁니다.
     저의 경우  총 16메가의  메모리를 쓰고, EXPANDED  MEMORY 1  MByte, SMARTDRV 
     1MByte를 사용하기 때문에 1 MByte의  여유를 갖고서 4M의 주소부터 16M의 주소
     까지를 EXTENDER가 사용하도록 아래처럼 지정하였습니다.

          SET DOS16M=@4M-16M

     자세한 내용은 README.DOS를 보시면 됩니다. (사실 저는 제가 필요한 것 이외는 
     자세히 읽지 않았거든요...)

     참고로 Windows NT에서는 INSTALL.CMD를 실행시켜 주는것으로 문제가 없더군요.


4. 변수(VARIABLE)
=================

     PERL의 변수는 크게 3 가지로 나누어집니다.

          1. scalar variable.
          2. array.
          3. associative array. (hash)

     scalar 변수는 변수명 앞에 $를 붙이는 변수로 굳이 말하자면 일반 변수라 하는 
     게 좋을 것  같습니다. scalar라는 것은 '실수(實數)로 표시할  수 있는 수량', 
     방향성이 없는 수량 같은 것인데 다른 언어에서처럼 정수형, 왕정수형, 실수형, 
     왕실수형 (헹님요....) 등과 같은 엄격한 구분 없이 모든 숫자가 실수형으로 저
     장이 되는 듯(?)하며(체계적으로 배운  게 아니니 용서바람.), 심지어는 문자열
     도 저장이 되는, 조금은 헷갈릴지  몰라도, 매우 편리한 변수형태 입니다. 따라
     서

          $price = 100000;
          print "$price\n";             # <- '\n'이 new line이라고 말했슈.
          $price = "Very expensive.";
          print "$price\n";

     에서와 같이 숫자를 할당했던 변수에 문자열을 재 할당해도 전혀 문제가 안됩니
     다. 신나는군요. 약간 이상한 게 눈에 뜨입니까 ? 일단 넘어가세요.

     또 Perl의 변수에는 문자열로 저장된  숫자형태의 변수, 즉 1000이 아닌 "1000"
     도 계산식에 그대로 적용시킬 수 있다는점이 아주 재미있습니다.

          $price = "130";  # 모양은 숫자이지만 실제는 문자열입니다.
          $double = $price * 2;
          print "$double\n";

     위의 소스를 실행시켜 보세요. 이게 에러가 없다니까요, 글쎄 !
     이런 변수의  특성은 여러분의 프로그램이 사용자로부터  받은 자료를 계산식에 
     이용할 때 다른  언어에서처럼 숫자로 변환하는 함수 등을  사용하지 않고 즉시 
     계산에 사용할 수 있게하겠지요.

     array는 배열입니다. 일종의 집합체, 구조체 같은 것입니다.
     배열이란 복수의  일반변수들을 변수 각각의 이름이  아닌 참조번호를 이용하여 
     접근할 수 있도록 굴비 엮듯  줄줄이 엮어놓은 것입니다. 즉 "전종필"이라고 부
     르지 않고 "58번"하고 부르는것이겠지요.
     배열의 머리에는 $가아닌 달팽이(@)를 붙입니다. 즉,

          @myarray;

     와 같습니다.  또 배열의 구성요소는  일반변수(scalar)이므로 개개 구성요소를 
     나타낼 때는

          $myarray[0] = 0;   # 0번 굴비에게는 파리 0마리,
          $myarray[1] = 5;   # 1번 굴비는 1마리의 파리를 드리겠어요오오.
          $myarray[2] = "I do not want a number but a long long long string.";
          $myarray[3] = 300; # 배 트자뿌겠네 !

          print $myarray[2], "\n";
          print "$myarray[2]\n";

     과 같이 나타냅니다.

     굴비가 몇 마리인지는 세어보면 알겠지만 배열의 크기를 알아야 할 때는 눈으로 
     셀 수 없지요. 그 때는

          $lastIndex = $#myarray;

     처럼 하면 @myarray의 맨 마지막  요소의 참조번호(index number)를 알 수 있습
     니다. 즉 $lastIndex 또는 $#myarray의  값이 3 이라면 배열의 첫 참조번호는 0
     이므로 요소의 갯수는 모두 4개인 셈입니다.

     배열의 크기를 조절할 때에도 마지막 참조번호를 이용할 수 있습니다.

          $#myarray = 2;      # 마지막 참조번호를 2로 맞추라 !  찌아안...

     라고 하면 $myarray[3]은 사라지고 3개의 요소만 남겨집니다. 조금은 희한한 방
     법이지만 편리하기도 하지요. 물론 늘일 수도 있겠지요.

     Associative array는 hash라고도 하는 잡동사니 주머니입니다. 배열과 비슷하지
     만 배열처럼 참조 번호가 아닌 참조 '열쇠'(key)로 값을 정하거나 찾을 수 있습
     니다. 즉,

          @myarray = ( 1, 3, 5, 2, 6 );
          $fourth = $myarray[3]; # 2

          %myhash = ( "apple", 3, "pear", 10, "banana", 4, "monkey", 2 );
          $howmany = $myhash{ "banana" }  # returns 4
          $howmany = $myhash{ "apple" }   # returns 3
          $myhash{ "pear" } = 9;  # becomes ( ..., 3, "pear", 9, "bana...  )

     여기까지 대략 변수에 대하여 알아보았습니다. 누워서 떡 먹기죠 ?
     이제는 하나씩 문제를 만들어가 봅시다요.


5. 화면에 쓰기 - print 함수
===========================

     우리의 첫 번째 프로그램인 hello.pl을 떠올려 봅시다.
     print "Hello World\n";가 전부였죠.

     좀더 긴 인사를 해볼까요 ?

          # heylong.pl

          print <홍길동과 108 장수들
          
          홍길동과 108 장수들


          나는 홍길동이다.
          한 대 맞아 볼테냐 ?

              
          아프지 ? 우하하하하 !!

          

     위의 HTML을 보고서 한 대 맞고 싶은 사용자는 "한 대 맞아 볼테냐 ?"에 마우스
     를 대고 똑딱입니다. 그러면  서버는 "strike.pl"파일을 찾아서 perl strike.pl
     을 실행시킵니다. 물론  perl.exe는 path로 지정되어 있는  경로에 있어야 합니
     다. strike.pl은 이렇게 생겼을 겁니다.

          # strike.pl

          print "Content-type: text/html\n\n";
            # 위의 명령행은 반드시 들어가야하는 내용입니다.
            # 그래야 browser가 html 파일임을 알아 볼 테니까요.
          print <사실은 백 아홉대임.
          
          
백 아홉대를 맞아랏 !

          왜냐하면 홍길동 보태기 백 여덟 장사면 백 아홉명 이니까.
          자, 맞아랏 !

          endOfHtml

          for( $i = 0; $i < 109; $i++ ) # 내용을 109번 반복. 나중에 또 설명.
          {
            print "따악 ";
          }  # 109번을 따악 따악 따악 따악 따악 따악 따악 !!!

          print "
"
          print "아프지 ?";

     웹서버 프로그램은 print되는 내용을  browser로 보냅니다. 결과는 상상해 보세
     요.

     일단은 이 정도만 알아 두셔도 될  듯 합니다. 앞으로는 꼭 필요한 경우를 제외
     하고는 굳이 cgi는 언급하지 않겠습니다.

     ******( 참고 )******
     PERL은 소스파일을 읽어  들인 후 일단 처음부터 끝까지  기계어로 번역을 합니
     다. 그리고는 매우 빠른 속도로 실행을 시킵니다. perl.exe로 실행을 시켜볼 때 
     실행 직전까지 약간의 멈춤 시간을 느낄 수 있는 것은 바로 완전한 번역을 위해 
     약간의 시간이 소요되기 때문입니다.
     프로그램에 버그가 있을 때는 그  앞의 명령행 어느 하나도 실행되지 않고 즉시 
     오류 메세지가 나오는 것도 실행 전에 완전히 번역을 해 놓기 때문입니다.
     ********************

7. PERL의 연산자(operator) - 숫자 계산
======================================

     $b = 3;            # = 는 같다는 뜻이 아닌 할당, 저장의 의미입니다.
                        # 즉, $b에 3이라는 값을 저장.
     $b = $a;           # ...
     $b = @a;           # 일반변수 $b에 배열 @a를 저장. 배열  $a의 모든요소
                        # 들이 그대로 간격없이 순서대로 연결되어 저장.
     $b = "@a";         # 일반변수 $b에 배열 @a를 저장. 배열  $a의 모든요소
                        # 들이 하나의 공백을 사이에 두고 순서대로 연결되어
                        # 저장.
     @b = @a;           # 배열 @b에 배열 @a를 저장. 배열  $a의 모든요소
                        # 들이 그대로 @b에 저장됨.
     %b = %a;           # hash %b에 hash %a를 저장.
     $b = $a = 3;       # $a, $b에 3을 저장.

        ### 위의 식들을 직접 실험해 보세요. 어떤 결과가 나오는지 직접
        ### 체크해 보시기 바랍니다.

     $a = 10 + 3;       # 10과 3을 더하여 $a에 저장.
     $a = 3 - 10;       # 3에서 10을 뺀 후 $a에 저장.
     $a = 3 * 10;       # 곱하기.
     $a = 3 / 10;       # 3 나누기 10.
     $a = 2 ** 3;       # 2의 3승 (8). 주의: -2**3은 -(2**3)과 같음.
     $a = 10 % 3;       # 10을 3으로 나눈 후의 나머지 값. ($a는 1).
     $b = ++$a;         # $a 값을 1 만큼 증가 시킨 후에 그 값을 $b에 저장.
     $b = --$a;         # $a 값을 1 만큼 감소 시킨 후에 그 값을 $b에 저장.
     $b = $a++;         # $a 값을 $b에 저장한 후에 $a값을 1 만큼 증가.
     $b = $a++;         # $a 값을 $b에 저장한 후에 $a값을 1 만큼 감소.

     $b += 13;          # $b의 값에 13을 더한 값을 $b에 저장.
     $b -= 13;          # $b의 값에서 13을 뺀 값을 $b에 저장.
     $b *= 13;          #   이하 설명 생략.
     $b /= 13;          # 
     $b %= 13;          # 
     $b **= 13;         # 


8. PERL에서의 연산자(operator) - 문자열 계산
============================================

     $a = "hello" . "world";     # $a는 "helloworld"가 됨. 사이에 있는것은
                                 # 점입니다. 일명, 쩜 !
     $a = "hello" x 3;           # "hellohellohello".
     $a = "hello";
     $a .= " world";             # "hello world"

     증가 연산자의 마술 !
     print ++($foo = '99');      # prints '100'
     print ++($foo = 'a0');      # prints 'a1'
     print ++($foo = 'Az');      # prints 'Ba'
     print ++($foo = 'zz');      # prints 'aaa'

     감소 연산자(--)는 증가 연산자가 피우는 재주를 모릅니다.


9. PERL에서의 연산자(operator) - 논리 연산자
============================================

     논리 연산자는 어떤 조건이 참인지 거짓인지 판별할 때 사용합니다. 논리적 AND 
     ( && )는 두 조건이 모두 참일 때 전체를 참으로 결정하고, 논리적인 OR ( || )
     는 두 조건이  모두 거짓일 때 전체를 거짓으로  결정합니다. 핵교 댕길때 다들 
     배우셨지요 ? Perl 언어에서도 0은  거짓으로 보고 그외는 참으로 봅니다. 그래
     서

     $a = 1;
     $b = 2;
     $c = 0;

     $d = $a && $b;     # $d는 1; 참
     $d = $a && $c;     # $d는 0; 거짓
     $d = $a || $b;     # $d는 1; 참
     $d = $a && $c;     # $d는 1; 참

     가 성립합니다.

     논리 연산자 (||, &&)의 재주부리기 :  || 는 앞과 뒤의 참 거짓을 바탕으로 전
     체적 참 거짓을 판가름하는 연산자이지만,  앞의 조건이 거짓일 때 뒤의 명령어
     를 실행시키는 역할도 합니다. 물론  앞의 조건이 참이면 전체가 참이므로 뒤의 
     명령어는 실행할 생각도 않습니다. 따라서 다음과 같은 명령이 가능합니다.

          $a <= $b || ( $max = $a );  # C라면 if( a > b ) max = a; 겠지요.

     편리하지 않습니까  ? 위의 예제에서는  $a가 $b보다 작거나 같지  않으면 뒤의 
     $max = $a가 실행됩니다.
     AND 연산자 (&&) 또한 마찬가지입니다. 

          $a > $b && ( $max = $a );

     즉, $a가 참인 경우에 뒤의 ( $max = $a )도 참인지 시험하기 위해 ( $max = $a 
     )를 실행시키는 것입니다. 그 실행이 끝나고 난 후 전체식 $a > $b && ( $max = 
     $a )이 참인지 거짓인지 가늠되는데  그 결과는 사용하던 안하던 여러분의 자유
     겠지요.
     위의 예문에서 ( $max = $a )와 같이 ()를 사용한 것은 || 또는 &&이 = 보다 계
     산시 우선 순위가 높기  때문에 괄호를 사용하지 않고 $a >  $b && $max = $a와 
     같이 했을 때 $a  > $b && $max가 먼저 계산이  되고 나중에 = $a라는 쓰레기만 
     남아서 에러 메시지가 나오고 실행되지 않는것을 막기 위해서입니다.

     정리해서 말하면 위의 경우처럼 사용되는  ||는 "그렇지 않으면"의 뜻이고 &&는 
     "그러할 경우에"의 뜻이 되는것입니다.

10. PERL에서의 연산자(operator) - 그 외
=======================================
     ,(comma) 연산자는 연속된 명령의 실행, 목록내에서는 요소간의 분리 등을 나타
     냅니다. 그다지 중요한 것은 아니지만 가끔은 편리할 때가 있습니다.

          $a = 1, $b = 3, print "@a and @b\n";

     >, <, >=, >=      # 숫자의 비교.  if ( $a > $b ) { print "O.K."; }
     ==, !=, <=>       # <=>는 앞의 변수가 작으면 -1, 크면 1, 앞과 뒤의 변수가 
                       # 같으면 0을 return합니다.
     lt, gt, le, ge    # 문자열의 비교. "ba"는 "bb"보다 작습니다(lt).
     eq, ne,  cmp         #  cmp는 숫자의 <=>와  같은 역할. az는  bb보다 작습니
     다.(-1)

     3 | 2             #  bit계산용 OR.  00000011 | 00000010 -> 00000011 -> 3
     3 & 2             #  bit계산용 AND. 00000011 & 00000010 -> 00000010 -> 2
     3 ^ 2             #  bit계산용 XOR. 00000011 ^ 00000010 -> 00000001 -> 1


11. 연산자의 우선 순위.
=======================
     한 명령행에서 여러 종류의 연산자가 사용되었을 때, perl.exe는 연산자들의 우
     선 순위를 따져서 먼저 계산될  부분을 결정하여 순서대로 계산을 합니다. 예를 
     들어 5 + 4 * 2 의 경우 앞의 5 + 4를 먼저 계산하는 것이 아니라 뒤의 4 * 2를 
     먼저 계산하고 그 다음에 5 + 8을 계산하는 것이지요.
     이 때 앞의 5 + 4를 먼저 계산 시키려면  ( 5 + 4 ) * 2 와 같이 괄호로 묶어주
     어야만 합니다.
     우선 순위가 같은 연산자 끼리는  앞의 연산자에 우선 순위가 있습니다. 어떻게 
     아느냐고요 ? 5 * 4 % 3 과 5 % 3 * 4를 각각 실행시켜 보십시오.

     다음은 연산자 사이의 우선 순위입니다. ( perlop.txt 발췌 )

          left terms and list operators (leftward) 
          left -> 
          nonassoc ++ -- 
          right ** 
          right ! ~ \ and unary + and - 
          left =~ !~ 
          left * / % x 
          left + - . 
          left << >> 
          nonassoc named unary operators 
          nonassoc < > <= >= lt gt le ge 
          nonassoc == != <=> eq ne cmp 
          left & 
          left | ^ 
          left && 
          left || 
          nonassoc .. 
          right ?: 
          right = += -= *= etc. 
          left , => 
          nonassoc list operators (rightward) 
          left not 
          left and 
          left or xor 

     위에 설명하지 않았던 연산자들이 많이 있죠 ? 일단은 접어 두고 가세요.
     또, 연산자 not, and, or,  xor는 Perl 4.x에서는 없는 것들입니다. Perl 5.x에
     서 사용가능한 연산자들이지요.

     또 궁금해서 도저히 못 참으시는 분 들은 제가 올려드린 PERL 문서
     (perldocu.zip)중 perlop.txt를 찾아 보세요.

     ******( 한마디 )******
     자바가 어쩌고,,, 이런 세상에 웬  구석기형의 언어냐고 타박하실 분도 계실 줄 
     압니다. 그러나 생각해 보십시오. 자바가  소위 '경향'인 것은 틀림없지만 현재 
     주류라고 할 수 있을까요 ?  자바는 32 비트 기반의 o/s에서 브라우징이 가능한 
     것으로 알고 있습니다. 우리 나라에서  개인을 제외한 기업, 특히 중소기업들의 
     대부분의 업무환경이 32 비트 오퍼레이팅 시스템일까요 ? 첨단 기술을 습득하고 
     보조를 맞추어 가야 하는 것은 컴퓨터 하는 사람의 자세임이 틀림없지만 여러분
     의 홈 페이지에 접속할 수많은 잠재 고객들의 사정을 가늠해 보는 것은 또한 비
     지니스 맨의 의무입니다.  아직도, 그리고 향후 얼마동안은,  16 비트 환경에서 
     일하는 여러분의 고객들을 생각하시고 perl을 그냥 지나치지 마십시오.
     참 돈 되는 일도 아닌데 제가 왜 이리 흥분인지 모르겠네요...
     **********************

12. 파일 다루기
===============

     저런, 눈에 쌍꺼풀이 지시는군요. 지루한 연산자 이야기였습니다.

     경우에 따라 여러분은 파일과 디렉토리를  다루어야 할 때가 있으리라 생각됩니
     다.
     PERL의 파일 다루는 솜씨는 매우  훌륭합니다. 파일의 상태 또는 이것이 파일인
     지 디렉토리인지 알아내기 위해서 C와 같은 언어에서는 대개 int86x같은 시스템 
     의존적인 함수를 이용해야 합니다.  그러나 PERL에서는 어떤 운영체제에서도 같
     은 명령을 사용합니다. 단지 참조 메뉴얼이 옆에 있어야 한다는 것 뿐이죠.

     파일 및 디렉토리에 대해 알고 싶은 경우 다음과 같은 함수들을 사용합니다.
     기본적인 것들만 나열합니다.(perlfall.txt의 -X FILEHANDLE을 보십시오.)

     문법: -X FILEHANDLE 또는 -X FILE_OR_DIR_NAME

          -e  파일이 존재하는가 ? (참이면 1, 거짓이면 0을 리턴합니다.)
          -z  파일 크기가 0인가 ?
          -s  파일이 0 아닌 크기를 갖는가 ? (파일의 크기를 리턴합니다.)
          -f  파일이 평범한 파일인가 ?
          -d  파일이름이 디렉토리인가 ?
          -T  파일이 텍스트 파일인가 ?
          -B  파일이 이진 파일인가 ?
          -M  파일이 생성된지 몇일이 되었는가 ? ( 0부터 시작 )

     그럼 파일을 한 번 읽어 봅시다.  파일을 읽거나 쓰기 전에는 반드시 파일 핸들
     을 생성, 파일을 '열어야' 하고, 다 읽은 후에는 '닫아야' 합니다. 파일 핸들에
     는 변수들에 붙는 $, @, %같은 것들이 붙지 않습니다.

          # mytype1.pl
          # 도스의 type, 유닉스의 cat 명령을 흉내내어 봅시다.

          $fileName = "hello.pl";

          if( -d $fileName )  #  -d $fileName && die "$fileName ...";와 같음.
            { die "$fileName is a directory.\n"; }
            # 디렉토리를 type할 수는 없죠.
            # die 함수는 메세지를 출력하고 프로그램 실행을 중단시킵니다.

          -e $fileName || die "$fileName is not exist.\n";

          -T $fileName || die "$fileName is not a text file.\n";

          open( fileHandle, $fileName ) || die "Cannot open $fileName.\n";
          @allLines = ;   # 핸들을 통하여 모든 문자열을 배열로
                                      # 읽어 들입니다.
                                      # 파일이 너무 크면 좀 문제가 있겠죠.
          close( fileHandle );  # 다 읽었으니 꼭 닫습니다. !!!!!

          print @allLines;  # 화면에 출력합니다.

     아주 간단하게 만들었죠 ?

     문자열을 한 줄씩 읽을 수도 있습니다. 핸들을 배열에 할당(=)시키면 모든 문자
     열이 다 읽히지만 일반 변수(scalar)에  할당시키면 한 줄만을 읽고, 파일의 끝
     에 도달했을 때에는 "undefined value"(정해지지 않은 값 ?)을 리턴 합니다. 이 
     undefined value는 조건식에서 사용하면 거짓으로 인식됩니다. 따라서,

          open( fileHandle, $fileName ) || die "Cannot open $fileName.\n";
          while( $aLine =  )
          {
            print $aLine;
          }
          close( fileHandle );  # 다 읽었으니 꼭 닫습니다. !!!!!

     와 같이 하면 안전하게 파일의 끝까지  한 줄씩 읽으면서 print할 수 있는 것이
     지요. 파일의 크기가 너무 커서 메모리 사용이 과다할 것 같은 경우에는 이렇게 
     한 줄씩 읽어들이는것도 좋은 방법이겠지요.

     open은 파일을 열고 close는 닫는 함수인데, open의 여는 동작은 다시 분류하여 
     생각할 필요가 있습니다.
          open( fileHandle, "hello.pl" );  # hello.pl을 쓰기 모드로 엽니다.
          open( fileHandle, ">>hello.pl" ); # hello.pl의 끝에서부터 추가하여
                                            # 쓰기 모드로 엽니다.
          open( fileHandle, "+perltest.htm" ) || die "Failed opening.\n";
          print fileHandle <test of writing
          
          
Test of writing file in PERL
          Hello. I am writing something to a file.
          Be careful to close the file after completion of writing.

          
          
          END_HTML

          close( fileHandle );

     위에서 print 다음의 fileHandle다음에 comma가 없음을 유의해 주세요.

     추가쓰기 모드는 따로 설명하지 않겠습니다. 숙제입니다.
     여기까지 파일 다루기에 대하여  간단히 살펴보았습니다. 다음은 디렉토리에 대
     해 살펴보겠습니다.

     하품하지 마세요.

13. 디렉토리 다루기
===================

     디렉토리는 하위 디렉토리들과 파일들의  명세서를 담고 있습니다. 여기서는 디
     렉토리 사이를  움직이는 것들보다는 디렉토리가 담고  있는 명세를 들여다보는 
     것에 대하여 살펴보도록 하겠습니다.

     파일에 핸들이 있듯이 디렉토리를 여닫는 데에도 핸들이 있습니다. 또 디렉토리
     를 여닫을 때에는 opendir와 closedir함수를 사용합니다.
     readdir 함수는 디렉토리에 있는 모든  디렉토리 및 파일들의 이름을 읽어 목록
     형태(배열)로 리턴합니다. 즉

          @myArray = readdir( DirHandle );

     과 같이 하면 됩니다.

     백문이 불여 일견이고 백견이 불여 일행이라.

          # readdir.pl

          opendir(dirHandle, ".") || die "Failed opening.\n";
          @files = readdir( dirHandle );
          closedir dirHandle;

          print @files;    # 알아먹기 힘들게 프린트됩니다.
          print "\n";

          print "@files";  # 이것은 볼만하지요 ?  잠깐 말씀 드린 적이
                           # 있는데 배열이 치환될 때에 각 요소 사이에
                           # 공백이 하나씩 들어갑니다.
          print "\n";

     읽혀진 파일 및 디렉토리 목록에서  몇 가지만 골라서 쓰고 싶은 분도 계시겠지
     요.
     나중에 또 기회가 있을 겁니다. 그  때까지 못 기다리실 분들은 함수 grep에 대
     해 찾아보세요. sort 함수도 볼 가치가 있습니다.

14. 명령행 인자 - @ARGV 배열
============================

     파일 다루기와 디렉토리 다루기에서 한가지  불만이 있었을 줄로 압니다. 왜 파
     일 이름과 디렉토리 이름을 미리 정해놓고서 유용성을 축소 시키느냐고요...
     조금 더 우아하게, type myfile.htm할 수 있을 텐데 말입니다.

     물론이지요. 좋은 질문입니다. 역시 민주 컴퓨터 쟁이는 다르군요.

     명령행에 붙여지는  인자는 @ARGV라는 배열에  담겨져서 프로그램으로 넘겨집니
     다.
     당연히 인자의 마지막 참조번호는 $#ARGV가 되겠지요. 인자가 하나도 없을 때에 
     $#ARGV의 값을 출력 시켜보면 -1을 프린트합니다. 의심나면 직접 해 보세요.

          print "$#ARGV\n";

     이 한줄이면 됩니다. 그리고 perl test.pl, perl test.pl hey, 등을 해 보세요.

     파일 다루기에서 만들었던 프로그램을 다시 짜봅시다.

          # mytype2.pl
          # 도스의 type, 유닉스의 cat 명령을 흉내내어 봅시다.

          if( $#ARGV < 0 )
            { die "Supply a file name, please.\n"; }
          if( $#ARGV > 0 )
            { die "Too many parameter.\n"; }

          $fileName = shift( @ARGV );

          if( -d $fileName )
            { die "$fileName is a directory.\n"; }
            # 디렉토리를 type할 수는 없죠.
            # die 함수는 메세지를 출력하고 프로그램 실행을 중단시킵니다.

          -e $fileName || die "$fileName is not exist.\n";

          -T $fileName || die "$fileName is not a text file.\n";

          open( fileHandle, $fileName ) || die "Cannot open $fileName.\n";
          while( $aLine =  ) # 한번에 한줄씩 읽습니다.
          {
            print $aLine;
          }
          close( fileHandle );  # 다 읽었으니 꼭 닫습니다. !!!!!

     예제를 만들면서 가능한 실수가 없도록 test를 해 봅니다. 혹시 깜박 잊고 test
     를 하지 못한데서  실수가 나올 수도 있겠지요. 그  실수를 찾아내는 것은 바로 
     ??
     예 ! 여러분의 숙제입니다. 정 모르시면 메일 주세요. 같이 찾아보도록 하지요. 
     그렇다고 욕은 하기 없깁니다.

15. 조건 - if와 unless
=======================

     위의 예제 mytype2.pl을 보면 아래와 같은 조건부 실행 명령이 있습니다.

          if( $#ARGV < 0 )
            { die "Supply a file name, please.\n"; }

     그 의미는 만약 if다음의 ( )안에 있는 내용이 참이면, 즉 $#ARGV가 0보다 작을 
     경우에는, { }로 쌓여 있는  블록 전체를 실행시키고, 그렇지 않으면(거짓이면) 
     실행시키지 않는다는 것입니다.

     if의 형식은 다음과 같습니다.

          if ( 식 )
          {
            do_something;
          }
          else  # '식'이 거짓일 경우 블록을 실행. else는 없을 수도 있음.
          {
            do_others;
          }

     또는,

          if ( 식 )
          {
            do_something;
          }
          elsif( 다른 식 ) # elsif는 몇개가 들어가도 좋음.
          {                # 주의: elseif라고 하지 않도록 유의할 것.
            do_anything;   # '식'이 거짓이고 '다른 식'이 참일 때 실행.
          }
          else
          {
            do_others;
          }

     if의 반대 개념으로 unless가 있습니다. 즉, 조건식에 거짓으로 판명이 될 경우
     에만 블록내의 명령(들)을 실행시킵니다.

          @a = 3;
          unless ( @a == 5 );
          {
            print "Hey\n";
          }

     위에서 hey는 출력이 될까요 안될까요 ???

     간단한 명령의 실행으로 이렇게 하는 수도 있습니다.

          print "Yes\n" if $answer == 3;
          print "Shut up !\n" unless $mouth eq "quiet";

     조건식과 명령문의 순서가 위에 보여드린  것과는 구성이 조금 다르지요 ? 그러
     나 내용은 다르지 않습니다.

     또, 연산자 이야기에서 설명한 것처럼

          $answer == 3  && print "Yes\n";
          $mouth eq "quiet"  || print "Shut up !\n";

     와 같이 if, unless가 아닌 &&, ||를 사용할 수도 있습니다.

16. 반복 실행 - for, foreach, while, until
==========================================

   for
   ---
     홍길동과 108장사들의 아름다운 이야기를 기억하십니까 ? 이런 내용이었지요.

          ... 전략
          for( $i = 0; $i < 109; $i++ )
          {
            print "따악 ";
          }  # 109번을 따악 따악 따악 따악 따악 따악 따악 !!!
          ... 후략

     for제어문은 뒤따라 오는 {}블록내의  명령들을 일정한 횟수만큼 반복하여 실행
     시켜주는 제어문입니다.
     for 다음의 괄호 안의 내용은 ; 기호에 의하여 3부분으로 나뉘어져 있습니다.

          for( 초기화; 조건; 조건 비교 후 취하는 행동 )
          {
            매번 해야할 일;
          }

     홍길동의 예제를 보면,  $i라는 일반 변수를 0으로 초기화한  다음에 $i의 값이 
     109보다 작은지를 검사하고 만일 작으면 블록 안의 내용을 실행한 후 $i의 값을 
     1만큼 증가시킵니다. 그리고 다시 $i의 값을 조사, 실행, 증가를 $i의 값이 109
     보다 같거나 클 때까지 반복합니다.
     홍길동의 예제를 보시고 또 다른 예제들을 만들어 보십시오.

     숙제를 내 드릴까요 ?
     참새 10마리가 전깃줄 위에서 노래합니다.
     첫째 참새는 "짹", 둘째는 "째잭", 셋째는 또 "짹"....열째는 "째잭".
     for loop와 % 연산자 그리고  if를 이용하여 노래를 시켜보세요. 한글을 띄우기 
     귀찮으면 zag, zazag 해도 되겠지요.

     홍길동의 이야기를 이렇게 쓸 수도 있습니다.
          for ( 1..109 )
            { print "딱 "; }
     간단하죠. 이 형태는 어떤 목록(  1..109는 1에서 109까지의 목록입니다.)의 각 
     요소마다 한번씩 일정 명령문을 반복하는 제어방법을 보여줍니다.

     이런 것도 있습니다.

          for ( 1..10, " hello ", "world ", "again\n" )
            { print; }

     결과는 "12345678910 hello world again"으로 출력됩니다.
     이건 좀  이상하죠 ? 이것만 알아두세요.  일반변수(scalar)가 있어야할 자리에 
     아무것도 보이지 않으면 대개는 그 자리에 "$_"라는 변수가 있는 것으로 가정이 
     됩니다. for( 1..109 )에서는 $_가 1로 초기화되어 109까지 계속하여 2, 3, 4로 
     한번씩 할당됩니다.  그렇게 한번씩 할당될 때마다  print "딱"이 실행되는것이
     고, for ( 1..10, " hello ", "world ", "again\n" )에서는 1에서 10까지 (점이 
     두 개 보이시죠 ? 1..10 ) 그 다음에는 " hello ", "world ", "again\n"이 한번
     씩 $_에 할당됩니다. 실행되는 부분에서는  또 print에 넘겨지는 인자가 없으므
     로 $_가 있는  것으로 가정하는 것이지요. print;를  print($_);로 바꾸어 써도 
     결과는 같이 나옵니다.
     할 수 있는  한, 직접 실행을 시켜 보세요. 혹시  제가 거짓말을 하고 있는지도 
     모르지 않습니까 ?


   foreach
   -------

     배열의 마지막 참조번호는 $#array_name으로 알 수 있다고 했습니다.

          for ( $elem = 0; $elem <= $#myArray; $elem++ )
          {
            print $myArray[$elem];   # 각 요소는 일반변수이므로
                                     # @가 아닌 $를 붙인다 했습니다.
          }

     위의 예제는 배열 @myArray의 각 요소를 출력하는 문장입니다.
     foreach는 이러한 상황에서 세상살이를 좀 더 넉넉하게 해 줍니다.

          foreach $elem ( @myArray )
          {
            print $myArray[$elem];   # 각 요소는 일반변수이므로
                                  # @가 아닌 $를 붙인다 했습니다.
          }

     foreach는 목록으로 생각되는 것들에 적용할  수 있습니다. 배열, hash, 텍스트 
     파일 등등..

     hash (associative array)의 예를 들어 보도록 하지요.

          # hash.pl

          %myhash = (
            "apple", 3,
            "pear", 10,
            "banana", 4,
            "monkey", 2,
            );

          $total = 0;
          foreach $eachKey ( keys %myhash ) # key라는 함수는 hash의 '키'들
                                            # 만을 모아 배열로 묶어줍니다.
          {
            print "$eachKey\t", $myhash{$eachKey}, "\n";
            $total += $myhash{$eachKey};
          }
          print "\nTotal\t$total\n";   # \t는 탭입니다.

     출력이 어떻게  되는지 직접  해 보시기  바랍니다. 백견이  불여 일행이라니까
     요...
     위의 foreach $eachKey ( keys  %myhash )가 헷갈리는 분들을 위하여 간단히 말
     씀드립니다.  key라는 함수는  hash의 '키'들(  위 예문의  경우  apple, pear, 
     banana, monkey가 key입니다.)만을 모아 배열로 묶어줍니다. $myhash{$eachKey}
     는 각 키에 대한  값( 위 예문의 경우 각각 3, 10, 4,  2 )을 리턴합니다. 쉽게 
     풀어 놓으면,

          ...
          @arrayOfKey = keys %myhash;
          foreach $eachKey ( @arrayOfKey )
          ...

     와 같습니다. 배열에서 사용하는 foreach와 똑같은 내용이지요.

     foreach는 심지어 파일내의 각 줄에 대해서도 적용이 됩니다 !

          # mytype3.pl

          if( $#ARGV < 0 )
            { die "Supply a file name, please.\n"; }
          if( $#ARGV > 0 )
            { die "Too many parameter.\n"; }

          $fileName = shift( @ARGV );

          if( -d $fileName )
            { die "$fileName is a directory.\n"; }

          -e $fileName || die "$fileName is not exist.\n";

          -T $fileName || die "$fileName is not a text file.\n";

          open( fileHandle, $fileName ) || die "Cannot open $fileName.\n";
          foreach $aLine ()
          {
            print $aLine;
          }
          close( fileHandle );  # 꼭, 꼭, 꼭, 꼭 닫읍시다.

     참 편리한 물건이지요 ?

     또 for ( 1..10, " hello  ", "world ", "again\n" )의 for를 foreach로 바꾸어
     도 같은 결과를 낳습니다.

   while
   -----

     어떤 조건식이 참인 동안 뒤따라 오는 블록내의 명령들이 계속해서 실행됩니다.

          $i = 0;
          while ( $i < 109 )
          {
            print "딱 ";
            $i++;
          }

     어디선가 본 듯하지요 ? $i가 109보다  작은 동안만 print "딱 ";과 $i++;가 계
     속 실행됩니다.

   until
   -----

     until은 while의 반대 개념입니다. 즉 조건이 거짓인 동안만 실행이 됩니다.

          $i = 0;
          until ( $i >= 109 )
          {
            print "딱 ";
            $i++;
          }

     위의 while과 until의 형식에서는 조건식이  먼저 테스트 됩니다. 따라서 맨 처
     음부터 조건식이 거짓이거나(while) 참인(until)  경우에 블록은 전혀 실행되지 
     않습니다. 그런 형태의  실행이 필요하면 그렇게 쓰시면  됩니다. 그러나, 일단 
     한 번 실행이 되고난 후에 테스트 되어야 할 경우에는 아래처럼 do와 함께 사용
     합니다.

     ******( 신소리 )******
     자꾸 loop에 관한 이야기만 하니까 머리가 뱅뱅(loop) 돕니까 ? 조금만 더 읽어 
     보세요. 참는자에게 복이 있답니다.
     **********************

   do 그리고 while/until
   ---------------------

     while, until과 큰 차이는 없습니다.  암호를 점검하는 간단한 프로그램을 봅시
     다.

          # pwd.pl

          do {
            print "Enter password : ";
            $password = ;        # 조금 색다른 것들이 나오네요.
            chop( $password );
          } while( $password ne "hack" ); # ne는 문자열을 비교하는 not equal
                                          # 연산자라고 했습니다.
          print "Well done !\n";

     블록내의 명령들은 눈치 보지않고 일단  실행이 됩니다. 그 다음에 조건식이 참
     인지 시험되고 참이면 불록의 명령들이  반복이 되고 거짓이면 블록의 다음으로 
     넘어갑니다. While과 다른점은 블록의 명령들이 일단 한번은 실행이 된 후에 조
     건식이 시험된다는 점입니다.

          # pwd2.pl

          do {
            print "Enter password : ";
            $password = ;       # 자꾸 신경쓰지 마세요. 말씀드릴테니.
            chop( $password );         # 이것도 ...
          } until( $password eq "hack" );  # until과 eq이 쓰였지요 ?
                                           # eq는 equal이란걸 다 아시는군요.
          print "Well done !\n";

     pwd.pl과 pwd2.pl이 다른것은 while과 until, ne와 eq 뿐입니다.

     파일 읽기 할 때 $aLine  = 를 기억하시죠 ? 유닉스에서는 모든 깡
     통(키보드, 디스플레이, 프린터 등등)들을 파일로  생각한다는 것은 이미 잘 아
     실겁니다. PERL또한 그 동네에서 출생된지라  글자를 키보드로 입력 받을 때 키
     보드에 STDIN이라는 파일 핸들을 할당시켜서  그 핸들을 통해 입력을 받습니다. 
     그래서 $passwork = ;하면 화면에 커서가 깜박이면서 입력을 기다렸다가 
     마지막에 리턴키를 받으면 $password에 입력받은 문자열과 리턴(\n)문자를 저장
     시킵니다. 그런데 맨 끝에 보면 $password를 "hack"과 비교를 하는 부분이 있는
     데, 문자열 "hack"에는 "\n"이 포함되어  있지 않지요. 그 "hack"과 비교시키기 
     위해 $password에 저장된 문자열의  맨끝에 틀림없이 저장되어 있을 "\n"문자를 
     없애기 위해 chop이라는 함수를 사용합니다.  chop은 문자열의 맨 뒤에 있는 한
     문자를 잘라주는 함수입니다. 라면 끓일 때 파를 뚜껑이 열린 냄비위에 대고 칼
     로 chop, chop, chop쳐서 썰어 넣는것을 "chop up"이라 한다는군요.

   loop의 한 가운데에서 . . .
   --------------------------

     loop이 반복실행되고 있는  중간에 조금 빗나가고 싶은  때가 있습니다. 간단히 
     소개하도록 하지요.

     << next >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

     C언어의 continue와 같습니다.

          # next.pl

          for ( 1..9 )
          {
            print "fore $_\n";
            next unless $_ % 3;  # 3의 배수에서만 맨처음으로 돌아가서 계속.
            print "aft  $_\n";   # $_이 3의 배수이면 이 행은 실행되지 않음.
          }
          print "End.\n";

     while같은 것으로도 실험해 보세요. (숙제)

     << last >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

     C언어의 break와 같습니다.

          # last.pl

          for ( 1..9 )
          {
            print "fore $_\n";   # $_는 위에서 설명 드렸습니다.
            last unless $_ % 3;  # 3의 배수에서 블록 다음으로 넘어감.
            print "aft  $_\n";
          }
          print "End.\n";

     아래는 위 예제의 c 버젼이겠지요.

          # break.c

          for ( int i = 1; i <= 9; i++ )
          {
            printf( "fore %d\r\n", i );
            if( ! ( i % 3 ) ) break;
            printf( "aft  %d\r\n", i );
          }
          printf( "End.\r\n" );


     위의 예제에서 4에서 9까지는 아예 얼굴도 못 내밉니다. 실험해보세요.

     << redo >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

     redo는 next와 비슷하지만 전체 블록의 재실행전의 인수의 증가 등을 다시 하지
     않습니다. 말이 좀 꼬이네요.
     즉 for ( $i = 0; $i < 10; $i++ )에서 $i++를 하지 않는다는 뜻입니다.
     예제를 보시고 직접 실행해 보십시오.  예제를 잘 분석해 보시면 제가 무슨말을 
     하려는지 잘 아실것입니다.

     다음은 암호를 받는데 있어서 10번의 기회를 주되, 마지막 한자를 잘못 쳐 넣었
     을 경우에는 우연한 실수임을 가정하여  10번의 count에서는 제외된 3번의 추가 
     기회를 주는 프로그램입니다.

          # pwd2.pl

          $count = 0;
          for ( 1..10 )
          {
            print "Type password ($_): ";
            chop( $password =  );
            if( $password eq "hack" )
            {
              print "Right !\n";
              last;
            }
            chop($password);
            if( $password eq "hac" )
            {
              last if( $count++ >= 3 );
              print "Almost correct. try more\n";
              redo;
            }
          }

          print "End.\n";

     위의 예제를 실행시키면서 암호를 묻는  프롬프트에 a, err, shit등 쓰잘데없는 
     암호를 몇번 입력하다가 haco, hact,  hacc등 hack과 끝 글자 한자만 다른 암호
     를 2번쯤 입력해 보십시오. 그러면  redo가 있는 블록이 실행되면서 for(1..10)
     에서 $_가 더 이상 커지지 않는것을 알 수 잇습니다. 이해가 가시죠 ?


17. 문자열의 일치
=================

     문자열의 일치에 대한 연산식은 어떤 문자열에 다른 단어나 구문, 문장 등이 들
     어있는지 알기위해 사용합니다. 그러려면 =~ 연산자를 사용해야 합니다. 그리고 
     찾을 단어나 구문, 문장주위에는 따옴표 대신 /로 둘러쌉니다. 따옴표도 안되는
     건  아니지만   일단은  사선(/)으로  하는것을   습관들여  주십시오.  나중에 
     perlop.txt를 보시면 어떤 부호를 어떻게 사용할 수 있는지 알 수 있습니다.

          # contain.pl

          $long = "Tell me what\'s up.";  # '는 특수한 문자이므로 \를 사용
                                          # 하여 excape시킵니다.
          if( $long =~ /hat/ )   # 보셨죠 ? 문자열 $long에 hat이라는 문자열
          {                      # 이 들어있는지 시험합니다.
            print "Yes, it contains \"hat\".\n"; # "도 escape시켜야 됩니다.
          }
          else
          {
            print "No, it does not.\n";
          }

     hat는 what에 포함되어 있지요.

     일치에 대해 이야기하려면 반드시  규정어법(Regular Expression, 약자로 RE)에 
     대하여 짚고 넘어가야만 합니다.

     ******( 규정어법 ? )******
     사실 저는 유닉스 쪽에서 Regular Expression을 무어라고 번역하는지 잘 모르겠
     습니다. 어떤 유닉스 입문서에서는  그냥 "레귤라 익스프레션"이라고 했더군요. 
     제 생각으로 규정어법이라 하면 맞을 듯 싶어 그렇게 하였습니다.
     혹시 다른 생각이나  올바른 이름을 알고 계시는 분이  계시면 정정하여 주시면 
     고맙겠습니다.
     **************************

     어떤 문자열 속에 특별한 내용의  단어 또는 짧은 구문이 있는지 검사하는 기능
     은 웬만한 편집기면 다 가지고 있지요. 그러나 이러한 찾기 기능은 대개 한계가 
     있어서 어떠한 '패턴'의 구문을 찾는데는 조금 문제가 있지요.
     예를 들어 "hello world"와 "hello my world"를 같은 패턴으로 생각하고 찾아야 
     한다면 찾기에 애로를 느끼지 않겠습니까 ?.
     이러한 패턴을  한 문자열  안에 설정시켜 주는  것이 바로  규정어법, Regular 
     Expression, RE 입니다.

     한가지씩 봅시다.

     .   점이 보이세요 ? 이것은  딱 한 자(영문 한 자)입니다. 어떤 글자도 좋습니
     다.  단 개행문자인  "\n"만은 제외입니다.  그래서 위의  예제 contain.pl에서 
     /hat/대신에 /h.t/를  해도 같은 결과가  출력됩니다. /h.t/은 hat,  hot, hut, 
     hit, 등등에 다 해당되지만 heat,  heart, hoot, ht 등은 아닙니다. 기억하십시
     오. "개행문자를 제외한 임의의 한  글자." 밑줄 치세요. 그리고 간단한 예제로 
     실험해 보세요. 혹시 제가 잘못했으면  제게 삿대질이라도 해야 할 것 아닙니까 
     ?

     *    별, asterisk 입니다. 도스에서 많이 보신  와일드 카드로 쓰이는 문자죠. 
     점(.)은 한 글자를 대신할 수 있지만 별(*)은 0 또는 그 이상의 어떤 수의 문자
     로도 대치될 수 있습니다. 또 다른 점은 점(.)은 그 자체로 어떤 문자를 대신하
     지만 별(*)은 그 앞에 어떤 문자가 있어야 합니다. 즉 o*p 하면 0 또는 몇 개의 
     o와 p가 있는 것을 말하며 p,  op, oop, oooooooop 등이 모두 해당됩니다. 그러
     나 *  앞에 o와  같은 어떤 문자가  있어야 하고  만일 $str =~  /*p/라고 하면 
     perl.exe는 에러 메시지를 내고 실행을 시키지 않습니다.

          # contain2.pl

          $long = "I wrote it at the beginning.";
          print $long, "\n";

          if( $long =~ /h*at/ )   # /*at/, /a.t/도 실험해 보세요.
            {  print "Yes, it contains.\n";  }
          else
            {  print "No, it does not.\n";  }

     결과가 어떻게 나올까요 ?

     +   보태기 표입니다. *가 0 또는  몇 개인 데에 반해 +는 '1' 또는 몇 개 입니
     다. 그래서 o+p는 op, oop, ooooop와 일치되지만 p에는 일치되지 않습니다.

     ?   물음표입니다. 0 또는 1개의 문자에 일치됩니다. 즉 o?p는 p 아니면 op입니
     다.

     +나 ? 모두  그 앞에 어떤 문자가 있어야 하는  것은 *과 동일합니다. 주의하세
     요.

     익숙해지는 방법은 자꾸 해보는 수밖에 없습니다. 자꾸 만들어 보세요.

     문자열의 어디에나 있는 구문이 아니라 문자열의 처음이나 맨 끝에 있는 것만을 
     찾으려 할 때에는 어떻게 할까요 ?

     ^는 문자열의 맨 처음을, $는  맨 끝을 나타냅니다. $는 일반변수의 $와 혼동될 
     염려가 없으니 신경 쓰지 마십시오.

     생각할 수 있는 것들을 적어보도록 하지요.

          t.e           the, tie, toe, 등등. settle에도 포함되어 있죠.
          ^t.e          위와 같으나 문자열/줄의 처음에 있을 경우.
                        settle은 안됨.
          ^.e           he, me, regard 등이 문자열/줄의 처음에 있을 경우.
          t.e$          toe, necktie 등으로 끝나는 문자열.
          s*he          she, he, ssssssssshe, the, tshe
          s+he          she, sshe, sssssshe, tshe 등. he, the는 안 됨.
          s?he          he 또는 she.
          ^s?he$        "he" 또는 "she". 한 줄에 이 두가지만이 허용됩니다.
          .*            개행문자를 제외한 모든 글자들.
          ^$            빈 줄/문자열.

     또 드리는 잔소리: 백견이 불여 일행.

     조금 더 심오한 선택을 해 볼까요 ?
     []로 쌓여있는 글자들은  몇 자가 되든 단 한  글자만을 대변하며, 포함된 모든 
     글자 중  어떤 글자라도 있으면  일치되는 것으로 인정됩니다.  []를 character 
     class라고 하더군요.

          [st]he        she 또는 the.
          ^[st]he       문자열의 처음에 있는 she 또는 the.
          [a-z]         소문자 한 자. '-'는 between의 의미로 범위를 나타냄.
          [a-zA-Z]      소문자 또는 대문자 한 자.
          [0-9]         십진수 한 자.
          [-0-9]        '-'부호와 십진수 중 한 자. 빼기 부호를 사용하려면
                        맨 앞에 두어야만 합니다. 안 그러면 범위를 나타내는
                        '-'부호와 헷갈리겠죠 ?
          [0-9a-fA-F]   십육진수 한 자.
          h[eao]y       hey, hay, hoy.
          ^h[eao]y      문자열의 첫머리에 있는 hey, hay, hoy.
          h[^eao]y      hey, hay, hoy를 "제외한" /h.y/. 즉 hiy, hfy, huy 등.
                        문자클래스(character class)안에서의 ^ 부호는 not 또는
                        except를 의미합니다.
          [^a-z]        소문자 빼고 모두 다.
          [a-z]+        소문자가 한 자 또는 줄줄이 있는 것들.
                        w, kdfns, oie, jfowjdngjwerh 등등.
          [tT][hH][eE]  the, thE, tHe, tHE, The, ThE, THe, THE, 등.

     마지막 예는  대소문자 구분없는 the를 찾기위한  방법의 하나였습니다. 그런데 
     조금 더 편리한 방법이 있습니다.

          $long = "The world of mine !";
          if( $long =~ /World/i ) { print "Yes\n"; } # 이상한게 있지요 ?
          else { print "No.\n"; }

     이 예에서는 yes가 출력됩니다. /World/뒤에 i 자 하나가 매미처럼 붙어 있죠 ?
     "ignore case"의 첫 글자로 대소문자  구분을 하지 말란 뜻입니다. HTML의 태그
     들은 대소문자를 구분하지 않습니다. 그런 경우 과 을 동시에 찾
     으려면 아주 유용한 선택이 되겠지요.

     앞에서 $_라는 특수 변수에 대하여 이야기 한 적이 있습니다. 찾아보세요. 거짓
     말 아닙니다. 다시 한 번 말씀드리면 어떤 변수가 사용되어져야 할 장소에 아무 
     변수도 보이지 않으면 PERL은 $_가  있는것으로 생각합니다 그래서 위의 간단한 
     예제는 이렇게 고쳐도 같은 결과를 보여줍니다.

          $_ = "The world of mine !";
          if( /World/i ) { print "Yes\n"; } # $_ =~ ... 로 생각합니다.
          else { print "No.\n"; }

     또 다른 재미있는 특수 변수를 두개 더 소개하지요. 정신 사나우시면 그냥 그런
     게 있구나 하고만 넘어가세요.
     위의 예제를 이렇게 고쳐봅시다.

          $_ = "The world of mine !";
          if( /World/i ) { print "Yes\n"; } # $_ =~ ... 로 생각합니다.
          else { print "No.\n"; }
          print "Fore : $`\nAft  : $'\n";  # $`, $' ??

     위의 예제를 직접 실행해 보시기 바랍니다 출력되는 결과는

          Yes
          Fore : The        # The 뒤에 공백이 하나 있습니다.
          Aft  :  is mine !

     입니다.
     어떤 문자열의 일치를 실험해 본  후 결과가 성공적이면 $`에는 찾은 문구의 바
     로 앞부분이, $'는 뒷부분이 할당되어 있습니다.

          My name is Jongpil
          My name is Inhyon
          My name is Jungkwang
          My name is Kwanghoon
          My name is Hyongku

     자, 위의 각 줄에서 이름만 따로 저장할 수 있겠습니까 ? $'를 사용하면 되겠지
     요 ?

     문자열의 일치에 대해서는 이 정도만  아셔도 웬만한 일은 하실 수 있으실 겁니
     다.  다음은 그저  참고  삼아서  보시고 더  알고  싶으신  분은 영문  참고서
     (perlre.txt)를 한번 보세요.

          --- 수직 막대, | 는 or 부호이고, ()는 글자들의 그룹입니다.  ---
          /clean|dirty/         clean 또는 dirty
          (eg|le)gs             eggs 또는 legs
          ba(na)+               bana, banana, bananananana

          *** ()를 사용하는 그룹화된 패턴은  한글에 적용할 때 유용하리라 생각됩
          니다. 다음 예문을 보시지요.

               $long = "닐리리 닐리리 닐리리야";
               if ( $long = /닐(리)+/ )
                 { print "닐리리야 니나노.\n"; }
               else
                 { print "어쩔시구리.\n"; }

          --- 특수문자들도 유용합니다. ---
          \n    개행문자.
          \t    탭.
          \w    문자 또는 숫자. [a-zA-Z0-9]와 같습니다.
          \W    \w가 아닌 것. [^a-zA-Z0-9]와 같습니다.
          \d    십진수. [0-9]와 같습니다.
          \D    십진수 아닌 것. [^0-9]와 같습니다.
          \s    공백문자. space, 탭, 개행문자 등.
          \S    공백문자 아닌 것.
          \b    단어의 경계(boundary). [ ]의 바깥에서만 사용.
                "the green grass of home"의 \bthe\b, \bgreen\b,
                   \bgrass\b, \bof\b, \bhome\b.
                \bthe\b와 \bhome\b도 포함됨에 유의하세요.
          \B    단어의 경계가 아닌 것.

          --- {}는 문자, 그룹의 개수를 지정합니다. ---
          ba(na){2}     banana만 해당.
          ba(na){1,2}   bana, banana만 해당.
          ba(na){2,5}   banana, bananana, banananana, bananananana만 해당.
          o{2,4}p       oop, ooop, oooop.

     중요: 위에서 쓰였던 특수한 문자들 ^$|[]()\/{}*.?+ 등을 그 자체로 사용할 때
     는 그 앞에 \를 붙여 주세요.

          \^ \$ \| \[ \] \( \) \\ \/ \{ \} \* \. \? \+

     정말 중요한 것은 직접 간단한 프로그램을 만들어서 시험해 보는 것입니다.
     몇 장 되지도 않는 설명에  포기해서는 정말 액티브한 홈페이지를 만들 수 없겠
     지요 ? 글쎄 아이큐 두 자릿수도 이해를 하고 있잖아요...


18. 문자열의 치환 - Substitution, Translation
==============================================

     치환은 일치의 응용으로 생각하시면 됩니다. 연산자도 =~를 사용하고 문자를 둘
     러싸는 부호도 /입니다.
     치환을 위하여 s///라는 함수를 사용합니다. 문장의 구조는

          "뒤적거릴 문자열" =~ s/찾을 문자열/바꿀 문자열/옵션;

     문자열을 찾아서 치환이 되었을 때 치환시킨 문자열의 수를 리턴합니다. 치환이 
     하나도 되지 않았다면 0을 리턴하겠죠.

          # subst.pl

          $_ = "Where is my baby, Oh Baby !";

          if( $count = ( s/baby/lover/ ) )  # $_ =~ s/.... 로 인정됩니다.
            {  print "Replaced $count time(s).\n   \"$_\"\n";  }
          else  {  print "Failed.\n";  }

          print "Fore : $`\nAft  : $'\n";

     위 예제의 결과를 예상해 보시고  직접 실험해 보시기 바랍니다. $count의 값만 
     참고로 말씀드리면 1입니다. 뒤에는 대문자로 시작하는 Baby라서 그런가 ?
     아, 벌써 아셨군요. 제가 s/baby/lover/i라고 말하려 한다는 것을 !!!
     한번 해 볼까요 ?

          틱, 티딕, 틱틱틱 퍽 !  (퍽은 enter키 치는 소리.)

     아니 ??! 결과가 이상하다 !! 왜  뒤의 Baby는 그냥 있지 ? 전종필이 가만 놔두
     지 않겠다 eC....     >-(

     잠깐요 ! ... 아 ! 한 가지 더 있었군요. g, global substitution, 전역 치환이
     라는 옵션을 사용하지 않으면 맨  처음에 발견되는 문구만 치환이 되고 그 뒤는 
     더 이상 뒤적거리지 않는것입니다.

     해 보시죠 ..s/baby/lover/gi.. 퍽 ! ...  음, 역시 그렇지요 ?

     그리고 마지막 줄의   print "Fore : $`\nAft  :  $'\n";의 결과도 눈여겨 보세
     요.

     문자열의 일치에서 살펴보았던  모든 규정어법(Regular Expression)이 여기서도 
     적용이 됩니다.

     간단한 예제 하나만 해 보고 부연하지 않겠습니다.

          # banana.pl

          $_ = <$stufile" ) || die "Can\'t open $stufile";
            # 파일을 쓰기 모드(>)로 열었습니다.
          foreach ( keys %students )  # keys 함수는 hash의 key들만을 모아서
          {                           # 배열로 만들어 return한다고 했습니다.
            $stud[0] = $_;      # $_ 기억하시죠 ?
            $stud[1] = $students{$_};
            $stud[2] = $studyear{$_};

            $string = join( ':', @stud );  # : 부호로 join합니다.
            $string .= "\n";               # ID와 학년, 그리고 사람 이름에
                                           # 들어갈리 없는 부호니까요.
            print Hstufile $string;  # 핸들을 통해서 파일에 프린트합니다.
          }

          close Hstufile;  # 꼭, 닫읍시다.

     split 함수를 기억하십니까 ? join함수의 역개념이지요. 지금 그것을 다시 설명
     하면 제가 여러분을 무시하는것이 되겠지요  ? 그러나 join에 짝이 없어서 서운
     하니까 한마디만 할께요.
     split함수는 어떤 패턴을 이용하여 문자열을 배열로 나누어 저장합니다. 궁금하
     시면 저의 Perl 이야기-3의 맨 뒷부분을 참조하세요.

     Perl에 관한 문서들을  보면 자주 나오는 이야기가 있습니다.  "방법은 한 가지 
     만은 아니다"는 말입니다. 여러가지  방법을 고려해서 문제를 풀어 나가십시오. 
     어떤 문제던지...

     ******( 일반변수의 기이한 재주 )******
     맨 처음에 변수에 관한 이야기를  하면서 빼놓고 간 이야기가 있는것 같습니다. 
     일반변수에는 문자와 숫자를 번갈아 할당할  수 있다고 했습니다. 그런데 이 재
     미있는 재주  말고도 Perl의 변수는 문자열로  저장되어있는 숫자형태의 변수를 
     계산식에까지 적용시킬 수 있다는 것입니다. 그래서,

          $a = "5";
          $b = 3;
          $c = $a + $b;
          print "$c\n";

     라고해도 군소리없이 8자가 나온다는 것이죠. 편리한 방법 아닙니까 ?
     ***************************************


21. Hash (Associative Array, 잡동사니)
======================================

     Hash는 본래 Associative array라고 하는건데 문자대로 말하면 "연상배열"이 되
     겠죠. 즉, 참조번호가 아닌 키워드에서 어떤 값을 연상해 내는 방식을 생각하시
     면 됩니다. 그러나  그것은 사실 연상의 결과는 아니지요.  단지 그렇게 보이는 
     것이지요. 그래서 Hash라고 하는지도  모릅니다. 연상배열이 아니라 잡동사니라
     는...

     Hash의 각 요소도 배열의 요소처럼 일반변수(scalar)입니다.

          # score.pl

          $scores{"engl"} = 75;   # hash의 각 요소의 값에는 당연히
          $scores{"math"} = 80;   # $가 붙습니다. 일반변수이니까요.
          $scores{"geo"}  = 65;

          foreach ( keys( %scores ) )  # 여기서는 hash그 자체를 가리키므로
          {                            # % 부호가 붙습니다.
            print "$_ : ", $scores{"$_"}, "\n";
          }

     keys 함수는  hash의 key들만을 모아서 배열로  만들어 return한다고 했습니다. 
     그러면 값들만을 모아서 배열로 만들어 주는 함수는 없을까요 ? 물론 있습니다.

          # test.pl

          $scores{"engl"} = 75;
          $scores{"math"} = 80;
          $scores{"geo"}  = 65;

          @keys = keys %scores;
          @values = values %scores;   # 바로 여기있군요 !

          while( $#keys >= 0 ) # 으잉 ???  pop을 한번씩 할 때마다 마지막
          {                    # 요소의 참조번호는 1씩 작아집니다. 당연하죠 ?
            print pop( @keys ), " : ", pop( @values ), "\n";
          }      # 요 위의 pop들을 shift로 바꾸어서 실행해 보세요.

     부연하지 않아도 이해가 되시죠 ?
     아무리해도 이해가 안되시면 메일주세요.

     ******( 괄호들은 어디에 ? )******
     똑같은 함수를 사용하면서도 어디에는 괄호를 씌우고 어디에는 시원하게 벗겨놓
     고 . . . Perl에서는  괄호를 선택적으로 사용합니다. 굳이 없어도 혼동되지 않
     는다면 함수의 인자들도 괄호로 둘둘 말 이유가 없습니다. 그래서

          print 8 + 3, "\n";
          print( 8 + 3, "\n");

     는 같은 결과를 출력합니다. 단,

          print ( 8 + 3 ), "\n";

     은 약간 이상한 모양이 됩니다. 즉, "\n"이 출력되지 않습니다.
     Perl은 , 연산자를 보면 ,의 왼쪽을 먼저 계산합니다(evaluating). 그래서

          $a = 5, $a = 4, $a = 3;

     의 경우 $a에는 결국 3이  저장되는 것입니다. 또 함수와 그에 따라오는 ()부호
     (List operator)는 전체로서 하나의 Term을  이루며 Term은 그 어떤 연산자보다 
     큰 우선순위를 갖기 때문에 위의 print함수의 예에서는 print ( 8 + 3 )이 먼저 
     계산되고 그 다음에 "\n"이 계산됩니다.  그 계산의 결과로 나타나는 것은 아무
     것도  없지만요.  (계산된다는  의미를  calculation으로만  생각하지  마시고, 
     evaluation, manipulation 등으로도 생각하십시오.)
     다음 명령문들을 실행해 보시고 출력물의 의미와 왜 그런 결과가 나왔는지를 생
     각해 보시기 바랍니다.

          print "Fore\n", print "Aft\n";
          print ( 5 + 3 ) * 5, "\n";

     어떤 결과를 쉽게  예측할 수 없으시는 경우에 가장  훌륭한 해결방법은 간단한 
     예제를 만들어 실행해 보는 것입니다.
     **********************************

     Hash를 배열에, 배열을 다시 Hash에  저장할 수 있습니다. 제 순서를 지켜서 찾
     아들어 가지요.

          # test.pl

          $scores{"engl "} = 75;
          $scores{"math "} = 80;
          $scores{"geo  "} = 65;
          $scores{"music"} = 98;

          @arr = %scores;
          print "\@arr : @arr\n";
          $count = ( $#arr + 1 ) / 2;
          print "Number of data in %scores : $count\n";

          %scores2 = @arr;
          foreach ( keys %scores2 ) { print "$_ : ", $scores2{"$_"}, "\n"; }


     keys와  values함수외에 each라는  함수가 있습니다.  이 함수는  hash의 key와 
     value를  짝지어 한  배열 안에  넣어줍니다. each함수가  한번씩 불려질때마다 
     hash의 요소가  순서대로 리턴되고, 모든  요소가 다 리턴 되고나면  그 다음은 
     NULL 배열이 되돌려집니다. 그러므로 아래의 while의 조건문은 제대로 작동됩니
     다.

          # each.pl

          %scores = ( "engl", 75, "math", 80,
                      "geo", 65,  "music", 98 );

          while( ($key, $value) = each %scores ) {
            print "$key :\t$value\n";
          }

     조금 긴 예제를을 한번 보시고 hash이야기를 마치겠습니다.
     학생 개인의 데이타와 학과 성적이 각각의 파일에 다음과 같이 저장되어 있습니
     다. 자료파일은 그저 평범한 텍스트 파일입니다.

     첫번째 파일은 stufile이고 각 줄은 한 학생의 id, 이름, 학년이 : 로 분리되어 
     있습니다.

          123:Jongpil:2
          246:Inhyon:1
          357:Jungkwang:3
          212:Kwanghoon:2

     또 두번째 파일은 scores이고 각 줄은 학생의 id, 학과번호, 시험점수가 공백으
     로 분리되어 있습니다.

          123 1 87
          246 1 76
          123 3 77
          212 2 99
          246 3 58
          357 2 69
          123 2 84
          357 3 97
          212 1 74
          246 2 98
          212 3 88

     이 자료파일들의 내용을 다음과 같이 출력하려 합니다.

          ID  Name      year     1   2   3    Totals

          123 Jongpil       2   87  84  77       248
          212 Kwanghoon     2   74  99  88       261
          246 Inhyon        1   76  98  58       232
          357 Jungkwang     3    0  69  97       166
              Total            237 350 320       907

     맨 윗줄의 1, 2, 3은 학과 번호입니다.
     조금 복잡해 보일지 몰라도 예제를  자세히 보시면 크게 어려울 것도 없습니다. 
     다음은 예제입니다.


          # test.pl

          $stufile = 'stufile';
          $scorefile = 'scores';

          $maxnamelength = 0;   # 이 두줄은 꼭 필요한 것은 아니지만
          $maxexamno = 0;       # 명확히 해주기 위해 넣었습니다.

          open( Hstufile, "<$stufile" )
              || die "Can\'t open $stufile.\n";  # 열어라, 아니면 죽어라.
          while(  )  # $_ = 과 같습니다.
          {
            chop;              # 맨 끝의 개행문자를 잘라 냅니다.
            last if( length( $_ ) < 3 );  # 3은 큰 의미는 없지만 3 자도
                                  # 안되면 자료가 아닌것으로 간주합니다.
            ( $stuid, $name, $year ) = split( ':', $_ );
            $students{$stuid} = $name;  # hash
            $studyear{$stuid} = $year;  # hash
            if( $maxnamelength < length( $name ) )    # 가장 긴 이름에 맞
              {  $maxnamelength = length( $name );  } # 추어 출력.
          }
          close Hstufile;  # 닫는것 기억하시죠 ?

          open( Hscorefile, "<$scorefile" )
              || die "Can\'t open $scorefile.\n";
          while(  )
          {
            chop;
            last if( length( $_ ) < 3 );
            ( $stuid, $examno, $score ) = split;
            $scores{ $stuid, $examno } = $score;  # 키가 2개입니다.
                                                  # $stuid는 중복되므로...
            if( $examno > $maxexamno )  # 학과가 몇개인지 셈.
               { $maxexamno = $examno; }
          }
          close Hscorefile;

          printf( "%3s %-${maxnamelength}s %4s", "ID", "Name", "year" );
            # ${maxnamelength}처럼 { }를 사용하여 둘러 쌉니다.
            # 그렇지 않으면 $maxnamelengths 로 인식되겠죠. (s자 보이죠?)
          foreach ( 1..$maxexamno )
            {  printf( "%4d", $_ );  }
          printf( "%10s\n\n", 'Totals' );

          foreach $stuid ( sort ( keys %students ) )  # sort함수는 배열내의
          {                              # 각 요소간의 문자열 비교로 전체 
                                         # 배열을 정렬한 배열을 리턴합니다.
            printf( "%3d %-${maxnamelength}s %4d", $stuid,
                                $students{$stuid}, $studyear{$stuid} );

            $total = 0;
            foreach $examno (1..$maxexamno)
            {
              printf( "%4d", $scores{ $stuid, $examno } );
              $total += $scores{ $stuid, $examno };
              $examtotal{ $examno } += $scores{ $stuid, $examno };
            }
            printf( "%10d\n", $total );
          }

          printf( "%3s %-${maxnamelength}s %4s", '', "Total", '' );
          $total = 0;
          foreach $examno (1..$maxexamno)
          {
            printf( "%4d", $examtotal{ $examno } );
            $total += $examtotal{ $examno };
          }
          printf( "%10d\n\n", $total );

     이렇게  보면 데이타베이스  프로그램도  못 만들건  없겠군요. 사실  Perl에는 
     database와 연동하기 위한 함수들이 많이 있습니다. 그리고 Internet에 보면 많
     은 database를 위한  Perl 라이브러리나 스크립트들이 많이  있습니다. 이 글을 
     보시는 어느분 중에는 곧 그런 라이브러리를 만들어서 우리나라와 그리고 전 세
     계에 나누어 주실 분도 계시리라는 생각도 드네요.

     ******( ${maxnamelength} ? )******
     일반변수의 이름 주위에 {}로 둘러싼  새로운 모습이 좀 이상하군요. 그러나 그 
     내용은 $maxnamelength와 하나도  다를 바가 없습니다. 단지  예제에서 그 뒤에 
     있는 s와의  접촉으로 $maxnamelengths가 되어 해석이  안되는 것을 막기위하여 
     {}부호가 사용되는 것입니다. 이런 경우는 또 있습니다.

          $fruit = "apple";
          print "I have five $fruits\n";  ???
          print "I have five ${fruit}s\n";  !!!

     위의 경우처럼 변수와 어떤 문자를 바로 연결하여 사용할 때에는 반드시 {}부호
     로 변수이름을 둘러싸야 한다는 사실을 기억하시기 바랍니다.
     ***********************************

22. 사용자 정의 함수 - Subroutine
==================================

     여기서는 간단한 소개만 하도록 하겠습니다.
     프로그램을 만들 수 있다면 함수는 왜 못만들겠수 ?

     Subroutine은 기존의 함수들로는 할 수  없는 일을 반복적으로 하거나, 전체 프
     로그램 운영상의 효율을 증대시키기 위해, 그리고 멋을 내고 싶을 때 만듭니다. 
     (왜 멋내면 안되우 ?)

     Subroutine은 다음과 같이 정의합니다.

          sub mysubroutine
          {
            print "Just print a simple message.\n";
          }

     위의 Subroutine은 그다지 유용한 프로그램은 아닌것 같군요. 하여간

          &mysubroutine;   #  & 를 붙여서 부릅니다.

     이라고 하면, Just print a simple message.\n을 화면에 출력합니다.

     Perl의 subroutine을 정의할 때는 인수의 종류나 개수 등을 특별히 정하지 않습
     니다. 그저 사용할 뿐입니다.
     인수는 @_라는 특수한 배열로 전달됩니다. $_와는 별개의 존재인 것 아시지요 ? 
     눈의 착각일 뿐입니다. 각 subroutine은  제 각기 자신의 @_를 가지고 있으므로 
     subroutine에서 다른 subroutine을 부를 때  공연한 걱정은 하지 않으셔도 됩니
     다. 다음을 한번 해 보세요.

          # param.pl

          sub args {
            print "@_\n";
          }

          sub bigargs {
                # ( "Shut", "up,", "please !" )라는 배열이 넘어옵니다
            &args( "Hello", "there", "?" );
            print "@_\n";
          }

          &bigargs( "Shut", "up,", "please !" );

     각각의 @_가 제 역할을 다 하는것이 보이시죠 ?

     @_도 배열이므로 $_[0], $_[1], $#_ 등 또한 제대로 사용할 수 있습니다.

     Subroutine은 마지막으로 도출된 값을  리턴하거나 return이라는 함수로 명확하
     게 표시하는 값을 리턴합니다.

          # return.pl

          $max = &max( 10, 5 );
          print "$max\n";

          $max = &max( 8, 15 );
          print "$max\n";

          sub max {
            if( $_[0] > $_[1] )
              { return $_[0]; }
            $_[1];
          }

     Subroutine밖에서의 변수들은 특별히 명시하지  않는 한 subroutine의 안쪽에서
     도 볼 수 있습니다. 볼 수 있다는 말은 변화시켜서는 않되는 변수의 값을 '실수
     로 인하여' 변화 시킬 수 있다는 말입니다.

          # oooops.pl

          $dum = "Very very important data";

          $max = &max( 10, 5 );
          print "10, 5 - $max\n";

          $max = &max( 9, 14 );
          print "9, 14 - $max\n";

          print "$dum\n";   #  oooops !!

          sub max {
            $dum = ( $_[0] > $_[1] ) ? $_[0] : $_[1];
          }

     이런 효과를 일부러 기대한 경우가 아니라면, 그리고 변수이름을 기필코 그렇게 
     하고 싶거나, 혹  다른 사람이 라이브러리로 쓰려는것을  예상하여 혹 있을지도 
     모르는 불미스러운  일을 미연에  방지하고 싶을 때는  local이라는 범위변경자
     (modifier)를 사용합니다.

     ******( 연산자 ?: )******
     위의 예제중에서 subroutine에 사용된 연산자  ?:는 조건의 참, 거짓에 따라 서
     로 다른 값을 리턴하는 연산자입니다. 형식은

          (조건식) ? 참일때의_값 : 거짓일때의_값

     입니다. 위의 예제의 경우 ( $_[0]  > $_[1] )가 참일 경우 $_[0]을, 거짓일 경
     우 $_[1]을 리턴함을 알 수 있습니다.

     다음은 위의 예제를 약간만 변형한 것입니다.

          # local.pl

          $dum = "Very very important data";

          $max = &max( 10, 5 );
          print "10, 5 - $max\n";

          $max = &max( 9, 14 );
          print "9, 14 - $max\n";

          print "$dum\n";  # Bueno ! No problemo !

          sub max {
            local( $dum ) = ( $_[0] > $_[1] ) ? $_[0] : $_[1];
               # 이 $dum은 바깥의 $dum과는 다릅니다.
          }

     실험해 보셨지요 ?
     local은 변수를 '지역화'하므로써 subroutine 안팎의 변수이름이 같더라도 실제
     의 '존재'는 다르게 조정합니다. 대표적인  지역변수가 바로 @_, $_[0], $_[1], 
     $_[2] .... 입니다. 위에서 보셨듯이 각각의 subroutine마다 서로 다른 @_를 가
     지고 있었던것을 기억하실겁니다.

# 다음번에는 몇가지 유용한 예제들을 만들어서 실험하면서 지금까지의 이야기들을
# 한번 정리해 보도록 하겠습니다.
#     감사합니다.
#
# 전 종 필 올림.
#