หนึ่งซับ VS สคริปต์

25

ฉันสังเกตเห็นคำถามและคำตอบจำนวนมากและความคิดเห็นที่แสดงความรังเกียจ (และบางครั้งก็กลัว) การเขียนสคริปต์แทนการใช้ liners คนเดียว ดังนั้นฉันต้องการทราบ:

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

คำนิยาม

one-liner: ลำดับของคำสั่งใด ๆ ที่พิมพ์หรือวางโดยตรงลงในเปลือกบรรทัดคำสั่ง มักเกี่ยวข้องกับท่อและ / หรือการใช้ภาษาเช่นsed, awk, perlและ / หรือเครื่องมือเช่นgrepหรือหรือcutsort

มันเป็นการดำเนินการโดยตรงบนบรรทัดคำสั่งที่เป็นลักษณะการกำหนด - ความยาวและการจัดรูปแบบไม่เกี่ยวข้อง "หนึ่งซับ" อาจอยู่ในหนึ่งบรรทัดหรืออาจมีหลายบรรทัด (เช่น sh สำหรับลูปหรือฝัง awk หรือรหัส sed ด้วยบรรทัดฟีดและการเยื้องเพื่อปรับปรุงการอ่าน)
script: ลำดับของคำสั่งในภาษาที่ตีความใด ๆ ที่บันทึกไว้ในไฟล์และดำเนินการ สคริปต์อาจถูกเขียนทั้งหมดในภาษาเดียวหรืออาจเป็นตัวหุ้มสคริปต์เชลล์รอบ ๆ "หนึ่งสมุทร" โดยใช้ภาษาอื่น ๆ

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

scripting conventions

— CAS
แหล่งที่มา

10

ที่เกี่ยวข้อง: ใน Bash เมื่อนามแฝงเมื่อสคริปต์และเมื่อใดที่จะเขียนฟังก์ชั่น?

— cas

4

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

— wjandrea

2

อะไรก็ตามที่ฉันต้อง google (โดยทั่วไปบาง regex) และอาจนำมาใช้ในรูปทรงหรือตัวแปรฉันจะบันทึกในไฟล์สคริปต์ในระบบคลาวด์ (ดรอปบ็อกซ์, google cloud, อะไรก็ตาม) ความเห็นมีคำหลักที่ฉันรู้ว่าฉันจะใช้เมื่อฉันต้องการมันอีกครั้ง มันประหยัดเวลาอีก 5 + นาทีในการชั่งน้ำหนักตัวเลือกของฉันระหว่างคำตอบที่คล้ายกันหลายแบบและหลีกเลี่ยงข้อผิดพลาดหรือสร้างตัวแปรที่จำเป็นเนื่องจากฉันไม่พบตัวแปรที่ถูกเขียนอย่างดีที่ฉันต้องการ

— user3445853

3

@wjandrea วิธีเพิ่ม: regexes Perl มีไวยากรณ์เฉพาะสำหรับพวกเขาที่รวมถึงการดำเนินการเพื่อดำเนินการอื่น ๆ ในงูหลามคุณต้องนำเข้าและเขียนฟังก์ชั่นการโทรด้วยตัวอักษรสตริงเป็นอาร์กิวเมนต์ที่ใช้ตัวอักษรมากขึ้น สมุทรหนึ่งส่วนใหญ่ใช้ regexes มากมายเพื่อจัดการกับข้อความดังนั้นนี่จึงเป็น "ปัญหาใหญ่"

— Giacomo Alzetta

1

@wjandrea Python ไม่ได้เลวร้ายนักสำหรับผู้ใช้งานคนเดียวไม่ได้ใช้ความสามารถในการเขียน โดยเฉลี่ยแล้วฉันสามารถแปลงสคริปต์ 4-5 บรรทัดให้กลายเป็นหนึ่งซับในได้ แต่อย่างที่คุณพูดมันชัดเจนกว่าภาษาอื่น (ซึ่ง IMHO เป็นหนึ่งในข้อดีของ Python) ดังนั้นพวกเขาสามารถนับจำนวนอักขระได้ถึงสองหรือสามเท่ากว่าพูด Perl หรือ awk (ซึ่งไม่จำเป็นต้องนำเข้าบางไลบรารีซึ่งแตกต่างจาก Python) และนั่นคือสิ่งที่คนส่วนใหญ่บ่นเกี่ยวกับ - ความยาวของหนึ่ง liners เหล่านั้น แต่จากนั้นอีกครั้ง IMHO เป็นเรื่องเล็กน้อยที่จะโต้แย้งเกี่ยวกับจำนวนตัวละคร หากสิ่งที่ใช้งานได้ - ใช้งานได้

