devnauts

curl -O https://beta.quicklisp.org/quicklisp.lisp

curl -O https://beta.quicklisp.org/quicklisp.lisp.asc

gpg --verify quicklisp.lisp.asc quicklisp.lisp

sbcl --load quicklisp.lisp

(quicklisp-quickstart:install)

(ql:add-to-init-file)

(ql:system-apropos "vecto")

(ql:quickload "vecto")

(load "~/quicklisp/setup.lisp")

<테스트 환경>

OS : Windows 7

QuickLisp 버전 : beta

(list a b c)
-> (a b c)

'(a b c)
-> (a b c)

(cons a '(b c))
-> (a b c)

(vector 1 2 3)
-> #(1 2 3)

#(1 2 3)
-> #(1 2 3)

(make-array 3 :initial-element 1)
-> #(1 1 1)

(defparameter some-array (make-array 4 :initial-element 1)) ; 길이가 4이고 1로 초기화

(unless A B C D)

; (if (not A) (progn B C D)) 와 동일

(not T)

-> NIL

(not nil)

-> T

(not '())
-> T

(not 10) ; 10은 nil 값이 아니므로

-> NIL

;; 사용법 :

(do ((변수명 초기값 다음값_계산식)) (종료조건1 종료조건2 ..)) ; 모든 종료 조건을 만족해야 종료 (AND 연산)
    실행구문1
    실행구문2
    ..
)

(do ((i 0 (+ i 1))) ((>= i 100)) ; => for (i = 0; i < 100; i++) 과 동일

)

(dolist (x '(1 2 3 4))
    (print x)
)
-> 1
2
3
4
NIL

(dolist (x '(1 2 3 4))
    (print x)
    (if (= x 2) (return)) ; return 문을 사용하여 루프를 빠져나올 수 있음
)
-> 1

2

NIL

(read-line)

; 문자열 자르기
(subseq "abcdef" 2)
-> "cdef"

(subseq "abcdef" 0 2)
-> "ab"

; 문자열 치환
(defparameter str (string "abcdef"))
(setf (subseq str 0 2) "AB")
str
-> "ABcdef"

; 치환시 변경 전의 길이보다 변경 후의 부분이 더 길 경우, 변경 전의 길이만큼만 바뀐다. (늘어나지 않음)
(defparameter str (string "abcdef"))
(setf (subseq str 0 2) "ABC")
str
-> "ABcdef"

(setf (subseq "abcdef" 0 2) "AB") ; (X) 변수에 대해서만 사용가능하다

(setq (subseq str 0 2) "ABC") ; (X) setq가 아닌 setf만 가능함에 유의

; 문자열 결합
(concatenate 'string "abc" "def") ; 문자열로 결합
-> "abcdef"

(concatenate 'list "abc" "def") ; 문자의 리스트로 결합
-> (#\a #\b #\c #\d #\e #\f)

; 문자열 포매팅
(format nil "this is ~A" '(a b c))
-> "this is (A B C)"

(format nil "this is ~{ ~A~}" '("abc" "def" "ghi"))
-> "this is  abc def ghi"

; 개별 문자 얻기
(char "abcdef" 2)
-> #\c

; 개별 문자 치환
(defparameter str (string "abcdef"))
(setf (char str 5) #\g)
str
-> "abcdeg"

; 문자 -> 코드 변환
(char-code #\a)
-> 97

; 코드 -> 문자 변환
(code-char 97)
-> #\a

; 한번에 한 문자씩 처리 : 익명 함수를 통해 직접 처리하는 방법
(map 'string #'(lambda (c) (print c)) "abcde")
-> #\a
#\b
#\c
#\d
#\e
"abcde"
 
; 한번에 한 문자씩 처리 : loop를 사용하여 문자 리스트를 얻어 처리하는 방법
(loop for char across "abcde" collect char)
-> (#\a #\b #\c #\d #\e)

; 특정 문자 제거
(remove #\b "abcdef")
-> "acdef"

(remove #\b "bbbbbb1" :start 2) ; 인덱스 2 이후 문자를 대상으로
-> "bb1"

; 특정 조건을 만족하는 문자 제거
(remove-if #'upper-case-p "AbCdEf") ; 대문자 제거
-> "bdf"

; 특정 문자 대체 (뒤엣것으로 앞엣것을 대체)
(substitute #\z #\a "abcdefga")
-> "zbcdefgz"

; 특정 조건을 만족하는 문자 대체
(substitute #\Z #'upper-case-p "AbCdEf")
-> "ZbZdZf"

; 특정 구간만큼 대체
(replace "abcdef" "12345" :end1 3) ; 인덱스 3 앞의 문자를 대상으로
-> "123def"

; 길이가 1인 문자열 -> 문자
(coerce "a" 'character)
-> #\a

(coerce "ab" 'character) ; 길이가 1이 아닐 때 쓰면 에러 발생!

; 길이가 1이 넘는 문자열 -> 문자 리스트
(coerce "abc" 'list)
-> (#\a #\b #\c)

; 길이가 1인 문자열 <- 문자
(string #\a)
-> "a"

; 길이가 1이 넘는 문자열 <- 문자
(coerce '(#\a #\b #\c) 'string) ; 리스트로부터 생성
-> "abc"

(coerce #(#\a #\b #\c) 'string) ; array로부터 생성 (1)
-> "abc"

(defparameter some-array (make-array 4 :initial-element #\a)) ; array로부터 생성 (2)
(coerce some-array 'string)
-> "aaaa"

; [참고] array 정의 방법
(defparameter some-array (make-array 4 :initial-element #\a)) ; 길이가 4이고 a로 초기화

; 문자열 뒤집기
(reverse (string "abcde"))
-> "edcba"

; 대소문자 변환
(string-upcase "abcde")
-> "ABCDE"
(string-downcase "ABCDE")
-> "abcde"
(string-capitalize "abcde")
-> "Abcde"

; 문자열 트림 : 첫번째 파라미터의 문자들을 두번째 파라미터 끝에서부터 제거한다
(string-trim " " " abc def ")
-> "abc def"
(string-trim " ac" " abc abc ")
-> "bc ab"
(string-left-trim " ac" " abc abc ") ; 왼쪽에서부터 제거
-> "bc abc "
(string-right-trim " ac" " abc abc ") ; 오른쪽에서부터 제거
-> " abc ab
(string-right-trim '(#\Space #\a #\c) " abc abc ") ; 첫번째 파라미터로 문자열 대신 리스트 사용
-> " abc ab"

; 문자열 -> 심볼(변수명 등) 변환
; - 단지 변환하는 것이 아닌 해당 심볼이 패키지에 존재하지 않을 경우 추가된다.
(intern "SOME-SYMBOL")

; 심볼 -> 문자열 변환
; - 심볼 존재 유무에 상관없이 동작
(symbol-name 'SOME-SYMBOL)
-> "SOME-SYMBOL"

; 문자 검색 후 발견한 문자 반환

(find #\t "The quick onyx goblin jumps over the lazy dwarf." :test #'equal) ; 대소문자 구별하여 검색
-> #\t

(find #\Z "The quick onyx goblin jumps over the lazy dwarf." :test #'equal) ; 미발견시
-> NIL

(find #\Z "The quick onyx goblin jumps over the lazy dwarf." :test #'equalp) ; 대소문자 구별 없이 검색
-> #\z


; 특정 함수를 만족시키는 문자 검색하여 문자 반환
; (digit-char-p : 문자가 숫자를 나타내는 문자인지 체크하는 함수)

(find-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890") ;
-> #\1

(find-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890" :from-end t) ; 뒤에서부터 검색
-> #\0


; 문자 검색 후 발견한 위치 반환

(position #\t "The quick onyx goblin jumps over the lazy dwarf." :test #'equal) ; 대소문자 구별하여 검색
-> 33

(position #\t "The quick onyx goblin jumps over the lazy dwarf." :test #'equalp) ; 대소문자 구별 없이 검색
-> 0

; 특정 함수를 만족시키는 문자 검색하여 위치를 반환

(position-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890")
-> 49

(position-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890" :from-end t) ; 뒤에서부터 검색
-> 58


; 문자 검색 후 발견한 갯수 반환

(count #\t "The quick onyx goblin jumps over the lazy dwarf." :test #'equal) ; 대소문자 구별하여 검색
-> 1

(count #\t "The quick onyx goblin jumps over the lazy dwarf." :test #'equalp) ; 대소문자 구별 없이 검색
-> 2

; 특정 함수를 만족시키는 문자 검색하여 갯수를 반환

(count-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890")
-> 10

(count-if #'digit-char-p "The quick onyx goblin jumps over the lazy dwarf. 1234567890" :start 51) ; 특정 위치에서부터 검색
-> 5

; 기본 검색
(search "the" "the quick onyx goblin jumps over the lazy dwarf.")
-> 0

; 뒤에서부터 검색
(search "the" "the quick onyx goblin jumps over the lazy dwarf." :from-end t)
-> 33

; 시작 위치를 지정하여 검색
(search "the" "the quick onyx goblin jumps over the lazy dwarf." :start2 4)
-> 33

; 뒤에서부터 시작 위치를 지정하여 검색
(search "the" "the quick onyx goblin jumps over the lazy dwarf." :end2 10 :from-end t)
-> 0

; 미발견시
(search "JUMPS" "the quick onyx goblin jumps over the lazy dwarf.")
-> NIL

; 특정 함수를 만족시키는 문자열 검색
(search "JUMPS" "the quick onyx goblin jumps over the lazy dwarf." :test #'char-equal) ; 대소문자 구별없이 문자 비교
-> 22

(parse-integer "37")
-> 37
2

(parse-integer "37" :start 1) ; 시작 위치를 지정
-> 7
2

(parse-integer "37" :end 1) ; 종료 위치를 지정
-> 3
1

(parse-integer "37" :radix 8) ; 진수를 지정
-> 31
2

(parse-integer " 37 ") ; space가 포함되도 괜찮다
-> 37
4

(parse-integer " 37 is thirty-seven" :junk-allowed t) ; space 외 다른 문자가 포함되는 것을 허용할 경우
-> 37
3

(parse-integer " 37 is thirty-seven") ; space 외 다른 문자를 허용하지 않을 경우
-> junk in string " 37 is thirty-seven" (에러 발생!)

(read-from-string "#X23") ; 8진수 표현
-> 35
4

(read-from-string "4.5") ; 소수점
-> 4.5
3

(read-from-string "6/8") ; 분수
-> 3/4
3

(read-from-string "#C(6/8 1)") ; 복소수 (실수부 + 허수부)
-> #C(3/4 1)
9

(read-from-string "1.2e2") ; 지수 표기법
-> 120.00001
5

(defparameter a-symbol 34)
(read-from-string "a-symbol")
-> A-SYMBOL
8

(defparameter a-symbol 34)
(read-from-string "#.a-symbol") ; 변수의 실제값을 사용
-> 34
10

(read-from-string "#.(+ 1 2)") ; 함수 호출 결과값을 사용
-> 3
9

(write-to-string 250)
-> "250"

(write-to-string 250.02)
-> "250.02"

(write-to-string 250 :base 16) ; 16진수로
-> "FA"

(write-to-string (/ 1 3)) ; 유리수
-> "1/3"

(string= "Abcd" "Abcd") ; 대소문자 구별하여 비교
-> T

(string= "Abcd" "abcd")
-> NIL

(string-equal "Abcd" "abcd") ; 대소문자 구별하지 않고 비교
-> T

(string< "aaaa" "aaab") ; "aaaa"가 "aaab"보다 작을 경우 달라지는 인덱스를 반환. 그렇지 않을 경우, NIL을 반환
-> 3

(string< "aaab" "aaaa")
-> NIL

(string-lessp "AAAA" "aaab") ; string<와 대소문자 구별을 하지 않는다는 점만 빼고 같음
-> 3

(mismatch "abcde" "bbcde" :test #'char=) ; char= 함수를 만족하지 않는 인덱스를 반환
-> 0

(mismatch "abcde" "abdde" :from-end t :test #'char=) ; 뒤에서부터 비교하여 char= 함수를 만족하지 않는 인덱스를 반환 (주의 : 0번째 문자에서 달라질 경우 1을 반환)
-> 3

(print *posix-argv*)

sbcl --script example.lisp enter your argument

("sbcl" "enter" "your" "argument")

<테스트 환경>

OS : Windows 7

(require :sb-posix)
(require :sb-grovel)

(defun is-directory (pathname) ; 주어진 경로가 디렉토리인지 체크한다
  (ignore-errors
    (sb-posix:s-isdir (sb-posix:stat-mode (sb-posix:lstat pathname)))
    )
  )

(defun get-directory-contents (pathname) ; 주어진 경로 내의 모든 디렉토리/파일 리스트를 얻는다
  (let ((dir (sb-posix:opendir pathname)))
    (prog1
      (loop for dirent = (sb-posix:readdir dir)
           until (sb-grovel::foreign-nullp dirent)
           unless (or (equal (sb-posix:dirent-name dirent) ".")
                      (equal (sb-posix:dirent-name dirent) ".."))
           collect (concatenate 'string pathname "/"
                                (sb-posix:dirent-name dirent)))
      (sb-posix:closedir dir))
    )
  )

(defun get-dirs (dir) ; 주어진 경로 내의 모든 디렉토리 리스트를 얻는다 (get-directory-contents의 결과 중 디렉토리가 아닌 항목을 제거한다)
  (remove-if-not #'is-directory (get-directory-contents dir))
  )


(defparameter dir-list nil)

(setq dir-list (get-dirs ".")) ; 현재 디렉토리 내의 디렉토리를 가져와 DIR-LIST에 저장한다

(dolist (dir dir-list) ; DIR-LIST의 내용을 출력한다
  (print dir)
  )

(require :sb-posix)
(require :sb-grovel)

(defun is-directory (pathname) ; 주어진 경로가 디렉토리인지 체크한다
  (ignore-errors
    (sb-posix:s-isdir (sb-posix:stat-mode (sb-posix:lstat pathname)))
    )
  )

(defun get-directory-contents (pathname) ; 주어진 경로 내의 모든 디렉토리/파일 리스트를 얻는다
  (let ((dir (sb-posix:opendir pathname)))
    (prog1
      (loop for dirent = (sb-posix:readdir dir)
           until (sb-grovel::foreign-nullp dirent)
           unless (or (equal (sb-posix:dirent-name dirent) ".")
                      (equal (sb-posix:dirent-name dirent) ".."))
           collect (concatenate 'string pathname "/"
                                (sb-posix:dirent-name dirent)))
      (sb-posix:closedir dir))
    )
  )

(defun get-dirs (dir) ; 주어진 경로 내의 모든 디렉토리 리스트를 얻는다 (get-directory-contents의 결과 중 디렉토리가 아닌 항목을 제거한다)
  (remove-if-not #'is-directory (get-directory-contents dir))
  )

(defun get-files (dir) ; 주어진 경로 내의 모든 파일 리스트를 얻는다 (get-directory-contents의 결과 중 디렉토리인 항목을 제거한다)
  (remove-if #'is-directory (get-directory-contents dir))
  )

(defparameter file-list nil)

(setq file-list (get-files ".")) ; 현재 디렉토리 내의 파일 리스트를 가져와 FILE-LIST에 저장한다

(dolist (file-item file-list) ; FILE-LIST의 내용을 출력한다
  (print file-item)
  )

<테스트 환경>

OS : Windows 7

SBCL 버전 : 1.2.7

sbcl.exe --script <filename>

sbcl.exe --script %1

<테스트 환경>

OS : Windows 7