Lợi ích của việc sử dụng $ () thay vì backticks trong shell script là gì?

Có hai cách để nắm bắt đầu ra của dòng lệnh trong bash:

1. Backticks vỏ di sản Bourne ``:

   var=`command`

2. $() cú pháp (theo như tôi biết là đặc thù của Bash, hoặc ít nhất là không được hỗ trợ bởi các shell cũ không phải POSIX như Bourne gốc)

   var=$(command)

Có bất kỳ lợi ích nào khi sử dụng cú pháp thứ hai so với backticks không? Hoặc là hai hoàn toàn tương đương 100%?

Cái chính là khả năng lồng chúng, ra lệnh trong các lệnh, mà không mất đi sự tỉnh táo của bạn khi cố gắng tìm hiểu xem một số hình thức thoát sẽ hoạt động trên backticks.

Một ví dụ, mặc dù hơi giả tạo:

deps=$(find /dir -name $(ls -1tr 201112[0-9][0-9]*.txt | tail -1l) -print)

sẽ cung cấp cho bạn một danh sách tất cả các tệp trong /dircây thư mục có cùng tên với tệp văn bản sớm nhất từ ​​tháng 12 năm 2011 ^(a) .

Một ví dụ khác sẽ giống như lấy tên (không phải đường dẫn đầy đủ) của thư mục mẹ:

pax> cd /home/pax/xyzzy/plugh
pax> parent=$(basename $(dirname $PWD))
pax> echo $parent
xyzzy

^(a) Bây giờ lệnh cụ thể đó có thể không thực sự hoạt động, tôi đã không kiểm tra chức năng. Vì vậy, nếu bạn bỏ phiếu cho tôi, bạn đã đánh mất ý định :-) Nó có ý nghĩa như một minh họa về cách bạn có thể lồng, chứ không phải là một đoạn trích sẵn sàng sản xuất không có lỗi.

Giả sử bạn muốn tìm thư mục lib tương ứng với nơi gccđược cài đặt. Bạn có một sự lựa chọn:

libdir=$(dirname $(dirname $(which gcc)))/lib

libdir=`dirname \`dirname \\\`which gcc\\\`\``/lib

Cái thứ nhất dễ hơn cái thứ hai - sử dụng cái thứ nhất.

Backticks ( `...`) là cú pháp kế thừa được yêu cầu chỉ bởi những vỏ bourne không tương thích POSIX lâu đời nhất và $(...)là POSIX và được ưa thích hơn vì nhiều lý do:

• Dấu gạch chéo ngược ( \) bên trong backticks được xử lý theo cách không rõ ràng:

  $ echo "`echo \\a`" "$(echo \\a)"
  a \a
  $ echo "`echo \\\\a`" "$(echo \\\\a)"
  \a \\a
  # Note that this is true for *single quotes* too!
  $ foo=`echo '\\'`; bar=$(echo '\\'); echo "foo is $foo, bar is $bar" 
  foo is \, bar is \\

• Báo giá lồng nhau bên trong $()là thuận tiện hơn nhiều:

  echo "x is $(sed ... <<<"$y")"

  thay vì:

  echo "x is `sed ... <<<\"$y\"`"

  hoặc viết một cái gì đó như:

  IPs_inna_string=`awk "/\`cat /etc/myname\`/"'{print $1}' /etc/hosts`

  bởi vì $()sử dụng một bối cảnh hoàn toàn mới để trích dẫn

  vốn không có khả năng di động vì đạn Bourne và Korn sẽ yêu cầu các dấu gạch chéo ngược này, trong khi Bash và dash thì không.

• Cú pháp để thay thế lệnh lồng nhau dễ dàng hơn:

  x=$(grep "$(dirname "$path")" file)

  hơn:

  x=`grep "\`dirname \"$path\"\`" file`

  bởi vì $() thực thi một bối cảnh hoàn toàn mới để trích dẫn, do đó, mỗi thay thế lệnh được bảo vệ và có thể được xử lý riêng mà không cần quan tâm đặc biệt đến trích dẫn và thoát. Khi sử dụng backticks, nó trở nên xấu hơn và xấu hơn sau hai cấp độ trở lên.

  Một vài ví dụ khác:

  echo `echo `ls``      # INCORRECT
  echo `echo \`ls\``    # CORRECT
  echo $(echo $(ls))    # CORRECT

