Código Markdown
Markdown ofrece múltiples formas de mostrar código, desde simples códigos en línea hasta complejos bloques de código, satisfaciendo las necesidades de visualización de código en diferentes escenarios.
Código en línea
Si es un fragmento de código de una función o sección dentro de un párrafo, puedes envolverlo con comillas invertidas (`), por ejemplo:
`printf()` 函数
El resultado se muestra a continuación:

Ejemplos de usos comunes:
- Nombre de función: usa
console.log()información de salida - Nombre de variable: asigna el valor a
userNamevariable - Línea de comandos: ejecuta
npm installinstalar dependencias - Tecla de teclado: presiona
Ctrl+Ccopiar contenido - Nombre de archivo: edita
index.htmlarchivo

Escape de caracteres especiales
Cuando necesitas mostrar comillas invertidas u otros caracteres especiales dentro de un código en línea, debes aplicar un escape.
Método para mostrar comillas invertidas:
Usa comillas invertidas dobles para rodear una comilla invertida simple:
Usa `backticks` para envolver el código
Efecto de renderizado:

Usa múltiples comillas invertidas para rodear:
```Código que contiene `` dobles backticks```
Efecto de renderizado:

Manejo de otros caracteres especiales:
- Etiqueta HTML:
<div>elemento - Símbolo matemático: calcula
x + y = z - Símbolo especial: usa
para representar un espacio
Bloques de código
Bloque de código con sangría
Los bloques de código usan4 espacioso untabulador (tecla Tab)。
Formato de sintaxis:
Párrafo de texto normal
Este es un bloque de código con sangría
Cada línea tiene cuatro espacios al principio
Mantén el formato original del código
Continuar con texto normal

Ejemplo:

El resultado se muestra a continuación:

Bloque de código de triple comilla invertida
También puedes usar```para envolver un fragmento de código y especificar un lenguaje (también se puede omitir):
``` Contenido de código multilínea Puede contener líneas en blanco Mantener la sangría original ```

Las comillas invertidas triples (```) son la sintaxis de bloque de código más utilizada y admiten resaltado de sintaxis y visualización de código multilínea.
```javascript
$(document).ready(function () {
alert('EJEMPLO');
});
```
El resultado se muestra a continuación:

Notas:
- Los bloques de código con sangría deben ir separados por líneas en blanco antes y después
- Todas las líneas de código deben mantener una sangría consistente
- No admite resaltado de sintaxis
- Cuando se usan en listas, se necesitan 8 espacios de sangría
Identificador de lenguaje y resaltado de sintaxis
Agregar un identificador de lenguaje después de las comillas invertidas triples activa la función de resaltado de sintaxis.
Lista de identificadores de lenguaje comunes:
javascript/js- JavaScriptpython/py- Pythonhtml- HTMLcss- CSSsql- SQLjson- JSONxml- XMLyaml/yml- YAMLbash/shell- Script de Shelljava- Javacpp/c++- C++csharp/c#- C#php- PHPruby/rb- Rubygo- Lenguaje Gorust- Rusttypescript/ts- TypeScript
JavaScript:
```javascript
const users = [
{ name: "Alice", age: 25 },
{ name: "Bob", age: 30 }
];
const adults = users.filter(user => user.age >= 18);
console.log(adults);
```
Python:
```python
def calculate_area(radius):
"""计算圆的面积"""
import math
return math.pi * radius ** 2
# 使用函数
area = calculate_area(5)
print(f"圆的面积是: {area:.2f}")
```
SQL:
```sql SELECT u.name, u.email, COUNT(o.id) as order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id WHERE u.created_at >= '2024-01-01' GROUP BY u.id, u.name, u.email ORDER BY order_count DESC LIMIT 10; ```

Características avanzadas de los bloques de código
Visualización de números de línea
Algunos renderizadores de Markdown admiten mostrar números de línea, mediante una sintaxis o configuración específica.
Ejemplo de sintaxis (soportado parcialmente):
```javascript {.line-numbers}
function fibonacci(n) {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
console.log(fibonacci(10));
```
O usar:
```javascript showLineNumbers
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);
const sum = doubled.reduce((a, b) => a + b, 0);
console.log(`总和: ${sum}`);
```
Comparación de diferencias de código
Se utiliza para mostrar adiciones, eliminaciones o modificaciones de código, y es común para presentar cambios en el control de versiones.
Sintaxis Diff:
```diff
function calculateTotal(items) {
- let total = 0;
+ let total = 0.0;
for (let item of items) {
- total += item.price;
+ total += parseFloat(item.price);
}
+ // 保留两位小数
+ total = Math.round(total * 100) / 100;
return total;
}
```

Visualización de diferencias estilo Git:
```diff
@@ -1,5 +1,8 @@
function greetUser(name) {
- console.log("Hello " + name);
+ if (!name) {
+ throw new Error("Name is required");
+ }
+ console.log(`Hello, ${name}!`);
}
```Comparación de diferencias específica del lenguaje:
```javascript
// 之前的代码
const oldFunction = () => {
var x = 10; // ❌ 使用 var
console.log("Value: " + x); // ❌ 字符串拼接
}
// 改进后的代码
const newFunction = () => {
const x = 10; // ✅ 使用 const
console.log(`Value: ${x}`); // ✅ 模板字符串
}
```