— Sergiy Kolodyazhnyy

33

การตอบสนองอีกอย่างจากประสบการณ์จริง

ฉันจะใช้หนึ่งซับถ้ามันเป็น "ทิ้ง" รหัสที่ฉันสามารถเขียนตรงที่พรอมต์ ตัวอย่างเช่นฉันอาจใช้สิ่งนี้:

for h in host1 host2 host3; do printf "%s\t%s\n" "$h" "$(ssh "$h" uptime)"; done

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

#!/bin/bash
# Check the uptime for each of the known set of hosts
########################################################################
#
hosts=(host1 host2 host3)

for h in "${hosts[@]}"
do
    printf "%s\t" "$h"
    uptime=$(ssh -o ConnectTimeout=5 -n "$h" uptime 2>/dev/null)
    printf "%s\n" "${uptime:-(unreachable)}"
done

การพูดทั่วไปอาจพูดได้

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

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

— roaima
แหล่งที่มา

นี่เป็นตัวอย่างการใช้งานที่ดีของวิธีการที่ซับไลน์ที่รวดเร็วและสกปรกสามารถพัฒนาเป็นสคริปต์ที่แข็งแกร่งยิ่งขึ้น

— Anthony G - ความยุติธรรมสำหรับโมนิก้า

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

— Monty Harder

@MontyHarder สำหรับกรณีเช่นนี้ฉันมักจะบันทึกเป็นสคริปต์แล้วเก็บไว้ใน repo คอมไพล์ ฉันสามารถติดตั้งลงในเครื่องใดก็ได้ที่ฉันต้องการผ่านโคลนคอมไพล์ง่ายๆ นั่นคือการทำงาน สำหรับการใช้งานส่วนตัวฉันไม่เคยเขียนโค้ดในไฟล์ "สูตร" (ฉันไม่ได้ใช้ตัวอย่างโค้ด github) ฉันบันทึกสคริปต์ทั้งหมดของฉันในไดเรกทอรี $ HOME / bin ที่ฉันเก็บไว้ตั้งแต่สมัยเรียนวิทยาลัยในปี 1997 (ในมหาวิทยาลัย SunOS) ผมมีความคิดจากนวนิยาย Neuromancer ที่ทั้งตัวเอกและศัตรูเก็บไว้สคริปต์ส่วนบุคคล / โปรแกรมที่จะใช้เป็นอาวุธ

— slebetman

1

แม้ว่ามันจะแน่นอนสัมผัสกับการสนทนาที่เกิดขึ้นจริงในสคริปต์ตัวอย่างของคุณคุณสามารถใช้set -- host1 host2 host3แล้วfor h in "$@"(หรือเพียงแค่for h) ซึ่งจะทำให้สคริปต์ POSIX แบบพกพา :-)

— wchargin

2

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

— FreeSoftwareServers

10

เขียนสคริปต์เมื่อ:

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

เขียนหนึ่งซับเมื่อ:

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

— dr01
แหล่งที่มา

ปกติแล้วมันจะง่ายต่อการแก้ไขสิ่งที่สิ่งที่หนึ่งซับทำงาน จุดที่ "ผ่านพารามิเตอร์" สำหรับสคริปต์อาจจะเป็น "คุณต้องการทำแพคเกจให้ใช้ง่ายในภายหลัง" ฉันเขียน "one-liners" ที่รวมถึงการกำหนดฟังก์ชั่นเชลล์และเรียกมันว่า แม้ว่าตอนนี้ฉันจะคิดถึงมันแล้ว แต่ก็มีอีกหนึ่งเรื่องที่ต้องตัดสินใจหลังจากทำซ้ำหลาย ๆ ครั้งและฉันควรใส่มันลงในสคริปต์

— Peter Cordes

9

เมื่อชุดคำสั่งที่ต้องการค่อนข้างสั้นและ / หรือสร้างผลลัพธ์ที่สามารถใช้งานได้เป็นส่วนหนึ่งของไพพ์ไลน์ขนาดใหญ่หรือนามแฝงคำสั่งอาจเป็นซับในที่ดี

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

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

