小开

如果不想依赖Perl，也可以使用sed。这有点混乱，因为每个角色都必须单独转义。用以下内容创建一个文件，并将其命名为urlencode.sed

s/%/%25/g
s/ /%20/g
s/ /%09/g
s/!/%21/g
s/"/%22/g
s/#/%23/g
s/\$/%24/g
s/\&/%26/g
s/'\''/%27/g
s/(/%28/g
s/)/%29/g
s/\*/%2a/g
s/+/%2b/g
s/,/%2c/g
s/-/%2d/g
s/\./%2e/g
s/\//%2f/g
s/:/%3a/g
s/;/%3b/g
s//%3e/g
s/?/%3f/g
s/@/%40/g
s/\[/%5b/g
s/\\/%5c/g
s/\]/%5d/g
s/\^/%5e/g
s/_/%5f/g
s/`/%60/g
s/{/%7b/g
s/|/%7c/g
s/}/%7d/g
s/~/%7e/g
s/      /%09/g

要使用它，请执行以下操作。

STR1=$(echo "https://www.example.com/change&$ ^this to?%checkthe@-functionality" | cut -d\? -f1)
STR2=$(echo "https://www.example.com/change&$ ^this to?%checkthe@-functionality" | cut -d\? -f2)
OUT2=$(echo "$STR2" | sed -f urlencode.sed)
echo "$STR1?$OUT2"

这将把字符串分成需要编码的部分，而没问题的部分，编码需要它的部分，然后缝合在一起。

为了方便起见，你可以把它放在sh脚本中，也许让它带一个参数来编码，把它放在你的路径上，然后你可以调用:

urlencode https://www.exxample.com?isThisFun=HellNo

_source

小开

在bash脚本的第二行中使用Perl的URI::Escape模块和uri_escape函数:

...


value="$(perl -MURI::Escape -e 'print uri_escape($ARGV[0]);' "$2")"
...

编辑:修复引用问题，正如Chris Johnsen在评论中所建议的那样。谢谢!

小开

直接链接到awk版本:http://www.shelldorado.com/scripts/cmds/urlencode
我使用它很多年了，它就像一个魅力

:
##########################################################################
# Title      :  urlencode - encode URL data
# Author     :  Heiner Steven (heiner.steven@odn.de)
# Date       :  2000-03-15
# Requires   :  awk
# Categories :  File Conversion, WWW, CGI
# SCCS-Id.   :  @(#) urlencode  1.4 06/10/29
##########################################################################
# Description
#   Encode data according to
#       RFC 1738: "Uniform Resource Locators (URL)" and
#       RFC 1866: "Hypertext Markup Language - 2.0" (HTML)
#
#   This encoding is used i.e. for the MIME type
#   "application/x-www-form-urlencoded"
#
# Notes
#    o  The default behaviour is not to encode the line endings. This
#   may not be what was intended, because the result will be
#   multiple lines of output (which cannot be used in an URL or a
#   HTTP "POST" request). If the desired output should be one
#   line, use the "-l" option.
#
#    o  The "-l" option assumes, that the end-of-line is denoted by
#   the character LF (ASCII 10). This is not true for Windows or
#   Mac systems, where the end of a line is denoted by the two
#   characters CR LF (ASCII 13 10).
#   We use this for symmetry; data processed in the following way:
#       cat | urlencode -l | urldecode -l
#   should (and will) result in the original data
#
#    o  Large lines (or binary files) will break many AWK
#       implementations. If you get the message
#       awk: record `...' too long
#        record number xxx
#   consider using GNU AWK (gawk).
#
#    o  urlencode will always terminate it's output with an EOL
#       character
#
# Thanks to Stefan Brozinski for pointing out a bug related to non-standard
# locales.
#
# See also
#   urldecode
##########################################################################


PN=`basename "$0"`          # Program name
VER='1.4'


: ${AWK=awk}


Usage () {
echo >&2 "$PN - encode URL data, $VER
usage: $PN [-l] [file ...]
-l:  encode line endings (result will be one line of output)


The default is to encode each input line on its own."
exit 1
}


Msg () {
for MsgLine
do echo "$PN: $MsgLine" >&2
done
}


Fatal () { Msg "$@"; exit 1; }


