cách ngắn nhất để thay thế các ký tự trong một biến

Có nhiều cách để thay thế các ký tự trong một biến.

Cách ngắn nhất tôi tìm ra là trcho đến nay:

OUTPUT=a\'b\"c\`d_123and_a_lot_more
OUTPUT=$(echo "$OUTPUT"|tr -d "'\`\"")
echo $OUTPUT

Có cách nào nhanh hơn? Và trích dẫn này có an toàn cho các trích dẫn như ', "và chính nó không?

Hãy xem nào. Điều ngắn nhất tôi có thể đưa ra là một tinh chỉnh trgiải pháp của bạn :

OUTPUT="$(tr -d "\"\`'" <<<$OUTPUT)"

Các lựa chọn thay thế khác bao gồm thay thế biến đã được đề cập có thể ngắn hơn hiển thị cho đến nay:

OUTPUT="${OUTPUT//[\'\"\`]}"

Và sedtất nhiên mặc dù điều này dài hơn về các nhân vật:

OUTPUT="$(sed s/[\'\"\`]//g <<<$OUTPUT)"

Tôi không chắc chắn nếu bạn có nghĩa là ngắn nhất về chiều dài hoặc về thời gian thực hiện. Về chiều dài, hai cái này ngắn như nó có được (hoặc như tôi có thể lấy nó bằng mọi cách) khi nói đến việc loại bỏ các ký tự cụ thể đó. Vậy, cái nào nhanh nhất? Tôi đã kiểm tra bằng cách đặt OUTPUTbiến thành những gì bạn có trong ví dụ của mình nhưng lặp lại vài chục lần:

$ echo ${#OUTPUT} 
4900

$ time tr -d "\"\`'" <<<$OUTPUT
real    0m0.002s
user    0m0.004s
sys     0m0.000s
$ time sed s/[\'\"\`]//g <<<$OUTPUT
real    0m0.005s
user    0m0.000s
sys     0m0.000s
$ time echo ${OUTPUT//[\'\"\`]}
real    0m0.027s
user    0m0.028s
sys     0m0.000s

Như bạn có thể thấy, trrõ ràng là nhanh nhất, theo sát bởi sed. Ngoài ra, có vẻ như việc sử dụng echothực sự nhanh hơn một chút so với sử dụng <<<:

$ for i in {1..10}; do 
    ( time echo $OUTPUT | tr -d "\"\`'" > /dev/null ) 2>&1
done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0025
$ for i in {1..10}; do 
    ( time tr -d "\"\`'" <<<$OUTPUT > /dev/null ) 2>&1 
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0029

Vì sự khác biệt là rất nhỏ, tôi đã thực hiện các bài kiểm tra trên 10 lần cho mỗi trong hai và hóa ra rằng nhanh nhất thực sự là bài kiểm tra mà bạn phải bắt đầu:

echo $OUTPUT | tr -d "\"\`'" 

Tuy nhiên, điều này thay đổi khi bạn tính đến chi phí chung của việc gán cho một biến, ở đây, sử dụng trchậm hơn một chút so với thay thế đơn giản:

$ for i in {1..10}; do
    ( time OUTPUT=${OUTPUT//[\'\"\`]} ) 2>&1
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0032

$ for i in {1..10}; do
    ( time OUTPUT=$(echo $OUTPUT | tr -d "\"\`'")) 2>&1
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0044

Vì vậy, để kết luận, khi bạn chỉ muốn xem kết quả, hãy sử dụng trnhưng nếu bạn muốn gán lại cho một biến, sử dụng các tính năng thao tác chuỗi của shell sẽ nhanh hơn vì chúng tránh được chi phí chạy một lớp con riêng biệt.

Bạn có thể sử dụng thay thế biến :

$ OUTPUT=a\'b\"c\`d
$ echo "$OUTPUT"
a'b"c`d

Sử dụng cú pháp đó: ${parameter//pattern/string}để thay thế tất cả các lần xuất hiện của mẫu bằng chuỗi.

$ echo "${OUTPUT//\'/x}"
axb"c`d
$ echo "${OUTPUT//\"/x}"
a'bxc`d
$ echo "${OUTPUT//\`/x}"
a'b"cxd
$ echo "${OUTPUT//[\'\"\`]/x}"
axbxcxd

Trong bash hoặc zsh, nó là:

OUTPUT="${OUTPUT//[\`\"\']/}"

Lưu ý rằng ${VAR//PATTERN/}loại bỏ tất cả các trường hợp của mẫu. Để biết thêm thông tin mở rộng tham số bash

Giải pháp này phải nhanh nhất cho các chuỗi ngắn vì nó không liên quan đến việc chạy bất kỳ chương trình bên ngoài nào. Tuy nhiên, đối với các chuỗi rất dài thì điều ngược lại là đúng - tốt hơn là sử dụng công cụ chuyên dụng cho các hoạt động văn bản, ví dụ:

$ OUTPUT="$(cat /usr/src/linux/.config)"

$ time (echo $OUTPUT | OUTPUT="${OUTPUT//set/abc}")
real    0m1.766s
user    0m1.681s
sys     0m0.002s

$ time (echo $OUTPUT | sed s/set/abc/g >/dev/null)
real    0m0.094s
user    0m0.078s
sys     0m0.006s

Nếu, trong trường hợp không may, bạn chỉ đang cố gắng xử lý các trích dẫn để tái sử dụng ion vỏ, thì bạn có thể làm điều này mà không cần loại bỏ chúng, và nó cũng rất đơn giản:

aq() { sh -c 'for a do
       alias "$((i=$i+1))=$a"
       done; alias' -- "$@"
}

Hàm shell đó trích dẫn bất kỳ mảng arg nào bạn trao cho nó và tăng đầu ra của nó cho mỗi đối số có thể lặp lại.

Đây là với một vài lập luận:

aq \
"here's an
ugly one" \
"this one is \$PATHpretty bad, too" \
'this one```****```; totally sucks'

ĐẦU RA

1='here'"'"'s an
ugly one'
2='this one is $PATHpretty bad, too'
3='this one```****```; totally sucks'

Đầu ra đó là từ dashmà thông thường trích dẫn an toàn trích dẫn đầu ra như thế '"'"'. bashsẽ làm gì '\''.

Việc thay thế một lựa chọn các byte đơn, không phải khoảng trắng, không null bằng một byte đơn khác có thể được thực hiện nhanh nhất trong bất kỳ shell POSIX nào bằng $IFSvà $*.

set -f; IFS=\"\'\`; set -- $var; printf %s "$*"

ĐẦU RA

"some ""crazy """"""""string ""here

Ở đó tôi chỉ printfcó nó để bạn có thể nhìn thấy nó, nhưng tất nhiên, nếu tôi đã làm:

var="$*"

... Thay vì giá trị của printflệnh $varsẽ là những gì bạn thấy trong đầu ra ở đó.

Khi tôi set -fchỉ thị shell không phải toàn cầu - trong trường hợp chuỗi chứa các ký tự có thể được hiểu là các mẫu hình cầu. Tôi làm điều này bởi vì trình phân tích cú pháp shell sẽ mở rộng các mẫu toàn cục sau khi nó thực hiện phân tách trường trên các biến. Globing có thể được kích hoạt lại như thế nào set +f. Nói chung - trong các tập lệnh - tôi thấy hữu ích khi đặt bang của mình như:

#!/usr/bin/sh -f

Và sau đó để kích hoạt toàn cầu với set +fbất kỳ dòng nào tôi có thể muốn.

Trường tách xảy ra dựa trên các ký tự trong $IFS.

Có hai loại $IFSgiá trị - $IFSkhoảng trắng và $IFSkhông khoảng trắng. $IFSCác trường được phân cách bằng khoảng trắng ( dấu cách, tab, dòng mới) được chỉ định để tách biệt theo trình tự thành một trường duy nhất (hoặc không có gì cả nếu chúng không đi trước một cái gì khác) - vì vậy ...

IFS=\ ; var='      '; printf '<%s>' $var
<>

Nhưng tất cả những thứ khác được chỉ định để đánh giá một trường duy nhất cho mỗi lần xuất hiện - chúng không bị cắt cụt.

IFS=/; var='/////'; printf '<%s>' $var
<><><><><>

Theo mặc định, tất cả các mở rộng biến là $IFScác mảng dữ liệu được phân tách - chúng phân tách thành các trường riêng biệt theo $IFS. Khi bạn "trích dẫn một, bạn ghi đè lên thuộc tính mảng đó và đánh giá nó dưới dạng một chuỗi.

Vì vậy, khi tôi làm ...

IFS=\"\'\`; set -- $var

Tôi đang đặt mảng đối số của shell thành nhiều $IFStrường được phân tách bằng cách $varmở rộng. Khi nó được mở rộng, các giá trị cấu thành của nó cho các ký tự chứa trong $IFSđó bị mất - hiện tại chúng chỉ là các dấu tách trường - chúng là \0NUL.

"$*"- giống như các mở rộng biến được trích dẫn kép khác - cũng ghi đè lên các phẩm chất phân tách trường của $IFS. Nhưng, ngoài ra , nó thay thế byte đầu tiên $IFS cho mỗi trường được phân tách trong "$@". Vì vậy, vì "là lần đầu tiên giá trị trong $IFS tất cả các delimiters tiếp theo trở nên "trong "$*". Và "không cần thiết $IFSkhi bạn chia nó. Bạn có thể thay đổi hoàn toàn $IFS sau set -- $args một giá trị khác và byte đầu tiên mới của nó sau đó sẽ hiển thị cho các dấu phân cách trường trong "$*". Hơn thế nữa, bạn có thể xóa tất cả dấu vết của chúng hoàn toàn như:

set -- $var; IFS=; printf %s "$*"

ĐẦU RA

some crazy string here