ใน Python การเยื้องเป็นส่วนหนึ่งของไวยากรณ์ดังนั้นคุณจึงไม่สามารถใช้คุณสมบัติของภาษาได้อย่างเต็มที่หากคุณเขียนหนึ่งบรรทัด

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

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

ดีที่สุดมักจะเป็นศัตรูของดีพอและสิ่งนี้ใช้มากที่นี่

และถ้าคุณคุ้นเคยกับ Perl คุณอาจเคยได้ยิน TMTOWTDI: มีมากกว่าหนึ่งวิธีที่ต้องทำ

— Telcom
แหล่งที่มา

บวกหนึ่งสำหรับการกล่าวถึง "หรือฟังก์ชั่นเปลือก"

— เกล็นแจ็

7

โปรดทราบว่านี่เป็นความเห็นส่วนตัว เอาไปด้วยเม็ดเกลือ

หากคำสั่งพอดีภายในพูด 80 ตัวอักษรใช้หนึ่งซับ บรรทัดคำสั่งยาวนั้นใช้งานได้ยาก นอกจากนี้ยังมีปัญหาเรื่องการเกิดซ้ำอีกดู # 2
หากคุณต้องการเรียกใช้คำสั่งมากกว่าหนึ่งครั้งให้ใช้สคริปต์ มิฉะนั้นให้ใช้หนึ่งซับให้เงื่อนไขตรง # 1
นี่เป็นเรื่องส่วนตัวมากแต่ใช่ฉันเห็น shell, Perl หรือ awk ว่าเป็นเครื่องมือสำหรับการใช้งานแบบเดียวของฉัน
ดู # 1, # 2, # 3

— schaiba
แหล่งที่มา

3

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

— cas

2

โหวตขึ้นแม้ว่าจุดที่ 4 ดูเหมือนไม่มีจุดหมาย :)

— Anthony G - ความยุติธรรมสำหรับโมนิกา

@cas: มีการควบคุมลูกศรคีย์ (หรือ Alt + f / Alt + B) คุณสามารถย้ายไปรอบ ๆ ในหนึ่งซับมากอย่างรวดเร็ว โดยเฉพาะอย่างยิ่งถ้าคุณมีการตั้งค่าการทำซ้ำอัตโนมัติที่สำคัญที่ 50 / วินาทีโดยมีความล่าช้าสั้น ๆ เช่น 220ms คุณยังสามารถใช้การค้นหาการควบคุม / s-control-r ภายในหนึ่งซับแม้ว่ามันจะนำคุณกลับไปสู่ประวัติศาสตร์อื่น หากคุณใช้งานได้ดีกับ control-w, alt + backspace, alt + d และ control-y คุณสามารถทำได้หลายอย่างด้วยการเลื่อนเคอร์เซอร์ของคีย์บอร์ด

— Peter Cordes

นอกจากนี้ IIRC เชลล์บางตัว (เช่น ZSH ที่ฉันคิดว่า) มีปุ่มลัดเพื่อเรียกใช้ตัวแก้ไขในบรรทัดคำสั่งปัจจุบันทำให้คุณสามารถเขียน "หนึ่งซับ" ในตัวแก้ไขที่คุณชื่นชอบ ลูกศรและการแก้ไข (ความสามารถในการแก้ไขสำหรับการเรียกใช้ซ้ำคือสิ่งที่ทำให้หนึ่ง liners ยอดเยี่ยมเทียบกับการจัดการตัวเลือกบรรทัดคำสั่งในสคริปต์) IIRC, bash มีการแก้ไขภายนอกเช่นกัน แต่ไม่ผูกพันกับสิ่งใดโดยค่าเริ่มต้น

— Peter Cordes

@PeterCordes การเลื่อนเคอร์เซอร์อย่างรวดเร็วไม่ได้เริ่มเปรียบเทียบกับสิ่งที่คุณสามารถทำได้ในโปรแกรมแก้ไขที่ดีเช่น vi / vim btw, ^ X ^ E เรียกใช้ $ EDITOR หรือ $ VISUAL ใน bash (และเชลล์อื่น ๆ บาง zsh ด้วยฉันคิดว่า. สามารถกำหนดค่าได้) มันเป็นวิธีที่ดีในการเปลี่ยนความยุ่งเหยิงที่อ่านไม่ได้ที่ฉันสร้างขึ้นเป็นสิ่งที่เข้าใจได้โดยการแทรกฟีดบรรทัดและการเยื้อง BTW หน้าต่างเทอร์มินัลของฉันมีความกว้างมากกว่า 250 ตัวอักษรดังนั้นหนึ่งใน liners ของฉันสามารถใช้งานได้นานมากแม้จะไม่มีการหุ้ม

