WWW : World Wide Wonsama

#!/usr/bin/perl

use 5.010;

#1. 해시 기본 문법

#hash{$some_key}

$family_name{"barney"}="rubble";

$family_name{"fred"}="flintstone";

$family_name{hash_key}="flintstone";

foreach $person (qw<barney fred>){

print "I've heard of $person $family_name{$person}.\n";

}

#2. 해시 목록 처리

%wow_hash = ("1그룹","전냥술","2그룹","도죽마드","3그룹","성사흑");

say $wow_hash{"1그룹"};

#3. 해시 목록화

@array = %wow_hash;

say @array;

say $array[1];

#4. reverse를 통해서 key와 value를 맞바꾸기 할 수 있다. (ip <-> address변환 처리에서 자주 사용 됨)

%wow_reverse = reverse %wow_hash;

say $wow_reverse{"전냥술"};

#5. 해시 보기 쉽게 정의

%welcome = (

"1" => "전사",

"2" => "도적"

);

say $welcome{"1"};

#6. keys values 함수

%hash=(

"one"=>"hana",

"two"=>"dul",

"three"=>"set"

);

#7. 입력된 순서되로 유지 되지 않음에 유의 

#단 키/값 의 순서는 유지 된다!

@my_keys = keys %hash; #키 목록 반환 - 입력한 순서대로 유지 되지 않음에 유의

@my_values = values %hash; #값 목록 반환

$counts = keys %hash; #해쉬 개수 반환처리

say "@my_keys";

say "@my_values";

say $counts;

#8. 값 유무에 따른 참 거짓 구분

if(%hash){

say "yes";

}else{

say "no";

}

#9. each 함수

#

while( ($key, $value) = each %hash){

say "$key => $value";

}

#10. sort hash : key를 알파벳 순으로 정렬한 것일뿐...

foreach (sort keys %hash) {

print "$_ => $hash{$_}\n";

}

#11. exists - 해당 키가 존재하는지를 확인한다.

%book=(

"dino"=>7

);

if(exists $book{"dino"}){

say "remain";

}

#12. delete 해당 값 삭제

say $book{"dino"};

delete $book{"dino"};

say $book{"dino"};

#13. $ENV 환경설정 출력 해시

say $ENV{WOW};

#!/usr/bin/perl

use 5.010;

#1. 이름 묻고 성 찾기

%hash = (

"fred"=>"flintstone",

"barney"=>"rubble",

"wilma"=>"great",

);

print "what is your name : ";

chomp($myname = <STDIN>);

print $hash{$myname},"\n";

#2. 단어 출현 횟수 구하기

chomp(@lines=<STDIN>);

foreach(@lines){

$hash{$_}+=1;

}

print "\nresult : \n";

foreach(sort keys %hash){

say "$_ ==> $hash{$_}";

}

#3. ENV키갑 나열하기

while(($key, $value) = each %ENV){

say "$key\t$value";

}

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

#정의 되지 않는 변수를 변형하여 사용하는 것을 막는다.

#일반적으로 my를 지정한 이후 사용해야 한다.

#use strict;

#특정 버전에 기능을 추가하여 사용하도록 한다.

# use 5.010 ==> 5.10버전과 동일함.

# state 구문을 사용 할 수 있음.

# 배열, 해쉬는 사용 불가 ! 변수만 사용 가능함.

use 5.010;

#파일 입력 받기 처리

while(<>){

chomp;

print "It was $_ that I saw!\n";

}

#파일 입력 지정

@ARGV = qw!test.pl!;

while(<>){

chomp;

print $_,"\n";

}

#출력 예제 (목록출력 vs 보간처리출력)

@array =  qw{도적 죽음의기사 마법사 드루이드 성기사 사냥꾼 흑마법사 전사 사냥꾼 주술사};

print @array,"\n";

print "@array","\n";

#괄호의 활용

#print (2+3)의 리턴값인 1에 *4를 곱해 버린다.

#이상한 처리 형태이므로 perl은 (2+3)까지의 결과값을 출력 하기 때문에 5를 화면에 출력한다.

print (2+3)*4,"\n";

#==> 5

#배열과 printf

#@items를 2번 사용하는데 한 번은 스칼라 문맥에서 배열의 개수를 얻고

