ทำไมความชั่วร้ายจึงเป็นจริง?

ฉันรู้ว่าโปรแกรมเมอร์ Lisp และ Scheme มักจะบอกว่าevalควรหลีกเลี่ยงเว้นแต่จำเป็นอย่างเคร่งครัด ผมเคยเห็นคำแนะนำเหมือนกันสำหรับการเขียนโปรแกรมภาษาหลาย evalแต่ฉันยังไม่เห็นรายชื่อของการขัดแย้งที่ชัดเจนกับการใช้งานของ ฉันจะหาบัญชีของปัญหาที่อาจเกิดขึ้นจากการใช้งานได้evalที่ไหน

ตัวอย่างเช่นผมรู้ว่าปัญหาของGOTOในการเขียนโปรแกรมขั้นตอน (โปรแกรมทำให้อ่านได้ยากและยากที่จะรักษาทำให้ปัญหาความปลอดภัยยากที่จะหา ฯลฯ ) evalแต่ผมไม่เคยเห็นมีปากเสียงกับ

ที่น่าสนใจข้อโต้แย้งที่เหมือนกันGOTOนั้นน่าจะใช้ได้กับการต่อเนื่อง แต่ฉันเห็นว่า Schemers นั้นจะไม่พูดว่าการต่อเนื่องนั้นเป็น "ความชั่วร้าย" - คุณควรระวังเมื่อใช้มัน พวกเขามีแนวโน้มที่จะขมวดคิ้วเมื่อใช้โค้ดevalมากกว่าใช้โค้ดต่อเนื่อง (เท่าที่ฉันเห็น - ฉันอาจผิด)

EVALมีเหตุผลหลายประการที่หนึ่งไม่ควรใช้

เหตุผลหลักสำหรับผู้เริ่มต้นคือคุณไม่ต้องการมัน

ตัวอย่าง (สมมติว่า Common LISP):

หาค่านิพจน์ด้วยตัวดำเนินการอื่น:

(let ((ops '(+ *)))
  (dolist (op ops)
    (print (eval (list op 1 2 3)))))

นั่นเขียนได้ดีกว่า:

(let ((ops '(+ *)))
  (dolist (op ops)
    (print (funcall op 1 2 3))))

มีตัวอย่างมากมายที่ผู้เริ่มต้นเรียนรู้ Lisp คิดว่าพวกเขาต้องการEVALแต่พวกเขาไม่ต้องการ - เนื่องจากมีการประเมินนิพจน์และสามารถประเมินส่วนของฟังก์ชันได้เช่นกัน เวลาส่วนใหญ่ที่ใช้EVALแสดงให้เห็นถึงการขาดความเข้าใจของผู้ประเมิน

มันเป็นปัญหาเดียวกันกับมาโคร บ่อยครั้งที่ผู้เริ่มต้นเขียนแมโครซึ่งพวกเขาควรจะเขียนฟังก์ชั่น - ไม่เข้าใจว่ามาโครตัวใดมีไว้เพื่ออะไรจริงๆและไม่เข้าใจว่าฟังก์ชั่นทำงานอยู่แล้ว

บ่อยครั้งเป็นเครื่องมือที่ไม่ถูกต้องสำหรับงานที่ใช้EVALและมักจะระบุว่าผู้เริ่มต้นไม่เข้าใจกฎการประเมินผลเสียงกระเพื่อมตามปกติ

หากคุณคิดว่าคุณต้องEVALแล้วตรวจสอบว่าสิ่งที่ชอบFUNCALL, REDUCEหรือAPPLYอาจจะนำมาใช้แทน

• FUNCALL - เรียกใช้ฟังก์ชันที่มีอาร์กิวเมนต์: (funcall '+ 1 2 3)
• REDUCE - เรียกใช้ฟังก์ชันในรายการค่าและรวมผลลัพธ์: (reduce '+ '(1 2 3))
• APPLY- (apply '+ '(1 2 3))เรียกใช้ฟังก์ชันที่มีรายชื่อเป็นข้อโต้แย้งนี้:

ถาม: ฉันต้องการ eval จริง ๆ หรือคอมไพเลอร์ / ผู้ประเมินแล้วสิ่งที่ฉันต้องการจริงๆ

เหตุผลหลักที่ควรหลีกเลี่ยงEVALสำหรับผู้ใช้ขั้นสูงเล็กน้อย:

• คุณต้องการตรวจสอบให้แน่ใจว่าโค้ดของคุณถูกคอมไพล์เพราะคอมไพเลอร์สามารถตรวจสอบรหัสสำหรับปัญหาต่าง ๆ และสร้างรหัสได้เร็วขึ้นบางครั้งจำนวนมากมาก (นั่นคือตัวคูณ 1,000 ;-))

• รหัสที่สร้างขึ้นและต้องได้รับการประเมินไม่สามารถรวบรวมได้เร็วที่สุด

• การป้อนข้อมูลผู้ใช้โดยพลการจะทำให้เกิดปัญหาด้านความปลอดภัยขึ้น

• การใช้การประเมินผลบางอย่างกับEVALสามารถเกิดขึ้นในเวลาที่ไม่ถูกต้องและสร้างปัญหาการสร้าง

หากต้องการอธิบายจุดสุดท้ายด้วยตัวอย่างที่ง่ายขึ้น:

(defmacro foo (a b)
  (list (if (eql a 3) 'sin 'cos) b))

ดังนั้นฉันอาจต้องการที่จะเขียนแมโครว่าขึ้นอยู่กับการใช้พารามิเตอร์แรกอย่างใดอย่างหนึ่งหรือSINCOS

(foo 3 4)ไม่(sin 4)และไม่(foo 1 4)(cos 4)

ตอนนี้เราอาจมี:

(foo (+ 2 1) 4)

สิ่งนี้ไม่ได้ให้ผลลัพธ์ที่ต้องการ

จากนั้นหนึ่งอาจต้องการซ่อมแซมแมโครFOOโดยการประเมินตัวแปร:

(defmacro foo (a b)
  (list (if (eql (eval a) 3) 'sin 'cos) b))

(foo (+ 2 1) 4)

แต่นี่ก็ยังใช้งานไม่ได้:

(defun bar (a b)
  (foo a b))

ค่าของตัวแปรไม่เป็นที่รู้จักในเวลารวบรวม

เหตุผลสำคัญทั่วไปที่ควรหลีกเลี่ยงEVAL:มักใช้เพื่อการแฮ็กที่น่าเกลียด

eval(ในภาษาใด ๆ ) ไม่ใช่ความชั่วร้ายในลักษณะเดียวกับที่ลูกโซ่ไม่ใช่ความชั่วร้าย มันเป็นเครื่องมือ มันเป็นเครื่องมือที่ทรงพลังที่เมื่อนำไปใช้ในทางที่ผิดสามารถตัดแขนขาและ eviscerate (พูดเชิงเปรียบเทียบ) แต่สามารถพูดได้เหมือนกันสำหรับเครื่องมือมากมายในกล่องเครื่องมือของโปรแกรมเมอร์รวมถึง:

• goto และเพื่อน ๆ
• เกลียวล็อคที่ใช้
• ต
• มาโคร (hygenic หรืออื่น ๆ )
• ชี้
• ข้อยกเว้นที่เริ่มต้นได้ใหม่
• รหัสแก้ไขตัวเอง
• ... และนักแสดงนับพัน

หากคุณพบว่าตัวเองต้องใช้เครื่องมือที่ทรงพลังและอันตรายเหล่านี้ให้ถามตัวเองสามครั้งว่า "ทำไม" ในห่วงโซ่ ตัวอย่างเช่น:

"ทำไมฉันต้องใช้eval?" "เพราะ foo" "ทำไมถึงต้องฟู" "เพราะ ..."

หากคุณไปถึงจุดสิ้นสุดของห่วงโซ่นั้นและเครื่องมือยังคงดูเหมือนว่าเป็นสิ่งที่ถูกต้องให้ทำเช่นนั้น บันทึก Hell ออกมา ทดสอบนรกออกมาจากมัน ตรวจสอบความถูกต้องและความปลอดภัยซ้ำแล้วซ้ำอีก แต่ทำมัน

Eval ใช้ได้ดีตราบใดที่คุณรู้ว่ามีอะไรเกิดขึ้น การป้อนข้อมูลของผู้ใช้ใด ๆ จะต้องตรวจสอบและตรวจสอบและทุกอย่าง หากคุณไม่ทราบวิธีการตรวจสอบให้แน่ใจ 100% อย่าทำเช่นนั้น

โดยทั่วไปผู้ใช้สามารถพิมพ์รหัสใด ๆ สำหรับภาษาที่เป็นปัญหาและมันจะดำเนินการ คุณสามารถจินตนาการถึงความเสียหายที่เขาสามารถทำได้

"ฉันควรใช้เมื่อevalไหร่" อาจเป็นคำถามที่ดีกว่า

คำตอบสั้น ๆ คือ "เมื่อโปรแกรมของคุณต้องการเขียนโปรแกรมอื่นเมื่อรันไทม์แล้วเรียกใช้" โปรแกรมทางพันธุกรรมevalเป็นตัวอย่างของสถานการณ์ที่มันอาจจะทำให้ความรู้สึกกับการใช้

IMO, คำถามนี้ไม่ได้เฉพาะการ LISP นี่คือคำตอบสำหรับคำถามเดียวกันสำหรับ PHP และใช้กับ LISP, Ruby และภาษาอื่น ๆ ที่มี eval:

ปัญหาหลักของ eval () คือ:

• การป้อนข้อมูลที่อาจไม่ปลอดภัย การส่งพารามิเตอร์ที่ไม่น่าเชื่อถือเป็นวิธีที่ล้มเหลว มันมักจะไม่ใช่งานที่ไม่สำคัญเพื่อให้แน่ใจว่าพารามิเตอร์ (หรือส่วนหนึ่งของมัน) นั้นเชื่อถือได้อย่างสมบูรณ์
• Trickyness การใช้ eval () ทำให้โค้ดฉลาดขึ้นดังนั้นจึงยากที่จะติดตาม ในการอ้างถึง Brian Kernighan " การดีบักนั้นยากกว่าการเขียนรหัสสองเท่าในตอนแรกดังนั้นถ้าคุณเขียนรหัสอย่างชาญฉลาดที่สุดเท่าที่จะทำได้คุณจะเป็นผู้นิยามไม่ฉลาดพอที่จะทำการแก้ไข "

ปัญหาหลักที่เกิดขึ้นจริงกับการใช้ eval () เป็นเพียงปัญหาเดียว:

• นักพัฒนาที่ไม่มีประสบการณ์ซึ่งใช้งานโดยไม่พิจารณาอย่างเพียงพอ

ที่นำมาจากที่นี่

ฉันคิดว่าชิ้นเล่ห์เหลี่ยมเป็นจุดที่น่าอัศจรรย์ ความหลงใหลในโค้ดกอล์ฟและโค้ดที่กระชับนั้นส่งผลให้เกิดโค้ด "ฉลาด" (ซึ่ง evals เป็นเครื่องมือที่ยอดเยี่ยม) แต่คุณควรเขียนโค้ดเพื่อให้สามารถอ่านได้ IMO ไม่ใช่เพื่อแสดงว่าคุณฉลาดและไม่ประหยัดกระดาษ (คุณจะไม่พิมพ์)

จากนั้นใน LISP มีปัญหาบางอย่างที่เกี่ยวข้องกับบริบทที่มีการเรียกใช้งาน Eval ดังนั้นโค้ดที่ไม่น่าเชื่อถือจึงสามารถเข้าถึงสิ่งต่างๆได้มากขึ้น ปัญหานี้ดูเหมือนจะเป็นเรื่องธรรมดาอยู่ดี

มีคำตอบที่ยอดเยี่ยมมากมาย แต่นี่เป็นอีกคำตอบหนึ่งจาก Matthew Flatt หนึ่งในผู้พัฒนาแร็กเก็ต:

http://blog.racket-lang.org/2011/10/on-eval-in-dynamic-languages-generally.html

เขาทำหลายจุดที่ได้รับการคุ้มครองแล้ว แต่บางคนอาจพบว่าเขาสนใจ แต่อย่างไรก็ตาม

สรุป: บริบทที่ใช้มีผลต่อผลลัพธ์ของการประเมินผล แต่มักไม่ได้รับการพิจารณาโดยโปรแกรมเมอร์ซึ่งนำไปสู่ผลลัพธ์ที่ไม่คาดคิด

คำตอบที่ยอมรับคือการอยู่ห่าง ซึ่งฉันพบว่าแปลกเพราะมันเป็นแบบดั้งเดิมและหนึ่งในเจ็ดแบบดั้งเดิม (ส่วนอื่น ๆ คือข้อเสียรถยนต์ cdr ถ้า eq และคำพูด) มันได้รับการใช้งานและความรักน้อยที่สุด

จากOn Lisp : "โดยปกติแล้วการโทรหา eval อย่างชัดเจนก็เหมือนกับการซื้อของในร้านขายของที่ระลึกที่สนามบินเมื่อรอจนถึงวินาทีสุดท้าย

ดังนั้นฉันจะใช้ eval เมื่อไหร่? หนึ่งในการใช้งานปกติคือการมี REPL ภายใน REPL (loop (print (eval (read))))ของคุณโดยการประเมิน ทุกคนใช้ได้ดีกับการใช้งานนั้น

แต่คุณยังสามารถกำหนดฟังก์ชั่นในแง่ของมาโครที่จะถูกประเมินหลังการคอมไพล์โดยรวม eval กับ backquote คุณไป

(eval `(macro ,arg0 ,arg1 ,arg2))))

และมันจะฆ่าบริบทสำหรับคุณ

Swank (สำหรับ emacs slime) เต็มไปด้วยกรณีเหล่านี้ พวกเขามีลักษณะเช่นนี้:

(defun toggle-trace-aux (fspec &rest args)
  (cond ((member fspec (eval '(trace)) :test #'equal)
         (eval `(untrace ,fspec))
         (format nil "~S is now untraced." fspec))
        (t
         (eval `(trace ,@(if args `(:encapsulate nil) (list)) ,fspec ,@args))
         (format nil "~S is now traced." fspec))))

