Tự động nắm bắt đầu ra của lệnh cuối cùng vào một biến bằng Bash?

Tôi muốn có thể sử dụng kết quả của lệnh được thực hiện cuối cùng trong một lệnh tiếp theo. Ví dụ,

$ find . -name foo.txt
./home/user/some/directory/foo.txt

Bây giờ hãy nói rằng tôi muốn có thể mở tệp trong trình chỉnh sửa hoặc xóa tệp hoặc làm một cái gì đó khác với nó, ví dụ:

mv <some-variable-that-contains-the-result> /some/new/location

Tôi làm nó như thế nào? Có thể sử dụng một số biến bash?

Cập nhật:

Để làm rõ, tôi không muốn chỉ định mọi thứ bằng tay. Những gì tôi đang theo là một cái gì đó giống như các biến bash tích hợp, vd

ls /tmp
cd $_

$_giữ đối số cuối cùng của lệnh trước đó. Tôi muốn một cái gì đó tương tự, nhưng với đầu ra của lệnh cuối cùng.

Cập nhật cuối cùng:

Câu trả lời của Seth đã hoạt động khá tốt. Vài điều cần lưu ý:

• đừng quên touch /tmp/xkhi thử giải pháp lần đầu tiên
• kết quả sẽ chỉ được lưu trữ nếu mã thoát lệnh cuối cùng thành công

Đây là một giải pháp thực sự hack, nhưng nó dường như chủ yếu hoạt động một số thời gian. Trong quá trình thử nghiệm, tôi lưu ý rằng đôi khi nó không hoạt động tốt khi nhận được^C dòng lệnh, mặc dù tôi đã điều chỉnh nó một chút để hành xử tốt hơn một chút.

Hack này chỉ là một chế độ hack tương tác, và tôi khá tự tin rằng tôi sẽ không giới thiệu nó cho bất cứ ai. Các lệnh nền có khả năng gây ra hành vi thậm chí ít được xác định hơn bình thường. Các câu trả lời khác là một cách tốt hơn để lập trình đạt được kết quả.

Điều đó đang được nói, đây là "giải pháp":

PROMPT_COMMAND='LAST="`cat /tmp/x`"; exec >/dev/tty; exec > >(tee /tmp/x)'

Đặt biến môi trường bash này và đưa ra các lệnh như mong muốn. $LASTthường sẽ có đầu ra mà bạn đang tìm kiếm:

startide seth> fortune
Courtship to marriage, as a very witty prologue to a very dull play.
                -- William Congreve
startide seth> echo "$LAST"
Courtship to marriage, as a very witty prologue to a very dull play.
                -- William Congreve

Tôi không biết bất kỳ biến nào tự động làm điều này . Để làm một cái gì đó ngoài việc chỉ sao chép kết quả, bạn có thể chạy lại bất cứ thứ gì bạn vừa làm, vd

vim $(!!)

Ở đâu !! mở rộng lịch sử có nghĩa là 'lệnh trước'.

Nếu bạn mong muốn có một tên tệp duy nhất có khoảng trắng hoặc các ký tự khác trong đó có thể ngăn phân tích cú pháp đối số phù hợp, hãy trích dẫn kết quả ( vim "$(!!)"). Để nó không được trích dẫn sẽ cho phép nhiều tệp được mở cùng một lúc miễn là chúng không bao gồm dấu cách hoặc các mã thông báo phân tích vỏ khác.

Bash là một loại ngôn ngữ xấu xí. Có, bạn có thể gán đầu ra cho biến

MY_VAR="$(find -name foo.txt)"
echo "$MY_VAR"

Nhưng tốt hơn là hy vọng bạn sẽ findchỉ trả về một kết quả và kết quả đó không có bất kỳ ký tự "lẻ" nào trong đó, như trả về vận chuyển hoặc nguồn cấp dữ liệu, vì chúng sẽ được sửa đổi âm thầm khi được gán cho biến Bash.

Nhưng tốt hơn hãy cẩn thận để trích dẫn chính xác biến của bạn khi sử dụng nó!