#또 한번은 목록 문맥에서 배열의 내용을 얻는다.

my @items = qw{apple banana pineapple mango};

my $format = "The characters are :\n".("%10s\n"x@items);

printf $format,@items;

if(!open PASSWD, "/etc/passwd"){

die "error occured : $!";

}

while(<PASSWD>){

#chomp;

print $_;

}

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

#정의 되지 않는 변수를 변형하여 사용하는 것을 막는다.

#일반적으로 my를 지정한 이후 사용해야 한다.

#use strict;

#특정 버전에 기능을 추가하여 사용하도록 한다.

# use 5.010 ==> 5.10버전과 동일함.

# state 구문을 사용 할 수 있음.

# 배열, 해쉬는 사용 불가 ! 변수만 사용 가능함.

use 5.010;

#사용자 정의 함수

# return 라인 멘 끝에 리턴할 값을 넣어준다.

my $n;

sub func_test{

$n+=10;

}

my $result = &func_test;

print $result,"\n";

#사용자 정의 함수

# 입력 파라미터 사용하기

# $_[숫자]를 활용한다

sub max1{

if($_[0]>=$_[1]){

$_[0];

}else{

$_[1];

}

}

print &max1(3,7),"\n";

# lexical variable : 어휘 변수(블럭 내부에서만 사용가능)

# my, @_ 의 활용

# ( 를 사용하면 목록 형 , 미사용 시는 스칼라 형임에 유의

sub max2{

my($n, $m) = @_;

if($n>=$m){$n}else{$m}

}

print max2(5,1),"\n";

#함수 입력 파라미터 점검

sub max3{

if(@_!=2){

print "warning ! &max3 should get exactly two arguments!\n";

}

my($n, $m) = @_;

if($n>=$m){$n}else{$m}

}

print max3(1,2,3),"\n";

#더 낳은 max루틴

sub max{

my($input) = shift @_;

if($input==undef){

print "warning ! no inputs!\n";

}

foreach(@_){

if($_>$input){

$input = $_;

}

}

$input;

}

print "max : ".&max(1,30,8),"\n";

#return의 활용

#원하는 값을 찾으면 조기 반환 처리

sub find_word{

my($word, @list) = @_;

foreach(0..$#list){

if($word eq $list[$_]){

return $_;

}

}

-1;

}

my @sample = qw!help wow grand!;

print "find_word : ".$sample[&find_word("wow",@sample)],"\n";

#함수의 활용

# & 또는 ()를 생략할 수 있다.

# 내장함수와 함수명이 동일한 경우 내장 함수를 호출하므로 &를 사용하는 것을 권장함.

print "find_word : ".$sample[find_word("wow",@sample)],"\n";

print "find_word : ".$sample[find_word"wow",@sample],"\n";

#state활용

# strict 사용시 global변수를 사용할 수 없는 경우에 사용됨.

# use 5.010을 써야 사용할 수 있음에 유의.

# 현재는 변수에서만 사용가능 ! 배열, 해쉬 사용 불가함.

sub print_test{

state $k+=1;

}

print &print_test,"\n";

print &print_test,"\n";

print &print_test,"\n";

#say 자동 줄바꿈이 포함됨.

#누적 연산 예제

sub print_sum{

state $sum = 0;

state @numbers;

push(@numbers,@_);

foreach(@numbers){

$sum+=$_;

}

say "list is (@numbers) : $sum";

}

&print_sum(1..3);

&print_sum(5..6);

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

#정의 되지 않는 변수를 변형하여 사용하는 것을 막는다.

#일반적으로 my를 지정한 이후 사용해야 한다.

#use strict;

#특정 버전에 기능을 추가하여 사용하도록 한다.

# use 5.010 ==> 5.10버전과 동일함.

# state 구문을 사용 할 수 있음.

# 배열, 해쉬는 사용 불가 ! 변수만 사용 가능함.

use 5.010;

#1에서 부터 100까지 더하는 사용자 함수

sub sum1to100{

my $sum;

foreach(1..100){

$sum+=$_;

}

say "sum 1 to 100 : $sum";

}

sum1to100();

#목록값을 입력 받아 평균보다 큰 값을 출력하는 함수

