การเขียนสคริปต์หลัก:เพิ่มผลผลิตโดยการทำงานซ้ำ ๆ โดยอัตโนมัติ

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

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

สคริปต์คืออะไร

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

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

ทำไมต้องเขียนสคริปต์

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

ข้อดีของสคริปต์

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

2. ประสิทธิภาพ:นอกจากนี้ยังช่วยให้คุณประหยัดเวลาด้วยการทำงานอัตโนมัติซึ่งโดยปกติแล้วคุณจะต้องทำด้วยตนเอง

3. การลดข้อผิดพลาด:สคริปต์สามารถช่วยลดข้อผิดพลาดของมนุษย์ผ่านการดำเนินการตามคำสั่งอย่างสม่ำเสมอ

4. ความยืดหยุ่น:สคริปต์สามารถปรับให้เข้ากับงานได้หลากหลายโดยมีการปรับเปลี่ยนเพียงเล็กน้อย

5. การบูรณาการ:นอกจากนี้ยังสามารถผสานรวมกับระบบ เครื่องมือ หรือเวิร์กโฟลว์อื่นๆ ได้อย่างราบรื่น

ความท้าทายกับสคริปต์

1. ประสิทธิภาพ:สคริปต์อาจช้ากว่าโปรแกรมที่คอมไพล์แล้วเนื่องจากค่าใช้จ่ายในการแปล

2. ความสามารถในการปรับขนาด:ไม่เหมาะกับงานขนาดใหญ่หรืองานที่ซับซ้อนสูงเสมอไป

3. การดีบัก:บางครั้งสคริปต์การดีบักอาจมีความท้าทายเนื่องจากลักษณะไดนามิกของสคริปต์

4. ความเสี่ยงด้านความปลอดภัย:สคริปต์ที่เขียนไม่ดีอาจทำให้เกิดช่องโหว่ โดยเฉพาะอย่างยิ่งหากสคริปต์ดำเนินการคำสั่งระดับระบบ

เมื่อใดควรใช้และไม่ใช้สคริปต์

สคริปต์เหมาะสำหรับ:

1. งานมีความเรียบง่าย มีการกำหนดชัดเจน หรือทำเพียงครั้งเดียว

2. การสร้างต้นแบบหรือการทำให้กระบวนการเป็นอัตโนมัติอย่างรวดเร็ว

3. ขอบเขตมีขนาดเล็กพอที่จะหลีกเลี่ยงความซับซ้อน

สคริปต์ไม่เหมาะสำหรับ:

1. งานที่มีความสำคัญต่อประสิทธิภาพซึ่งต้องการประสิทธิภาพสูง แทนที่จะใช้สคริปต์ ให้ลองใช้เครื่องมือ ETL (แยก, แปลง, โหลด) โดยเฉพาะ หรือนายหน้าข้อความ หรือเครื่องมือทางเลือกที่คล้ายกันที่เหมาะกับกรณีการใช้งานของคุณ

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

3. สถานการณ์ที่ต้องการการบำรุงรักษาระยะยาว ซึ่งโปรแกรมที่คอมไพล์แล้วอาจมีความเสถียรมากกว่า ให้ใช้ตัวกำหนดเวลางานหรือตัวจัดการเวิร์กโฟลว์ เช่น ฟังก์ชัน CRON, Airflow, AWS Lambda/GCP แทน

วิธีการเขียนสคริปต์ที่มีประสิทธิภาพ

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

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

2. เลือกภาษาที่ถูกต้อง:

   • ทุบตี: เหมาะสำหรับงานระดับระบบ เช่น การทำงานของไฟล์หรือการจัดการเซิร์ฟเวอร์

   • หลาม: เหมาะสำหรับการประมวลผลข้อมูล การขูดเว็บ และระบบอัตโนมัติที่ซับซ้อนยิ่งขึ้น

   • จาวาสคริปต์: เหมาะสำหรับการพัฒนาเว็บและระบบอัตโนมัติบนเบราว์เซอร์

3. เขียนสคริปต์:ใช้โปรแกรมแก้ไขข้อความหรือ Integrated Development Environment (IDE) และตรวจสอบให้แน่ใจว่าคุณปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด เช่น การใช้ความคิดเห็น ชื่อตัวแปรที่มีความหมาย และโค้ดโมดูลาร์ เราจะกล่าวถึงสิ่งเหล่านี้ด้านล่าง

