Como incluir código na documentação

Há várias maneiras além de capturas de tela para incluir código em um artigo publicado no Microsoft Learn:

• Elementos individuais (palavras) numa linha.

  Eis um exemplo do estilo code.

  Utilize o formato de código quando se referir a parâmetros e variáveis com nome num bloco de código próximo no seu texto. O formato de código também pode ser utilizado para propriedades, métodos, classes e palavras-chave de linguagem. Para obter mais informações, veja Elementos de código mais adiante neste artigo.

• Blocos de código no ficheiro Markdown do artigo.

      ```csharp
      public static void Log(string message)
      {
          _logger.LogInformation(message);
      }
      ```
  

  Utilize blocos de código inline quando for pouco prático apresentar código com referência a um ficheiro de código. Para obter mais informações, veja Blocos de código mais adiante neste artigo.

• Blocos de código com referência a um ficheiro de código do repositório local.

  :::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" range="2-24,26":::
  

  Para obter mais informações, veja Referências a fragmentos dentro do repositório mais adiante neste artigo.

• Blocos de código com referência a um ficheiro de código de outro repositório.

  :::code language="csharp" source="~/samples-durable-functions/samples/csx/shared/Location.csx" highlight="2,5":::
  

  Para obter mais informações, veja Referências a fragmentos fora do repositório mais adiante neste artigo.

• Blocos de código que permitem aos utilizadores executarem código no browser.

  :::code source="PowerShell.ps1" interactive="cloudshell-powershell":::
  

  Para obter mais informações, veja Fragmentos de código interativos mais adiante neste artigo.

Para além de explicar o Markdown para cada uma destas formas de inclusão de código, o artigo contém documentação de orientação geral para todos os blocos de código.

Elementos de código

Um "elemento de código" é uma palavra-chave, um nome de classe, um nome de propriedade, entre outros, que faz parte de uma linguagem de programação. Nem sempre é óbvio determinar o que se qualifica como código. Por exemplo, os nomes de pacotes do NuGet devem ser tratados como código. Em caso de dúvida, veja Diretrizes de formatação de texto.

Estilo de código inline