— cas

7

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

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

ฉันตั้งค่าประวัติเชลล์ของฉันให้เกิน 5,000 บรรทัดโดยแยกประวัติต่อเทอร์มินัลและต่อการเข้าสู่ระบบจากระยะไกลและอื่น ๆ ฉันเกลียดที่ไม่สามารถค้นหาในประวัติศาสตร์เหล่านี้ได้ด้วยคำสั่งบรรทัดเดียวที่ฉันพัฒนาขึ้นเมื่อสองสามสัปดาห์ก่อนและไม่คิดว่าฉันจะต้องการอีกครั้งดังนั้นกลยุทธ์ของฉัน

บางครั้งกลุ่มคำสั่งทั้งหมดจำเป็นต้องทำบางสิ่งเช่นกำหนดค่าฮาร์ดแวร์บางอย่าง ในตอนท้ายฉันก็คัดลอกพวกเขาทั้งหมดออกไปจากประวัติศาสตร์ทำความสะอาดมันให้น้อยที่สุดและเพิ่มลงในเชลล์สคริปต์RUNMEเช่นเดียวกับบันทึกสิ่งที่ฉันทำ แต่ก็เพื่อให้พวกเขาเกือบพร้อมที่จะใช้งานได้อีกครั้ง (นี่คือสาเหตุที่ฉันพบเครื่องมือที่ให้ GUI เพื่อกำหนดค่าให้พวกเขาเจ็บปวดเท่านั้น) ฉันพบว่านี่เป็นประโยชน์ที่เหลือเชื่อในประสิทธิภาพเนื่องจากบ่อยครั้งที่สิ่งที่คุณคาดว่าจะทำเพียงครั้งเดียวต้องทำอีก 5 ครั้ง .. .

— meuh
แหล่งที่มา

1

+1 หนึ่ง liners เหมาะสำหรับลูกศรขึ้นและแก้ไขเทียบกับการใช้ตัวเลือกบรรทัดคำสั่งสำหรับสคริปต์เพื่อควบคุมสิ่งที่มันทำแยกต่างหากจากสิ่งที่มันทำงาน เช่นการเปลี่ยนแปลงlnvs. ln -sสำหรับฮาร์ดลิงก์หรือซอฟต์ลิงก์ในหนึ่งซับที่วนรอบไฟล์บางไฟล์

— Peter Cordes

5

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

ความล้มเหลวในการจัดทำเอกสารเวิร์กโฟลว์ (เป็นสคริปต์หรือเทียบเท่า) ทำให้การแนะนำพนักงานใหม่ในโครงการทำได้ยากขึ้นและทำให้ยากที่จะเปลี่ยนผู้คนออกจากโครงการ นอกจากนี้ยังทำให้การตรวจสอบทุกประเภทยากและการติดตามข้อบกพร่องอาจเป็นไปไม่ได้

สิ่งนี้ไม่ว่าจะใช้ภาษาใดในการเขียนโปรแกรม

สถานที่ทำงานอื่น ๆ อาจมีประเพณีหรือความคาดหวังที่คล้ายกัน / ต่างกัน

ที่บ้านคุณทำสิ่งที่คุณรู้สึกเหมือน

ตัวอย่างเช่นฉันเขียนสคริปต์ทันทีที่ฉันทำสิ่งที่ไม่สำคัญในเชลล์เช่นก่อนที่จะส่งคำตอบสำหรับคำถาม U&L หรือเมื่อใดก็ตามที่ฉันต้องการทดสอบแต่ละองค์ประกอบของคำสั่งหรือชุดคำสั่งก่อนที่จะเรียกใช้ "สำหรับ จริง".

ฉันยังเขียนสคริปต์สำหรับงานซ้ำ ๆ ที่ฉันต้องการทำแบบเดียวกันทุกครั้งแม้ว่ามันจะง่ายเหมือน

