Multi tool use

How to escape single quotes within single quoted strings?

Let's say, you have a bash alias like:

alias

alias rxvt='urxvt'


which works fine.

However:

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


won't work, and neither will:

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


So how do you end up matching up opening and closing quotes inside a string once you have escaped quotes?

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


seems ungainly although it would represent the same string if you're allowed to concatenate them like that.

"""

19 Answers
19

If you really want to use single quotes in the outermost layer, remember that you can glue both kinds of quotation. Example:

alias rxvt='urxvt -fg '"'"'#111111'"'"' -bg '"'"'#111111'"'"
# ^^^^^ ^^^^^ ^^^^^ ^^^^
# 12345 12345 12345 1234


Explanation of how '"'"' is interpreted as just ':

'"'"'

'

'

"

'

"

'

If you do not place any whitespaces between (1) and (2), or between (4) and (5), the shell will interpret that string as a one long word.

alias splitpath='echo $PATH | awk -F : '"'"'{print "PATH is set to"} {for (i=1;i<=NF;i++) {print "["i"]",$i}}'"'"

alias serve_this_dir='ruby -rrack -e "include Rack;Handler::Thin.run Builder.new{run Directory.new'"'"''"'"'}"'

'''

'"'"'

"

I always just replace each embedded single quote with the sequence: ''' (that is: quote backslash quote quote) which closes the string, appends an escaped single quote and reopens the string.

'''

I often whip up a "quotify" function in my Perl scripts to do this for me. The steps would be:

s/'/'\''/g # Handle each embedded quote
$_ = qq['$_']; # Surround result with single quotes.


This pretty much takes care of all cases.

Life gets more fun when you introduce eval into your shell-scripts. You essentially have to re-quotify everything again!

eval

For example, create a Perl script called quotify containing the above statements:

#!/usr/bin/perl -pl
s/'/'\''/g;
$_ = qq['$_'];


then use it to generate a correctly-quoted string:

$ quotify
urxvt -fg '#111111' -bg '#111111'


result:

'urxvt -fg '''#111111''' -bg '''#111111''''


which can then be copy/pasted into the alias command:

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


(If you need to insert the command into an eval, run the quotify again:

$ quotify
alias rxvt='urxvt -fg '''#111111''' -bg '''#111111''''


result:

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


which can be copy/pasted into an eval:

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


set -x

echo "here's a string"

echo 'here'''s a string'

set +x

Since Bash 2.04 syntax $'string' (instead of just 'string'; warning: do not confuse with $('string')) is another quoting mechanism which allows ANSI C-like escape sequences and do expansion to single-quoted version.

$'string'

'string'

$('string')

Simple example:

$> echo $'aa'bb'
aa'bb

$> alias myvar=$'aa'bb'
$> alias myvar
alias myvar='aa'''bb'


In your case:

$> alias rxvt=$'urxvt -fg '#111111' -bg '#111111''
$> alias rxvt
alias rxvt='urxvt -fg '''#111111''' -bg '''#111111''''


Common escaping sequences works as expected:

' single quote
" double quote
\ backslash
n new line
t horizontal tab
r carriage return


Below is copy+pasted related documentation from man bash (version 4.4):

man bash

Words of the form $'string' are treated specially. The word expands to string, with backslash-escaped characters replaced as specified by the ANSI C standard. Backslash escape sequences, if present, are decoded as follows:

a alert (bell)
b backspace
e
E an escape character
f form feed
n new line
r carriage return
t horizontal tab
v vertical tab
\ backslash
' single quote
" double quote
? question mark
nnn the eight-bit character whose value is the octal
value nnn (one to three digits)
xHH the eight-bit character whose value is the hexadecimal
value HH (one or two hex digits)
uHHHH the Unicode (ISO/IEC 10646) character whose value is
the hexadecimal value HHHH (one to four hex digits)
UHHHHHHHH the Unicode (ISO/IEC 10646) character whose value
is the hexadecimal value HHHHHHHH (one to eight
hex digits)
cx a control-x character


The expanded result is single-quoted, as if the dollar sign had not been present.

See Quotes and escaping: ANSI C like strings on bash-hackers.org wiki for more details. Also note that "Bash Changes" file (overview here) mentions a lot for changes and bug fixes related to the $'string' quoting mechanism.

$'string'

According to unix.stackexchange.com How to use a special character as a normal one? it should work (with some variations) in bash, zsh, mksh, ksh93 and FreeBSD and busybox sh.

echo $'foo'b!ar'

!ar': event not found

> echo $BASH_VERSION

4.2.47(1)-release

> echo $'foo'b!ar'

foo'b!ar

$'

I don't see the entry on his blog (link pls?) but according to the gnu reference manual:

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.

so bash won't understand:

alias x='y 'z '

alias x='y 'z '

however, you can do this if you surround with double quotes:

alias x="echo 'y "
> x
> 'y


I can confirm that using ''' for a single quote inside a single-quoted string does work in Bash, and it can be explained in the same way as the "gluing" argument from earlier in the thread. Suppose we have a quoted string: 'A '''B''' C' (all quotes here are single quotes). If it is passed to echo, it prints the following: A 'B' C.
In each ''' the first quote closes the current single-quoted string, the following ' glues a single quote to the previous string (' is a way to specify a single quote without starting a quoted string), and the last quote opens another single-quoted string.

'''

'A '''B''' C'

A 'B' C

'''

'

'

alias something='A '''B''' C'

something

'A ' + ' + 'B' + ' + ' C'

STR='''; echo $STR

'''

Simple example of escaping quotes in shell:

$ echo 'abc'''abc'
abc'abc
$ echo "abc"""abc"
abc"abc