4. ทดสอบสคริปต์:ทดสอบสคริปต์ในสภาพแวดล้อมที่มีการควบคุมเพื่อให้แน่ใจว่าสคริปต์ทำงานได้ตามที่คาดไว้โดยไม่ก่อให้เกิดข้อผิดพลาด

5. ดำเนินการและปรับใช้:เรียกใช้สคริปต์ในสภาพแวดล้อมที่ต้องการ หากจำเป็น ให้กำหนดเวลาการดำเนินการโดยใช้เครื่องมือ เช่น Cron (สำหรับ Bash) หรือตัวกำหนดเวลางาน

สคริปต์ตัวอย่าง

ตอนนี้คุณรู้พื้นฐานแล้ว เรามาฝึกฝนกันดีกว่า สมมติว่าคุณมีไฟล์ชื่อ "book-part-1.pdf", "book-part-2.pdf", …, "book-part-100.pdf" ประมาณ 100 ไฟล์ คุณต้องการแทนที่เครื่องหมายขีดกลาง (-) ทั้งหมดในชื่อไฟล์ด้วยเครื่องหมายขีดล่าง (_) เนื่องจากเว็บไซต์ที่คุณพยายามอัปโหลดเอกสารเหล่านี้ไม่อนุญาตให้คุณอัปโหลดไฟล์ที่มีชื่อที่มีเครื่องหมายขีดกลาง

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

1. ค้นหาไฟล์ทั้งหมดในไดเร็กทอรี

2. ตรวจสอบว่าชื่อมียัติภังค์ (-) หรือไม่ และ

3. แทนที่ยัติภังค์ด้วยขีดล่าง (_)

ต่อไปนี้เป็นชื่อไฟล์ที่จะเริ่มต้น (มีเครื่องหมายยัติภังค์):

สคริปต์ทุบตี

เราจะเริ่มต้นด้วยสคริปต์ทุบตี นี่คือ:

#!/bin/bash
# Replace "-" with "_" in file names
DIRECTORY="/path/to/your/folder"
for FILE in "$DIRECTORY"/*; do
 if [[ "$FILE" == *-* ]]; then
 NEW_NAME=$(echo "$FILE" | sed 's/-/_/g')
 mv "$FILE" "$NEW_NAME"
 echo "Renamed: $FILE -> $NEW_NAME"
 fi
done

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

สคริปต์หลาม

ต่อไป เรามาดูกันว่ามันจะมีลักษณะอย่างไรใน Python:

import os
# Replace "-" with "_" in file names
directory = "/path/to/your/folder"
for filename in os.listdir(directory):
 if "-" in filename:
 old_path = os.path.join(directory, filename)
 new_filename = filename.replace("-", "_")
 new_path = os.path.join(directory, new_filename)
 os.rename(old_path, new_path)
 print(f"Renamed: {filename} -> {new_filename}")

ขั้นตอนค่อนข้างคล้ายกันใน Python ขั้นแรก เรากำหนดไดเร็กทอรีแล้ววนซ้ำแต่ละไฟล์ในไดเร็กทอรี หากต้องการค้นหาไฟล์ทั้งหมดในไดเร็กทอรี เราต้องใช้ listdir วิธีการจาก os แพ็คเกจ

จากนั้นเราตรวจสอบว่าชื่อไฟล์มี - หรือไม่ ในบรรทัดถัดไป ในกรณีเช่นนี้ เราจะค้นหาเส้นทางปัจจุบัน (old_path ) ของไฟล์โดยการรวมไดเร็กทอรีและชื่อไฟล์เข้าด้วยกัน เราสามารถสร้างชื่อไฟล์ใหม่ได้โดยการแทนที่ - ด้วย _ โดยใช้ replace วิธีการ.

จากนั้นเราสร้างเส้นทางไฟล์ใหม่ (new_path ) ในทำนองเดียวกันที่เราสร้าง old_path . สุดท้ายเราเรียก rename วิธีการใน os แพ็กเกจที่มีเส้นทางไฟล์เก่าและใหม่เป็นอาร์กิวเมนต์

สคริปต์จาวาสคริปต์

และตอนนี้เรามาดูกันว่า JavaScript จะมีลักษณะอย่างไร:

const fs = require('fs');
const path = require('path');
const directory = '/path/to/your/folder';
fs.readdir(directory, (err, files) => {
 if (err) {
 console.error('Error reading directory:', err);
 return;
 }
 files.forEach(file => {
 if (file.includes('-')) {
 const oldPath = path.join(directory, file);
 const newFilename = file.replace(/-/g, '_');
 const newPath = path.join(directory, newFilename);
 fs.rename(oldPath, newPath, err => {
 if (err) {
 console.error(`Error renaming ${file}:`, err);
 } else {
 console.log(`Renamed: ${file} -> ${newFilename}`);
 }
 });
 }
 });
});

การใช้งาน JavaScript ค่อนข้างคล้ายกับการใช้งาน Python แต่คุณจะต้องเขียนโค้ดเพิ่มเติม โดยทั่วไปแล้ว devs ไม่ชอบ JavaScript สำหรับสคริปต์ประเภทนี้ ส่วนใหญ่พึ่งพา Bash/Python JavaScript เหมาะกว่าสำหรับสคริปต์อัตโนมัติบนเบราว์เซอร์

ยังเรามาดูสิ่งที่เรามีที่นี่ ในโค้ด JavaScript นี้ คุณต้องใช้แพ็กเกจที่แตกต่างกันสองชุด fs และ path . เรากำหนดไดเร็กทอรีที่ด้านบน อ่านไฟล์ในไดเร็กทอรีโดยใช้ readdir วิธีการจาก fs แพ็กเกจและส่งไดเร็กทอรีเป็นอาร์กิวเมนต์ นอกจากไดเร็กทอรีแล้ว เรายังส่งฟังก์ชันเรียกกลับที่จะดำเนินการเมื่อไฟล์ถูกอ่าน

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

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

วิธีเรียกใช้สคริปต์เหล่านี้

ตกลง นี่คือวิธีที่คุณสามารถใช้สคริปต์เหล่านี้ได้:

1. แทนที่ /path/to/your/folder ด้วยไดเร็กทอรีจริงที่มีไฟล์อยู่

2. รันสคริปต์ในสภาพแวดล้อมที่เกี่ยวข้อง:

   • ทุบตี: บันทึกเป็น .sh จากนั้นดำเนินการด้วย bash script.sh

   • หลาม: บันทึกเป็น .py จากนั้นดำเนินการด้วย python script.py

   • จาวาสคริปต์: บันทึกเป็น .js จากนั้นดำเนินการด้วย node script.js

ภาพหน้าจอด้านล่างแสดงการเรียกใช้สคริปต์ทุบตีเพื่อเปลี่ยนชื่อไฟล์

สคริปต์ที่เกิดซ้ำ

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

แนวทางทั่วไป

1. งาน CRON:ระบบปฏิบัติการส่วนใหญ่รองรับ CRON ซึ่งสามารถทริกเกอร์สคริปต์ตามกำหนดเวลาที่กำหนดได้

2. คิวงาน:เครื่องมืออย่าง Celery (Python), Bull (Node.js) หรือ Sidekiq (Ruby) สามารถจัดการงานที่กำหนดเวลาไว้ได้อย่างยืดหยุ่นมากขึ้น

3. เครื่องกำหนดเวลาบนคลาวด์:บริการต่างๆ เช่น AWS Lambda พร้อม EventBridge, Google Cloud Scheduler หรือแอป Azure Logic ช่วยให้คุณสามารถตั้งค่าสคริปต์ที่เกิดซ้ำในสถาปัตยกรรมแบบไร้เซิร์ฟเวอร์ได้

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

แนวทางปฏิบัติที่ดีที่สุดในการเขียนสคริปต์

ต่อไปนี้เป็นสิ่งที่ควรคำนึงถึงเมื่อคุณเขียนสคริปต์:

1. ใช้ความคิดเห็น :อธิบายส่วนที่ซับซ้อนของสคริปต์พร้อมความคิดเห็น

ในตัวอย่างด้านล่าง หากไม่มีความคิดเห็น บางคนอาจต้องใช้เวลาเพิ่มเติมในการหาสาเหตุที่อัตราภาษีเป็นทศนิยมไม่ใช่เปอร์เซ็นต์

# Calculate the total price with tax
def calculate_price_with_tax(price, tax_rate):
 # Tax rate is expressed as a decimal (e.g., 0.07 for 7%)
 return price + (price * tax_rate)

2. การจัดการข้อผิดพลาด :คำนึงถึงข้อผิดพลาดที่อาจเกิดขึ้นและจัดการอย่างสง่างาม

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

try:
 with open('data.csv', 'r') as file:
 data = file.readlines()
except FileNotFoundError:
 print("Error: 'data.csv' file not found. Make sure the file exists before running the script.")
except Exception as e:
 print(f"An unexpected error occurred: {e}")

3. การออกแบบโมดูลาร์ :แบ่งสคริปต์ออกเป็นฟังก์ชันหรือโมดูลที่นำมาใช้ซ้ำได้

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

def fetch_data_from_api(api_url):
 # Fetch data from the given API
 pass
def process_data(data):
 # Process the data into the desired format
 pass
def save_to_file(data, filename):
 # Save processed data to a file
 pass
# Main script
if __name__ == "__main__":
 data = fetch_data_from_api("https://example.com/api")
 processed_data = process_data(data)
 save_to_file(processed_data, "output.json")

4. การตรวจสอบอินพุต :ตรวจสอบอินพุตของผู้ใช้เพื่อป้องกันข้อผิดพลาดที่ไม่คาดคิดหรือความเสี่ยงด้านความปลอดภัย

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

import re
# Validate that the input is a valid email address
def validate_email(email):
 pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
 if not re.match(pattern, email):
 raise ValueError("Invalid email address format")
 return email
# Example usage
try:
 user_email = validate_email(input("Enter your email: "))
 print(f"Valid email: {user_email}")
except ValueError as e:
 print(e)

5. การควบคุมเวอร์ชัน :ใช้ Git หรือเครื่องมือควบคุมเวอร์ชันอื่นๆ เพื่อติดตามการเปลี่ยนแปลง

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

git init
git add script.py
git commit -m "Initial commit"

บทสรุป

การเขียนสคริปต์เป็นทักษะที่สามารถเพิ่มประสิทธิภาพการทำงานและความสามารถในการแก้ปัญหาของคุณได้อย่างมาก ด้วยการทำความเข้าใจพื้นฐานของภาษาสคริปต์ เช่น Bash, Python และ JavaScript คุณสามารถทำงานอัตโนมัติ ปรับปรุงเวิร์กโฟลว์ และประหยัดเวลาอันมีค่าได้ เริ่มต้นจากเล็กๆ สร้างทีละน้อย และฝึกเขียนสคริปต์สำหรับกรณีการใช้งานที่แตกต่างกันเพื่อฝึกฝนทักษะอันล้ำค่านี้

ฉันมีแบบฝึกหัดสำหรับคุณ หากต้องการเรียกใช้และตรวจสอบสคริปต์ตัวอย่างนี้ คุณอาจคิดว่าคุณต้องสร้างไฟล์ 100 ไฟล์ด้วยตนเอง ซึ่งกินเวลามาก

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

นี่อาจฟังดูยากในตอนแรก แต่เชื่อฉันเถอะว่าคุณแค่ต้องเขียนโค้ด bash 5 บรรทัดเพื่อสร้างไฟล์ 100 ไฟล์ ไม่ใช่แค่ 100 – คุณยังสามารถสร้างไฟล์ล้าน/พันล้าน/ล้านล้านไฟล์ด้วยโค้ดเพียง 5 บรรทัด

หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสคริปต์ โปรดสมัครรับจดหมายข่าวทางอีเมลของฉัน (https://5minslearn.gogosoon.com/) และติดตามฉันบนโซเชียลมีเดีย

ขอให้มีความสุขกับการเขียนสคริปต์!

เรียนรู้การเขียนโค้ดฟรี หลักสูตรโอเพ่นซอร์สของ freeCodeCamp ช่วยให้ผู้คนมากกว่า 40,000 คนได้งานในตำแหน่งนักพัฒนา เริ่มต้น