อัปเดตระบบ OpenBSD ของฉันและแพ็คเกจที่ติดตั้งทั้งหมด (คำสั่งสั้น ๆ นี้มีให้ถึงสามคำสั่งและผู้อื่นจำนวนหนึ่งสำหรับทำความสะอาด, รวบรวมในสคริปต์สั้น ๆ ) หรือ
การสำรองข้อมูลระบบของฉันไปยังที่เก็บข้อมูลนอกสถานที่ (โดยปกติแล้วเป็นคำสั่งเดียวแต่อีกครั้งด้วยการดูแลทำความสะอาดค่อนข้างมากและสคริปต์ยังช่วยให้ฉันสามารถแตกต่างระหว่างสแน็ปช็อต ฯลฯ และจำเป็นต้องทำงานอย่างแตกต่างกันในระบบที่แตกต่างกัน ฉันเรียกใช้จากงาน cron) หรือ
การดึงเมล (อีกครั้งโดยพื้นฐานแล้วคือคำสั่งเดียว แต่ฉันต้องการให้มันทำงานแตกต่างกันเมื่อถูกเรียกว่าเป็นงาน cron และเมื่อฉันใช้มันจากบรรทัดคำสั่งและไม่ควรพยายามดึงเมลในบางสถานการณ์และมันเขียน ข้อความบันทึกสั้น ๆ ไปยังไฟล์)