Nó tốt hơn để hoạt động trên các tập tin trực tiếp, ví dụ như với find's -execdir(tham khảo hướng dẫn).

find -name foo.txt -execdir vim '{}' ';'

hoặc là

find -name foo.txt -execdir rename 's/\.txt$/.xml/' '{}' ';'

Có nhiều hơn một cách để làm điều này. Một cách là sử dụng v=$(command)sẽ gán đầu ra của lệnh v. Ví dụ:

v=$(date)
echo $v

Và bạn cũng có thể sử dụng backquote.

v=`date`
echo $v

Từ Hướng dẫn cho người mới bắt đầu Bash ,

Khi hình thức thay thế được trích dẫn kiểu cũ được sử dụng, dấu gạch chéo ngược vẫn giữ nguyên nghĩa đen của nó trừ khi được theo sau bởi "$", "` "hoặc" \ ". Các backticks đầu tiên không đi trước dấu gạch chéo ngược chấm dứt thay thế lệnh. Khi sử dụng biểu mẫu "$ (THÔNG TIN)", tất cả các ký tự giữa các dấu ngoặc đơn sẽ tạo thành lệnh; không ai được điều trị đặc biệt

EDIT: Sau khi chỉnh sửa trong câu hỏi, có vẻ như đây không phải là điều mà OP đang tìm kiếm. Theo tôi biết, không có biến đặc biệt như $_đầu ra của lệnh cuối cùng.

Nó khá dễ. Sử dụng dấu ngoặc kép:

var=`find . -name foo.txt`

Và sau đó bạn có thể sử dụng nó bất cứ lúc nào trong tương lai

echo $var
mv $var /somewhere

Tiết lộ:

• Câu trả lời này là muộn nửa năm: D
• Tôi là người dùng tmux nặng
• Bạn phải chạy shell của bạn trong tmux để nó hoạt động

Khi chạy shell tương tác trong tmux, bạn có thể dễ dàng truy cập dữ liệu hiện được hiển thị trên thiết bị đầu cuối. Chúng ta hãy xem một số lệnh thú vị:

• khung chụp tmux : cái này sao chép dữ liệu được hiển thị vào một trong các bộ đệm bên trong của tmux. Nó có thể sao chép lịch sử hiện không thể nhìn thấy, nhưng chúng tôi không quan tâm đến điều đó ngay bây giờ
• bộ đệm danh sách tmux : phần này hiển thị thông tin về bộ đệm đã chụp. Cái mới nhất sẽ có số 0.
• tmux show-buffer -b (num num) : phần này in nội dung của bộ đệm đã cho trên một thiết bị đầu cuối
• tmux paste-buffer -b (num num) : cái này dán nội dung của bộ đệm đã cho làm đầu vào

Vâng, điều này mang lại cho chúng tôi rất nhiều khả năng bây giờ :) Đối với tôi, tôi đã thiết lập một bí danh đơn giản: alias L="tmux capture-pane; tmux showb -b 0 | tail -n 3 | head -n 1"và bây giờ mỗi khi tôi cần truy cập vào dòng cuối cùng tôi chỉ cần sử dụng $(L)để có được nó.

Điều này độc lập với luồng đầu ra mà chương trình sử dụng (có thể là stdin hoặc stderr), phương thức in (ncurses, v.v.) và mã thoát của chương trình - dữ liệu chỉ cần được hiển thị.

Tôi nghĩ rằng bạn có thể hack được một giải pháp liên quan đến việc đặt shell của bạn thành tập lệnh chứa:

#!/bin/sh
bash | tee /var/log/bash.out.log

Sau đó, nếu bạn đặt $PROMPT_COMMANDthành đầu ra một dấu phân cách, bạn có thể viết hàm trợ giúp (có thể được gọi _) để đưa bạn đoạn cuối của nhật ký đó, vì vậy bạn có thể sử dụng nó như sau:

% find lots*of*files
...
% echo "$(_)"
... # same output, but doesn't run the command again

