Trong bài viết đầu tiên của loạt bài này, bạn đã tạo tập lệnh Bash một dòng, rất nhỏ, đầu tiên của mình và khám phá lý do tạo tập lệnh shell. Trong bài viết thứ hai, bạn đã bắt đầu tạo một mẫu khá đơn giản có thể là điểm khởi đầu cho các chương trình Bash khác và bắt đầu thử nghiệm nó. Trong bài viết thứ ba, bạn đã tạo và sử dụng một hàm Trợ giúp đơn giản và tìm hiểu về cách sử dụng các hàm cũng như cách xử lý các tùy chọn dòng lệnh như -h .
Bài viết thứ tư và cuối cùng trong loạt bài này về các biến và khởi tạo chúng cũng như cách thực hiện một chút kiểm tra độ tỉnh táo để giúp đảm bảo chương trình chạy trong các điều kiện thích hợp. Hãy nhớ rằng, mục tiêu của loạt bài này là xây dựng mã làm việc sẽ được sử dụng làm mẫu cho các dự án lập trình Bash trong tương lai. Ý tưởng là làm cho việc bắt đầu các dự án lập trình mới trở nên dễ dàng bằng cách có sẵn các phần tử chung trong mẫu.
Biến
Bash shell, giống như tất cả các ngôn ngữ lập trình, có thể xử lý các biến. Một biến là một tên tượng trưng dùng để chỉ một vị trí cụ thể trong bộ nhớ có chứa một giá trị nào đó. Giá trị của một biến có thể thay đổi, tức là nó có thể thay đổi được. Nếu bạn không quen với việc sử dụng biến, hãy đọc bài viết của tôi Cách lập trình với Bash:Cú pháp và công cụ trước khi bạn đi xa hơn.
Xong? Tuyệt quá! Bây giờ chúng ta hãy xem xét một số phương pháp hay khi sử dụng các biến.
Tôi luôn đặt các giá trị ban đầu cho mọi biến được sử dụng trong các tập lệnh của mình. Bạn có thể tìm thấy điều này trong tập lệnh mẫu của mình ngay sau các thủ tục như là phần đầu tiên của phần thân chương trình chính, trước khi nó xử lý các tùy chọn. Việc khởi tạo mỗi biến với một giá trị thích hợp có thể ngăn ngừa các lỗi có thể xảy ra với các biến chưa được khởi tạo trong các phép toán so sánh hoặc toán học. Đặt danh sách các biến này ở một nơi cho phép bạn xem tất cả các biến được cho là có trong tập lệnh và giá trị ban đầu của chúng.
Tập lệnh nhỏ của bạn chỉ có một biến duy nhất, $ option , cho đến nay. Đặt nó bằng cách chèn các dòng sau như được hiển thị:
################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
# Initialize variables
option=""
################################################################################
# Process the input options. Add options as needed. #
################################################################################
Kiểm tra điều này để đảm bảo rằng mọi thứ hoạt động như bình thường và không có gì bị hỏng do thay đổi này.
Hằng số
Hằng số cũng là các biến - ít nhất chúng cũng phải như vậy. Sử dụng các biến bất cứ khi nào có thể trong các chương trình giao diện dòng lệnh (CLI) thay vì các giá trị được mã hóa cứng. Ngay cả khi bạn nghĩ rằng bạn sẽ sử dụng một giá trị cụ thể (chẳng hạn như tên thư mục, tên tệp hoặc chuỗi văn bản) chỉ một lần, hãy tạo một biến và sử dụng nó ở nơi bạn đã đặt tên mã cứng.
Ví dụ:thông báo được in như một phần của nội dung chính của chương trình là một chuỗi ký tự, echo "Hello world!" . Thay đổi nó thành một biến. Đầu tiên, thêm câu lệnh sau vào phần khởi tạo biến:
Msg="Hello world!"Và bây giờ hãy thay đổi dòng cuối cùng của chương trình từ:
echo "Hello world!"tới:
echo "$Msg"Kiểm tra kết quả.
Kiểm tra tình trạng
Kiểm tra tình trạng chỉ đơn giản là kiểm tra các điều kiện cần phải đúng để chương trình hoạt động chính xác, chẳng hạn như:chương trình phải được chạy với tư cách người dùng gốc hoặc nó phải chạy trên một bản phân phối và phát hành cụ thể của bản phân phối đó. Thêm kiểm tra cho root với tư cách là người dùng đang chạy trong mẫu chương trình đơn giản của bạn.
Việc kiểm tra xem người dùng root có đang chạy chương trình hay không rất dễ dàng vì chương trình chạy với tư cách là người dùng khởi chạy chương trình đó.
id có thể được sử dụng để xác định ID người dùng số (UID) mà chương trình đang chạy. Nó cung cấp một số bit thông tin khi nó được sử dụng mà không có bất kỳ tùy chọn nào:
[student@testvm1 ~]$ id
uid=1001(student) gid=1001(student) groups=1001(student),5000(dev)
Sử dụng -u tùy chọn chỉ trả về UID của người dùng, có thể dễ dàng sử dụng trong chương trình Bash của bạn:
[student@testvm1 ~]$ id -u
1001
[student@testvm1 ~]$
Thêm chức năng sau vào chương trình. Tôi đã thêm nó vào sau thủ tục Trợ giúp, nhưng bạn có thể đặt nó ở bất kỳ đâu trong phần thủ tục. Logic là nếu UID không bằng 0, luôn là UID của người dùng gốc, chương trình sẽ thoát:
################################################################################
# Check for root. #
################################################################################
CheckRoot()
{
if [ `id -u` != 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}
Bây giờ, hãy thêm cuộc gọi vào CheckRoot thủ tục ngay trước khi khởi tạo biến. Kiểm tra điều này, trước tiên hãy chạy chương trình với tư cách là người dùng sinh viên:
[student@testvm1 ~]$ ./hello
ERROR: You must be root user to run this program
[student@testvm1 ~]$
sau đó với tư cách là người dùng gốc:
[root@testvm1 student]# ./hello
Hello world!
[root@testvm1 student]#
Bạn có thể không phải lúc nào cũng cần kiểm tra độ tỉnh táo cụ thể này, vì vậy hãy bình luận cuộc gọi đến CheckRoot nhưng để nguyên tất cả mã trong mẫu. Bằng cách này, tất cả những gì bạn cần làm để sử dụng mã đó trong một chương trình trong tương lai là bỏ ghi chú cuộc gọi.
Mã
Sau khi thực hiện các thay đổi được nêu ở trên, mã của bạn sẽ giống như sau:
#!/usr/bin/bash
################################################################################
# scriptTemplate #
# #
# Use this template as the beginning of a new program. Place a short #
# description of the script here. #
# #
# Change History #
# 11/11/2019 David Both Original code. This is a template for creating #
# new Bash shell scripts. #
# Add new history entries as needed. #
# #
# #
################################################################################
################################################################################
################################################################################
# #
# Copyright (C) 2007, 2019 David Both #
# [email protected] #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, #
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program; if not, write to the Free Software #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
# #
################################################################################
################################################################################
################################################################################
################################################################################
# Help #
################################################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
################################################################################
# Check for root. #
################################################################################
CheckRoot()
{
# If we are not running as root we exit the program
if [ `id -u` != 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}
################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
################################################################################
# Sanity checks #
################################################################################
# Are we rnning as root?
# CheckRoot
# Initialize variables
option=""
Msg="Hello world!"
################################################################################
# Process the input options. Add options as needed. #
################################################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # incorrect option
echo "Error: Invalid option"
exit;;
esac
done
echo "$Msg"
Bài tập cuối cùng
Bạn có thể nhận thấy rằng chức năng Trợ giúp trong mã của bạn đề cập đến các tính năng không có trong mã. Cuối cùng, hãy tìm cách thêm các hàm đó vào mẫu mã bạn đã tạo.
Tóm tắt
Trong bài viết này, bạn đã tạo một số hàm để thực hiện kiểm tra độ tỉnh táo xem chương trình của bạn có đang chạy dưới dạng root hay không. Chương trình của bạn ngày càng phức tạp hơn một chút, vì vậy việc thử nghiệm ngày càng trở nên quan trọng hơn và yêu cầu nhiều đường dẫn thử nghiệm hơn để hoàn thiện.
Loạt bài này xem xét một chương trình Bash rất tối thiểu và cách xây dựng kịch bản mỗi lần một chút. Kết quả là một mẫu đơn giản có thể là điểm khởi đầu cho các tập lệnh Bash khác, hữu ích hơn và chứa các phần tử hữu ích giúp dễ dàng bắt đầu các tập lệnh mới.
Bây giờ, bạn có ý tưởng:Các chương trình biên dịch là cần thiết và đáp ứng một nhu cầu rất quan trọng. Nhưng đối với sysadmins, luôn có một cách tốt hơn. Luôn sử dụng các tập lệnh shell để đáp ứng nhu cầu tự động hóa công việc của bạn. Các tập lệnh Shell đang mở; nội dung và mục đích của chúng có thể biết được. Chúng có thể được sửa đổi dễ dàng để đáp ứng các yêu cầu khác nhau. Tôi chưa bao giờ tìm thấy bất cứ điều gì mà tôi cần làm trong vai trò sysadmin của mình mà không thể hoàn thành với tập lệnh shell.
Những gì bạn đã tạo ra cho đến nay trong loạt bài này chỉ là khởi đầu. Khi bạn viết nhiều chương trình Bash hơn, bạn sẽ tìm thấy nhiều đoạn mã hơn mà bạn sử dụng thường xuyên và nên được đưa vào mẫu chương trình của bạn.
Tài nguyên
- Cách lập trình với Bash:Cú pháp và công cụ
- Cách lập trình với Bash:Toán tử logic và mở rộng shell
- Cách lập trình với Bash:Loops
Loạt bài viết này một phần dựa trên Tập 2, Chương 10 của khóa học tự học Linux ba phần của David Cả hai, Sử dụng và Quản trị Linux — Zero to SysAdmin.