How do I escape a backtick ` within a code block?
This is probably a duplicate, since I'm sure it's a common concern, but I can't find a question that addresses this specifically.
How do I write List'1 with the "1" character still in the code-text format?
For reference, see http://daringfireball.net/projects/markdown/syntax, which is linked in the formatting question box.
For simple cases, use double backticks: ``List`1`` produces List`1.
To put one or more backticks at the beginning or the end of your code, e.g., foo`, `foo, or just `, add a space on each side as well:
`` foo` `` produces foo``` `foo `` produces `foo`` ` `` produces `Without these spaces, parsing breaks:
``foo``` produces ``foo``````foo`` produces ```foo``````` produces `````Space is needed on both sides, even if a backtick only appears on one side of the intended code. Otherwise, the space itself may be considered part of the code span:
``foo` `` produces foo` `` `foo`` produces `fooIf the inline code must contain a longer sequence of backticks, use a backtick sequence at the start and end that is longer than anything in the code itself:
```foo``bar``` produces foo``bar````foo```bar```` produces foo```barAnd so on. You can also see this technique in action in the source code of this answer.
Code blocks can be created either using "code fences" (lines before and after with three or more backticks), or by indenting each line of the code by an additional four spaces (above and beyond the code's indentation, as well as any indentation needed to put it inside a bullet-point list etc.).
The extra-indentation approach makes it simple to include backticks in the code block, but can otherwise be unwieldy.
With code fences, there is usually no problem with putting backticks in the code:
` this works this also works: ``` ``` it even works with text here However, this breaks if the code block must have three backticks on a line by themselves, even with leading and/or trailing spaces. In this case, we again fix the problem by using a longer sequence of backticks on the start and end lines. For example, source like
```` ``` ```` produces
``` 
!``! For triple or higher backticks, you can wrap your inline code with double backticks, rather than quadruple backticks (unless you need both triple and double backticks at different places). !```! vs !``!```! \` alternative For GitHub, like for displaying a MySQL `table_name`, in regular text use \` (backslash backtick).
For showing backticks inside inline codeblocks `table_name`, use double backticks with extra spaces `` `table_name` `` around the inner single backticks.
To show the previous example explanation in an inline codeblock: `` `table_name` ``, surround the whole in three backticks with extra spaces, e.g. ``` `` `table_name` `` ```
(head a splode)
table_name `` You can use an extra backtick at the start and end to make sure it escapes correctly:
``List`1`` When inline it will display as List`1.
\ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark for example, this:
## \\ \` \* \_ \{ \} \[ \] \( \) \# \+ \- \. \! returns:
Escaped codeblock, italics, bold, link, headings and list:
`not codeblock`, *not italics*, **not bold**, [not link](https://www.example.com)
# not h1
## not h2
### not h3
+ not ul
- not ul
List`1 is achieved using `List\`1`. grep "docker-machine-`uname -s`-`uname -m`", so thanks! For fenced code blocks, the prescription is more backticks.
This Markdown
```` ``` Example of Markdown syntax for fenced code block with triple back ticks ``` ```` will be rendered like this
``` Example of Markdown syntax for fenced code block with triple back ticks ``` 
^ (start of a line) with ^ (start of a line followed by four spaces). Works a treat! Use <code> and HTML character entities instead. This is especially useful in situations where your code is already wrapping things in backticks (e.g., in Swift, enum { case `true` = 1 }).
HTML gives you three ways to specify a character entity for a backtick: `, `, & `. The choice is yours.
The way to accomplish the example with this technique would be <code>List`1</code>, resulting in List`1. The markdown for List`List`1 would just be <code>List`List`1</code>. It's a little messy, but not unbearable if you're used to reading/writing HTML.
While more cumbersome than normal Markdown, this approach is also much more compatible. Some Markdown parsers don't like backslash-escapes; some will created nested code spans instead of working like @Brian's example; others will do other weird things; but the HTML approach will only fail if the Markdown parser has HTML turned completely off (which is exceedingly rare).
The general approach I take is “If I can't do it with Markdown, or if doing it in Markdown is a complicated mess of repeated symbols and tricks, just drop down to HTML for that use-case.”
Note that on SE sites, this only works in questions & answers, not comments (unfortunately! and somewhat negating my “exceedingly rate” analysis above!); HTML entities are displayed as plaintext in comments.
It's different in posts and in comments.
1.
`` ` `` Result (only for posts, not valid in comments): `
2.
<code>\`</code> Result (only for posts, not valid in comments): `
`\`` Result (only for comments, not valid in posts): ```
<code>\`xx\`</code> `\`x\`` renders as `x`. If you only escape the first one, you get ``x``.
\Example:`