ฉันใช้ฟังก์ชั่นเชลล์ (นามแฝงที่ไม่ค่อยมีคนรู้จัก) เพื่อความสะดวกสบายในเชลล์แบบอินเทอร์แอคทีฟเช่นเพื่อเพิ่มตัวเลือกให้กับคำสั่งบางอย่างโดยค่าเริ่มต้น ( -Fสำหรับls) หรือสำหรับการสร้างรูปแบบพิเศษของคำสั่งบางอย่าง ( pmanนี่คือmanคำสั่ง .

— Kusalananda
แหล่งที่มา

5

ดูเหมือนว่าฉันถือมุมมองของชนกลุ่มน้อยเกี่ยวกับเรื่องนี้

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

ภายในทีมฉันชอบเขียนซอฟต์แวร์ด้วยกระบวนการตรวจสอบโค้ดที่บังคับใช้โดยเครื่องมือ (github / gitlab / gerrit) สิ่งนี้ทำให้การควบคุมเวอร์ชันเป็นโบนัส หากคุณมีหลายระบบให้เพิ่มเครื่องมือการปรับใช้อย่างต่อเนื่อง และห้องทดสอบบางชุดหากระบบเป้าหมายมีความสำคัญ ฉันไม่ใช่คนเคร่งศาสนา แต่คำนึงถึงประโยชน์และต้นทุน

หากคุณมีทีมงานผู้ดูแลระบบสิ่งที่ง่ายที่สุดvim /root/bin/x.shคือภัยพิบัติในแง่ของการสื่อสารที่เกี่ยวข้องกับการเปลี่ยนแปลงการอ่านรหัสและการกระจายข้ามระบบ บ่อยครั้งที่การทำงานผิดพลาดที่ร้ายแรงทำให้เสียเวลา / เงินมากกว่ากระบวนการ "หนักหน่วง" ที่คาดคะเน

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

ความแตกต่างที่สำคัญระหว่าง (ไม่ได้ตรวจสอบ!) one-liners และซอฟต์แวร์ที่ได้รับการตรวจสอบ ("สคริปต์"): ความรับผิดชอบจะเกิดขึ้นกับคุณอย่างสมบูรณ์เมื่อคุณเรียกใช้งานหนึ่ง-liners คุณไม่สามารถพูดกับตัวเอง "ฉันเพิ่งพบนี้อยู่ที่ไหนสักแห่งหนึ่งซับผมวิ่งได้โดยไม่ต้องทำความเข้าใจสิ่งที่ตามมาไม่ได้เป็นความผิดของฉัน" - คุณรู้ว่าคุณกำลังใช้งานซอฟแวร์บิตของก่อนสอบทานและยังไม่ทดลองดังนั้นมันเป็นความผิดของคุณ ตรวจสอบให้แน่ใจว่ามีขนาดเล็กพอที่คุณจะสามารถเห็นผลลัพธ์ได้

คุณต้องใช้วิธีการที่ง่าย ๆ นี้ในบางครั้งและการตั้งค่าแถบที่ข้อความประมาณหนึ่งบรรทัดใช้งานได้ดีในทางปฏิบัติ (นั่นคือขอบเขตระหว่างโค้ดที่ตรวจทานและไม่ผ่านการตรวจสอบ) ผู้เดินสมุทรรายหนึ่งของฉันบางคนดูน่าเกรงขาม แต่พวกเขาทำงานได้อย่างมีประสิทธิภาพสำหรับฉัน ตราบใดที่ฉันห้อมล้อมพวกเขาและฉันไม่ได้ผลักมันไปยังเพื่อนร่วมงานรุ่นน้องอีกต่อไปมันก็ใช้ได้ ช่วงเวลาที่ฉันต้องการแบ่งปัน - ฉันต้องผ่านกระบวนการพัฒนาซอฟต์แวร์มาตรฐาน

— kubanczyk
แหล่งที่มา

1

ข้อดี: ฉันชอบคำว่า "โปรแกรม" เหนือ "สคริปต์" ด้วยตัวเอง

— เกล็นแจ็

5

ฉันต้องบอกว่าฉันค่อนข้างตกใจกับความหมายของส่วนแรกของคำถาม ภาษาสคริปต์ Unix เป็นภาษาการเขียนโปรแกรมเต็มรูปแบบและภาษาการเขียนโปรแกรมเป็นภาษาซึ่งหมายความว่าพวกเขาเกือบจะไม่สามารถดัดแปลงได้และมีความยืดหยุ่นเหมือนภาษามนุษย์ และหนึ่งในจุดเด่นของ "ความยืดหยุ่นและความยืดหยุ่นที่ไม่มีขีด จำกัด " ก็คือมันแทบจะไม่เคย "มีวิธีที่ถูกต้อง" ในการแสดงบางอย่าง - มีหลายวิธีและนี่คือสิ่งที่ดี! ใช่แน่นอนมันเป็นเรื่องของความชอบส่วนตัวและไม่มีอะไรผิดปกติกับเรื่องนั้น ใครก็ตามที่บอกว่ามีวิธีการทำสิ่งเดียวเท่านั้น

กาลครั้งหนึ่งฉันเอง~/binก็เต็มไปด้วยสคริปต์เล็ก ๆ น้อย ๆ ที่มีประโยชน์ที่ฉันเขียน แต่ฉันรู้ว่าส่วนใหญ่ของพวกเขาได้ใช้วันที่ฉันเขียนพวกเขาและไม่เคยอีกครั้ง ดังนั้นยิ่งเวลาผ่านไปbinไดเรกทอรีของฉันก็เล็กลง

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

เหตุผลที่ฉันไม่ได้เขียนสคริปต์มากขึ้น (และฉันเดาว่าชอบ "one-liners"):

binความยุ่งเหยิงของไดเรกทอรีมีค่าใช้จ่าย ฉันไม่ได้ใส่ของที่นั่นอีกเว้นแต่พวกเขาจะอยู่ที่นั่นจริงๆ
ภาษาสคริปต์ที่ผมใช้เป็นภาษาที่ฉันใช้ ; ตอนนี้ฉันเป็นมิตรกับพวกเขาจริงๆ พิมพ์ซ้ำหนึ่งครั้งเมื่อใดก็ตามที่ฉันต้องการไม่รู้สึกเหมือนทำงาน ฉันไม่รู้สึกว่าได้รับคำสั่งให้รักษาและบันทึกและใช้สคริปต์เพียงเพื่อลดภาระการพิมพ์อีกครั้ง (เหนือสิ่งอื่นใดในบางครั้งภาระการพิมพ์ซ้ำจะน้อยกว่าภาระหน่วยความจำในการจดจำว่าสคริปต์คืออะไร)
อีกเหตุผลหนึ่งที่การพิมพ์ซ้ำสิ่งต่าง ๆ ไม่รู้สึกว่าเป็นภาระ: ประวัติคำสั่ง มีหนึ่งตอร์ปิโดมากมายที่ฉันไม่ได้ประพันธ์เป็นสคริปต์แม้ว่าฉันจะใช้มันทุกวัน แต่ฉันไม่จำเป็นต้องพิมพ์ซ้ำ ฉันแค่จำพวกเขาจากประวัติศาสตร์ ด้วยวิธีนี้พวกเขาเป็นสคริปต์หรือนามแฝงของคนจน

— สตีฟซัมมิท
แหล่งที่มา

4

ฉันเชื่อว่าส่วนใหญ่เวลาขอ "หนึ่งซับ" ในความเป็นจริงการร้องขอสำหรับ "กัดเสียง" นั่นคือ:

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

ผู้คนต้องการและขอรหัสสั้นที่สุดที่แสดงวิธีแก้ปัญหาสำหรับคำถามที่ถาม

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

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

ดังนั้นเขียน "หนึ่งซับ" เพื่อถ่ายทอดความคิดหรือแนวคิด

เขียนรหัสทั่วไปของคุณเป็นสคริปต์แบบเต็มไม่ใช่แบบเส้นเดียว

— Isaac
แหล่งที่มา

1

คุณถามถึง "ความกลัวและการดูหมิ่นสคริปต์" นี่เป็นเพราะสถานการณ์ Q + A ซึ่งบ่อยครั้งที่คำตอบนั้นต้องการ : ขั้นตอนนี้และสิ่งนี้ แต่ฉันยังสามารถใส่มันในหนึ่งบรรทัด (เพื่อให้คุณสามารถคัดลอกวางและใช้มันเป็นคำสั่งที่ง่ายยาว

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

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

ไฟล์ประวัติเชลล์คือ "หนึ่ง liners" แต่ยังคงถูกบันทึกไว้ ฟังก์ชั่นทุบตีoperate-and-get-next (C-o)ช่วยให้คุณทำซ้ำได้แบบกึ่งอัตโนมัติ

ฉันแทบจะไม่เห็นคำว่าฟังก์ชันที่กล่าวถึง นั่นคือวิธีในการจัดเก็บ "สคริปต์" และ "หนึ่งสมุทร" และด้วยการกดปุ่มไม่กี่ครั้งคุณสามารถสลับระหว่างรูปแบบทั้งสองได้ คำสั่งผสมมักจะสามารถเหมาะสมทั้ง

history -r fileเป็นวิธีในการอ่านบรรทัดคำสั่งหนึ่งหรือหลายบรรทัด (และความคิดเห็น) จากไฟล์ใด ๆ ไม่ใช่แค่จากไฟล์ประวัติเริ่มต้น มันใช้เวลาเพียงเล็กน้อยในการจัดระเบียบ คุณไม่ควรพึ่งพาไฟล์ประวัติขนาดใหญ่และการค้นหาประวัติเพื่อดึงข้อมูลบรรทัดคำสั่ง (บางส่วน)

ควรกำหนดฟังก์ชั่นในลักษณะที่คล้ายกัน สำหรับผู้เริ่มให้ใส่thisfunc() {...}ไฟล์ "ฟังก์ชั่น" ลงในโฮม dir ของคุณแล้วส่งมา ใช่นี่คือค่าใช้จ่ายบางส่วน แต่มันเป็นวิธีการแก้ปัญหาทั่วไป

หากคุณเก็บทุกบรรทัดคำสั่งและทุกรูปแบบสคริปต์ในไฟล์แยกต่างหากมันเป็นของเสีย (ในทางทฤษฎี แต่มีวัตถุประสงค์) ของบล็อกระบบไฟล์

หนึ่งซับมีอะไรอย่างรวดเร็วและสกปรกด้วยตัวเอง มันเป็นส่วนคัดลอกวางที่ขมวดคิ้วมากขึ้นและวิธีที่เราพึ่งประวัติคำสั่งเพื่อบันทึกสำหรับเรา

@sitaram: สายการบินเดียวของคุณมีคุณสมบัติที่ไม่ยกเลิกการเดินทาง : สาย shebang, ขึ้นบรรทัดใหม่, การเรียกยูทิลิตี้สี่สาย - สองตัวเลือกคือ "โปรแกรม" ฉันคิดว่าสคริปต์ Perl ต้นฉบับดูดีกว่าและวิ่งเร็วขึ้นและไม่เสียไบต์ใด ๆ ด้วยการแพร่กระจายใน 60 บรรทัด และ Perl ยังช่วยให้คุณบีบได้ไม่น้อย

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

10 นาที ในภายหลัง: ฉันแค่ต้องการตรวจสอบว่าฉันสามารถพูดได้ว่า "สองโปรแกรม sed" หรือเป็น "สองทดแทน / โทร sed" แต่คำตอบของ sitaram หายไป คำตอบของฉันยังคงสมเหตุสมผลฉันหวังว่า

— rastafile
แหล่งที่มา