如何在单引号字符串中转义单引号

如何使用十六进制和八进制字符转义单引号 (') 和双引号 (")

如果使用像 echo 这样的东西，我会遇到一些非常复杂、非常奇怪和难以逃避（想想：非常嵌套）的情况，我唯一能做的就是使用八进制或十六进制代码！

以下是一些基本示例，只是为了演示它是如何工作的：

1. 单引号示例，其中 ' 用十六进制 \x27 或八进制 \047（其对应的 ASCII 码）转义：

hex \x27 echo -e "让\x27s 编码！" # OR echo -e '让\x27s 开始编码！'结果：让我们开始编码吧！八进制 \047 echo -e "让\047s 编码！" # OR echo -e 'Let\047s 开始编码！'结果：让我们开始编码吧！

2. 双引号示例，其中 " 用十六进制 \x22 或八进制 \042 （其对应的 ASCII 码）进行转义。

注意：bash 是疯了！ Sometimes even the ! char has special meaning，并且必须从双引号中删除，然后转义 "like this"\! 或完全放在单引号 'like this!' 内，而不是放在双引号内。

# 1. hex; also escape `!` by removing it from within the double quotes 
# and escaping it with `\!`
$ echo -e "She said, \x22Let\x27s get coding"\!"\x22"
She said, "Let's get coding!"

# OR put it all within single quotes:
$ echo -e 'She said, \x22Let\x27s get coding!\x22'
She said, "Let's get coding!"


# 2. octal; also escape `!` by removing it from within the double quotes 
$ echo -e "She said, \042Let\047s get coding"\!"\042"
She said, "Let's get coding!"

# OR put it all within single quotes:
$ echo -e 'She said, \042Let\047s get coding!\042'
She said, "Let's get coding!"


# 3. mixed hex and octal, just for fun
# also escape `!` by removing it from within the double quotes when it is followed by
# another escape sequence
$ echo -e "She said, \x22Let\047s get coding! It\x27s waaay past time to begin"\!"\042"
She said, "Let's get coding! It's waaay past time to begin!"

# OR put it all within single quotes:
$ echo -e 'She said, \x22Let\047s get coding! It\x27s waaay past time to begin!\042'
She said, "Let's get coding! It's waaay past time to begin!"

请注意，如果您没有正确地转义 !，则在需要时（正如我在上面展示的两种方法），您会遇到一些奇怪的错误，如下所示：

$ echo -e "She said, \x22Let\047s get coding! It\x27s waaay past time to begin!\042"
bash: !\042: event not found

或者：

$ echo -e "She said, \x22Let\x27s get coding!\x22"
bash: !\x22: event not found

另一种选择：这允许在同一个 bash 字符串中混合扩展和非扩展

这是另一种转义技术的另一个演示。

首先，阅读 the main answer by @liori 以了解下面的第二种形式是如何工作的。现在，阅读这两种转义字符的替代方法。以下两个示例的输出相同：

CMD="gs_set_title"

# 1. 1st technique: escape the $ symbol with a backslash (\) so it doesn't 
# run and expand the command following it
echo "$CMD '\$(basename \"\$(pwd)\")'"

# 2. 2nd technique (does the same thing in a different way): escape the 
# $ symbol using single quotes around it, and the single quote (') symbol
# using double quotes around it
echo "$CMD ""'"'$(basename "$(pwd)")'"'"

样本输出：

gs_set_title '$(basename "$(pwd)")' gs_set_title '$(basename "$(pwd)")'

注意：对于我有 in my ~/.bash_aliases file somewhere around here 的 gs_set_title bash 函数，请参阅 my other answer here。

参考：

https://en.wikipedia.org/wiki/ASCII#Printable_characters https://serverfault.com/questions/208265/what-is-bash-event-not-found/208266#208266 另见我的其他答案：如何使用 echo 写非 ASCII 字符？

---

恕我直言，真正的答案是您不能在单引号字符串中转义单引号。

不可能。

如果我们假设我们正在使用 bash。

从bash手册...

Enclosing characters in single quotes preserves the literal value of each
character within the quotes.  A single quote may not occur
between single quotes, even when preceded by a backslash.

您需要使用其他字符串转义机制之一“或\

alias 没有什么神奇的地方要求它使用单引号。

以下两项均在 bash 中工作。

alias rxvt="urxvt -fg '#111111' -bg '#111111'"
alias rxvt=urxvt\ -fg\ \'#111111\'\ -bg\ \'#111111\'

后者使用 \ 来转义空格字符。

需要单引号的 #111111 也没有什么神奇之处。

以下选项实现了与其他两个选项相同的结果，因为 rxvt 别名按预期工作。

alias rxvt='urxvt -fg "#111111" -bg "#111111"'
alias rxvt="urxvt -fg \"#111111\" -bg \"#111111\""

也可以直接逃避麻烦的#

alias rxvt="urxvt -fg \#111111 -bg \#111111"

---

这些答案中的大多数都针对您要询问的特定案例。我和朋友开发了一种通用方法，允许任意引用，以防您需要通过多层 shell 扩展（例如，通过 ssh、su -c、bash -c 等）引用 bash 命令。有一个您需要的核心原语，在本机 bash 中：

quote_args() {
    local sq="'"
    local dq='"'
    local space=""
    local arg
    for arg; do
        echo -n "$space'${arg//$sq/$sq$dq$sq$dq$sq}'"
        space=" "
    done
}

这正是它所说的：它单独引用每个参数（当然是在 bash 扩展之后）：

$ quote_args foo bar
'foo' 'bar'
$ quote_args arg1 'arg2 arg2a' arg3
'arg1' 'arg2 arg2a' 'arg3'
$ quote_args dq'"'
'dq"'
$ quote_args dq'"' sq"'"
'dq"' 'sq'"'"''
$ quote_args "*"
'*'
$ quote_args /b*
'/bin' '/boot'

它对一层扩展做了明显的事情：

$ bash -c "$(quote_args echo a'"'b"'"c arg2)"
a"b'c arg2

（请注意，$(quote_args ...) 周围的双引号对于使结果成为 bash -c 的单个参数是必要的。）它可以更普遍地用于通过多层扩展正确引用：

$ bash -c "$(quote_args bash -c "$(quote_args echo a'"'b"'"c arg2)")"
a"b'c arg2

上面的例子：

shell将每个参数单独引用到内部quote_args，然后将结果输出与内部双引号组合成单个参数。 shell 引用 bash、-c 和第 1 步中已经引用过的结果，然后将结果与外部双引号组合成单个参数。将该混乱作为参数发送到外部 bash -c。

简而言之就是这个想法。你可以用它做一些非常复杂的事情，但你必须小心评估的顺序和引用哪些子字符串。例如，以下做错了事情（对于“错误”的某些定义）：

$ (cd /tmp; bash -c "$(quote_args cd /; pwd 1>&2)")
/tmp
$ (cd /tmp; bash -c "$(quote_args cd /; [ -e *sbin ] && echo success 1>&2 || echo failure 1>&2)")
failure

在第一个示例中，bash 立即将 quote_args cd /; pwd 1>&2 扩展为两个单独的命令，quote_args cd / 和 pwd 1>&2，因此在执行 pwd 命令时 CWD 仍然是 /tmp。第二个示例说明了类似的通配问题。实际上，所有 bash 扩展都会出现相同的基本问题。这里的问题是命令替换不是函数调用：它实际上是在评估一个 bash 脚本并将其输出用作另一个 bash 脚本的一部分。

如果您尝试简单地转义 shell 运算符，您将失败，因为传递给 bash -c 的结果字符串只是一系列单独引用的字符串，这些字符串随后不会被解释为运算符，如果您回显将传递给 bash 的字符串：

$ (cd /tmp; echo "$(quote_args cd /\; pwd 1\>\&2)")
'cd' '/;' 'pwd' '1>&2'
$ (cd /tmp; echo "$(quote_args cd /\; \[ -e \*sbin \] \&\& echo success 1\>\&2 \|\| echo failure 1\>\&2)")
'cd' '/;' '[' '-e' '*sbin' ']' '&&' 'echo' 'success' '1>&2' '||' 'echo' 'failure' '1>&2'

这里的问题是您过度引用。您需要将运算符作为封闭 bash -c 的输入不加引号，这意味着它们需要在 $(quote_args ...) 命令替换之外。

因此，从最一般的意义上讲，您需要做的是在命令替换时单独对不打算扩展的命令的每个单词进行 shell 引用，并且不对 shell 运算符应用任何额外的引用：

$ (cd /tmp; echo "$(quote_args cd /); $(quote_args pwd) 1>&2")
'cd' '/'; 'pwd' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")
/
$ (cd /tmp; echo "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
'cd' '/'; [ -e *'sbin' ] && 'echo' 'success' 1>&2 || 'echo' 'failure' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
success

完成此操作后，整个字符串是公平的游戏，可以进一步引用任意级别的评估：

$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")"
/
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")"
/
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")")"
/
$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")"
success
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *sbin ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")"
success
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")")"
success