Bạn có thể thiết lập bí danh sau trong hồ sơ bash của mình:

alias s='it=$($(history | tail -2 | head -1 | cut -d" " -f4-))'

Sau đó, bằng cách nhập 's' sau một lệnh tùy ý, bạn có thể lưu kết quả vào biến shell 'nó'.

Vì vậy, ví dụ sử dụng sẽ là:

$ which python
/usr/bin/python
$ s
$ file $it
/usr/bin/python: symbolic link to `python2.6'

Tôi chỉ chắt lọc bashchức năng này từ các gợi ý ở đây:

grab() {     
  grab=$("$@")
  echo $grab
}

Sau đó, bạn chỉ cần làm:

> grab date
Do 16. Feb 13:05:04 CET 2012
> echo $grab
Do 16. Feb 13:05:04 CET 2012

Cập nhật : một người dùng ẩn danh được đề xuất thay thế echobằng printf '%s\n'ưu điểm mà nó không xử lý các tùy chọn như -etrong văn bản đã lấy. Vì vậy, nếu bạn mong đợi hoặc trải nghiệm những đặc thù như vậy, hãy xem xét đề xuất này. Một lựa chọn khác là sử dụng cat <<<$grabthay thế.

Bằng cách nói "Tôi muốn có thể sử dụng kết quả của lệnh được thực hiện cuối cùng trong một lệnh tiếp theo", tôi giả sử - bạn có nghĩa là kết quả của bất kỳ lệnh nào, không chỉ tìm thấy.

Nếu đó là trường hợp - xargs là những gì bạn đang tìm kiếm.

find . -name foo.txt -print0 | xargs -0 -I{} mv {} /some/new/location/{}

HOẶC nếu bạn muốn xem đầu ra trước:

find . -name foo.txt -print0

!! | xargs -0 -I{} mv {} /some/new/location/{}

Lệnh này xử lý nhiều tệp và hoạt động như một bùa mê ngay cả khi đường dẫn và / hoặc tên tệp chứa không gian.

Lưu ý phần mv {} / some / new / location / {} của lệnh. Lệnh này được xây dựng và thực thi cho mỗi dòng được in bằng lệnh trước đó. Ở đây, dòng được in bằng lệnh trước đó được thay thế thay cho {} .

Trích từ trang man của xargs:

xargs - xây dựng và thực thi các dòng lệnh từ đầu vào tiêu chuẩn

Để biết thêm chi tiết, xem trang người đàn ông: man xargs

Nắm bắt đầu ra với backticks:

output=`program arguments`
echo $output
emacs $output

Tôi thường làm những gì mà những người khác ở đây đã đề nghị ... mà không có sự phân công:

$find . -iname '*.cpp' -print
./foo.cpp
./bar.cpp
$vi `!!`
2 files to edit

Bạn có thể nhận được fancier nếu bạn thích:

$grep -R "some variable" * | grep -v tags
./foo/bar/xxx
./bar/foo/yyy
$vi `!!`

Nếu tất cả những gì bạn muốn là chạy lại lệnh cuối cùng của bạn và nhận đầu ra, một biến bash đơn giản sẽ hoạt động:

LAST=`!!`

Vì vậy, sau đó bạn có thể chạy lệnh của bạn trên đầu ra với:

yourCommand $LAST

Điều này sẽ sinh ra một quy trình mới và chạy lại lệnh của bạn, sau đó cung cấp cho bạn đầu ra. Có vẻ như những gì bạn thực sự muốn sẽ là một tệp lịch sử bash cho đầu ra lệnh. Điều này có nghĩa là bạn sẽ cần phải nắm bắt đầu ra mà bash gửi đến thiết bị đầu cuối của bạn. Bạn có thể viết một cái gì đó để xem / dev hoặc / Proc cần thiết, nhưng điều đó lộn xộn. Bạn cũng có thể chỉ cần tạo một "đường ống đặc biệt" giữa thuật ngữ của mình và bash bằng lệnh tee ở giữa để chuyển hướng đến tệp đầu ra của bạn.

Nhưng cả hai đều là giải pháp hacky. Tôi nghĩ điều tốt nhất sẽ là terminator , một thiết bị đầu cuối hiện đại hơn với ghi nhật ký đầu ra. Chỉ cần kiểm tra tệp nhật ký của bạn để biết kết quả của lệnh cuối cùng. Một biến bash tương tự như trên sẽ làm cho điều này thậm chí còn đơn giản hơn.

Đây là một cách để làm điều đó sau khi bạn thực hiện lệnh của mình và quyết định rằng bạn muốn lưu trữ kết quả trong một biến:

$ find . -name foo.txt
./home/user/some/directory/foo.txt
$ OUTPUT=`!!`
$ echo $OUTPUT
./home/user/some/directory/foo.txt
$ mv $OUTPUT somewhere/else/

Hoặc nếu bạn biết trước rằng bạn sẽ muốn kết quả trong một biến, bạn có thể sử dụng backticks:

$ OUTPUT=`find . -name foo.txt`
$ echo $OUTPUT
./home/user/some/directory/foo.txt

Thay thế cho các câu trả lời hiện có: Sử dụng whilenếu tên tệp của bạn có thể chứa các khoảng trắng như thế này:

find . -name foo.txt | while IFS= read -r var; do
  echo "$var"
done

Như tôi đã viết, sự khác biệt chỉ có liên quan nếu bạn phải mong đợi khoảng trống trong tên tệp.

NB: công cụ tích hợp duy nhất không phải là về đầu ra mà là về trạng thái của lệnh cuối cùng.

bạn có thể sử dụng !!: 1. Thí dụ:

~]$ ls *.~
class1.cpp~ class1.h~ main.cpp~ CMakeList.txt~ 

~]$ rm !!:1
rm class1.cpp~ class1.h~ main.cpp~ CMakeList.txt~ 


~]$ ls file_to_remove1 file_to_remove2
file_to_remove1 file_to_remove2

~]$ rm !!:1
rm file_to_remove1

~]$ rm !!:2
rm file_to_remove2

Tôi có một nhu cầu tương tự, trong đó tôi muốn sử dụng đầu ra của lệnh cuối cùng vào lệnh tiếp theo. Giống như một | (ống). ví dụ

$ which gradle 
/usr/bin/gradle
$ ls -alrt /usr/bin/gradle

đến một cái gì đó như -

$ which gradle |: ls -altr {}

Giải pháp: Tạo đường ống tùy chỉnh này. Thực sự đơn giản, sử dụng xargs -

$ alias :='xargs -I{}'

Về cơ bản không có gì bằng cách tạo ra một bàn tay ngắn cho xargs, nó hoạt động như sự quyến rũ, và thực sự tiện dụng. Tôi chỉ cần thêm bí danh trong tệp .bash_profile.

Nó có thể được thực hiện bằng cách sử dụng phép thuật của mô tả tập tin và lastpipe tùy chọn shell.

Nó phải được thực hiện với một tập lệnh - tùy chọn "Lastpipe" sẽ không hoạt động trong chế độ tương tác.

Đây là kịch bản tôi đã thử nghiệm với:

$ cat shorttest.sh 
#!/bin/bash
shopt -s lastpipe

exit_tests() {
    EXITMSG="$(cat /proc/self/fd/0)"
}

ls /bloop 2>&1 | exit_tests

echo "My output is \"$EXITMSG\""


$ bash shorttest.sh 
My output is "ls: cannot access '/bloop': No such file or directory"

Những gì tôi đang làm ở đây là:

1. thiết lập tùy chọn shell shopt -s lastpipe. Nó sẽ không hoạt động mà không có điều này vì bạn sẽ mất mô tả tập tin.

2. đảm bảo stderr của tôi cũng bị bắt với 2>&1

3. dẫn đầu ra vào một hàm để có thể tham chiếu bộ mô tả tệp stdin.

4. thiết lập biến bằng cách lấy nội dung của bộ /proc/self/fd/0mô tả tệp, đó là stdin.

Tôi đang sử dụng điều này để ghi lại các lỗi trong tập lệnh vì vậy nếu có vấn đề với lệnh tôi có thể dừng xử lý tập lệnh và thoát ngay lập tức.

shopt -s lastpipe

exit_tests() {
    MYSTUFF="$(cat /proc/self/fd/0)"
    BADLINE=$BASH_LINENO
}

error_msg () {
    echo -e "$0: line $BADLINE\n\t $MYSTUFF"
    exit 1
}

ls /bloop 2>&1 | exit_tests ; [[ "${PIPESTATUS[0]}" == "0" ]] || error_msg

Bằng cách này tôi có thể thêm 2>&1 | exit_tests ; [[ "${PIPESTATUS[0]}" == "0" ]] || error_msgđằng sau mỗi lệnh tôi quan tâm để kiểm tra.

Bây giờ bạn có thể tận hưởng đầu ra của bạn!

Đây không hoàn toàn là một giải pháp bash nhưng bạn có thể sử dụng đường ống với sed để có được hàng cuối cùng của đầu ra lệnh trước đó.

Trước tiên hãy xem những gì tôi có trong thư mục "a"

rasjani@helruo-dhcp022206::~$ find a
a
a/foo
a/bar
a/bat
a/baz
rasjani@helruo-dhcp022206::~$ 

Sau đó, ví dụ của bạn với ls và cd sẽ chuyển sang sed & piping thành một cái gì đó như thế này:

rasjani@helruo-dhcp022206::~$ cd `find a |sed '$!d'`
rasjani@helruo-dhcp022206::~/a/baz$ pwd
/home/rasjani/a/baz
rasjani@helruo-dhcp022206::~/a/baz$

Vì vậy, phép thuật thực tế xảy ra với sed, bạn chuyển những gì từng xuất ra của lệnh từng thành sed và sed in hàng cuối cùng mà bạn có thể sử dụng làm tham số với dấu tích ngược. Hoặc bạn có thể kết hợp nó để xargs cũng. ("man xargs" trong shell là bạn của bạn)

Shell không có các ký hiệu đặc biệt giống như perl lưu trữ kết quả tiếng vang của lệnh cuối cùng.

Tìm hiểu để sử dụng biểu tượng đường ống với awk.

find . | awk '{ print "FILE:" $0 }'

Trong ví dụ trên bạn có thể làm:

find . -name "foo.txt" | awk '{ print "mv "$0" ~/bar/" | "sh" }'

find . -name foo.txt 1> tmpfile && mv `cat tmpfile` /path/to/some/dir/

là một cách khác, mặc dù bẩn.

Tôi thấy việc ghi nhớ đầu ra các lệnh của tôi vào một tệp cụ thể sẽ gây khó chịu đôi chút, giải pháp của tôi là một chức năng trong .bash_profile đó bắt đầu ra trong một tệp và trả về kết quả khi bạn cần.

Ưu điểm của cái này là bạn không phải chạy lại toàn bộ lệnh (khi sử dụng findhoặc các lệnh chạy dài khác có thể rất quan trọng)

Đủ đơn giản, dán cái này vào .bash_profile:

Kịch bản

# catch stdin, pipe it to stdout and save to a file
catch () { cat - | tee /tmp/catch.out}
# print whatever output was saved to a file
res () { cat /tmp/catch.out }

Sử dụng

$ find . -name 'filename' | catch
/path/to/filename

$ res
/path/to/filename

Tại thời điểm này, tôi có xu hướng chỉ thêm | catch vào cuối tất cả các lệnh của mình, bởi vì không có chi phí để thực hiện và nó giúp tôi tiết kiệm được các lệnh mất nhiều thời gian để hoàn thành.

Ngoài ra, nếu bạn muốn mở đầu ra tệp trong trình soạn thảo văn bản, bạn có thể thực hiện việc này:

# vim or whatever your favorite text editor is
$ vim <(res)