Expect คือโปรแกรมที่พูดถึงโปรแกรมโต้ตอบอื่น ๆ ตามสคริปต์ หลังจากที่สคริปต์คาดว่าจะรู้ว่าสิ่งที่คาดหวังจากโปรแกรมและสิ่งที่ควรได้รับการตอบสนองที่ถูกต้อง ภาษาที่ตีความจะมีโครงสร้างการควบคุมสาขาและระดับสูงในการกำหนดกรอบโต้ตอบ นอกจากนี้ผู้ใช้สามารถควบคุมและโต้ตอบโดยตรงได้เมื่อต้องการจากนั้นกลับไปควบคุมสคริปต์
Expectk เป็นส่วนผสมของ Expect และ Tk มันมีลักษณะเหมือน Expect และ Tk's ปรารถนา Expect สามารถใช้งานได้โดยตรงใน C หรือ C ++ โดยไม่มี Tcl
ชื่อ "คาดหวัง" มาจากแนวคิดการส่ง / คาดหวังลำดับที่นิยมโดย uucp, kermit และโปรแกรมควบคุมโมเด็มอื่น ๆ อย่างไรก็ตามไม่เหมือน uucp คาดว่าจะเป็นแบบ generalised เพื่อให้สามารถรันเป็นคำสั่งระดับผู้ใช้กับโปรแกรมและงานต่างๆได้ คาดว่าจะสามารถพูดคุยกับหลายโปรแกรมในเวลาเดียวกัน
สิ่งที่คาดหวังได้
ตัวอย่างเช่นนี่คือบางสิ่งที่คำสั่งคาดหวังสามารถทำได้:
- ทำให้คอมพิวเตอร์ของคุณโทรกลับเพื่อให้คุณสามารถเข้าสู่ระบบได้โดยไม่ต้องเสียค่าโทร
- เริ่มเกมและหากการกำหนดค่าที่เหมาะสมไม่ปรากฏขึ้นให้เริ่มต้นใหม่อีกครั้งและอีกครั้ง) จนกว่าจะมีการส่งมอบแล้วส่งมอบการควบคุมให้กับคุณ
- เรียกใช้ fsck และในการตอบคำถามของคำตอบ "ใช่" หรือ "ไม่" หรือให้การควบคุมกลับไปหาคุณตามเกณฑ์ที่กำหนดไว้
- เชื่อมต่อกับเครือข่ายอื่นและเรียกดูจดหมายของคุณโดยอัตโนมัติเพื่อให้ดูเหมือนว่าระบบเดิมของคุณถูกส่งไปยังระบบภายในของคุณ
- ดำเนินการตัวแปรสภาพแวดล้อมไดเร็กทอรีปัจจุบันหรือข้อมูลใด ๆ ใน rlogin, telnet, tip, su หรือ chgrp
มีสาเหตุหลายประการที่ เปลือก ไม่สามารถปฏิบัติงานเหล่านี้ได้ ทั้งหมดนี้เป็นไปได้ด้วย Expect
โดยทั่วไป Expect จะเป็นประโยชน์สำหรับการเรียกใช้โปรแกรมใด ๆ ที่ต้องการการโต้ตอบระหว่างโปรแกรมกับผู้ใช้ สิ่งที่จำเป็นคือปฏิสัมพันธ์สามารถระบุได้ทางโปรแกรม คาดหวังยังสามารถให้การควบคุมกลับไปยังผู้ใช้โดยไม่หยุดชะงักโปรแกรมที่ถูกควบคุม ในทำนองเดียวกันผู้ใช้สามารถกลับการควบคุมสคริปต์ได้ตลอดเวลา
การใช้
คาดว่าจะอ่าน cmdfile สำหรับรายการคำสั่งที่จะรัน คาดหวังว่าจะสามารถเรียกใช้โดยปริยายในระบบที่สนับสนุน #! สัญกรณ์โดยการทำเครื่องหมายสคริปต์เป็นไฟล์ปฏิบัติการและทำบรรทัดแรกในสคริปต์:
#! / usr / local / bin / expect -fแน่นอนเส้นทางต้องบรรยายถึงสิ่งที่คาดว่าจะมีชีวิตอยู่ / usr / local / bin เป็นเพียงตัวอย่างเท่านั้น
ธง -c จะนำคำสั่งไปใช้ก่อนที่จะใช้ในสคริปต์ คำสั่งควรถูกยกมาเพื่อป้องกันไม่ให้ถูกทำลายโดยเปลือก ตัวเลือกนี้อาจใช้หลายครั้ง คำสั่งหลายคำอาจทำงานด้วย single -c โดยการแยกด้วยเครื่องหมายอัฒภาค คำสั่งจะถูกดำเนินการตามลำดับที่ปรากฏ เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -command
ค่าสถานะ -d ช่วยให้สามารถตรวจจับการวินิจฉัยได้ซึ่งส่วนใหญ่รายงานถึงกิจกรรมภายในของคำสั่งต่างๆเช่นคาดหวังและโต้ตอบ ธงนี้มีลักษณะเช่นเดียวกับ "exp_internal 1" ที่จุดเริ่มต้นของสคริปต์ Expect พร้อมด้วยพิมพ์ Expect
ธง -D ช่วยให้ดีบักแบบโต้ตอบ ค่าจำนวนเต็มควรเป็นไปตาม ตัวดีบักจะควบคุมก่อนขั้นตอน Tcl ถัดไปถ้าค่าไม่เป็นศูนย์หรือถ้ากดปุ่ม ^ C หรือจุดหยุดทำงานหรือคำสั่งดีบักเกอร์ที่เหมาะสมอื่น ๆ จะปรากฏในสคริปต์ เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น - ดีบัก
ธง f จะนำไฟล์มาอ่านคำสั่ง ธงตัวเองเป็นตัวเลือกเนื่องจากเป็นประโยชน์เฉพาะเมื่อใช้ #! สัญกรณ์ดังนั้นอาร์กิวเมนต์อื่น ๆ อาจถูกจัดเตรียมไว้ในบรรทัดคำสั่ง เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -file
แฟ้มคำสั่งจะถูกอ่านลงใน หน่วยความจำ และดำเนินการอย่างครบถ้วน บางครั้งก็ควรอ่านไฟล์ทีละบรรทัด เพื่อที่จะบังคับให้ไฟล์ใด ๆ ได้รับการจัดการด้วยวิธีนี้ให้ใช้ค่าสถานะ -b เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -buffer
ถ้าสตริง "-" ระบุเป็นชื่อไฟล์จะมีการอ่านข้อมูลมาตรฐานแทน ใช้ "./-" เพื่ออ่านจากแฟ้มที่มีชื่อว่า "-"
สาเหตุ -i ทำให้ Expect โต้ตอบโต้ตอบสำหรับคำสั่งแทนการอ่านจากไฟล์ การแจ้งเตือนถูกยกเลิกโดยใช้คำสั่ง exit หรือเมื่อ EOF -i-flag จะสันนิษฐานถ้าไม่มีใช้ไฟล์คำสั่งหรือ -c เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -interactive
- อาจถูกใช้เพื่อกำหนดค่าตัวเลือกท้ายสุด วิธีนี้จะเป็นประโยชน์ถ้าคุณต้องการส่งอาร์กิวเมนต์ตัวเลือกให้กับสคริปต์ของคุณโดยไม่ได้ถูกแปลโดย Expect นี้จะมีประโยชน์ใน #! line เพื่อป้องกันการตีความที่ไม่เหมือนใครโดย Expect ตัวอย่างเช่นต่อไปนี้จะปล่อยอาร์กิวเมนต์เดิมรวมถึงชื่อสคริปต์ในตัวแปร argv
#! / usr / local / bin / expect -โปรดทราบว่าต้องใช้ข้อตกลง getopt (3) และ execve (2) ตามปกติเมื่อเพิ่มอาร์กิวเมนต์ลงใน #! เส้น
ไฟล์ $ exp_library / expect.rc มีอยู่โดยอัตโนมัติหากมีอยู่เว้นแต่จะมีการใช้ค่าสถานะ -N (เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น -NORC) ทันทีหลังจากนี้ไฟล์ ~ / .expect.rc จะได้รับการประมวลผลโดยอัตโนมัติเว้นแต่จะมีการใช้งาน -n flag ไว้ ถ้ามีการกำหนดตัวแปร DOTDIR สภาพแวดล้อมตัวแปรจะถือว่าเป็นไดเร็กทอรีและอ่าน. expect.rc จากที่นั่น เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น -norc การจัดหานี้เกิดขึ้นเฉพาะหลังจากดำเนินการแฟล็กใด ๆ -c
สาเหตุที่คาดว่าจะพิมพ์หมายเลขเวอร์ชันและออก ธงที่เกี่ยวข้องใน Expectk ซึ่งใช้ชื่อธงแบบยาวคือ --version
อาร์กิวเมนต์ตัวเลือกถูกสร้างขึ้นในรายการและเก็บไว้ในตัวแปรชื่อ argv และ argc ถูกเตรียมใช้งานตามความยาวของ argv
Argv0 ถูกกำหนดให้เป็นชื่อของสคริปต์หรือไบนารีหากไม่มีสคริปต์ถูกใช้ ตัวอย่างเช่นต่อไปนี้จะพิมพ์ชื่อของสคริปต์และอาร์กิวเมนต์สามตัวแรก:
send_user "$ argv0 [lrange $ argv 0 2] \ n"คำสั่ง
Expect ใช้ Tool Command Language Tcl ให้การควบคุมการไหล (ถ้า, สำหรับ, ทำลาย), การประเมินผลการแสดงออกและคุณสมบัติอื่น ๆ เช่น recursionand ขั้นตอนคำจำกัดความ คำสั่งที่ใช้ที่นี่ แต่ไม่ได้กำหนดไว้ (set, if, exec) เป็นคำสั่ง Tcl Expect รองรับคำสั่งเพิ่มเติม ถ้าไม่ได้ระบุไว้เป็นอย่างอื่นคำสั่งจะส่งคืนสตริงที่ว่างเปล่า
คำสั่งจะเรียงลำดับตามตัวอักษรเพื่อให้สามารถตั้งได้อย่างรวดเร็ว อย่างไรก็ตามผู้ใช้รายใหม่อาจเริ่มต้นได้ง่ายขึ้นโดยอ่านคำอธิบายเกี่ยวกับการวางไข่ส่งคาดหวังและโต้ตอบในลำดับดังกล่าว
ปิด [-slave] [-onexec 0 | 1] [-i spawn_id]ปิดการเชื่อมต่อกับ กระบวนการ ปัจจุบัน โปรแกรมโต้ตอบส่วนใหญ่จะตรวจจับ EOF บน stdin และ exit; ดังนั้น ใกล้ มักพอเพียงที่จะฆ่า กระบวนการ เช่นกัน ธง -i ประกาศ กระบวนการที่ จะปิดสอดคล้องกับชื่อ spawn_id
ทั้งสองคาดหวังและโต้ตอบจะตรวจพบเมื่อ กระบวนการ ปัจจุบันออกและปิดบังโดยปริยาย แต่ถ้าคุณฆ่า กระบวนการ โดยกล่าวว่า "exec ฆ่า $ pid" คุณต้องติดต่ออย่างใกล้ชิด
ธง -onexec กำหนดว่าจะวางรหัสวางไข่ไว้ในกระบวนการที่ เกิด ใหม่หรือเมื่อ กระบวนการ นี้ซ้อนทับ หากต้องการปล่อยรหัสวางไข่ให้เปิดใช้ค่า 0. ค่าจำนวนเต็มที่ไม่ใช่ศูนย์บังคับให้วางไข่ปิดลงในกระบวนการใหม่ ๆ
ธงสไลลาจะปิดทาสที่เชื่อมโยงกับรหัสวางไข่ เมื่อปิดการเชื่อมต่อทาสจะปิดโดยอัตโนมัติหากยังเปิดอยู่
ไม่ว่าการเชื่อมต่อจะปิดโดยปริยายหรืออย่างชัดเจนคุณควรเรียกใช้เพื่อรอให้ชัดเจนขึ้นช่อง กระบวนการ เคอร์เนลที่สอดคล้องกัน คำสั่ง close ไม่เรียกรอเนื่องจากไม่มีการรับประกันว่าการปิดการเชื่อมต่อ กระบวนการ จะทำให้ออกไป
debug [[now] 0 | 1]ควบคุมดีบัก Tcl ช่วยให้คุณสามารถก้าวผ่านงบและตั้งค่าจุดสั่งหยุด
ไม่มีอาร์กิวเมนต์ 1 จะถูกส่งกลับถ้าดีบักเกอร์ไม่ทำงานมิฉะนั้น 0 จะถูกส่งกลับ
ด้วยอาร์กิวเมนต์ที่ 1 เริ่มต้นดีบักเกอร์ ด้วยอาร์กิวเมนต์ 0 ดีบั๊กจะหยุดลง ถ้าอาร์กิวเมนต์ 1 ถูกนำหน้าด้วยแฟล็ก now, debugger จะเริ่มทำงานทันที มิฉะนั้นดีบักเกอร์จะเริ่มต้นด้วยคำสั่ง Tcl ถัดไป
คำสั่งแก้ปัญหาจะไม่เปลี่ยนกับดักใด ๆ เปรียบเทียบนี้เพื่อเริ่มต้นคาดหวังกับธง -D
คำสั่ง disconnect disconnects กระบวนการ forked จาก terminal . มันยังคงทำงานอยู่เบื้องหลัง กระบวนการนี้จะมีกลุ่มกระบวนการของตัวเอง มาตรฐาน I / O ถูกเปลี่ยนเส้นทางไปที่ / dev / null
ส่วนต่อไปนี้ใช้ยกเลิกการเชื่อมต่อเพื่อเรียกใช้สคริปต์ต่อในพื้นหลัง
ถ้า {[fork]! = 0} ออกจากการเชื่อมต่อ . .สคริปต์ต่อไปนี้อ่านรหัสผ่านและเรียกใช้โปรแกรมทุกๆชั่วโมงที่ต้องการรหัสผ่านในแต่ละครั้งที่มีการเรียกใช้ สคริปต์มีรหัสผ่านเพื่อให้คุณต้องพิมพ์เพียงครั้งเดียวเท่านั้น
send_user "password? \" expect_user -re "(. *) \ n" สำหรับ {} 1 {} {if {[fork]! = 0} {sleep 3600; continue} ยกเลิกการวางไข่ priv_prog expect รหัสผ่าน: ส่ง "$ expect_out ( 1 สตริง) \ r " . . ออก}ข้อดีของการยกเลิกการเชื่อมต่อกับคุณลักษณะของอะซิงโครนัสของเชลล์ (&) คือ Expect สามารถบันทึกพารามิเตอร์เทอร์มินัลก่อนตัดการเชื่อมต่อและนำไปใช้กับ ptys ใหม่ได้ ด้วย &, Expect ไม่มีโอกาสอ่านค่าพารามิเตอร์ของเทอร์มินัลเนื่องจากเทอร์มินอลถูกยกเลิกการเชื่อมต่อตามเวลาที่คาดว่าจะได้รับการควบคุม
ออก [-opts] [สถานะ]สาเหตุคาดว่าจะออกหรือเตรียมทำเช่นนั้น
ธง singlexit ทำให้อาร์กิวเมนต์ถัดไปถูกใช้เป็นตัวจัดการการออก ไม่มีอาร์กิวเมนต์ตัวจัดการทางออกปัจจุบันจะถูกส่งกลับ
ธง -noexit ทำให้เกิด Expect เพื่อเตรียมพร้อมในการออกจากระบบ แต่หยุดการใช้งานจริงในการส่งคืนการควบคุมไปยังระบบปฏิบัติการ ตัวจัดการการดำเนินการออกจากผู้ใช้ที่กำหนดไว้จะทำงานเหมือนกับตัวจัดการภายในของ Expect เอง ไม่ควรดำเนินการคำสั่ง Expect เพิ่มเติม นี้จะเป็นประโยชน์ถ้าคุณกำลังเรียกใช้คาดว่าจะมีส่วนขยาย Tcl อื่น ๆ ล่ามปัจจุบัน (และหน้าต่างหลักถ้าอยู่ในสภาพแวดล้อม Tk) ยังคงอยู่เพื่อให้ส่วนขยาย Tcl อื่นสามารถล้างข้อมูลได้ ถ้า Expect's exit ถูกเรียกอีกครั้ง (แต่อาจเกิดขึ้นได้) ตัวจัดการจะไม่เริ่มต้นใหม่
เมื่อออกจากการเชื่อมต่อกับกระบวนการสืบพันธุ์จะถูกปิด การปิดจะถูกตรวจพบเป็น EOF โดยกระบวนการที่เกิดขึ้น exit ใช้เวลาดำเนินการอื่นนอกเหนือจากที่ปกติ _exit (2) ทำ ดังนั้นกระบอกไม้ไผ่กระบวนการที่ไม่ได้ตรวจสอบสำหรับ EOF อาจทำงานต่อไป (เงื่อนไขต่าง ๆ มีความสำคัญต่อการพิจารณาตัวอย่างเช่นสิ่งที่ส่งสัญญาณว่ากระบวนการที่เกิดขึ้นจะถูกส่งไปหรือไม่ แต่ระบบเหล่านี้ขึ้นอยู่กับระบบโดยทั่วไปจะมีการบันทึกไว้ภายใต้ exit (3)) กระบวนการที่เรียกว่า spawned จะถูกสืบทอดมาโดย init
สถานะ (หรือ 0 ถ้าไม่ได้ระบุ) จะถูกส่งกลับเป็นสถานะการออกจาก Expect exit จะทำงานโดยปริยายถ้าสิ้นสุดสคริปต์
exp_continue [-continue_timer]
คำสั่ง exp_continue ช่วยให้ คาดว่า ตัวเองจะดำเนินการต่อไปแทนที่จะกลับมาตามปกติ ตามค่าเริ่มต้น exp_continue จะ รีเซ็ตตัวจับเวลาหมดเวลา ค่าสถานะ -continue_timer ช่วยป้องกันไม่ให้รีสตาร์ทเครื่องจับเวลา (โปรดดูข้อมูลเพิ่มเติมที่ต้องการ)
ค่า exp_internal [-ffile]
ทำให้เกิดคำสั่งเพิ่มเติมเพื่อส่งข้อมูลการวินิจฉัยภายในเพื่อ คาดหวัง ให้ stderr ถ้า ค่า ไม่ใช่ศูนย์ เอาต์พุตนี้ถูกปิดใช้งานถ้า ค่า เป็น 0 ข้อมูลการวินิจฉัยจะรวมถึงอักขระทุกตัวที่ได้รับและความพยายามทุกอย่างที่ทำเพื่อให้ตรงกับผลลัพธ์ปัจจุบันกับรูปแบบ
ถ้ามีการจัดเตรียม แฟ้มข้อมูล เพิ่มเติมเอาต์พุตปกติและดีบักทั้งหมดจะถูกเขียนลงในไฟล์นั้น (ไม่คำนึงถึงมูลค่าของ ค่า ) แฟ้มผลลัพธ์การวินิจฉัยก่อนหน้านี้ถูกปิด
ธงข้อมูลอธิบายสาเหตุ exp_internal เพื่อส่งคำอธิบายของอาร์กิวเมนต์ที่ไม่ใช่ข้อมูลล่าสุดที่ระบุ
exp_open [args] [-i spawn_id]
ส่งกลับตัวระบุไฟล์ Tcl ที่ตรงกับรหัสวางไข่เดิม ตัวระบุไฟล์สามารถใช้งานได้เหมือนกับว่าได้เปิดขึ้นโดยคำสั่ง เปิด ของ Tcl (ไม่ควรใช้รหัสวางไข่อีกต่อไป รอ ไม่ควร รอ
ธง -Laaveopen จะวางรหัสวางไข่ไว้เพื่อเข้าใช้งานผ่านคำสั่ง Expect ต้อง รอการรอคอย ในรหัสวางไข่
exp_pid [-i spawn_id]
ส่งกลับรหัสกระบวนการที่สอดคล้องกับกระบวนการที่เกิดขึ้นในปัจจุบัน ถ้ามีการใช้ -i- band pid ที่ ส่งกลับจะตรงกับ ID ของ spawn ที่กำหนด
exp_send
เป็นนามแฝงสำหรับการ ส่ง
exp_send_error
เป็นชื่อแทนสำหรับ send_error
exp_send_log
เป็นชื่อแทนสำหรับ send_log
exp_send_tty
เป็นชื่อแทนสำหรับ send_tty
exp_send_user
เป็นนามแฝงสำหรับ send_user
exp_version [[-exit] version]
เป็นประโยชน์สำหรับการมั่นใจว่าสคริปต์สามารถทำงานร่วมกับเวอร์ชันปัจจุบันของ Expect ได้
ไม่มีข้อโต้แย้ง จะ มีการส่งคืนเวอร์ชันปัจจุบันของ Expect เวอร์ชันนี้อาจถูกเข้ารหัสในสคริปต์ของคุณ ถ้าคุณรู้จริงว่าคุณไม่ได้ใช้คุณลักษณะของเวอร์ชันล่าสุดคุณสามารถระบุเวอร์ชันก่อนหน้าได้
รุ่นประกอบด้วยสามตัวเลขที่คั่นด้วยจุด อันดับแรกคือจำนวนที่สำคัญ สคริปต์ที่เขียนขึ้นสำหรับรุ่นของ Expect ด้วยหมายเลขหลักที่แตกต่างกันเกือบจะไม่ทำงาน exp_version แสดงข้อผิดพลาดหากตัวเลขหลักไม่ตรงกัน
ประการที่สองคือตัวเลขรอง สคริปต์ที่เขียนขึ้นสำหรับเวอร์ชันที่มีจำนวนน้อยกว่าเวอร์ชันปัจจุบันอาจขึ้นอยู่กับคุณลักษณะใหม่ ๆ และอาจไม่ทำงาน exp_version จะส่งคืนข้อผิดพลาดหากตัวเลขหลักตรงกัน แต่จำนวนสคริปต์น้อยกว่ามากกว่าที่ คาดการณ์ ไว้
ประการที่สามคือจำนวนที่ไม่มีส่วนใดในการเปรียบเทียบเวอร์ชัน อย่างไรก็ตามจะเพิ่มขึ้นเมื่อการกระจายซอฟต์แวร์ Expect มีการเปลี่ยนแปลงในลักษณะใด ๆ เช่นโดยเอกสารเพิ่มเติมหรือการเพิ่มประสิทธิภาพ จะมีการรีเซ็ตเป็น 0 สำหรับแต่ละรุ่นใหม่
Expect พิมพ์ข้อผิดพลาดและออกถ้าเวอร์ชันล้าสมัย
คาดว่า [[-opts] pat1 body1] ... [-opts] patn [bodyn]
รอจนกว่ารูปแบบใดรูปแบบหนึ่งจะตรงกับผลลัพธ์ของกระบวนการที่พลิกกลับช่วงเวลาที่ระบุได้ผ่านไปแล้วหรือเห็นไฟล์สิ้นสุดลง ถ้าร่างกายสุดท้ายว่างเปล่าอาจถูกละไว้
รูปแบบจาก คำ สั่ง expect_before ล่าสุดจะถูกใช้โดยปริยายก่อนรูปแบบอื่น ๆ รูปแบบจาก คำ สั่ง expect_after ล่าสุดจะถูกใช้โดยปริยายหลังจากรูปแบบอื่น ๆ
หากอาร์กิวเมนต์กับคำ คาดหวัง ทั้งหมดต้องมีมากกว่าหนึ่งบรรทัดอาร์กิวเมนต์ทั้งหมดอาจถูก "ยึด" ไว้ในแถวเดียวเพื่อหลีกเลี่ยงการยกเลิกแต่ละบรรทัดโดยใช้เครื่องหมายแบ็กสแลช ในกรณีนี้การแทนที่ Tcl ตามปกติจะเกิดขึ้นแม้จะมีวงเล็บปีกกา
หากรูปแบบเป็น eof คำหลักร่างกายที่สอดคล้องกันจะถูกเรียกใช้งานเมื่อสิ้นสุดไฟล์ ถ้ารูปแบบเป็น timeout ของ คำหลักตัวที่เกี่ยวข้องจะถูกเรียกใช้เมื่อหมดเวลา หากไม่มีการใช้คำหลัก timeout คำว่า null action จะดำเนินการเมื่อหมดเวลา ระยะหมดเวลาเริ่มต้นคือ 10 วินาที แต่อาจตั้งค่าได้เช่น 30 โดยใช้คำสั่ง "set outout 30" การหมดเวลา infinite สามารถกำหนดโดยค่า -1 หากรูปแบบเป็น ค่าดีฟอลต์ของ คำหลักตัวที่เกี่ยวข้องจะถูกเรียกใช้เมื่อหมดเวลาหรือสิ้นสุดของไฟล์
ถ้ารูปแบบตรงกับตัวทำนองเดียวกัน คาดว่า จะส่งกลับผลของร่างกาย (หรือสตริงที่ว่างเปล่าถ้าไม่มีรูปแบบที่ตรงกัน) ในกรณีที่มีรูปแบบหลายรูปแบบที่ตรงกันรูปแบบที่ปรากฏขึ้นก่อนจะใช้เพื่อเลือกเนื้อหา
ทุกครั้งที่มีการส่งออกใหม่จะได้รับการเปรียบเทียบกับแต่ละรูปแบบตามลำดับที่ระบุไว้ ดังนั้นคุณอาจทดสอบเพื่อไม่ให้มีการจับคู่โดยการทำให้รูปแบบบางอย่างที่ผ่านมามีการรับประกันว่าจะปรากฏเช่นข้อความแจ้ง ในสถานการณ์ที่ไม่มีพรอมต์คุณต้องใช้การ หมดเวลา (เช่นเดียวกับที่คุณทำถ้าคุณโต้ตอบด้วยตนเอง)
รูปแบบถูกระบุด้วยสามวิธี โดยค่าเริ่มต้นรูปแบบจะถูกระบุเช่นเดียวกับคำสั่งการ จับคู่สตริง ของ Tcl (รูปแบบดังกล่าวยังคล้ายกับการแสดงผลปกติของ C-shell ซึ่ง มักเรียกว่า "glob") ธง -gl อาจถูกนำมาใช้เพื่อปกป้องรูปแบบที่อาจเป็นไปตามที่ คาดหวัง ไว้ รูปแบบที่ขึ้นต้นด้วย "-" ควรได้รับการป้องกันด้วยวิธีนี้ (สตริงทั้งหมดที่ขึ้นต้นด้วย "-" สงวนไว้สำหรับตัวเลือกในอนาคต)
ตัวอย่างเช่นส่วนต่อไปนี้จะมองหาการเข้าสู่ระบบที่ประสบความสำเร็จ (โปรดทราบว่าการ ทำแท้ง ถือว่าเป็นขั้นตอนที่กำหนดไว้ในที่อื่น ๆ ในสคริปต์)
คาดหวัง {busy {ทำให้ยุ่ง \ n; exp_continue} ล้มเหลวยกเลิก "รหัสผ่านที่ไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}คำพูดเป็นสิ่งจำเป็นในรูปแบบที่สี่เนื่องจากมีช่องว่างซึ่งจะแยกรูปแบบออกจากการทำงาน รูปแบบที่มีการดำเนินการเดียวกัน (เช่น 3 และ 4) จำเป็นต้องมีการแสดงการดำเนินการอีกครั้ง ซึ่งสามารถหลีกเลี่ยงได้โดยใช้รูปแบบ regexp (ดูด้านล่าง) ข้อมูลเพิ่มเติมเกี่ยวกับรูปแบบของรูปแบบโลกสามารถดูได้จากคู่มือ Tcl
รูปแบบ Regexp เป็นไปตามไวยากรณ์ที่กำหนดโดย regexp ของ Tcl (ย่อมาจาก "นิพจน์ทั่วไป") รูปแบบ regexp นำมาใช้กับค่าสถานะ -re ตัวอย่างก่อนหน้านี้สามารถเขียนใหม่โดยใช้ regexp เป็น:
คาดหวัง {busy {ทำให้ยุ่ง \ n; exp_continue} -re "ล้มเหลว | รหัสผ่านไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}ทั้งสองรูปแบบคือ "unanchored" ซึ่งหมายความว่ารูปแบบไม่ต้องตรงกับสตริงทั้งหมด แต่สามารถเริ่มต้นและสิ้นสุดการจับคู่ได้ทุกที่ในสตริง (ตราบเท่าที่ทุกอย่างตรงกับ) ใช้ ^ เพื่อจับคู่จุดเริ่มต้นของสตริงและ $ เพื่อให้ตรงกับจุดสิ้นสุด โปรดทราบว่าถ้าคุณไม่รอให้สตริงจบการตอบสนองของคุณจะจบลงตรงกลางของสตริงเพราะจะมีการสะท้อนออกมาจากกระบวนการที่เกิดขึ้น ในขณะที่ยังให้ผลลัพธ์ที่ถูกต้องเอาต์พุตอาจดูผิดปกติ ดังนั้นการใช้ $ เป็นกำลังใจถ้าคุณสามารถอธิบายตัวอักษรที่ท้ายสตริงได้
โปรดทราบว่าในบรรณาธิการจำนวนมาก ^ และ $ ตรงกับจุดเริ่มต้นและจุดสิ้นสุดของบรรทัดตามลำดับ อย่างไรก็ตามเนื่องจากคาดว่าจะไม่ได้เป็นเส้นตรงอักขระเหล่านี้จะตรงกับจุดเริ่มต้นและจุดสิ้นสุดของข้อมูล (ในทางตรงข้ามกับเส้น) ปัจจุบันอยู่ในบัฟเฟอร์การจับคู่คาดหวัง (โปรดดูหมายเหตุด้านล่างเกี่ยวกับ "การไม่ย่อยของระบบ")
ธง -ex ทำให้รูปแบบที่จะจับคู่เป็นสตริง "แน่นอน" ทำไม่ได้การตีความของ *, ^, ฯลฯ (แม้ว่าจะต้องมีการปฏิบัติตามอนุสัญญา Tcl ตามปกติ) รูปแบบที่แน่นอนไม่มีการเปลี่ยนแปลง
ธง -nocase ทำให้เกิดอักขระตัวพิมพ์ใหญ่ของเอาต์พุตเพื่อเปรียบเทียบเหมือนกับว่าเป็นตัวพิมพ์เล็ก รูปแบบไม่ได้รับผลกระทบ
ในขณะที่อ่านผลลัพธ์มากกว่า 2,000 ไบต์ สามารถบังคับไบต์ก่อนหน้าให้ "ลืม" ได้ ซึ่งอาจมีการเปลี่ยนแปลงโดยใช้ฟังก์ชัน match_max (โปรดทราบว่าค่าที่มากเกินไปอาจทำให้ตัวจัดรูปแบบช้าลงได้) หาก patlist เป็น full_buffer ร่างกายที่ตรงกันจะถูกเรียกใช้ถ้าได้รับไบต์ match_max และไม่มีรูปแบบอื่นที่ตรงกับ ไม่ว่าจะใช้คำหลัก full_buffer หรือไม่ก็ตามอักขระที่ลืมจะถูกเขียนลงใน expect_out (buffer)
ถ้า patlist เป็น null คำหลักและ nulls จะได้รับอนุญาต (ผ่านทางคำสั่ง remove_nulls ) ตัวที่เกี่ยวข้องจะถูกเรียกใช้ถ้า ASCII 0 ตัวเดียวถูกจับคู่ ไม่สามารถจับคู่ 0 ไบต์ผ่านรูปแบบ glob หรือ regexp
เมื่อจับคู่รูปแบบ (หรือ eof หรือ full_buffer) ผลลัพธ์ที่ตรงกันและไม่ตรงกันก่อนหน้านี้จะถูกบันทึกไว้ในตัวแปร expect_out (buffer) สามารถจับคู่สตริงย่อยของ regexp ได้สูงสุด 9 สตริงในตัวแปร expect_out (1 สตริง) ผ่าน expect_out (9 สตริง) ถ้าธง -indices ถูกใช้ก่อนรูปแบบดัชนีเริ่มต้นและสิ้นสุด (ในรูปแบบที่เหมาะสมสำหรับ lrange ) ของ 10 สายจะถูกเก็บไว้ในตัวแปร expect_out (X, start) และ expect_out (X, end) โดยที่ X เป็น a ตัวเลขตรงกับตำแหน่งสตริงในบัฟเฟอร์ 0 หมายถึงสตริงที่ตรงกับรูปแบบทั้งหมดและถูกสร้างขึ้นสำหรับรูปแบบของโลกรวมถึงรูปแบบ regexp ตัวอย่างเช่นถ้ากระบวนการผลิตผลลัพธ์ของ "abcdefgh \ n" ผลลัพธ์ของ:
คาดว่า "cd"เป็นถ้างบต่อไปนี้ได้ดำเนินการ:
ตั้งค่า expect_out (0, string) cd set expect_out (buffer) abcdและ "efgh \ n" จะถูกทิ้งไว้ในบัฟเฟอร์เอาท์พุท ถ้ากระบวนการผลิตผลลัพธ์ "abbbcabkkkka \ n" ผลของ:
คาดว่า -indices -re "b (b *). * (k +)"เป็นถ้างบต่อไปนี้ได้ดำเนินการ:
ตั้ง expect_out (0, start) 1 set expect_out (0, end) 10 set expect_out (0, string) ตั้งค่า expect_out (1, start) 2 set expect_out (1, end) 3 ชุด expect_out (1 สตริง) bb ตั้ง expect_out (2, เริ่มต้น) 10 ชุด expect_out (2, end) 10 ชุด expect_out (2, สตริง) k set expect_out (buffer) abbbcabkkkkและ "a \ n" ถูกทิ้งไว้ในบัฟเฟอร์เอาท์พุท รูปแบบ "*" (และ -re ". *") จะล้างบัฟเฟอร์เอาต์พุตโดยไม่ต้องอ่านผลลัพธ์เพิ่มเติมจากกระบวนการ
โดยปกติผลลัพธ์ที่ตรงกันจะถูกทิ้งออกจากบัฟเฟอร์ภายในของ Expect ซึ่งอาจป้องกันได้โดยนำหน้ารูปแบบที่มีธง -nTransferfer ธงนี้เป็นประโยชน์อย่างยิ่งในการทดลอง (และสามารถอธิบายได้โดยย่อว่า "ไม่" เพื่อความสะดวกในขณะที่ทำการทดลอง)
รหัสวางไข่ที่เกี่ยวข้องกับผลลัพธ์การจับคู่ (หรือ eof หรือ full_buffer) จะถูกเก็บไว้ใน expect_out (spawn_id)
ค่าสถานะ timeout จะทำให้คำสั่ง current expect ใช้ค่าต่อไปนี้เป็น timeout แทนการใช้ค่าของตัวแปร timeout
โดยค่าเริ่มต้นรูปแบบจะถูกจับคู่กับเอาท์พุทจากกระบวนการปัจจุบันอย่างไรก็ตาม -i- flag จะประกาศว่าเอาท์พุทจากรายการ spawn_id ที่ระบุจะถูกจับคู่กับรูปแบบใด ๆ ต่อไปนี้ (ขึ้นอยู่กับ -i ถัดไป) รายการ spawn_id ควรเป็นรายการ spawn_ids ที่แยกกันเป็นช่องว่างหรือตัวแปรที่อ้างถึงรายการ spawn_ids
ตัวอย่างเช่นตัวอย่างต่อไปนี้รอให้ "เชื่อมต่อ" จากกระบวนการปัจจุบันหรือ "ไม่ว่าง", "ล้มเหลว" หรือ "รหัสผ่านไม่ถูกต้อง" จาก spawn_id โดยชื่อ $ proc2
คาดหวังว่า {-i $ proc2 busy {ทำให้ยุ่ง \ n; exp_continue} -re "ล้มเหลว | รหัสผ่านไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}ค่าของตัวแปร global any_spawn_id อาจถูกใช้เพื่อจับคู่รูปแบบกับ spawn_ids ใด ๆ ที่มีชื่อพร้อม flagi -i ทั้งหมดในคำสั่ง expect ปัจจุบัน spawn_id จาก -i- flag ที่ไม่มีรูปแบบที่เกี่ยวข้อง (เช่นตามด้วยอีก -i ) จะใช้กับรูปแบบอื่น ๆ ในคำสั่ง expect เดียวกันกับ any_spawn_id
ธง -i อาจตั้งชื่อว่าตัวแปรส่วนกลางซึ่งในกรณีนี้จะมีการอ่านตัวแปรสำหรับรายการไอดีวางไข่ ตัวแปรจะอ่านซ้ำทุกครั้งที่มีการเปลี่ยนแปลง นี่เป็นวิธีการเปลี่ยนแหล่ง I / O ในขณะที่คำสั่งกำลังทำงานอยู่ รหัสวางไข่ที่ให้มาด้วยวิธีนี้เรียกว่า id โดยกำเนิด "ทางอ้อม"
การดำเนินการเช่น break และ ดำเนินการต่อ โครงสร้างการควบคุมสาเหตุ (เช่น for , proc ) ให้ทำงานในลักษณะปกติ คำสั่ง exp_continue ช่วยให้ คาดว่า ตัวเองจะดำเนินการต่อไปแทนที่จะกลับมาตามปกติ
วิธีนี้มีประโยชน์ในการหลีกเลี่ยงความซ้ำซ้อนหรือข้อความคาดหวังซ้ำ ๆ ตัวอย่างต่อไปนี้เป็นส่วนหนึ่งของส่วนที่จะทำให้ rlogin ทำงานโดยอัตโนมัติ exp_continue หลีกเลี่ยงการเขียนคำที่ คาดหวัง ที่สอง (เพื่อค้นหาพรอมต์อีกครั้ง) ถ้า rlogin พร้อมท์ให้ใส่รหัสผ่าน
คาดว่า {รหัสผ่าน: {stty -echo send_user "รหัสผ่าน (สำหรับ $ user) บน host $:" expect_user -re "(. *) \ n" send_user "\ n" ส่ง "$ expect_out (1, string) \" stty echo exp_continue} ไม่ถูกต้อง {send_user "รหัสผ่านหรือบัญชีที่ไม่ถูกต้อง \ n" exit} timeout {send_user "การเชื่อมต่อกับโฮสต์ $ หมดเวลา \ n" exit} eof {send_user \ "การเชื่อมต่อไปยังโฮสต์ล้มเหลว: $ expect_out (buffer)" exit} $ prompt}ตัวอย่างเช่นส่วนต่อไปนี้อาจช่วยให้คู่มือผู้ใช้มีปฏิสัมพันธ์ที่มีอยู่แล้วโดยอัตโนมัติทั้งหมด ในกรณีนี้เทอร์มินัลจะเข้าสู่โหมดดิบ ถ้าผู้ใช้กด "+" ตัวแปรจะเพิ่มขึ้น ถ้ากดปุ่ม "p" ผลตอบแทนหลายรายการจะถูกส่งไปยังกระบวนการนี้อาจจะเป็นการกระตุ้นให้เกิดผลบางอย่างและ "i" ช่วยให้ผู้ใช้โต้ตอบกับกระบวนการนี้ได้อย่างมีประสิทธิภาพและขโมยตัวควบคุมออกจากสคริปต์ได้อย่างมีประสิทธิภาพ ในแต่ละกรณี exp_continue ช่วยให้ปัจจุบัน คาดว่า จะสามารถจับคู่รูปแบบต่อไปได้หลังจากดำเนินการในปัจจุบัน
stty raw -echo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "ออกจาก" ออก}ตามค่าเริ่มต้น exp_continue จะ รีเซ็ตตัวจับเวลาหมดเวลา ตัวจับเวลาจะไม่ถูกรีสตาร์ทถ้า exp_continue ถูกเรียกว่ามีค่า -continue_timer flag
expect_after [expect_args]
ทำงานเหมือนกันกับ expect_before ยกเว้นว่าถ้ารูปแบบจากทั้ง คาดหวัง และ expect_after สามารถจับคู่รูปแบบ คาดหวังที่ จะใช้ ดู คำ สั่ง expect_before สำหรับข้อมูลเพิ่มเติม
expect_background [expect_args]
ใช้อาร์กิวเมนต์เดียวกันกับที่ คาดไว้ แต่จะส่งกลับทันที รูปแบบจะได้รับการทดสอบเมื่อมีการป้อนข้อมูลใหม่ การ หมดเวลาของ รูปแบบและ ค่าเริ่มต้น ไม่มีความหมายกับ expect_background และถูกทิ้งไว้อย่างเงียบ ๆ มิฉะนั้น คำ สั่ง expect_background จะใช้รูปแบบ expect_before และ expect_after เหมือนกับที่ คาดหมาย ไว้
เมื่อการดำเนินการ expect_background กำลังได้รับการประเมินการประมวลผลเบื้องหลังสำหรับรหัสวางไข่เดียวกันจะถูกบล็อก การประมวลผลเบื้องหลังจะยกเลิกการปิดกั้นเมื่อการดำเนินการเสร็จสิ้น แม้ว่าการประมวลผลเบื้องหลังจะถูกบล็อค แต่ก็เป็นไปได้ที่จะทำ (เบื้องหน้า) ในรหัสวางไข่เดียวกัน
ไม่สามารถ คาดการณ์ได้ ในขณะที่ คาดว่า จะยกเลิกการบล็อก expect_background expect_background สำหรับรหัสวางไข่โดยเฉพาะจะถูกลบออกโดยการประกาศใหม่ expect_background ที่มีรหัสวางไข่เดียวกัน การประกาศ expect_background โดยไม่มีรูปแบบจะลบรหัสวางไข่ที่ระบุออกจากความสามารถในการจับคู่รูปแบบในพื้นหลัง
expect_before [expect_args]
ใช้อาร์กิวเมนต์เดียวกันกับที่ คาดไว้ แต่จะส่งกลับทันที รูปแบบการกระทำคู่จาก expect_before ล่าสุดที่มีรหัสวางไข่เดียวกันจะถูกเพิ่มอย่างไม่ คาดคิด ต่อไปนี้ คาดหวัง คำสั่ง ถ้ารูปแบบตรงกับมันจะถือว่าเป็นได้รับการระบุไว้ในคำสั่ง คาดหวัง ตัวเองและร่างกายที่เกี่ยวข้องจะถูกดำเนินการในบริบทของคำสั่ง คาดหวัง ถ้ารูปแบบจากทั้ง expect_before และ คาดว่า จะสามารถจับคู่ได้รูปแบบ expect_before จะถูกใช้
หากไม่มีการระบุรูปแบบรหัสการวางไข่จะไม่ได้รับการตรวจสอบสำหรับรูปแบบใด ๆ
เว้นเสียแต่ว่าจะถูกแทนที่ด้วยธง -i , รูปแบบ expect_before จะ ตรงกับรหัสวางไข่ที่กำหนดไว้ในขณะดำเนินการ คำ สั่ง expect_before (ไม่ใช่เมื่อมีการจับคู่รูปแบบ)
ธงข้อมูลระบุว่า expect_before จะคืนค่าข้อกำหนดปัจจุบันของรูปแบบที่จะจับคู่ โดยค่าเริ่มต้นจะรายงาน ID การวางไข่ปัจจุบัน อาจระบุข้อมูลรหัส id วางไข่สำหรับข้อมูลเกี่ยวกับ ID การวางไข่ ตัวอย่างเช่น
expect_before -info -i $ procอาจได้รับข้อกำหนดเกี่ยวกับการวางไข่มากที่สุด ธง - ตรงที่จะยับยั้งรหัสวางไข่โดยตรงที่มาจากข้อกำหนดทางอ้อมเท่านั้น
แทนที่จะเป็นข้อกำหนดเกี่ยวกับรหัสวางไข่เครื่องหมาย "-all" จะทำให้ "ข้อมูล" รายงานเกี่ยวกับรหัสการวางไข่ทั้งหมด
เอาท์พุทของอินฟอร์แฟกค์สามารถนำกลับมาใช้ซ้ำได้เนื่องจากอาร์กิวเมนต์ที่คาดว่าจะได้รับก่อน
expect_tty [expect_args]
เป็นเหมือน คาดหวัง แต่จะอ่านอักขระจาก / dev / tty (เช่นการกดแป้นพิมพ์จากผู้ใช้) การอ่านจะดำเนินการในโหมดปรุงอาหาร ดังนั้นเส้นต้องจบลงด้วยการกลับมาเพื่อที่จะได้เห็น นี้อาจมีการเปลี่ยนแปลงผ่าน stty (ดูคำสั่ง stty ด้านล่าง)
expect_user [expect_args]
เป็นเหมือน คาดหวัง แต่จะอ่านอักขระจาก stdin (เช่นการกดแป้นพิมพ์จากผู้ใช้) การอ่านจะดำเนินการในโหมดปรุงอาหาร ดังนั้นเส้นต้องจบลงด้วยการกลับมาเพื่อที่จะได้เห็น นี้อาจมีการเปลี่ยนแปลงผ่าน stty (ดูคำสั่ง stty ด้านล่าง)
ส้อม
สร้าง กระบวนการ ใหม่ กระบวนการ ใหม่นี้เป็นสำเนาของ กระบวนการ Expect ปัจจุบัน เมื่อประสบความสำเร็จ ส้อม ส่งกลับ 0 ไปยังกระบวนการใหม่ (child) และส่งคืนรหัส กระบวนการ ของ กระบวนการย่อย ไปยัง กระบวนการ หลัก เกี่ยวกับความล้มเหลว (อย่างสม่ำเสมอเนื่องจากการขาดทรัพยากรเช่นพื้นที่ swap หน่วยความจำ) ส้อม ส่งกลับ -1 ไปยัง กระบวนการ หลักและไม่มี กระบวนการ เด็กถูกสร้างขึ้น
กระบวนการ Forked ออก จาก คำสั่ง exit เช่นเดียวกับ กระบวนการ เดิม กระบวนการ Forked ได้รับอนุญาตให้เขียนลงในแฟ้มบันทึก ถ้าคุณไม่ปิดใช้งานการดีบักหรือเข้าสู่กระบวนการส่วนใหญ่ผลลัพธ์อาจทำให้เกิดความสับสน
การใช้งาน PPS บางอย่างอาจสร้างความสับสนโดยผู้อ่านและนักเขียนหลายคนแม้แต่ในเวลาอันใกล้ ดังนั้นจึงเป็นเรื่องที่ปลอดภัยที่สุดในการ แยก ไข่ก่อนที่จะมีกระบวนการวางไข่
โต้ตอบ [string1 body1] ... [stringn [bodyn]]
ให้การควบคุม กระบวนการ ปัจจุบันให้กับผู้ใช้เพื่อให้การกดแป้นพิมพ์ถูกส่งไปยัง กระบวนการ ปัจจุบันและจะมีการส่งคืน stdout และ stderr ของ กระบวนการ ปัจจุบัน
อาจระบุสตริงคู่ของร่างกายเป็นอาร์กิวเมนต์ซึ่งในกรณีนี้ร่างกายจะถูกเรียกใช้เมื่อป้อนสตริงที่เกี่ยวข้อง (ตามค่าดีฟอลต์สตริงจะไม่ถูกส่งไปยัง กระบวนการ ปัจจุบัน) คำสั่ง interpreter จะสันนิษฐานถ้าร่างกายตัวสุดท้ายหายไป
หากอาร์กิวเมนต์ทั้งหมด โต้ตอบ ต้องใช้มากกว่าหนึ่งบรรทัดอาร์กิวเมนต์ทั้งหมดอาจถูก "ยึด" ไว้ในแถวเดียวเพื่อหลีกเลี่ยงการยกเลิกแต่ละบรรทัดโดยใช้เครื่องหมายแบ็กสแลช ในกรณีนี้การแทนที่ Tcl ตามปกติจะเกิดขึ้นแม้จะมีวงเล็บปีกกา
ตัวอย่างเช่นคำสั่งต่อไปนี้ทำงานโต้ตอบกับคู่ string-body ต่อไปนี้ที่กำหนดไว้: เมื่อกดปุ่ม ^ Z คาดว่า Expect จะถูกระงับ ( ค่ารีเซ็ต จะคืนค่าโหมดเทอร์มินัล) เมื่อกดปุ่ม ^ A ผู้ใช้จะเห็นว่า "คุณพิมพ์ตัวควบคุม A" และ กระบวนการ นี้จะส่งค่า ^ A เมื่อกด $ ผู้ใช้จะเห็นวันที่ เมื่อกดปุ่ม ^ C คาดว่า Expits จะ ออก หากมีการป้อน "foo" ผู้ใช้จะเห็น "bar" เมื่อมีการกด ~~ ผู้ ล่า Expect จะโต้ตอบกัน
ตั้งค่า CTRLZ \ 032 interact {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "คุณพิมพ์ตัวควบคุม A \ n"; ส่ง "\ 001"} $ {send_user "วันที่เป็น [clock format [clock clock [clock clock]]"} \ 003 ออก foo {send_user "bar"} ~~}ในสตริงคู่ร่างกายสตริงจะจับคู่ตามลำดับที่ระบุเป็นอาร์กิวเมนต์ สตริงที่ตรงกับบางส่วนจะไม่ถูกส่งไปยัง กระบวนการ ปัจจุบันในขณะที่คาดว่าส่วนที่เหลือจะมาถึง หากมีการป้อนอักขระเพื่อไม่ให้มีการจับคู่อีกต่อไปเพียงส่วนเดียวของสตริงจะถูกส่งไปยัง กระบวนการ ที่ไม่สามารถเริ่มต้นการแข่งขันอื่นได้ ดังนั้นสตริงที่เป็นสตริงย่อยของการจับคู่บางส่วนสามารถจับคู่ได้ในภายหลังถ้าสตริงเดิมที่พยายามจะจับคู่ล้มเหลวที่สุด
โดยค่าเริ่มต้นการจับคู่สตริงเป็นที่แน่นอนโดยไม่มี การ์ดเสริม (ในทางตรงกันข้ามคำสั่ง คาดหวัง จะใช้รูปแบบของรูปแบบโลกโดยค่าเริ่มต้น) ธง -ex อาจถูกใช้เพื่อป้องกันรูปแบบที่อาจเป็นไปได้ในการ โต้ตอบ กับแฟล็ก โต้ตอบ จากการทำเช่นนั้น รูปแบบที่ขึ้นต้นด้วย "-" ควรได้รับการป้องกันด้วยวิธีนี้ (สตริงทั้งหมดที่ขึ้นต้นด้วย "-" สงวนไว้สำหรับตัวเลือกในอนาคต)
ธง -re บังคับให้สตริงถูกตีความว่าเป็นรูปแบบ regexp ในกรณีนี้การจับคู่สตริงย่อยจะถูกเก็บไว้ในตัวแปร interact_out ในทำนองเดียวกันกับที่ คาดว่าจะจัด เก็บเอาท์พุทไว้ในตัวแปร expect_out แฟ ล็ก -indices ได้รับการสนับสนุนในทำนองเดียวกัน
รูปแบบ eof จะ แนะนำการดำเนินการที่ดำเนินการเมื่อสิ้นสุดไฟล์ รูปแบบ eof ที่ แยกจากกันอาจเป็นไปตาม ค่า สถานะ -output ซึ่งในกรณีนี้จะมีการจับคู่หากมีการตรวจจับ eof ในขณะเขียนข้อมูลเอาต์พุต การดำเนินการ eof เริ่มต้นคือ "return" เพื่อให้ผลตอบแทนเพียงเมื่อ EOF ใด ๆ
ช่วง หมดเวลาของ รูปแบบแนะนำการหมดเวลา (เป็นวินาที) และการดำเนินการที่ดำเนินการหลังจากไม่มีการอ่านอักขระในช่วงเวลาที่กำหนด รูปแบบการ หมดเวลา ใช้กับ กระบวนการที่ ระบุไว้ล่าสุด ไม่มีการหมดเวลาเริ่มต้น ตัวแปรพิเศษ "timeout" (ใช้โดยคำสั่ง expect ) ไม่มีผลต่อการหมดเวลานี้
ตัวอย่างเช่นคำแถลงต่อไปนี้สามารถใช้เพื่ออ้างสิทธิ์ผู้ใช้ที่ไม่ได้พิมพ์อะไรเป็นเวลา 1 ชั่วโมง แต่ยังคงได้รับข้อความระบบบ่อยๆดังนี้
โต้ตอบ - ใส่ $ user_spawn_id timeout 3600 return -output \ $ spawn_idถ้ารูปแบบเป็น null คำหลักและ nulls ได้รับอนุญาต (ผ่านทางคำสั่ง remove_nulls ) ตัวที่สอดคล้องกันจะถูกเรียกใช้ถ้า ASCII 0 เดียวถูกจับคู่ ไม่สามารถจับคู่ 0 ไบต์ผ่านรูปแบบ glob หรือ regexp
การสร้างแบบจำลองด้วยธง --iwit จะทำให้ตัวแปร interact_out (spawn_id) ถูกตั้งค่าเป็น spawn_id ซึ่งตรงกับรูปแบบ (หรือ eof)
การดำเนินการเช่น break และ ดำเนินการต่อ โครงสร้างการควบคุมสาเหตุ (เช่น for , proc ) ให้ทำงานในลักษณะปกติ อย่างไรก็ตามการ กลับมา ทำให้เกิดการโต้ตอบเพื่อกลับไปยังผู้เรียกของตนขณะที่ inter_return ทำให้เกิด การโต้ตอบ เพื่อก่อให้เกิดผลตอบแทนในผู้โทร ตัวอย่างเช่นถ้า "proc foo" เรียกว่า interact ซึ่งจะดำเนินการ action inter_return แล้ว proc foo จะกลับมา (ซึ่งหมายความว่าหาก มีปฏิสัมพันธ์กับผู้ ติดต่อ ล่าม การพิมพ์แบบ ย้อนกลับ โต้ตอบจะทำให้การโต้ตอบดำเนินต่อไปขณะที่ inter_return จะทำให้การโต้ตอบกลับไปยังผู้โทร)
ระหว่างการ โต้ตอบ โหมดดิบจะใช้เพื่อให้อักขระทั้งหมดอาจถูกส่งผ่านไปยัง กระบวนการ ปัจจุบัน หาก กระบวนการ ปัจจุบันไม่จับสัญญาณควบคุมงานจะหยุดถ้าส่งสัญญาณหยุด (โดยค่าเริ่มต้น ^ Z) หากต้องการเริ่มต้นใหม่ให้ส่งสัญญาณต่อไป (เช่น "kill -ONT") ถ้าคุณต้องการส่ง SIGSTOP ไปยัง กระบวนการ ดังกล่าว (โดย ^ Z) ให้พิจารณาวางไข่ csh ก่อนแล้วจึงเรียกใช้โปรแกรมของคุณ ในทางตรงกันข้ามถ้าคุณต้องการส่ง SIGSTOP เพื่อ คาดหวัง ตัวเองล่ามสายแรก (บางทีโดยใช้ตัวหนี) จากนั้นกด ^ Z
คู่สตริง - ร่างกายสามารถใช้เป็นชวเลขเพื่อหลีกเลี่ยงการป้อนคำแปลและสั่งการคำสั่งได้ โหมดเทอร์มินอลก่อนหน้านี้จะถูกใช้งานขณะกำลังทำงานของร่างกายของคู่สายสตริง
สำหรับความเร็วการดำเนินการจะดำเนินการในโหมดดิบโดยค่าเริ่มต้น ค่า รีเซ็ต - ตั้ง ค่าใหม่ให้รีเซ็ตเทอร์มินัลไปยังโหมดที่มีอยู่ก่อนที่จะมี การโต้ตอบกัน (โหมดสุก) โปรดทราบว่าอักขระที่ป้อนเมื่อเปลี่ยนโหมดอาจสูญหายไป (คุณลักษณะที่ไม่พึงประสงค์ของไดรเวอร์เทอร์มินัลในบางระบบ) เหตุผลเดียวที่จะใช้ -reset คือการดำเนินการของคุณขึ้นอยู่กับการทำงานในโหมดปรุงอาหาร
ธง -echo ส่งอักขระที่ตรงกับรูปแบบต่อไปนี้กลับไปสู่ กระบวนการ ที่สร้างขึ้นเมื่ออ่านอักขระแต่ละตัว ซึ่งอาจเป็นประโยชน์เมื่อผู้ใช้ต้องการดูการตอบรับจากรูปแบบที่พิมพ์บางส่วน
หากรูปแบบถูกสะท้อน แต่ในที่สุดไม่สามารถจับคู่อักขระจะถูกส่งไปที่ กระบวนการ พลิกกลับ ถ้า กระบวนการ พลิกกลับแล้วสะท้อนให้เห็นผู้ใช้จะเห็นตัวอักษรสองครั้ง -echo น่าจะเป็นเฉพาะในสถานการณ์ที่ผู้ใช้ไม่น่าจะไม่สมบูรณ์แบบ ตัวอย่างเช่นข้อความที่ตัดตอนมานี้มาจาก rftp สคริปต์ recursive-ftp ซึ่งผู้ใช้จะได้รับแจ้งให้ป้อน ~ g, ~ p หรือ ~ l เพื่อเรียกดูใส่หรือแสดงรายการไดเรกทอรีปัจจุบันที่ทำซ้ำ ซึ่งห่างจากคำสั่ง ftp ปกติซึ่งผู้ใช้ไม่น่าจะพิมพ์ ~ ตามด้วยสิ่งอื่นยกเว้นผิดพลาดซึ่งในกรณีนี้อาจเป็นเพียงแค่ละเว้นผลลัพธ์ต่อไป
โต้ตอบ {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}ธง nobuffer จะส่งอักขระที่ตรงกับรูปแบบต่อไปนี้ไปสู่ กระบวนการ เอาต์พุตเมื่ออ่านอักขระ
นี้จะเป็นประโยชน์เมื่อคุณต้องการให้โปรแกรม echo กลับรูปแบบ ตัวอย่างเช่นต่อไปนี้อาจใช้ในการตรวจสอบว่าบุคคลใดโทรไป (โมเด็ม Hayes) แต่ละครั้ง "atd" จะเห็นสคริปต์บันทึกส่วนที่เหลือของบรรทัด
proc lognumber {} {interact -nobuffer -re "(. *) \ r" return ทำให้ $ log "[clock format [clock clock]]: เรียกเลขหมาย $ interact_out (1, string)"} interact -nobuffer "atd" lognumberระหว่างการ โต้ตอบการ ใช้งานก่อนหน้าของ log_user จะถูกละเว้น โดยเฉพาะอย่างยิ่ง ปฏิสัมพันธ์ จะบังคับเอาท์พุทที่จะเข้าสู่ระบบ (ส่งไปยังเอาท์พุทมาตรฐาน) เนื่องจากผู้ใช้ไม่ต้องการโต้ตอบกับคนตาบอด
ธง -o จะทำให้คู่คีย์ - ร่างกายต่อไปนี้ถูกนำไปใช้กับผลลัพธ์ของ กระบวนการ ปัจจุบัน ซึ่งอาจเป็นประโยชน์เช่นเมื่อติดต่อกับ โฮสต์ ที่ส่งอักขระที่ไม่พึงประสงค์ระหว่างเซสชัน telnet
โดยค่าเริ่มต้น โต้ตอบ คาดว่าผู้ใช้จะเขียน stdin และอ่าน stdout ของ กระบวนการ Expect เอง ธง อู (สำหรับ "ผู้ใช้") ทำให้ การโต้ตอบ หาผู้ใช้เป็น กระบวนการ ชื่อโดยอาร์กิวเมนต์ของมัน (ซึ่งต้องเป็น ID spawned)
ซึ่งจะช่วยให้ทั้งสองกระบวนการที่ไม่เกี่ยวข้องสามารถรวมเข้าด้วยกันได้โดยไม่ต้องใช้ลูปที่ชัดเจน เพื่อช่วยในการแก้จุดบกพร่องคาดว่าการวินิจฉัยจะไปที่ stderr (หรือ stdout สำหรับข้อมูลการเข้าสู่ระบบและการดีบัก) ด้วยเหตุผลเดียวกันคำสั่ง interpreter จะอ่านการโต้ตอบจาก stdin
ตัวอย่างเช่นส่วนต่อไปนี้สร้าง กระบวนการ เข้าสู่ระบบ จากนั้นจะหมุนหมายเลขผู้ใช้ (ไม่แสดง) และสุดท้ายจะเชื่อมต่อทั้งสองเข้าด้วยกัน แน่นอนว่า กระบวนการ ใด ๆ อาจถูกใช้แทนได้ เชลล์จะช่วยให้ผู้ใช้สามารถทำงานได้โดยไม่ต้องมีบัญชีและรหัสผ่าน
spawn login set login $ spawn_id spawn tip modem # กดกลับออกไปยังผู้ใช้ # เชื่อมต่อผู้ใช้เพื่อเข้าสู่ระบบโต้ตอบ -u $ เข้าสู่ระบบเมื่อต้องการส่งเอาท์พุทไปยังหลายโพรเซสให้ทำรายการไอดีไอแต่ละรายการที่นำมาวางโดยธง a- output การป้อนข้อมูลสำหรับ กลุ่ม ของรหัสคลาดเคลื่อนเอาต์พุตอาจถูกกำหนดโดยรายการ spawn id ที่นำมาใช้โดยค่า -input (ทั้งสองเข้าและออกอาจใช้รายการในรูปแบบเดียวกับธง -i ในคำสั่ง คาดหวัง ยกเว้น any_spawn_id ไม่มีความหมายใน การโต้ตอบ ) ธงต่อไปนี้ทั้งหมดและ สตริง (หรือรูปแบบ) นำไปใช้กับอินพุทนี้จนกว่าจะมีอีก - ธงป้อนข้อมูลจะปรากฏขึ้น ถ้าไม่มี -input ปรากฏขึ้น -output อนุมานว่า "-input $ user_spawn_id -output" (ในทำนองเดียวกันกับรูปแบบที่ไม่ได้ ป้อน ข้อมูล) ถ้ากำหนดไว้หนึ่งอินพุทจะแทนที่ $ user_spawn_id หากมีการระบุ อินพุต ที่สองจะแทนที่ $ spawn_id สามารถระบุแฟล็กเพิ่มเติมได้
กระบวนการป้อนข้อมูลโดยนัยทั้งสองจะมีค่าเริ่มต้นเป็นค่าที่กำหนดไว้เป็น $ spawn_id และ $ user_spawn_id (ในทางกลับกัน) หากธง a- input ปรากฏขึ้นโดยไม่มี flag- out เอา ไว้ระบบจะทิ้งตัวอักษรจาก กระบวนการ นี้
-i-band แนะนำให้ใช้ทดแทน spawn_id ปัจจุบันเมื่อไม่มี flag - input หรือ -output ธง -i หมายถึงเครื่องหมาย -o
เป็นไปได้ที่จะเปลี่ยนกระบวนการที่กำลังมีการโต้ตอบกับโดยใช้รหัสวางไข่ทางอ้อม (Id วางไข่ทางอ้อมอธิบายไว้ในส่วนของคำสั่งคาดการณ์) รหัส id ที่วางไข่โดยทางอ้อมอาจระบุด้วยไอดี -i, -u, -input หรือ -output
ล่าม [args]
ทำให้ผู้ใช้ได้รับข้อความโต้ตอบแบบทันทีสำหรับคำสั่ง Expect และ Tcl ผลของคำสั่งแต่ละคำจะถูกพิมพ์ออกมา
การดำเนินการเช่น break และ ดำเนินการต่อ โครงสร้างการควบคุมสาเหตุ (เช่น for , proc ) ให้ทำงานในลักษณะปกติ อย่างไรก็ตามการ กลับมา ทำให้ล่ามเพื่อกลับไปยังผู้เรียกของมันในขณะที่ inter_return ทำให้ ล่าม เกิดผลตอบแทนในผู้โทร ยกตัวอย่างเช่นถ้า "proc foo" เรียกว่า interpreter ซึ่งใช้งาน inter_return แล้ว proc foo จะกลับมา คำสั่งอื่น ๆ จะทำให้ ล่าม ดำเนินต่อเพื่อแจ้งคำสั่งใหม่
โดยค่าเริ่มต้นพรอมต์ประกอบด้วยสองจำนวนเต็ม จำนวนเต็มแรกอธิบายความลึกของสแต็คการประเมินผล (กล่าวคือกี่ครั้ง Tcl_Eval ถูกเรียก) จำนวนเต็มที่สองคือตัวระบุประวัติ Tcl พรอมต์สามารถตั้งค่าได้โดยการกำหนดขั้นตอนที่เรียกว่า "prompt1" ซึ่งค่าที่ส่งกลับจะกลายเป็นพรอมต์ถัดไป ถ้าคำสั่งมีราคาเปิด parens วงเล็บปีกกาหรือวงเล็บคำสั่งรอง (ตามค่าเริ่มต้น "+") จะออกให้กับบรรทัดใหม่ พรอมต์รองอาจถูกตั้งค่าโดยการกำหนดขั้นตอนที่เรียกว่า "prompt2"
ระหว่าง ล่าม โหมดสุกจะใช้แม้ว่าผู้โทรจะใช้โหมดดิบ
หาก stdin ถูกปิด ล่าม จะกลับมาจนกว่าจะมีการใช้แฟลก eof ซึ่งในกรณีนี้อาร์กิวเมนต์ที่ตามมาจะถูกเรียกใช้
log_file [args] [[-a] ไฟล์]
ถ้ามีชื่อไฟล์ log_file จะบันทึกสำเนาของเซสชัน (เริ่มต้นที่จุดนั้น) ในไฟล์ log_file จะหยุดการบันทึกถ้าอาร์กิวเมนต์ไม่ได้รับ แฟ้มบันทึกก่อนหน้านี้ถูกปิด
แทนชื่อไฟล์ตัวระบุไฟล์ Tcl อาจได้รับโดยใช้ค่าสถานะ เปิด หรือ -leaveopen นี้คล้ายกับคำสั่ง วางไข่ (ดู วางไข่ เพื่อดูข้อมูลเพิ่มเติม)
-a ธงบังคับให้ส่งออกเพื่อเข้าสู่ระบบที่ถูกระงับโดยคำสั่ง log_user
โดยค่าเริ่มต้นคำสั่ง log_file จะ ผนวก เข้ากับไฟล์เก่าแทนที่จะตัดทอนเพื่อความสะดวกในการที่จะสามารถตัดการใช้งานออกและใช้งานได้หลายครั้งในเซสชั่นเดียว หากต้องการตัดทอนไฟล์ให้ใช้แฟ ล็ก -noappend
flaga-info ทำให้ log_file ส่งคำอธิบายของอาร์กิวเมนต์ที่ไม่ใช่ข้อมูลล่าสุดที่กำหนดไว้
log_user -info | 0 | 1
โดยค่าเริ่มต้นกล่องโต้ตอบส่ง / คาดจะถูกบันทึกลงใน stdout (และ logfile ถ้าเปิดอยู่) การเข้าสู่ระบบ stdout ถูกปิดใช้งานโดยคำสั่ง "log_user 0" และเปิดใช้งานอีกครั้งโดย "log_user 1" การเข้าสู่ระบบ logfile จะไม่มีการเปลี่ยนแปลง
flaga-info ทำให้ log_user แสดงคำอธิบายของอาร์กิวเมนต์ที่ไม่ใช่ข้อมูลล่าสุดที่กำหนด
match_max [-d] [-i spawn_id] [size]
กำหนดขนาดของบัฟเฟอร์ (ไบต์) ที่ใช้ภายในโดย คาดหวัง ไม่มีอาร์กิวเมนต์ขนาดขนาดปัจจุบันจะถูกส่งกลับ
ด้วยค่าสถานะ -d จะมีการตั้งค่าขนาดเริ่มต้นไว้ (ค่าดีฟอลต์เริ่มต้นคือ 2000) ด้วย -i- flag ขนาดจะถูกกำหนดไว้สำหรับ id การวางไข่ที่ตั้งไว้มิฉะนั้นจะถูกตั้งค่าสำหรับ กระบวนการ ปัจจุบัน
overlay [- # spawn_id] [- # spawn_id] [... ] โปรแกรม [args]
รัน โปรแกรม " args" ในตำแหน่งของโปรแกรม Expect ปัจจุบันซึ่งจะสิ้นสุดลง อาร์กิวเมนต์ยัติภังค์บังคับให้ยัติภังค์อยู่ด้านหน้าของชื่อคำสั่งเหมือนกับว่าเป็นเชลล์ล็อกอิน spawn_id ทั้งหมดถูกปิดยกเว้นสำหรับที่ระบุว่าเป็นอาร์กิวเมนต์ เหล่านี้จะถูกแมปไปยังตัวระบุไฟล์ที่ระบุ
Spawn_ids ถูกแม็พกับตัวระบุไฟล์สำหรับโปรแกรมใหม่ที่สืบทอด ตัวอย่างเช่นบรรทัดต่อไปนี้เรียกใช้หมากรุกและช่วยให้สามารถควบคุมโดย กระบวนการ ปัจจุบันเช่นหมากรุกเป็นต้น
overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id หมากรุกนี้มีประสิทธิภาพมากกว่า "โต้ตอบ -u" แต่จะเสียสละความสามารถในการทำโปรแกรมปฏิสัมพันธ์ตั้งแต่ กระบวนการ คาดหวัง ไม่อยู่ในการควบคุม
โปรดทราบว่าไม่มีขั้วควบคุม ดังนั้นหากคุณยกเลิกการเชื่อมต่อหรือใส่ข้อมูลเข้ามาตรฐานโปรแกรมที่ทำหน้าที่ควบคุมงาน (เปลือกหอยการเข้าสู่ระบบ ฯลฯ ) จะไม่ทำงานอย่างถูกต้อง
ความเท่าเทียมกัน [-d] [-i spawn_id] [value]
กำหนดความเท่าเทียมกันควรจะเก็บรักษาไว้หรือปลดออกจากกระบวนการผลิตที่เกิดขึ้น ถ้า ค่า เป็นศูนย์จะมีการถอดพาริตีออกหรือมิฉะนั้นจะไม่ถูกตัดออก ไม่มีอาร์กิวเมนต์ค่าค่าปัจจุบันจะถูกส่งกลับ
ด้วยค่า -d ค่าความเท่าเทียมกันเริ่มต้นถูกตั้งไว้ (ค่าดีฟอลต์เริ่มต้นคือ 1 คือไม่เท่ากัน parity) ด้วย -i- flag ค่า parity จะถูกกำหนดไว้สำหรับ id วางไข่ที่ตั้งไว้มิฉะนั้นจะถูกตั้งค่าไว้สำหรับ กระบวนการ ปัจจุบัน
remove_nulls [-d] [-i spawn_id] [value]
กำหนดว่า nulls จะถูกเก็บหรือลบออกจากเอาท์พุทของกระบวนการ spawned ก่อนรูปแบบการจับคู่หรือการจัดเก็บในตัวแปร expect_out หรือ interact_out หากมี ค่า เป็น 1 ค่า null จะถูกลบออก ถ้า ค่า เป็น 0 ค่า null จะไม่ถูกเอาออก ไม่มีอาร์กิวเมนต์ค่าค่าปัจจุบันจะถูกส่งกลับ
เมื่อใช้ค่า -d flag ค่าดีฟอลต์จะถูกตั้งไว้ (ค่าเริ่มต้นเริ่มต้นคือ 1 คือ nulls จะถูกเอาออก) ด้วย -i- flag ค่าจะถูกตั้งค่าไว้สำหรับ id วางไข่ที่มีชื่อมิฉะนั้นจะถูกตั้งค่าสำหรับ กระบวนการ ปัจจุบัน
ไม่ว่าจะลบ nulls, คาดว่า จะบันทึกไบต์ null เข้าสู่ log และ stdout
ส่งสตริง [--flags]
ส่งข้อความไปยัง กระบวนการ ปัจจุบัน ตัวอย่างเช่นคำสั่ง
ส่งตัวอักษร helloworld ไปสู่ กระบวนการ ปัจจุบัน (Tcl รวมถึงคำสั่ง printf เหมือนกัน (เรียกว่า รูปแบบ ) ซึ่งสามารถสร้างสตริงที่ซับซ้อนโดยพลการได้)
อักขระจะถูกส่งทันทีแม้ว่าโปรแกรมที่มีอินพุตแบบบัฟเฟอร์บรรทัดจะไม่อ่านอักขระจนกว่าจะมีการส่งอักขระที่ส่งคืน อักขระ return แสดงว่า "\ r"
ค่าสถานะ - อาร์กิวเมนต์ถัดไปจะตีความว่าเป็นสตริงแทนที่จะเป็นแฟล็ก สตริงใด ๆ สามารถนำหน้าด้วย "-" ได้ไม่ว่าจะเป็นรูปธงหรือไม่ก็ตาม นี่เป็นกลไกที่เชื่อถือได้ในการระบุสตริงตัวแปรโดยไม่ต้องสะดุดโดยผู้ที่บังเอิญมีลักษณะเป็นธง (สตริงทั้งหมดที่ขึ้นต้นด้วย "-" สงวนไว้สำหรับตัวเลือกในอนาคต)
ธง -i ประกาศว่าสตริงถูกส่งไปยัง spawn_id ที่มีชื่อ ถ้า spawn_id เป็น user_spawn_id และ terminal อยู่ในโหมด raw บรรทัดใหม่ในสตริงจะถูกแปลเป็นลำดับกลับ - บรรทัดใหม่เพื่อให้ปรากฏขึ้นเหมือนกับว่า terminal อยู่ในโหมดสุก ธงคำอธิบาย - ปิดใช้งานการแปลนี้
ค่าสถานะ -null ส่งอักขระ null (0 ไบต์) โดยค่าเริ่มต้นจะมีการส่งค่า null หนึ่งค่า จำนวนเต็มอาจเป็นไปตาม " null" เพื่อระบุจำนวน nulls ที่จะส่ง
ค่าสถานะการ บุกรุก สร้างสภาพแตกหัก นี้จะทำให้รู้สึกได้ว่า id การวางไข่หมายถึงอุปกรณ์ tty เปิดผ่านทาง "spawn -open" หากคุณมี กระบวนกระบวนการ เช่นทิปคุณควรใช้ข้อตกลงในการสร้างข้อผิดพลาด
ค่าสถานะ -s จะส่งผลให้ "ช้าๆ" ส่งผลให้หลีกเลี่ยงสถานการณ์ทั่วไปที่คอมพิวเตอร์มีการจัดเตรียมบัฟเฟอร์อินพุตที่ออกแบบมาสำหรับมนุษย์ที่ไม่มีวันหมดตัวของ บัฟเฟอร์ เดียวกัน เอาท์พุทนี้ถูกควบคุมโดยค่าของตัวแปร "send_slow" ซึ่งจะใช้เวลาสองรายการองค์ประกอบ องค์ประกอบแรกคือจำนวนเต็มที่อธิบายถึงจำนวนไบต์ที่จะส่ง atomically องค์ประกอบที่สองคือจำนวนจริงที่อธิบายถึงจำนวนวินาทีที่อะตอมมิกส่งต้องถูกแยกออก ตัวอย่างเช่น "set send_slow {10 .001}" จะบังคับให้ "send -s" ส่งสตริงด้วยมิลลิวินาทีในระหว่างแต่ละอักขระที่ส่งมา 10 ตัว
ค่าสถานะ -h จะส่งออกไป (ค่อนข้าง) เหมือนกับคนที่พิมพ์จริง ความล่าช้าของมนุษย์เกิดขึ้นระหว่างตัวอักษร (อัลกอริทึมจะขึ้นอยู่กับการแจกจ่าย Weibull โดยมีการปรับเปลี่ยนให้เหมาะสมกับแอ็พพลิเคชันนี้โดยเฉพาะ) ผลลัพธ์นี้ถูกควบคุมโดยค่าของตัวแปร "send_human" ซึ่งจะมีรายการองค์ประกอบห้ารายการ องค์ประกอบสองตัวแรกเป็นระยะเวลาระหว่างอักขระเฉลี่ยภายในไม่กี่วินาที ใช้ค่าแรกเป็นค่าเริ่มต้น ส่วนที่สองใช้ในตอนท้ายคำเพื่อจำลองช่วงเวลาที่ลึกซึ้งซึ่งบางครั้งเกิดขึ้นในช่วงเวลาดังกล่าว พารามิเตอร์ที่สามเป็นตัวชี้วัดความแปรปรวนที่. 1 มีตัวแปรค่อนข้างมากตัวแปร 1 มีตัวแปรที่สมเหตุสมผลและ 10 มีค่าไม่เปลี่ยนแปลง สุดขั้วเป็น 0 ถึงไม่มีที่สิ้นสุด พารามิเตอร์สองตัวสุดท้ายคือลำดับขั้นสูงสุดและต่ำสุด จำนวนขั้นต่ำและสูงสุดจะถูกใช้เป็นครั้งสุดท้ายและ "คลิป" เป็นครั้งสุดท้าย ค่าเฉลี่ยที่ดีที่สุดอาจแตกต่างจากค่าเฉลี่ยที่กำหนดถ้าค่าต่ำสุดและสูงสุดของค่าพอ
ตัวอย่างเช่นคำสั่งต่อไปนี้เลียนแบบเครื่องพิมพ์ดีดที่รวดเร็วและสอดคล้องกัน:
ตั้ง send_human {.1 .3 1 .0 2} send -h "ฉันหิวเรามาทำอาหารกลางวันกันเถอะ"ในขณะที่อาการต่อไปนี้อาจเหมาะสมกว่าหลังจากอาการเมาค้าง:
ตั้งค่า send_human {.4 .4 .2 .5 100} send -h "คืนพรรคนางดีปาร์ตี้!"โปรดทราบว่าข้อผิดพลาดไม่ได้ถูกจำลองแม้ว่าคุณจะสามารถตั้งค่าสถานการณ์การแก้ไขข้อผิดพลาดได้ด้วยการฝังข้อผิดพลาดและการแก้ไขในอาร์กิวเมนต์การส่ง
ค่าสถานะสำหรับการส่งอักขระ null สำหรับการส่งแฟ็กซ์การบังคับให้เอาต์พุตช้าและสำหรับเอาต์พุตแบบมนุษย์มีลักษณะพิเศษร่วมกัน ระบบจะใช้เฉพาะรายการสุดท้ายที่ระบุเท่านั้น นอกจากอาร์กิวเมนต์ สตริง ไม่สามารถระบุด้วยธงสำหรับการส่งตัวอักษรหรือตัวแบ่ง
เป็นความคิดที่ดีที่จะนำหน้าการ ส่ง ไปยัง ขั้นตอนแรก โดย คาดหวัง คาดว่า จะรอให้ กระบวนการ เริ่มต้นในขณะที่ ส่ง ไม่ได้ โดยเฉพาะอย่างยิ่งถ้าการ ส่ง ครั้งแรกเสร็จสิ้นก่อนที่ กระบวนการจะ เริ่มทำงานคุณจะเสี่ยงต่อการถูกละเลยข้อมูลของคุณ ในสถานการณ์ที่โปรแกรมโต้ตอบไม่มีการแจ้งให้คุณเริ่มต้นคุณสามารถนำ ส่ง โดยการหน่วงเวลาเช่น:
# เพื่อหลีกเลี่ยงการให้คำแนะนำเกี่ยวกับวิธีแฮ็กเกอร์ในระบบ # ระบบนี้ไม่สามารถขอรหัสผ่านภายนอกได้ # รอ 5 วินาทีสำหรับ exec เพื่อให้ spnet วางไข่ telnet very.secure.gov sleep 5 ส่ง password \ rexp_send เป็นชื่อแทนสำหรับ ส่ง ถ้าคุณกำลังใช้ Expectk หรือตัวแปรอื่น ๆ ของ Expect ในสภาพแวดล้อม Tk การ ส่ง จะกำหนดโดย Tk สำหรับวัตถุประสงค์ที่แตกต่างไปจากเดิมอย่างสิ้นเชิง exp_send มีให้สำหรับการทำงานร่วมกันระหว่างสภาพแวดล้อม มีการระบุนามแฝงเดียวกันสำหรับคำสั่งส่งอื่น ๆ ของ Expect
สตริง [-flags] ของ send_error
เป็นเหมือน ส่ง ยกเว้นว่าผลลัพธ์ถูกส่งไปยัง stderr แทนที่จะเป็น กระบวนการ ปัจจุบัน
send_log [-] สตริง
เป็นเหมือน ส่ง ยกเว้นว่าสายจะถูกส่งไปยังล็อกไฟล์เท่านั้น (ดู log_file ) อาร์กิวเมนต์จะถูกละเว้นถ้าไม่มีแฟ้มบันทึกถูกเปิดอยู่
สตริง [-flags] ของ send_tty
เป็นเหมือน ส่ง ยกเว้นว่าผลลัพธ์ถูกส่งไปที่ / dev / tty แทนที่จะเป็น กระบวนการ ปัจจุบัน
สตริง [-flags] ของ send_user
เป็นเหมือน ส่ง ยกเว้นว่าผลลัพธ์ถูกส่งไปยัง stdout แทนที่จะเป็น กระบวนการ ปัจจุบัน
วินาทีนอนหลับ
ทำให้สคริปต์สลีปสำหรับจำนวนวินาทีที่ระบุ วินาทีอาจเป็นตัวเลขทศนิยม การขัดจังหวะ (และเหตุการณ์ Tk ถ้าคุณใช้ Expectk) จะได้รับการประมวลผลในขณะที่ Expect นอนหลับ
วางไข่ [args] โปรแกรม [args]
สร้าง กระบวนการ ใหม่ที่เรียกใช้ "โปรแกรม args" stdin, stdout และ stderr เชื่อมต่อกับ Expect เพื่อให้สามารถอ่านและเขียนโดยคำสั่ง Expect อื่น ๆ ได้ การเชื่อมต่อเสียโดย ปิด หรือถ้า กระบวนการ นี้ปิดตัวระบุไฟล์ใด ๆ
เมื่อ กระบวนการ เริ่มต้นโดยการ วางไข่ ตัวแปร spawn_id ถูกตั้งค่าเป็น descriptor หมายถึง กระบวนการ นั้น กระบวนการที่ อธิบายโดย spawn_id ถือเป็น " กระบวนการ ปัจจุบัน " spawn_id อาจถูกอ่านหรือเขียนได้
user_spawn_id เป็นตัวแปรส่วนกลางที่ประกอบด้วย descriptor ซึ่งหมายถึงผู้ใช้ ตัวอย่างเช่นเมื่อตั้งค่า spawn_id เป็นค่านี้ คาดว่า จะทำตัวเหมือน expect_user
. error_spawn_id คือตัวแปรส่วนกลางที่ประกอบด้วย descriptor ซึ่งหมายถึงข้อผิดพลาดมาตรฐาน ตัวอย่างเช่นเมื่อตั้งค่า spawn_id เป็นค่านี้ ส่ง พฤติกรรมเช่น send_error
tty_spawn_id เป็นตัวแปรระดับโลกที่ประกอบด้วย descriptor ซึ่งอ้างถึง / dev / tty ถ้าไม่มี / dev / tty (เช่นใน cron, at หรือ batch script) tty_spawn_id ไม่ได้ถูกกำหนดไว้ ซึ่งอาจได้รับการทดสอบเป็น:
ถ้า {[info vars tty_spawn_id]} {# / dev / tty exists} else {# / dev / tty ไม่มีอยู่ # อาจเป็นใน cron, batch หรือที่ script}วางไข่ จะส่งคืนรหัส กระบวนการ UNIX หากไม่มี กระบวนการ ใดที่เกิดขึ้นจะส่งคืน 0 ตัวแปร spawn_out (ทาส, ชื่อ) ถูกตั้งค่าเป็นชื่อของอุปกรณ์ pty slave
โดยค่าเริ่มต้นการ วางไข่จะ สะท้อนชื่อคำสั่งและอาร์กิวเมนต์ ธง -noecho หยุดการ วางไข่ เมื่อทำเช่นนี้
ธง -console ทำให้คอนโซลเอาท์พุตถูกเปลี่ยนเส้นทางไปยัง กระบวนการที่ เกิดขึ้น นี้ไม่ได้รับการสนับสนุนในทุกระบบ
ภายใน spawn ใช้ pty, initialized เช่นเดียวกับ tty ของผู้ใช้ นี้จะเริ่มต้นต่อไปเพื่อให้การตั้งค่าทั้งหมดเป็น "สติ" (ตาม stty (1)) ถ้ากำหนดตัวแปร stty_init จะถูกตีความในรูปแบบของอาร์กิวเมนต์ stty เป็นการกำหนดค่าต่อไป ตัวอย่างเช่น "set stty_init raw" จะทำให้ขั้วของกระบวนการผลิตที่ต่อจากนี้เริ่มทำงานในโหมดดิบ - nottycopy ข้ามการเริ่มต้นขึ้นอยู่กับ tty ของผู้ใช้ - nottyinit ข้ามการเริ่มต้น "มีสติ"
โดยปกติการ วางไข่ จะใช้เวลาเพียงเล็กน้อยในการดำเนินการ ถ้าคุณสังเกตเห็นการวางไข่โดยใช้เวลาเป็นจำนวนมากอาจเป็นไปได้ว่าต้องเผชิญกับ ptys ที่ถูกปั้น จำนวนของการทดสอบจะดำเนินการใน ptys เพื่อหลีกเลี่ยง entanglements กับกระบวนการหลงทาง (เหล่านี้ใช้เวลา 10 วินาทีต่อ wedty pty.) ทำงานคาดหวังกับ d- ตัวเลือกจะแสดงว่า Expect พบ ptys จำนวนมากในรัฐคี่ ถ้าคุณไม่สามารถฆ่ากระบวนการที่มีการแนบ ptys เหล่านี้การไล่เบี้ยเฉพาะของคุณอาจเป็นการรีบูต
ถ้า โปรแกรม ไม่สามารถกลับมาได้สำเร็จเนื่องจาก exec (2) ไม่ทำงาน (เช่นเมื่อไม่มี โปรแกรม ) ข้อความแสดงข้อผิดพลาดจะถูกส่งกลับโดยการ โต้ตอบ หรือ คาดหวัง คำสั่งถัดไปเหมือนกับว่า โปรแกรม ได้เรียกใช้และสร้างข้อความแสดงข้อผิดพลาดเป็นเอาต์พุต ลักษณะการทำงานนี้เป็นผลตามธรรมชาติของการดำเนินการ วางไข่ ภายใน spawn forks หลังจากที่ กระบวนการ spawned มีวิธีสื่อสารกับ กระบวนการ Expect เดิมยกเว้นโดยการสื่อสารผ่าน spawn_id
ธง เปิด - ทำให้อาร์กิวเมนต์ถัดไปถูกตีความว่าเป็นตัวระบุไฟล์ Tcl (เช่นกลับโดยการ เปิด ) รหัส spawn สามารถใช้งานได้ราวกับว่ามันเป็น กระบวนการที่ เกิดขึ้น (ตัวระบุไฟล์ไม่ควรใช้อีกต่อไป) ซึ่งจะช่วยให้คุณรักษาอุปกรณ์ดิบไฟล์และท่อเป็นกระบวนการที่เกิดขึ้นโดยไม่ต้องใช้ pty 0 จะถูกส่งกลับเพื่อบ่งชี้ว่าไม่มี กระบวนการที่ เกี่ยวข้อง เมื่อการเชื่อมต่อกับ กระบวนการ spawned ถูกปิดเช่นเดียวกับตัวระบุไฟล์ Tcl ธง -leaveopen คล้ายกับ -open ยกเว้นว่า -leaveopen ทำให้ตัวระบุไฟล์ถูกเปิดทิ้งไว้แม้ว่าจะมีการวางรหัสวางไข่ไว้
ธง pty ทำให้ pty ถูกเปิดขึ้น แต่ไม่มี กระบวนการ ใดที่เกิดขึ้น 0 จะถูกส่งกลับเพื่อบ่งชี้ว่าไม่มี กระบวนการที่ เกี่ยวข้อง Spawn_id ถูกตั้งค่าตามปกติ
ตัวแปร spawn_out (slave, fd) ถูกตั้งค่าเป็นตัวระบุไฟล์ที่สอดคล้องกับ pty slave สามารถปิดได้โดยใช้ "ปิดสเลฟ"
แฟ ล็ก -ignore จะ ตั้งชื่อสัญญาณที่จะละเว้นใน กระบวนการที่ พลิก กลับ มิฉะนั้นสัญญาณจะมีลักษณะการทำงานเริ่มต้น สัญญาณจะถูกตั้งชื่อตามคำสั่ง trap ยกเว้นว่าสัญญาณแต่ละสัญญาณต้องใช้ค่าสถานะที่แยกต่างหาก
ระดับ strace
ทำให้งบต่อไปนี้ถูกพิมพ์ออกมาก่อนที่จะดำเนินการ (Tcl ของร่องรอยคำสั่งร่องรอยตัวแปร.) ระดับ ระบุว่าไกลลงในสแต็คโทรเพื่อติดตาม ตัวอย่างเช่นคำสั่งต่อไปนี้เรียกใช้ Expect ขณะติดตามระดับการโทร 4 ระดับแรก แต่ไม่มีผู้ใดที่ต่ำกว่าระดับนี้
แฟ ล็กอินพุต เป็นสาเหตุให้ strace ส่งคำอธิบายของอาร์กิวเมนต์ที่ไม่ใช่ข้อมูลล่าสุดที่กำหนด
stty args
เปลี่ยนโหมดเทอร์มินัลเช่นเดียวกับคำสั่งภายนอก stty
เทอร์มินัลการควบคุมสามารถเข้าถึงได้ "ขอให้ส่งคืนสถานะเป็นผลมาจากคำสั่งถ้าไม่มีการร้องขอสถานะและเข้าถึงสถานีควบคุมสถานะก่อนหน้าของแอ็ตทริบิวต์ดิบและ echo จะถูกส่งคืนในรูปแบบที่สามารถใช้ต่อได้ ใช้คำสั่ง
ตัวอย่างเช่นอาร์กิวเมนต์ ดิบ หรือที่ ติด ตั้งใส่เทอร์มินัลเข้าสู่โหมดดิบ อาร์กิวเมนต์ - ดิบ หรือ สุก ใส่เทอร์มินอลลงในโหมดสุก อาร์กิวเมนต์ echo และ -echo ใส่เทอร์มินอลลงในโหมด echo และ noecho ตามลำดับ
ตัวอย่างต่อไปนี้แสดงวิธีปิดกั้นการปิดกั้นชั่วคราว ซึ่งอาจใช้ในสคริปต์อัตโนมัติแบบอื่นเพื่อหลีกเลี่ยงการฝังรหัสผ่านไว้ (ดูข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ภายใต้หัวข้อความคาดหมายด้านล่าง)
stty -echo send_user "รหัสผ่าน:" expect_user -re "(. *) \ n" ตั้งรหัสผ่าน $ expect_out (1, string) stty echo ระบบ args
ให้ args เพื่อ sh (1) เป็น input เช่นเดียวกับถ้ามันถูกพิมพ์เป็นคำสั่งจาก terminal คาดว่า รอจนกว่าเปลือกจะสิ้นสุดลง สถานะการส่งคืนจาก sh ถูกจัดการแบบเดียวกับที่ exec จัดการกับสถานะการส่งคืน
ตรงกันข้ามกับ exec ซึ่งเปลี่ยนเส้นทาง stdin และ stdout ไปเป็นสคริปต์ ระบบจะ ไม่มีการเปลี่ยนเส้นทาง (นอกเหนือจากที่ระบุโดยสตริง) ดังนั้นจึงเป็นไปได้ที่จะใช้โปรแกรมที่ต้องพูดคุยโดยตรงกับ / dev / tty ด้วยเหตุผลเดียวกันผลของ ระบบ จะไม่ถูกบันทึกลงในบันทึก
timestamp [args]
ส่งกลับ timestamp จำนวนอาร์กิวเมนต์ไม่มีการนับจำนวนวินาทีนับตั้งแต่มีการส่งคืน epoch
ธง รูปแบบจะ แนะนำสตริงที่ส่งคืน แต่มีการแทนที่ตามกฎ POSIX สำหรับ strftime ตัวอย่างเช่น% a จะถูกแทนที่ด้วยชื่อย่อของชื่อย่อ (เช่น Sat) อื่น ๆ :
ชื่อวันทำงานแบบย่อชื่อวันทำงานเต็มรูปแบบ% b ชื่อเดือนย่อชื่อ% B เดือนเต็ม% c วันเวลาใน: พุธ 6 ต.ค. 11:45:56 1993% d วันของเดือน (01-31% ชั่วโมง H (00 - 23)% I ชั่วโมง (01-12)% j วัน (001-366)% m เดือน (01-12)% M นาที (00-59)% p am หรือ pm% S วินาที (00-61) % u วัน (1-7 วันจันทร์เป็นวันแรกของสัปดาห์) สัปดาห์ U% (00-53 วันอาทิตย์แรกเป็นวันแรกของสัปดาห์แรก)% V สัปดาห์ (01-53, รูปแบบ ISO 8601)% w day (0-7, 6) สัปดาห์% W (00-53, วันจันทร์แรกคือวันแรกของสัปดาห์แรก)% x วันที่เวลา: พุธ 6 ต.ค. 1993% เวลา X เป็น: 23:59:59% y ปี (00-99) ปี Y ตามที่: 1993% Z timezone (หรือไม่มีเลยถ้าไม่สามารถกำหนดได้) %% เป็นเครื่องหมายเปอร์เซ็นต์ข้อกำหนดอื่น ๆ % ไม่ได้กำหนดไว้ อักขระอื่น ๆ จะถูกส่งผ่านไปยังมิได้ถูกแตะต้อง รองรับเฉพาะ C locale เท่านั้น
ธงวินาทีที่สองแนะนำจำนวนวินาทีนับจากยุคที่จะใช้เป็นแหล่งที่มาของรูปแบบ มิเช่นนั้นจะใช้เวลาปัจจุบัน
ธง gmt บังคับให้เวลาออกเพื่อใช้ เขต เวลา GMT ไม่มีค่าสถานะใช้เขตเวลาท้องถิ่น
ดัก [[คำสั่ง] สัญญาณ]
ทำให้ คำสั่งที่ กำหนดให้ทำงานเมื่อได้รับสัญญาณใด ๆ ในอนาคต คำสั่งจะถูกดำเนินการในขอบเขตทั่วโลก ถ้าไม่มี คำสั่ง การทำงานของสัญญาณจะถูกส่งกลับ ถ้า คำสั่ง คือสตริง SIG_IGN สัญญาณจะถูกละเลย ถ้า คำสั่ง คือสตริง SIG_DFL สัญญาณจะส่งผลให้เริ่มต้นระบบ สัญญาณ คือ สัญญาณ เดี่ยวหรือรายการสัญญาณ สัญญาณสามารถระบุตัวเลขหรือสัญลักษณ์ตามสัญญาณ (3) คำนำหน้า "SIG" อาจถูกละเว้น
กับอาร์กิวเมนต์ไม่ (หรืออาร์กิวเมนต์จำนวน), trap ส่งกลับหมายเลขสัญญาณของคำสั่ง trap ที่กำลังดำเนินการอยู่
รหัสรหัส ใช้รหัสส่งกลับของคำสั่งแทนรหัสที่ Tcl ใด ๆ กำลังจะกลับมาเมื่อคำสั่งเริ่มต้นทำงาน
ธง -interp ทำให้คำสั่งที่จะประเมินโดยใช้ล่ามที่ใช้งานอยู่ในขณะที่คำสั่งเริ่มทำงานมากกว่าเมื่อมีการประกาศ trap
ธง name ทำให้เกิดคำสั่ง trap เพื่อส่งคืนชื่อสัญญาณของคำสั่ง trap ที่กำลังดำเนินการอยู่
ค่าสถานะ - max ทำให้เกิดคำสั่ง trap เพื่อส่งคืนหมายเลขสัญญาณที่ใหญ่ที่สุดที่สามารถตั้งค่าได้
ตัวอย่างเช่นคำสั่ง "trap {send_user" Ouch! "} SIGINT" จะพิมพ์ "Ouch!" แต่ละครั้งที่ผู้ใช้กด ^ C
โดยค่าเริ่มต้น SIGINT (ซึ่งสามารถสร้างได้โดยการกด ^ C) และสาเหตุ SIGTERM คาดว่าจะออก นี่เป็นเพราะกับดักต่อไปนี้ซึ่งสร้างโดยค่าเริ่มต้นเมื่อ Expect เริ่มทำงาน
กับดักออก {SIGINT SIGTERM}ถ้าคุณใช้ค่าสถานะ -D เพื่อเริ่มต้นดีบักเกอร์ SIGINT จะถูกกำหนดใหม่เพื่อเริ่มการทำงานของดีบักเกอร์แบบโต้ตอบ เนื่องจากมีกับดักต่อไปนี้:
กับดัก {exp_debug 1} SIGINTคุณสามารถเปลี่ยนแปลงกับดักการดีบักโดยกำหนดตัวแปรสภาพแวดล้อม EXPECT_DEBUG_INIT ให้กับคำสั่ง trap ใหม่
คุณสามารถแทนที่ได้ทั้งสองอย่างนี้โดยการเพิ่มคำสั่ง trap ในสคริปต์ของคุณ โดยเฉพาะอย่างยิ่งถ้าคุณมี "SIGINT exit zip" ของคุณระบบจะแทนที่ทับดีบักเกอร์ นี่เป็นประโยชน์ถ้าคุณต้องการป้องกันไม่ให้ผู้ใช้เข้าสู่โปรแกรมดีบั๊กเลย
ถ้าคุณต้องการกำหนดดักของคุณเองบน SIGINT แต่ยังคงดักจับกับดีบักเกอร์อยู่เมื่อใช้งานอยู่ให้ใช้:
ถ้า {! [exp_debug]} {trap mystuff SIGINT}หรืออีกทางเลือกหนึ่งคุณสามารถดักบั๊กได้โดยใช้สัญญาณอื่น ๆ
กับดัก จะไม่ยอมให้คุณลบล้างการกระทำของ SIGALRM เนื่องจากจะใช้ภายในเพื่อ คาดหวัง คำสั่ง disconnect จะตั้งค่า SIGALRM เป็น SIG_IGN (ละเว้น) คุณสามารถเปิดใช้งานอีกครั้งได้ตราบใดที่คุณปิดใช้งานในคำสั่งวางไข่ตามมา
ดูสัญญาณ (3) สำหรับข้อมูลเพิ่มเติม
รอ [args]
ความล่าช้าจนถึง กระบวนการ พลิกแพลง (หรือ กระบวนการ ปัจจุบันถ้าไม่มีชื่อ) จะสิ้นสุดลง
wait ปกติจะแสดงรายการสี่จำนวนเต็ม จำนวนเต็มแรกคือ pid ของ กระบวนการ ที่รอขึ้นมา จำนวนเต็มที่สองคือรหัสวางไข่ที่ตรงกัน จำนวนเต็มที่สามคือ -1 ถ้ามีข้อผิดพลาดของระบบปฏิบัติการหรือ 0 อื่น ถ้าจำนวนเต็มที่สามเป็น 0 จำนวนเต็มที่สี่คือสถานะที่ส่งกลับโดย กระบวนการที่ เกิดขึ้น ถ้าจำนวนเต็มที่สามคือ -1 จำนวนเต็มที่สี่คือค่าของ errno ที่กำหนดโดยระบบปฏิบัติการ มีการตั้งค่าตัวแปร errorCode ทั่วโลก
องค์ประกอบเพิ่มเติมอาจปรากฏที่ส่วนท้ายของค่าที่ส่งคืนจาก รอ องค์ประกอบที่ห้าเป็นตัวระบุระบุชั้นข้อมูล ขณะนี้ค่าเดียวที่เป็นไปได้สำหรับองค์ประกอบนี้คือ CHILDKILLED ซึ่งในกรณีนี้อีกสองค่าคือชื่อสัญญาณแบบ C และคำอธิบายแบบข้อความสั้น ๆ
ธง -i ประกาศ กระบวนการที่ จะรอให้สอดคล้องกับชื่อ spawn_id (ไม่ใช่รหัส กระบวนการ ) ภายในตัวจัดการ SIGCHLD สามารถรอ กระบวนการที่ เกิดขึ้นโดยใช้ spawn id -1
ค่าสถานะ -nowait ทำให้รอเพื่อกลับทันทีพร้อมด้วยการรอคอยที่สำเร็จ เมื่อ กระบวนการ ออก (ภายหลัง) จะหายไปโดยอัตโนมัติโดยไม่จำเป็นต้องรออย่างชัดเจน
คำสั่ง wait อาจถูกใช้รอ กระบวนการ forked โดยใช้อาร์กิวเมนต์ "-i -1" ซึ่งแตกต่างจากการใช้งานกับกระบวนการพลิกกลับคำสั่งนี้สามารถทำงานได้ทุกเมื่อ ไม่มีการควบคุม กระบวนการที่ จะเก็บเกี่ยว อย่างไรก็ตามคุณสามารถตรวจสอบค่าส่งคืนสำหรับรหัส กระบวนการ
ห้องสมุด
คาดหวังว่าจะรู้เกี่ยวกับไลบรารี Expect ในไลบรารีในตัวสองเครื่องโดยอัตโนมัติ เหล่านี้ถูกกำหนดโดยไดเร็กทอรีที่มีชื่อในตัวแปร exp_library และ exp_exec_library ทั้งสองหมายถึงการมีไฟล์อรรถประโยชน์ที่สามารถใช้โดยสคริปต์อื่น ๆ
exp_library มีไฟล์ที่ไม่ใช่สถาปัตยกรรม exp_exec_library มีไฟล์ที่ขึ้นกับสถาปัตยกรรม ไดเรกทอรีทั้งสองอาจว่างเปล่าทั้งนี้ขึ้นอยู่กับระบบของคุณ การมีอยู่ของไฟล์ $ exp_exec_library / cat-buffers อธิบายว่าบัฟเฟอร์ / bin / cat ของคุณเป็นค่าเริ่มต้นหรือไม่
สวยพิมพ์
คำจำกัดความของ vgrind มีให้สำหรับสคริปต์ Expect ของ Pretty-print สมมติว่าคำจำกัดความ vgrind ที่ให้มาพร้อมกับการกระจาย Expect ได้รับการติดตั้งอย่างถูกต้องคุณสามารถใช้เป็นข้อกำหนดต่อไปนี้
ไฟล์ vgrind -lexpectตัวอย่าง
หลายคนไม่เข้าใจว่าควรใส่ทุกสิ่งทุกอย่างที่หน้า คน อธิบายไว้ ผมขอแนะนำให้คุณอ่านและทดลองใช้ตัวอย่างในไดเร็กทอรีตัวอย่างของการกระจาย Expect บางส่วนเป็นโปรแกรมจริง อื่น ๆ เป็นเพียงตัวอย่างของเทคนิคบางอย่างและแน่นอนคู่เป็นเพียง hacks รวดเร็ว ไฟล์ INSTALL มีภาพรวมคร่าวๆของโปรแกรมเหล่านี้
เอกสาร Expect (ดูที่เห็น) มีประโยชน์เช่นกัน แม้ว่าเอกสารบางชิ้นจะใช้ไวยากรณ์ที่สอดคล้องกับรุ่นก่อนหน้าก็ตาม แต่เหตุผลที่มาพร้อมกับยังคงใช้งานได้และมีรายละเอียดมากกว่าหน้าคนนี้
คำเตือน
ส่วนขยายอาจขัดแย้งกับชื่อคำสั่ง Expect ตัวอย่างเช่น ส่ง ถูกกำหนดโดย Tk สำหรับวัตถุประสงค์ที่ต่างกันทั้งหมด ด้วยเหตุผลนี้คำสั่ง Expect ส่วนใหญ่จึงมีให้เป็น "exp_XXXX" คำสั่งและตัวแปรที่ขึ้นต้นด้วย "exp", "inter", "spawn" และ "timeout" ไม่มีชื่อแทน ใช้ชื่อคำสั่งแบบขยายหากต้องการความเข้ากันได้ระหว่างสภาพแวดล้อม
คาดว่า จะใช้มุมมองที่ค่อนข้างเสรีในการกำหนดขอบเขต โดยเฉพาะอย่างยิ่งตัวแปรที่อ่านโดยคำสั่งเฉพาะสำหรับโปรแกรม Expect จะถูกเรียกใช้งานครั้งแรกจากขอบเขตภายในและหากไม่พบในขอบเขตทั่วโลก เช่นนี้ obviates จำเป็นที่จะวาง "หมดเวลาทั่วโลก" ในขั้นตอนที่คุณเขียนที่ใช้ คาดหวัง ทุก ในทางกลับกันตัวแปรที่เขียนขึ้นจะอยู่ในขอบเขตท้องถิ่น (ยกเว้นกรณีที่ได้มีการออกคำสั่ง "global") สาเหตุที่พบมากที่สุดคือสาเหตุที่เกิดการวางไข่ในขั้นตอน นอกขั้นตอน spawn_id ไม่มีอยู่อีกต่อไปดังนั้น กระบวนการ spawned ไม่สามารถเข้าถึงได้อีกต่อไปเพียงเพราะขอบเขต เพิ่ม "global spawn_id" ตามขั้นตอนดังกล่าว
ถ้าคุณไม่สามารถเปิดใช้งานความสามารถในการดูข้อมูลแบบ multispawning ได้ (เช่นระบบของคุณไม่สนับสนุนการเลือก (BSD *. *), poll (SVR> 2) และสิ่งที่เทียบเท่า), Expect จะสามารถควบคุม กระบวนการ เดี่ยวได้ในแต่ละครั้งเท่านั้น ในกรณีนี้อย่าพยายามตั้งค่า spawn_id หรือคุณควรจะประมวลผลกระบวนการผ่านทาง exec ขณะที่ กระบวนการ เรียกใช้ spawned ทำงานอยู่ นอกจากนี้คุณจะไม่สามารถ คาดหวัง จากหลาย ๆ กระบวนการ (รวมถึงผู้ใช้เป็นหนึ่ง) ในเวลาเดียวกัน
พารามิเตอร์เทอร์มินัลอาจมีผลต่อสคริปต์มาก ตัวอย่างเช่นถ้ามีการเขียนสคริปต์เพื่อค้นหาการสะท้อนเสียงจะทำงานไม่ถูกต้องถ้าปิดเสียงสะท้อนอยู่ ด้วยเหตุนี้คาดหวังว่าจะบังคับพารามิเตอร์เทอร์มินัลเป็นค่าเริ่มต้น แต่น่าเสียดายที่สิ่งนี้อาจทำให้สิ่งต่างๆไม่เป็นที่พอใจสำหรับโปรแกรมอื่น ๆ ตัวอย่างเช่นเปลือก emacs ต้องการเปลี่ยนการแม็ป "ตามปกติ": บรรทัดใหม่จะถูกแม็พกับบรรทัดใหม่แทนที่จะเป็นบรรทัดใหม่ของการรับส่งข้อมูลการรับส่งและการปิดกั้นการสะท้อนจะถูกปิดใช้งาน วิธีนี้จะช่วยให้สามารถใช้ emacs เพื่อแก้ไขสายป้อนข้อมูลได้ น่าเสียดายที่ Expect ไม่สามารถเดาได้
คุณสามารถขอให้ Expect ไม่แทนที่การตั้งค่าเริ่มต้นของพารามิเตอร์เทอร์มินัล แต่คุณต้องระมัดระวังในการเขียนสคริปต์สำหรับสภาพแวดล้อมดังกล่าว ในกรณีของ emacs หลีกเลี่ยงการขึ้นอยู่กับสิ่งต่างๆเช่นการจับคู่แบบสะท้อนและการสิ้นสุดของเส้น
คำสั่งที่ยอมรับอาร์กิวเมนต์มีความยาวเป็นรายการเดียว ( คาดว่า ตัวแปรและ โต้ตอบ ) ใช้ heuristic เพื่อตัดสินใจว่ารายการนั้นเป็นอาร์กิวเมนต์หนึ่งหรือหลายรายการ heuristic สามารถล้มเหลวเฉพาะในกรณีที่รายการจริงแสดงอาร์กิวเมนต์เดียวที่มีการฝังตัวแบบหลายตัว \ n ซึ่งมีอักขระที่ไม่ใช่ตัวเว้นวรรคระหว่างพวกเขา ดูเหมือนจะเป็นไปไม่ได้เลยทีเดียวอย่างไรก็ตามการโต้เถียง "-nobrace" สามารถใช้เพื่อบังคับให้อาร์กิวเมนต์เดี่ยวถูกจัดการเป็นอาร์กิวเมนต์เดียว นี่น่าจะใช้กับรหัส Expect ของเครื่องที่สร้างขึ้น ในทำนองเดียวกัน -brace บังคับอาร์กิวเมนต์เดียวที่จะจัดการเป็นหลายรูปแบบ / การกระทำ
ข้อบกพร่อง
มันเป็นเรื่องที่น่าสนใจที่จะตั้งชื่อโปรแกรมว่า "sex" (สำหรับ "Smart EXEC" หรือ "Send-EXpect") แต่ความรู้สึกที่ดี (หรืออาจจะเป็นแค่ Puritanism) ก็ถือว่าดีขึ้น
ในบางระบบเมื่อเปลือกเกิดขึ้นจะบ่นเกี่ยวกับการไม่สามารถเข้าถึง tty แต่ทำงานต่อไป ซึ่งหมายความว่าระบบของคุณมีกลไกในการควบคุม TTY ที่ Expect ไม่รู้จัก โปรดตรวจสอบว่ามีอะไรบ้างและส่งข้อมูลนี้กลับมาให้ฉัน
Ultrix 4.1 (อย่างน้อยรุ่นล่าสุดที่มีอยู่ที่นี่) จะถือว่าการหมดเวลาเหนือ 1000000 จะเท่ากับ 0
Digital UNIX 4.0A (และอาจเป็นเวอร์ชันอื่น) ปฏิเสธที่จะจัดสรร ptys ถ้าคุณกำหนดตัวจัดการ SIGCHLD ดูหน้า grantpt สำหรับข้อมูลเพิ่มเติม
IRIX 6.0 ไม่สามารถใช้สิทธิ์ pty ได้อย่างถูกต้องเพื่อที่ว่าถ้า Expect พยายามจัดสรร pty ที่ใช้โดยคนอื่นก่อนหน้านี้ล้มเหลว อัปเกรดเป็น IRIX 6.1
Telnet (ตรวจสอบเฉพาะภายใต้ SunOS 4.1.2) จะแฮงค์ถ้าไม่มีการตั้งค่า TERM ปัญหานี้เป็นปัญหาตาม cron ที่และในสคริปต์ cgi ซึ่งไม่ได้กำหนด TERM ดังนั้นคุณต้องตั้งค่าอย่างชัดเจนว่าเป็นประเภทใดโดยปกติไม่เกี่ยวข้อง มันก็ต้องมีการตั้งค่าให้กับบางสิ่งบางอย่าง! ต่อไปนี้อาจพอเพียงสำหรับกรณีส่วนใหญ่
ตั้งค่า env (TERM) vt100เคล็ดลับ (ตรวจสอบเฉพาะภายใต้ BSDI BSD / OS 3.1 i386) จะแฮงค์ถ้าไม่ได้ตั้งค่า SHELL และ HOME นี่เป็นปัญหาตาม cron ที่และในสคริปต์ cgi ซึ่งไม่ได้กำหนดตัวแปรสภาพแวดล้อมเหล่านี้ ดังนั้นคุณต้องตั้งค่าเหล่านี้อย่างชัดเจน - โดยปกติจะไม่เกี่ยวข้องกับประเภทใด มันก็ต้องมีการตั้งค่าให้กับบางสิ่งบางอย่าง! ต่อไปนี้อาจพอเพียงสำหรับกรณีส่วนใหญ่
ตั้งค่า env (SHELL) / bin / sh set env (HOME) / usr / local / binimplementations บางส่วนของ ptys ได้รับการออกแบบเพื่อให้เคอร์เนลพ่นเอาท์พุทที่ยังไม่ได้อ่านใด ๆ หลังจาก 10 ถึง 15 วินาที (จำนวนจริงขึ้นอยู่กับการใช้งาน) หลังจากที่ กระบวนการ ได้ปิด descriptor ไฟล์ ดังนั้น คาดว่า โปรแกรมเช่น
วางไข่วันที่ 20 คาดหวังจะล้มเหลว เพื่อหลีกเลี่ยงปัญหานี้ให้เรียกใช้โปรแกรมที่ไม่ใช่โปรแกรมโต้ตอบกับ exec แทนการ วางไข่ ในขณะที่สถานการณ์เช่นนี้เป็นไปได้ในทางปฏิบัติฉันไม่เคยพบสถานการณ์ที่ผลลัพธ์สุดท้ายของโปรแกรมโต้ตอบจริงจะหายไปเนื่องจากพฤติกรรมนี้
ในทางกลับกัน Cty UNICOS ptys จะทิ้งผลลัพธ์ที่ยังไม่ได้อ่านออกทันทีหลังจาก กระบวนการ ปิด descriptor ไฟล์ ฉันได้รายงานเรื่องนี้ต่อ Cray และพวกเขากำลังดำเนินการแก้ไข
บางครั้งต้องมีการหน่วงเวลาระหว่างการตอบสนองและการตอบสนองเช่นเมื่ออินเตอร์เฟซ tty กำลังเปลี่ยนแปลงการตั้งค่า UART หรือจับคู่อัตราการค้นหาโดยการหาบิตเริ่มต้น / หยุด โดยปกติสิ่งเหล่านี้จำเป็นต้องใช้คือการนอนหลับเป็นเวลาสองหรือสองวัน เทคนิคที่มีประสิทธิภาพมากขึ้นคือการลองใหม่จนกว่าฮาร์ดแวร์จะพร้อมรับอินพุท ตัวอย่างต่อไปนี้ใช้ทั้งสองกลยุทธ์:
ส่ง "ความเร็ว 9600 \ r"; sleep 1 expect {timeout {send "\ r"; exp_continue} $ prompt}trap-code จะไม่ทำงานกับคำสั่งใด ๆ ที่อยู่ในลูปเหตุการณ์ของ Tcl เช่นการนอนหลับ ปัญหาคือว่าในห่วงเหตุการณ์, Tcl ทิ้งรหัสส่งคืนจากตัวจัดการเหตุการณ์ async การแก้ปัญหาคือการตั้งค่าสถานะในรหัสกับดัก จากนั้นตรวจสอบธงทันทีหลังจากคำสั่ง (เช่นการนอนหลับ)
คำสั่ง expect_background จะไม่สนใจอาร์กิวเมนต์เวลาทำงานและไม่มีแนวคิดในการหมดเวลาโดยทั่วไป
& # 34; EXPECT HINTS & # 34;
มีสองสิ่งที่เกี่ยวกับ คาด ว่าอาจจะไม่ใช้งานง่าย ส่วนนี้พยายามแก้ไขปัญหาบางอย่างด้วยคำแนะนำสองข้อ
ปัญหาที่พบโดยทั่วไปคือการรู้จักการแจ้งเตือนของเชลล์ ตั้งแต่เหล่านี้จะปรับแต่งแตกต่างกันโดยคนที่แตกต่างกันและเปลือกหอยที่แตกต่างกันโดยอัตโนมัติ rlogin portably อาจเป็นเรื่องยากโดยไม่ต้องรู้พร้อมท์ การประชุมที่สมเหตุสมผลคือการให้ผู้ใช้เก็บนิพจน์ทั่วไปที่อธิบายถึงพรอมต์ (โดยเฉพาะตอนท้าย) ในตัวแปรสภาพแวดล้อม EXPECT_PROMPT สามารถใช้รหัสดังต่อไปนี้ได้ ถ้าไม่มี EXPECT_PROMPT รหัสนี้ยังคงมีโอกาสที่จะทำงานได้ดี
ตั้งค่า prompt "(% | # | \\ $) $"; # prompt prompt เริ่มต้น {set prompt $ env (EXPECT_PROMPT)} expect -re $ promptผมขอแนะนำให้คุณเขียนรูปแบบที่ คาดหวัง ซึ่งรวมถึงจุดสิ้นสุดของสิ่งที่คุณคาดหวังไว้ให้ดู วิธีนี้จะหลีกเลี่ยงความเป็นไปได้ในการตอบคำถามก่อนที่จะเห็นสิ่งทั้งปวง นอกจากนี้ในขณะที่คุณอาจตอบคำถามได้ดีก่อนที่จะเห็นพวกเขาทั้งหมดหากคุณตอบคำถามในช่วงต้นคำตอบของคุณอาจปรากฏขึ้นในระหว่างคำถาม กล่าวอีกนัยหนึ่งบทสนทนาที่ได้จะถูกต้อง แต่ดูเป็นสัญญาณรบกวน
คำแนะนำส่วนใหญ่จะรวมถึงอักขระพื้นที่ในตอนท้าย ตัวอย่างเช่นพรอมต์จาก ftp คือ 'f', 't', 'p', '>' และ เพื่อให้ตรงกับพรอมต์นี้คุณต้องระบุแต่ละอักขระเหล่านี้ เป็นข้อผิดพลาดทั่วไปที่ไม่รวมช่องว่าง ใส่ช่องว่างไว้อย่างชัดแจ้ง
ถ้าคุณใช้รูปแบบของ X * เครื่องหมาย * จะตรงกับผลลัพธ์ทั้งหมดที่ได้รับจากปลาย X ไปจนถึงสิ่งสุดท้ายที่ได้รับ เสียงนี้ฟังดูง่าย แต่อาจทำให้เกิดความสับสนเนื่องจากวลี "สิ่งสุดท้ายที่ได้รับ" อาจแตกต่างกันไปขึ้นอยู่กับความเร็วของคอมพิวเตอร์และการประมวลผล I / O ทั้งจากเคอร์เนลและไดรเวอร์อุปกรณ์
โดยเฉพาะอย่างยิ่งมนุษย์มักจะเห็นผลผลิตของโปรแกรมที่มาถึงในชิ้นใหญ่ (atomically) เมื่อในความเป็นจริงโปรแกรมส่วนใหญ่ผลิตออกหนึ่งบรรทัดในเวลา สมมติว่าเป็นกรณีนี้ * ในรูปแบบของย่อหน้าก่อนหน้านี้อาจตรงกับจุดสิ้นสุดของบรรทัดปัจจุบันถึงแม้ว่าจะดูเหมือนว่ามีมากขึ้นเนื่องจากในขณะที่มีการจับคู่ซึ่งเป็นผลลัพธ์ทั้งหมดที่ได้รับ
คาดว่า จะไม่มีทางรู้ว่าจะมีการส่งออกต่อไปเว้นแต่ว่ารูปแบบของคุณจะระบุไว้เป็นพิเศษ
แม้ว่าจะขึ้นอยู่กับการกำหนดบัฟเฟอร์ตามสายเป็นอย่างไม่ฉลาดก็ตาม โปรแกรมไม่เพียง แต่จะให้คำจำกัดความเกี่ยวกับประเภทของบัฟเฟอร์ที่ทำ แต่การย่อยอาหารของระบบอาจทำให้เส้นผลผลิตสูงขึ้นเพื่อให้เส้นแบ่งในตำแหน่งสุ่ม ดังนั้นถ้าคุณสามารถแสดงตัวอักษรสองสามตัวสุดท้ายของข้อความแจ้งเมื่อเขียนรูปแบบคุณควรทำเช่นนั้น
หากคุณกำลังรอรูปแบบในผลลัพธ์สุดท้ายของโปรแกรมและโปรแกรมจะส่งข้อมูลอื่นแทนคุณจะไม่สามารถตรวจพบว่ามีคำหลัก หมดเวลา ได้ เหตุผลก็คือ คาดว่า จะไม่หมด - แทนที่จะได้รับการบ่งชี้ eof ใช้ที่แทน ใช้ดียิ่งขึ้น ด้วยวิธีนี้ถ้าบรรทัดนั้นถูกย้ายไปรอบ ๆ คุณจะไม่ต้องแก้ไขบรรทัด
นิวไลน์มักจะถูกแปลงเป็นผลตอบแทนจากการรับส่งข้อมูลลำดับของบรรทัดคำสั่งเมื่อส่งออกโดยโปรแกรมควบคุมเทอร์มินัล ดังนั้นหากคุณต้องการรูปแบบที่ตรงกับสองบรรทัดจาก print print ("foo \ nbar") คุณควรใช้รูปแบบ "foo \ r \ nbar"
การแปลที่คล้ายคลึงกันเกิดขึ้นเมื่ออ่านจากผู้ใช้ผ่าน expect_user ในกรณีนี้เมื่อคุณกด return มันจะถูกแปลเป็น newline หาก Expect ส่งผ่านไปยังโปรแกรมที่ตั้งค่าเทอร์มินัลเป็นโหมดดิบ (เช่น telnet) จะมีปัญหาเนื่องจากโปรแกรมคาดว่าจะได้รับผลตอบแทนที่แท้จริง (บางโปรแกรมเป็นจริงให้อภัยในสิ่งที่พวกเขาจะแปล newlines เพื่อส่งกลับ แต่ส่วนมากไม่ได้) แต่น่าเสียดายที่ไม่มีวิธีใดที่จะพบว่าโปรแกรมวาง terminal ลงในโหมดดิบ
แทนที่จะใช้บรรทัดใหม่ที่ส่งคืนด้วยตนเองการแก้ปัญหาคือการใช้คำสั่ง "stty raw" ซึ่งจะหยุดการแปล อย่างไรก็ตามโปรดทราบว่านั่นหมายความว่าคุณจะไม่ได้รับคุณลักษณะการแก้ไขบรรทัดที่ปรุงเสร็จอีกต่อไป
โต้ตอบ กำหนดโดยนัยชุดขั้วของคุณไปยังโหมดดิบดังนั้นปัญหานี้จะไม่เกิดขึ้นแล้ว
มักเป็นประโยชน์ในการจัดเก็บรหัสผ่าน (หรือข้อมูลส่วนตัวอื่น ๆ ) ไว้ในสคริปต์ Expect ไม่แนะนำให้ใช้เนื่องจากมีการเก็บข้อมูลใด ๆ ไว้ในคอมพิวเตอร์ซึ่งอาจทำให้บุคคลอื่นเข้าถึงได้ ดังนั้นการโต้ตอบกระตุ้นรหัสผ่านจากสคริปต์เป็นความคิดที่ชาญฉลาดกว่าการฝังตัวอักษรอย่างแท้จริง อย่างไรก็ตามบางครั้งการฝังตัวดังกล่าวเป็นไปได้เพียงอย่างเดียว
แต่ระบบไฟล์ยูนิกซ์ไม่มีวิธีโดยตรงในการสร้างสคริปต์ที่สามารถใช้งานได้ แต่ไม่สามารถอ่านได้ ระบบที่สนับสนุนสคริปต์เชลล์ setgid อาจมีการจำลองโดยทางอ้อมต่อไปนี้:
สร้างสคริปต์ Expect (ซึ่งมีข้อมูลลับ) ตามปกติ กำหนดสิทธิ์เป็น 750 (-rwxr-x ---) และเป็นของกลุ่มที่ไว้ใจได้เช่นกลุ่มที่ได้รับอนุญาตให้อ่าน ถ้าจำเป็นให้สร้างกลุ่มใหม่เพื่อจุดประสงค์นี้ จากนั้นสร้างสคริปต์ / bin / sh พร้อมสิทธิ์ 2751 (-rwxr-s-x) ซึ่งเป็นของกลุ่มเดียวกันกับก่อน
ผลลัพธ์คือสคริปต์ที่อาจจะถูกดำเนินการ (และอ่าน) โดยทุกคน เมื่อเรียกใช้จะเรียกใช้สคริปต์ Expect
& # 34; ดูยัง & # 34;
Tcl (3), libexpect (3)
"Exploring Expect: ชุดเครื่องมือ Tcl-Based สำหรับโปรแกรมโต้ตอบอัตโนมัติ" โดย Don Libes, หน้า 602, ไอ 1-56592-090-2, O'Reilly and Associates, 1995
"คาดหวัง: การรักษาผู้ที่ไม่สามารถควบคุมการโต้ตอบ" โดย Don Libes การดำเนินการของฤดูร้อน 1990 USENIX Conference, Anaheim, California, 11-15 มิถุนายน 1990
"การใช้ คาดหวังว่า จะทำให้งานบริหารระบบอัตโนมัติ" โดย Don Libes การดำเนินการของ USENIX Conference การบริหารระบบการติดตั้งขนาดใหญ่ในปี 2533 Colorado Springs, Colorado, 17-19 ตุลาคม 1990
การประชุม USENIX, Washington, DC, 22-26 มกราคม, 1990 .. "คาดหวัง: สคริปต์สำหรับการควบคุมโปรแกรมโต้ตอบ" โดย Don Libes, Computing Systems , เล่ม "การทดสอบการถดถอยและการทดสอบโปรแกรมเชิงโต้ตอบ" โดย Don Libes การดำเนินการของฤดูร้อน 1992 USENIX Conference, pp 135-144, San Antonio, TX, 12-15 มิถุนายน, 1992 .. I "Kibitz - การเชื่อมต่อหลายโปรแกรมโต้ตอบกัน" โดย Don Libes, Software - Practice & Experience, John Wiley & Sons, West Sussex, England, Vol.
23, ฉบับที่ 5 พฤษภาคม 2536. ฉัน "ดีบักเกอร์สำหรับแอพพลิเคชัน Tcl" โดย Don Libes การดำเนินการของ Tcl / Tk Workshop 1993, Berkeley, CA, 10-11 มิถุนายน 1993
ผู้แต่ง
Don Libes, สถาบันมาตรฐานและเทคโนโลยีแห่งชาติ
กิตติกรรมประกาศ
ขอบคุณ John Ousterhout สำหรับ Tcl และ Scott Paisley สำหรับแรงบันดาลใจ ขอบคุณ Rob Savoye สำหรับรหัสการกำหนดรูปแบบอัตโนมัติของ Expect
ไฟล์ประวัติการเรียนรู้ถึงวิวัฒนาการของสิ่งที่ คาดหวัง ทำให้การอ่านที่น่าสนใจและอาจให้ข้อมูลเชิงลึกแก่ซอฟต์แวร์นี้ ขอบคุณคนที่กล่าวถึงในนั้นผู้ที่ส่งฉันแก้ไขข้อผิดพลาดและให้ความช่วยเหลืออื่น ๆ
การออกแบบและการใช้ Expect ได้รับการชำระเงินจากรัฐบาลสหรัฐฯเป็นส่วนหนึ่งดังนั้นจึงอยู่ในโดเมนสาธารณะ อย่างไรก็ตามผู้เขียนและ NIST ต้องการเครดิตถ้ามีการใช้โปรแกรมและเอกสารหรือบางส่วนของเอกสารเหล่านี้