ฉันไม่คิดว่ามันเป็นการแฮ็คที่สกปรก ฉันใช้มันตลอดเวลาเพื่อคืนค่าแมโครใหม่ให้เป็นฟังก์ชั่น

อีกสองสามคะแนนใน Lisp eval:

• มันประเมินภายใต้สภาพแวดล้อมของโลกสูญเสียบริบทท้องถิ่นของคุณ
• บางครั้งคุณอาจถูกล่อลวงให้ใช้ Eval เมื่อคุณตั้งใจจะใช้มาโคร read ''. ซึ่งประเมินในเวลาอ่าน

เช่นเดียวกับกฎ "GOTO": หากคุณไม่รู้ว่าคุณกำลังทำอะไรอยู่

นอกเหนือจากการสร้างข้อมูลที่เป็นที่รู้จักและปลอดภัยแล้วยังมีปัญหาที่บางภาษา / การใช้งานไม่สามารถเพิ่มประสิทธิภาพของรหัสได้อย่างเพียงพอ evalคุณอาจจะจบลงด้วยภายในรหัสตีความ

Eval นั้นไม่ปลอดภัย ตัวอย่างเช่นคุณมีรหัสต่อไปนี้:

eval('
hello('.$_GET['user'].');
');

ขณะนี้ผู้ใช้มาที่ไซต์ของคุณและป้อน URL http://example.com/file.php?user= ); $ is_admin = true; echo (

จากนั้นรหัสผลลัพธ์จะเป็น:

hello();$is_admin=true;echo();

Eval ไม่ใช่ความชั่วร้าย Eval ไม่ซับซ้อน มันเป็นฟังก์ชั่นที่รวบรวมรายชื่อที่คุณส่งให้ ในภาษาอื่น ๆ ส่วนใหญ่การคอมไพล์โค้ดโดยพลการจะหมายถึงการเรียนรู้ AST ของภาษาและการขุดในคอมไพเลอร์ภายในเพื่อหา API คอมไพเลอร์ ในเสียงกระเพื่อมคุณเพียงเรียก eval

คุณควรใช้เมื่อใด เมื่อใดก็ตามที่คุณต้องการที่จะรวบรวมสิ่งที่มักจะใช้โปรแกรมที่ยอมรับสร้างหรือปรับเปลี่ยนโค้ดที่รันไทม์

เมื่อใดที่คุณไม่ควรใช้ กรณีอื่น ๆ ทั้งหมด

ทำไมคุณไม่ควรใช้มันเมื่อคุณไม่ต้องการ? เพราะคุณจะทำอะไรบางอย่างในลักษณะที่ซับซ้อนเกินความจำเป็นซึ่งอาจทำให้เกิดปัญหาในการอ่านประสิทธิภาพและการดีบัก

ใช่ แต่ถ้าฉันเป็นผู้เริ่มฉันจะรู้ได้อย่างไรว่าฉันควรใช้มัน? พยายามใช้สิ่งที่คุณต้องการด้วยฟังก์ชั่นเสมอ หากไม่ได้ผลให้เพิ่มมาโคร หากยังไม่ได้ผลให้ลองดู!

ปฏิบัติตามกฎเหล่านี้และคุณจะไม่ทำชั่วกับการประเมิน :)

