[Đã xong] Các hàm CAR, CDR, và các hàm biến thể từ chúng

[Doan Van Ha 3212]

Từ 2 hàm cơ bản CAR và CDR, Acad xây dựng thêm nhiều hàm biến thể khác để xử lý danh sách. Các hàm này đều liên quan tới 4 chữ cái A, C, D, R. Trong số đó, Acad chỉ có Help của 4 hàm, đó là: CAR, CDR, CADR, CADDR.

Vậy, còn bao nhiêu hàm biến thể nữa? Và cách sử dụng chúng như thế nào?

Bài viết này nhằm tổng kết nguyên lý xây dựng các hàm biến thể và cách sử dụng chúng.

- Có tất cả 31 hàm. Dưới đây là danh sách xếp theo thứ tự chữ cái:

CAAAAR
CAAADR
CAAAR
CAADAR
CAADDR
CAADR
CAAR
CADAAR
CADADR
CADAR
CADDAR
CADDDR
CADDR
CADR
CAR
CDAAAR
CDAADR
CDAAR
CDADAR
CDADDR
CDADR
CDAR
CDDAAR
CDDADR
CDDAR
CDDDAR
CDDDDR
CDDDR
CDDR
CDR

- Tất cả các hàm đều được xây dựng từ 2 hàm cơ bản: CAR và CDR

- Hàm CAR: lấy phần tử đầu tiên của List, tức là trả về phần tử đầu tiên của List.

- Hàm CDR: cắt phần tử đầu tiên của List, tức là trả về danh sách bị cắt bớt phần tử đầu tiên.

- Quy ước đặt tên để tạo các hàm:

+ Mọi hàm đều bắt đầu bằng chữ C và kết thúc bằng chữ R, kiểu như C...R.

+ Do đó, hai chữ C và R này không được xét tới khi phân tích chức năng hàm.

+ Giữa C và R, mỗi chữ A ám chỉ 1 hàm CAR; mỗi chữ D ám chỉ 1 hàm CDR.

+ Dựa vào nguyên tắc này, ta sẽ hiểu được bản chất của tất cả 31 hàm.

- Xét trường hợp đặc biệt thứ 1: giữa C và R là toàn chữ D

Nguyên lý các hàm CD...DR: cứ thêm 1 chữ D thì cắt bớt thêm 1 phần tử của danh sách.

Xét ví dụ: (setq lst ‘(1 2 3 4 5 6))

(CDR lst) <=> (CDR lst) => (2 3 4 5 6) ; cắt 1 phần tử đầu (có 1 chữ D)

(CDDR lst) <=> (CDR (CDR lst)) => (3 4 5 6) ; cắt 2 phần tử đầu (có 2 chữ D)

(CDDDR lst) <=> (CDR (CDR (CDR lst))) => (4 5 6) ; cắt 3 phần tử đầu (có 3 chữ D)

(CDDDDR lst) <=> (CDR (CDR (CDR (CDR lst)))) => (5 6) ; cắt 4 phần tử đầu (có 4 chữ D)

(CDDDDDR lst) => error: no function definition: CDDDDDR => không có hàm cắt > 4 phần tử

- Xét trường hợp đặc biệt thứ 2: giữa C và R là toàn chữ A

Nguyên lý các hàm CA...AR: cứ thêm 1 chữ A là thêm 1 lần lấy phần tử đầu của danh sách.

Xét ví dụ: (setq lst '(((((1 2) 3) 4) 5) 6))

(CAR lst) <=> (CAR lst) => ((((1 2) 3) 4) 5) ; lấy phần tử đầu (có 1 chữ A)

(CAAR lst) <=> (CAR (CAR lst)) => (((1 2) 3) 4) ; lấy tiếp phần tử đầu (có 2 chữ A)

(CAAAR lst) <=> (CAR (CAR (CAR lst))) => ((1 2) 3) ; lấy tiếp phần tử đầu (có 3 chữ A)

(CAAAAR lst) <=> (CAR (CAR (CAR (CAR lst)))) => (1 2) ; lấy tiếp phần tử đầu (có 4 chữ A)

(CAAAAAR lst) => error: no function definition: CAAAAAR ; => không có hàm lấy > 4 phần tử

- Như vậy, có 8 hàm đã tường minh cách xây dựng và sử dụng. Các hàm còn lại (23 hàm) cũng đều dựa trên nguyên tắc: cứ 1 chữ C tương đương 1 hàm CDR và 1 chữ A tương đương 1 hàm CAR.

Xét ví dụ: hàm CADADR

(CADADR lst) <=> (CAR (CDR (CAR (CDR lst))))

- Trong thực tế, chúng ta thường hay dùng 4 hàm sau đây (và Acad chỉ có Help của 4 hàm này) với chức năng như sau:

+ Hàm CAR: lấy toạ độ X của điểm.

+ Hàm CADR: lấy toạ độ Y của điểm.

+ Hàm CADDR: lấy toạ độ Z của điểm.

+ Hàm CDR: lấy giá trị mã DXF của đối tượng.

Xét ví dụ: (setq pt ‘(1.0 2.0 3.0))

(CAR pt) => 1.0

(CADR pt) => 2.0

(CADDR pt) => 3.0

(CDR ‘(1 . “TEXT”) => “TEXT”

Hy vọng bài viết này bổ ích cho các bạn!

[ketxu 3020]

Nguyên tắc : (CXXXXR) : X = A hoặc D, Lisp thực hiện tuần tự từ phải sang trái

[Doan Van Ha 3212]

Không cần phải nêu quy tắc này Ket ạ. Bởi cứ thay A bằng (CAR) và D bằng (CDR) thì tự khắc nó lồng nhau. Còn thứ tự từ trong ra ngoài (trong trường hợp này là phải sang trái) là nguyên tắc của hàm hợp rồi.

[Thaistreetz 541]

đọc cái quy tắc của bác DVH sao mà trừu tượng rối rắm thế (!?)

Mình toàn làm kiểu thế này cho nó đơn giản và tiện lắp ghép không sợ nhầm lẫn : (phần màu đỏ là fần cần bỏ)

(car (cdr)) = (ca-dr) = (cadr)

(cadr (cadr)) = (cad-adr) = (cadadr)

(car (cadadr)) = (ca-adadr) = (caadadr)

(cadr (cadr (car))) = cad-ad-ar = (cadadar)

 

=> Chốt hạ 1 câu ngắn gọn là: hãy bỏ 3 ký tự nối giữa 2 hàm "r(c" bạn sẽ có 1 hàm gộp của 2 hàm đó

 

Vì mình viết code bằng vlide nên danh sách các hàm hỗ trợ đã được nhận biết. với quy tắc trên, nếu kết quả không thuộc danh sách các từ khóa được bảo vệ (các từ khóa được bảo vệ tự động chuyển sang màu xanh dương khi ta hoàn thành từ khóa) thì có nghĩa ta không có hàm đó.

[Doan Van Ha 3212]

Lý do của sự "rối rắm" là:

- Có hàm hợp thì viết được hàm đơn. Cái này dùng để viết lisp cho gọn.

- Có hàm đơn thì hiểu được hàm hợp. Cái này dùng để đọc lisp người khác viết.