It's done by finishing already opened one ('), placing escaped one ('), then opening another one ('). This syntax works for all commands. It's very similar approach to the 1st answer.

'

'

'

I'm not specifically addressing the quoting issue because, well, sometimes, it's just reasonable to consider an alternative approach.

rxvt() { urxvt -fg "#${1:-000000}" -bg "#${2:-FFFFFF}"; }


which you can then call as:

rxvt 123456 654321


the idea being that you can now alias this without concern for quotes:

alias rxvt='rxvt 123456 654321'


or, if you need to include the # in all calls for some reason:

#

rxvt() { urxvt -fg "${1:-#000000}" -bg "${2:-#FFFFFF}"; }


which you can then call as:

rxvt '#123456' '#654321'


then, of course, an alias is:

alias rxvt="rxvt '#123456' '#654321'"


(oops, i guess i kind of did address the quoting :)

I just use shell codes.. e.g. x27 or \x22 as applicable. No hassle, ever really.

x27

\x22

x27

Since one cannot put single quotes within single quoted strings, the simplest and most readable option is to use a HEREDOC string

command=$(cat <<'COMMAND'
urxvt -fg '#111111' -bg '#111111'
COMMAND
)

alias rxvt=$command


In the code above, the HEREDOC is sent to the cat command and the output of that is assigned to a variable via the command substitution notation $(..)

cat

$(..)

Putting a single quote around the HEREDOC is needed since it is within a $()

$()

dash