• Nó giải quyết vấn đề về hành vi không nhất quán khi sử dụng backquote:

  • echo '\$x' đầu ra \$x
  • echo `echo '\$x'` đầu ra $x
  • echo $(echo '\$x') đầu ra \$x

• Cú pháp Backticks có các hạn chế lịch sử đối với nội dung của lệnh nhúng và không thể xử lý một số tập lệnh hợp lệ bao gồm backquote, trong khi $()biểu mẫu mới hơn có thể xử lý bất kỳ loại tập lệnh nhúng hợp lệ nào.

  Ví dụ: các tập lệnh nhúng hợp lệ này không hoạt động ở cột bên trái, nhưng hoạt động ở bên phải ^IEEE :

  echo `                         echo $(
  cat <<\eof                     cat <<\eof
  a here-doc with `              a here-doc with )
  eof                            eof
  `                              )
  
  
  echo `                         echo $(
  echo abc # a comment with `    echo abc # a comment with )
  `                              )
  
  
  echo `                         echo $(
  echo '`'                       echo ')'
  `                              )

Do đó, cú pháp thay thế lệnh$ -prefixed nên là phương thức ưa thích, vì nó rõ ràng với cú pháp rõ ràng (cải thiện khả năng đọc của người và máy), nó có thể lồng vào nhau và trực quan, phân tích cú pháp bên trong của nó là riêng biệt và cũng phù hợp hơn (với tất cả các bản mở rộng khác được phân tích cú pháp từ trong dấu ngoặc kép) trong đó backticks là ngoại lệ duy nhất và ký tự dễ dàng được ngụy trang khi liền kề để làm cho nó khó đọc hơn, đặc biệt là với các phông chữ nhỏ hoặc bất thường.`"

Nguồn: Tại sao được $(...)ưa thích hơn `...`(backticks)? tại BashFAQ

Xem thêm:

• Phần tiêu chuẩn POSIX "2.6.3 Thay thế lệnh"
• Lý do POSIX bao gồm cú pháp $ ()
• Bộ chỉ huy thay thế
• bash-hackers: thay thế lệnh

Từ người đàn ông bash:

          $(command)
   or
          `command`

   Bash performs the expansion by executing command and replacing the com-
   mand  substitution  with  the  standard output of the command, with any
   trailing newlines deleted.  Embedded newlines are not deleted, but they
   may  be  removed during word splitting.  The command substitution $(cat
   file) can be replaced by the equivalent but faster $(< file).

   When the old-style backquote form of substitution  is  used,  backslash
   retains  its  literal  meaning except when followed by $, `, or \.  The
   first backquote not preceded by a backslash terminates the command sub-
   stitution.   When using the $(command) form, all characters between the
   parentheses make up the command; none are treated specially.

Ngoài các câu trả lời khác,

$(...)

trực quan tốt hơn

`...`

Backticks trông quá giống như dấu nháy đơn; điều này thay đổi tùy thuộc vào phông chữ bạn đang sử dụng.

(Và, như tôi vừa nhận thấy, backticks khó nhập hơn rất nhiều trong các mẫu mã nội tuyến.)

$() cho phép làm tổ

out=$(echo today is $(date))

Tôi nghĩ backticks không cho phép nó.

Đó là tiêu chuẩn POSIX xác định $(command)hình thức thay thế lệnh. Hầu hết các shell được sử dụng ngày nay đều tuân thủ POSIX và hỗ trợ hình thức ưa thích này qua ký hiệu backtick cổ xưa. Phần thay thế lệnh (2.6.3) của tài liệu Shell Language mô tả điều này:

Thay thế lệnh cho phép đầu ra của một lệnh được thay thế thay cho tên lệnh. Thay thế lệnh sẽ xảy ra khi lệnh được bao quanh như sau:

$(command)

hoặc (phiên bản rút gọn):

`command`

Shell sẽ mở rộng thay thế lệnh bằng cách thực thi lệnh trong môi trường lớp con (xem Môi trường thực thi Shell ) và thay thế lệnh thay thế (văn bản lệnh cộng với "$ ()" hoặc backquote kèm theo với đầu ra tiêu chuẩn của lệnh, loại bỏ trình tự của một hoặc nhiều <newline>ký tự ở cuối thay thế. Các <newline>ký tự nhúng trước khi kết thúc đầu ra sẽ không bị xóa; tuy nhiên, chúng có thể được coi là các dấu phân cách trường và bị loại bỏ trong quá trình tách trường, tùy thuộc vào giá trị của IFS và trích dẫn có hiệu lực. Nếu đầu ra chứa bất kỳ byte rỗng nào, hành vi không được chỉ định.

Trong kiểu thay thế lệnh <backslash>được trích dẫn , sẽ giữ nguyên nghĩa đen của nó, ngoại trừ khi được theo sau: ' $', ' `' hoặc <backslash>. Việc tìm kiếm backquote phù hợp sẽ được thỏa mãn bởi backquote không thoát được trích dẫn đầu tiên; trong quá trình tìm kiếm này, nếu gặp phải một backquote không thoát trong một nhận xét shell, tài liệu ở đây, thay thế lệnh nhúng của biểu mẫu $ ( lệnh ) hoặc chuỗi được trích dẫn, sẽ xảy ra kết quả không xác định. Một chuỗi trích dẫn đơn hoặc trích dẫn kép bắt đầu, nhưng không kết thúc, trong `...`chuỗi "" tạo ra kết quả không xác định.

Với biểu mẫu $ ( lệnh ), tất cả các ký tự theo dấu ngoặc đơn mở cho dấu ngoặc đơn đóng phù hợp sẽ tạo thành lệnh . Bất kỳ tập lệnh shell hợp lệ nào cũng có thể được sử dụng cho lệnh , ngoại trừ tập lệnh chỉ bao gồm các chuyển hướng tạo ra kết quả không xác định.

Các kết quả thay thế lệnh sẽ không được xử lý để mở rộng dấu ngã, mở rộng tham số, thay thế lệnh hoặc mở rộng số học. Nếu thay thế lệnh xảy ra bên trong dấu ngoặc kép, việc tách trường và mở rộng tên đường dẫn sẽ không được thực hiện trên kết quả của sự thay thế.

Thay thế lệnh có thể được lồng nhau. Để chỉ định lồng trong phiên bản backquote, ứng dụng phải đi trước các backquote bên trong với các <backslash>ký tự; ví dụ:

\`command\`

Cú pháp của ngôn ngữ lệnh shell có sự mơ hồ đối với các mở rộng bắt đầu bằng "$((. thay thế nếu nó xác định rằng nó không thể phân tích sự mở rộng như một sự mở rộng số học. Vỏ không cần đánh giá các mở rộng lồng nhau khi thực hiện xác định này. shell sẽ coi việc mở rộng là một mở rộng số học không hoàn chỉnh và báo cáo lỗi cú pháp. Một ứng dụng tuân thủ phải đảm bảo rằng nó tách biệt "$( " và '('thành hai mã thông báo (nghĩa là tách chúng bằng khoảng trắng) trong một thay thế lệnh bắt đầu bằng một lớp con. Ví dụ, một sự thay thế lệnh có chứa một chuỗi con có thể được viết là:

$( (command) )

Đây là một câu hỏi di sản, nhưng tôi đã đưa ra một ví dụ hoàn toàn hợp lệ về $(...)hơn `...`.

Tôi đã sử dụng một máy tính để bàn từ xa để các cửa sổ chạy cygwin và muốn lặp lại kết quả của một lệnh. Đáng buồn thay, nhân vật backtick không thể nhập, do điều máy tính từ xa hoặc chính cygwin.

Thật giả khi cho rằng một ký hiệu đô la và dấu ngoặc đơn sẽ dễ dàng nhập vào các thiết lập lạ như vậy.