set -- `getopt hl "$@" 2>/dev/null` || Usage
[ $# -lt 1 ] && Usage           # "getopt" detected an error


EncodeEOL=no
while [ $# -gt 0 ]
do
case "$1" in
-l) EncodeEOL=yes;;
--) shift; break;;
-h) Usage;;
-*) Usage;;
*)  break;;         # First file name
esac
shift
done


LANG=C  export LANG
$AWK '
BEGIN {
# We assume an awk implementation that is just plain dumb.
# We will convert an character to its ASCII value with the
# table ord[], and produce two-digit hexadecimal output
# without the printf("%02X") feature.


EOL = "%0A"     # "end of line" string (encoded)
split ("1 2 3 4 5 6 7 8 9 A B C D E F", hextab, " ")
hextab [0] = 0
for ( i=1; i<=255; ++i ) ord [ sprintf ("%c", i) "" ] = i + 0
if ("'"$EncodeEOL"'" == "yes") EncodeEOL = 1; else EncodeEOL = 0
}
{
encoded = ""
for ( i=1; i<=length ($0); ++i ) {
c = substr ($0, i, 1)
if ( c ~ /[a-zA-Z0-9.-]/ ) {
encoded = encoded c     # safe character
} else if ( c == " " ) {
encoded = encoded "+"   # special handling
} else {
# unsafe character, encode it as a two-digit hex-number
lo = ord [c] % 16
hi = int (ord [c] / 16);
encoded = encoded "%" hextab [hi] hextab [lo]
}
}
if ( EncodeEOL ) {
printf ("%s", encoded EOL)
} else {
print encoded
}
}
END {
#if ( EncodeEOL ) print ""
}
' "$@"

小开

我发现下面的代码片段很有用，可以将它插入到一个程序调用链中，其中URI::Escape可能没有安装:

perl -p -e 's/([^A-Za-z0-9])/sprintf("%%%02X", ord($1))/seg'

(源)

小开

最佳答案

使用curl --data-urlencode;从man curl:

它发布数据，类似于其他--data选项，不同的是它执行url编码。为了与cgi兼容，<data>部分应该以名称开头，后面跟着分隔符和内容说明。

使用示例:

curl \
--data-urlencode "paramName=value" \
--data-urlencode "secondParam=value" \
http://example.com

更多信息请参见手册页。

这需要curl 7.18.0或更新版本(发布于2008年1月)。使用curl -V来检查你拥有的版本。

你也可以对查询字符串进行编码:

curl --get \
--data-urlencode "p1=value 1" \
--data-urlencode "p2=value 2" \
http://example.com
# http://example.com?p1=value%201&p2=value%202

小开

我发现在python中可读性更好:

encoded_value=$(python3 -c "import urllib.parse; print urllib.parse.quote('''$value''')")

三重'确保单引号的值不会有伤害。Urllib在标准库中。它的工作，例如这个疯狂的(现实世界)url:

"http://www.rai.it/dl/audio/" "1264165523944Ho servito il re d'Inghilterra - Puntata 7

小开

对于那些正在寻找不需要perl的解决方案的人来说，这里有一个只需要hexdump和awk的解决方案:

url_encode() {
[ $# -lt 1 ] && { return; }


encodedurl="$1";


# make sure hexdump exists, if not, just give back the url
[ ! -x "/usr/bin/hexdump" ] && { return; }


encodedurl=`
echo $encodedurl | hexdump -v -e '1/1 "%02x\t"' -e '1/1 "%_c\n"' |
LANG=C awk '
$1 == "20"                    { printf("%s",   "+"); next } # space becomes plus
$1 ~  /0[adAD]/               {                      next } # strip newlines
$2 ~  /^[a-zA-Z0-9.*()\/-]$/  { printf("%s",   $2);  next } # pass through what we can
{ printf("%%%s", $1)        } # take hex value of everything else
'`
}

通过网络上的几个地方和当地的一些试验和错误拼接在一起。效果很好!

小开

url=$(echo "$1" | sed -e 's/%/%25/g' -e 's/ /%20/g' -e 's/!/%21/g' -e 's/"/%22/g' -e 's/#/%23/g' -e 's/\$/%24/g' -e 's/\&/%26/g' -e 's/'\''/%27/g' -e 's/(/%28/g' -e 's/)/%29/g' -e 's/\*/%2a/g' -e 's/+/%2b/g' -e 's/,/%2c/g' -e 's/-/%2d/g' -e 's/\./%2e/g' -e 's/\//%2f/g' -e 's/:/%3a/g' -e 's/;/%3b/g' -e 's//%3e/g' -e 's/?/%3f/g' -e 's/@/%40/g' -e 's/\[/%5b/g' -e 's/\\/%5c/g' -e 's/\]/%5d/g' -e 's/\^/%5e/g' -e 's/_/%5f/g' -e 's/`/%60/g' -e 's/{/%7b/g' -e 's/|/%7c/g' -e 's/}/%7d/g' -e 's/~/%7e/g')

这将对$1中的字符串进行编码，并将其输出到$url中。尽管你不需要把它放在var中。顺便说一句，没有包括sed for选项卡，认为它会把它变成空格

小开

如果你想运行GET请求并使用纯curl，只需将--get添加到@Jacob的解决方案中。

这里有一个例子:

curl -v --get --data-urlencode "access_token=$(cat .fb_access_token)" https://graph.facebook.com/me/feed

小开

下面是一个使用Lua的单行转换，类似于旅行包的回答，只是所有的RFC 3986无保留字符都没有被编码(比如这个答案):

url=$(echo 'print((arg[1]:gsub("([^%w%-%.%_%~])",function(c)return("%%%02X"):format(c:byte())end)))' | lua - "$1")

此外，您可能需要确保字符串中的换行符从LF转换为CRLF，在这种情况下，您可以在百分比编码之前的链中插入gsub("\r?\n", "\r\n")。

下面是应用程序/x-www-form-urlencoded的非标准样式中的一个变体，它执行换行归一化，并将空格编码为'+'而不是'%20'(可以使用类似的技术将其添加到Perl代码片段中)。

url=$(echo 'print((arg[1]:gsub("\r?\n", "\r\n"):gsub("([^%w%-%.%_%~ ]))",function(c)return("%%%02X"):format(c:byte())end):gsub(" ","+"))' | lua - "$1")

小开

为了完整起见，许多使用sed或awk的解决方案只翻译一组特殊的字符，因此代码大小相当大，也不翻译其他应该编码的特殊字符。

urlencode的一个安全方法是对每个字节进行编码——即使是那些允许的字节。

echo -ne 'some random\nbytes' | xxd -plain | tr -d '\n' | sed 's/\(..\)/%\1/g'

XXD在这里小心地将输入处理为字节而不是字符。

编辑:

xxd附带了Debian中的vim-common包，我只是在一个没有安装它的系统上，我不想安装它。另一种方法是使用Debian中的bsdmainutils包中的hexdump。根据下图，bsdmainutils和vim-common应该有相同的可能性被安装:

http://qa.debian.org/popcon-png.php?packages=vim-common%2Cbsdmainutils&show_installed=1&want_legend=1&want_ticks=1

尽管如此，这里有一个版本使用hexdump而不是xxd，并允许避免tr调用:

echo -ne 'some random\nbytes' | hexdump -v -e '/1 "%02x"' | sed 's/\(..\)/%\1/g'

小开

从shell脚本中使用php:

value="http://www.google.com"
encoded=$(php -r "echo rawurlencode('$value');")
# encoded = "http%3A%2F%2Fwww.google.com"
echo $(php -r "echo rawurldecode('$encoded');")
# returns: "http://www.google.com"

小开

下面是纯BASH的答案。

更新:由于已经讨论了许多更改，我已经将此放在https://github.com/sfinktah/bash/blob/master/rawurlencode.inc.sh上，任何人都可以对其发出PR。

请注意:这个解决方案并不打算编码unicode或多字节字符——这完全超出了BASH的简陋本地的功能。它仅用于编码那些在POST或GET请求中会破坏参数传递的符号，例如。'&'， '='等等。

__abc0:不要尝试用任何语言编写自己的unicode转换函数。见答案结尾。

rawurlencode() {
local string="${1}"
local strlen=${#string}
local encoded=""
local pos c o


for (( pos=0 ; pos<strlen ; pos++ )); do
c=${string:$pos:1}
case "$c" in
[-_.~a-zA-Z0-9] ) o="${c}" ;;
* )               printf -v o '%%%02x' "'$c"
esac
encoded+="${o}"
done
echo "${encoded}"    # You can either set a return variable (FASTER)
REPLY="${encoded}"   #+or echo the result (EASIER)... or both... :p
}

你可以在两种情况下使用它:

easier:  echo http://url/q?=$( rawurlencode "$args" )
faster:  rawurlencode "$args"; echo http://url/q?${REPLY}

(编辑)

下面是匹配的rawurldecode()函数，它非常棒。

# Returns a string in which the sequences with percent (%) signs followed by
# two hex digits have been replaced with literal characters.
rawurldecode() {


# This is perhaps a risky gambit, but since all escape characters must be
# encoded, we can replace %NN with \xNN and pass the lot to printf -b, which
# will decode hex for us


printf -v REPLY '%b' "${1//%/\\x}" # You can either set a return variable (FASTER)


echo "${REPLY}"  #+or echo the result (EASIER)... or both... :p
}

有了匹配集，我们现在可以执行一些简单的测试:

$ diff rawurlencode.inc.sh \
<( rawurldecode "$( rawurlencode "$( cat rawurlencode.inc.sh )" )" ) \
&& echo Matched


Output: Matched

如果你真的觉得你需要一个外部工具(好吧，它会快得多，可能会处理二进制文件之类的…)我在我的OpenWRT路由器上发现了这个…

replace_value=$(echo $replace_value | sed -f /usr/lib/ddns/url_escape.sed)

url_escape的地方。Sed是一个包含以下规则的文件:

# sed url escaping
s:%:%25:g
s: :%20:g
s:<:%3C:g
s:>:%3E:g
s:#:%23:g
s:{:%7B:g
s:}:%7D:g
s:|:%7C:g
s:\\:%5C:g
s:\^:%5E:g
s:~:%7E:g
s:\[:%5B:g
s:\]:%5D:g
s:`:%60:g
s:;:%3B:g
s:/:%2F:g
s:?:%3F:g
s^:^%3A^g
s:@:%40:g
s:=:%3D:g
s:&:%26:g
s:\$:%24:g
s:\!:%21:g
s:\*:%2A:g

虽然在BASH中编写这样一个能够处理UTF-8输入的脚本(可能使用xxd和一个非常长的规则集)并非不可能，但有更快更可靠的方法。试图将UTF-8解码为UTF-32是一项非常重要的任务，要做到准确，尽管很容易做得不准确，以至于您认为它有效，直到有一天它不起作用。

甚至Unicode联盟在发现样本代码不再100%与实际标准兼容后，也删除了样本代码。

Unicode标准在不断发展，变得非常微妙。你可以拼凑的任何实现都不会正确地兼容，如果你通过一些极端的努力来管理它，它也不会保持兼容。

小开

其中一种变体可能很丑，但很简单:

urlencode() {
local data
if [[ $# != 1 ]]; then
echo "Usage: $0 string-to-urlencode"
return 1
fi
data="$(curl -s -o /dev/null -w %{url_effective} --get --data-urlencode "$1" "")"
if [[ $? != 3 ]]; then
echo "Unexpected error" 1>&2
return 2
fi
echo "${data##/?}"
return 0
}

例如，下面是一行代码的版本(由< em >布鲁诺< / em >建议):

date | curl -Gso /dev/null -w %{url_effective} --data-urlencode @- "" | cut -c 3-


# If you experience the trailing %0A, use
date | curl -Gso /dev/null -w %{url_effective} --data-urlencode @- "" | sed -E 's/..(.*).../\1/'

小开

Ruby，为了完整性

value="$(ruby -r cgi -e 'puts CGI.escape(ARGV[0])' "$2")"

小开

uni2ascii非常方便:

$ echo -ne '你好世界' | uni2ascii -aJ
%E4%BD%A0%E5%A5%BD%E4%B8%96%E7%95%8C

小开

这可能是最好的一个:

after=$(echo -e "$before" | od -An -tx1 | tr ' ' % | xargs printf "%s")

小开

安装php后，我使用这种方式:

URL_ENCODED_DATA=`php -r "echo urlencode('$DATA');"`

小开

另一种php方法:

echo "encode me" | php -r "echo urlencode(file_get_contents('php://stdin'));"

小开

这是orwellophile的答案的ksh版本，包含rawurlencode和rawurldecode函数(链接:如何为curl命令urlencode数据?)。我没有足够的代表发表评论，因此有了新的帖子。

#!/bin/ksh93


function rawurlencode
{
typeset string="${1}"
typeset strlen=${#string}
typeset encoded=""


for (( pos=0 ; pos<strlen ; pos++ )); do
c=${string:$pos:1}
case "$c" in
[-_.~a-zA-Z0-9] ) o="${c}" ;;
* )               o=$(printf '%%%02x' "'$c")
esac
encoded+="${o}"
done
print "${encoded}"
}


function rawurldecode
{
printf $(printf '%b' "${1//%/\\x}")
}


print $(rawurlencode "C++")     # --> C%2b%2b
print $(rawurldecode "C%2b%2b") # --> C++

小开

这是节点版本:

uriencode() {
node -p "encodeURIComponent('${1//\'/\\\'}')"
}

小开

问题是在bash中做这个，不需要python或perl，因为实际上有一个命令可以做你想要的事情——“urlencode”。

value=$(urlencode "${2}")

这也更好，因为上面的perl答案，例如，没有正确编码所有字符。尝试使用从Word中获得的长破折号，你会得到错误的编码。

注意，你需要"gridsite-clients"安装来提供这个命令:

sudo apt install gridsite-clients

小开

你可以在perl中模拟javascript的encodeURIComponent。下面是命令:

perl -pe 's/([^a-zA-Z0-9_.!~*()'\''-])/sprintf("%%%02X", ord($1))/ge'

你可以在.bash_profile中将其设置为bash别名:

alias encodeURIComponent='perl -pe '\''s/([^a-zA-Z0-9_.!~*()'\''\'\'''\''-])/sprintf("%%%02X",ord($1))/ge'\'

现在你可以导入encodeURIComponent:

$ echo -n 'hèllo wôrld!' | encodeURIComponent
h%C3%A8llo%20w%C3%B4rld!

小开

简单的PHP选项:

echo 'part-that-needs-encoding' | php -R 'echo urlencode($argn);'

小开

另一个选项是使用jq:

$ printf %s 'input text'|jq -sRr @uri
input%20text
$ jq -rn --arg x 'input text' '$x|@uri'
input%20text

-r (--raw-output)输出字符串的原始内容，而不是JSON字符串字面量。-n (--null-input)不从STDIN读取输入。

-R (--raw-input)将输入行视为字符串，而不是将其解析为JSON，并且-sR (--slurp --raw-input)将输入读入单个字符串。如果你的输入只包含一行，或者你不想用%0A替换换行符，你可以用-Rr替换-sRr:

$ printf %s\\n multiple\ lines of\ text|jq -Rr @uri
multiple%20lines
of%20text
$ printf %s\\n multiple\ lines of\ text|jq -sRr @uri
multiple%20lines%0Aof%20text%0A

或者这个百分比编码所有字节:

xxd -p|tr -d \\n|sed 's/../%&/g'

小开

下面是一个POSIX函数:

url_encode() {
awk 'BEGIN {
for (n = 0; n < 125; n++) {
m[sprintf("%c", n)] = n
}
n = 1
while (1) {
s = substr(ARGV[1], n, 1)
if (s == "") {
break
}
t = s ~ /[[:alnum:]_.!~*\47()-]/ ? t s : t sprintf("%%%02X", m[s])
n++
}
print t
}' "$1"
}

例子:

value=$(url_encode "$2")

小开

下面是一个不调用任何外部程序的Bash解决方案:

uriencode() {
s="${1//'%'/%25}"
s="${s//' '/%20}"
s="${s//'"'/%22}"
s="${s//'#'/%23}"
s="${s//'$'/%24}"
s="${s//'&'/%26}"
s="${s//'+'/%2B}"
s="${s//','/%2C}"
s="${s//'/'/%2F}"
s="${s//':'/%3A}"
s="${s//';'/%3B}"
s="${s//'='/%3D}"
s="${s//'?'/%3F}"
s="${s//'@'/%40}"
s="${s//'['/%5B}"
s="${s//']'/%5D}"
printf %s "$s"
}

小开

下面是我的嵌入式系统busybox ash shell版本，我最初采用了Orwellophile的变体:

urlencode()
{
local S="${1}"
local encoded=""
local ch
local o
for i in $(seq 0 $((${#S} - 1)) )
do
ch=${S:$i:1}
case "${ch}" in
[-_.~a-zA-Z0-9])
o="${ch}"
;;
*)
o=$(printf '%%%02x' "'$ch")
;;
esac
encoded="${encoded}${o}"
done
echo ${encoded}
}


urldecode()
{
# urldecode <string>
local url_encoded="${1//+/ }"
printf '%b' "${url_encoded//%/\\x}"
}

小开

有什么能比javascript更好地解析url呢?

node -p "encodeURIComponent('$url')"

小开

以下是基于Orwellophile的答案，但解决了多字节通过设置LC_ALL=C (vte.sh的一个技巧)在评论中提到的错误。我把它写成了函数PROMPT_COMMAND的形式，因为这就是我使用它的方式。

print_path_url() {
local LC_ALL=C
local string="$PWD"
local strlen=${#string}
local encoded=""
local pos c o


for (( pos=0 ; pos<strlen ; pos++ )); do
c=${string:$pos:1}
case "$c" in
[-_.~a-zA-Z0-9/] ) o="${c}" ;;
* )               printf -v o '%%%02x' "'$c"
esac
encoded+="${o}"
done
printf "\033]7;file://%s%s\007" "${HOSTNAME:-}" "${encoded}"
}

小开

对于我的一个案例，我发现NodeJS url库有最简单的解决方案。当然是YMMV

$ urlencode(){ node -e "console.log(require('url').parse(process.argv.slice(1).join('+')).href)" "$@"; }


$ urlencode "https://example.com?my_database_has=these 'nasty' query strings in it"
https://example.com/?my_database_has=these%20%27nasty%27%20query%20strings%20in%20it

小开

Orwellophile给出了一个很好的答案，它包含了一个纯bash选项(函数rawurlencode)，我在我的网站上使用过(基于shell的CGI脚本，响应搜索请求的大量url)。唯一的缺点是高峰期间CPU过高。

我找到了一个改进的解决方案，利用bash "global replace"特性。有了这个解决方案，url编码的处理时间快了4倍。解决方案识别要转义的字符，并使用“全局替换”;操作符(${var//source/replacement})来处理所有替换。这种速度的提高显然来自于使用bash内部循环，而不是显式循环。

性能:核心i3-8100 3.60Ghz。测试用例:来自堆栈溢出的1000个URL，类似于这个票据:"https://stackoverflow.com/questions/296536/how-to-urlencode-data-for-curl-command"

现有解决方案:0.807秒
优化方案:0.162秒(5倍加速)

url_encode()
{
local key="${1}" varname="${2:-_rval}" prefix="${3:-_ENCKEY_}"
local unsafe=${key//[-_.~a-zA-Z0-9 ]/}
local -i key_len=${#unsafe}
local ch ch1 ch0


while [ "$unsafe" ] ;do
ch=${unsafe:0:1}
ch0="\\$ch"
printf -v ch1 '%%%02x' "'$ch'"
key=${key//$ch0/"$ch1"}
unsafe=${unsafe//"$ch0"}
done
key=${key// /+}


REPLY="$key"
# printf "%s" "$REPLY"
return 0
}

作为一个次要的额外字符，它使用'+'来编码空格。稍微紧凑的URL。

基准:

function t {
local key
for (( i=1 ; i<=$1 ; i++ )) do url_encode "$2" kkk2 ; done
echo "K=$REPLY"
}


t 1000 "https://stackoverflow.com/questions/296536/how-to-urlencode-data-for-curl-command"

小开

Python 3基于@sandro在2010年的好答案:

echo "Test & /me" | python -c "import urllib.parse;print (urllib.parse.quote(input()))"

测试% 20% 26% 20 /我

小开

这个基于nodejs的答案将在stdin上使用encodeURIComponent:

uriencode_stdin() {
node -p 'encodeURIComponent(require("fs").readFileSync(0))'
}


echo -n $'hello\nwörld' | uriencode_stdin
hello%0Aw%C3%B6rld

小开

请注意

这些函数不是用来编码URL的数据，而是用来编码URL。
将url以每行一个的方式放入文件中。

#!/bin/dash


replaceUnicodes () { # $1=input/output file
if ! mv -f "$1" "$1".tmp 2>/dev/null; then return 1; fi
output="$1" awk '
function hexValue(chr) {
if(chr=="0") return 0; if(chr=="1") return 1; if(chr=="2") return 2; if(chr=="3") return 3; if(chr=="4") return 4; if(chr=="5") return 5;
if(chr=="6") return 6; if(chr=="7") return 7; if(chr=="8") return 8; if(chr=="9") return 9; if(chr=="A") return 10;
if(chr=="B") return 11; if(chr=="C") return 12; if(chr=="D") return 13; if(chr=="E") return 14; return 15 }
function hexToDecimal(str,  value,i,inc) {
str=toupper(str); value=and(hexValue(substr(str,length(str),1)),15); inc=1;
for(i=length(str)-1;i>0;i--) {
value+=lshift(hexValue(substr(str,i,1)),4*inc++)
} return value }
function toDecimal(str, value,i) {
for(i=1;i<=length(str);i++) {
value=(value*10)+substr(str,i,1)
} return value }
function to32BE(high,low) {
# return 0x10000+((high-0xD800)*0x400)+(low-0xDC00) }
return lshift((high-0xD800),10)+(low-0xDC00)+0x10000 }
function toUTF8(value) {
if(value<0x80) {
return sprintf("%%%02X",value)
} else if(value>0xFFFF) {
return sprintf("%%%02X%%%02X%%%02X%%%02X",or(0xF0,and(rshift(value,18),0x07)),or(0x80,and(rshift(value,12),0x3F)),or(0x80,and(rshift(value,6),0x3F)),or(0x80,and(rshift(value,0),0x3F)))
} else if(value>0x07FF) {
return sprintf("%%%02X%%%02X%%%02X",or(0xE0,and(rshift(value,12),0x0F)),or(0x80,and(rshift(value,6),0x3F)),or(0x80,and(rshift(value,0),0x3F)))
} else { return sprintf("%%%02X%%%02X",or(0xC0,and(rshift(value,6),0x1F)),or(0x80,and(rshift(value,0),0x3F))) }
}
function trap(str) { sub(/^\\+/,"\\",str); return str }
function esc(str) { gsub(/\\/,"\\\\",str); return str }
BEGIN { output=ENVIRON["output"] }
{
finalStr=""; while(match($0,/[\\]+u[0-9a-fA-F]{4}/)) {
p=substr($0,RSTART,RLENGTH); num=hexToDecimal(substr(p,RLENGTH-3,4));
bfrStr=substr($0,1,RSTART-1); $0=substr($0,RSTART+RLENGTH,length($0)-(RSTART+RLENGTH-1));
if(surrogate) {
surrogate=0;
if(RSTART!=1 || num<0xD800 || (num>0xDBFF && num<0xDC00) || num>0xDFFF) {
finalStr=sprintf("%s%s%s%s",finalStr,trap(highP),bfrStr,toUTF8(num))
} else if(num>0xD7FF && num<0xDC00) {
surrogate=1; high=num; finalStr=sprintf("%s%s",finalStr,trap(highP))
} else { finalStr=sprintf("%s%s",finalStr,toUTF8(to32BE(high,num))) }
} else if(num>0xD7FF && num<0xDC00) {
surrogate=1; highP=p; high=num; finalStr=sprintf("%s%s",finalStr,bfrStr)
} else { finalStr=sprintf("%s%s%s",finalStr,bfrStr,toUTF8(num)) }
} finalStr=sprintf("%s%s",finalStr,$0); $0=finalStr


while(match($0,/[\\]+U[0-9a-fA-F]{8}/)) {
str=substr($0,RSTART,RLENGTH); gsub(esc(str),toUTF8(hexToDecimal(substr(str,RLENGTH-7,8))),$0)
}
while(match($0,/[\\]*&#[xX][0-9a-fA-F]{1,8};/)) {
str=substr($0,RSTART,RLENGTH); idx=index(str,"#");
gsub(esc(str),toUTF8(hexToDecimal(substr(str,idx+2,RLENGTH-idx-2))),$0)
}
while(match($0,/[\\]*&#[0-9]{1,10};/)) {
str=substr($0,RSTART,RLENGTH); idx=index(str,"#");
gsub(esc(str),toUTF8(toDecimal(substr(str,idx+1,RLENGTH-idx-1))),$0)
}
printf("%s\n",$0) > output
}' "$1".tmp
rm -f "$1".tmp
}


replaceHtmlEntities () { # $1=input/output file
if ! mv -f "$1" "$1".tmp 2>/dev/null; then return 1; fi
sed 's/%3[aA]/:/g; s/%2[fF]/\//g; s/&quot;/%22/g; s/&lt;/%3C/g; s/&gt;/%3E/g; s/&nbsp;/%A0/g; s/&cent;/%A2/g; s/&pound;/%A3/g; s/&yen;/%A5/g; s/&copy;/%A9/g; s/&reg;/%AE/g; s/&amp;/\&/g; s/\\*\//\//g' "$1".tmp > "$1"
rm -f "$1".tmp
}




# "od -v -A n -t u1 -w99999999"
# "hexdump -v -e \47/1 \42%d \42\47"
# Reminder :: Do not encode (, ), [, and ].
toUTF8Encoded () { # $1=input/output file
if ! mv -f "$1" "$1".tmp 2>/dev/null; then return 1; fi
if [ -s "$1".tmp ]; then
# od -A n -t u1 -w99999999 "$1".tmp | \
hexdump -v -e '/1 "%d "' "$1".tmp | \
output="$1" awk 'function hexDigit(chr) { if((chr>47 && chr<58) || (chr>64 && chr<71) || (chr>96 && chr<103)) return 1; return 0 }
BEGIN { output=ENVIRON["output"] }
{   for(i=1;i<=NF;i++) {
flushed=0; c=$(i);
if(c==13) { if($(i+1)==10) i++; printf("%s\n",url) > output; url=""; flushed=1
} else if(c==10) { printf("%s\n",url) > output; url=""; flushed=1
} else if(c==37) {
if(hexDigit($(i+1)) && hexDigit($(i+2))) {
url=sprintf("%s%%%c%c",url,$(i+1),$(i+2)); i+=2
} else { url=sprintf("%s%%25",url) }
} else if(c>32 && c<127 && c!=34 && c!=39 && c!=96 && c!=60 && c!=62) {
url=sprintf("%s%c",url,c)
} else { url=sprintf("%s%%%02X",url,c) }
} if(!flushed) printf("%s\n",url) > output
}'
fi
rm -f "$1".tmp
}

调用replaceUnicodes()——>replaceHtmlEntities()——比;toUTF8Encoded()

小开

在本例中，我需要对主机名进行URL编码。不要问为什么。作为一个极简主义者和Perl爱好者，下面是我想到的。

url_encode()
{
echo -n "$1" | perl -pe 's/[^a-zA-Z0-9\/_.~-]/sprintf "%%%02x", ord($&)/ge'
}

很适合我。

小开

这是一个更简单的纯bash/ksh版本，没有子字符串逻辑。其他纯shell解决方案以不同的方式解析字符串以获取每个字符(使用参数替换${#str}来获取长度，使用${str:$i:1}来发现每个字符)。下面的方法只对字符串进行一次循环来处理每个字符。它是O(n²)和O(n)之差。在这个答案中:https://stackoverflow.com/a/40833433/1344599 Thunderbeef在一个大型文本文件上看到了~150倍的速度提高。这个解决方案也是一个更短的在线程序:

while IFS='' read -n 1 c ; do [[ "$c" =~ [A-Za-z0-9.~_-] ]] && printf "$c" || printf '%%%02X' "'$c" ; done

在函数中，你可以使用stdin或形参:

function urlen_stdin {
while IFS='' read -n 1 c ; do [[ "$c" =~ [A-Za-z0-9.~_-] ]] && printf "$c" || printf '%%%02X' "'$c" ; done
}
function urlen_param {
printf '%s' "$1" | while IFS='' read -n 1 c ; do [[ "$c" =~ [A-Za-z0-9.~_-] ]] && printf "$c" || printf '%%%02X' "'$c" ; done
}
function urlen_here {
while IFS='' read -n 1 c ; do [[ "$c" =~ [A-Za-z0-9.~_-] ]] && printf "$c" || printf '%%%02X' "'$c" ; done <<< "$1"
}


#usage:
echo -n 'hello !@#$%^&*()[]:;{}\/|-_=+.,? world' | urlen_stdin
urlen_param 'hello !@#$%^&*()[]:;{}\/|-_=+.,? world'
urlen_here 'hello !@#$%^&*()[]:;{}\/|-_=+.,? world'
# all methods render:
hello%20%21%40%23%24%25%5E%26%2A%28%29%5B%5D%3A%3B%7B%7D%2F%7C-_%3D%2B.%2C%3F%20world

解释:

IFS=''使空格像普通字符一样 read -n 1每次读取1个字符
[[ =~ ]]是一个正则表达式比较。如果字符匹配，则遵循&&路径，否则遵循||路径
printf '%%%02X'打印一个%和字符作为零填充长度2的十六进制代码