sub above_average{

my $sum , $avg;

foreach(@_){

$sum+=$_;

}

$avg = $sum / @_;

my @result = ($sum,$avg);

foreach(@_){

if($_>$avg){

push(@result,$_);

}

}

@result;

}

my @real = 1..10;

my @result = above_average(@real);

my $sum = shift @result;

my $avg = shift @result;

say "--------------------------";

say "real : @real";

say "sum : $sum";

say "avg : $avg";

say "above list : @result";

say "--------------------------";

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

$rock[0] = "aaa";

$rock[1] = "bbb";

$rock[25] = "zzz";

# $#rock : 배열의 마지막 첨자

print $rock[$#rock]."\n";

# -1 : 마지막 요소를 출력 한다

print $rock[-1]."\n";

# 목록 상수 @

# $#wow1 : 해당 배열 또는 목록의 마지막 인덱스 값을 반환한다.

@wow = ("1",2,"test");

print @wow."\n";

print @wow[-1]."\n";

# ..연산자

# 결과 : 목록에 1~100까지 수를 순차적으로 넣어줌.

@wow1 = (1..100);

print "wow1 : ".$#wow1."\n";

# ..연산자

# 결과 ; -1 , 목록에 100..1 과 같이 감소 형태로 넣음 안됨.

@wow1 = (100..1);

print "wow1 : ".$#wow1."\n";

# 목록 상수 qw

# 공백을 통해 목록을 구분 한다

# 구분자 : ! / ( { [ < # 사용 가능

# 다양한 구분자를 사용하는 이유 : unix에서 다양한 입력을 처리하기 위함

@list = qw{

/usr/bin/perl

/usr/game/wow

};

$cnt = 0;

while($cnt<=$#list){

print $cnt." : ".@list[$cnt]."\n";

$cnt+=1;

}

print "---------------\n";

$wo[0] = 123;

$wo[1] = 456;

($wo[0], $wo[1]) = ($wo[1], $wo[0]);

print $wo[-1]."\n";

@welcome = qw#hello , world !#;

$cnt = 0;

while($cnt<=$#welcome){

print $cnt." : ".@welcome[$cnt]."\n";

$cnt+=1;

}

print "---------------\n";

# @array : 목록 개수 , $#array : 마지막 인덱스

@array = 3..5;

print @array."\n";

print $#array."\n";

print "---------------\npush\n---------------\n";

# push : target , push value

push(@array, 10);

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

print "---------------\npush\n---------------\n";

push @array, 1..3;

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

print "---------------\npop\n---------------\n";

pop @array;

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

#shift : 가장 먼저 넣은 값을 반환 처리 한다.

@array = qw#main list description#;

print "---------------\nshift : real\n---------------\n";

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

@remain = shift @array;

print "---------------\nshift : result\n---------------\n";

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

print "---------------\nshift : return\n---------------\n";

$cnt = 0;

while($cnt<=$#remain){

print $cnt." : ".@remain[$cnt]."\n";

$cnt+=1;

}

#unshift : push를 left(오래된 쪽)에 한다 

@array = qw!first second third!;

print "---------------\nunshift : real\n---------------\n";

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

unshift @array , fourth;

print "---------------\nunshift : result\n---------------\n";

$cnt = 0;

while($cnt<=$#array){

print $cnt." : ".@array[$cnt]."\n";

$cnt+=1;

}

#foreach 선택 값(목록형태)

print "---------------\nforeach \n---------------\n";

foreach $numbers(qw/one two three/){

print "count : $numbers\n";

}

#foreach : 

# 기본 변수 $_

print "---------------\nforeach : \$_ \n---------------\n";

foreach (qw/one two three/){

print "count : $_\n",;

}

#print :

# 기본 변수 $_

print "---------------\nprint : \$_ \n---------------\n";

$_ = "test\n";

print;

#foreach : 

# 내부 목록 값 변경 가능

# $number : 해당 선택 값에 사용된 변수는 반복 이후 원상 복귀 됨 , 미 정의 시 undef가 됨

print "---------------\nforeach : undef \n---------------\n";

$number = init;

@numbers = qw!one two three!;

foreach $number (@numbers){

$number = "\t$number\n";

}

print "The numbers are :\n",@numbers;

print "\$number : $number\n";

#reverse

# 인자로 받은 값을 거꾸로 뒤집음.

#sort

# 인자로 받은 값을 정렬 한다.

print "---------------\nreverse & sort\n---------------\n";

@test = 1..10;

print "real : @test\n";

@test = reverse @test;

print "reverse : @test\n";

@test = sort(@test);

print "sort : @test\n";

#스칼라와 목록 문맥 이해

print "---------------\nconsider : scalar & list\n---------------\n";

@sample = qw[one two three];

@same = @sample; #목록을 반환한다.

$n = @sample; #개수를 반환한다.

print @same,"\n";

print $n,"\n";

print "_-_-_-_-_-_-_-_-_-\n";

@backward = reverse qw[one two three]; #목록을 reverse한다

$backward = reverse qw[one two three]; #문장을 reverse한다

print @backward,"\n";

print $backward,"\n";

print "_-_-_-_-_-_-_-_-_-\n";

@sample = qw{one two three};

print @sample,"\n";

print scalar @sample,"\n";

print "_-_-_-_-_-_-_-_-_-\n";

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

# ex1) reverse

print "input : (end : press ctrl + D)\n";

chomp(@lines = <STDIN>);

print "result : \n";

@lines = reverse @lines;

foreach(@lines){

print $_,"\n";

}

# ex2) arrangement

@items = qw[one two three four five];

print "input number 1 ~ 5 : (end : press ctrl + D)\n";

chomp(@lines = <STDIN>);

print "result : \n";

foreach(@lines){

print @items[$_-1],"\n";

}

# ex3) sort

print "input : (end : press ctrl + D)\n";

chomp(@lines = <STDIN>);

print "result : \n";

@lines = sort @lines;

foreach(@lines){

print $_,"\n";

}

>>> 원의 반지름 구하기 예제

print"input circle's radius : ";

$rad = <STDIN>;

$circle = 2 * 3.141592 * $rad;

if($rad<0){

print"circle's circumference : 0\n";

}else{

print"circle's circumference : ".$circle."\n";

}

>> 입력 받은 두 수 곱하기 예제

print"input first number : ";

$num1 = <STDIN>;

print"input second number : ";

$num2 = <STDIN>;

print"multiply result : ".($num1*$num2)."\n";

>> 입력 받은 문자열 반복 출력 예제

print"input string : ";

chomp($str = <STDIN>);

$str.=" ";

print"input repeat count : ";

$cnt = <STDIN>;

print"repeated string : ".($str x $cnt)."\n";

초반이라 그런지 잼있고 .. 할만 하네여 -_-;

#!/usr/bin/perl

#경고를 보여준다 (주석 해제 이후 사용)

#use warnings;

#경고보다 상세한 진단결과를 보여준다. (주석 해제 이후 사용) dianostics.pm 파일이 없는 경우 동작하지 않음.

#use dianostics;

#syntax error : 문자열 끼리만 연결이 가능함.(missing operator)

#print 4x5."\n";

#print "4"x5."\n";

print "4"x"5"."\n";

print 4x"5"."\n";

#결과 : (x는 문자열 반복 연산자)

#44444

print "4"*"5"."\n";

#결과 : (연산자에 따른 자동 캐스팅 활성됨)

#20

print "12xxf4"*"3"."\n";

#결과 :(줄바꿈 함) 

#36

print "12xxf4"*"3\n";

#결과 :(줄바꿈 안함) (숫자 뒤 문자는 무시 됨)

#36

print "\n";

#결과 :(줄바꿈)

$wow = 3;

$wow**=3;

print "$wow\n";

#결과 :

#27

#비교 : 숫자 // 문자

#같음 : == // eq

#같지않음 : != // ne

#작음 : < // lt

#큼 : > // gt

#작거나 같음 : <= // le

#크거나 같음 : >= // ge

if("test" gt "wow"){

print "test is small\n";

}else{

print "test is big\n";

}

#표준 입력 처리

#chomp : 줄바꿈 제거 , 반환 : 제거된 개수

print "input : ";

$line = <STDIN>;

print $line;

print chomp($line);

print $line;

#결과 : (>는 프롬프트를 의미)

#test

#1test>

print "\n";

#while

print "sum (1 ~ N) : ";

$count = 1;

$sum = 0;

$limit = <STDIN>;

while($count<=$limit){

$sum+=$count;

$count+=1;

}

print $sum."\n";