等等

考虑到 success、sbin 和 pwd 之类的词不需要在 shell 中引用，这些示例可能看起来有些过头了，但是在编写带有任意输入的脚本时要记住的关键点是您要引用您不确定不需要的所有内容都需要引用，因为您永远不知道用户何时会输入 Robert'; rm -rf /。

为了更好地理解幕后发生的事情，您可以使用两个小辅助函数：

debug_args() {
    for (( I=1; $I <= $#; I++ )); do
        echo -n "$I:<${!I}> " 1>&2
    done
    echo 1>&2
}

debug_args_and_run() {
    debug_args "$@"
    "$@"
}

这将在执行命令之前枚举命令的每个参数：

$ debug_args_and_run echo a'"'b"'"c arg2
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)"
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'bash'"'"' '"'"'-c'"'"' '"'"''"'"'"'"'"'"'"'"'debug_args_and_run'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'echo'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'a"b'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'c'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'arg2'"'"'"'"'"'"'"'"''"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

---

在给定的示例中，简单地使用双引号而不是单引号作为外部转义机制：

alias rxvt="urxvt -fg '#111111' -bg '#111111'"

这种方法适用于您只想将固定字符串传递给命令的许多情况：只需检查 shell 如何通过 echo 解释双引号字符串，并在必要时使用反斜杠转义字符。

在示例中，您会看到双引号足以保护字符串：

$ echo "urxvt -fg '#111111' -bg '#111111'"
urxvt -fg '#111111' -bg '#111111'

---

这是对上面提到的唯一正确答案的详细说明：

有时我会在 ssh 上使用 rsync 进行下载，并且必须使用 ' 转义文件名两次！ （天哪！）一次用于 bash，一次用于 ssh。交替引用分隔符的相同原理在这里起作用。

例如，假设我们想要获得：Louis Theroux 的 LA Stories ...

首先，将 Louis Theroux 括在 bash 的单引号和 ssh 的双引号中：'"Louis Theroux"' 然后使用单引号转义双引号 '"' 使用双引号转义撇号 "'" 然后重复 #2 , 使用单引号转义双引号 '"' 然后将 LA Stories 括在 bash 的单引号和 ssh 的双引号中：'"LA Stories"'

看哪！你结束了这个：

rsync -ave ssh '"Louis Theroux"''"'"'"'"''"s LA Stories"'

对于一个小家伙来说，这是一项非常艰巨的工作——但是你去吧

---

显然，简单地用双引号括起来会更容易，但其中的挑战在哪里？这是仅使用单引号的答案。我使用变量而不是 alias，这样打印证明更容易，但这与使用 alias 相同。

$ rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'
$ echo $rxvt
urxvt -fg '#111111' -bg '#111111'

解释

关键是您可以关闭单引号并根据需要多次重新打开它。例如 foo='a''b' 与 foo='ab' 相同。因此，您可以关闭单引号，输入文字单引号 \'，然后重新打开下一个单引号。

分解图

该图通过使用方括号来显示单引号的打开和关闭位置清楚地说明了这一点。引号不像括号那样“嵌套”。您还可以注意正确应用的颜色突出显示。带引号的字符串是栗色，而 \' 是黑色。

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'    # original
[^^^^^^^^^^] ^[^^^^^^^] ^[^^^^^] ^[^^^^^^^] ^    # show open/close quotes
 urxvt -fg   ' #111111  '  -bg   ' #111111  '    # literal characters remaining

（这与阿德里安的答案基本相同，但我觉得这可以更好地解释它。他的答案最后还有 2 个多余的单引号。）

---

除了@JasonWoof 完美答案，我想展示我如何解决相关问题

在我的情况下，用 '\'' 编码单引号并不总是足够的，例如，如果一个字符串必须用单引号引起来，但引号的总数会导致奇数

#!/bin/bash

# no closing quote
string='alecxs\'solution'

# this works for string
string="alecxs'solution"
string=alecxs\'solution
string='alecxs'\''solution'

假设字符串是文件名，我们需要将带引号的文件名保存在列表中（如 stat -c%N ./* > list）

echo "'$string'" > "$string"
cat "$string"

但处理此列表将失败（取决于字符串总共包含多少引号）

while read file
  do
    ls -l "$file"
    eval ls -l "$file"
done < "$string"

解决方法：使用字符串操作对引号进行编码

string="${string//$'\047'/\'\$\'\\\\047\'\'}"

# result
echo "$string"

现在它起作用了，因为报价总是平衡的

echo "'$string'" > list
while read file
  do
    ls -l "$file"
    eval ls -l "$file"
done < list

希望在遇到类似问题时这会有所帮助

---

需要一个最小的答案，这样人们就可以不用花费很多时间就可以开始工作，因为我不得不筛选那些雄辩的人。

没有办法转义单引号或单引号内的任何其他内容。

以下是，也许令人惊讶的是，一个完整的命令：

$ echo '\'

其输出是：

\

甚至对于 bash 的长期用户来说，反斜杠在单引号内没有任何意义。也没有别的。

---

另一种解决嵌套引用层数过多问题的方法：

您正试图将太多东西塞进太小的空间，因此请使用 bash 函数。

问题是你试图有太多的嵌套级别，而基本的别名技术还不够强大，无法容纳。使用这样的 bash 函数来实现，这样单引号、双引号反引号和传入的参数都可以正常处理，就像我们期望的那样：

lets_do_some_stuff() {
    tmp=$1                       #keep a passed in parameter.
    run_your_program $@          #use all your passed parameters.
    echo -e '\n-------------'    #use your single quotes.
    echo `date`                  #use your back ticks.
    echo -e "\n-------------"    #use your double quotes.
}
alias foobarbaz=lets_do_some_stuff

然后，您可以使用 $1 和 $2 变量以及单引号、双引号和反引号，而不必担心别名函数会破坏它们的完整性。

该程序打印：

el@defiant ~/code $ foobarbaz alien Dyson ring detected @grid 10385
alien Dyson ring detected @grid 10385
-------------
Mon Oct 26 20:30:14 EDT 2015
-------------

---

shell_escape () {
    printf '%s' "'${1//\'/\'\\\'\'}'"
}

实现说明：

双引号，因此我们可以轻松地输出包装单引号并使用 ${...} 语法

bash 的搜索和替换看起来像：${varname//search/replacement}

我们将 ' 替换为 '\''

'\'' 编码单个 ' 像这样：' 结束单引号 \' 编码一个 ' （需要反斜杠，因为我们不在引号内） ' 再次开始单引号 bash 自动连接字符串，中间没有空格

' 结束单引号

\' 编码一个 ' （需要反斜杠，因为我们不在引号内）

' 再次开始单引号

bash 自动连接字符串之间没有空格

在每个 \ 和 ' 之前都有一个 \ 因为这是 ${...//.../...} 的转义规则。

string="That's "'#@$*&^`(@#'
echo "original: $string"
echo "encoded:  $(shell_escape "$string")"
echo "expanded: $(bash -c "echo $(shell_escape "$string")")"

PS 始终编码为单引号字符串，因为它们比双引号字符串简单得多。

---

这是我的两分钱——如果一个人想要sh便携，而不仅仅是bash专用（不过，解决方案效率不是很高，因为它启动了一个外部程序——sed） ：

把它放在你的 PATH 某处的 quote.sh （或只是引用）中：

# this works with standard input (stdin)
quote() {
  echo -n "'" ;
  sed 's/\(['"'"']['"'"']*\)/'"'"'"\1"'"'"'/g' ;
  echo -n "'"
}

case "$1" in
 -) quote ;;
 *) echo "usage: cat ... | quote - # single-quotes input for Bourne shell" 2>&1 ;;
esac

一个例子：

$ echo -n "G'day, mate!" | ./quote.sh -
'G'"'"'day, mate!'

而且，当然，这会转换回来：

$ echo 'G'"'"'day, mate!'
G'day, mate!

解释：基本上我们必须用引号 ' 将输入括起来，然后用这个微型怪物替换其中的任何单引号：'"'"'（以配对 ' 结束开头引号, 通过用双引号包裹找到的单引号来转义 - "'"，然后最后发出一个新的开始单引号 '，或伪符号：' + "'" + ' == '"'"'）

一种标准方法是将 sed 与以下替换命令一起使用：

s/\(['][']*\)/'"\1"'/g 

不过，一个小问题是，为了在 shell 中使用它，需要在 sed 表达式本身中转义所有这些单引号字符——这会导致类似

sed 's/\(['"'"']['"'"']*\)/'"'"'"\1"'"'"'/g' 

（构建此结果的一种好方法是将原始表达式 s/\(['][']*\)/'"\1"'/g 提供给 Kyle Rose 或 George V. Reilly 的脚本）。

最后，期望输入来自 stdin 是有道理的——因为通过命令行参数传递它可能已经太麻烦了。

（哦，也许我们想添加一个小帮助消息，这样当有人运行它时脚本不会挂起，因为 ./quote.sh --help 想知道它做了什么。）

---

如果您在 Python 2 或 Python 3 中生成 shell 字符串，以下内容可能有助于引用参数：

#!/usr/bin/env python

from __future__ import print_function

try:  # py3
    from shlex import quote as shlex_quote
except ImportError:  # py2
    from pipes import quote as shlex_quote

s = """foo ain't "bad" so there!"""

print(s)
print(" ".join([shlex_quote(t) for t in s.split()]))

这将输出：

foo ain't "bad" so there!
foo 'ain'"'"'t' '"bad"' so 'there!'

---

如果你安装了 GNU Parallel，你可以使用它的内部引用：

$ parallel --shellquote
L's 12" record
<Ctrl-D>
'L'"'"'s 12" record'
$ echo 'L'"'"'s 12" record'
L's 12" record

从版本 20190222 开始，您甚至可以多次--shellquote：

$ parallel --shellquote --shellquote --shellquote
L's 12" record
<Ctrl-D>
'"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
$ eval eval echo '"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
L's 12" record

它将在所有受支持的 shell 中引用字符串（不仅是 bash）。

---

这个功能：

quote () 
{ 
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

允许在 ' 中引用 '。像这样使用：

$ quote "urxvt -fg '#111111' -bg '#111111'"
'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

如果要引用的行变得更复杂，例如双引号和单引号混合，那么在变量中获取要引用的字符串可能会变得非常棘手。当出现这种情况时，请在脚本中写下您需要引用的确切行（类似于此）。

#!/bin/bash

quote ()
{
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

while read line; do
    quote "$line"
done <<-\_lines_to_quote_
urxvt -fg '#111111' -bg '#111111'
Louis Theroux's LA Stories
'single quote phrase' "double quote phrase"
_lines_to_quote_

将输出：

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''
'Louis Theroux'\''s LA Stories'
''\''single quote phrase'\'' "double quote phrase"'

单引号内所有正确引用的字符串。

---

这是另一个解决方案。该函数将接受一个参数并使用单引号字符适当地引用它，正如上面投票答案所解释的那样：

single_quote() {
  local quoted="'"
  local i=0
  while [ $i -lt ${#1} ]; do
    local ch="${1:i:1}"
    if [[ "$ch" != "'" ]]; then
      quoted="$quoted$ch"
    else
      local single_quotes="'"
      local j=1
      while [ $j -lt ${#1} ] && [[ "${1:i+j:1}" == "'" ]]; do
        single_quotes="$single_quotes'"
        ((j++))
      done
      quoted="$quoted'\"$single_quotes\"'"
      ((i+=j-1))
    fi
    ((i++))
  done
  echo "$quoted'"
}

所以，你可以这样使用它：

single_quote "1 2 '3'"
'1 2 '"'"'3'"'"''

x="this text is quoted: 'hello'"
eval "echo $(single_quote "$x")"
this text is quoted: 'hello'

---