Both versions are working, either with concatenation by using the escaped single quote character ('), or with concatenation by enclosing the single quote character within double quotes ("'").

The author of the question did not notice that there was an extra single quote (') at the end of his last escaping attempt:

alias rxvt='urxvt -fg'''#111111''' -bg '''#111111'''
│ │┊┊| │┊┊│ │┊┊│ │┊┊│
└─STRING──┘┊┊└─STRIN─┘┊┊└─STR─┘┊┊└─STRIN─┘┊┊│
┊┊ ┊┊ ┊┊ ┊┊│
┊┊ ┊┊ ┊┊ ┊┊│
└┴─────────┴┴───┰───┴┴─────────┴┘│
All escaped single quotes │
│
?


As you can see in the previous nice piece of ASCII/Unicode art, the last escaped single quote (') is followed by an unnecessary single quote ('). Using a syntax-highlighter like the one present in Notepad++ can prove very helpful.

The same is true for another example like the following one:

alias rc='sed '"'"':a;N;$!ba;s/n/, /g'"'"
alias rc='sed ''':a;N;$!ba;s/n/, /g''


These two beautiful instances of aliases show in a very intricate and obfuscated way how a file can be lined down. That is, from a file with a lot of lines you get only one line with commas and spaces between the contents of the previous lines. In order to make sense of the previous comment, the following is an example:

$ cat Little_Commas.TXT
201737194
201802699
201835214

$ rc Little_Commas.TXT
201737194, 201802699, 201835214


Most of these answers hit on the specific case you're asking about. There is a general approach that a friend and I have developed that allows for arbitrary quoting in case you need to quote bash commands through multiple layers of shell expansion, e.g., through ssh, su -c, bash -c, etc. There is one core primitive you need, here in native bash:

su -c

bash -c

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
}


This does exactly what it says: it shell-quotes each argument individually (after bash expansion, of course):

$ 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'


It does the obvious thing for one layer of expansion:

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


(Note that the double quotes around $(quote_args ...) are necessary to make the result into a single argument to bash -c.) And it can be used more generally to quote properly through multiple layers of expansion:

$(quote_args ...)

bash -c

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


The above example:

quote_args

bash

-c

bash -c

That's the idea in a nutshell. You can do some pretty complicated stuff with this, but you have to be careful about order of evaluation and about which substrings are quoted. For instance, the following do the wrong things (for some definition of "wrong"):

$ (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


In the first example, bash immediately expands quote_args cd /; pwd 1>&2 into two separate commands, quote_args cd / and pwd 1>&2, so the CWD is still /tmp when the pwd command is executed. The second example illustrates a similar problem for globbing. Indeed, the same basic problem occurs with all bash expansions. The problem here is that a command substitution isn't a function call: it's literally evaluating one bash script and using its output as part of another bash script.

quote_args cd /; pwd 1>&2

quote_args cd /

pwd 1>&2

/tmp

pwd

If you try to simply escape the shell operators, you'll fail because the resulting string passed to bash -c is just a sequence of individually-quoted strings that aren't then interpreted as operators, which is easy to see if you echo the string that would have been passed to bash:

bash -c

$ (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'


The problem here is that you're over-quoting. What you need is for the operators to be unquoted as input to the enclosing bash -c, which means they need to be outside the $(quote_args ...) command substitution.

bash -c

$(quote_args ...)

Consequently, what you need to do in the most general sense is to shell-quote each word of the command not intended to be expanded at the time of command substitution separately, and not apply any extra quoting to the shell operators:

$ (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


Once you've done this, the entire string is fair game for further quoting to arbitrary levels of evaluation:

$ 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


etc.

These examples may seem overwrought given that words like success, sbin, and pwd don't need to be shell-quoted, but the key point to remember when writing a script taking arbitrary input is that you want to quote everything you're not absolutely sure doesn't need quoting, because you never know when a user will throw in a Robert'; rm -rf /.

success

sbin

pwd

Robert'; rm -rf /

To better understand what is going on under the covers, you can play around with two small helper functions:

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

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


that will enumerate each argument to a command before executing it:

$ 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


vagrant ssh -c {single-arg} guest

{single-arg}

{single-arg}

quote_args()

vagrant ssh -c "'command' 'arg 1 with blanks' 'arg 2'" guest

IMHO the real answer is that you can't escape single-quotes within single-quoted strings.

Its impossible.

If we presume we are using bash.

From bash manual...

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.


You need to use one of the other string escape mechanisms " or

There is nothing magic about alias that demands it use single quotes.

alias

Both the following work in bash.

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


The latter is using to escape the space character.

There is also nothing magic about #111111 that requires single quotes.

The following options achieves the same result the other two options, in that the rxvt alias works as expected.

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


You can also escape the troublesome # directly

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


In the given example, simply used double quotes instead of single quotes as outer escape mechanism:

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


This approach is suited for many cases where you just want to pass a fixed string to a command: Just check how the shell will interpret the double-quoted string through an echo, and escape characters with backslash if necessary.

echo

In the example, you'd see that double quotes are sufficient to protect the string:

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


Here is an elaboration on The One True Answer referenced above:

Sometimes I will be downloading using rsync over ssh and have to escape a filename with a ' in it TWICE! (OMG!) Once for bash and once for ssh. The same principle of alternating quotation delimiters is at work here.

For example, let's say we want to get: Louis Theroux's LA Stories ...

And behold! You wind up with this:

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


which is an awful lot of work for one little ' -- but there you go

Another way to fix the problem of too many layers of nested quotation:

You are trying to cram too much into too tiny a space, so use a bash function.

The problem is you are trying to have too many levels of nesting, and the basic alias technology is not powerful enough to accommodate. Use a bash function like this to make it so the single, double quotes back ticks and passed in parameters are all handled normally as we would expect:

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


Then you can use your $1 and $2 variables and single, double quotes and back ticks without worrying about the alias function wrecking their integrity.

This program prints:

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


This function:

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


allows quoting of ' inside '. Use as this:

'

'

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


If the line to quote gets more complex, like double quotes mixed with single quotes, it may become quite tricky to get the string to quote inside a variable. When such cases show up, write the exact line that you need to quote inside an script (similar to this).

#!/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_


Will output:

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


All correctly quoted strings inside single quotes.

Obviously, it would be easier simply to surround with double quotes, but where's the challenge in that? Here is the answer using only single quotes. I'm using a variable instead of alias so that's it's easier to print for proof, but it's the same as using alias.

alias

alias

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


Explanation

The key is that you can close the single quote and re-open it as many times as you want. For example foo='a''b' is the same as foo='ab'. So you can close the single quote, throw in a literal single quote ', then reopen the next single quote.

foo='a''b'

foo='ab'

'

Breakdown diagram

This diagram makes it clear by using brackets to show where the single quotes are opened and closed. Quotes are not "nested" like parentheses can be. You can also pay attention to the color highlighting, which is correctly applied. The quoted strings are maroon, whereas the ' is black.

'

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


(This is essentially the same answer as Adrian's, but I feel this explains it better. Also his answer has 2 superfluous single quotes at the end.)

Here is another solution. This function will take a single argument and appropriately quote it using the single-quote character, just as the voted answer above explains:

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'"
}


So, you can use it this way:

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

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


If you're generating the shell string within Python 2 or Python 3, the following may help to quote the arguments:

#!/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()]))


This will output:

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


By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.