Para incluir um elemento de código no texto do artigo, rodeie-o com backticks (') para indicar o estilo do código. O estilo de código inline não deve utilizar o formato de acentos graves triplos.

Markdown	Composto
Por padrão, o Entity Framework interpreta uma propriedade chamada 'Id' ou 'ClassnameID' como a chave primária.	Por predefinição, o Entity Framework interpreta uma propriedade com o nome Id ou ClassnameID como a chave primária.

Quando um artigo é localizado (traduzido para outros idiomas), o texto com o estilo de código não é traduzido. Se pretender evitar a tradução sem utilizar o estilo de código, veja Cadeias de carateres não traduzidas.

Estilo negrito

Alguns guias de estilo mais antigos especificam que o código inline deve estar a negrito. O negrito é uma opção que se pode utilizar quando o estilo de código é de tal forma intrusivo que compromete a legibilidade. Por exemplo, uma tabela Markdown que contenha maioritariamente elementos de código poderá parecer demasiado preenchida com estilos de código. Se optar por utilizar o estilo negrito, utilize cadeias de carateres não traduzidas para garantir que o seu código não está traduzido.

Ligações

Uma ligação para documentação de referência pode ser mais útil do que formato de código em alguns contextos. Se utilizar uma ligação, não aplique formato de código ao texto de ligação. Ao aplicar um estilo de código a uma ligação, pode tornar menos claro que o texto se trata de uma ligação.

Se utilizar uma ligação e referir o mesmo elemento mais tarde no mesmo contexto, as instâncias subsequentes devem utilizar formato de código em vez de ligações. Por exemplo:

The first reference to <xref:System.CommandLine> in this text is a link.
Subsequent references to `System.CommandLine` can be in code style.

Composto:

A primeira referência neste System.CommandLine texto é um link. As referências subsequentes podem System.CommandLine ser em estilo de código.

Marcadores de Posição

Se desejar que o usuário substitua uma seção do código exibido por seus próprios valores, use o texto de espaço reservado marcado por colchetes angulares. Por exemplo:

az group delete -n <ResourceGroupName>

Você pode notar que os parênteses devem ser removidos ao substituir valores reais. O Microsoft Writing Style Guide pede itálico, que pode ser formatado dentro de um código embutido entre colchetes angulares:

<ResourceGroupName> é o grupo de recursos onde...

As chaves { } são desencorajadas para uso como espaços reservados sintáticos. Eles podem ser confundidos com a mesma notação usada em texto substituível, cadeias de caracteres de formato, interpolação de cadeia de caracteres, modelos de texto e construções de programação semelhantes.

Os nomes de espaços reservados podem ser separados por hífenes ("caso de kebab"), com sublinhados, ou não separados de todo (caso de Pascal). Caso de Kebab pode gerar erros de sintaxe e sublinhados podem entrar em conflito com sublinhado. Todas as letras maiúsculas podem entrar em conflito com constantes nomeadas em muitos idiomas, embora também possam chamar a atenção para o nome do espaço reservado.

<Resource-Group-Name> ou <ResourceGroupName>

Blocos de código

A sintaxe para incluir código num documento depende da localização do código:

• No ficheiro Markdown do artigo
• Num ficheiro de código, no mesmo repositório
• Num ficheiro de código, num repositório diferente

Seguem-se as diretrizes aplicáveis a todos os três tipos de blocos de código:

• Imagens
• Automatize a validação de código
• Realçar as principais linhas de código
• Evite barras de rolagem horizontais
• Identifique claramente o código incorreto

Capturas de ecrã

Todos os métodos indicados na secção anterior resultam em blocos de código utilizáveis:

• Pode copiar e colar.
• São indexados por motores de busca.
• São acessíveis aos leitores de ecrã.

Estes são apenas alguns dos motivos pelos quais as capturas de ecrã de IDE não são recomendadas como um método de incluir código num artigo. Utilize capturas de ecrã de IDE para código apenas se estiver a mostrar algo sobre o próprio IDE, como o IntelliSense. Não utilize capturas de ecrã apenas para mostrar colorização e realces.

Validação de código

Alguns repositórios implementaram processos que compilam automaticamente todos os exemplos de código para verificar a existência de erros. O repositório .NET faz isto. Para obter mais informações, veja Contribuir no repositório .NET.

Se estiver a incluir blocos de código de outro repositório, trabalhe com os proprietários numa estratégia de manutenção do código para que o seu código incluído não falhe ou fique desatualizado à medida que novas versões das bibliotecas que o código utiliza são enviadas.

Destacar

Normalmente, os fragmentos incluem mais código do que o que é preciso para contextualizar. Quando destaca as linhas chave e que se está a focar dentro do fragmento, está a contribui para a legibilidade, tal como neste exemplo:

Não pode destacar o código quando o inclui no ficheiro Markdown do artigo. Só resulta em fragmentos de código incluídos por referência a um ficheiro de código.

Barras de deslocamento horizontal

Divida as linhas compridas para evitar as barras de deslocamento horizontais. As barras de deslocamento nos blocos de código dificultam a leitura do mesmo. São especialmente problemáticas em blocos de código mais longos, onde pode ser impossível ver em simultâneo a barra de deslocamento e a linha que quer ler.

Uma boa prática para minimizar as barras de deslocamento horizontal nos blocos de código consiste em dividir linhas de código com mais de 85 carateres. No entanto, tenha em atenção que a presença ou ausência de uma barra de deslocamento não é o único critério de legibilidade. Se dividir uma linha antes dos 85 carateres prejudicar a legibilidade ou conveniência de copiar e colar, não hesite em exceder os 85.

Identifique claramente o código incorreto

Em alguns cenários, é útil apontar padrões de codificação que devem ser evitados, por exemplo:

• Código que causará um erro de compilador se tentado.
• Código que será compilado corretamente, mas não é recomendado.

Para estes cenários:

• Explique o erro nos comentários de código e no texto do artigo.

  Os leitores muitas vezes ignoram o texto do artigo e olham apenas para o código, por isso não é suficiente explicar o erro apenas no texto do artigo. Também não é suficiente explicar o erro apenas em comentários de código, porque os comentários de código não são localizados.

• Considere comentar o código se ele causar um erro do compilador.

  O código comentado não interromperá o sistema de integração contínua (CI) se o repositório do artigo tiver um agora ou implementar um no futuro.

Para obter um exemplo de como apresentar código que não é recomendado, consulte Exemplo de uso de runa: alterando maiúsculas e minúsculas. Neste exemplo, o conselho para evitá-lo é até mesmo incorporado no próprio código, como o nome do método C# é ConvertToUpperBadExample.

Blocos de código inline

Utilize blocos de código inline apenas quando for pouco prático apresentar código com referência a um ficheiro de código. Geralmente, o código inline é mais difícil de testar e manter atualizado em comparação com um ficheiro de código que faz parte de um projeto completo. O código inline pode omitir o contexto que poderia ajudar o programador a compreender e utilizar o código. Estas considerações aplicam-se principalmente a linguagens de programação. Os blocos de código inline também podem ser utilizados para saídas e entradas (como JSON), linguagens de consulta (como SQL) e linguagens de scripts (como PowerShell).

Há duas maneiras de indicar que uma seção de texto em um arquivo de artigo é um bloco de código: cercando-a em triplos ticks (''') ou recuando-a. A delimitação por barreiras é preferível, uma vez que lhe permite especificar a linguagem. Evite utilizar avanços porque é muito fácil cometer um erro e pode ser difícil para outro autor compreender a sua intenção quando precisa de editar o seu artigo.

Os indicadores de linguagem são posicionados imediatamente antes dos acentos graves triplos iniciais, conforme o exemplo a seguir:

Markdown:

    ```json
    {
        "aggregator": {
            "batchSize": 1000,
            "flushTimeout": "00:00:30"
        }
    }
    ```

Composto:

{
    "aggregator": {
        "batchSize": 1000,
        "flushTimeout": "00:00:30"
    }
}

Gorjeta

O GitHub Flavored Markdown suporta a delimitação de blocos de código com tildes (~), bem como com backticks ('). O símbolo usado para abrir e fechar o bloco de código deve ser consistente dentro do mesmo bloco de código.

Para obter informações sobre os valores que pode utilizar como indicadores de linguagem, veja Language names and aliases (Nomes e aliases das linguagens).

Se você usar uma palavra de idioma ou ambiente após os triplos backticks (''') que não é suportada, essa palavra aparecerá na barra de título da seção de código na página renderizada. Sempre que possível, utilize um indicador de ambiente ou linguagem nos seus blocos de código inline.

Nota

Se você copiar e colar o código de um documento do Word, certifique-se de que ele não tenha "aspas enroladas", que não são válidas no código. Se tiver, altere para aspas normais (' e "). Como alternativa, conte com o Learn Authoring Pack, recurso de substituição de cotações inteligentes.

Referências a fragmentos dentro do repositório

A forma preferível de incluir fragmentos de código para linguagens de programação em documentos é através de referência a um ficheiro de código. Este método dá-lhe a capacidade de realçar linhas de código e disponibiliza o contexto mais amplo do fragmento no GitHub para que os programadores possam utilizá-lo. Você pode incluir código usando o formato de dois pontos triplos (:::) manualmente ou no Visual Studio Code com a ajuda do Learn Authoring Pack.

1. No Visual Studio Code, prima Alt+M ou Opção+M e selecione Snippet (Fragmento).
2. Quando a opção Snippet (Fragmento) estiver selecionada, ser-lhe-á pedido para selecionar Full Search (Pesquisa Completa), Scoped Search (Pesquisa de Âmbito) ou Cross-Repository Reference (Referência Entre Repositórios). Para procurar localmente, selecione Full Search (Pesquisa Completa).
3. Introduza um termo de pesquisa para procurar o ficheiro. Quando encontrar o ficheiro, selecione-o.
4. Em seguida, selecione uma opção para determinar que linhas de código devem ser incluídas no fragmento. As opções são: ID, Range e None.
5. Com base na sua seleção no Passo 4, forneça um valor caso seja necessário.

Apresentar o ficheiro de código completo:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs":::

Apresentar parte de um ficheiro de código através da especificação dos números de linha:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" range="2-24,26":::

Apresentar parte de um ficheiro de código através da especificação do nome de um fragmento:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" id="snippet_Create":::

As secções que seguem explicam estes exemplos:

• Utilizar um caminho relativo para o ficheiro de código
• Incluir apenas números de linha selecionados
• Mencionar um fragmento com nome
• Destacar linhas selecionadas

Para obter mais informações, veja Referência de sintaxe de fragmento mais adiante neste artigo.

Caminho do ficheiro de código

Exemplo:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" range="2-24,26":::

Este exemplo é do repositório de documentos ASP.NET, o ficheiro do artigo aspnetcore/data/ef-mvc/crud.md. A referência ao ficheiro de código é feita através de um caminho relativo para aspnetcore/data/ef-mvc/intro/samples/cu/Controllers/StudentsController.cs dentro do mesmo repositório.

Números de linha selecionados

Exemplo:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" range="2-24,26":::

Este exemplo apresenta apenas as linhas 2-24 e 26 do ficheiro de código StudentController.cs.

Dê preferência a fragmentos com nome em vez de números de linha hard-coded, conforme explicado na secção a seguir.

Fragmento com nome

Exemplo:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" id="snippet_Create":::

Utilize apenas letras e carateres de sublinhado para o nome.

O exemplo apresenta a secção snippet_Create do ficheiro de código. O ficheiro de código deste exemplo tem etiquetas de fragmentos nos comentários no código C#:

// code excluded from the snippet
// <snippet_Create>
// code included in the snippet
// </snippet_Create>
// code excluded from the snippet

Trechos de código nomeados podem ser aninhados, conforme mostrado no exemplo a seguir:

// <Method>
public static void SomeMethod()
{
    // <Line>
    // Single line of code.
    // </Line>
}
// </Method>

Quando o trecho de Method código é renderizado, as Line tags não são incluídas na saída renderizada.

Sempre que puder, crie uma referência para uma secção com nome em vez de especificar números de linha. As referências a números de linha são falíveis porque os ficheiros de código são inevitavelmente alterados de formas que alteram os números de linha. Poderá não receber uma notificação a informar que ocorreram tais alterações. Eventualmente, o seu artigo começará a apresentar as linhas erradas e nem saberá que algo foi alterado.

Destacar linhas selecionadas

Exemplo:

:::code language="csharp" source="intro/samples/cu/Controllers/StudentsController.cs" range="2-24,26" highlight="2,5":::

O exemplo destaca as linhas 2 e 5, a contar do início do fragmento apresentado. Os números de linha a realçar não são contabilizados a partir do início do ficheiro de código. Por outras palavras, as linhas 3 e 6 do ficheiro de código estão realçadas.

Referências a fragmento fora do repositório

Se o ficheiro de código que pretende referenciar se encontrar num repositório diferente, tem de configurar o repositório de código como um repositório dependente. Quando o fizer, especifique um nome para o repositório. Posteriormente, esse nome atuará como um nome de pasta para fins de referência a código.

Por exemplo, o repositório de documentos é Azure/azure-docs e o repositório de código é Azure/azure-functions-durable-extension.

Na pasta raiz azure-docs, adicione a seguinte secção em .openpublishing.publish.config.json:

    {
      "path_to_root": "samples-durable-functions",
      "url": "https://github.com/Azure/azure-functions-durable-extension",
      "branch": "main",
      "branch_mapping": {}
    },

Agora, quando mencionar samples-durable-functions como se fosse uma pasta dentro de azure-docs, está efetivamente a referir-se à pasta raiz no repositório azure-functions-durable-extension.

Você pode incluir código usando o formato de dois pontos triplos (:::) manualmente ou no Visual Studio Code com a ajuda do Learn Authoring Pack.

1. No Visual Studio Code, prima Alt+M ou Opção+M e selecione Snippet (Fragmento).
2. Quando a opção Snippet (Fragmento) estiver selecionada, ser-lhe-á pedido para selecionar Full Search (Pesquisa Completa), Scoped Search (Pesquisa de Âmbito) ou Cross-Repository Reference (Referência Entre Repositórios). Para procurar entre repositórios, selecione Cross-Repository Reference (Referência Entre Repositórios).
3. Ser-lhe-á apresentada uma seleção dos repositórios presentes no .openpublishing.publish.config.json. Selecione um repositório.
4. Introduza um termo de pesquisa para procurar o ficheiro. Quando encontrar o ficheiro, selecione-o.
5. Em seguida, selecione uma opção para determinar que linhas de código devem ser incluídas no fragmento. As opções são: ID, Range e None.
6. Com base na sua seleção no Passo 5, forneça um valor.

A sua referência a um fragmento terá o seguinte aspeto:

:::code language="csharp" source="~/samples-durable-functions/samples/csx/shared/Location.csx" highlight="2,5":::

No repositório azure-functions-durable-extension, esse ficheiro de código está na pasta samples/csx/shared. Conforme mencionado anteriormente, os números de linha de destaque são relativos ao início do fragmento e não ao início do ficheiro.

Nota

O nome atribuído ao repositório dependente é relativo à raiz do repositório principal, mas o til (~) refere-se à raiz do docset. A raiz docset é determinada por build_source_folder in .openpublishing.publish.config.json. O caminho para o fragmento no exemplo anterior funciona no repositório azure-docs porque build_source_folder se refere à raiz do repositório (.). Se build_source_folder fossem articles, o caminho iria começar com ~/../samples-durable-functions em vez de ~/samples-durable-functions.

Trechos em um caderno Jupyter

Você pode fazer referência a uma célula em um bloco de anotações Jupyter como um trecho de código. Para referenciar a célula:

1. Adicione metadados de célula ao bloco de anotações para as células que você deseja referenciar.
2. Configure o acesso ao repositório.
3. Use a sintaxe de trecho do bloco de anotações Jupyter em seu arquivo de marcação.

Adicionar metadados ao bloco de notas

1. Nomeie a célula adicionando metadados de célula no bloco de anotações Jupyter.

   • No Jupyter, você pode editar metadados de célula ativando primeiro a barra de ferramentas da célula: Exibir > Barra de Ferramentas de Célula > Editar Metadados.
   • Quando a barra de ferramentas da célula estiver ativada, selecione Editar metadados na célula que você deseja nomear.
   • Ou você pode editar metadados diretamente na estrutura JSON do bloco de anotações.

2. Nos metadados da célula, adicione um atributo "name":

   "metadata": {"name": "<name>"},
   

   Por exemplo:

   "metadata": {"name": "workspace"},
   

   Gorjeta

   Você pode adicionar quaisquer outros metadados que desejar para ajudá-lo a rastrear onde a célula está sendo usada. Por exemplo:

       "metadata": {
         "name": "workspace",
         "msdoc": "how-to-track-experiments.md"
       },
   

Configurar o acesso ao repositório

Se o arquivo do bloco de anotações que você deseja referenciar estiver em um repositório diferente, configure o repositório de código como um repositório dependente.

Referência de sintaxe de trecho de bloco de anotações Jupyter

Assim que o seu bloco de notas contiver os metadados necessários, consulte-os no seu ficheiro de marcação. Use o que você adicionou ao bloco de anotações e o <cell-name-value> que você configurou <path> como seu repositório dependente.

[!notebook-<language>[] (<path>/<notebook-name.ipynb>?name=<cell-name-value>)]

Por exemplo:

[!notebook-python[] (~/MachineLearningNotebooks/train-on-local.ipynb?name=workspace)]

Importante

Esta sintaxe é uma extensão Markdown de bloco. Tem de ser usada numa linha própria.

Use qualquer um dos idiomas suportados para o <language> identificador.

Fragmentos de código interativos

Blocos de código interativo inline

Nas seguintes linguagens, os fragmentos de código podem tornar-se executáveis na janela do browser:

• Azure Cloud Shell
• Azure PowerShell Cloud Shell
• C# REPL

Quando o modo interativo está ativado, as caixas de código composto têm um botão Experimentar ou Executar. Por exemplo:

    ```azurepowershell-interactive
    New-AzResourceGroup -Name myResourceGroup -Location westeurope
    ```

é representado da seguinte forma:

New-AzResourceGroup -Name myResourceGroup -Location westeurope

And

    ```csharp-interactive
    var aFriend = "Maria";
    Console.WriteLine($"Hello {aFriend}");
    ```

renderiza como:

    var aFriend = "Maria";
    Console.WriteLine($"Hello {aFriend}");

Para ativar esta funcionalidade para um bloco de código particular, tem de utilizar um identificador de linguagem especial. As opções disponíveis são:

• azurepowershell-interactive – ativa o Azure PowerShell Cloud Shell, tal como no exemplo anterior
• azurecli-interactive – Ativa o Azure Cloud Shell
• csharp-interactive – Ativa o C# REPL

No caso do Azure Cloud Shell e do PowerShell Cloud Shell, os utilizadores podem executar comandos apenas na sua própria conta do Azure.

Fragmentos de código incluídos por referência

Pode ativar o modo interativo para fragmentos de código incluídos por referência. Para ativar esta funcionalidade para um bloco de código particular, tem de utilizar o atributo interactive. Os valores do atributo disponíveis são:

• cloudshell-powershell – ativa o Azure PowerShell Cloud Shell, tal como no exemplo anterior
• cloudshell-bash – Ativa o Azure Cloud Shell
• try-dotnet – ativa o Try .NET
• try-dotnet-class – ativa o Try .NET com scaffolding de classes
• try-dotnet-method – ativa o Try .NET com scaffolding de métodos

Seguem-se alguns exemplos:

:::code source="PowerShell.ps1" interactive="cloudshell-powershell":::

:::code source="Bash.sh" interactive="cloudshell-bash":::

No caso do Azure Cloud Shell e do PowerShell Cloud Shell, os utilizadores podem executar comandos apenas na sua própria conta do Azure.

Para a experiência do .NET Interactive, o conteúdo do seu bloco de código depende de qual das três experiências de scaffolding escolhe:

• Sem andaimes (try-dotnet): O bloco de código deve representar um texto completo do programa. Por exemplo, o ficheiro Program.cs gerado por dotnet new console seria válido. Estes são mais úteis para mostrar um programa pequeno completo, incluindo as diretivas using necessárias. De momento, as instruções de nível superior não são suportadas.
• Andaime de método (try-dotnet-method): O bloco de código deve representar o conteúdo de um método em um Main aplicativo de console. Pode assumir as diretivas using adicionadas pelo modelo dotnet new console. Esta definição é mais útil para fragmentos pequenos que demonstram uma funcionalidade.
• Andaime de classe (try-dotnet-class): O bloco de código deve representar uma classe com um Main método como ponto de entrada do programa. Esta definição pode ser utilizada para demonstrar como os membros de uma classe interagem.

Referência de sintaxe de fragmento

Sintaxe:

:::code language="<language>" source="<path>" <attribute>="<attribute-value>":::

Importante

Esta sintaxe é uma extensão Markdown de bloco. Tem de ser usada numa linha própria.

• <language> (opcional)

  • Linguagem do fragmento de código. Para obter mais informações, veja a secção Linguagens suportadas mais à frente neste artigo.

• <path> (obrigatório)

  • O caminho relativo no sistema de ficheiros que indica o ficheiro do fragmento de código a referenciar.

• <attribute> e <attribute-value> (opcionais)

  • Usados juntos para especificar como o código deve ser recuperado do arquivo e como ele deve ser exibido:
    • range: 1,3-5 Um intervalo de linhas. Este exemplo inclui as linhas 1, 3, 4 e 5.
    • id: Create A ID do trecho que precisa ser inserido do arquivo de código. Este valor não pode coexistir com o intervalo.
    • highlight: 2-4,6 Intervalo e/ou números de linhas que precisam ser destacados no trecho de código gerado. A numeração é relativa às linhas apresentadas (conforme especificado pelo intervalo ou ID), não ao ficheiro.
    • interactive: cloudshell-powershell, cloudshell-bash, try-dotnet, try-dotnet-class, try-dotnet-method O valor de cadeia determina que tipos de interatividade estão ativados.
    • Para obter detalhes sobre a representação de nomes de etiquetas nos ficheiros de origem dos fragmentos de código por linguagem, veja as diretrizes do DocFX (em inglês).

Idiomas suportados

O Learn Authoring Pack inclui um recurso para fornecer preenchimento de instrução e validação dos identificadores de idioma disponíveis para blocos de cerca de código.

Blocos de código vedados

Nome	Aliases válidos
CLI de .NET Core	dotnetcli
1C	1c
ABNF	abnf
Registos de acesso	accesslog
Ada	ada
ARM assembler	armasm, arm
AVR assembler	avrasm
ActionScript	actionscript, as
Alan	alan, i
AngelScript	angelscript, asc
ANTLR	antlr
Apache	apache, apacheconf
AppleScript	applescript, osascript
Arcade	arcade
AsciiDoc	asciidoc, adoc
AspectJ	aspectj
ASPX	aspx
ASP.NET (C#)	aspx-csharp
ASP.NET (VB)	aspx-vb
AutoHotkey	autohotkey
AutoIt	autoit
Awk	awk, , , mawknawkgawk
Axapta	axapta
AzCopy	azcopy
CLI do Azure	azurecli
CLI do Azure (Interativo)	azurecli-interactive
Azure PowerShell	azurepowershell
Azure Powershell (Interativo)	azurepowershell-interactive
Bash	bash, , shzsh
Básica	basic
BNF	bnf
C	c
C#	csharp, cs
C# (Interativo)	csharp-interactive
C++	cpp, , , , , h++, ccchc++hpp
C++/CX	cppcx
C++/WinRT	cppwinrt
C/AL	cal
Cache Object Script	cos, cls
CMake	cmake, cmake.in
Coq	coq
CSP	csp
CSS	css
Cap'n Proto	capnproto, capnp
Clojure	clojure, clj
CoffeeScript	coffeescript, , , coffeecsoniced
Crmsh	crmsh, , crmpcmk
Crystal	crystal, cr
Cypher (Neo4j)	cypher
D	d
DAX Power BI	dax
Ficheiro de Zona DNS	dns, , zonebind
DOS	dos, , batcmd
Dart	dart
Delphi	delphi, , , , , , , lpr, lazarusdfmpasdprpascalfreepascallfm
Diff	diff, patch
Django	django, jinja
Dockerfile	dockerfile, docker
dsconfig	dsconfig
DTS (Árvore de Dispositivos)	dts
Dust	dust, dst
Guilherme	dylan
EBNF	ebnf
Elixir	elixir
Elm	elm
Erlang	erlang, erl
Excel	excel, , xlsxlsx
Extempore	extempore, , xtlangxtm
F#	fsharp, fs
FIX	fix
Fortran	fortran, , f90f95
G-Code	gcode, nc
Gams	gams, gms
GAUSS	gauss, gss
GDScript	godot, gdscript
Gherkin	gherkin
GN for Ninja	gn, gni
Go	go, golang
Golo	golo, gololang
Gradle	gradle
GraphQL	graphql
Groovy	groovy
HTML	html, xhtml
HTTP	http, https
Haml	haml
Handlebars	handlebars, , , hbshtml.hbshtml.handlebars
Haskell	haskell, hs
Haxe	haxe, hx
Hy	hy, hylang
Ini	ini
Inform7	inform7, i7
IRPF90	irpf90
JSON	json
Java	java, jsp
JavaScript	javascript, , jsjsx
Kotlin	kotlin, kt
Kusto	kusto
Folha	leaf
Lasso	lasso, , lslassoscript
Menos	less
LDIF	ldif
Lisp	lisp
LiveCode Server	livecodeserver
LiveScript	livescript, ls
Lua	lua
Makefile	makefile, , mkmak
Markdown	markdown, , , mdmkdownmkd
Mathematica	mathematica, , mmawl
Matlab	matlab
Maxima	maxima
Maya Embedded Language	mel
Mercury	mercury
Linguagem de Scripts mIRC	mirc, mrc
Mizar	mizar
formato MOF (Managed Object Format)	mof
Mojolicious	mojolicious
Monkey	monkey
Moonscript	moonscript, moon
MS Graph (Interativo)	msgraph-interactive
N1QL	n1ql
NSIS	nsis
Nginx	nginx, nginxconf
Nimrod	nimrod, nim
Nix	nix
OCaml	ocaml, ml
Objective C	objectivec, , , mmobjcobj-c
OpenGL Shading Language	glsl
OpenSCAD	openscad, scad
Oracle Rules Language	ruleslanguage
Oxygene	oxygene
PF	pf, pf.conf
PHP	php, , , , php3php4php5php6
Parser3	parser3
Perl	perl, , plpm
Texto simples sem destaque	plaintext
Pony	pony
PostgreSQL & PL/pgSQL	pgsql, , postgrespostgresql
PowerShell	powershell, ps
PowerShell (Interativo)	powershell-interactive
Em processamento	processing
Prólogo	prolog
Propriedades	properties
Memória Intermédia do Protocolo	protobuf
Puppet	puppet, pp
Python	python, , pygyp
Resultados de gerador de perfis de Python	profile
Q#	qsharp
PERGUNTAS E	k, kdb
QML	qml
R	r
Razor CSHTML	cshtml, , razorrazor-cshtml
ReasonML	reasonml, re
RenderMan RIB	rib
RenderMan RSL	rsl
Roboconf	graph, instances
Robot Framework	robot, rf
Ficheiros de especificações RPM	rpm-specfile, , , , rpmspecrpm-specspecfile
Ruby	ruby, , , , thor, rbgemspecpodspecirb
Rust	rust, rs
SAS	SAS, sas
SCSS	scss
SQL	sql
STEP Part 21	p21, , stepstp
Scala	scala
Esquema	scheme
Scilab	scilab, sci
Expressão de Forma	shexc
Shell	shell, console
Smali	smali
Smalltalk	smalltalk, st
Solidity	solidity, sol
Stan	stan
Stata	stata
Texto Estruturado	iecst, , , sclstlstructured-text
Stylus	stylus, styl
SubUnit	subunit
Supercollider	supercollider, sc
Swift	swift
Tcl	tcl, tk
Terraform (HCL)	terraform, , tfhcl
Test Anything Protocol	tap
TeX	tex
Thrift	thrift
TOML	toml
TP	tp
Twig	twig, craftcms
TypeScript	typescript, ts
VB.NET	vbnet, vb
VBScript	vbscript, vbs
VHDL	vhdl
Vala	vala
Verilog	verilog, v
Vim Script	vim
Visual Basic	vb
Visual Basic for Applications	vba
X++	xpp
x86 Assembly	x86asm
XL	xl, tao
XQuery	xquery, , xpathxq
XAML	xaml
XML	xml, , , , , , xsl, rssxhtmlxsdatomxjbplist
YAML	yml, yaml
Zephir	zephir, zep

Gorjeta

O recurso Learn Authoring Pack, Dev Lang Completion usa o primeiro alias válido quando vários aliases estão disponíveis.

Próximos passos

Para obter informações sobre formatação de texto para tipos de conteúdos que não sejam código, veja Text formatting guidelines (Diretrizes de formatação de texto).