ฉันชอบคำตอบของแซคเป็นอย่างมากและเขาก็มีความสำคัญกับเรื่องนี้: evalใช้เมื่อคุณกำลังเขียนภาษาใหม่สคริปต์หรือการดัดแปลงภาษา เขาไม่ได้อธิบายเพิ่มเติมดังนั้นฉันจะยกตัวอย่าง:

(eval (read-line))

ในโปรแกรม Lisp แบบง่ายนี้ผู้ใช้จะได้รับพร้อมต์ให้ป้อนข้อมูลจากนั้นสิ่งที่พวกเขาป้อนจะถูกประเมิน สำหรับการทำงานทั้งชุดของคำจำกัดความของสัญลักษณ์ที่จะนำเสนอมีถ้าโปรแกรมจะรวบรวมเพราะคุณมีความคิดที่ฟังก์ชั่นการใช้อาจป้อนไม่ดังนั้นคุณจะต้องรวมถึงพวกเขาทั้งหมด ซึ่งหมายความว่าหากคุณรวบรวมโปรแกรมอย่างง่ายนี้ไบนารีที่ได้จะเป็นขนาดใหญ่

ตามหลักการแล้วคุณไม่สามารถพิจารณาคำแถลงที่รวบรวมได้ด้วยเหตุผลนี้ โดยทั่วไปเมื่อคุณใช้evalคุณจะทำงานในสภาพแวดล้อมที่ถูกตีความและรหัสจะไม่สามารถรวบรวมได้อีกต่อไป ถ้าคุณไม่ใช้evalคุณสามารถคอมไพล์โปรแกรม Lisp หรือ Scheme เหมือนกับโปรแกรม C ดังนั้นคุณต้องการที่จะให้แน่ใจว่าคุณต้องการและความจำเป็นที่จะอยู่ในสภาพแวดล้อมที่ตีความก่อน committing ใช้EVAL