Microsoft C#

Contents
Ambiente de desenvolvimento do Windows

Visão geral
Dicas de desempenho e de fluxo de trabalho
Histórias de desenvolvedores
Tutoriais populares
Guia do Mac para Windows
Atalhos de teclado
Caminhos de desenvolvimento
Introdução ao JavaScript
Visão geral
Introdução ao NodeJS
Visão geral
Instalação no WSL
Instalar no Windows
Tutorial para iniciantes
Introdução ao React
Visão geral
Instalação no WSL
Instalar no Windows
Instalar o React Native para Windows
Instalar o React Native para Android
Instalar o NextJS
Instalar o Gatsby
Introdução ao Vue
Visão geral
Instalação no WSL
Instalar no Windows
Instalar o NuxtJS
Introdução ao Python
Visão geral
Introdução para iniciantes
Introdução ao desenvolvimento para a Web
Introdução à automação
Perguntas Frequentes
Introdução ao Android
Visão geral
Introdução ao Android nativo
Introdução à multiplataforma
Xamarin nativo
Xamarin.Forms
React Native
PWA (Ionic, PhoneGap, Cordova)
Configurações do Defender para aprimorar o desempenho
Testar no dispositivo ou no emulador
Introdução ao C e ao C++
Introdução ao C#
Introdução ao Docker
Introdução ao PowerShell
Introdução aos bancos de dados no WSL
Introdução ao Rust
Sumário
Visão geral do desenvolvimento no Windows com o Rust
Configurar seu ambiente de desenvolvimento
Rust para Windows
Tutorial do leitor de RSS (Rust para Windows)
Ferramentas e plataformas
Subsistema do Windows para Linux
Terminal do Windows
Gerenciador de Pacotes do Windows
Visão geral
Usar a ferramenta winget
Visão geral
Depuração e solução de problemas
Comando export
Comando features
Comando hash
Comando help
Comando import
Comando install
Comando list
Comando search
Comando settings
Comando show
Comando source
Comando uninstall
Comando upgrade
Comando validate
Enviar pacotes
Visão geral
Criar o manifesto do pacote
Enviar seu manifesto para o repositório
Processo de validação
Como solucionar problemas de envios
Erros de validação binária
Políticas de repositório
Histórico de alterações das políticas de repositório
PowerToys
Visão geral
Sobre o PowerToys
Instalar o PowerToys
Executar no modo admin
Modo Ativo
Seletor de Cor
FancyZones
Complementos do Explorador de Arquivos
Redimensionador de Imagem
Gerenciador de Teclado
Renomear Avançado
Execução do PowerToys
Guia de Atalhos
Ativar mudo de videoconferência
Código VS
Visual Studio
Azure
.NET
Configurar seu ambiente de desenvolvimento no
Windows
20/09/2021 • 4 minutes to read
O Windows convida você a codificar do seu jeito. Use a estrutura ou linguagem de codificação da sua
preferência, seja desenvolvendo com ferramentas no Windows ou com ferramentas Linux no Subsistema do
Windows para Linux, este guia ajudará você a configurar e instalar o que você precisa para começar a codificar,
depurar e acessar serviço para colocar seu trabalho em produção.
Caminhos de desenvolvimento
Introdução ao JavaScript
Comece a usar o JavaScript configurando seu ambiente de desenvolvimento no Windows ou no Subsistema do
Windows para Linux e instale o Node.js, o React, o Vue, o Express, o Gatsby, o Next.js ou o Nuxt.js.
Introdução ao Python
Instale o Python e obtenha a configuração do ambiente de desenvolvimento no Windows ou no Subsistema do
Windows para Linux.
Introdução ao Android
Instale o Android Studio ou escolha uma solução multiplataforma como Xamarin, React ou Cordova e obtenha
sua configuração de ambiente de desenvolvimento no Windows.
Introdução ao Windows Desktop
Comece a criar aplicativos da área de trabalho para Windows usando o SDK de Aplicativo do Windows, a UWP, o
Win32, o WPF o Windows Forms ou a atualizar e implantar aplicativos da área de trabalho existentes com Ilhas
XAML e MSIX.
Introdução ao C e ao C++
Comece a usar o C, C++ e o assembly para desenvolver aplicativos, serviços e ferramentas.
Introdução ao C#
Comece a criar aplicativos usando o C# e o .NET Core.
Introdução ao Docker Desktop para Windows

Crie contêineres de desenvolvimento remoto com suporte do Visual Studio, VS Code, .NET, Subsistema do
Windows para Linux ou uma variedade de serviços do Azure.
Introdução ao PowerShell
Comece a usar a automação de tarefas e o gerenciamento de configuração multiplataforma por meio do
PowerShell, um shell de linha de comando e uma linguagem de scripts.
Introdução ao Rust
Introdução à programação usando o Rust—incluindo como configurar o Rust para Windows consumindo o
windows crate.
Introdução ao Blazor
Comece a usar o Blazor, uma estrutura de interface do usuário do cliente dentro do ASP.NET Core. Use as
linguagens HTML, CSS e C# (em vez de JavaScript) para criar componentes de interface do usuário e aplicativos
de página única para a Web.
Ferramentas e plataformas
Subsistema do Windows para Linux

Use sua distribuição do Linux favorita totalmente integrada com o Windows (sem mais necessidade de
inicialização dupla).
Instalar o WSL
Terminal do Windows
Personalize seu ambiente de terminal para trabalhar com vários shells de linha de comando.
Instalar o Terminal

Use o cliente winget.exe, um gerenciador de pacotes abrangente, com sua linha de comando para instalar
aplicativos no Windows.
Instalar o Gerenciador de Pacotes do Windows (versão prévia pública)
Microsoft PowerToys
Ajuste e simplifique sua experiência com o Windows para obter maior produtividade com esse conjunto de
utilitários de usuário avançado.
VS Code
Um editor de código-fonte leve com suporte interno para JavaScript, TypeScript, Node.js, um avançado
ecossistema de extensões (C++, C#, Java, Python, PHP, Go) e runtimes (como .NET e Unity).
Instalar VS Code
Visual Studio
Um ambiente de desenvolvimento integrado que você pode usar para editar, depurar, compilar código e
publicar aplicativos, incluindo compiladores, o preenchimento de código do IntelliSense e muitos outros
recursos.
Instalar o Visual Studio
Azure
Uma plataforma de nuvem completa para hospedar seus aplicativos existentes e simplificar o novo
desenvolvimento. Os serviços do Azure integram tudo o que você precisa para desenvolver, testar, implantar e
gerenciar seus aplicativos.
Configurar uma conta do Azure
.NET
Uma plataforma de desenvolvimento de software livre com ferramentas e bibliotecas para compilar qualquer
tipo de aplicativo, incluindo Web, móvel, área de trabalho, jogos, IoT, nuvem e microsserviços.
Instalar o .NET
Executar o Windows e o Linux

O WSL (Subsistema do Windows para Linux) permite aos desenvolvedores executar um sistema operacional
Linux paralelamente ao Windows. Ambos compartilham o mesmo disco rígido (e podem acessar os arquivos
uns dos outros), a área de transferência dá suporte para copiar e colar dados entre os dos sistemas
normalmente, sem a necessidade de inicialização dupla. O WSL permite a você usar BASH e fornece o tipo de
ambiente mais conhecido pelos usuários do Mac.
Saiba mais nos documentos do WSL ou por meio dos vídeos do WSL no Canal 9.
Você também pode usar o Terminal do Windows para abrir todas as suas ferramentas de linha de comando
favoritas na mesma janela com várias guias ou em vários painéis, sejam elas o PowerShell, o prompt de
comando do Windows, o Ubuntu, o Debian, a CLI do Azure, o Oh-my-Zsh, o Git Bash ou todos os anteriores.
Saiba mais nos documentos do Terminal do Windows ou por meio dos vídeos do Terminal do Windows no
Canal 9.
Fazer a transição entre Mac e Windows

Confira nosso guia para fazer a transição entre o ambiente de desenvolvimento Mac e Windows (ou o
Subsistema do Windows para Linux). Ele pode ajudar você a mapear a diferença entre:
Atalhos do teclado
Atalhos do trackpad
Ferramentas do terminal e do shell
Aplicativos e utilitários
Recursos adicionais
Dicas para aprimorar o fluxo de trabalho
Histórias de desenvolvedores que alternaram do Mac para o Windows
Tutoriais, cursos e exemplos de código populares
Documentação da Pilha de Jogos da Microsoft
Dicas para melhorar o desempenho e os fluxos de
trabalho de desenvolvimento
Reunimos algumas dicas que esperamos que ajudem a tornar seu fluxo de trabalho mais eficiente e agradável.
Você tem mais dicas para compartilhar? Envie uma solicitação de pull, usando o botão "Editar" acima, ou um
problema, usando o botão "Comentários" abaixo e podemos adicioná-lo à lista.
NOTE
Se você estiver enfrentando problemas de desempenho relacionados ao desenvolvimento no Windows 10, como:
Ferramentas de desenvolvimento (por exemplo, compiladores, vinculadores etc.) com execução mais lenta no Windows
do que o esperado.
Plataformas de runtime (por exemplo, Node, .NET, Python) com execução mais lenta no Windows do que em outras
plataformas.
Seus aplicativos enfrentam problemas de desempenho relacionados à E/S/rede/criação de processo.
Informe-nos enviando um problema no repositório de Problemas de WinDev (Desenvolvedores Windows).
Usar atalhos para abrir um projeto no VS Code ou no Explorador de

Arquivos do Windows
Você pode iniciar o VS Code por meio da linha de comando no projeto que você abriu usando o comando:
code . ou abrir o diretório do projeto por meio da linha de comando com o Explorador de Arquivos do
Windows usando explorer.exe . do Windows ou sua distribuição do WSL. Talvez seja necessário adicionar o
VS Code executável à variável de ambiente PATH se isso não funcionar por padrão. Saiba mais sobre como
Iniciar por meio da linha de comando.
Usar o Gerenciador de Credenciais para o processo de autenticação

simplificado
Se você estiver usando o Git para controle de versão e colaboração, poderá simplificar seu processo de
autenticação configurando o Gerenciador de Credenciais do Git para armazenar seus tokens no Gerenciador de
Credenciais do Windows. Também recomendamos adicionar um arquivo .gitignore ao seu projeto.
Use o WSL para testar seu pipeline de produção antes de implantar

na nuvem
O Subsistema do Windows para Linux permite que os desenvolvedores executem um ambiente GNU/Linux,
incluindo a maioria das ferramentas de linha de comando, utilitários e aplicativos, diretamente no Windows,
sem modificações e sem a sobrecarga de uma máquina virtual tradicional ou instalação dualboot.
O WSL é destinado a desenvolvedores, com a intenção de ser usado como parte de um loop de
desenvolvimento interno. Digamos que Pedro esteja criando um pipeline de CI/CD (integração contínua e
entrega contínua) e queira testá-lo primeiro em um computador local (laptop) antes de implantá-lo na nuvem.
O Pedro poderá habilitar o WSL (e o WSL 2 para melhorar a velocidade e o desempenho) e, em seguida, usar
uma instância do Linux Ubuntu autêntica localmente (no laptop) com quaisquer comandos e ferramentas de
bash que preferir. Depois de verificar o pipeline de desenvolvimento localmente, Pedro pode enviar por push
esse pipeline de CI/CD para a nuvem (ou seja, para o Azure), colocando-o em um contêiner do Docker e
enviando o contêiner para uma instância de nuvem em que ele é executado em uma VM Ubuntu pronta para
produção.
Para obter mais maneiras de usar o WSL, confira Episódio Guias versus Espaços no WSL 2.
Melhorar a velocidade de desempenho do WSL evitando o

cruzamento de sistemas de arquivos
Se você estiver trabalhando com o Windows e o Subsistema do Windows para Linux, terá dois sistemas de
arquivos instalados: NTFS (Windows) e WSL (sua distribuição do Linux). Para um desempenho rápido, verifique
se os arquivos de projeto estão armazenados no mesmo sistema que as ferramentas que você está usando.
Saiba mais sobre como escolher o sistema de arquivos correto para ter um desempenho mais rápido.
Melhorar as velocidades de compilação adicionando exclusões no

Windows Defender
Você pode aprimorar sua velocidade de build atualizando suas configurações do Windows Defender para
adicionar exclusões para pastas de projeto ou tipos de arquivos confiáveis o suficiente para evitar a verificação
de ameaças à segurança. Saiba mais sobre como Atualizar as configurações do Windows Defender para
aprimorar o desempenho.
Iniciar todas as linhas de comando no Terminal do Windows de uma
vez
Você pode iniciar várias linhas de comando, como PowerShell, Ubuntu e CLI do Azure, tudo em uma
única janela com vários painéis usando Argumentos de Linha de Comando do Terminal do Windows.
Depois de instalar o Terminal do Windows, o WSL/Ubuntu e a CLI do Azure, digite este comando no
PowerShell para abrir uma nova janela de vários painéis com todos os três:
wt -p "Command Prompt" `; split-pane -p "Windows PowerShell" `; split-pane -H wsl.exe
Compartilhar sua dicas

Você tem alguma dica para ajudar outros desenvolvedores que usam o Windows a melhorar o fluxo de trabalho
deles? Envie uma solicitação de pull adicionando sua dica à página ou registre um problema se você quiser usar
para adicionar uma dica em um tópico específico.
Você tem problemas relacionados ao desempenho que gostaria de endereçar? Registre-o no novo repositório
de problemas do WinDev.
Obrigado, desenvolvedores. Estamos ouvindo e tentando melhorar sua experiência.
Histórias de desenvolvedores que alternaram do
Mac para o Windows
Achamos que pode ser útil ouvir as experiências de outros desenvolvedores sobre a mudança entre um
ambiente de desenvolvimento Mac e Windows. A maioria achou o processo razoavelmente simples e gostou
que eles ainda podiam usar as ferramentas do Linux e de software livre favoritas deles enquanto também
integraram o acesso às ferramentas de produtividade do Windows, como Microsoft Office, Outlook e Teams.
Aqui estão alguns artigos e entradas de blog que encontramos:
Ken Wang, "Think Different – Software Developer Switching from Mac to Windows" ("Pense diferente –
Desenvolvedor de software mudando do Mac para o Windows")
Owen Williams, "The state of switching to Windows from Mac in 2019" ("O estado da mudança do Mac para
o Windows em 2019")
August Lilleaas, "Why I ditched macOS, Linux, and chose Windows for development work" ("Por que eu
desisti do macOS e do Linux e escolhi o Windows para trabalhos de desenvolvimento")
Brent Rose, "What Happened When I Switched From Mac to Windows" ("O que aconteceu quando eu mudei
do Mac para o Windows")
Jack Franklin, "Using Windows 10 and WSL for frontend web development" ("Usando o Windows 10 e o
WSL para desenvolvimento para a Web de front-end")
Aaron Schlesinger, "Coming from a Mac to Windows & WSL 2" ("Passando de um Mac para Windows e WSL
2")
David Heinemeier Hansson, "Back to windows after twenty years" ("De volta ao Windows depois de 20
anos")
Ray Elenteny, "Why I returned to Windows" ("Por que eu voltei para o Windows")
Tutoriais, cursos e exemplos de código populares
Listamos alguns tutoriais, cursos e exemplos de código abaixo para introduzir você a algumas tarefas e cenários
de desenvolvimento comuns.
Criar um banco de dados

Criar um aplicativo MongoDB com React e Azure Cosmos DB
Implantar um aplicativo Web Python (Django) com PostgreSQL no Serviço de Aplicativo do Azure
Compilar um aplicativo Android

Compilar um aplicativo Android de tela dupla com funcionalidades do tipo "arrastar e soltar"
Criar um aplicativo multiplataforma

compilar um aplicativo multiplataforma de lista de tarefas pendentes com o Xamarin.Forms
Compilar um aplicativo Xamarin.Android que utiliza o Google Play Services para demonstrar a API do
Google Maps
Introdução ao WSL
Uma introdução ao Subsistema do Windows para Linux
Compilar um aplicativo Web ou chamar uma API

Compile seu primeiro aplicativo Web ASP.Net Core com o Blazor
Chamar uma API Web do ASP.NET Core de um aplicativo WPF usando o Azure AD v2
Compilar um aplicativo de console

Compile um aplicativo Java com o Microsoft Graph
Criar um microsserviço
Criar e implantar um microsserviço ASP.NET Core nativo de nuvem
Recursos adicionais
Explore cursos online gratuitos no Microsoft Learn
Explorar os cursos online da Pluralsight
Guia para alterar o ambiente de desenvolvimento
do Mac para o Windows
As dicas e os controles equivalentes a seguir devem ajudar em sua transição entre um ambiente de
desenvolvimento Mac e Windows (ou WSL/Linux).
Para o desenvolvimento de aplicativos, o equivalente mais próximo ao Xcode seria o Visual Studio. Também há
uma versão do Visual Studio para Mac, caso você sinta a necessidade de retornar. Para a edição de código-fonte
de plataforma cruzada (e diversos plug-ins), o Visual Studio Code é a escolha mais conhecida.
Atalhos de teclado
O P ERA Ç Ã O MAC W IN DO W S
Copiar Command+C Ctrl+C
Recortar Command+X Ctrl+X
Colar Command+V Ctrl+V
Desfazer Command+Z Ctrl+Z
Salvar Command+S Ctrl+S
Abrir Command+O Ctrl+O
Bloquear o computador Command+Control+Q Tecla do Windows+L
Mostrar a área de trabalho Command+F3 Tecla do Windows+D
Abrir o navegador de arquivos Command+N Tecla do Windows+E
Minimizar janelas Command+M Tecla do Windows+M
Pesquisar Command+Espaço Tecla do Windows
Fechar janela ativa Command+W Control+W
Alternar para a tarefa atual Command+Tab Alt+Tab
Maximizar uma janela para tela inteira Control+Command+F Tecla do Windows+seta para cima
Salvar tela (captura de tela) Command+Shift+3 Tecla do Windows+Shift+S
Salvar janela Command+Shift+4 Tecla do Windows+Shift+S

Exibir informações ou propriedades do Command+I Alt+Enter

item
Selecionar todos os itens Command+A Ctrl+A
Selecionar mais de um item em uma Command, depois clicar em cada item Controle, depois clicar em cada item
lista (não contíguo)
Digitar caracteres especiais Option+tecla de caractere Alt+tecla de caractere
Atalhos do trackpad
Observação: alguns desses atalhos exigem um "trackpad de precisão", como o trackpad em dispositivos Surface
e outros laptops de terceiros.
Rolagem Passar dois dedos na vertical Passar dois dedos na vertical
Zoom Pinçar com dois dedos para reduzir e Pinçar com dois dedos para reduzir e
aumentar aumentar
Passar o dedo para trás e para frente Passar dois dedos nas laterais Passar dois dedos nas laterais
entre exibições
Alternar espaços de trabalho virtuais Passar quatro dedos nas laterais Passar quatro dedos nas laterais
Exibir aplicativos abertos no momento Passar quatro dedos para cima Passar três dedos para cima
Alternar entre aplicativos N/D Passar devagar três dedos nas laterais
Acessar a área de trabalho Espalhar quatro dedos para fora Passar três dedos para baixo
Abrir a Cortana/Central de Ações Deslizar dois dedos a partir da direita Tocar com três dedos
Abrir informações adicionais Tocar com três dedos N/D
Mostrar a barra inicial/iniciar um Pinçar com quatro dedos Tocar com quatro dedos
aplicativo
Observação: as opções de trackpad são configuráveis nas duas plataformas.
Terminais e shells de linha de comando

O Windows dá suporte a vários terminais e shells de linha de comando que, às vezes, funcionam de maneira um
pouco diferente no shell do BASH do Mac e em aplicativos emuladores de terminal, como o Terminal e o iTerm.
Shells do Windows
O Windows tem dois shells primários de linha de comando:
1. PowerShell – O PowerShell é uma estrutura de gerenciamento de configuração e automação de tarefas
multiplataforma que consiste em um shell de linha de comando e linguagem de scripts criado em .NET.
Usando o PowerShell, administradores, desenvolvedores e usuários avançados podem controlar e
automatizar rapidamente tarefas que gerenciam processos complexos e vários aspectos do ambiente e
do sistema operacional em que ele é executado. O PowerShell é totalmente de software livre e, por ser
multiplataforma, também está disponível para Mac e Linux.
Usuários do shell do BASH para Mac e Linux : O PowerShell também dá suporte a muitos aliases de
comando com os quais você já está familiarizado. Por exemplo:
Liste o conteúdo do diretório atual, usando: ls
Mova arquivos com: mv
Mova para um novo diretório com: cd <path>
Alguns comandos e argumentos são diferentes no PowerShell em relação ao BASH. Saiba mais inserindo:
get-help no PowerShell ou confira os aliases de compatibilidade nos documentos.
Para executar o PowerShell como administrador, insira "PowerShell" no menu Iniciar do Windows e
selecione "Executar como Administrador".
2. Linha de Comando do Windows (Cmd) : O Windows ainda fornece o Prompt de Comando
tradicional (e o console – confira abaixo), fornecendo compatibilidade com comandos do MS-DOS atuais
e herdados e arquivos em lotes. O Cmd é útil ao executar arquivos em lotes existentes/antigos ou
operações de linha de comando, mas, em geral, é recomendável que os usuários aprendam e usem o
PowerShell, já que o Cmd agora está em manutenção e não receberá nenhum aprimoramento ou novos
recursos no futuro.
Shells do Linux
O WSL (Subsistema do Windows para Linux) agora pode ser instalado para dar suporte à execução de um shell
do Linux dentro do Windows. Isso significa que você pode executar o Bash , com qualquer distribuição específica
do Linux que escolher, integrado dentro do Windows. O uso de WSL fornecerá o tipo de ambiente mais
conhecido para os usuários do Mac. Por exemplo, você usa ls para listar os arquivos do diretório atual – e não
dir , como faria no Shell do Cmd tradicional do Windows. Para saber mais sobre como instalar e usar o WSL,
confira o Guia de Instalação do Subsistema do Windows para Linux para Windows 10. As distribuições do Linux
que podem ser instaladas no Windows com o WSL incluem:
1. Ubuntu 20.04 LTS
2. Kali Linux
3. Debian GNU/Linux
4. OpenSUSE Leap 15.1
5. SUSE Linux Enterprise Server 15 SP1
Para citar apenas algumas. Encontre mais nos documentos de instalação do WSL e instale-as diretamente da
Microsoft Store.
Terminais do Windows
Além de muitas ofertas de terceiros, a Microsoft fornece dois "terminais" – aplicativos de GUI que fornecem
acesso a shells de linha de comando e aplicativos.
1. Terminal do Windows : o Terminal do Windows é um novo aplicativo de terminal de linha de comando
moderno e altamente configurável que fornece um desempenho muito alto, experiência de usuário de
linha de comando de baixa latência, várias guias, painéis de janelas divididas, temas e estilos
personalizados, vários "perfis" para diferentes shells ou aplicativos de linha de comando, além de
oportunidades consideráveis para configurar e personalizar muitos aspectos da sua experiência de
usuário de linha de comando.
Você pode usar o Terminal do Windows para abrir guias conectadas ao PowerShell, a shells do WSL
(como Ubuntu ou Debian), ao Prompt de Comando tradicional do Windows ou a qualquer outro
aplicativo de linha de comando (por exemplo, SSH, CLI do Azure e Git Bash).
2. Console : no Mac e no Linux, os usuários geralmente iniciam seu aplicativo de terminal preferido que,
em seguida, cria e se conecta ao shell padrão do usuário (por exemplo, o BASH).
No entanto, devido a uma peculiaridade da história, os usuários do Windows tradicionalmente iniciam o
shell e o Windows inicia e conecta automaticamente um aplicativo de console da GUI.
Embora ainda seja possível iniciar os shells diretamente e usar o console herdado do Windows, é
altamente recomendável que, em vez disso, os usuários instalem e usem o Terminal do Windows para
experimentar a melhor, a mais rápida e a mais produtiva experiência de linha de comando.
A P L IC AT IVO MAC W IN DO W S
Configurações e Preferências Preferências do Sistema Settings
Gerenciador de tarefas Monitor de Atividade Gerenciador de Tarefas
Formatação de disco Utilitário de disco Gerenciamento de disco
Edição de texto TextEdit Bloco de notas
Exibição de evento Console Visualizador de Eventos
Localizar arquivos/aplicativos Command+Espaço Tecla do Windows

Guia para alterar o ambiente de desenvolvimento
do Mac para o Windows
As dicas e os controles equivalentes a seguir devem ajudar em sua transição entre um ambiente de
desenvolvimento Mac e Windows (ou WSL/Linux).
Para o desenvolvimento de aplicativos, o equivalente mais próximo ao Xcode seria o Visual Studio. Também há
uma versão do Visual Studio para Mac, caso você sinta a necessidade de retornar. Para a edição de código-fonte
de plataforma cruzada (e diversos plug-ins), o Visual Studio Code é a escolha mais conhecida.
Atalhos de teclado
Copiar Command+C Ctrl+C
Recortar Command+X Ctrl+X
Colar Command+V Ctrl+V
Desfazer Command+Z Ctrl+Z
Salvar Command+S Ctrl+S
Abrir Command+O Ctrl+O
Bloquear o computador Command+Control+Q Tecla do Windows+L
Mostrar a área de trabalho Command+F3 Tecla do Windows+D
Abrir o navegador de arquivos Command+N Tecla do Windows+E
Minimizar janelas Command+M Tecla do Windows+M
Pesquisar Command+Espaço Tecla do Windows
Fechar janela ativa Command+W Control+W
Alternar para a tarefa atual Command+Tab Alt+Tab
Maximizar uma janela para tela inteira Control+Command+F Tecla do Windows+seta para cima
Salvar tela (captura de tela) Command+Shift+3 Tecla do Windows+Shift+S
Salvar janela Command+Shift+4 Tecla do Windows+Shift+S

Exibir informações ou propriedades do Command+I Alt+Enter

item
Selecionar todos os itens Command+A Ctrl+A
Selecionar mais de um item em uma Command, depois clicar em cada item Controle, depois clicar em cada item
lista (não contíguo)
Digitar caracteres especiais Option+tecla de caractere Alt+tecla de caractere
Atalhos do trackpad
Observação: alguns desses atalhos exigem um "trackpad de precisão", como o trackpad em dispositivos Surface
e outros laptops de terceiros.
Rolagem Passar dois dedos na vertical Passar dois dedos na vertical
Zoom Pinçar com dois dedos para reduzir e Pinçar com dois dedos para reduzir e
aumentar aumentar
Passar o dedo para trás e para frente Passar dois dedos nas laterais Passar dois dedos nas laterais
entre exibições
Alternar espaços de trabalho virtuais Passar quatro dedos nas laterais Passar quatro dedos nas laterais
Exibir aplicativos abertos no momento Passar quatro dedos para cima Passar três dedos para cima
Alternar entre aplicativos N/D Passar devagar três dedos nas laterais
Acessar a área de trabalho Espalhar quatro dedos para fora Passar três dedos para baixo
Abrir a Cortana/Central de Ações Deslizar dois dedos a partir da direita Tocar com três dedos
Abrir informações adicionais Tocar com três dedos N/D
Mostrar a barra inicial/iniciar um Pinçar com quatro dedos Tocar com quatro dedos
aplicativo
Observação: as opções de trackpad são configuráveis nas duas plataformas.
Terminais e shells de linha de comando

O Windows dá suporte a vários terminais e shells de linha de comando que, às vezes, funcionam de maneira um
pouco diferente no shell do BASH do Mac e em aplicativos emuladores de terminal, como o Terminal e o iTerm.
Shells do Windows
O Windows tem dois shells primários de linha de comando:
1. PowerShell – O PowerShell é uma estrutura de gerenciamento de configuração e automação de tarefas
multiplataforma que consiste em um shell de linha de comando e linguagem de scripts criado em .NET.
Usando o PowerShell, administradores, desenvolvedores e usuários avançados podem controlar e
automatizar rapidamente tarefas que gerenciam processos complexos e vários aspectos do ambiente e
do sistema operacional em que ele é executado. O PowerShell é totalmente de software livre e, por ser
multiplataforma, também está disponível para Mac e Linux.
Usuários do shell do BASH para Mac e Linux : O PowerShell também dá suporte a muitos aliases de
comando com os quais você já está familiarizado. Por exemplo:
Liste o conteúdo do diretório atual, usando: ls
Mova arquivos com: mv
Mova para um novo diretório com: cd <path>
Alguns comandos e argumentos são diferentes no PowerShell em relação ao BASH. Saiba mais inserindo:
get-help no PowerShell ou confira os aliases de compatibilidade nos documentos.
Para executar o PowerShell como administrador, insira "PowerShell" no menu Iniciar do Windows e
selecione "Executar como Administrador".
2. Linha de Comando do Windows (Cmd) : O Windows ainda fornece o Prompt de Comando
tradicional (e o console – confira abaixo), fornecendo compatibilidade com comandos do MS-DOS atuais
e herdados e arquivos em lotes. O Cmd é útil ao executar arquivos em lotes existentes/antigos ou
operações de linha de comando, mas, em geral, é recomendável que os usuários aprendam e usem o
PowerShell, já que o Cmd agora está em manutenção e não receberá nenhum aprimoramento ou novos
recursos no futuro.
Shells do Linux
O WSL (Subsistema do Windows para Linux) agora pode ser instalado para dar suporte à execução de um shell
do Linux dentro do Windows. Isso significa que você pode executar o Bash , com qualquer distribuição específica
do Linux que escolher, integrado dentro do Windows. O uso de WSL fornecerá o tipo de ambiente mais
conhecido para os usuários do Mac. Por exemplo, você usa ls para listar os arquivos do diretório atual – e não
dir , como faria no Shell do Cmd tradicional do Windows. Para saber mais sobre como instalar e usar o WSL,
confira o Guia de Instalação do Subsistema do Windows para Linux para Windows 10. As distribuições do Linux
que podem ser instaladas no Windows com o WSL incluem:
1. Ubuntu 20.04 LTS
2. Kali Linux
3. Debian GNU/Linux
4. OpenSUSE Leap 15.1
5. SUSE Linux Enterprise Server 15 SP1
Para citar apenas algumas. Encontre mais nos documentos de instalação do WSL e instale-as diretamente da
Microsoft Store.
Terminais do Windows
Além de muitas ofertas de terceiros, a Microsoft fornece dois "terminais" – aplicativos de GUI que fornecem
acesso a shells de linha de comando e aplicativos.
1. Terminal do Windows : o Terminal do Windows é um novo aplicativo de terminal de linha de comando
moderno e altamente configurável que fornece um desempenho muito alto, experiência de usuário de
linha de comando de baixa latência, várias guias, painéis de janelas divididas, temas e estilos
personalizados, vários "perfis" para diferentes shells ou aplicativos de linha de comando, além de
oportunidades consideráveis para configurar e personalizar muitos aspectos da sua experiência de
usuário de linha de comando.
Você pode usar o Terminal do Windows para abrir guias conectadas ao PowerShell, a shells do WSL
(como Ubuntu ou Debian), ao Prompt de Comando tradicional do Windows ou a qualquer outro
aplicativo de linha de comando (por exemplo, SSH, CLI do Azure e Git Bash).
2. Console : no Mac e no Linux, os usuários geralmente iniciam seu aplicativo de terminal preferido que,
em seguida, cria e se conecta ao shell padrão do usuário (por exemplo, o BASH).
No entanto, devido a uma peculiaridade da história, os usuários do Windows tradicionalmente iniciam o
shell e o Windows inicia e conecta automaticamente um aplicativo de console da GUI.
Embora ainda seja possível iniciar os shells diretamente e usar o console herdado do Windows, é
altamente recomendável que, em vez disso, os usuários instalem e usem o Terminal do Windows para
experimentar a melhor, a mais rápida e a mais produtiva experiência de linha de comando.
A P L IC AT IVO MAC W IN DO W S
Configurações e Preferências Preferências do Sistema Settings
Gerenciador de tarefas Monitor de Atividade Gerenciador de Tarefas
Formatação de disco Utilitário de disco Gerenciamento de disco
Edição de texto TextEdit Bloco de notas
Exibição de evento Console Visualizador de Eventos
Localizar arquivos/aplicativos Command+Espaço Tecla do Windows

Instalar estruturas do JavaScript no Windows
Este guia ajudará você a começar a usar as estruturas JavaScript no Windows, incluindo o Node.js, o React.js, o
Vue.js, o Next.js, o Nuxt.js ou o Gatsby.
Escolha uma estrutura do JavaScript para instalar e configurar seu

ambiente de desenvolvimento
Visão geral do Node.js

Saiba mais sobre o que você pode fazer com o Node.js e como configurar um ambiente de desenvolvimento
dele.
Instalar no Windows
Instalação no WSL
Experimente um tutorial de nível iniciante
Visão geral do React

Saiba mais sobre o que você pode fazer com o React e como configurar um ambiente de desenvolvimento dele.
Instalação no Windows para criação de aplicativos Web
Instalação no WSL para criação de aplicativos Web
Instalação no Windows para criação de aplicativos da área de trabalho
Instalação no Windows para criação de aplicativos móveis Android
Visão geral do Vue.js
Saiba mais sobre o que você pode fazer com o Vue.js e como configurar um ambiente de desenvolvimento dele.
Instalar no Windows
Instalação no WSL
Instalar o Next.js no WSL

Next.js é uma estrutura para criar aplicativos JavaScript renderizados pelo servidor com base em React.js,
Node.js, Webpack e Babel.js. Saiba como instalá-lo no Subsistema do Windows para Linux.
Instalar o Nuxt.js no WSL

Nuxt.js é uma estrutura para criar aplicativos JavaScript renderizados pelo servidor com base em Vue.js, Node.js,
Webpack e Babel.js. Saiba como instalá-lo no Subsistema do Windows para Linux.
Instalar o Gatsby no WSL

O Gatsby é uma estrutura de gerador de site estático baseada no React.js. Saiba como instalá-lo no Subsistema
do Windows para Linux.
O que é o NodeJS?
O Node.js é um ambiente de runtime JavaScript do lado do servidor, de software livre e multiplataforma

baseado no mecanismo JavaScript V8 do Chrome, originalmente criado por Ryan Dahl e lançado em 2009.
O Node.js funciona no Windows?

Sim. O Windows 10 dá suporte a dois ambientes diferentes para o desenvolvimento de aplicativos com o
Node.js:
Instalar um ambiente de desenvolvimento do Node.js no Windows
Instalar um ambiente de desenvolvimento do Node.js no Subsistema do Windows para Linux
Para obter ajuda sobre como determinar qual ambiente deve ser usado, confira Devo fazer a instalação no
Windows ou no Subsistema do Windows para Linux?
O que você pode fazer com o NodeJS?

O Node.js é usado principalmente para criar aplicativos Web rápidos e escalonáveis. Ele usa um modelo de E/S
controlado por evento e sem bloqueio, tornando-o leve e eficiente. É uma ótima estrutura para aplicativos em
tempo real que usam muitos dados e que são executados em dispositivos distribuídos. Aqui estão alguns
exemplos do que você pode criar com o Node.js.
SPAs (aplicativos de página única) : são aplicativos Web que funcionam dentro de um navegador e não
precisam recarregar uma página sempre que você usá-la para obter novos dados. Alguns exemplos de SPAs
incluem aplicativos de rede social, aplicativos de mapa ou email, texto online ou ferramentas de desenho etc.
RTAs (aplicativos em tempo real) : são aplicativos Web que permitem aos usuários receber as
informações assim que publicadas por um autor, em vez de exigir que o usuário (ou software) verifique uma
fonte periodicamente em busca de atualizações. Alguns exemplos de RTAs incluem aplicativos de mensagens
instantâneas ou salas de chat, jogos com vários jogadores online que podem ser reproduzidos no navegador,
documentos de colaboração online, armazenamento da Comunidade, aplicativos de videoconferência etc.
Aplicativos de streaming de dados : são aplicativos (ou serviços) que enviam dados/conteúdo à medida
que chegam (ou são criados) e ao mesmo tempo mantêm a conexão aberta para continuar baixando dados,
conteúdo ou componentes adicionais, conforme necessário. Alguns exemplos incluem aplicativos de
streaming de vídeo e áudio.
APIs REST : são as interfaces que fornecem dados para interação com o aplicativo Web de outra pessoa. Por
exemplo, um serviço de API de Calendário pode fornecer datas e horas para um local de show que poderia
ser usado pelo site de eventos locais de outra pessoa.
Aplicativos SSR (renderizados do lado do ser vidor) : esses aplicativos Web podem ser executados no
cliente (no navegador/front-end) e no servidor (o back-end), permitindo que as páginas dinâmicas exibam
(gerem HTML para) qualquer conteúdo conhecido e extraiam rapidamente conteúdo não conhecido quando
disponível. Eles são frequentemente chamados de aplicativos "isomórficos" ou "universais". Os SSRs utilizam
métodos SPA, de modo que não precisam ser recarregados toda vez que forem usados. No entanto, os SSRs
oferecem alguns benefícios que podem ou não ser importantes para você, como fazer com que o conteúdo
do seu site apareça nos resultados da pesquisa do Google e fornecer uma imagem de visualização quando
os links para seu aplicativo são compartilhados em mídias sociais, como o Twitter ou o Facebook. A possível
desvantagem é que ele exige um servidor Node.js em constante execução. A título de exemplo, um aplicativo
de rede social com suporte a eventos que os usuários desejam que apareçam nas resultados da pesquisa e
em mídias sociais pode se beneficiar de SSR, mas aplicativos de email podem se beneficiar mais de SPA. Você
também pode executar aplicativos não SPA renderizados pelo servidor, como um blog do WordPress. Como
podemos ver, conforme as coisas vão ficando complicadas, você precisa decidir o que é importante.
Ferramentas da linha de comando : permitem automatizar tarefas repetitivas e, em seguida, distribuir sua
ferramenta pelo vasto ecossistema Node.js. Um exemplo de ferramenta de linha de comando é cURL, que
representa a URL do cliente e é usada para baixar conteúdo de uma URL da internet. A cURL geralmente é
usada para instalar itens como Node.js ou, em nosso caso, um gerenciador de versão do Node.js.
Programação de hardware : embora não seja tão conhecido quanto os aplicativos Web, o Node.js vem
crescendo em popularidade para usos de IoT, como coletar dados de sensores, sinalizadores, transmissores,
motores ou qualquer item que gere grandes quantidades de dados. O Node.js pode habilitar a coleta e
análise de dados, a comunicação entre um dispositivo e um servidor e a execução de ações com base na
análise. O NPM contém mais de 80 pacotes para controladores Arduino, Raspberry Pi, Intel IoT Edison, vários
sensores e dispositivos Bluetooth.
Próximas etapas
Devo fazer a instalação no Windows ou no WSL (Subsistema do Windows para Linux)?
Instalar o NodeJS no Windows
Instalar o NodeJS no WSL
Microsoft Learn: Criar aplicativos JavaScript com o Node.js
Instalar o Node.js no WSL2 (Subsistema do
Windows para Linux)
Se você está usando o Node.js em um contexto profissional, considera a velocidade de desempenho e a

compatibilidade de chamadas do sistema importantes, deseja executar contêineres do Docker que aproveitam
os workspaces do Linux e evitam a necessidade de manter scripts de build do Linux e do Windows ou
simplesmente prefere usar uma linha de comando do Bash, instale o Node.js no Subsistema do Windows para
Linux (mais especificamente, no WSL 2).
O uso do WSL (Subsistema do Windows para Linux) permite que você instale sua distribuição preferida do
Linux (o Ubuntu é o nosso padrão), de modo que você possa ter consistência entre o ambiente de
desenvolvimento (local no qual você escreve o código) e o ambiente de produção (servidor no qual o código é
implantado).
NOTE
Se você é iniciante no desenvolvimento com o Node.js e quer aprender a usá-lo rapidamente, instale o Node.js no
Windows. Essa recomendação também se aplica se você planeja usar um ambiente de produção do Windows Server.
Instalar o WSL 2
O WSL 2 é a versão mais recente disponível no Windows 10, e a recomendamos para os fluxos de trabalho de
desenvolvimento profissional do Node.js. Para habilitar e instalar o WSL 2, siga as etapas na documentação de
instalação do WSL. Essas etapas incluirão a escolha da distribuição do Linux (por exemplo, o Ubuntu).
Após instalar o WSL 2 e uma distribuição do Linux, abra a distribuição do Linux (encontrada no menu Iniciar do
Windows) e verifique a versão e o codinome usando o comando: lsb_release -dc .
É recomendável atualizar a distribuição do Linux regularmente, inclusive imediatamente após a instalação, para
garantir que os pacotes são os mais recentes. O Windows não cuida automaticamente dessa atualização. Para
atualizar a distribuição, use o comando: sudo apt update && sudo apt upgrade .
Instalar o Terminal do Windows (opcional)

O Terminal do Windows é um shell de linha de comando aprimorado que permite executar várias guias, de
modo que você possa alternar rapidamente entre as linhas de comando do Linux, o prompt de comando do
Windows, o PowerShell, a CLI do Azure ou o que preferir usar. Você também pode criar associações de chave
personalizadas (teclas de atalho para abrir ou fechar guias, copiar e colar etc.), usar o recurso de pesquisa,
personalizar o terminal com temas (esquemas de cores, tamanhos e estilos de fonte,
imagem/desfoque/transparência da tela de fundo), entre outros. Saiba mais na documentação do Terminal do
Windows.
Instale o Terminal do Windows usando a Microsoft Store: com a instalação dele por meio da Store, as
atualizações serão processadas automaticamente.
Instalar NVM, Node.js e NPM

Além de você escolher se deseja instalá-lo no Windows ou no WSL, há opções adicionais a serem feitas ao
instalar o Node.js. É recomendável usar um gerenciador de versão, pois as versões mudam muito rapidamente.
Provavelmente, você precisará alternar entre várias versões do Node.js de acordo com as necessidades de
diferentes projetos nos quais está trabalhando. O Node Version Manager, mais comumente chamado de NVM, é
a maneira mais popular de instalar várias versões do Node.js. Veremos as etapas para instalar o NVM e, em
seguida, usá-lo para instalar o Node.js e o NPM (Node Package Manager). Há gerenciadores de versão
alternativos que serão considerados e abordados na próxima seção.
IMPORTANT
É sempre recomendável remover todas as instalações existentes do Node.js ou do NPM do seu sistema operacional antes
de instalar um gerenciador de versão, pois os diferentes tipos de instalação podem levar a conflitos estranhos e confusos.
Por exemplo, a versão do Node que pode ser instalada com o comando apt-get do Ubuntu está desatualizada no
momento. Para obter ajuda com a remoção de instalações anteriores, confira Como remover o Node.js do Ubuntu.
1. Abra a linha de comando do Ubuntu 18.04.

2. Instale o cURL (uma ferramenta usada para baixar conteúdo da Internet na linha de comando) com:
sudo apt-get install curl
3. Instale o NVM, com: curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
NOTE
No momento da publicação, o NVM v0.38.0 era a última versão disponível. Você pode verificar a página do
projeto GitHub para obter a versão mais recente do NVM e ajustar o comando acima para incluir a versão mais
recente. A instalação da versão mais recente do NVM usando cURL substituirá a mais antiga, deixando intacta a
versão do Node que você usou o NVM para instalar. Por exemplo:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
4. Para verificar a instalação, digite: command -v nvm ...isso deverá retornar 'nvm'. Se você receber 'comando
não encontrado' ou nenhuma resposta, feche o terminal atual, reabra-o e tente novamente. Saiba mais no
repositório GitHub do NVM.
5. Lista quais versões do Node estão instaladas no momento (não deve ter nenhuma neste ponto): nvm ls
6. Instale a versão atual do Node.js (para testar os aprimoramentos dos recursos mais recentes, mas com
mais probabilidade de ter problemas): nvm install node
7. Instale a versão mais recente e estável do LTS do Node.js (recomendado): nvm install --lts
8. Liste quais versões do Node estão instaladas: nvm ls ... agora você deve ver listadas as duas versões que
acabou de instalar.
9. Verifique se o Node.js está instalado e a versão padrão atual com: node --version . Em seguida, verifique
se você também tem o NPM, com: npm --version (Você também pode usar which node ou which npm
para ver o caminho usado para as versões padrão).
10. Para alterar a versão do Node.js que você deseja usar para um projeto, crie um diretório de projeto
mkdir NodeTest e insira o diretório cd NodeTest . Em seguida, digite nvm use node para alternar para a
versão atual ou nvm use --lts para alternar para a versão LTS. Você também pode usar o número
específico para qualquer versão adicional instalada, como nvm use v8.2.1 . (Para listar todas as versões
disponíveis do Node.js, use o comando: nvm ls-remote ).
Se você estiver usando o NVM para instalar o Node.js e o NPM, não será necessário usar o comando SUDO para
instalar novos pacotes.
Gerenciadores de versão alternativos

Embora o NVM seja atualmente o gerenciador de versão mais popular para o nó, há algumas alternativas a
serem consideradas:
O n é uma alternativa nvm de longa duração que realiza a mesma coisa com comandos ligeiramente
diferentes e é instalada por meio de npm , em vez de um script Bash.
O fnm é um gerenciador de versão mais recente, que alega ser muito mais rápido do que nvm . (Ele também
usa o Azure Pipelines.)
O Volta é um novo gerenciador de versão da equipe do LinkedIn que alega uma velocidade aprimorada e
suporte multiplataforma.
O asdf-vm é uma CLI para vários idiomas, como ike gvm, nvm, rbenv e pyenvv (e muito mais), tudo em um.
O nvs (Node Version Switcher) é uma alternativa nvm multiplataforma com a capacidade de integração ao
VS Code.
Instalar o Visual Studio Code

Recomendamos usar o Visual Studio Code com o pacote de extensão de desenvolvimento remoto para projetos
do Node.js. Isso divide o VS Code em uma arquitetura de "cliente-servidor", com o cliente (a interface do
usuário do VS Code) em execução no sistema operacional Windows e o servidor (seu código, Git, plug-ins etc.)
em execução "remotamente" na distribuição do Linux do seu WSL.
NOTE
Esse cenário "remoto" é um pouco diferente do que você pode estar acostumado. O WSL dá suporte a uma distribuição
do Linux real em que o código do projeto está em execução, separadamente do sistema operacional Windows, mas ainda
em seu computador local. A extensão Remote-WSL se conecta ao seu subsistema Linux como se fosse um servidor
remoto, embora não esteja em execução na nuvem… ainda está em execução no computador local, no ambiente do WSL
que você habilitou para ser executado em paralelo com o Windows.
Há suporte para lint e IntelliSense baseado em Linux.

Seu projeto será criado automaticamente no Linux.
Você pode usar todas as suas extensões em execução no Linux (ES Lint, NPM IntelliSense, snippets ES6 etc.).
Outros editores de código, como o IntelliJ, o Sublime Text, o Brackets etc., também funcionarão com um
ambiente de desenvolvimento do WSL 2 do Node.js, mas talvez não tenham os mesmos tipos de recursos
remotos oferecidos pelo VS Code. Esses editores de código podem ter problemas para acessar a localização da
rede compartilhada do WSL (\wsl$\Ubuntu\home) e tentarão compilar os arquivos do Linux usando as
ferramentas do Windows, o que, provavelmente, não será o desejado. A extensão do WSL Remoto no VS Code
cuida dessa compatibilidade para você. Com outros IDEs, talvez seja necessário configurar um servidor X. Em
breve, haverá suporte para a execução de aplicativos de GUI no WSL (como um IDE do editor de códigos).
Os editores de texto baseados em terminal (vim, emacs, nano) também são úteis para fazer alterações rápidas
diretamente dentro do seu console. O artigo Emacs, Nano ou Vim: escolha seu editor de texto baseado em
terminal com sabedoria explica bem sobre algumas diferenças e um pouco sobre como usar cada um deles.
Para instalar o VS Code e a extensão Remote-WSL:
1. Baixe e instale o VS Code para Windows. O VS Code também está disponível para Linux, mas o
Subsistema do Windows para Linux não dá suporte a aplicativos de GUI e, portanto, precisamos instalá-
lo no Windows. Não se preocupe, você ainda poderá fazer a integração à linha de comando e às
ferramentas do Linux usando a Extensão WSL – Remoto.
2. Instale a Extensão WSL – Remoto no VS Code. Isso permite que você use o WSL como o ambiente de
desenvolvimento integrado e cuidará da compatibilidade e dos caminhos para você. Saiba mais.
IMPORTANT
Se você já tiver o VS Code instalado, precisará verificar se tem a versão de maio 1.35 ou posterior para instalar a Extensão
do WSL Remoto. Não recomendamos o uso do WSL no VS Code sem a extensão do WSL Remoto, pois você perderá o
suporte de preenchimento automático, depuração, linting etc. Curiosidade: Essa extensão do WSL é instalada em
$HOME/.vscode-server/extensions.
Extensões úteis do VS Code

Embora o VS Code venha com muitos recursos prontos para uso para desenvolvimento do Node.js, há algumas
extensões úteis que você pode considerar instalar e que estão disponíveis no Pacote de extensão do Node.js.
Instale todas ou escolha a que parecer mais útil para você.
Para instalar o pacote de extensão do Node.js:
1. Abra a janela Extensões (Ctrl + Shift + X) no VS Code.
A janela Extensões agora está dividida em três seções (porque você instalou a extensão Remote-WSL).
"Local – Instalado": as extensões instaladas para uso com o sistema operacional Windows.
"WSL:Ubuntu-18.04 – Instalado": as extensões instaladas para uso com o sistema operacional Ubuntu
(WSL).
"Recomendado": as extensões recomendadas pelo VS Code com base nos tipos de arquivo em seu
projeto atual.
2. Na caixa de pesquisa na parte superior da janela Extensões, digite: Pacote de extensão do Node (ou o
nome de qualquer extensão que você estiver procurando). A extensão será instalada para as instâncias
local ou WSL do VS Code, dependendo de onde você tiver aberto o projeto atual. Você pode saber
selecionando o link remoto no canto inferior esquerdo da janela do VS Code (em verde). Ele fornecerá a
opção de abrir ou fechar uma conexão remota. Instale suas extensões do Node.js no ambiente
"WSL:Ubuntu-18.04".
Algumas extensões adicionais que talvez você queira considerar incluem:

Depurador para Chrome: depois de concluir o desenvolvimento no lado do servidor com o Node.js, você
precisará desenvolver e testar o lado do cliente. Essa extensão integra seu editor do VS Code ao serviço de
depuração do navegador Chrome, tornando as coisas um pouco mais eficientes.
Mapas de teclas de outros editores: essas extensões poderão ajudar na familiaridade com seu ambiente se
você estiver fazendo a transição de outro editor de texto (como Atom, Sublime, Vim, eMacs, Notepad++ etc.).
Sincronização de configurações: permite que você sincronize suas configurações do VS Code em diferentes
instalações usando o GitHub. Se você trabalha em diferentes computadores, isso ajuda a manter seu
ambiente consistente entre eles.
Configurar o Git (opcional)
Para configurar o Git para um projeto Node.js no WSL, confira o artigo Introdução ao uso do Git no Subsistema
do Windows para Linux na documentação do WSL.
Se você é iniciante no desenvolvimento com o Node.js e quer aprender a usá-lo rapidamente, siga as etapas
abaixo para instalar o Node.js diretamente no Windows.
NOTE
Se você está usando o Node.js em um contexto profissional, considera a velocidade de desempenho e a compatibilidade
de chamadas do sistema importantes, deseja executar contêineres do Docker que aproveitam os workspaces do Linux e
evita a necessidade de manter os scripts de build do Linux e do Windows ou simplesmente prefere usar uma linha de
comando do Bash, instale o Node.js no Subsistema do Windows para Linux (mais especificamente, no WSL 2).
Instalar NVM-Windows, Node.js e NPM

Além de você escolher se deseja instalá-lo no Windows ou no WSL, há opções adicionais a serem feitas ao
instalar o Node.js. É recomendável usar um gerenciador de versão, pois as versões mudam muito rapidamente.
Provavelmente, você precisará alternar entre várias versões do Node.js de acordo com as necessidades de
diferentes projetos nos quais você está trabalhando. O Node Version Manager, mais comumente chamado de
NVM, é a maneira mais popular de instalar várias versões do Node.js, mas só está disponível para Mac/Linux e
não tem suporte no Windows. Em vez disso, veremos as etapas para instalar o NVM-Windows e, em seguida,
usá-lo para instalar o Node.js e o NPM (Node Package Manager). Há gerenciadores de versão alternativos que
serão considerados e abordados na próxima seção.
IMPORTANT
É sempre recomendável remover todas as instalações existentes do Node.js ou do NPM do seu sistema operacional antes
de instalar um gerenciador de versão, pois os diferentes tipos de instalação podem levar a conflitos estranhos e confusos.
Isso inclui a exclusão de diretórios de instalação do Node.js existentes (por exemplo, "C:\Arquivos de Programas\nodejs")
que possam permanecer. O link simbólico gerado pelo NVM não substituirá um diretório de instalação existente (mesmo
vazio). Para obter ajuda com a remoção de instalações anteriores, confira Como remover completamente o Node.js do
Windows.
1. Abra o repositório do Windows-NVM no navegador da Internet e selecione o link Baixar Agora .

2. Baixe o arquivo nvm-setup.zip para obter a versão mais recente.
3. Depois de baixado, abra o arquivo zip e abra o arquivo nvm-setup.exe .
4. O assistente de instalação Setup-NVM-for-Windows guiará você pelas etapas de instalação, incluindo a
escolha do diretório onde NVM-Windows e Node.js serão instalados.
5. Quando a instalação for concluída. Abra o PowerShell e tente usar o Windows-NVM para listar quais
versões do Node estão instaladas no momento (não deve ter nenhuma neste ponto): nvm ls
6. Instale a versão atual do Node.js (para testar os aprimoramentos dos recursos mais recentes, mas com
mais probabilidade de ter problemas do que a versão LTS): nvm install latest
7. Instale a versão mais recente do LTS estável do Node.js (recomendada) examinando primeiro qual é o
número de versão atual do LTS: nvm list available , em seguida, instale o número de versão do LTS com:
nvm install <version> (substitua <version> pelo número, ou seja: nvm install 12.14.0 ).
8. Liste quais versões do Node estão instaladas: nvm ls ... agora você deve ver listadas as duas versões que
acabou de instalar.
9. Depois de instalar os números de versão do Node.js de que você precisa, selecione a versão que deseja
usar inserindo nvm use <version> (substituindo <version> pelo número, ou seja: nvm use 12.9.0 ).
10. Para alterar a versão do Node.js que você deseja usar para um projeto, crie um diretório de projeto
mkdir NodeTest e insira o diretório cd NodeTest . Em seguida, digite nvm use <version> substituindo
<version> pelo número de versão que deseja usar (como v10.16.3).
11. Verifique qual versão do NPM está instalada com: npm --version , este número de versão será alterado
automaticamente para qualquer versão do NPM associada à sua versão atual do Node.js.
Gerenciadores de versão alternativos
Embora o Windows-NVM seja atualmente o gerenciador de versão mais popular para o nó, há alternativas a
serem consideradas:
O nvs (Node Version Switcher) é uma alternativa nvm multiplataforma com a capacidade de integração
ao VS Code.
O Volta é um novo gerenciador de versão da equipe do LinkedIn que alega uma velocidade aprimorada e
suporte multiplataforma.
Para instalar o Volta como seu gerenciador de versão (em vez do Windows-NVM), vá para a seção Instalação
do Windows de seu guia de Introdução, em seguida, baixe e execute o instalador do Windows Installer,
seguindo as instruções de instalação.
IMPORTANT
Você precisa garantir que o Modo de Desenvolvedor esteja habilitado no computador Windows antes de instalar o Volta.
Para saber mais sobre como usar o Volta para instalar várias versões do Node.js no Windows, confira os
Documentos do Volta.

Recomendamos que você instale o Visual Studio Code, bem como o Pacote de Extensão do Node.js, para
desenvolvimento com o Node.js no Windows. Instale todas ou escolha a que parecer mais útil para você.
Para instalar o pacote de extensão do Node.js:
1. Abra a janela Extensões (Ctrl + Shift + X) no VS Code.
2. Na caixa de pesquisa na parte superior da janela Extensões, digite: "Pacote de extensão do Node" (ou o nome
da extensão que você está procurando).
3. Selecione Instalar . Uma vez instalada, sua extensão aparecerá na pasta "Habilitado" da janela Extensões . É
possível desabilitar, desinstalar ou definir as configurações selecionando o ícone de engrenagem ao lado da
descrição de sua nova extensão.
Algumas extensões adicionais que talvez você queira considerar incluem:
Depurador para Chrome: depois de concluir o desenvolvimento no lado do servidor com o Node.js, você
precisará desenvolver e testar o lado do cliente. Essa extensão integra seu editor do VS Code ao serviço de
depuração do navegador Chrome, tornando as coisas um pouco mais eficientes.
Mapas de teclas de outros editores: essas extensões poderão ajudar na familiaridade com seu ambiente se
você estiver fazendo a transição de outro editor de texto (como Atom, Sublime, Vim, eMacs, Notepad++ etc.).
Sincronização de configurações: permite que você sincronize suas configurações do VS Code em diferentes
instalações usando o GitHub. Se você trabalha em diferentes computadores, isso ajuda a manter seu
ambiente consistente entre eles.
Editores de código alternativos
Se você preferir usar um editor de código ou um IDE diferente do Visual Studio Code, as seguintes opções
também serão boas para seu ambiente de desenvolvimento do Node.js:
IntelliJ IDEA
Sublime Text
Atom
Brackets
Bloco de Notas++
Instalar o Git
Se você pretende colaborar com outras pessoas ou hospedar seu projeto em um site de software livre (como o
GitHub), o VS Code é compatível com o controle de versão com o Git. A guia Controle do Código-fonte no VS
Code acompanha todas as alterações e tem comandos Git comuns (add, commit, push e pull) incorporados
diretamente na interface do usuário. Primeiro, você precisa instalar o Git para ativar o painel Controle do
Código-fonte.
1. Baixe e instale o Git para Windows no site do git-scm.
2. Um Assistente de Instalação está incluído e fará uma série de perguntas sobre as configurações da
instalação do Git. Recomendamos o uso de todas as configurações padrão, a menos que você tenha um
motivo específico para alterar algo.
3. Se você nunca trabalhou com o Git antes, os Guias do GitHub podem ajudar você a começar a usá-lo.
4. É recomendável adicionar um arquivo .gitignore aos seus projetos do Node. Este é o modelo de gitignore
padrão do GitHub para Node.js.
Usar o Subsistema do Windows para Linux para produção

O uso do Node.js diretamente no Windows é ótimo para aprender e experimentar o que você pode fazer.
Quando você estiver pronto para criar aplicativos Web prontos para produção, que normalmente são
implantados em um servidor baseado em Linux, recomendamos o uso do Subsistema do Windows para Linux
versão 2 (WSL 2) para o desenvolvimento de aplicativos Web Node.js. Muitos pacotes e estruturas do Node.js
são criados com um ambiente nix* em mente e a maioria dos aplicativos Node.js é implantada no Linux.
Portanto, o desenvolvimento em WSL garante a consistência entre seus ambientes de desenvolvimento e de
produção. Para configurar um ambiente de desenvolvimento WSL, confira Configurar o ambiente de
desenvolvimento do Node.js com o WSL 2.
NOTE
Se você está na situação (um pouco rara) de precisar hospedar um aplicativo Node.js em um servidor Windows, o cenário
mais comum parece ser usar um proxy reverso. Há duas maneiras de fazer isso: 1) usar iisnode ou diretamente. Não
mantemos esses recursos e recomendamos usar servidores Linux para hospedar seus aplicativos Node.js.
Tutorial: Node.js para iniciantes
Se você estiver começando a usar o Node.js, este guia ajudará você a se familiarizar com algumas noções
básicas.
Experimentar usar o Node.js no Visual Studio Code
Criar seu primeiro aplicativo Web Node.js usando o Express
Tente usar um módulo Node.js
Pré-requisitos
Instalação no Node.js no Windows ou no Subsistema do Windows para Linux
Se você é um iniciante que está experimentando o Node.js pela primeira vez, recomendamos instalá-lo
diretamente no Windows. Para obter mais informações, confira Devo instalar o Node.js no Windows ou no
Subsistema do Windows para Linux?
Experimentar o NodeJS com o Visual Studio Code

Se você ainda não instalou o Visual Studio Code, volte à seção de pré-requisitos acima e siga as etapas de
instalação vinculadas para o Windows ou o WSL.
1. Abra a linha de comando, crie um diretório mkdir HelloNode e insira o diretório: cd HelloNode
2. Crie um arquivo JavaScript chamado "app.js" e adicione uma variável chamada "msg" dentro:
echo var msg > app.js
3. Abra o diretório e o arquivo app.js no VS Code usando o comando: code .
4. Adicione uma variável de cadeia de caracteres simples ("Olá, Mundo") e envie o conteúdo da cadeia de
caracteres para o console digitando isto no arquivo "app.js":
var msg = 'Hello World';

console.log(msg);
5. Para executar o arquivo "app.js" com o Node.js, abra seu terminal no VS Code selecionando Exibir >
Terminal (ou use as teclas CTRL+`, clicando no caractere de acento grave). Se você precisar alterar o
terminal padrão, selecione o menu suspenso e escolha Selecionar Shell Padrão .
6. No terminal, digite: node app.js . Você deverá ver a saída: "Olá, Mundo".
NOTE
Quando você digita console no arquivo "app.js", o VS Code exibe opções com suporte relacionadas ao objeto console
para você escolher usando o IntelliSense. Tente experimentar o IntelliSense usando outros objetos JavaScript.
Criar seu primeiro aplicativo Web NodeJS usando o Express

O Express é uma estrutura mínima, flexível e simplificada do Node.js que facilita o desenvolvimento de um
aplicativo Web que pode lidar com vários tipos de solicitações, como GET, PUT, POST e DELETE. O Express vem
com um gerador de aplicativo que cria automaticamente uma arquitetura de arquivos para o seu aplicativo.
Para criar um projeto com o Express.js:
1. Abra a linha de comando (prompt de comando, PowerShell ou o que preferir).
2. Crie uma pasta de projeto, mkdir ExpressProjects , e insira este diretório: cd ExpressProjects
3. Use o Express para criar um modelo de projeto OláMundo: npx express-generator HelloWorld --view=pug
NOTE
Estamos usando o comando npx aqui para executar o pacote de nós do Express.js sem realmente instalá-lo (ou
instalando-o temporariamente, dependendo de como você quiser interpretar). Se você tentar usar o comando
express ou verificar a versão do Express instalado usando express --version , receberá uma resposta
informando que não foi possível encontrar o Express. Para instalar o Express globalmente e usá-lo várias vezes,
utilize: npm install -g express-generator . Você pode exibir uma lista dos pacotes que foram instalados pelo
npm usando npm list . Eles serão listados por profundidade (o número de diretórios aninhados). Os pacotes
que você instalou terão a profundidade 0. As dependências desse pacote terão a profundidade 1, outras
dependências terão a profundidade 2 e assim por diante. Para saber mais, confira Diferença entre o npx e o npm?
no StackOverflow.
4. Examine os arquivos e pastas incluídos pelo Express abrindo o projeto no VS Code, com: code .
Os arquivos gerados pelo Express criarão um aplicativo Web que usa uma arquitetura que, a princípio,
pode parecer um pouco complexa. Você verá na janela do Explorador do VS Code (CTRL+Shift+E para
exibir) que os seguintes arquivos e pastas foram gerados:
bin . Contém o arquivo executável que inicia o aplicativo. Dispara um servidor (na porta 3000, se
nenhuma alternativa for fornecida) e define o tratamento básico de erros.
public . Contém todos os arquivos acessados publicamente, incluindo arquivos JavaScript, folhas de
estilo CSS, arquivos de fonte, imagens e outros ativos que as pessoas precisam quando se conectam
ao seu site.
routes . Contém todos os manipuladores de rota para o aplicativo. Dois arquivos, index.js e
users.js , são gerados automaticamente nessa pasta para servir como exemplos de como separar a
configuração de rota do seu aplicativo.
views . Contém os arquivos usados pelo seu mecanismo de modelagem. O Express está configurado
para procurar aqui uma exibição correspondente quando o método de renderização for chamado. O
mecanismo de modelo padrão é o Jade, que foi preterido em favor do Pug, portanto, usamos o
sinalizador --view para alterar o mecanismo de exibição (modelo). Você pode ver as opções do
sinalizador --view , e de outros, usando express --help .
app.js . O ponto de partida do seu aplicativo. Ele carrega tudo e começa a atender às solicitações do
usuário. Basicamente é o que mantém todas as diferentes partes unidas.
package.json . Contém a descrição do projeto, o gerenciador de scripts e o manifesto do aplicativo.
Seu principal objetivo é rastrear as dependências do seu aplicativo e suas respectivas versões.
5. Agora, você precisa instalar as dependências que o Express usa para criar e executar seu aplicativo
OláMundo (os pacotes usados para tarefas como executar o servidor, conforme definido no arquivo
package.json ). Dentro do VS Code, abra seu terminal selecionando Exibir > Terminal (ou as teclas
CTRL+`, usando o caractere de acento grave), certifique-se de que você ainda esteja no diretório do
projeto "OláMundo". Instale as dependências do pacote do Express com:
npm install
6. Neste ponto, a estrutura está configurada para um aplicativo Web de várias páginas, com acesso a
diversas APIs e métodos de utilitário HTTP e middleware, facilitando a criação de uma API robusta. Inicie
o aplicativo Express em um servidor virtual digitando:
npx cross-env DEBUG=HelloWorld:* npm start
TIP
A parte do comando DEBUG=myapp:* acima indica que você está dizendo ao Node.ja que deseja ativar o registro
em log para fins de depuração. Lembre-se de substituir "myapp" pelo nome do aplicativo. Você pode encontrar o
nome do aplicativo no arquivo package.json , na propriedade "name". O uso de npx cross-env define a
variável de ambiente DEBUG em qualquer terminal, mas você também pode defini-la com o método específico de
seu terminal. O comando npm start está dizendo para o npm executar os scripts em seu arquivo de
package.json .
7. Agora você pode exibir o aplicativo em execução abrindo um navegador da Web e acessando:
localhost:3000
8. Agora que seu aplicativo Express OláMundo está sendo executado localmente em seu navegador, tente
fazer uma alteração abrindo a pasta "views" no diretório do projeto e selecionando o arquivo "index.pug".
Uma vez aberto, altere h1= title para h1= "Hello World!" e selecione Salvar (CTRL+S). Exiba sua
alteração atualizando a URL localhost:3000 no navegador da Web.
9. Para interromper a execução do aplicativo Express, digite no terminal: CTRL+C
Tente usar um módulo Node.js

O Node.js tem várias ferramentas para ajudar no desenvolvimento de aplicativos Web do lado do servidor,
algumas internas e muitas outras disponíveis via npm. Esses módulos podem ajudar em várias tarefas:
F ERRA M EN TA USA DA PA RA
gm, sharp Manipulação de imagem, incluindo edição,

redimensionamento, compactação e assim por diante,
diretamente no seu código JavaScript
PDFKit Geração de PDF

F ERRA M EN TA USA DA PA RA
validator.js Validação de cadeia de caracteres
imagemin, UglifyJS2 Minificação
spritesmith Geração de folha de Sprite
winston Registro em log
commander.js Criação de aplicativos de linha de comando
Vamos usar o módulo interno do sistema operacional para obter algumas informações sobre o SO do seu
computador:
1. Na linha de comando, abra a CLI do Node.js. Você verá o aviso > informando que você está usando o
Node.js depois de inserir: node
2. Para identificar o sistema operacional usado no momento (o que deve retornar uma resposta indicando
que você está no Windows), digite: os.platform()
3. Para verificar a arquitetura da CPU, digite: os.arch()
4. Para exibir as CPUs disponíveis no sistema, digite: os.cpus()
5. Saia da CLI do Node.js inserindo .exit ou selecionando as teclas CTRL+C duas vezes.
TIP
Você pode usar o módulo do sistema operacional Node.js para realizar ações como verificar a plataforma e
retornar uma variável específica da plataforma: Win32/.bat para desenvolvimento do Windows, Darwin/.sh para
Mac/unix, Linux, SunOS e assim por diante (por exemplo, var isWin = process.platform === "win32"; ).
Visão geral do React
O que é o React JS?

O React é uma biblioteca JavaScript de software livre usada para criar interfaces do usuário de front-end. Ao
contrário de outras bibliotecas JavaScript que fornecem uma estrutura de aplicativo completa, o React é voltado
exclusivamente para a criação de exibições de aplicativo por meio de unidades encapsuladas chamadas de
componentes que mantêm o estado e geram elementos de interface do usuário. Você pode colocar um
componente individual em uma página da Web ou aninhar hierarquias de componentes para criar uma
interface do usuário complexa.
Normalmente, os componentes do React são escritos em JavaScript e JSX (JavaScript XML), que é uma extensão
do JavaScript muito parecida com HTML, mas com alguns recursos de sintaxe que facilitam tarefas comuns
como o registro de manipuladores de eventos para elementos de interface do usuário. Um componente do
React implementa o método render , que retorna o JSX representando a interface do usuário do componente.
Em um aplicativo Web, o código JSX retornado pelo componente é convertido em HTML em conformidade com
o navegador no navegador.
O React funciona no Windows?

Sim. O Windows 10 dá suporte a dois ambientes diferentes para o desenvolvimento de aplicativos React:
Instalar um ambiente de desenvolvimento do React no Windows
Instalar um ambiente de desenvolvimento do React no Subsistema do Windows para Linux
Para obter ajuda sobre como determinar qual ambiente deve ser usado, confira Devo fazer a instalação no
Windows ou no Subsistema do Windows para Linux?
O que você pode fazer com o React?

O Windows 10 dá suporte a uma ampla gama de cenários para os desenvolvedores do React, incluindo:
Aplicativos Web básicos : se você é iniciante no React e tem interesse principalmente em aprender a
criar um aplicativo Web básico com ele, recomendamos que você instale o create-react-app diretamente
no Windows. Se você pretende criar um aplicativo Web que será implantado em produção, o ideal é
considerar a instalação do create-react-app no WSL (Subsistema do Windows para Linux), para aprimorar
a velocidade de desempenho, a compatibilidade de chamadas do sistema e o alinhamento entre o
ambiente de desenvolvimento local e o ambiente de implantação (que costuma ser um servidor Linux).
SPAs (aplicativos de página única) : são sites que interagem com o usuário pela reescrita dinâmica
da página da Web atual com novos dados de um servidor, em vez do padrão do navegador de carregar
páginas novas inteiras. Caso você deseje criar um site de SPA orientado ao conteúdo estático,
recomendamos instalar o Gatsby no WSL. Caso você deseje criar um site de SPA renderizado pelo
servidor com um back-end do Node.js, recomendamos instalar o Next.js no WSL. (Embora o Next.js agora
também ofereça serviços de arquivos estáticos).
Aplicativos da área de trabalho nativos : o React Native para Windows e macOS permite que você
crie aplicativos da área de trabalho nativos com JavaScript que são executados em vários tipos de
computadores desktop, laptops, tablets, Xbox e dispositivos de realidade misturada. Ele dá suporte ao
SDK do Windows e ao SDK do macOS.
Aplicativos móveis nativos : o React Native é uma forma multiplataforma de criar aplicativos Android
e iOS com JavaScript que são renderizados para o código da interface do usuário da plataforma nativa.
Há duas maneiras principais de instalar o React Native: a CLI do Expo e a CLI do React Native. Há uma boa
comparação dos dois no StackOverflow. O Expo tem um aplicativo cliente para dispositivos móveis iOS e
Android para executar e testar seus aplicativos. Para obter instruções sobre como desenvolver um
aplicativo Android usando o Windows, o React Native e a CLI do Expo, confira React Native para
desenvolvimento do Android no Windows.
Opções de instalação
Há várias maneiras diferentes de instalar o React junto com uma cadeia de ferramentas integrada que funcione
melhor para seu cenário de caso de uso. Veja algumas das mais populares.
Instalar o create-react-app diretamente no Windows
Instalar o create-react-app no WSL (Subsistema do Windows para Linux)
Instalar a estrutura Next.js no WSL
Instalar a estrutura Gatsby no WSL
Instalar o React Native para o desenvolvimento para desktop no Windows
Instalar o React Native para desenvolvimento do Android no Windows
Instalar o React Native para desenvolvimento móvel entre plataformas
Instalar o React no navegador sem nenhuma cadeia de ferramentas : como o React é uma biblioteca
JavaScript que, na forma mais básica, é apenas uma coleção de arquivos de texto, você pode criar aplicativos
React sem instalar nenhuma ferramenta ou biblioteca no computador. O ideal é só adicionar alguns "toques
de interatividade" a uma página da Web e não precisar de ferramentas de criação. Adicione um componente
do React simplesmente adicionando uma marca <script> simples a uma página HTML. Siga as etapas de
"Adicionar o React em um minuto" na documentação do React.
Ferramentas do React
Embora a escrita de um componente simples do React em um editor de texto sem formatação seja uma boa
introdução ao React, o código gerado dessa maneira é volumoso e lento, além de ser difícil de ser mantido e
implantado. Há algumas tarefas comuns que os aplicativos de produção precisarão executar. Essas tarefas são
processadas por outras estruturas JavaScript que são consideradas pelo aplicativo como uma dependência.
Essas tarefas incluem:
Compilação : o JSX é a linguagem que costuma ser usada para os aplicativos React, mas os navegadores não
podem processar essa sintaxe diretamente. Em vez disso, o código precisa ser compilado na sintaxe
JavaScript padrão e personalizado para diferentes navegadores. O Babel é um exemplo de compilador que
dá suporte ao JSX.
Agrupamento : como o desempenho é fundamental para os aplicativos Web modernos, é importante que o
JavaScript de um aplicativo inclua apenas o código necessário para o aplicativo e seja combinado no mínimo
de arquivos possível. Um empacotador, como o webpack, executa essa tarefa para você.
Gerenciamento de pacotes : os gerenciadores de pacotes facilitam a inclusão da funcionalidade de pacotes
de terceiros no seu aplicativo, incluindo a atualização deles e o gerenciamento de dependências. Os
gerenciadores de pacotes normalmente usados incluem o Yarn e o npm.
Em conjunto, o pacote de estruturas que ajuda você a criar, compilar e implantar seu aplicativo é chamado de
cadeia de ferramentas. Uma cadeia de ferramentas que é fácil de começar a usar é o create-react-app, que gera
um aplicativo simples de uma página para você. A única configuração necessária para usar o create-react-app
é o Node.js.
Para o desenvolvimento no Windows, siga as instruções para instalar o Node.js no WSL ou para instalar o
Node.js no Windows. Para obter ajuda sobre como decidir qual deles usar, confira o artigo: Devo fazer a
instalação no Windows ou no Subsistema do Windows para Linux?.
Diretório de componentes do React Native
Os componentes que podem ser usados em um aplicativo React Native incluem os seguintes:
Componentes principais: componentes cujo desenvolvimento e suporte fazem parte da estrutura React
Native.
Componentes da comunidade: componentes desenvolvidos e mantidos pela comunidade.
Componentes nativos: componentes que você pode criar por conta própria, usando o código nativo da
plataforma e registrá-los para serem acessíveis no React Native.
O diretório do React Native fornece uma lista de bibliotecas de componentes que podem ser filtradas pela
plataforma de destino.
Opções da cadeia de ferramentas de pilha completa do React

O React é uma biblioteca, não uma estrutura. Portanto, pode exigir ferramentas adicionais para a criação de um
aplicativo mais complexo. Além de usar o React, o ideal é considerar o uso dos seguintes:
Gerenciador de pacotes: dois gerenciadores de pacotes populares para o React são o npm (que está incluído
no NodeJS) e o Yarn. Os dois dão suporte a uma ampla biblioteca de pacotes bem mantidos que podem ser
instalados.
React Router: uma coleção de componentes de navegação que pode ajudar você com itens como URLs que
podem ser adicionadas a Favoritos para seu aplicativo Web ou uma forma combinável de navegar no React
Native. O React está realmente voltado apenas ao gerenciamento de estado e em renderizar esse estado para
o DOM, de modo que a criação de aplicativos React geralmente exige o uso de uma biblioteca de roteamento
como o React Router.
Redux: um contêiner de estado previsível que ajuda com a arquitetura de fluxo de dados. Provavelmente, ele
não é algo de que você precise até chegar a um desenvolvimento mais avançado do React. Citando Dan
Abramov, um dos criadores do Redux: "Não use o Redux até ter problemas com o React básico".
Webpack: uma ferramenta de build que permite compilar módulos JavaScript, também conhecida como
empacotador de módulo. Quando o webpack processa seu aplicativo, ele cria internamente um grafo de
dependência que mapeia cada módulo de que o seu projeto precisa e gera um ou mais pacotes.
Uglify: um kit de ferramentas de análise, minificação, compressão e embelezamento de JavaScript.
Babel: um compilador de JavaScript usado principalmente para converter o código ECMAScript 2015 e
posterior em uma versão compatível com versões anteriores de JavaScript em navegadores ou ambientes
atuais e antigos. Também pode ser útil usar o babel-preset-env para que você não precise microgerenciar
transformações de sintaxe ou polyfills de navegador e possa definir quais navegadores da Internet terão
suporte.
ESLint: uma ferramenta usada para identificar e relatar os padrões encontrados no código JavaScript que
ajuda você a tornar seu código mais consistente e evitar bugs.
Enzyme: um utilitário de teste de JavaScript para o React que facilita o teste da saída dos componentes do
React.
Jest: uma estrutura de teste incorporada ao pacote create-react-app para ajudar na escrita de testes de
JavaScript idiomáticos.
Mocha: uma estrutura de teste executada em Node.js e no navegador para ajudar no teste assíncrono, no
relatório e no mapeamento de exceções não capturadas dos casos de teste corretos.
Cursos e tutoriais do React

Estes são alguns lugares recomendados para aprender a usar o React e criar aplicativos de exemplo:
Microsoft Learn: o roteiro de aprendizagem do React contém módulos de curso online para ajudar você a se
familiarizar com os conceitos básicos.
Criar um SPA (aplicativo de página única) que é executado no navegador (como neste aplicativo Web de
exemplo que recupera informações de calendário para um usuário com a API do Microsoft Graph)
Criar um aplicativo renderizado pelo servidor com o Next.js ou um aplicativo gerado por site estático com o
Gatsby
Criar uma interface do usuário para um aplicativo nativo executado em dispositivos Windows, Android e iOS
(confira estes exemplos de aplicativos nativos do Windows ou este exemplo de aplicativo nativo que
recupera informações de calendário para um usuário com a API do Microsoft Graph)
Desenvolver um aplicativo para o dispositivo de tela dupla do Surface Duo
Criar um aplicativo Web ou um aplicativo nativo usando componentes do React do Fluent UI
Criar um aplicativo React com TypeScript
Recursos adicionais
A documentação oficial do React oferece todas as informações mais recentes e atualizadas sobre o React
Complementos do Microsoft Edge para as Ferramentas para Desenvolvedores do React: adicione duas guias
às suas ferramentas de desenvolvimento do Microsoft Edge para ajudar com o desenvolvimento do React:
Componentes e Profiler.
Instalar o React no Subsistema do Windows para
Linux
Este guia descreverá como instalar o React em uma distribuição do Linux (por exemplo, Ubuntu) em execução
no WSL (Subsistema do Windows para Linux) usando a cadeia de ferramentas create-react-app.
Recomendamos seguir estas instruções se você está criando um SPA (aplicativo de página única) com o qual
deseja usar comandos ou ferramentas do Bash e/ou que pretende implantar em um servidor Linux ou no qual
pretende usar contêineres do Docker. Se você é iniciante no React e tem interesse em aprender mais sobre ele, o
ideal é considerar a instalação com o create-react-app diretamente no Windows.
Para obter mais informações gerais sobre o React, decidir entre o React (aplicativos Web), o React Native
(aplicativos móveis) e o React Native para Windows (aplicativos da área de trabalho), confira a visão geral do
React.
Pré-requisitos
Instalar a última versão do Windows 10 (versão 1903 e posterior, build 18362 e posterior)
Instalar o WSL (Subsistema do Windows para Linux), incluindo uma distribuição do Linux (como o Ubuntu), e
verificar se ele está sendo executado no modo WSL 2. Para verificar isso, abra o PowerShell e digite:
wsl -l -v
Instalar o Node.js no WSL 2: essas instruções usam o nvm (Gerenciador de Versão do Node) para instalação.
Você precisará ter uma versão recente do NodeJS para executar o create-react-app, bem como uma versão
recente do npm (Gerenciador de Pacotes do Node). Para obter os requisitos exatos de versão, confira o site
do Create React App.
IMPORTANT
A instalação de uma distribuição do Linux com o WSL criará um diretório para armazenar os arquivos:
\\wsl\Ubuntu-20.04 (substitua o Ubuntu-20.04 por qualquer distribuição do Linux que esteja usando). Para abrir esse
diretório no Explorador de Arquivos do Windows, abra a linha de comando do WSL, selecione o diretório base usando
cd ~ e insira o comando explorer.exe . . Tome cuidado para não instalar o NodeJS nem armazenar arquivos com os
quais você trabalhará na unidade C montada ( /mnt/c/Users/yourname$ ). Essa ação deixará a instalação e os tempos de
build significativamente lentos.
Instalar o React
Para instalar a cadeia de ferramentas completa do React no WSL, recomendamos usar o create-react-app:
1. Abra uma linha de comando do WSL (ou seja, o Ubuntu).
2. Crie uma pasta de projeto, mkdir ReactProjects , e insira este diretório: cd ReactProjects .
3. Instale o React usando o npx:
npx create-react-app my-app

NOTE
npx é o executor de pacote usado pelo npm para executar pacotes no lugar de uma instalação global.
Basicamente, ele cria uma instalação temporária do React de modo que, a cada novo projeto, você esteja usando a
versão mais recente do React (não qualquer versão atual no momento da execução da instalação global acima). O
uso do executor de pacote NPX para executar um pacote também pode ajudar a reduzir a poluição da instalação
de vários pacotes no computador.
4. Primeiro, ele solicitará sua permissão para instalar temporariamente o create-react-app e os pacotes
associados. Após a conclusão, altere os diretórios para o seu novo aplicativo ("my-app" ou o que você
escolheu como nome): cd my-app .
5. Inicie seu novo aplicativo React:
npm start
Esse comando iniciará o servidor do Node.js e iniciará uma nova janela do navegador exibindo seu
aplicativo. Use CTRL + C para interromper a execução do aplicativo React na linha de comando.
NOTE
O Create React App inclui um pipeline de build de front-end usando o Babel e o webpack, mas não trata da lógica
nem dos bancos de dados de back-end. Se você procura criar um site renderizado pelo servidor com o React que
use um back-end do Node.js, recomendamos instalar o Next.js em vez do create-react-app, que é mais voltado a
aplicativos de página única. O ideal também será considerar a instalação do Gatsby se você quiser criar um site
estático orientado ao conteúdo.
6. Quando você estiver pronto para implantar seu aplicativo Web em produção, a execução de
npm run build criará um build do aplicativo na pasta "build". Saiba mais no Guia do usuário do Create
React App.
Adicionar o React a um aplicativo Web existente

Como o React é uma biblioteca JavaScript que, na forma mais básica, é apenas uma coleção de arquivos de
texto, você pode criar aplicativos React sem instalar nenhuma ferramenta ou biblioteca no computador. O ideal é
só adicionar alguns "toques de interatividade" a uma página da Web e não precisar de ferramentas de criação.
Adicione um componente do React simplesmente adicionando uma marca <script> simples a uma página
HTML. Siga as etapas de "Adicionar o React em um minuto" na documentação do React.
Recursos adicionais
Documentação do React
Documentação do Create React App
Instalar o Next.js
Instalar o Gatsby
Experimente o tutorial: Como usar o React no Visual Studio Code
Experimente o curso online do Microsoft Learn: React
Instalar o React diretamente no Windows
Este guia descreverá a instalação do React diretamente no Windows usando a cadeia de ferramentas create-
react-app.
Recomendamos seguir estas instruções se você é iniciante no React e está apenas interessado em aprender a
usá-lo. Se você está criando um SPA (aplicativo de página única) com o qual deseja usar comandos ou
ferramentas do Bash e/ou que pretende implantar em um servidor Linux, recomendamos que você o instale
com o create-react-app no WSL (Subsistema do Windows para Linux).
Para obter mais informações gerais sobre o React, decidir entre o React (aplicativos Web), o React Native
(aplicativos móveis) e o React Native para Windows (aplicativos da área de trabalho), confira a visão geral do
React.
Pré-requisitos
wsl -l -v
Instalar o Node.js no WSL 2: essas instruções usam o nvm (Gerenciador de Versão do Node) para instalação.
Você precisará ter uma versão recente do NodeJS para executar o create-react-app, bem como uma versão
recente do npm (Gerenciador de Pacotes do Node). Para obter os requisitos exatos de versão, confira o site
do Create React App.
Criar seu aplicativo React

Para instalar a cadeia de ferramentas completa do React no WSL, recomendamos usar o create-react-app:
1. Abra um terminal (prompt de comando do Windows ou PowerShell).
2. Crie uma pasta de projeto, mkdir ReactProjects , e insira este diretório: cd ReactProjects .
3. Instale o React usando o create-react-app, uma ferramenta que instala todas as dependências para criar e
executar um aplicativo React.js completo:
npx create-react-app my-app
NOTE
npx é o executor de pacote usado pelo npm para executar pacotes no lugar de uma instalação global.
Basicamente, ele cria uma instalação temporária do React de modo que, a cada novo projeto, você esteja usando a
versão mais recente do React (não qualquer versão atual no momento da execução da instalação global acima). O
uso do executor de pacote NPX para executar um pacote também pode ajudar a reduzir a poluição da instalação
de vários pacotes no computador.
4. Primeiro, ele solicitará sua permissão para instalar temporariamente o create-react-app e os pacotes
associados. Após a conclusão, altere os diretórios para o seu novo aplicativo ("my-app" ou o que você
escolheu como nome): cd my-app .
5. Inicie seu novo aplicativo React:
npm start
Esse comando iniciará o servidor do Node.js e iniciará uma nova janela do navegador exibindo seu
aplicativo. Use CTRL + C para interromper a execução do aplicativo React na linha de comando.
NOTE
O Create React App inclui um pipeline de build de front-end usando o Babel e o webpack, mas não trata da lógica
nem dos bancos de dados de back-end. Se você procura criar um site renderizado pelo servidor com o React que
use um back-end do Node.js, recomendamos instalar o Next.js em vez do create-react-app, que é mais voltado a
aplicativos de página única. O ideal também será considerar a instalação do Gatsby se você quiser criar um site
estático orientado ao conteúdo.
6. Quando você estiver pronto para implantar seu aplicativo Web em produção, a execução de
npm run build criará um build do aplicativo na pasta "build". Saiba mais no Guia do usuário do Create
React App.
Recursos adicionais
Documentação do Create React App
Instalar o Next.js
Instalar o Gatsby
Experimente o tutorial: Como usar o React no Visual Studio Code
Introdução à criação de um aplicativo da área de
trabalho com o React Native para Windows
O React Native para Windows permite que você crie um aplicativo UWP (Plataforma Universal do Windows)
usando o React.
Visão geral do React Native

O React Native é uma estrutura de aplicativo móvel de software livre criada pelo Facebook. Ele é usado para
desenvolver aplicativos para Android, iOS, Web e UWP (Windows) fornecendo controles de interface do usuário
nativos e acesso completo à plataforma nativa. O uso do React Native exige uma compreensão dos conceitos
básicos do JavaScript.
Para obter mais informações gerais sobre o React, confira a página de visão geral do React.
Pré-requisitos
Os requisitos de instalação para uso do React Native para Windows podem ser encontrados na página
Requisitos do sistema. Verifique se o Modo de Desenvolvedor está ATIVADO no Aplicativo de Configurações do
Windows.

Você pode criar um aplicativo da área de trabalho do Windows usando o React Native para Windows seguindo
estas etapas.
1. Abra uma janela de linha de comando (terminal) e procure o diretório em que deseja criar seu projeto de
aplicativo da área de trabalho do Windows.
2. Use esse comando com o NPX (Executor de Pacotes do Node) para criar um projeto do React Native sem
a necessidade de instalação local ou a instalação global de ferramentas adicionais. O comando vai gerar
um aplicativo React Native no diretório especificado por <projectName> .
npx react-native init <projectName> --template react-native@^0.63.2
3. Alterne para o diretório do projeto e execute o seguinte comando para instalar os pacotes do React
Native para Windows:
cd projectName
npx react-native-windows-init --overwrite
4. Para executar o aplicativo, primeiro inicie o navegador da Web (ou seja, o Microsoft Edge) e execute o
seguinte comando:
npx react-native run-windows
Depurar o aplicativo da área de trabalho React Native usando o Visual

Studio
Instale o Visual Studio 2019 com as seguintes cargas de trabalho:
Cargas de trabalho: desenvolvimento para Plataforma Universal do Windows e Desenvolvimento para
área de trabalho com C++.
Componentes individuais: atividades de desenvolvimento e suporte ao desenvolvimento do Node.js.
Abra o arquivo de solução na pasta do aplicativo no Visual Studio (por exemplo,
AwesomeProject/Windows/AwesomeProject.sln se você usou AwesomeProject como ).
Selecione a configuração de Depuração e a plataforma x64 nos controles de caixa de combinação à
esquerda do botão Executar e abaixo do item de menu Equipe e Ferramentas.
Execute yarn start no diretório do projeto e aguarde o empacotador do React Native relatar o êxito.
Selecione Executar à direita do controle de caixa de combinação da plataforma no VS ou o item de menu
Depurar -> Iniciar sem Depuração. Agora você verá seu novo aplicativo, e o Chrome terá carregado
http://localhost:8081/debugger-ui/ em uma nova guia.
Selecione a tecla F12 ou CTRL + SHIFT + I para abrir as Ferramentas para Desenvolvedores no navegador
da Web.
Depurar o aplicativo da área de trabalho React Native usando o Visual

Studio Code
Abra a pasta de aplicativos no VS Code.
Instale o plug-in de Ferramentas React Native para VS Code.
Crie um arquivo no diretório raiz de aplicativos, .vscode/launch.json, e cole a seguinte configuração:
{
"version": "0.2.0",
"configurations": [
{
"name": "Debug Windows",
"cwd": "${workspaceFolder}",
"type": "reactnative",
"request": "launch",
"platform": "windows"
}
]
}
Pressione F5 ou procure o menu Depurar (se preferir, pressione CTRL + SHIFT + D) e, na lista suspensa
Depurar, selecione "Depurar o Windows" e pressione a seta verde para executar o aplicativo.
Recursos adicionais
Documentação do React Native para Windows
Documentação do React Native
Introdução ao desenvolvimento para Android
usando o React Native
Este guia ajudará você a começar a usar o React Native no Windows para criar um aplicativo multiplataforma
que funcionará em dispositivos Android.
Visão geral
Comece a usar o React Native instalando as ferramentas necessárias

1. Instale o Visual Studio Code (ou o editor de códigos de sua preferência).
2. Instalar o Android Studio para Windows. Por padrão, o Android Studio instala o último SDK do Android. O
React Native exige o SDK do Android 6.0 (Marshmallow) ou superior. Recomendamos usar o último SDK.
3. Crie caminhos de variável de ambiente para o SDK do Java e o SDK do Android:
No menu de pesquisa do Windows, insira: "Editar as variáveis de ambiente do sistema". Isso abrirá a
janela Propriedades do Sistema .
Escolha Variáveis de Ambiente… e Novo… em Variáveis de usuário .
Insira o nome da variável e o valor (caminho). Os caminhos padrão para os SDKs do Java e do
Android são mostrados a seguir. Se você tiver escolhido uma localização específica para instalar os
SDKs do Java e do Android, atualize os caminhos de variável de acordo.
JAVA_HOME: C:\Arquivos de Programas\Android\Android Studio\jre\jre
ANDROID_HOME: C:\Users\username\AppData\Local\Android\Sdk
4. Instalar o NodeJS para Windows O ideal é considerar o uso do nvm (Gerenciador de Versão do Node)
para Windows se você está trabalhando com vários projetos e a versão do NodeJS. Recomendamos
instalar a última versão do LTS para novos projetos.
NOTE
O ideal também é instalar e usar o Terminal do Windows para trabalhar com sua CLI (interface de linha de comando)
preferida, bem como o Git para o controle de versão. O JDK do Java vem empacotado com o Android Studio v2.2 e
posterior, mas se você precisar atualizar o JDK separadamente do Android Studio, use o Windows x64 Installer.
Criar um projeto com o React Native

1. Use o npx, a ferramenta de executor de pacote que é instalada com o npm , para criar um projeto do
React Native. no prompt de comando do Windows, no PowerShell, no Terminal do Windows ou no
terminal integrado do VS Code (Exibir > Terminal Integrado).
npx react-native init MyReactNativeApp
2. Abra o novo diretório "MyReactNativeApp":
cd MyReactNativeApp
3. Se você quiser executar o projeto em um dispositivo Android de hardware, conecte o dispositivo ao

computador com um cabo USB.
4. Se quiser executar seu projeto em um Android Emulator, você não precisará realizar nenhuma ação, pois
o Android Studio é instalado com um emulador padrão. Caso deseje executar seu aplicativo no emulador
para um dispositivo específico. Clique no botão Gerenciador de AVD na barra de ferramentas.
.
5. Para executar o projeto, insira o comando a seguir. Isso abrirá uma nova janela de console exibindo o
Node Metro Bundler.
npx react-native run-android

NOTE
Se você estiver usando uma nova instalação do Android Studio e ainda não tiver feito nenhum outro
desenvolvimento no Android, poderá receber erros na linha de comando ao executar o aplicativo sobre como
aceitar licenças para o SDK do Android. Como "Aviso: licença para o pacote do SDK do Android Plataforma 29 não
aceita". Para resolver isso, clique no botão Gerenciador de SDK no Android Studio. . Ou, então, você
pode listar e aceitar as licenças com o comando a seguir, lembrando-se de usar o caminho para a localização do
SDK no computador.
C:\Users\[User Name]\AppData\Local\Android\Sdk\tools\bin\sdkmanager --licenses
6. Para modificar o aplicativo, abra o diretório do projeto MyReactNativeApp no IDE de sua preferência.
Recomendamos usar o VS Code ou o Android Studio.
7. O modelo de projeto criado pelo react-native init usa uma página principal chamada App.js . Essa
página é pré-preenchida com muitos links úteis para informações sobre o desenvolvimento do React
Native. Adicione um texto ao primeiro elemento de Texto , como a cadeia de caracteres "OLÁ, MUNDO!"
mostrada abaixo.
<Text style={styles.sectionDescription}>
Edit <Text style={styles.highlight}>App.js</Text> to change this
screen and then come back to see your edits. HELLO WORLD!
</Text>
8. Recarregue o aplicativo para mostrar as alterações feitas. Há várias maneiras de fazer isso.
Na janela do console do Metro Bundler, digite "r".
No emulador de dispositivo do Android, toque duas vezes em "r" no teclado.
Em um dispositivo Android de hardware, agite o dispositivo para abrir o menu de depuração do React
Native e selecione 'Recarregar'.
Recursos adicionais
Desenvolver aplicativos de tela dupla para Android e obter o SDK de dispositivo do Surface Duo
Adicionar exclusões do Windows Defender para aprimorar o desempenho
Habilitar o suporte de virtualização para aprimorar o desempenho do Emulador
Introdução ao Next.js no Windows
Um guia para ajudar você a instalar a estrutura da Web Next.js e colocá-la em funcionamento no Windows 10.
Next.js é uma estrutura para criar aplicativos JavaScript renderizados pelo servidor com base em React.js,
Node.js, Webpack e Babel.js. Ele é basicamente um projeto genérico para o React, criado de acordo com as
práticas recomendadas, que permite criar aplicativos Web "universais" de forma simples e consistente,
praticamente com qualquer configuração. Esses aplicativos Web "universais" renderizados pelo servidor
também são chamados de "isomórficos", o que significa que o código é compartilhado entre o cliente e o
servidor.
Para saber mais sobre o React e outras estruturas JavaScript baseadas no React, confira a página de visão geral
do React.
Pré-requisitos
Este guia pressupõe que você já tenha concluído as etapas para configurar o ambiente de desenvolvimento do
Node.js, incluindo:
wsl -l -v
Instalar o Node.js no WSL 2: isso inclui um gerenciador de versões, um gerenciador de pacotes, o Visual
Studio Code e a extensão de desenvolvimento remoto.
Recomendamos usar o Subsistema do Windows para Linux ao trabalhar com aplicativos NodeJS a fim de
aprimorar a velocidade de desempenho, a compatibilidade de chamadas do sistema e obter paridade ao
executar servidores Linux ou contêineres do Docker.
IMPORTANT
Instalar o Next.js
Para instalar o Next.js, que inclui a instalação de next, react e react-dom:
2. Crie uma pasta de projeto, mkdir NextProjects , e insira este diretório: cd NextProjects .
3. Instale o Next.js e crie um projeto (substituindo "My-next-app" pelo nome que você gostaria para seu
aplicativo): npx create-next-app my-next-app .
4. Depois de instalar o pacote, altere os diretórios para sua nova pasta de aplicativo, cd my-next-app , e use
code . para abrir o projeto Next.js no VS Code. Assim, você pode examinar a estrutura do Next.js criada
para seu aplicativo. Observe que o VS Code abriu seu aplicativo em um ambiente WSL remoto (como
indicado na guia verde na parte inferior esquerda da janela do VS Code). Isso significa que, enquanto
você estiver usando o VS Code para editar no sistema operacional Windows, ele ainda estará executando
seu aplicativo no sistema operacional Linux.
5. Há três comandos que você precisará saber quando o Next.js estiver instalado:
npm run dev para executar uma instância de desenvolvimento com recarga dinâmica, observação de
arquivo e nova execução de tarefa.
npm run build para compilar seu projeto.
npm start para iniciar seu aplicativo no modo de produção.
Abra o terminal WSL integrado no VS Code (Exibir > Terminal ). Verifique se o caminho do terminal está
indicando o diretório do projeto (por exemplo, ~/NextProjects/my-next-app$ ). Em seguida, tente executar
uma instância de desenvolvimento do novo aplicativo Next.js usando: npm run dev
6. O servidor de desenvolvimento local será iniciado e, depois que a criação das páginas do projeto for
concluída, o terminal exibirá "compilado com êxito – pronto em http://localhost:3000". Selecione esse link
do localhost para abrir o novo aplicativo Next.js em um navegador da Web.
7. Abra o arquivo pages/index.js no editor do VS Code. Localize o título da página

<h1 className='title'>Welcome to Next.js!</h1> e altere-o para
<h1 className='title'>This is my new Next.js app!</h1> . Com o navegador da Web ainda aberto em
localhost:3000, salve sua alteração e observe que o recurso de recarga dinâmica compila e atualiza
automaticamente a alteração no navegador.
8. Vejamos como o Next.js lida com erros. Remova a marca de fechamento </h1> para que o código de
título agora tenha esta aparência: <h1 className='title'>This is my new Next.js app! . Salve essa
alteração e observe que será exibido o erro "Falha ao compilar" no navegador e no seu terminal,
informando que se espera uma marca de fechamento para <h1> . Substitua a marca de fechamento
</h1> , salve, e a página será recarregada.
Você pode usar o depurador do VS Code com o aplicativo Next.js clicando na tecla F5 ou acessando Exibir >
Depurar (Ctrl+Shift+D) e Exibir > Console de Depuração (Ctrl+Shift+Y) na barra de menus. Se você
selecionar o ícone de engrenagem na janela de Depuração, um arquivo de configuração de inicialização (
launch.json ) será criado para que você salve os detalhes da configuração de depuração. Confira mais
informações em Depuração do VS Code.
Para saber mais sobre o Next.js, confira os Documentos do Next.js.

Introdução ao Gatsby.js no Windows
Um guia para ajudar você a instalar a estrutura da Web Gatsby.js e colocá-la em funcionamento no Windows 10.
O Gatsby.js é uma estrutura de geração de site estático baseada no React.js, e não renderizada pelo servidor
como o Next.js. Um gerador de site estático gera HTML estático no tempo de compilação. Ele não requer um
servidor. O Next.js gera um HTML em runtime (sempre que uma nova solicitação chega), exigindo a execução de
um servidor. O Gatsby também determina como os dados serão tratados no seu aplicativo (com o GraphQL),
enquanto o Next.js deixa essa decisão para você.
Para saber mais sobre o React e outras estruturas JavaScript baseadas no React, confira a página de visão geral
do React.
Pré-requisitos
Node.js, incluindo:
wsl -l -v
IMPORTANT
Instalar o Gatsby.js
Para criar um projeto Gatsby.js:
1. Abra o terminal do WSL (ou seja, Ubuntu 18.04).
2. Crie uma pasta de projeto, mkdir GatsbyProjects , e insira este diretório: cd GatsbyProjects
3. Use npm para instalar a CLI do Gatsby: npm install -g gatsby-cli . Depois de instalado, verifique a
versão com gatsby --version .
4. Crie seu projeto Gatsby.js: gatsby new my-gatsby-app
5. Depois de instalar o pacote, altere os diretórios para a nova pasta de aplicativo, cd my-gatsby-app , e use
code . para abrir o projeto Gatsby.js no VS Code. Assim, você pode examinar a estrutura do Gatsby.js
criada para seu aplicativo usando o Explorador de Arquivos do VS Code. Observe que o VS Code abriu
seu aplicativo em um ambiente WSL remoto (como indicado na guia verde na parte inferior esquerda da
janela do VS Code). Isso significa que, enquanto você estiver usando o VS Code para editar no sistema
operacional Windows, ele ainda estará executando seu aplicativo no sistema operacional Linux.
6. Há três comandos que você precisará saber quando o Gatsby estiver instalado:
gatsby develop para executar uma instância de desenvolvimento com recarga dinâmica.
gatsby build para criar um build de produção.
gatsby serve para iniciar seu aplicativo no modo de produção.
indicando o diretório do projeto (por exemplo, ~/GatsbyProjects/my-gatsby-app$ ). Em seguida, tente
executar uma instância de desenvolvimento do novo aplicativo usando: gatsby develop
7. Depois que o novo projeto Gatsby concluir a compilação, o terminal exibirá que "Agora você pode exibir
gatsby-starter-default no navegador. http://localhost:8000/." Selecione esse link do localhost para abrir o
novo projeto criado em um navegador da Web.
NOTE
Você observará que a saída do terminal também informará que você pode "Exibir GraphiQL, um IDE no navegador, para
explorar os dados e o esquema do seu site: http://localhost:8000/___graphql". O GraphQL consolida as APIs em um IDE
de autodocumentação (GraphiQL) integrado ao Gatsby. Além de explorar os dados e o esquema de seu site, você pode
executar operações GraphQL, como consultas, mutações e assinaturas. Confira mais informações em Introdução ao
GraphiQL.
8. Abra o arquivo src/pages/index.js no editor do VS Code. Localize o título da página

<h1 >Hi people</h1> e altere-o para <h1 >Hi (Your Name)!</h1> . Com o navegador da Web ainda aberto
em localhost:8000, salve sua alteração e observe que o recurso de recarga dinâmica compila e atualiza
automaticamente sua alteração no navegador.
9. Vejamos como o Next.js lida com erros. Remova a marca de fechamento </h1> para que o código de
título agora tenha esta aparência: <h1>Hi (Your Name)! . Salve essa alteração e observe que será exibido o
erro "Falha ao compilar" no navegador e no seu terminal, informando que se espera uma marca de
fechamento para <h1> . Substitua a marca de fechamento </h1> , salve, e a página será recarregada.
Você pode usar o depurador do VS Code com o aplicativo Next.js clicando na tecla F5 ou acessando Exibir >
Confira mais informações sobre o Gatsby em Documentos do Gatsby.js.

Tutorial: React no Windows para iniciantes
Se você estiver começando a usar o React agora, este guia ajudará você a se familiarizar com alguns conceitos
básicos.
Alguns termos e conceitos básicos
Experimente usar o React no Visual Studio Code
Experimente usar o React com uma API
Pré-requisitos
Instalar o React (Devo fazer a instalação no Windows ou no Subsistema do Windows para Linux)
Instalar o React no Windows
Instalar o React no Subsistema do Windows para Linux
Instale o VS Code. Recomendamos instalar o VS Code no Windows, independentemente de você pretender
usar o React no Windows ou no WSL.
Alguns termos e conceitos básicos

O React é uma biblioteca JavaScript projetada para a criação de interfaces do usuário.
Ele é software livre, o que significa que você pode contribuir com ele enviando problemas ou solicitações
de pull. (Assim como nesta documentação.)
Isso é declarativo, o que significa que você escreve o código desejado e o React usa o código declarado e
executa todas as etapas do JavaScript/do DOM para obter o resultado desejado.
Ele é baseado em componentes, o que significa que os aplicativos são criados usando módulos de código
independentes reutilizáveis e pré-fabricados que gerenciam o próprio estado e podem ser combinados
por meio da estrutura React, possibilitando a transmissão de dados por meio do aplicativo, mantendo o
estado fora do DOM.
O lema do React é "aprenda uma vez, escreva em qualquer lugar". A intenção é a reutilização de código e
não fazer suposições sobre como você usará a interface do usuário do React com outras tecnologias, mas
para tornar os componentes reutilizáveis sem a necessidade de reescrever o código existente.
O JSX é uma extensão de sintaxe para JavaScript escrita para ser usada com o React parecida com HTML,
mas que, na verdade, é um arquivo JavaScript que precisa ser compilado ou convertido em JavaScript
normal.
DOM virtual: DOM significa Modelo de Objeto do Documento e representa a interface do usuário do seu
aplicativo. Sempre que o estado da interface do usuário do aplicativo é alterado, o DOM é atualizado para
representar a alteração. Quando um DOM é atualizado com frequência, o desempenho fica lento. Um
DOM virtual é apenas uma representação visual do DOM. Portanto, quando o estado do aplicativo é
alterado, o DOM virtual é atualizado em vez do DOM real, reduzindo o custo de desempenho. É uma
representação de um objeto DOM, como uma cópia leve.
Exibições: são o que o usuário vê renderizado no navegador. No React, a exibição está relacionada ao
conceito de renderizar elementos que você deseja que um usuário veja na tela.
Estado: refere-se aos dados armazenados por diferentes exibições. Normalmente, o estado dependerá de
quem é o usuário e do que ele está fazendo. Por exemplo, entrar em um site pode mostrar seu perfil do
usuário (exibição) com o seu nome (estado). Os dados de estado serão alterados com base no usuário,
mas a exibição permanecerá a mesma.
Experimente usar o React no Visual Studio Code

Há muitas maneiras de criar um aplicativo com o React (confira a Visão geral do React para obter exemplos).
Este tutorial descreverá como usar o create-react-app para agilizar a configuração de um aplicativo React
funcional, de modo que você possa vê-lo em execução e se concentrar na experimentação com o código, não se
preocupando ainda com as ferramentas de build.
1. Use o create-react-app no Windows ou no WSL (confira os pré-requisitos acima) para criar um projeto:
npx create-react-app hello-world
2. Altere os diretórios para que você esteja dentro da pasta do novo aplicativo cd hello-world e inicie o
aplicativo: npm start
Seu novo aplicativo React Olá, Mundo será compilado e abrirá o navegador da Web padrão para mostrar
que está em execução no localhost:3000.
3. Pare de executar seu aplicativo React (CTRL + C) e abra os arquivos de código no VS Code inserindo:
code .
4. Localize o arquivo src/App.js e encontre a seção de cabeçalho que indica:
<p>Edit <code>src/App.js</code> and save to reload.</p>
Altere-a para que ela indique:
<p>Hello World! This is my first React app.</p>
Experimente usar o React com uma API

Usando o mesmo aplicativo Olá, Mundo! que você criou com o React e atualizou com o Visual Studio Code,
vamos tentar adicionar uma chamada à API para exibir alguns dados.
1. Primeiro, vamos remover tudo desse arquivo app.js e transformá-lo em um componente de classe.
Primeiro, importaremos o componente do React e o usaremos para criar o componente de classe. (Há
dois tipos de componentes: classe e função). Também adicionaremos um código JSX personalizado em
uma instrução return() . Recarregue a página para ver o resultado.
Agora, o arquivo app.js ficará assim:
import React, { Component } from 'react';
class App extends Component {

render() {
return (
<p>Hello world! This is my first React app.</p>
);
}
}
export default App;
2. Em seguida, vamos definir um estado local em que podemos salvar os dados de uma API. Um objeto de
estado é o local em que podemos armazenar os dados a serem usados na exibição. A exibição é
renderizada para a página dentro de render() .
Para adicionar um estado local, primeiro, precisaremos adicionar um construtor. Ao implementar o
construtor para uma subclasse React.Component, você deve chamar super(props) antes de qualquer
outra instrução. Caso contrário, this.props ficará indefinido no construtor, o que pode resultar em bugs.
Objetos são o que transmite os dados para os componentes.
Também precisamos inicializar o estado local e atribuir um objeto a this.state . Usaremos "postagens"
como uma matriz vazia que podemos preencher com os dados da postagem de uma API.
Agora, o arquivo app.js ficará assim:

constructor(props) {
super(props);
this.state = {
posts: []
}
}
render() {
return (
<p>Hello world!</p>
);
}
}
export default App;
3. Para chamar uma API com os dados para uso no aplicativo React, usaremos o método JavaScript .fetch. A
API que chamaremos é JSONPlaceholder, uma API gratuita para teste e protótipos que fornece dados de
espaço reservado fictícios no formato JSON. O método componentDidMount é usado para montar o fetch
no componente do React. Os dados da API são salvos no estado (usando a solicitação setState).

constructor(props) {
super(props);
this.state = {
posts: []
}
}
componentDidMount() {
const url = "https://jsonplaceholder.typicode.com/albums/1/photos";
fetch(url)
.then(response => response.json())
.then(json => this.setState({ posts: json }))
}
render() {
return (
<p>Hello world!</p>
);
}
}
export default App;
4. Vamos dar uma olhada em quais tipos de dados a API salvou no estado posts . Veja abaixo uma parte do
conteúdo do arquivo de API JSON fictício. Podemos ver o formato no qual os dados estão listados
usando as categorias "albumId", "id", "title", "url" e "thumbnailUrl".
[
{
"albumId": 1,
"id": 1,
"title": "accusamus beatae ad facilis cum similique qui sunt",
"url": "https://via.placeholder.com/600/92c952",
"thumbnailUrl": "https://via.placeholder.com/150/92c952"
},
{
"albumId": 1,
"id": 2,
"title": "reprehenderit est deserunt velit ipsam",
"url": "https://via.placeholder.com/600/771796",
"thumbnailUrl": "https://via.placeholder.com/150/771796"
}
]
5. Precisaremos adicionar um estilo de página para exibir nossos dados de API. Vamos usar o Bootstrap
para processar o estilo para nós. Podemos copiar e colar a referência de folha de estilos da CDN do
Bootstrap dentro do arquivo ./public/index.html do aplicativo React.


<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
rel="stylesheet" integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
crossorigin="anonymous">
<title>React App</title>
</head>
<body>
6. Para exibir os dados da API, referenciando as classes do Bootstrap para estilo, agora, precisaremos
adicionar um código JSX dentro da instrução return() renderizada. Adicionaremos um contêiner, um
cabeçalho ("Postagens da chamada à API") e um cartão para cada um dos dados da API. Usaremos o
método map() para exibir nossos dados do objeto posts que o armazenamos como chaves. Cada
cartão exibirá um cabeçalho com o "nº da ID" e o valor de chave post.id + o valor de chave post.title dos
dados JSON. Seguido do corpo que exibe a imagem com base no valor da chave thumbnailURL.
render() {
const { posts } = this.state;
return (
<div className="container">
<div class="jumbotron">
<h1 class="display-4">Posts from our API call</h1>
</div>
{posts.map((post) => (
<div className="card" key={post.id}>
<div className="card-header">
ID #{post.id} {post.title}
</div>
<div className="card-body">
<img src={post.thumbnailUrl}></img>
</div>
</div>
))}
</div>
);
}
7. Execute o aplicativo React novamente: npm start e dê uma olhada no navegador da Web local em
localhost:3000 para ver os dados da API que estão sendo exibidos.
Recursos adicionais
A documentação oficial do React oferece todas as informações mais recentes e atualizadas sobre o React
Complementos do Microsoft Edge para as Ferramentas para Desenvolvedores do React: adicione duas guias
às suas ferramentas de desenvolvimento do Microsoft Edge para ajudar com o desenvolvimento do React:
Componentes e Profiler.
Microsoft Learn: o roteiro de aprendizagem do React contém módulos de curso online para ajudar você a se
familiarizar com os conceitos básicos.
O que é o Vue.js?
O Vue é uma estrutura JavaScript de front-end e de software livre para criação de interfaces do usuário e
aplicativos de página única na Web. Criado por Evan You, lançado em 2014 e mantido por Evan e pela equipe
principal dele, o Vue tem como foco a renderização declarativa e a composição de componentes que oferecem
uma biblioteca principal somente para a camada de exibição.
Caso deseje criar um aplicativo Web Vue renderizado pelo servidor com recursos avançados, como roteamento,
gerenciamento de estado e ferramentas de build, dê uma olhada no Nuxt.js.
O que torna o Vue único?

O Vue usa uma arquitetura model-view-viewmodel. Anteriormente, Evan You trabalhou no AngularJS na Google
e extraiu partes do Angular para oferecer uma estrutura mais leve. De muitas maneiras, o Vue é semelhante ao
React, ao Angular, ao Ember, ao Knockout etc. Confira a documentação do Vue para obter uma comparação mais
detalhada com essas outras estruturas JavaScript.
O que você pode fazer com o Vue?

Criar um SPA (aplicativo de página única)
Usar apenas um componente do Vue para adicionar uma lista de tarefas pendentes simples ao seu aplicativo
ou encontrar exemplos mais complexos
Criar um site renderizado pelo servidor com um back-end do Node.js, com a ajuda do Nuxt.js
Ferramentas do Vue
O Vue.js tem como foco apenas a camada de exibição. Portanto, ele pode exigir ferramentas adicionais para criar
um aplicativo mais complexo. O ideal é considerar usar o seguinte:
Gerenciador de pacotes: dois gerenciadores de pacotes populares para o Vue são o npm (que está incluído
no NodeJS) e o Yarn. Os dois dão suporte a uma ampla biblioteca de pacotes bem mantidos que podem ser
instalados.
CLI do Vue: um kit de ferramentas padrão para o desenvolvimento rápido com o Vue.js com suporte
integrado para Babel, PostCSS, TypeScript, ESLint etc.
Nuxt.js: uma estrutura projetada para possibilitar a renderização de aplicativos Vue.js no lado do servidor. A
renderização no lado do servidor pode aprimorar a SEO e tornar as interfaces do usuário mais dinâmicas.
Pacote de extensão do Vue para VS Code: adiciona realce de sintaxe, formatação de código e snippets de
código aos arquivos .vue.
Vuetify: uma biblioteca de interface do usuário do Vue que oferece componentes de estrutura de design de
material.
Vuesion: um genérico do Vue para PWAs (Aplicativos Web Progressivos) prontos para produção.
Livro de história: um ambiente de desenvolvimento e teste para componentes de interface do usuário do
Vue.
Vue Router: dá suporte ao mapeamento de URLs de aplicativo para componentes do Vue.
Vue Design System: uma ferramenta de software livre projetada para criar sistemas de design com o Vue.js.
VueX: sistema de gerenciamento de estado para aplicativos Vue.
Recursos adicionais
Documentação do Vue
Instalar o Vue.js no WSL
Instalar o Vue.js no Windows
Instalar o Nuxt.js
Curso online do Microsoft Learn: Dê seus primeiros passos com o Vue.js
Experimente um tutorial do Vue com o VS Code
Instalar o Vue.js no Subsistema do Windows para
Linux
Um guia para ajudar você a configurar um ambiente de desenvolvimento do Vue.js no Windows 10 instalando a
estrutura da Web Vue.js no WSL (Subsistema do Windows para Linux). Saiba mais na página de visão geral do
Vue.js.
O Vue pode ser instalado diretamente no Windows ou no WSL. Em geral, recomendamos que você o instale no
WSL se pretende interagir com um back-end do NodeJS, deseja obter paridade com um servidor de produção
Linux ou pretende acompanhar um tutorial que utilize comandos do Bash. Para obter mais informações, confira
Devo fazer a instalação no Windows ou no Subsistema do Windows para Linux?.
Pré-requisitos
wsl -l -v
Studio Code e a extensão de desenvolvimento remoto. O npm (Gerenciador de Pacotes do Node) é usado
para instalar o Vue.js.
IMPORTANT
cd ~ e insira o comando explorer.exe . . Tome cuidado para não instalar nem armazenar arquivos com os quais você
trabalhará na unidade C montada ( /mnt/c/Users/yourname$ ). Essa ação deixará a instalação e os tempos de build
significativamente lentos.
Instalar o Vue.js
Para instalar o Vue.js no WSL:
2. Crie uma pasta de projeto, mkdir VueProjects , e insira este diretório: cd VueProjects .
3. Instale o Vue.js usando o npm (Gerenciador de Pacotes do Node):
npm install vue
Verifique o número de versão que você instalou usando o comando vue --version .
NOTE
Para instalar o Vue.js usando uma CDN em vez do npm, confira a documentação de instalação do Vue.js.
Instalar a CLI do Vue
A CLI do Vue é um kit de ferramentas usado para trabalhar com o Vue na linha de comando/no terminal. Com
ela, você pode fazer um scaffold rápido de um novo projeto (vue create), criar protótipos de novas ideias (vue
serve) ou gerenciar projetos usando uma interface gráfica do usuário (vue ui). A CLI do Vue é um pacote npm
instalado globalmente que lida com algumas das complexidades do build (como o uso do Babel ou do webpack)
para você. Se você não está criando um aplicativo de página única, talvez não precise nem queira usar a CLI do
Vue.
Para instalar a CLI do Vue, use o npm. Você precisará usar o sinalizador -g para a instalação global a fim de
atualizá-lo ( vue upgrade --next ):
npm install -g @vue/cli
Para saber mais sobre outros plug-ins que podem ser adicionados (como o lint ou o Apollo para a integração do
GraphQL), acesse Plug-ins da CLI do Vue na documentação da CLI do Vue.
Recursos adicionais
Instalar o Vue.js no Windows
Instalar o Nuxt.js
Instalar o Vue.js diretamente no Windows
Um guia para ajudar você a configurar um ambiente de desenvolvimento do Vue.js no Windows 10. Saiba mais
na página de visão geral do Vue.js.
O Vue pode ser instalado diretamente no Windows ou no WSL (Subsistema do Windows para Linux). Em geral,
recomendamos que você instale o Vue no WSL se pretende interagir com um back-end do NodeJS, deseja obter
paridade com um servidor de produção do Linux ou pretende acompanhar o artigo com um tutorial que utilize
comandos do Bash. Para obter mais informações, confira Devo fazer a instalação no Windows ou no Subsistema
do Windows para Linux?.
Pré-requisitos
Instalar o Node.js no Windows: isso inclui um gerenciador de versões, um gerenciador de pacotes e o Visual
Studio Code. O npm (Gerenciador de Pacotes do Node) é usado para instalar o Vue.js.
Instalar o Vue.js
Para instalar o Vue.js:
1. Abra uma linha de comando (ou seja, prompt de comando do Windows ou PowerShell).
2. Crie uma pasta de projeto, mkdir VueProjects , e insira este diretório: cd VueProjects .
3. Instale o Vue.js usando o npm (Gerenciador de Pacotes do Node):
npm install vue
Verifique o número de versão que você instalou usando o comando vue --version .
NOTE
Para instalar o Vue.js usando uma CDN em vez do npm, confira a documentação de instalação do Vue.js. Confira a
documentação do Vue para obter uma Explicação de diferentes builds do Vue.
Instalar a CLI do Vue

A CLI do Vue é um kit de ferramentas usado para trabalhar com o Vue na linha de comando/no terminal. Com
ela, você pode fazer um scaffold rápido de um novo projeto (vue create), criar protótipos de novas ideias (vue
serve) ou gerenciar projetos usando uma interface gráfica do usuário (vue ui). A CLI do Vue é um pacote npm
instalado globalmente que lida com algumas das complexidades do build (como o uso do Babel ou do webpack)
para você. Se você não está criando um aplicativo de página única, talvez não precise nem queira usar a CLI do
Vue.
Para instalar a CLI do Vue, use o npm. Você precisará usar o sinalizador -g para a instalação global a fim de
atualizá-lo ( vue upgrade --next ):
npm install -g @vue/cli

Para saber mais sobre outros plug-ins que podem ser adicionados (como o lint ou o Apollo para a integração do
GraphQL), acesse Plug-ins da CLI do Vue na documentação da CLI do Vue.
Recursos adicionais
Instalar o Vue.js no WSL
Instalar o Nuxt.js
Introdução ao Nuxt.js no Windows
Um guia para ajudar você a instalar a estrutura da Web Nuxt.js e colocá-la em funcionamento no Windows 10.
Nuxt.js é uma estrutura para criar aplicativos JavaScript renderizados pelo servidor com base em Vue.js, Node.js,
Webpack e Babel.js. Ele foi inspirado no Next.js. Basicamente, é um projeto genérico para Vue. Assim como o
Next.js, ele foi criado de acordo com as práticas recomendadas e permite desenvolver aplicativos Web
"universais" de forma simples e consistente, praticamente com qualquer configuração. Esses aplicativos Web
"universais" renderizados pelo servidor também são chamados de "isomórficos", o que significa que o código é
compartilhado entre o cliente e o servidor.
Para saber mais sobre o Vue, confira a página de visão geral do Vue.
Pré-requisitos
Node.js, incluindo:
wsl -l -v
IMPORTANT
Instalar o Nuxt.js
Para instalar o Nuxt.js, você precisará responder a uma série de perguntas sobre qual tipo de estrutura de
servidor integrado, estrutura da interface do usuário, estrutura de teste, modo, módulos e linter você deseja
instalar:
2. Crie uma pasta de projeto, mkdir NuxtProjects , e insira este diretório: cd NuxtProjects .
3. Instale o Nuxt.js e crie um projeto (substituindo "my-nuxt-app" pelo nome que você gostaria para seu
aplicativo): npm create nuxt-app my-nuxt-app
4. Agora, o instalador do Nuxt.js fará as seguintes perguntas:
Nome do projeto: my-nuxtjs-app
Descrição do projeto: descrição do meu aplicativo Nuxt.js.
Nome do autor: uso meu alias do GitHub.
Escolha o gerenciador de pacotes: yarn ou NPM – usamos NPM para nossos exemplos.
Escolha estrutura da IU: nenhum, Vue de design do Ant, Vue de inicialização etc. Vamos escolher
Vuetify para este exemplo, mas a Comunidade Vue criou um interessante resumo de comparação
dessas estruturas de IU para ajudar na escolha do melhor esquema para seu projeto.
Escolha estruturas de servidor personalizadas: nenhuma, AdonisJs, Express, Fastify etc. Vamos
escolher Nenhuma para este exemplo, mas você pode encontrar uma comparação de estruturas de
servidor 2019-2020 no site Dev.to.
Escolha módulos de Nuxt.js (use a barra de espaços para selecionar módulos ou apenas insira se você
não quiser): Axios (para simplificar as solicitações HTTP) ou suporte do PWA (para adicionar um
serviço de trabalho, arquivo manifest.json etc.). Não vamos adicionar um módulo a este exemplo.
Escolha ferramentas de lint: ESLint , Prettier e arquivos Lint em etapas. Vamos escolher ESLint (uma
ferramenta para analisar seu código e avisar sobre possíveis erros).
Escolha uma estrutura de teste: Nenhuma , JEST, AVA. Vamos escolher Nenhuma , já que não
abordaremos os testes neste guia de início rápido.
Escolha o modo de renderização: Universal (SSR) ou um SPA (aplicativo de página única). Vamos
escolher Universal (SSR) para nosso exemplo, mas os documentos do Nuxt.js indicam algumas
diferenças, como SSR exigindo um servidor Node.js em execução para renderizar seu aplicativo no
servidor e um SPA para hospedagem estática.
Escolher ferramentas de desenvolvimento: jsconfig.json (recomendado para VS Code para que a
conclusão do código IntelliSense funcione)
5. Depois que o projeto for criado, use cd my-nuxtjs-app para inserir o diretório do projeto Nuxt.js, depois
insira code . para abrir o projeto no ambiente WSL remoto do VS Code.
6. Há três comandos que você precisará saber quando o Nuxt.js estiver instalado:
npm run dev para executar uma instância de desenvolvimento com recarga dinâmica, observação de
arquivo e nova execução de tarefa.
npm run build para compilar seu projeto.
npm start para iniciar seu aplicativo no modo de produção.
indicando o diretório do projeto (por exemplo, ~/NuxtProjects/my-nuxt-app$ ). Em seguida, tente executar
uma instância de desenvolvimento do novo aplicativo Nuxt.js usando: npm run dev
7. O servidor de desenvolvimento local será iniciado (exibindo algumas barras de progresso legais para as
compilações do cliente e do servidor). Após a criação do projeto, seu terminal exibirá "Compilado com
êxito" com o tempo que a compilação levou. Aponte o navegador da Web para http://localhost:3000 a fim
de abrir o novo aplicativo Nuxt.js.
8. Abra o arquivo pages/index.vue no editor do VS Code. Localize o título da página
<v-card-title class="headline">Welcome to the Vuetify + Nuxt.js template</v-card-title> e altere-o para
<v-card-title class="headline">This is my new Nuxt.js app!</v-card-title> . Com o navegador da Web
ainda aberto em localhost:3000, salve sua alteração e observe que o recurso de recarga dinâmica
compila e atualiza automaticamente a alteração no navegador.
9. Vejamos como o Nuxt.js lida com erros. Remova a marca de fechamento </v-card-title> para que o
código de título agora tenha esta aparência: <v-card-title class="headline">This is my new Nuxt.js app! .
Salve essa alteração e observe que um erro de compilação será exibido no navegador e no terminal,
informando que a marca de fechamento <v-card-title> está ausente, e os números de linha em que o
erro pode ser encontrado em seu código. Substitua a marca de fechamento </v-card-title> , salve, e a
página será recarregada.
Você pode usar o depurador do VS Code com o aplicativo Nuxt.js clicando na tecla F5 ou acessando Exibir >
Para saber mais sobre o Nuxt.js, confira o Guia do Nuxt.js.

Tutorial: Vue.js para iniciantes
Se você estiver começando a usar o Vue.js agora, este guia ajudará você a se familiarizar com alguns conceitos
básicos.
Experimentar a área restrita de código HelloWorld do Vue.js
Experimentar usar o Node.js no Visual Studio Code
Pré-requisitos
Primeiro, é necessário instalar o Vue.js no Windows ou no Subsistema do Windows para Linux. Não tem
certeza de qual usar? Em geral, recomendamos que os iniciantes façam a instalação no Windows para
aprender a usá-lo, mas os profissionais podem instalá-lo no WSL. Confira Devo instalar o Node.js no
Windows ou no Subsistema do Windows para Linux?.
Experimentar o NodeJS com o Visual Studio Code

Caso ainda não o tenha, instale o VS Code. Recomendamos instalar o VS Code no Windows,
independentemente de você pretender usar o Vue no Windows ou no WSL.
1. Abra a linha de comando, crie um diretório mkdir HelloVue e insira o diretório: cd HelloVue
2. Instale a CLI do Vue: npm install -g @vue/cli
3. Crie seu aplicativo Vue: vue create hello-vue-app
Você precisará escolher se deseja usar o Vue 2 ou a versão prévia do Vue 3 ou selecionar manualmente
os recursos desejados.
4. Abra o diretório do novo hello-vue-app: cd hello-vue-app
5. Tente executar o novo aplicativo Vue no navegador da Web: npm run serve
Você verá "Bem-vindo(a) ao seu aplicativo Vue.js" no http://localhost:8080 em seu navegador. Pressione
Ctrl+C para interromper o servidor vue-cli-service.
NOTE
Se estiver usando o WSL (com o Ubuntu ou sua distribuição favorita do Linux) para este tutorial, você precisará
verificar se tem a Extensão do WSL Remoto instalada para obter a melhor experiência de execução e edição do seu
código com o servidor remoto do VS.
6. Tente atualizar a mensagem de boas-vindas abrindo o código-fonte do aplicativo Vue no VS Code, insira:
code .
7. O VS Code será iniciado e exibirá o aplicativo Vue no Explorador de Arquivos. Execute seu aplicativo no
terminal novamente com o npm run serve e abra o navegador da Web no localhost para ver a página
inicial da página do Vue exibida. Encontre o arquivo App.vue no VS Code. Tente alterar "Bem-vindo(a) ao
seu aplicativo Vue.js" para "Bem-vindo(a) à selva!". Você verá a "recarga dinâmica" do aplicativo Vue
assim que salvar a alteração.
Recursos adicionais
Usando o Vue no Visual Studio Code: saiba mais sobre como usar o Vue com o VS Code, incluindo a
extensão do Vetur que fornece realce de sintaxe do Vue, IntelliSense, suporte à depuração, entre outros.
Documentação do Vue.js
Comparação do Vue com outras estruturas como o React ou o Angular
Introdução ao uso do Python no Windows para
iniciantes
Veja a seguir um guia passo a passo para os iniciantes que estão interessados em aprender mais sobre o Python
usando o Windows 10.

Para os iniciantes que realmente não têm noções básicas sobre o Python, recomendamos a instalação do Python
pela Microsoft Store. A instalação por meio da Microsoft Store usa o interpretador básico Python3, mas cuida da
definição das configurações de PATH para o usuário atual (evitando a necessidade de acesso de administrador),
além de fornecer atualizações automáticas. Isso será especialmente útil se você estiver em um ambiente
educacional ou fizer parte de uma organização que restringe as permissões ou o acesso administrativo no
computador.
Se você estiver usando o Python no Windows para o desenvolvimento para a Web , recomendamos uma
configuração diferente para o ambiente de desenvolvimento. Em vez da instalação direta no Windows,
recomendamos a instalação e o uso do Python por meio do Subsistema do Windows para Linux. Para obter
ajuda, confira: Introdução ao uso do Python para desenvolvimento para a Web no Windows. Se você estiver
interessado em automatizar tarefas comuns no sistema operacional, confira nosso guia: Introdução ao uso do
Python no Windows para script e automação. Para alguns cenários avançados (como a necessidade de
acessar/modificar arquivos instalados do Python, fazer cópias de binários ou usar as DLLs do Python
diretamente), o ideal é considerar a possibilidade de baixar uma versão específica do Python diretamente em
python.org ou instalar uma alternativa, como Anaconda, Jython, PyPy, WinPython, IronPython etc. Só
recomendamos isso se você for um programador mais avançado do Python com um motivo específico para
escolher uma implementação alternativa.
Instalar o Python
Para instalar o Python usando a Microsoft Store:
1. Acesse o menu Iniciar (ícone do Windows no canto inferior esquerdo), digite "Microsoft Store" e
selecione o link para abrir a loja.
2. Quando a loja estiver aberta, selecione Pesquisar no menu superior direito e insira "Python". Selecione
qual versão do Python você gostaria de usar dos resultados mostrados em Aplicativos. É recomendável
usar a mais recente, a menos que você tenha um motivo para não fazer isso (como o alinhamento com a
versão usada em um projeto pré-existente no qual você planeja trabalhar). Depois de determinar qual
versão deseja instalar, selecione Obter .
3. Depois que o Python concluir o processo de download e instalação, abra o Windows PowerShell usando
o menu Iniciar (ícone do Windows no canto inferior esquerdo). Quando o PowerShell estiver aberto,
insira Python --version para confirmar se o Python3 foi instalado no computador.
4. A instalação do Python por meio da Microsoft Store inclui o pip , o gerenciador de pacotes padrão. O pip
permite que você instale e gerencie pacotes adicionais que não fazem parte da biblioteca padrão do
Python. Para confirmar que você também tem o pip disponível para instalar e gerenciar pacotes, insira
pip --version .
Usando o VS Code como o editor de texto/o IDE (ambiente de desenvolvimento integrado), você pode
aproveitar o IntelliSense (um recurso de preenchimento de código), o Linting (ajuda a evitar erros no código), o
Suporte de depuração (ajuda a encontrar erros no código depois de executá-lo), os Snippets de código
(modelos para pequenos blocos de código reutilizáveis) e os Testes de unidade (testes da interface do código
com diferentes tipos de entrada).
O VS Code também contém um terminal interno que permite que você abra uma linha de comando do Python
com o Prompt de Comando do Windows, o PowerShell ou o que preferir, estabelecendo um fluxo de trabalho
contínuo entre o editor de códigos e a linha de comando.
1. Para instalar o VS Code, baixe o VS Code para Windows: https://code.visualstudio.com.
2. Depois que o VS Code tiver sido instalado, você também deverá instalar a extensão do Python. Para
instalar a extensão do Python, você pode selecionar o link VS Code Marketplace ou abrir o VS Code e
pesquisar Python no menu extensões (Ctrl+Shift+X).
3. O Python é uma linguagem interpretada e, para executar o código Python, você precisará informar o VS
Code de qual interpretador usar. É recomendável usar a versão mais recente do Python, a menos que
você tenha um motivo específico para escolher algo diferente. Depois de ter instalado a extensão do
Python, selecione um interpretador do Python 3 abrindo a paleta de comandos (Ctrl+Shift+P) e
comece a digitar o comando Python: Selecionar Interpretador para pesquisar e, em seguida,
selecione o comando. Use também a opção Selecionar Ambiente do Python na barra de status
inferior, se disponível (talvez ela já mostre um interpretador selecionado). O comando apresenta uma
lista dos interpretadores disponíveis que o VS Code pode localizar automaticamente, incluindo ambientes
virtuais. Se o interpretador desejado não for exibido, confira Como configurar ambientes do Python.
4. Para abrir o terminal no VS Code, selecione Exibir > Terminal ou, como alternativa, use o atalho Ctrl+`
(usando o caractere de acento grave). O terminal padrão é o PowerShell.
5. No terminal do VS Code, abra o Python apenas inserindo o comando: python
6. Experimente o interpretador do Python inserindo print("Hello World") . O Python retornará a declaração

"Olá, Mundo".
Instalar o Git (opcional)

Se você pretende colaborar com outras pessoas no código Python ou hospedar seu projeto em um site open-
source (como o GitHub), o VS Code dá suporte ao controle de versão com o Git. A guia Controle do Código-
fonte no VS Code acompanha todas as alterações e tem comandos Git comuns (add, commit, push e pull)
incorporados diretamente na interface do usuário. Primeiro, você precisa instalar o Git para ativar o painel
Controle do Código-fonte.
Tutorial de Olá, Mundo para aprender alguns conceitos básicos do

Python
O Python, de acordo com o criador Guido van Rossum, é uma "linguagem de programação de alto nível e a
filosofia de design principal resume-se à legibilidade do código e a uma sintaxe que permite aos programadores
expressar conceitos em algumas linhas de código”.
O Python é uma linguagem interpretada. Em contraste com as linguagens compiladas, em que o código escrito
precisa ser convertido no código do computador para ser executado pelo processador do computador, o código
Python é passado para um interpretador e executado diretamente. Basta digitar seu código e executá-lo. Vamos
testá-lo!
1. Com a linha de comando do PowerShell aberta, insira python para executar o interpretador do Python 3.
(Algumas instruções preferem usar o comando py ou python3 , e isso também deverá funcionar). Você
saberá que obteve êxito porque um aviso >>> com três símbolos maior que será exibido.
2. Há vários métodos internos que permitem que você faça modificações em cadeias de caracteres no
Python. Crie uma variável com variable = 'Hello World!' . Pressione Enter para ir para uma nova linha.
3. Imprima a variável com print(variable) . Isso exibirá o texto "Olá, Mundo!".
4. Descubra o tamanho e a quantidade de caracteres usada da variável de cadeia de caracteres com
len(variable) . Isso mostrará que há 12 caracteres usados. (Observe que o espaço em branco contado
como um caractere no tamanho total.)
5. Converta a variável de cadeia de caracteres em letras maiúsculas: variable.upper() . Agora, converta a
variável de cadeia de caracteres em letras minúsculas: variable.lower() .
6. Conte quantas vezes a letra "l" é usada na variável de cadeia de caracteres: variable.count("l") .
7. Pesquise um caractere específico na variável de cadeia de caracteres. Vamos encontrar o ponto de
exclamação com variable.find("!") . Isso mostrará que o ponto de exclamação é encontrado no
caractere na 11ª posição da cadeia de caracteres.
8. Substitua o ponto de exclamação por um ponto de interrogação: variable.replace("!", "?") .
9. Para sair do Python, insira exit() , quit() ou selecione Ctrl-Z.
Esperamos que tenha se divertido usando alguns dos métodos internos de modificação de cadeia de caracteres
do Python. Agora tente criar um arquivo de programa do Python e executá-lo com o VS Code.
Tutorial de Olá, Mundo para usar o Python com o VS Code

A equipe do VS Code compilou um excelente tutorial Introdução ao Python descrevendo como criar um
programa Olá, Mundo com o Python, executar o arquivo de programa, configurar e executar o depurador e
instalar pacotes como matplotlib e numpy para criar um gráfico em um ambiente virtual.
1. Abra o PowerShell e crie uma pasta vazia chamada "hello", navegue até essa pasta e abra-a no VS Code:
mkdir hello
cd hello
code .
2. Quando o VS Code for aberto exibindo a nova pasta hello na janela do Explorador no lado esquerdo,
abra uma janela de linha de comando no painel inferior do VS Code pressionando CTRL+` (usando o
caractere de acento grave) ou selecionando Exibir > Terminal . Iniciando o VS Code em uma pasta, essa
pasta torna-se o "workspace". O VS Code armazena configurações específicas para esse workspace em
.vscode/settings.json, que são separadas das configurações de usuário armazenadas globalmente.
3. Continue o tutorial nos documentos do VS Code: Crie um arquivo de código-fonte Olá, Mundo do
Python.
Criar um jogo simples com o Pygame

O PyGame é um pacote do Python popular para escrever jogos, incentivando os alunos a aprender a programar
enquanto criam algo divertido. O PyGame exibe gráficos em uma nova janela e, portanto, não funcionará na
abordagem somente de linha de comando do WSL. No entanto, se você instalou o Python por meio da
Microsoft Store conforme detalhado neste tutorial, ele funcionará corretamente.
1. Depois de instalar o Python, instale o PyGame por meio da linha de comando (ou do terminal no VS
Code) digitando python -m pip install -U pygame --user .
2. Teste a instalação executando um jogo de exemplo: python -m pygame.examples.aliens
3. Se tudo estiver certo, o jogo abrirá uma janela. Feche a janela quando terminar de jogar.
Veja como começar a escrever seu próprio jogo.
1. Abra o PowerShell (ou o Prompt de Comando do Windows) e crie uma pasta vazia chamada "bounce".
Navegue até essa pasta e crie um arquivo chamado "bounce.py". Abra a pasta no VS Code:
mkdir bounce
cd bounce
new-item bounce.py
code .
2. Usando o VS Code, insira o seguinte código Python (ou copie-o e cole-o):

import sys, pygame
pygame.init()
size = width, height = 640, 480

dx = 1
dy = 1
x= 163
y = 120
black = (0,0,0)
white = (255,255,255)
screen = pygame.display.set_mode(size)
while 1:
for event in pygame.event.get():

if event.type == pygame.QUIT: sys.exit()
x += dx
y += dy
if x < 0 or x > width:

dx = -dx
if y < 0 or y > height:

dy = -dy
screen.fill(black)
pygame.draw.circle(screen, white, (x,y), 8)
pygame.display.flip()
3. Salve-o como bounce.py .

4. No terminal do PowerShell, execute-o inserindo python bounce.py .
Tente ajustar alguns dos números para ver o efeito que eles têm na bola saltitante.
Leia mais sobre como escrever jogos com o PyGame em pygame.org.
Recursos para aprendizado contínuo
Recomendamos os recursos a seguir para ajudar você a continuar aprendendo sobre o desenvolvimento com o
Python no Windows.
Cursos online de introdução ao Python
Introdução ao Python no Microsoft Learn: Experimente a plataforma interativa do Microsoft Learn e
ganhe pontos de experiência por concluir este módulo abordando os conceitos básicos sobre como
escrever um código Python básico, declarar variáveis e trabalhar com a entrada e a saída do console. O
ambiente interativo de área restrita faz desse um ótimo lugar para começar para as pessoas que ainda
não têm seu próprio ambiente de desenvolvimento do Python configurado.
Python no Pluralsight: 8 cursos, 29 horas: O roteiro de aprendizagem do Python no Pluralsight oferece
cursos online que abrangem uma variedade de tópicos relacionados ao Python, incluindo uma
ferramenta para avaliar suas habilidades e encontrar suas lacunas.
Tutoriais de LearnPython.org: Comece a aprender a usar o Python sem precisar instalar nem definir nada
com estes tutoriais interativos e gratuitos do Python da equipe do DataCamp.
Os tutoriais do Python.org: Apresenta o leitor informalmente aos conceitos básicos e aos recursos da
linguagem Python e do sistema.
Introdução ao Python no Lynda.com: Uma introdução básica ao Python.
Como trabalhar com o Python no VS Code
Como editar o Python no VS Code: Saiba mais sobre como aproveitar o preenchimento automático e o
suporte do IntelliSense do VS Code para o Python, incluindo como personalizar o comportamento deles
ou apenas desligá-los.
Linting do Python: Linting é o processo de execução de um programa que analisará o código em busca
de possíveis erros. Saiba mais sobre as diferentes formas de suporte de linting fornecidas pelo VS Code
para o Python e como configurá-lo.
Depuração do Python: Depuração é o processo de identificação e remoção de erros de um programa de
computador. Este artigo aborda como inicializar e configurar a depuração para o Python com o VS Code,
como definir e validar pontos de interrupção, anexar um script local, executar a depuração para diferentes
tipos de aplicativos ou em um computador remoto e algumas soluções de problemas básicas.
Teste de unidade do Python: Aborda uma explicação preliminar sobre o significado do teste de unidade,
um passo a passo de exemplo, a habilitação de uma estrutura de teste, a criação e a execução dos testes,
a depuração de testes e definições de configuração de teste.
Introdução ao uso do Python para desenvolvimento
para a Web no Windows
Veja a seguir um guia passo a passo para ajudar você a começar a usar o Python para desenvolvimento para a
Web no Windows usando o WSL (Subsistema do Windows para Linux).

Recomendamos a instalação do Python no WSL ao criar aplicativos Web. Muitos dos tutoriais e muitas das
instruções de desenvolvimento para a Web do Python são escritos para usuários do Linux e usam ferramentas
de instalação e empacotamento baseadas em Linux. A maioria dos aplicativos Web também é implantada no
Linux, portanto, isso garantirá a consistência entre os ambientes de desenvolvimento e produção.
Se você estiver usando o Python para algo que não seja o desenvolvimento para a Web, recomendamos a
instalação do Python diretamente no Windows 10 usando a Microsoft Store. O WSL não dá suporte a aplicativos
nem áreas de trabalho de GUI (por exemplo, PyGame, Gnome, KDE etc.). Instale e use o Python diretamente no
Windows para esses casos. Se você estiver conhecendo o Python agora, confira nosso guia: Introdução ao uso
do Python no Windows para iniciantes. Se você estiver interessado em automatizar tarefas comuns no sistema
operacional, confira nosso guia: Introdução ao uso do Python no Windows para script e automação. Para alguns
cenários avançados, o ideal é considerar a possibilidade de baixar uma versão específica do Python diretamente
em python.org ou instalar uma alternativa, como Anaconda, Jython, PyPy, WinPython, IronPython etc. Só
recomendamos isso se você for um programador mais avançado do Python com um motivo específico para
escolher uma implementação alternativa.
Instalar o Subsistema do Windows para Linux

O WSL permite executar um ambiente de linha de comando GNU/Linux diretamente integrado com o Windows
e suas ferramentas preferidas, como o Visual Studio Code, o Outlook etc.
Para habilitar e instalar o WSL (ou o WSL 2, de acordo com suas necessidades), siga as etapas na documentação
de instalação do WSL. Essas etapas incluirão a escolha da distribuição do Linux (por exemplo, o Ubuntu).
Após instalar o WSL e uma distribuição do Linux, abra a distribuição do Linux (encontrada no menu Iniciar do
Windows) e verifique a versão e o codinome usando o comando: lsb_release -dc .
É recomendável atualizar a distribuição do Linux regularmente, inclusive imediatamente após a instalação, para
garantir que os pacotes são os mais recentes. O Windows não cuida automaticamente dessa atualização. Para
atualizar a distribuição, use o comando: sudo apt update && sudo apt upgrade .
TIP
Considere instalar o novo Terminal do Windows da Microsoft Store para habilitar várias guias (alterne rapidamente entre
as linhas de comando do Linux, o prompt de comando do Windows, o PowerShell, a CLI do Azure etc.), crie associações de
chave personalizadas (teclas de atalho para abrir ou fechar guias, copiar + colar etc.), use o recurso de pesquisa e
configure temas personalizados (esquemas de cores, estilos e tamanhos de fonte, imagem de tela de
fundo/desfoque/transparência). Saiba mais.
Configurar o Visual Studio Code

Aproveite o IntelliSense, o Linting, o Suporte de depuração, os Snippets de código e os Testes de unidade
usando o VS Code. O VS Code se integra perfeitamente ao Subsistema do Windows para Linux, fornecendo um
terminal interno para estabelecer um fluxo de trabalho contínuo entre o editor de códigos e a linha de comando,
além de dar suporte ao Git para controle de versão com os comandos comuns do Git (add, commit, push e pull)
incorporados diretamente na interface do usuário.
1. Baixe e instale o VS Code para Windows. O VS Code também está disponível para Linux, mas o
Subsistema do Windows para Linux não dá suporte a aplicativos de GUI e, portanto, precisamos instalá-
lo no Windows. Não se preocupe, você ainda poderá fazer a integração à linha de comando e às
ferramentas do Linux usando a Extensão WSL – Remoto.
2. Instale a Extensão WSL – Remoto no VS Code. Isso permite que você use o WSL como o ambiente de
desenvolvimento integrado e cuidará da compatibilidade e dos caminhos para você. Saiba mais.
IMPORTANT
Se você já tiver o VS Code instalado, precisará verificar se tem a versão de maio 1.35 ou posterior para instalar a Extensão
do WSL Remoto. Não recomendamos o uso do WSL no VS Code sem a extensão do WSL Remoto, pois você perderá o
suporte de preenchimento automático, depuração, linting etc. Curiosidade: Essa extensão do WSL é instalada em
$HOME/.vscode-server/extensions.
Criar um novo projeto

Vamos criar um diretório de projeto no sistema de arquivos do Linux (Ubuntu) e, em seguida, trabalharemos
com aplicativos e ferramentas do Linux usando o VS Code.
1. Feche o VS Code e abra o Ubuntu 18.04 (a linha de comando do WSL) acessando o menu Iniciar (ícone
do Windows no canto inferior esquerdo) e digitando: "Ubuntu 18.04".
2. Na linha de comando do Ubuntu, navegue até o local em que deseja colocar o projeto e crie um diretório
para ele: mkdir HelloWorld .
TIP
Um ponto importante a ser lembrado ao usar o WSL (Subsistema do Windows para Linux) é que agora você está
trabalhando entre dois sistemas de arquivos diferentes : 1) o sistema de arquivos do Windows e 2) o sistema de
arquivos do Linux (WSL), que é o Ubuntu em nosso exemplo. Você precisará prestar atenção no local de instalação dos
pacotes e armazenamento dos arquivos. Você pode instalar uma versão de uma ferramenta ou um pacote no sistema de
arquivos do Windows e uma versão completamente diferente no sistema de arquivos do Linux. A atualização da
ferramenta no sistema de arquivos do Windows não terá nenhum efeito na ferramenta no sistema de arquivos do Linux e
vice-versa. O WSL monta as unidades fixas no computador na pasta /mnt/<drive> da distribuição do Linux. Por
exemplo, a unidade C: do Windows está montada em /mnt/c/ . Acesse seus arquivos do Windows por meio do terminal
do Ubuntu e use aplicativos e ferramentas do Linux nesses arquivos e vice-versa. Recomendamos trabalhar no sistema de
arquivos do Linux para o desenvolvimento na Web com o Python, considerando que grande parte das ferramentas da
Web foi originalmente escrita para o Linux e implantada em um ambiente de produção do Linux. Isso também evita a
mistura de semântica do sistema de arquivos (como o Windows não diferenciando maiúsculas de minúsculas em relação
aos nomes de arquivos). Dito isso, o WSL agora dá suporte à alternância entre os sistemas de arquivos do Linux e do
Windows, de modo que você possa hospedar seus arquivos em um deles. Saiba mais.
Instalar o Python, o pip e o venv
O Ubuntu 18.04 LTS é fornecido com o Python 3.6 já instalado, mas não vem com alguns dos módulos que você
pode esperar obter com outras instalações do Python. Ainda precisaremos instalar o pip , o gerenciador de
pacotes padrão para o Python, e o venv , o módulo padrão usado para criar e gerenciar ambientes virtuais leves.
1. Confirme se o Python3 já está instalado abrindo o terminal do Ubuntu e inserindo python3 --version .
Isso deverá retornar o número de versão do Python. Caso precise atualizar sua versão do Python,
primeiro, atualize sua versão do Ubuntu inserindo sudo apt update && sudo apt upgrade e, em seguida,
atualize o Python usando sudo apt upgrade python3 .
2. Instale o pip inserindo sudo apt install python3-pip . O pip permite que você instale e gerencie pacotes
adicionais que não fazem parte da biblioteca padrão do Python.
3. Instale o venv inserindo sudo apt install python3-venv .
Criar um ambiente virtual

O uso de ambientes virtuais é uma melhor prática recomendada para projetos de desenvolvimento do Python.
Ao criar um ambiente virtual, você pode isolar suas ferramentas de projeto e evitar conflitos de controle de
versão com ferramentas para seus outros projetos. Por exemplo, você pode manter um projeto Web mais antigo
que exija a estrutura da Web Django 1.2, mas um novo projeto interessante surge usando o Django 2.2. Se você
atualizar o Django globalmente, fora de um ambiente virtual, poderá ter alguns problemas de controle de
versão posteriormente. Além de evitar conflitos acidentais de controle de versão, os ambientes virtuais
permitem que você instale e gerencie pacotes sem privilégios administrativos.
1. Abra o terminal e, na pasta do projeto HelloWorld, use o seguinte comando para criar um ambiente
virtual chamado .venv : python3 -m venv .venv .
2. Para ativar o ambiente virtual, insira source .venv/bin/activate . Se isso funcionou, você deve ver (.venv)
antes do prompt de comando. Agora você tem um ambiente autossuficiente pronto para codificação e
instalação de pacotes. Quando terminar de trabalhar com o ambiente virtual, insira o seguinte comando
para desativá-lo: deactivate .
TIP
Recomendamos a criação do ambiente virtual dentro do diretório no qual você planeja ter o projeto. Como cada projeto
deve ter seu próprio diretório separado, cada um terá seu próprio ambiente virtual e, portanto, não há necessidade de
nomes exclusivos. Nossa sugestão é usar o nome .venv para seguir a convenção do Python. Algumas ferramentas (como
o pipenv) também usarão esse nome como padrão se você instalá-lo no diretório do projeto. Você não deseja usar .env ,
pois isso entra em conflito com os arquivos de definição de variável de ambiente. Em geral, não recomendamos usar
nomes sem um ponto à esquerda, pois você não precisa que ls lembre você constantemente de que o diretório existe.
Também recomendamos a adição de .venv ao arquivo .gitignore. (Este é modelo de gitignore padrão do GitHub para
Python para referência.) Para obter mais informações sobre como trabalhar com ambientes virtuais no VS Code, confira
Como usar ambientes do Python no VS Code.
Abrir uma janela do WSL Remoto

O VS Code usa a Extensão do WSL Remoto (instalada anteriormente) para tratar o subsistema Linux como um
servidor remoto. Isso permite que você use o WSL como o ambiente de desenvolvimento integrado. Saiba mais.
1. Abra a pasta do projeto no VS Code do terminal do Ubuntu inserindo code . (o "." instrui o VS Code a
abrir a pasta atual).
2. Um alerta de segurança será exibido em um pop-up do Windows Defender. Selecione "Permitir acesso".
Quando o VS Code for aberto, você deverá ver o indicador de Host de Conexão Remota, no canto inferior
esquerdo, informando que a edição está sendo feita no WSL: Ubuntu-18.04 .
3. Feche o terminal do Ubuntu. Mais adiante, usaremos o terminal do WSL integrado ao VS Code.
4. Abra o terminal do WSL no VS Code pressionando CTRL+` (usando o caractere de acento grave) ou
selecionando Exibir > Terminal . Isso abrirá uma linha de comando do Bash (WSL) aberta no caminho da
pasta do projeto que você criou no terminal do Ubuntu.
Instalar a extensão do Microsoft Python

Você precisará instalar as extensões do VS Code para o WSL Remoto. As extensões já instaladas localmente no
VS Code não estarão disponíveis automaticamente. Saiba mais.
1. Abra a janela Extensões do VS Code inserindo Ctrl+Shift+X (ou use o menu para navegar até Exibir >
Extensões ).
2. Na caixa Pesquisar Extensões no Marketplace no canto superior, insira: Python .
3. Encontre a extensão Python (ms-python.python) da Microsoft e selecione o botão verde Instalar .
4. Quando a instalação da extensão for concluída, você precisará selecionar o botão azul Recarregamento
Necessário . Isso recarregará o VS Code e exibirá uma seção WSL: UBUNTU-18.04 – Instalado na
janela Extensões do VS Code, mostrando que você instalou a extensão do Python.
Executar um programa simples do Python

O Python é uma linguagem interpretada e dá suporte a diferentes tipos de interpretadores (Python2, Anaconda,
PyPy etc.). O VS Code deve usar como padrão o interpretador associado ao projeto. Se você tiver um motivo
para alterá-lo, selecione o interpretador atualmente exibido na barra azul na parte inferior da janela do VS Code
ou abra a paleta de comandos (Ctrl+Shift+P) e insira o comando Python: Selecionar Interpretador . Isso
exibirá uma lista dos interpretadores do Python atualmente instalados. Saiba mais sobre a configuração de
ambientes do Python.
Vamos criar e executar um programa simples do Python como um teste e verificar se selecionamos o
interpretador do Python correto.
1. Abra a janela do Explorador de Arquivos do VS Code inserindo Ctrl+Shift+E (ou use o menu para
navegar até Exibir > Explorador ).
2. Se ele ainda não estiver aberto, abra o terminal integrado do WSL inserindo Ctrl+Shift+` e verifique se
a pasta do projeto HelloWorld do Python está selecionada.
3. Crie um arquivo do Python inserindo touch test.py . Você deverá ver o arquivo recém-criado exibido na
janela do Explorador nas pastas .venv e .vscode que já estão no diretório do projeto.
4. Selecione o arquivo test.py recém-criado na janela do Explorador para abri-lo no VS Code. Como o .py
no nome de arquivo informa o VS Code de que se trata de um arquivo do Python, a extensão do Python
carregada anteriormente escolherá e carregará automaticamente um interpretador do Python que você
verá na parte inferior da janela do VS Code.
5. Cole este código Python no arquivo test.py e, em seguida, salve o arquivo (Ctrl+S):
print("Hello World")
6. Para executar o programa "Olá, Mundo" do Python recém-criado, selecione o arquivo test.py na janela
do Explorador do VS Code e, em seguida, clique com o botão direito do mouse no arquivo para exibir um
menu de opções. Selecione Executar o Arquivo Python no Terminal . Como alternativa, na janela do
terminal integrado do WSL, insira python test.py para executar o programa "Olá, Mundo". O
interpretador do Python imprimirá "Olá, Mundo" na janela do terminal.
Parabéns! Você está pronto para criar e executar programas do Python. Agora, vamos tentar criar um aplicativo
Olá, Mundo com duas das estruturas da Web mais populares do Python: Flask e Django.
Tutorial de Olá, Mundo para Flask

O Flask é uma estrutura de aplicativo Web para o Python. Neste breve tutorial, você criará um pequeno
aplicativo Flask "Olá, Mundo" usando o VS Code e o WSL.
1. Abra o Ubuntu 18.04 (a linha de comando do WSL) acessando o menu Iniciar (ícone do Windows no
canto inferior esquerdo) e digitando: "Ubuntu 18.04".
2. Crie um diretório mkdir HelloWorld-Flask para o projeto e, em seguida, cd HelloWorld-Flask para inserir
o diretório.
3. Crie um ambiente virtual para instalar as ferramentas do projeto: python3 -m venv .venv
4. Abra o projeto HelloWorld-Flask no VS Code inserindo o comando: code .
5. No VS Code, abra o terminal integrado do WSL (também conhecido como Bash) inserindo Ctrl+Shift+`
(a pasta do projeto HelloWorld-Flask já deverá estar selecionada). Feche a linha de comando do
Ubuntu, pois trabalharemos no terminal do WSL integrado ao VS Code mais adiante.
6. Ative o ambiente virtual criado na etapa nº 3 usando o terminal do Bash no VS Code:
source .venv/bin/activate . Se isso funcionou, você deve ver (.venv) antes do prompt de comando.
7. Instale o Flask no ambiente virtual inserindo python3 -m pip install flask . Verifique se ele está
instalado inserindo python3 -m flask --version .
8. Crie um arquivo para o código Python: touch app.py
9. Abra o arquivo app.py no Explorador de Arquivos do VS Code ( Ctrl+Shift+E e, em seguida, selecione o

arquivo app.py). Isso ativará a Extensão do Python para a escolha de um interpretador. Ela deve usar
como padrão o Python 3.6.8 de 64 bits ('.venv': venv) . Observe que ela também detectou o
ambiente virtual.
10. Em app.py , adicione o código para importar o Flask e crie uma instância do objeto Flask:
from flask import Flask

app = Flask(__name__)
11. Também em app.py , adicione uma função que retorna o conteúdo, neste caso, uma cadeia de caracteres
simples. Use o decorador app.route do Flask para mapear a rota de URL "/" para essa função:
@app.route("/")
def home():
return "Hello World! I'm using Flask."
TIP
Você pode usar vários decoradores na mesma função, um por linha, dependendo de quantas rotas diferentes você
deseja mapear para a mesma função.
12. Salve o arquivo app.py (Ctrl+S ).

13. No terminal, execute o aplicativo inserindo o seguinte comando:
python3 -m flask run
Isso executará o servidor de desenvolvimento do Flask. O servidor de desenvolvimento procura app.py

por padrão. Ao executar o Flask, você deverá ver uma saída semelhante à seguinte:
(env) user@USER:/mnt/c/Projects/HelloWorld$ python3 -m flask run

* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: off
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
14. Abra o navegador da Web padrão na página renderizada, Ctrl+Clique na URL http://127.0.0.1:5000/ no
terminal. Você deverá ver a seguinte mensagem no navegador:
15. Observe que, quando você visita uma URL como "/", uma mensagem é exibida no terminal de depuração
mostrando a solicitação HTTP:
127.0.0.1 - - [19/Jun/2019 13:36:56] "GET / HTTP/1.1" 200 -
16. Pare o aplicativo usando Ctrl+C no terminal.
TIP
Caso deseje usar um nome de arquivo diferente de app.py , como program.py , defina uma variável de ambiente
chamada FL ASK_APP e defina o valor como o arquivo escolhido. O servidor de desenvolvimento do Flask usa o valor
FL ASK_APP em vez do arquivo padrão app.py . Para obter mais informações, confira Documentação da interface de linha
de comando do Flask.
Parabéns, você criou um aplicativo Web do Flask usando o Visual Studio Code e o Subsistema do Windows para
Linux! Para obter um tutorial mais aprofundado sobre como usar o VS Code e o Flask, confira Tutorial do Flask
no Visual Studio Code.
Tutorial de Olá, Mundo para Django

O Django é uma estrutura de aplicativo Web para o Python. Neste breve tutorial, você criará um pequeno
aplicativo Django "Olá, Mundo" usando o VS Code e o WSL.
1. Abra o Ubuntu 18.04 (a linha de comando do WSL) acessando o menu Iniciar (ícone do Windows no
canto inferior esquerdo) e digitando: "Ubuntu 18.04".
2. Crie um diretório mkdir HelloWorld-Django para o projeto e, em seguida, cd HelloWorld-Django para
inserir o diretório.
3. Crie um ambiente virtual para instalar as ferramentas do projeto: python3 -m venv .venv
4. Abra o projeto HelloWorld-Django no VS Code inserindo o comando: code .
5. No VS Code, abra o terminal integrado do WSL (também conhecido como Bash) inserindo Ctrl+Shift+`
(a pasta do projeto HelloWorld-Django já deverá estar selecionada). Feche a linha de comando do
Ubuntu, pois trabalharemos no terminal do WSL integrado ao VS Code mais adiante.
6. Ative o ambiente virtual criado na etapa nº 3 usando o terminal do Bash no VS Code:
source .venv/bin/activate . Se isso funcionou, você deve ver (.venv) antes do prompt de comando.
7. Instale o Django no ambiente virtual com o comando python3 -m pip install django . Verifique se ele
está instalado inserindo python3 -m django --version .
8. Em seguida, execute o seguinte comando para criar o projeto do Django:
django-admin startproject web_project .
O comando startproject pressupõe (pelo uso de . no final) que a pasta atual seja a pasta do projeto e
cria o seguinte dentro dela:
: O utilitário administrativo da linha de comando do Django para o projeto. Execute
manage.py
comandos administrativos para o projeto usando python manage.py <command> [options] .
Uma subpasta chamada web_project , que contém os seguintes arquivos:
__init__.py : um arquivo vazio que informa o Python de que essa pasta é um pacote do
Python.
wsgi.py : um ponto de entrada para servidores Web compatíveis com WSGI para atender ao
projeto. Normalmente, esse arquivo é mantido no estado em que se encontra, pois ele fornece
os ganchos para servidores Web de produção.
settings.py : contém configurações para o projeto do Django, que você modificará no decorrer
do desenvolvimento de um aplicativo Web.
urls.py : contém um sumário para o projeto do Django, que você também modificará no curso
de desenvolvimento.
9. Para verificar o projeto do Django, inicie o servidor de desenvolvimento do Django usando o comando
python3 manage.py runserver . O servidor é executado na porta padrão 8000 e você deverá ver uma saída
semelhante à seguinte saída na janela do terminal:
Performing system checks...
System check identified no issues (0 silenced).
June 20, 2019 - 22:57:59

Django version 2.2.2, using settings 'web_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
Quando você executa o servidor pela primeira vez, ele cria um banco de dados SQLite padrão no arquivo
db.sqlite3 , que é destinado para fins de desenvolvimento, mas pode ser usado em produção para
aplicativos Web de baixo volume. Além disso, o servidor Web interno do Django é destinado apenas para
fins de desenvolvimento local. No entanto, quando você implanta em um host da Web, o Django usa o
servidor Web do host. O módulo wsgi.py no projeto do Django cuida da conexão com os servidores de
produção.
Caso você deseje usar uma porta diferente da 8000 padrão, especifique o número da porta na linha de
comando, como python3 manage.py runserver 5000 .
10. Ctrl+click na URL http://127.0.0.1:8000/ na Janela de Saída do terminal para abrir o navegador
padrão nesse endereço. Se o Django for instalado corretamente e o projeto for válido, você verá uma
página padrão. A Janela de Saída de terminal do VS Code também mostra o log do servidor.
11. Quando terminar, feche a janela do navegador e pare o servidor no VS Code usando Ctrl+C , conforme
indicado na Janela de Saída do terminal.
12. Agora, para criar um aplicativo do Django, execute o comando startapp do utilitário administrativo na
pasta do projeto (em que manage.py reside):
python3 manage.py startapp hello
O comando cria uma pasta chamada hello que contém vários arquivos de código e uma subpasta.
Deles, com frequência, você trabalha com views.py (que contém as funções que definem as páginas no
aplicativo Web) e models.py (que contém as classes que definem os objetos de dados). A pasta
migrations é usada pelo utilitário administrativo do Django para gerenciar versões de banco de dados,
conforme abordado mais adiante neste tutorial. Também há arquivos apps.py (configuração de
aplicativo), admin.py (para criar uma interface administrativa) e tests.py (para testes), que não são
abordados aqui.
13. Modifique hello/views.py para que ele corresponda ao seguinte código, que cria uma única exibição
para a home page do aplicativo:
from django.http import HttpResponse
def home(request):
return HttpResponse("Hello, Django!")
14. Crie um arquivo, hello/urls.py , com o conteúdo abaixo. O arquivo urls.py é o local em que você
especifica padrões para rotear diferentes URLs para suas respectivas exibições apropriadas. O código
abaixo contém uma rota para mapear a URL raiz do aplicativo ( "" ) para a função views.home recém-
adicionada a hello/views.py :
from django.urls import path

from hello import views
urlpatterns = [
path("", views.home, name="home"),
]
15. A pasta web_project também contém um arquivo urls.py , que é o local em que o roteamento de URL é
realmente tratado. Abra web_project/urls.py e modifique-o para que ele corresponda ao código a seguir
(mantenha os comentários instrutivos se desejar). Esse código efetua pull de hello/urls.py do aplicativo
usando django.urls.include , que mantém as rotas do aplicativo contidas no aplicativo. Essa separação é
útil quando um projeto contém vários aplicativos.
from django.contrib import admin

from django.urls import include, path
urlpatterns = [
path("", include("hello.urls")),
]
16. Salve todos os arquivos modificados.

17. No terminal do VS Code, execute o servidor de desenvolvimento com python3 manage.py runserver e
abra um navegador em http://127.0.0.1:8000/ para ver uma página que renderiza "Olá, Django".
Parabéns, você criou um aplicativo Web do Django usando o VS Code e o Subsistema do Windows para Linux!
Para obter um tutorial mais aprofundado sobre como usar o VS Code e o Django, confira Tutorial do Django no
Visual Studio Code.
Recursos adicionais
Tutorial do Python com o VS Code: Um tutorial introdutório do VS Code como um ambiente do Python,
principalmente sobre como editar, executar e depurar o código.
Suporte ao Git no VS Code: Saiba como usar os conceitos básicos de controle de versão do Git no VS Code.
Saiba mais sobre as atualizações que serão lançadas em breve com o WSL 2: Essa nova versão altera a forma
como as distribuições do Linux interagem com o Windows, aumentando o desempenho do sistema de
arquivos e adicionando compatibilidade total com chamadas do sistema.
Como trabalhar com várias distribuições do Linux no Windows: Saiba como gerenciar várias distribuições do
Linux diferentes no computador Windows.
Introdução ao uso do Python no Windows para
script e automação
Veja a seguir um guia passo a passo para configurar seu ambiente de desenvolvedor e começar a usar o Python
para criar scripts e automatizar operações do sistema de arquivos no Windows.
NOTE
Este artigo abordará a configuração do ambiente para usar algumas das bibliotecas úteis do Python que podem
automatizar tarefas entre plataformas, como pesquisa no sistema de arquivos, acesso à Internet, análise de tipos de
arquivo etc., em uma abordagem centralizada no Windows. Para operações específicas do Windows, confira ctypes, uma
biblioteca de funções estrangeiras compatíveis com C para o Python, winreg, funções que expõem a API do Registro do
Windows para Python e Python/WinRT, habilitação do acesso das APIs do Windows Runtime no Python.

Ao usar o Python para escrever scripts que executam operações do sistema de arquivos, recomendamos instalar
o Python por meio da Microsoft Store. A instalação por meio da Microsoft Store usa o interpretador básico
Python3, mas cuida da definição das configurações de PATH para o usuário atual (evitando a necessidade de
acesso de administrador), além de fornecer atualizações automáticas.
Se você estiver usando o Python para desenvolvimento para a Web no Windows, recomendamos uma
configuração diferente usando o Subsistema do Windows para Linux. Encontre um passo a passo em nosso
guia: Introdução ao uso do Python para desenvolvimento para a Web no Windows. Se você estiver conhecendo
o Python agora, experimente nosso guia: Introdução ao uso do Python no Windows para iniciantes. Para alguns
cenários avançados (como a necessidade de acessar/modificar arquivos instalados do Python, fazer cópias de
binários ou usar as DLLs do Python diretamente), o ideal é considerar a possibilidade de baixar uma versão
específica do Python diretamente em python.org ou instalar uma alternativa, como Anaconda, Jython, PyPy,
WinPython, IronPython etc. Só recomendamos isso se você for um programador mais avançado do Python com
um motivo específico para escolher uma implementação alternativa.
Instalar o Python
Para instalar o Python usando a Microsoft Store:
1. Acesse o menu Iniciar (ícone do Windows no canto inferior esquerdo), digite "Microsoft Store" e
selecione o link para abrir a loja.
2. Quando a loja estiver aberta, selecione Pesquisar no menu superior direito e insira "Python". Selecione
qual versão do Python você gostaria de usar dos resultados mostrados em Aplicativos. É recomendável
usar a mais recente, a menos que você tenha um motivo para não fazer isso (como o alinhamento com a
versão usada em um projeto pré-existente no qual você planeja trabalhar). Depois de determinar qual
versão deseja instalar, selecione Obter .
3. Depois que o Python concluir o processo de download e instalação, abra o Windows PowerShell usando
o menu Iniciar (ícone do Windows no canto inferior esquerdo). Quando o PowerShell estiver aberto,
insira Python --version para confirmar se o Python3 foi instalado no computador.
4. A instalação do Python por meio da Microsoft Store inclui o pip , o gerenciador de pacotes padrão. O pip
permite que você instale e gerencie pacotes adicionais que não fazem parte da biblioteca padrão do
Python. Para confirmar que você também tem o pip disponível para instalar e gerenciar pacotes, insira
pip --version .

Usando o VS Code como o editor de texto/o IDE (ambiente de desenvolvimento integrado), você pode
aproveitar o IntelliSense (um recurso de preenchimento de código), o Linting (ajuda a evitar erros no código), o
Suporte de depuração (ajuda a encontrar erros no código depois de executá-lo), os Snippets de código
(modelos para pequenos blocos de código reutilizáveis) e os Testes de unidade (testes da interface do código
com diferentes tipos de entrada).
Baixe o VS Code para Windows e siga as instruções de instalação: https://code.visualstudio.com.
Instalar a extensão do Microsoft Python

Você precisará instalar a extensão do Microsoft Python para aproveitar os recursos de suporte do VS Code.
Saiba mais.
1. Abra a janela Extensões do VS Code inserindo Ctrl+Shift+X (ou use o menu para navegar até Exibir >
Extensões ).
2. Na caixa Pesquisar Extensões no Marketplace no canto superior, insira: Python .
3. Encontre a extensão Python (ms-python.python) da Microsoft e selecione o botão verde Instalar .
Abrir o terminal integrado do PowerShell no VS Code

O VS Code contém um terminal interno que permite abrir uma linha de comando do Python com o PowerShell,
estabelecendo um fluxo de trabalho contínuo entre o editor de código e a linha de comando.
1. Abra o terminal no VS Code, selecione Exibir > Terminal ou, como alternativa, use o atalho Ctrl+`
(usando o caractere de acento grave).
NOTE
O terminal padrão deverá ser o PowerShell, mas se você precisar alterá-lo, use Ctrl+Shift+P para inserir a paleta
de comandos. Insira Terminal: Selecionar Shell Padrão e uma lista de opções de terminal será exibida,
contendo o PowerShell, o prompt de comando, o WSL etc. Selecione aquela que deseja usar e insira Ctrl+Shift+`
(usando o acento grave) para criar um terminal.
2. No terminal do VS Code, abra o Python inserindo: python
3. Experimente o interpretador do Python inserindo print("Hello World") . O Python retornará a declaração

"Olá, Mundo".
4. Para sair do Python, insira exit() , quit() ou selecione Ctrl-Z.
Instalar o Git (opcional)

Se você pretende colaborar com outras pessoas no código Python ou hospedar seu projeto em um site open-
source (como o GitHub), o VS Code dá suporte ao controle de versão com o Git. A guia Controle do Código-
fonte no VS Code acompanha todas as alterações e tem comandos Git comuns (add, commit, push e pull)
incorporados diretamente na interface do usuário. Primeiro, você precisa instalar o Git para ativar o painel
Controle do Código-fonte.
Script de exemplo para exibir a estrutura do diretório do sistema de

arquivos
As tarefas comuns de administração do sistema podem levar muito tempo, mas com um script Python, você
pode automatizar essas tarefas para torná-las rápidas. Por exemplo, o Python pode ler o conteúdo do sistema de
arquivos do computador e executar operações como imprimir uma estrutura de tópicos dos arquivos e dos
diretórios, mover pastas de um diretório para outro ou renomear centenas de arquivos. Normalmente, tarefas
como essas poderão levar muito tempo se você executá-las manualmente. Em vez disso, use um script Python.
Vamos começar com um script simples que examina uma árvore de diretório e exibe a estrutura dele.
1. Abra o PowerShell usando o menu Iniciar (ícone do Windows no canto inferior esquerdo).
2. Crie um diretório mkdir python-scripts para o projeto e, em seguida, abra esse diretório
cd python-scripts .
3. Crie alguns diretórios para uso com o script de exemplo:
mkdir food, food\fruits, food\fruits\apples, food\fruits\oranges, food\vegetables
4. Crie alguns arquivos nesses diretórios para uso com o script:
new-item food\fruits\banana.txt, food\fruits\strawberry.txt, food\fruits\blueberry.txt,

food\fruits\apples\honeycrisp.txt, food\fruits\oranges\mandarin.txt, food\vegetables\carrot.txt
5. Crie um arquivo do Python no diretório python-scripts:
mkdir src
new-item src\list-directory-contents.py
6. Abra o projeto no VS Code inserindo: code .
7. Abra a janela Explorador de Arquivos do VS Code inserindo Ctrl+Shift+E (ou use o menu para navegar
até Exibir > Explorador ) e selecione o arquivo list-directory-contents.py recém-criado. A extensão do
Microsoft Python carregará automaticamente um interpretador do Python. Você pode ver qual
interpretador foi carregado na parte inferior da janela do VS Code.
NOTE
O Python é uma linguagem interpretada, o que significa que ele funciona como uma máquina virtual, emulando
um computador físico. Há diferentes tipos de interpretadores do Python que você pode usar: Python 2, Python 3,
Anaconda, PyPy etc. Para executar o código Python e obter o Python IntelliSense, você precisará informar o VS
Code de qual interpretador usar. Recomendamos o uso do interpretador escolhido por padrão pelo VS Code
(Python 3, em nosso caso), a menos que você tenha um motivo específico para escolher algo diferente. Para
alterar o interpretador do Python, selecione o interpretador atualmente exibido na barra azul na parte inferior da
janela do VS Code ou abra a paleta de comandos (Ctrl+Shift+P) e insira o comando Python: Selecionar
Interpretador . Isso exibirá uma lista dos interpretadores do Python atualmente instalados. Saiba mais sobre a
configuração de ambientes do Python.
8. Cole o seguinte código no arquivo list-directory-contents.py e, em seguida, selecione Salvar :
import os
root = os.path.join('..', 'food')

for directory, subdir_list, file_list in os.walk(root):
print('Directory:', directory)
for name in subdir_list:
print('Subdirectory:', name)
for name in file_list:
print('File:', name)
print()
9. Abra o terminal integrado do VS Code (CTRL+` , usando o caractere de acento grave) e insira o diretório
src em que você acabou de salvar o script Python:
cd src
10. Execute o script no PowerShell com:
python3 .\list-directory-contents.py
Você deverá ver uma saída parecida com esta:

Directory: ..\food
Subdirectory: fruits
Subdirectory: vegetables
Directory: ..\food\fruits
Subdirectory: apples
Subdirectory: oranges
File: banana.txt
File: blueberry.txt
File: strawberry.txt
Directory: ..\food\fruits\apples
File: honeycrisp.txt
Directory: ..\food\fruits\oranges
File: mandarin.txt
Directory: ..\food\vegetables
File: carrot.txt
11. Use o Python para imprimir essa saída do diretório do sistema de arquivos para seu próprio arquivo de
texto inserindo este comando diretamente no terminal do PowerShell:
python3 list-directory-contents.py > food-directory.txt
Parabéns! Você acabou de escrever um script automatizado de administração de sistemas que lê o diretório e os
arquivos criados e usa o Python para exibir e, em seguida, imprimir a estrutura de diretório no próprio arquivo
de texto.
NOTE
Caso não consiga instalar o Python 3 da Microsoft Store, confira este problema para obter um exemplo de como lidar
com o caminho desse script de exemplo.
Script de exemplo para modificar todos os arquivos de um diretório

Este exemplo usa os arquivos e os diretórios recém-criados, renomeando cada um dos arquivos com a adição
da data da última modificação do arquivo ao início do nome do arquivo.
1. Na pasta src do diretório python-scripts , crie um arquivo do Python para o script:
new-item update-filenames.py
2. Abra o arquivo update-filenames.py, cole o seguinte código no arquivo e salve-o:
NOTE
os.getmtime retorna um carimbo de data/hora em tiques, o que não é facilmente legível. Ele precisa ser
convertido em uma cadeia de caracteres de datetime padrão primeiro.
import datetime
import os
root = os.path.join('..', 'food')

for directory, subdir_list, file_list in os.walk(root):
for name in file_list:
source_name = os.path.join(directory, name)
timestamp = os.path.getmtime(source_name)
modified_date = str(datetime.datetime.fromtimestamp(timestamp)).replace(':', '.')
target_name = os.path.join(directory, f'{modified_date}_{name}')
print(f'Renaming: {source_name} to: {target_name}')
os.rename(source_name, target_name)
3. Teste o script update-filenames.py executando-o – python3 update-filenames.py – e, em seguida,

executando o script list-directory-contents.py novamente: python3 list-directory-contents.py
4. Você deverá ver uma saída semelhante a esta:
Renaming: ..\food\fruits\banana.txt to: ..\food\fruits\2019-07-18 12.24.46.385185_banana.txt

Renaming: ..\food\fruits\blueberry.txt to: ..\food\fruits\2019-07-18 12.24.46.391170_blueberry.txt
Renaming: ..\food\fruits\strawberry.txt to: ..\food\fruits\2019-07-18 12.24.46.389174_strawberry.txt
Renaming: ..\food\fruits\apples\honeycrisp.txt to: ..\food\fruits\apples\2019-07-18
12.24.46.395160_honeycrisp.txt
Renaming: ..\food\fruits\oranges\mandarin.txt to: ..\food\fruits\oranges\2019-07-18
12.24.46.398151_mandarin.txt
Renaming: ..\food\vegetables\carrot.txt to: ..\food\vegetables\2019-07-18 12.24.46.402496_carrot.txt
PS C:\src\python-scripting\src> python3 .\list-directory-contents.py

..\food\
Directory: ..\food
Subdirectory: fruits
Subdirectory: vegetables
Directory: ..\food\fruits
Subdirectory: apples
Subdirectory: oranges
File: 2019-07-18 12.24.46.385185_banana.txt
File: 2019-07-18 12.24.46.389174_strawberry.txt
File: 2019-07-18 12.24.46.391170_blueberry.txt
Directory: ..\food\fruits\apples
File: 2019-07-18 12.24.46.395160_honeycrisp.txt
Directory: ..\food\fruits\oranges
File: 2019-07-18 12.24.46.398151_mandarin.txt
Directory: ..\food\vegetables
File: 2019-07-18 12.24.46.402496_carrot.txt
5. Use o Python para imprimir os novos nomes de diretório do sistema de arquivos com o carimbo de
data/hora da última modificação em seu próprio arquivo de texto digitando este comando diretamente
no terminal do PowerShell: python3 list-directory-contents.py > food-directory-last-modified.txt
Esperamos que tenha aprendido algumas coisas divertidas sobre o uso de scripts Python para automatizar
tarefas básicas de administração de sistemas. É claro que há muito mais para aprender, mas esperamos que isso
tenha ajudado você a ter um bom começo. Compartilhamos abaixo alguns recursos adicionais para que você
continue aprendendo.
Recursos adicionais
Documentos do Python: Acesso a arquivos e diretórios: Documentação do Python sobre como trabalhar com
sistemas de arquivos e usar módulos para ler as propriedades de arquivos, manipular caminhos de forma
portátil e criar arquivos temporários.
Aprender a usar o Python: Tutorial de String_Formatting: Mais sobre o uso do operador "%" para formatação
de cadeia de caracteres.
Dez métodos do sistema de arquivos do Python que você deve saber: Artigo um pouco mais aprofundado
sobre a manipulação de arquivos e pastas com os e shutil .
O Guia do Mochileiro do Python: Administração de sistemas: Um "guia de opinião" que oferece visões gerais
e melhores práticas sobre tópicos relacionados ao Python. Esta seção aborda as estruturas e as ferramentas
de administração do sistema. Este guia é hospedado no GitHub e, portanto, você pode enviar problemas e
fazer contribuições.
Visão geral do desenvolvimento do Android no
Windows
há vários caminhos para o desenvolvimento de um aplicativo de dispositivo Android usando o sistema

operacional Windows. Esses caminhos se enquadram em três tipos principais: desenvolvimento Android
nativo , desenvolvimento de plataforma cruzada e desenvolvimento de jogos Android . esta visão geral
ajudará você a decidir qual caminho de desenvolvimento deve ser seguido para desenvolver um aplicativo
Android e, em seguida, fornecer as próximas etapas para ajudá-lo a começar a usar o Windows para
desenvolver com:
Android nativo
Xamarin.Android
Xamarin.Forms
React Native
Cordova, Ionic ou PhoneGap
C/C++ para desenvolvimento de jogos
além disso, este guia fornecerá dicas sobre como usar Windows para:
Testar em um dispositivo Android ou emulador
Atualizar as configurações do Windows Defender para aprimorar o desempenho
Desenvolver aplicativos de tela dupla para Android e obter o SDK do dispositivo Surface Duo
Android nativo
o desenvolvimento nativo do Android no Windows significa que seu aplicativo destina-se somente ao android
(não dispositivos iOS ou Windows). você pode usar Android Studio ou Visual Studio para desenvolver dentro do
ecossistema projetado especificamente para o sistema operacional Android. O desempenho será otimizado para
dispositivos Android, a aparência da interface do usuário será consistente com outros aplicativos nativos no
dispositivo, e quaisquer recursos ou capacidades do dispositivo do usuário serão diretos para acessar e utilizar.
Desenvolver seu aplicativo em um formato nativo ajudará a ti a simplesmente "sentir-se certo" porque ele segue
todos os padrões de interação e padrões de experiência do usuário estabelecidos especificamente para
dispositivos Android.
Plataforma cruzada
as estruturas de plataforma cruzada fornecem uma única base de código que pode (principalmente) ser
compartilhada entre dispositivos Android, iOS e Windows. O uso de uma estrutura de plataforma cruzada pode
ajudar seu aplicativo a manter a mesma aparência e experiência em plataformas de dispositivos, além de se
beneficiar da distribuição automática de atualizações e correções. Em vez de precisar entender uma variedade
de linguagens de código específicas do dispositivo, o aplicativo é desenvolvido em uma base de códigos de
bases compartilhada, normalmente em uma linguagem.
Embora as estruturas entre plataformas tenham o objetivo de parecer o mais próximo possível dos aplicativos
nativos, elas nunca serão tão integradas como um aplicativo desenvolvido nativamente e podem ser
prejudicadas com velocidade reduzida e desempenho degradado. Além disso, as ferramentas usadas para criar
aplicativos de plataforma cruzada podem não ter todos os recursos oferecidos por cada plataforma de
dispositivo diferente, potencialmente exigindo soluções alternativas.
Uma codebase normalmente é composta por código da interface do usuário, para criar a interface de
usuários, como páginas, controles de botões, rótulos, listas, etc., e código lógico , para chamar serviços Web,
acessar um banco de dados, invocar recursos de hardware e gerenciar o estado. Em média, 90% disso pode ser
reutilizado, embora normalmente haja alguma necessidade de personalizar o código para cada plataforma de
dispositivo. Essa generalização depende muito do tipo de aplicativo que você está criando, mas fornece um
pouco de contexto que esperamos ajudar com a tomada de decisões.
Escolhendo uma estrutura de plataforma cruzada

Xamarin nativo (Xamarin. Android)
Código da interface do usuário: XML com Designer Android e tema do material
Código lógico: C# ou F #
Ainda é possível tocar em alguns elementos nativos do Android, mas é bom para reutilização da base de
código para outras plataformas (iOS, Windows).
Somente o código lógico é compartilhado entre plataformas, não o código da interface do usuário.
Ótimo para aplicativos mais complexos com uma interface de usuário específica do dispositivo.
Formulários do xamarin (Xamarin. Forms)
Código da interface do usuário: XAML e .NET (com Visual Studio)
Código lógico: C #
compartilha cerca de 60 a 90% da lógica e do código da interface do usuário em aplicativos de dispositivos
Android, iOS e Windows.
Usa controles de usuário comuns como botão, rótulo, entrada, ListView, StackLayout, calendário, TabbedPage,
etc. Criar um botão e formulários do Xamarin descobrirá como chamar o botão nativo para cada plataforma
usando a biblioteca de associação para chamar código Java ou Swift do C#.
Ótimo para aplicativos simples, como aplicativos internos ou de linha de negócios (LOB), protótipos ou
MVPs. Qualquer aplicativo que possa parecer, de certa forma, padrão ou genérico, utilizando uma interface
do usuário simples.
React Native
Código da interface do usuário: JavaScript
Código lógico: JavaScript
o objetivo do React Native não é escrever o código uma vez e executá-lo em qualquer plataforma, em vez de
aprender uma vez (a React maneira) e escrever em qualquer lugar.
a comunidade adicionou ferramentas como exposição e cria React Native aplicativo para ajudá-los a criar
aplicativos sem usar o Xcode ou o Android Studio.
semelhante ao Xamarin (C#), React Native (JavaScript) chama elementos nativos da interface do usuário
(sem a necessidade de escrever Java/Kotlin ou Swift).
PWAs (Aplicativos Web Progressivos)
Código da interface do usuário: HTML, CSS, JavaScript
Código lógico: JavaScript
PWAs são aplicativos Web criados com padrões padrão para permitir que eles aproveitem os recursos de
aplicativos nativos e da Web. Eles podem ser criados sem uma estrutura, mas algumas estruturas populares
a serem consideradas são Ionic e PhoneGap.
o PWAs pode ser instalado em um dispositivo (Android, iOS ou Windows) e pode trabalhar offline graças à
incorporação de um trabalhador de serviço.
O PWAs pode ser distribuído e instalado sem uma loja de aplicativos usando apenas uma URL da Web. o
Microsoft Store e Google Play Store permitir que PWAs sejam listados, a Apple Store atualmente não, embora
eles ainda possam ser instalados em qualquer dispositivo iOS executando o 12,2 ou posterior.
Para saber mais, Confira esta introdução ao PWAs no MDN.
Desenvolvimento de jogos
O desenvolvimento de jogos para Android é, muitas vezes, exclusivo do desenvolvimento de um aplicativo
Android padrão, já que os jogos normalmente usam lógica de renderização personalizada, geralmente escritas
em OpenGL ou Vulkan. por esse motivo, e devido às muitas bibliotecas C disponíveis que dão suporte ao
desenvolvimento de jogos, é comum que os desenvolvedores usem o C/C++ com o Visual Studio, juntamente
com o NDK (Kit de desenvolvimento nativo)do android, para criar jogos para Android. Introdução ao C/C++
para desenvolvimento de jogos.
Outro caminho comum para desenvolver jogos para Android é usar um mecanismo de jogo. há muitos
mecanismos gratuitos e de código-fonte aberto disponíveis, como o Unity com Visual Studio, mecanismo inreal,
monojogo com xamarin, UrhoSharp com xamarin, SkiaSharp com xamarin. Forms CocoonJS, App Game Kit,
Fusion, Corona SDK, ilhas 2d e muito mais.
Próximas etapas
Introdução ao desenvolvimento Android nativo no Windows
Comece a desenvolver para Android usando o Xamarin. Android
Comece a desenvolver para Android usando o Xamarin. Forms
Introdução ao desenvolvimento para Android usando o React Native
introdução ao desenvolvimento de um PWA para Android
Habilitar o suporte de virtualização para melhorar o desempenho do emulador
Introdução ao desenvolvimento Android nativo no
Windows
este guia vai ajudá-lo a começar a usar o Windows para criar aplicativos Android nativos. se você preferir uma
solução de plataforma cruzada, consulte visão geral do desenvolvimento do Android no Windows para obter
um breve resumo de algumas opções.
A maneira mais direta de criar um aplicativo Android nativo é usar o Android Studio com Java ou Kotlin, embora
também seja possível usar C ou C++ para desenvolvimento Android se você tiver uma finalidade específica. As
ferramentas SDK Android Studio compilam seu código, dados e arquivos de recurso em um pacote Android de
arquivo, arquivo. apk. Um arquivo APK contém todo o conteúdo de um aplicativo Android e é o arquivo que os
dispositivos com Android usam para instalar o aplicativo.
Instalar Android Studio

Android Studio é o ambiente de desenvolvimento integrado oficial para o sistema operacional Android do
Google. Baixe a versão mais recente do Android Studio para Windows.
Se você baixou um arquivo de .exe (recomendado), clique duas vezes para iniciá-lo.
Se você baixou um arquivo de .zip, descompacte o ZIP, copie a pasta Android-Studio na pasta arquivos de
programas e, em seguida, abra a pasta bin do Android-Studio > e inicie studio64.exe (para máquinas de 64
bits) ou studio.exe (para computadores de 32 bits).
Siga o assistente de instalação no Android Studio e instale os pacotes do SDK que ele recomenda. À medida que
novas ferramentas e outras APIs estiverem disponíveis, Android Studio o notificará com um pop-up ou
verificará se há atualizações selecionando ajuda > para atualização .
Criar um novo projeto

selecione arquivo > novo > Project .
Na janela escolher seu projeto , você poderá escolher entre esses modelos:
Atividade básica : cria um aplicativo simples com uma barra de aplicativos, um botão de ação flutuante
e dois arquivos de layout: um para a atividade e outro para separar o conteúdo de texto.
Atividade vazia : cria uma atividade vazia e um único arquivo de layout com conteúdo de texto de
exemplo.
Atividade de navegação inferior : cria uma barra de navegação inferior padrão para uma atividade.
Para obter mais informações sobre isso, consulte a seção componente de navegação inferior das
diretrizes de design de material do Google.
Os modelos são normalmente usados para adicionar atividades a módulos de aplicativo novos e
existentes. Por exemplo, para criar uma tela de logon para os usuários do seu aplicativo, adicione uma
atividade com o modelo de atividade de logon. Para saber mais sobre como selecionar uma atividade e
como adicionar código de um modelo, consulte Guia do desenvolvedor do Android pelo Google.
NOTE
O sistema operacional Android é baseado na ideia de componentes e usa a atividade de termos e a intenção de
definir interações. Uma atividade representa uma única tarefa focada que um usuário pode fazer. Uma atividade
fornece uma janela para criar a interface do usuário usando classes baseadas na classe View . Há um ciclo de vida para
atividades no sistema operacional Android, definido por seis retornos de chamada:,,,, onCreate() onStart()
onResume() onPause() onStop() e onDestroy() . Os componentes de atividade interagem uns com os outros
usando objetos de intenção . A intenção define a atividade para iniciar ou descreve o tipo de ação a ser executada (e o
sistema seleciona a atividade apropriada para você, que pode até mesmo ser de um aplicativo diferente). Saiba mais sobre
as atividades, o ciclo de vida da atividade e as intenções no Guia do desenvolvedor do Android pelo Google.
Java ou Kotlin
O Java tornou-se uma linguagem em 1991, desenvolvida pelo que era a Sun Microsystems, mas que agora
pertence à Oracle. Ele se tornou uma das linguagens de programação mais populares e poderosas com uma das
maiores comunidades de suporte do mundo. O Java é baseado em classe e orientado a objeto, projetado para
ter o menor número possível de dependências de implementação. A sintaxe é semelhante a C e C++, mas tem
menos instalações de nível baixo do que qualquer uma delas.
O Kotlin foi anunciado pela primeira vez como uma nova linguagem de software livre por JetBrains em 2011 e
foi incluído como uma alternativa ao Java em Android Studio desde 2017. Em maio de 2019, o Google anunciou
o Kotlin como seu idioma preferido para desenvolvedores de aplicativos Android, portanto, apesar de ser uma
linguagem mais nova, ele também tem uma comunidade de suporte forte e foi identificado como uma das
linguagens de programação cada vez mais crescentes. O Kotlin é de plataforma cruzada, digitada estaticamente
e projetada para interoperar totalmente com o Java.
O Java é mais amplamente usado para uma gama mais ampla de aplicativos e oferece alguns recursos que o
Kotlin não, como exceções marcadas, tipos primitivos que não são classes, membros estáticos, campos não
privados, tipos curinga e operadores ternários. O Kotlin é especificamente projetado para o e recomendado pelo
Android. Ele também oferece alguns recursos que o Java não, como referências nulas controladas pelo sistema
de tipos, sem tipos brutos, matrizes invariáveis, tipos de função apropriados (em oposição às conversões de
SAM do Java), use a variação de site sem curingas, difusões inteligentes e muito mais. Encontre uma visão mais
detalhada da comparação com Java na documentação do Kotlin.
Nível mínimo de API
Você precisará decidir o nível mínimo de API para seu aplicativo. Isso determina a qual versão do Android seu
aplicativo dará suporte. Níveis de API inferiores são mais antigos e, portanto, geralmente dão suporte a mais
dispositivos, mas níveis de API mais altos são mais recentes e, portanto, fornecem mais recursos.
Selecione o link ajude-me escolher para abrir um gráfico de comparação mostrando a distribuição de suporte
a dispositivos e os principais recursos associados à versão da plataforma.
Suporte a aplicativos instantâneos e artefatos Androidx
Você pode observar uma caixa de seleção para dar supor te a aplicativos instantâneos e outro para usar
ar tefatos androidx em suas opções de criação de projeto. O suporte aos aplicativos instantâneos não é
verificado e o androidx é verificado como o padrão recomendado.
Google Play aplicativos instantâneos fornecem uma maneira para as pessoas tentarem um aplicativo ou
jogo sem instalá-lo primeiro. Esses aplicativos instantâneos podem ser exibidos em toda a Play Store, Google
Search, redes sociais e em qualquer lugar que você compartilhar um link. Ao marcar a caixa supor te para
aplicativos instantâneos , você está solicitando que Android Studio inclua o SDK de desenvolvimento
instantâneo Google Play com seu projeto. Saiba mais sobre Google Play aplicativos instantâneos no Guia do
desenvolvedor do Android.
Os ar tefatos do AndroidX representam a nova versão da biblioteca de suporte do Android e fornecem
compatibilidade com versões anteriores do Android. AndroidX fornece um namespace consistente começando
com a cadeia de caracteres AndroidX para todos os pacotes disponíveis.
NOTE
AndroidX agora é a biblioteca padrão. Para desmarcar essa caixa e usar a biblioteca de suporte anterior requer a remoção
do último SDK do Android Q. Consulte desmarque usar artefatos Androidx em StackOverflow para obter instruções, mas
primeiro Observe que os pacotes de biblioteca de suporte anteriores foram mapeados nos pacotes Androidx. *
correspondentes. Para obter um mapeamento completo de todas as classes antigas e criar artefatos para os novos,
consulte migrando para o AndroidX.
Arquivos de projeto
a janela Android Studio Project , contém os seguintes arquivos (certifique-se de que a exibição do Android
esteja selecionada no menu suspenso):
aplicativo > Java > com. example. meuprimeiroapp > MainActivity
A atividade principal e o ponto de entrada para seu aplicativo. Quando você cria e executa seu aplicativo, o
sistema inicia uma instância dessa atividade e carrega seu layout.
> de layout de > res do aplicativo > activity_main.xml
O arquivo XML que define o layout da interface do usuário da atividade. Ele contém um elemento TextView com
o texto "Olá, Mundo"
> de manifestos do > de aplicativos AndroidManifest.xml
O arquivo de manifesto que descreve as características fundamentais do aplicativo e de cada um de seus
componentes.
Gradle scripts > Build. gradle
há dois arquivos com este nome: "Project: meu primeiro aplicativo", para todo o projeto e "módulo: aplicativo",
para cada módulo de aplicativo. Um novo projeto terá inicialmente apenas um módulo. Use o Build. File do
módulo para controlar como o plug-in gradle compila seu aplicativo. Saiba mais sobre como configurar sua
compilação no guia do desenvolvedor do Android.
Use C ou C++ para desenvolvimento de jogos Android

O sistema operacional Android foi projetado para dar suporte a aplicativos escritos em Java ou Kotlin,
beneficiando-se de ferramentas incorporadas na arquitetura do sistema. Muitos recursos do sistema, como a
interface do usuário do Android e o tratamento de intenções, são expostos apenas por meio de interfaces Java.
Há algumas instâncias em que você talvez queira usar código C ou C++ por meio do NDK (Kit de
desenvolvimento nativo) do Android , apesar de alguns dos desafios associados. O desenvolvimento de
jogos é um exemplo, já que os jogos normalmente usam lógica de renderização personalizada escrita em
OpenGL ou Vulkan e se beneficiam de uma infinidade de bibliotecas C focadas no desenvolvimento de jogos.
Usar C ou C++ também pode ajudá-lo a compactar o desempenho extra de um dispositivo para obter baixa
latência ou executar aplicativos de computação intensiva, como simulações de física. No entanto, o NDK não é
apropriado para a maioria dos programadores Android iniciantes . A menos que você tenha uma
finalidade específica para usar o NDK, é recomendável ficar com Java, Kotlin ou uma das estruturas de
plataforma cruzada.
Para criar um novo projeto com suporte a C/C++:
Na seção escolher seu projeto do assistente de Android Studio, selecione o tipo de projeto C++ *
nativo. Selecione Avançar , preencha os campos restantes e, em seguida, selecione Avançar novamente.
Na seção Personalizar supor te a c++ do assistente, você pode personalizar seu projeto com o campo
padrão do c++ . Use a lista suspensa para selecionar a padronização do C++ que você deseja usar. A
seleção de ferramentas padrão usa a configuração padrão de CMake. Selecione Concluir .
uma vez que Android Studio cria seu novo projeto, você pode encontrar uma pasta cpp no painel
Project que contém os arquivos de origem nativos, os cabeçalhos, os scripts de compilação para CMake
ou ndk-build, e bibliotecas predefinidas que fazem parte do seu projeto. Você também pode encontrar
um arquivo de origem C++ de exemplo, native-lib.cpp , na src/main/cpp/ pasta que fornece uma
stringFromJNI() função simples que retorna a cadeia de caracteres "Olá de C++". Além disso, você deve
ver um script de Build CMakeLists.txt do cmake,, no diretório raiz do seu módulo, necessário para criar
sua biblioteca nativa.
Para saber mais, sobre como adicionar código C e C++ ao seu projeto, consulte o Guia do desenvolvedor do
Android. Para localizar exemplos do Android NDK com a integração do C++, consulte o repositório de exemplos
do Android NDK em github. Para compilar e executar um jogo C++ no Android, use a API de serviços de jogos
Google Play.
Diretrizes de design
Os usuários do dispositivo esperam que os aplicativos pareçam e se comportem de uma determinada maneira...
seja passando o dedo ou tocando ou usando controles de voz, os usuários terão expectativas específicas sobre o
que o aplicativo deve ter e como usá-lo. Essas expectativas devem permanecer consistentes para reduzir a
confusão e a frustração. O Android oferece um guia para essas expectativas de plataforma e dispositivo que
combina a base de design do Google material para Visual e padrões de navegação, juntamente com diretrizes
de qualidade para compatibilidade, desempenho e segurança.
Saiba mais na documentação de design do Android.
Sistema Fluent Design para Android
A Microsoft também oferece diretrizes de design com o objetivo de fornecer uma experiência integrada em todo
o portfólio de aplicativos móveis da Microsoft.
Sistema Fluent Design para o Design do Android e criar aplicativos personalizados que são nativamente
Android, enquanto ainda Fluent com exclusividade.
Kit de ferramentas do Sketch
Kit de ferramentas do Figma
Fonte do Android
Diretrizes de interface do usuário do Android
Diretrizes para ícones de aplicativos Android
Recursos adicionais
Conceitos básicos do aplicativo Android
Começar a desenvolver para Android usando o
Xamarin.Android
Este guia ajudará você a começar a usar o Xamarin.Android Windows criar um aplicativo de plataforma cruzada
Neste artigo, você criará um aplicativo Android simples usando xamarin.Android e Visual Studio 2019.
Requisitos
Para usar este tutorial, você precisará do seguinte:
Windows 10
Visual Studio 2019: Community, Professional ou Enterprise (consulte a observação)
A carga de trabalho "Desenvolvimento móvel com .NET" para Visual Studio 2019
NOTE
Este guia funcionará com Visual Studio 2017 ou 2019. Se você estiver usando o Visual Studio 2017, algumas instruções
poderão estar incorretas devido a diferenças de interface do usuário entre as duas versões do Visual Studio.
Você também terá um telefone Android ou emulador configurado no qual executar seu aplicativo. Consulte
Configurando um android emulador.
Criar um projeto Xamarin.Android

Inicie o Visual Studio. Selecione Arquivo > Novo > Project para criar um novo projeto.
Na caixa de diálogo novo projeto, selecione o modelo aplicativo Android (Xamarin) e clique em Próximo.
Nomeia o projeto TimeChangerAndroid e clique em Criar .
Na caixa de diálogo Novo Aplicativo de Plataforma Cruzada, selecione Aplicativo em Branco . Na Versão
Mínima do Android, selecione Android 5.0 (Lollipop). Clique em OK .
O Xamarin criará uma nova solução com um único projeto chamado TimeChangerAndroid.
Criar uma interface do usuário com XAML

No diretório Resources\layout do seu projeto, abra activity_main.xml . O XML nesse arquivo define a
primeira tela que um usuário verá ao abrir o TimeChanger.
A interface do usuário do TimeChanger é simples. Ele exibe a hora atual e tem botões para ajustar a hora em
incrementos de uma hora. Ele usa um vertical para alinhar o tempo acima dos botões e um horizontal para
organizar os botões lado a LinearLayout LinearLayout lado. O conteúdo é centralizado na tela definindo o
atributo android:gravity para centralizar no LinearLayout vertical.
Substitua o conteúdo de activity_main.xml pelo código a seguir.
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="At runtime, I will display current time"
android:id="@+id/timeDisplay"
/>
<LinearLayout
android:orientation="horizontal">
<Button
android:text="Up"
android:id="@+id/upButton"/>
<Button
android:text="Down"
android:id="@+id/downButton"/>
</LinearLayout>
</LinearLayout>
Neste ponto, você pode executar TimeChangerAndroid e ver a interface do usuário que você criou. Na
próxima seção, você adicionará funcionalidade à interface do usuário exibindo a hora atual e habilitando os
botões para executar uma ação.
Adicionar código lógico com C

Abra o MainActivity.cs . Esse arquivo contém a lógica code-behind que adicionará funcionalidade à interface do
usuário.
Definir a hora atual
Primeiro, obter uma referência ao TextView que exibirá a hora. Use FindViewById para pesquisar todos os
elementos da interface do usuário para aquele com o android:id correto (que foi definido como no
"@+id/timeDisplay" xml da etapa anterior). Esse é o TextView que exibirá a hora atual.
var timeDisplay = FindViewById<TextView>(Resource.Id.timeDisplay);
Os controles de interface do usuário devem ser atualizados no thread da interface do usuário. As alterações
feitas de outro thread podem não atualizar corretamente o controle conforme ele é exibido na tela. Como não
há nenhuma garantia de que esse código sempre será executado no thread da interface do usuário, use o
método RunOnUiThread para garantir que as atualizações sejam exibidas corretamente. Este é o método
UpdateTimeLabel completo.
private void UpdateTimeLabel(object state = null)
{
RunOnUiThread(() =>
{
TimeDisplay.Text = DateTime.Now.ToLongTimeString();
});
}
Atualizar a hora atual uma vez a cada segundo

Neste ponto, a hora atual será precisa para, no máximo, um segundo depois que TimeChangerAndroid for
lançado. O rótulo deve ser atualizado periodicamente para manter o tempo preciso. Um objeto Timer chamará
periodicamente um método de retorno de chamada que atualiza o rótulo com a hora atual.
var clockRefresh = new Timer(dueTime: 0, period: 1000, callback: UpdateTimeLabel, state: null);
Adicionar HourOffset
Os botões para cima e para baixo ajustam o tempo em incrementos de uma hora. Adicione uma propriedade
HourOffset para acompanhar o ajuste atual.
public int HourOffset { get; private set; }
Agora atualize o método UpdateTimeLabel para estar ciente da propriedade HourOffset.
TimeDisplay.Text = DateTime.Now.AddHours(HourOffset).ToLongTimeString();
Criar o botão Clicar manipuladores de eventos

Todos os botões para cima e para baixo precisam fazer é incrementar ou decrementar a propriedade HourOffset
e chamar UpdateTimeLabel.
public void UpButton_Click(object sender, System.EventArgs e)

{
HourOffset++;
UpdateTimeLabel();
}
Ligar os botões para cima e para baixo para seus manipuladores de eventos correspondentes
Para associar os botões aos manipuladores de eventos correspondentes, primeiro use FindViewById para
encontrar os botões por suas IDs. Depois de ter uma referência ao objeto de botão, você pode adicionar um
manipulador de eventos ao seu Click evento.
Button upButton = FindViewById<Button>(Resource.Id.upButton);

upButton.Click += UpButton_Click;
Arquivo MainActivity.cs concluído

Quando você terminar, MainActivity.cs deverá ter esta aparência:
using Android.App;
using Android.OS;
using Android.Support.V7.App;
using Android.Runtime;
using Android.Widget;
using System;
using System.Threading;
namespace TimeChangerAndroid
{
[Activity(Label = "@string/app_name", Theme = "@style/AppTheme", MainLauncher = true)]
public class MainActivity : AppCompatActivity
{
public TextView TimeDisplay { get; private set; }
protected override void OnCreate(Bundle savedInstanceState)

{
base.OnCreate(savedInstanceState);
// Set the view from the "main" layout resource

SetContentView(Resource.Layout.activity_main);
Button upButton = FindViewById<Button>(Resource.Id.upButton);

upButton.Click += OnUpButton_Click;
Button downButton = FindViewById<Button>(Resource.Id.downButton);

downButton.Click += OnDownButton_Click;
TimeDisplay = FindViewById<TextView>(Resource.Id.timeDisplay);
}

{
// Timer callbacks run on a background thread, but UI updates must run on the UI thread.
RunOnUiThread(() =>
{
TimeDisplay.Text = DateTime.Now.AddHours(HourOffset).ToLongTimeString();
});
}
public void OnUpButton_Click(object sender, System.EventArgs e)

{
HourOffset++;
UpdateTimeLabel();
}
public void OnDownButton_Click(object sender, System.EventArgs e)

{
HourOffset--;
UpdateTimeLabel();
}
}
}
Executar o aplicativo
Para executar o aplicativo, pressione F5 ou clique em Depurar > Iniciar Depuração. Dependendo de como o
depurador está configurado,seu aplicativo será lançado em um dispositivo ou em um emulador.
Links relacionados
Teste em um dispositivo Android ou emulador.
Criar um aplicativo de exemplo do Android usando o Xamarin.Forms
Começar a desenvolver para Android usando o
Xamarin.Forms
Este guia ajudará você a começar a usar o Xamarin.Forms no Windows para criar um aplicativo de plataforma
cruzada que funcionará em dispositivos Android.
Neste artigo, você criará um aplicativo Android simples usando o Xamarin.Forms e Visual Studio 2019.
Requisitos
Para usar este tutorial, você precisará do seguinte:
Windows 10
Visual Studio 2019: Community, Professional ou Enterprise (consulte a observação)
A carga de trabalho "Desenvolvimento móvel com .NET" para Visual Studio 2019
NOTE
Este guia funcionará com o Visual Studio 2017 ou 2019. Se você estiver usando o Visual Studio 2017, algumas instruções
poderão estar incorretas devido a diferenças de interface do usuário entre as duas versões do Visual Studio.
Você também terá um telefone Android ou emulador configurado no qual executar seu aplicativo. Consulte
Testar em um dispositivo Android ou emulador.
Criar um novo projeto do Xamarin.Forms

Inicie o Visual Studio. Clique em > Novo > Project para criar um novo projeto.
Na caixa de diálogo novo projeto, selecione o modelo Aplicativo Móvel (Xamarin.Forms) e clique em
Próximo.
Nomeia o projeto TimeChangerForms e clique em Criar .
Na caixa de diálogo Novo Aplicativo de Plataforma Cruzada, selecione Em Branco. Na seção Plataforma,
marque Android e descons marque todas as outras caixas. Clique em OK .
O Xamarin criará uma nova solução com dois projetos: TimeChangerForms e TimeChangerForms.Android.
Criar uma interface do usuário com XAML

Expanda o projeto TimeChangerForms e abra MainPage.xaml. O XAML nesse arquivo define a primeira
tela que um usuário verá ao abrir o TimeChanger.
A interface do usuário do TimeChanger é simples. Ele exibe a hora atual e tem botões para ajustar a hora em
incrementos de uma hora. Ele usa um StackLayout vertical para alinhar o tempo acima dos botões e um
StackLayout horizontal para organizar os botões lado a lado. O conteúdo é centralizado na tela definindo
HorizontalOptions e Ver ticalOptions do StackLayout vertical como "CenterAndExpand".
Substitua o conteúdo de MainPage.xaml pelo código a seguir.
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:d="http://xamarin.com/schemas/2014/forms/design"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
x:Class="TimeChangerForms.MainPage">
<StackLayout HorizontalOptions="CenterAndExpand"
VerticalOptions="CenterAndExpand">
<Label x:Name="time"
HorizontalOptions="CenterAndExpand"
VerticalOptions="CenterAndExpand"
Text="At runtime, this Label will display the current time.">
</Label>
<StackLayout Orientation="Horizontal">
<Button HorizontalOptions="End"
VerticalOptions="End"
Text="Up"
Clicked="OnUpButton_Clicked"/>
<Button HorizontalOptions="Start"
VerticalOptions="End"
Text="Down"
Clicked="OnDownButton_Clicked"/>
</StackLayout>
</StackLayout>
</ContentPage>
Neste ponto, a interface do usuário está concluída. No entanto, TimeChangerForms não será construído porque
os métodos UpButton_Clicked e DownButton_Clicked são referenciados no XAML, mas não definidos em
nenhum lugar. Mesmo que o aplicativo tenha sido executado, a hora atual não será exibida. Na próxima seção,
você corrigirá esses erros e adicionará funcionalidade à interface do usuário.
Adicionar código lógico com C

No Gerenciador de Soluções, clique com o botão direito do mouse em MainPage.xaml e clique em Exibir
Código . Esse arquivo contém o código por trás que adicionará a funcionalidade à interface do usuário.
Definir a hora atual
O código nesse arquivo pode referenciar controles declarados no XAML usando o valor do atributo x:Name do
controle. Nesse caso, o rótulo que exibe a hora atual é chamado time .
Os controles de interface do usuário devem ser atualizados no thread principal. As alterações feitas de outro
thread podem não atualizar corretamente o controle conforme ele é exibido na tela. Como não há nenhuma
garantia de que esse código sempre será executado no thread principal, use o método
BeginInvokeOnMainThread para garantir que as atualizações sejam exibidas corretamente. Aqui está o
método UpdateTimeLabel completo.

{
Device.BeginInvokeOnMainThread(() =>
{
time.Text = DateTime.Now.ToLongTimeString();
}
);
}
Atualizar a hora atual uma vez a cada segundo

Neste ponto, a hora atual será precisa para, no máximo, um segundo depois que TimeChangerForms for
lançado. O rótulo deve ser atualizado periodicamente para manter o tempo preciso. Um objeto Timer chamará
periodicamente um método de retorno de chamada que atualiza o rótulo com a hora atual.
Adicionar HourOffset
Os botões para cima e para baixo ajustam o tempo em incrementos de uma hora. Adicione uma propriedade
HourOffset para acompanhar o ajuste atual.
Agora atualize o método UpdateTimeLabel para estar ciente da propriedade HourOffset.
currentTime.Text = DateTime.Now.AddHours(HourOffset).ToLongTimeString();
Adicionar botão Clique em manipuladores de eventos

Todos os botões para cima e para baixo precisam fazer é incrementar ou decrementar a propriedade HourOffset
e chamar UpdateTimeLabel.
private void UpButton_Clicked(object sender, EventArgs e)

{
HourOffset++;
UpdateTimeLabel();
}
Quando terminar, MainPage.xaml.cs deverá ter esta aparência:

using System;
using System.ComponentModel;
using System.Threading;
using Xamarin.Forms;
namespace TimeChangerForms
{
// Learn more about making custom code visible in the Xamarin.Forms previewer
// by visiting https://aka.ms/xamarinforms-previewer
[DesignTimeVisible(false)]
public partial class MainPage : ContentPage
{
public MainPage()
{
InitializeComponent();
}
protected override void OnAppearing()

{
base.OnAppearing();
}

{
Device.BeginInvokeOnMainThread(() =>
{
time.Text = DateTime.Now.AddHours(HourOffset).ToLongTimeString();
}
);
}
private void OnUpButton_Clicked(object sender, EventArgs e)

{
HourOffset++;
UpdateTimeLabel();
}
private void OnDownButton_Clicked(object sender, EventArgs e)

{
HourOffset--;
UpdateTimeLabel();
}
}
}
Executar o aplicativo
Para executar o aplicativo, pressione F5 ou clique em Depurar > Iniciar Depuração. Dependendo de como o
depurador está configurado,seu aplicativo será lançado em um dispositivo ou em um emulador.
Links relacionados
Teste em um dispositivo Android ou emulador.
Criar um aplicativo de exemplo do Android usando o Xamarin.Android
Introdução ao desenvolvimento para Android
usando o React Native
Este guia ajudará você a começar a usar o React Native no Windows para criar um aplicativo multiplataforma
Visão geral
Comece a usar o React Native instalando as ferramentas necessárias

1. Instale o Visual Studio Code (ou o editor de códigos de sua preferência).
2. Instalar o Android Studio para Windows. Por padrão, o Android Studio instala o último SDK do Android. O
React Native exige o SDK do Android 6.0 (Marshmallow) ou superior. Recomendamos usar o último SDK.
3. Crie caminhos de variável de ambiente para o SDK do Java e o SDK do Android:
No menu de pesquisa do Windows, insira: "Editar as variáveis de ambiente do sistema". Isso abrirá a
janela Propriedades do Sistema .
Escolha Variáveis de Ambiente… e Novo… em Variáveis de usuário .
Insira o nome da variável e o valor (caminho). Os caminhos padrão para os SDKs do Java e do
Android são mostrados a seguir. Se você tiver escolhido uma localização específica para instalar os
SDKs do Java e do Android, atualize os caminhos de variável de acordo.
JAVA_HOME: C:\Arquivos de Programas\Android\Android Studio\jre\jre
ANDROID_HOME: C:\Users\username\AppData\Local\Android\Sdk
4. Instalar o NodeJS para Windows O ideal é considerar o uso do nvm (Gerenciador de Versão do Node)
para Windows se você está trabalhando com vários projetos e a versão do NodeJS. Recomendamos
instalar a última versão do LTS para novos projetos.
NOTE
O ideal também é instalar e usar o Terminal do Windows para trabalhar com sua CLI (interface de linha de comando)
preferida, bem como o Git para o controle de versão. O JDK do Java vem empacotado com o Android Studio v2.2 e
posterior, mas se você precisar atualizar o JDK separadamente do Android Studio, use o Windows x64 Installer.
Criar um projeto com o React Native

1. Use o npx, a ferramenta de executor de pacote que é instalada com o npm , para criar um projeto do
React Native. no prompt de comando do Windows, no PowerShell, no Terminal do Windows ou no
terminal integrado do VS Code (Exibir > Terminal Integrado).
npx react-native init MyReactNativeApp
2. Abra o novo diretório "MyReactNativeApp":
cd MyReactNativeApp
3. Se você quiser executar o projeto em um dispositivo Android de hardware, conecte o dispositivo ao

computador com um cabo USB.
4. Se quiser executar seu projeto em um Android Emulator, você não precisará realizar nenhuma ação, pois
o Android Studio é instalado com um emulador padrão. Caso deseje executar seu aplicativo no emulador
para um dispositivo específico. Clique no botão Gerenciador de AVD na barra de ferramentas.
.
5. Para executar o projeto, insira o comando a seguir. Isso abrirá uma nova janela de console exibindo o
Node Metro Bundler.
npx react-native run-android

NOTE
Se você estiver usando uma nova instalação do Android Studio e ainda não tiver feito nenhum outro
desenvolvimento no Android, poderá receber erros na linha de comando ao executar o aplicativo sobre como
aceitar licenças para o SDK do Android. Como "Aviso: licença para o pacote do SDK do Android Plataforma 29 não
aceita". Para resolver isso, clique no botão Gerenciador de SDK no Android Studio. . Ou, então, você
pode listar e aceitar as licenças com o comando a seguir, lembrando-se de usar o caminho para a localização do
SDK no computador.
C:\Users\[User Name]\AppData\Local\Android\Sdk\tools\bin\sdkmanager --licenses
6. Para modificar o aplicativo, abra o diretório do projeto MyReactNativeApp no IDE de sua preferência.
Recomendamos usar o VS Code ou o Android Studio.
7. O modelo de projeto criado pelo react-native init usa uma página principal chamada App.js . Essa
página é pré-preenchida com muitos links úteis para informações sobre o desenvolvimento do React
Native. Adicione um texto ao primeiro elemento de Texto , como a cadeia de caracteres "OLÁ, MUNDO!"
mostrada abaixo.
<Text style={styles.sectionDescription}>
Edit <Text style={styles.highlight}>App.js</Text> to change this
screen and then come back to see your edits. HELLO WORLD!
</Text>
8. Recarregue o aplicativo para mostrar as alterações feitas. Há várias maneiras de fazer isso.
Na janela do console do Metro Bundler, digite "r".
No emulador de dispositivo do Android, toque duas vezes em "r" no teclado.
Em um dispositivo Android de hardware, agite o dispositivo para abrir o menu de depuração do React
Native e selecione 'Recarregar'.
Recursos adicionais
Habilitar o suporte de virtualização para aprimorar o desempenho do Emulador
Começar a desenvolver um aplicativo Web PWA ou
Híbrido para Android
Este guia ajudará você a começar a criar um aplicativo Web híbrido ou aplicativo Web progressivo (PWA) no
Windows usando uma única base de código HTML/CSS/JavaScript que pode ser usada na Web e em
plataformas de dispositivo (Android, iOS, Windows).
Usando as estruturas e os componentes corretos, os aplicativos baseados na Web podem funcionar em um
dispositivo Android de uma maneira que pareça aos usuários muito semelhante a um aplicativo nativo.
Recursos de um aplicativo Web PWA ou Híbrido

Há dois tipos principais de aplicativos Web que podem ser instalados em dispositivos Android. A principal
diferença é se o código do aplicativo é inserido em um pacote de aplicativos (híbrido) ou hospedado em um
servidor Web (pwa).
Aplicativos Web híbridos: o código (HTML, JS, CSS) é empacotado em um APK e pode ser distribuído
por meio do Google Play Store. O mecanismo de exibição é isolado do navegador da Internet dos
usuários, sem sessão ou compartilhamento de cache.
PWAs (Aplicativos Web Progressivos) : o código (HTML, JS, CSS) reside na Web e não precisa ser
empacotado como um APK. Os recursos são baixados e atualizados conforme necessário usando um
Service Worker. O navegador Chrome renderizará e exibirá seu aplicativo, mas será nativo e não incluirá
a barra de endereços normal do navegador etc. Você pode compartilhar armazenamento, cache e sessões
com o navegador. Isso é basicamente como instalar um atalho para o navegador Chrome em um modo
especial. PWAs também podem ser listados no Google Play Store atividade da Web confiável.
PWAs e aplicativos Web híbridos são muito semelhantes a um aplicativo Android nativo, já que eles:
Pode ser instalado por meio do App Store (Google Play Store e/ou Microsoft Store)
Ter acesso a recursos de dispositivo nativo, como câmera, GPS, Bluetooth, notificações e lista de contatos
Trabalhar offline (sem conexão com a Internet)
Os PWAs também têm alguns recursos exclusivos:
Pode ser instalado na tela inicial do Android diretamente da Web (sem um App Store)
Além disso, pode ser instalado por meio do Google Play Store usando uma Atividade da Web Confiável
Pode ser descoberto por meio da pesquisa na Web ou compartilhado por meio de um link de URL
Contar com um Service Worker para evitar a necessidade de empacotar código nativo
Você não precisa de uma estrutura para criar um aplicativo híbrido ou um PWA, mas há algumas estruturas
populares que serão abordadas neste guia, incluindo PhoneGap (com Cordova) e Ionic (com Cordova ou Ltda
usando Angular ou React).
Apache Cordova
Apache Cordova é uma estrutura de código-fonte aberto que pode simplificar a comunicação entre o código
JavaScript que está morando em um WebView nativo e a plataforma Android nativa usando plug-ins. Esses
plug-ins expõem pontos de extremidade JavaScript que podem ser chamados do seu código e usados para
chamar APIs de dispositivo Android nativas. Alguns plug-ins cordova de exemplo incluem o acesso aos serviços
de dispositivo, como status da bateria, acesso ao arquivo, vibração/tom de anel, etc. Esses recursos
normalmente não estão disponíveis para aplicativos Web ou navegadores.
Há duas distribuições populares do Cordova:
PhoneGap:o suporte foi descontinuado pela Adobe.
Ionic
Ionic
O Ionic é uma estrutura que ajusta a interface do usuário do seu aplicativo para corresponder à linguagem de
design de cada plataforma (Android, iOS, Windows). O Ionic permite que você use Angular ou React.
NOTE
Há uma nova versão do Ionic que usa uma alternativa ao Cordova, chamada Def. Essa alternativa usa contêineres para
tornar seu aplicativo mais amigável para a Web.
Começar a trabalhar com o Ionic instalando as ferramentas necessárias

Para começar a criar um aplicativo Web PWA ou híbrido com o Ionic, primeiro instale as seguintes ferramentas:
Node.js para interagir com o ecossistema Iônico. Baixe NodeJS para Windows ou siga o guia de
instalação do NodeJS usando Subsistema do Windows para Linux (WSL). Talvez você queira considerar o
uso do NVM (Gerenciador de Versões do Node) se estiver trabalhando com vários projetos e a versão do
NodeJS.
VS Code para escrever seu código. Baixe VS Code para Windows. Talvez você também queira instalar a
Extensão Remota do WSL se preferir criar seu aplicativo com uma linha de comando do Linux.
Terminal do Windows para trabalhar com sua CLI (interface de linha de comando) preferencial. Instale
Terminal do Windows do Microsoft Store.
Git para controle de versão. Baixe o Git.
Criar um novo projeto com ionic Cordova e Angular

Instale o Ionic e o Cordova inserindo o seguinte na linha de comando:
npm install -g @ionic/cli cordova
Crie um aplicativo de Angular Ionic usando o modelo de aplicativo "Guias" inserindo o comando :
ionic start photo-gallery tabs
Altere para a pasta do aplicativo:
cd photo-gallery
Execute o aplicativo em seu navegador da Web:
ionic serve
Para obter mais informações, consulte a documentação do Angular Ionic Cordova. Visite a seção Tornando seu
aplicativo Angular um PWA dos documentos Ionic para saber como mover seu aplicativo de um aplicativo
híbrido para um PWA.
Criar um novo projeto com Ionic Ltda e Angular

Instale o Ionic e Cordova-Res inserindo o seguinte na linha de comando:
npm install -g @ionic/cli native-run cordova-res
Crie um aplicativo de Angular Ionic usando o modelo de aplicativo "Guias" e adicione oPhone inserindo o
comando :
ionic start photo-gallery tabs --type=angular --capacitor
cd photo-gallery
Adicione componentes para tornar o aplicativo um PWA:
npm install @ionic/pwa-elements
Importe @ionic/pwa-elements adicionando o seguinte ao src/main.ts arquivo:
import { defineCustomElements } from '@ionic/pwa-elements/loader';
// Call the element loader after the platform has been bootstrapped
defineCustomElements(window);
ionic serve
Para obter mais informações, consulte a documentação do Ionic Angular. Visite a seção Tornando seu aplicativo
Angular um PWA dos documentos Ionic para saber como mover seu aplicativo de um aplicativo híbrido para
um PWA.
Criar um novo projeto com ionic e React

Instale a CLI do Ionic inserindo o seguinte na linha de comando:
npm install -g @ionic/cli
Crie um novo projeto com React inserindo o comando :
ionic start myApp blank --type=react

cd myApp
ionic serve
Para obter mais informações, consulte a documentação React Ionic. Visite a seção Tornando seu aplicativo React
um PWA dos documentos Ionic para saber como mover seu aplicativo de um aplicativo híbrido para um PWA.
Testar seu aplicativo Ionic em um dispositivo ou emulador

Para testar seu aplicativo Ionic em um dispositivo Android, conecte seu dispositivo(certifique-se de que ele está
habilitado primeiro para desenvolvimento ), em seguida, na linha de comando, insira:
ionic cordova run android
Para testar seu aplicativo Ionic em um emulador de dispositivo Android, você deve:
1. Instale os componentes necessários – JDK (Java Development Kit), Gradle e o SDK do Android.
2. Criar um AVD (Dispositivo Virtual Android): consulte o Guia do desenvolvedor do Android .
3. Insira o comando para que o Ionic crie e implante seu aplicativo no emulador:
ionic cordova emulate [<platform>] [options] . Nesse caso, o comando deve ser:
ionic cordova emulate android --list
Confira a documentação Emulator Cordova nos documentos do Ionic para obter mais informações.
Recursos adicionais
Habilitar o suporte à virtualização para melhorar o desempenho do emulador
adicionar exceções de Windows Defender para
acelerar o desempenho de build do Android
este guia aborda como configurar exclusões em suas Windows Defender configurações de segurança para
melhorar os tempos de compilação ao desenvolver aplicativos Android usando uma máquina Windows.
Windows Defender Sobre

no Windows 10, versão 1703 e posterior, o aplicativo Windows Defender Antivírus faz parte do Segurança do
Windows. Windows Defender tem o objetivo de manter seu computador seguro com proteção interna em
tempo real contra vírus, ransomware, spyware e outras ameaças à segurança.
no entanto , a proteção em tempo real do Windows Defender também diminuirá drasticamente o acesso ao
sistema de arquivos e a velocidade de compilação ao desenvolver aplicativos Android.
Durante o processo de compilação do Android, muitos arquivos são criados em seu computador. Com a
verificação de antivírus em tempo real habilitada, o processo de compilação será interrompido toda vez que um
novo arquivo for criado enquanto o antivírus verificar esse arquivo.
felizmente, Windows Defender tem a capacidade de excluir arquivos, diretórios de projeto ou tipos de arquivos
que você sabe que são seguros do processo de verificação antivírus.
WARNING
para garantir que seu computador esteja protegido contra software mal-intencionado, você não deve desabilitar
completamente a verificação em tempo real ou o software antivírus Windows Defender. Definir exclusões reduz a proteção
oferecida pelo defender. Você sempre deve avaliar os riscos associados à implementação de exclusões e excluir somente os
arquivos que você tem certeza de que não são mal-intencionados.
Como adicionar exclusões a Windows Defender

para adicionar exclusões na central de segurança do Windows Defender:
1. selecione o botão iniciar do menu de Windows
2. inserir Segurança do Windows
3. Selecionar proteção contra vírus e ameaças
4. Selecione gerenciar configurações em vírus & ameaças proteção configurações
5. Role até o cabeçalho exclusões e selecione Adicionar ou remover exclusões
6. Selecione + Adicionar uma exclusão . Em seguida, será necessário escolher se a exclusão que você deseja
adicionar é um arquivo , uma pasta , um tipo de arquivo ou um processo .
Exclusões a serem consideradas para o desenvolvimento do Android
a lista a seguir mostra o local padrão de cada diretório de Android Studio que pode ser adicionado como uma
exclusão de Windows Defender verificação em tempo real:
Cache gradle: %USERPROFILE%\.gradle
Projetos de Android Studio: %USERPROFILE%\AndroidStudioProjects
SDK do Android: %USERPROFILE%\AppData\Local\Android\SDK
Android Studio arquivos do sistema: %USERPROFILE%\.AndroidStudio<version>\system
esses locais de diretório podem não se aplicar ao seu projeto se você não tiver usado os locais padrão definidos
por Android Studio ou se tiver baixado um projeto do GitHub (por exemplo). Considere adicionar uma exclusão
ao diretório do seu projeto de desenvolvimento Android atual, onde quer que possa estar localizado.
As exclusões adicionais que talvez você queira considerar incluem:
processo de ambiente de desenvolvimento de Visual Studio: devenv.exe
processo de compilação de Visual Studio: msbuild.exe
Diretório JetBrains: %LOCALAPPDATA%\JetBrains\<Transient directory (folder)>
Para obter mais informações sobre como adicionar exclusões de verificação antivírus, incluindo como
personalizar locais de diretório para ambientes Política de Grupo controlados, consulte a seção impacto sobre o
antivírus da documentação do Android Studio.
Lembre-se de que a adição de exclusões reduz a proteção oferecida pelo defender. Você sempre deve avaliar os
riscos associados à implementação de exclusões e excluir somente os arquivos que você tem certeza de que não
são mal-intencionados.
NOTE
Daniel Knoodle configurou um repositório de GitHub com scripts recomendados para adicionar Windows Defender
exclusões para Visual Studio 2017.
Recursos adicionais
Testar em um dispositivo Android ou emulador
Há várias maneiras de testar e depurar seu aplicativo Android usando um dispositivo ou emulador real em seu
Windows computador. Descrevemos algumas recomendações neste guia.
Executar em um dispositivo Android real

Para executar seu aplicativo em um dispositivo Android real, primeiro você precisará habilitar seu dispositivo
Android para desenvolvimento. As opções de desenvolvedor no Android estão ocultas por padrão desde a
versão 4.2 e habilita-las pode variar com base na versão do Android.
Habilitar seu dispositivo para desenvolvimento
Para um dispositivo que executa uma versão recente do Android 9.0+:
1. Conexão seu dispositivo em seu computador Windows de desenvolvimento com um cabo USB. Você pode
receber uma notificação para instalar um driver USB.
2. Abra a Configurações no dispositivo Android.
3. Selecione Sobre telefone .
4. Role até a parte inferior e toque em Número de build sete vezes, até Que agora você seja um
desenvolvedor! está visível.
5. Retorne à tela anterior e selecione Sistema .
6. Selecione Avançado, role até a parte inferior e toque em Opções do desenvolvedor.
7. Na janela Opções do desenvolvedor, role para baixo para encontrar e habilitar a depuração de USB.
Para um dispositivo que executa uma versão mais antiga do Android, consulte Configurar o dispositivo para
desenvolvimento.
Executar seu aplicativo no dispositivo
1. Na barra Android Studio de ferramentas, selecione seu aplicativo no menu suspenso Configurações de
execução.
2. No menu suspenso do dispositivo de destino, selecione o dispositivo em que você deseja executar seu
aplicativo.
3. Selecione Executar ▷. Isso iniciará o aplicativo em seu dispositivo conectado.
Executar seu aplicativo em um dispositivo Android virtual usando um

emulador
A primeira coisa a saber sobre como executar um android emulador em seu computador Windows é que,
independentemente do seu IDE (Android Studio, Visual Studio etc.), o desempenho do emulador é muito
melhorado habilitando o suporte à virtualização.
Habilitar o suporte à virtualização
Antes de criar um dispositivo virtual com o Android Emulator, é recomendável habilitar a virtualização ativando
os recursos hyper-V e WHPX (plataforma de hipervisor do Windows). Isso permitirá que o processador do
computador melhore significativamente a velocidade de execução do emulador.
Para executar o Hyper-V e Windows Hypervisor Platform, seu computador deve:

Ter 4 GB de memória disponível
Ter um processador Intel de 64 bits ou CPU AMD Ryzen com SLAT (Conversão de Endereços de Segundo
Nível)
Estar executando Windows 10 build 1803+ (Verifique o build #)
Ter drivers gráficos atualizados (Gerenciador de Dispositivos > adaptadores de exibição > Driver de
atualização)
Se o computador não se ajustar a esses critérios, você poderá executar o Intel HAXM ou o Hipervisor AMD.
Para obter mais informações, consulte o artigo: Aceleração de hardware para desempenho do emulador ou
a documentação Android Studio Emulator do .
1. Verifique se o hardware e o software do computador são compatíveis com o Hyper-V abrindo um prompt
de comando e inserindo o comando : systeminfo
2. Na caixa Windows de pesquisa (inferior esquerdo), insira "recursos do Windows". Selecione Ativar ou
Windows recursos nos resultados da pesquisa.
3. Depois que a lista Windows Recursos do Windows for exibida, role até encontrar o Hyper-V (inclui as
Ferramentas de Gerenciamento e a Plataforma) e Windows Plataforma de Hiper visor , verifique se a
caixa está marcada para habilitar ambos e selecione OK.
4. Reinicie o computador quando solicitado.
Emulator desenvolvimento nativo com Android Studio
Ao criar e testar um aplicativo Android nativo, é recomendável usar Android Studio. Quando o aplicativo estiver
pronto para teste, você poderá criar e executar seu aplicativo:
1. Na barra Android Studio de ferramentas, selecione seu aplicativo no menu suspenso Configurações de
execução.
2. No menu suspenso do dispositivo de destino, selecione o dispositivo em que você deseja executar seu
aplicativo.
3. Selecione Executar ▷. Isso iniciará o android Emulator.
TIP
Depois que o aplicativo for instalado no dispositivo emulador, você poderá usar para implantar determinadas alterações
de código e recursos sem Apply Changes criar um novo APK. Confira o Guia do desenvolvedor do Android para obter
mais informações.
Emulator desenvolvimento de plataforma cruzada com Visual Studio

Há muitas opções de emulador do Android disponíveis para Windows PCs. É recomendável usar o Emulador
doGoogle Android, pois ele oferece acesso às imagens e serviços mais recentes do sistema operacional Android
Google Play serviços.
Instalar o Android Emulator com Visual Studio
1. Se você ainda não o tiver instalado, baixe o Visual Studio 2019. Use o Instalador do Visual Studio para
Modificar suas cargas de trabalho e verifique se você tem a carga de trabalho Desenvolvimento móvel
com .NET .
2. Criar um novo projeto. Depois de configurar o Android Emulator, você poderá usar o Gerenciador de
Dispositivos Android para criar, duplicar, personalizar e iniciar uma variedade de dispositivos virtuais
Android. Iniciar o Gerenciador de Dispositivos Android no menu Ferramentas com: Ferramentas >
Android > Gerenciador de Dispositivos Android .
3. Depois que Gerenciador de Dispositivos Android, selecione + Novo para criar um novo dispositivo.
4. Você precisará dar um nome ao dispositivo, escolher o tipo de dispositivo base em um menu suspenso,
escolher um processador e a versão do sistema operacional, juntamente com várias outras variáveis para
o dispositivo virtual. Para obter mais informações, Gerenciador de Dispositivos Android Tela Principal.
5. Na barra de Visual Studio, escolha entre Depurar (anexa ao processo do aplicativo em execução dentro
do emulador depois que o aplicativo é iniciado) ou o modo de versão (desabilita o depurador). Em
seguida, escolha um dispositivo virtual no menu suspenso do dispositivo e selecione o botão Reproduzir
▷ para executar seu aplicativo no emulador.
Recursos adicionais
Visão geral do desenvolvimento remoto do Docker
no Windows
O uso de contêineres para desenvolvimento remoto e a implantação de aplicativos com a plataforma Docker é
uma solução muito popular com muitos benefícios. Saiba mais sobre a variedade de suporte oferecido pelas
ferramentas e pelos serviços da Microsoft, incluindo o WSL (Subsistema do Windows para Linux), Visual Studio,
Visual Studio Code, .NET e uma ampla variedade de serviços do Azure.
Docker no Windows 10
Instalar o Docker Desktop para Windows

Encontre etapas de instalação, requisitos do sistema, o que está incluído no instalador, como desinstalar,
diferenças entre versões estáveis e de borda e como fazer a alternância entre os contêineres do Windows e do
Linux.
Introdução ao Docker
Orientação do Docker e documentos de instalação com instruções passo a passo sobre como começar, incluindo
um guia passo a passo em vídeo.
Curso do MS Learn: introdução aos contêineres do Docker

O Microsoft Learn oferece um curso introdutório gratuito sobre contêineres do Docker, além de uma variedade
de cursos sobre como começar a usar o Docker e se conectar aos serviços do Azure.
Introdução aos contêineres remotos do Docker no WSL 2
Saiba como configurar o Docker Desktop para Windows para uso com uma linha de comando do Linux
(Ubuntu, Debian, SUSE etc.) usando o WSL 2 (Subsistema do Windows para Linux, versão 2).
VS Code e Docker
Criar um contêiner do Docker com VS Code

Configure um ambiente de desenvolvimento completo dentro de um contêiner com a extensão Remoto –
Contêineres e encontre tutoriais para configurar um contêiner do NodeJS, um contêiner do Python ou um
contêiner do ASP.NET Core.
Anexar VS Code a um contêiner do Docker
Saiba como anexar o Visual Studio Code a um contêiner do Docker que já está em execução ou a um contêiner
em um cluster de Kubernetes.
Configuração avançada do contêiner

Saiba mais sobre cenários de configuração avançada para usar contêineres do Docker com Visual Studio Code
ou leia este artigo sobre como Inspecionar Contêineres para depuração com o VS Code.
Usar Contêineres Remotos no WSL 2
Leia sobre como usar contêineres do Docker com o WSL 2 (Subsistema do Windows para Linux, versão 2) e
como configurar tudo com o VS Code. Você também pode ler sobre como ele funciona.
Visual Studio e Docker
Supor te ao Docker no Visual Studio

Saiba mais sobre o suporte do Docker disponível para projetos ASP.NET, projetos ASP.NET Core e projetos de
console do .NET Core e .NET Framework no Visual Studio, além de dar suporte à orquestração de contêineres.
Início Rápido: Docker no Visual Studio
Saiba como criar, depurar e executar aplicativos .NET, ASP.NET e ASP.NET Core em contêineres e publicá-los no
ACR (Registro de Contêiner do Azure), no Docker Hub, no Serviço de Aplicativo do Azure ou em seu registro de
contêiner com o Visual Studio.
Tutorial: Criar um aplicativo de vários contêineres com o Docker Compose

Saiba como gerenciar mais de um contêiner e se comunicar entre eles quando usar as ferramentas de contêiner
no Visual Studio. Você também pode encontrar links para tutoriais como Usar o Docker com um aplicativo React
de página única.
Ferramentas de Contêiner no Visual Studio
Encontre tópicos que abordam como executar ferramentas de build em um contêiner, depurar aplicativos do
Docker, solucionar problemas de ferramentas de desenvolvimento, implantar contêineres do Docker e unir o
Kubernetes com o Visual Studio.
.NET Core e Docker

Guia do .NET: aplicativos e contêineres de microsser viço
Guia de introdução a aplicativos baseados em microsserviços gerenciados com contêineres.
O que é o Docker?
Explicação básica de contêineres do Docker, incluindo Comparar contêineres do Docker com máquinas virtuais e
uma taxonomia básica de termos e conceitos do Docker explicando a diferença entre contêineres, imagens e
Registros.
Tutorial: Colocar um aplicativo .NET Core em contêineres
Saiba como colocar um aplicativo .NET Core em contêineres com o Docker, incluindo a criação de um Dockerfile,
comandos essenciais e recursos de limpeza.
Fluxo de trabalho de desenvolvimento para aplicativos do Docker

Descreve o fluxo de trabalho de desenvolvimento de loop interno para aplicativos baseados em contêiner do
Docker.
Serviço de Contêiner do Azure

Instâncias de Contêiner do Azure
Saiba como executar contêineres do Docker sob demanda em um ambiente do Azure gerenciado e sem
servidor, incluindo maneiras de fazer a implantação com a CLI do Docker, o ARM, o portal do Azure, criar grupos
de vários contêineres, compartilhar dados entre contêineres, conectar-se a uma rede virtual e muito mais.
Registro de Contêiner do Azure

Saiba como criar, armazenar e gerenciar imagens de contêiner e artefatos em um Registro privado para todos
os tipos de implantações de contêiner. Crie registros de contêiner do Azure para seus pipelines de
desenvolvimento e implantação de contêiner existentes, configure tarefas de automação e saiba como gerenciar
seus Registros, incluindo replicação geográfica e melhores práticas.
Azure Ser vice Fabric
Conheça o Azure Service Fabric, uma plataforma de sistemas distribuídos para empacotar, implantar e gerenciar
microsserviços e contêineres escalonáveis e confiáveis.
Ser viço de aplicativo do Azure

Saiba como criar e hospedar aplicativos Web, back-ends móveis e APIs RESTful na linguagem de programação
de sua escolha sem gerenciar a infraestrutura. Experimente o curso sobre o Serviço de Aplicativo do Azure no
MS Learn para implantar um aplicativo Web baseado em uma imagem do Docker e configurar a implantação
contínua.
Saiba mais sobre serviços do Azure que dão suporte a contêineres.
Vídeo explicativo de contêineres do Docker

Vídeo explicativo da orquestração de contêineres e do Kubernetes
Contêineres no Windows
Documentos sobre Contêineres no Windows

Empacote aplicativos com as dependências deles e aproveite a virtualização no nível do sistema operacional
para ter ambientes rápidos e totalmente isolados em um sistema. Saiba sobre os contêineres do Windows,
incluindo inícios rápidos, guias de implantação e exemplos.
Perguntas frequentes sobre contêineres do Windows
Encontre perguntas frequentes sobre contêineres. Veja também essa explicação no StackOverflow em "Qual é a
diferença entre Docker for Windows e o Docker no Windows?"
Configure seu ambiente

Saiba como configurar o Windows 10 ou o Windows Server para criar, executar e implantar contêineres,
incluindo pré-requisitos, a instalação do Docker e o trabalho com Imagens Base de Contêiner do Windows.
Criar um contêiner do Windows Ser ver em um AKS (Ser viço de Kubernetes do Azure)
Saiba como implantar um aplicativo de exemplo do ASP.NET em um contêiner do Windows Server em um
cluster AKS usando a CLI do Azure.
Visão geral do desenvolvimento no Windows com o
Rust
Não é difícil começar a usar o Rust. Se você for um iniciante interessado em aprender o Rust usando o Windows
10, é recomendável que siga cada detalhe deste guia passo a passo. Ele mostra o que você deve instalar e como
configurar o ambiente de desenvolvimento.
TIP
Se você já se convenceu a respeito do Rust e tem o ambiente do Rust configurado, e deseja apenas começar a chamar as
APIs do Windows, fique à vontade para ir direto para o tópico Rust para Windows e o windows crate.
O que é o Rust?
O Rust é uma linguagem de programação de sistemas, portanto, é usado para gravar sistemas (como sistemas
operacionais). Mas ele também pode ser usado para aplicativos em que o desempenho e a confiabilidade são
importantes. A sintaxe da linguagem Rust é semelhante à do C++, fornece desempenho no mesmo nível do
C++ moderno e, para muitos desenvolvedores experientes, o Rust sempre acerta quando se trata de
compilação e modelo de runtime, sistema de tipos e finalização determinística.
Além disso, o Rust foi criado com base na promessa de segurança de memória garantida, sem a necessidade de
coleta de lixo.
Então, por que escolhemos o Rust para a projeção de linguagem mais recente do Windows? Um fator é que a
pesquisa anual de desenvolvedor do Stack Overflow mostra que o Rust é de longe a melhor linguagem de
programação ano após ano. Embora você possa achar que a linguagem tem uma curva de aprendizado
acentuada, depois que você supera o obstáculo, é difícil não se apaixonar.
Além disso, a Microsoft é um membro fundador da Rust Foundation. A Foundation é uma organização sem fins
lucrativos independente, com uma nova abordagem para sustentar e aumentar um ecossistema de software
livre grande e participativo.
As partes do conjunto de ferramentas/ecossistema de

desenvolvimento do Rust
Apresentaremos algumas ferramentas e termos do Rust nesta seção. Você pode consultar esta seção novamente
para se atualizar em qualquer uma das descrições.
Um crate é uma unidade de compilação e vinculação do Rust. Um crate pode existir na forma de código-
fonte e, com base nisso, pode ser processado em um crate na forma de um executável binário (binário para
abreviar) ou uma biblioteca binária (biblioteca para abreviar).
Um projeto do Rust é conhecido como pacote. Um pacote contém um ou mais crates, juntamente com um
arquivo Cargo.toml que descreve como criar esses crates.
rustup é o instalador e o atualizador da cadeia de ferramentas do Rust.
Cargo é o nome da ferramenta de gerenciamento de pacotes do Rust.
rustc é o compilador do Rust. Na maioria das vezes, você não invoca o rustc diretamente, mas
indiretamente por meio do Cargo.
crates.io ( https://crates.io/ ) é o registro de crate da comunidade do Rust.
Como configurar o seu ambiente de desenvolvimento

No próximo tópico, veremos como configurar o ambiente de desenvolvimento no Windows para Rust.
Relacionados
O site do Rust
Rust para Windows e o crate windows
Pesquisa anual de desenvolvedor do Stack Overflow
Rust Foundation
crates.io
Configurar seu ambiente de desenvolvimento no Windows para Rust
Configurar seu ambiente de desenvolvimento no
Windows para Rust
No tópico Visão geral do desenvolvimento no Windows com o Rust, apresentamos o Rust e falamos sobre o
que ele é e quais são algumas de suas principais partes móveis. Neste tópico, vamos configurar nosso ambiente
de desenvolvimento.
Recomendamos que você faça seu desenvolvimento do Rust no Windows. No entanto, se você planeja compilar
e testar localmente no Linux, também pode optar por desenvolver com Rust no Subsistema do Windows para
Linux (WSL).
Instalar o Visual Studio (recomendado) ou as ferramentas de

compilação do Microsoft C++
No Windows, o Rust requer certas ferramentas de compilação do C++.
Você pode baixar as Ferramentas de compilação do Microsoft C++ou (recomendado) você preferir apenas
instalar Microsoft Visual Studio.
IMPORTANT
O uso das ferramentas de compilação do Microsoft C++, ou das Ferramentas de Build do Visual Studio, requer uma
licença válida do Visual Studio (Community, Pro ou Enterprise).
NOTE
Usaremos Visual Studio Code como nosso IDE (ambiente de desenvolvimento integrado) para Rust e não com o Visual
Studio. Mas você ainda pode instalar o Visual Studio sem despesas. Uma Community Edition está disponível— é gratuita
para alunos, colaboradores de software de código aberto e indivíduos.
Ao instalar o Visual Studio, há várias cargas de trabalho do Windows que recomendamos que você selecione
—desenvolvimento de área de trabalho .NET , desenvolvimento para área de trabalho com C++ e
desenvolvimento de Plataforma Universal do Windows . Talvez você pense que não precisará de todos os
três, mas é provável que alguma dependência ocorra e que seja mais simples selecionar todos os três.
Novos projetos Rust usam o Git como padrão. Além disso, adicione o componente individual do Git para
Windows à combinação (use a caixa de pesquisa para procurá-lo por nome).
Instalar o Rust
Em seguida, Instale o Rust no site do Rust. O site detecta que você está executando o Windows e oferece os
instaladores de 64 e 32 bits da ferramenta rustup para Windows, bem como instruções sobre como instalar o
Rust no Subsistema do Windows para Linux (WSL).
TIP
O Rust funciona muito bem no Windows; portanto, não há necessidade de usar a rota WSL (a menos que planeje
compilar e testar localmente no Linux). Como você tem o Windows, recomendamos a execução do instalador rustup
para o Windows de 64 bits. Em seguida, você estará configurado para gravar aplicativos para o Windows usando o Rust.
Quando o instalador do Rust for concluído, você estará pronto para programar com o Rust. Você ainda não terá
um IDE conveniente (abordaremos isso na próxima seção—Instalar o Visual Studio Code). E você ainda não está
configurado para chamar APIs do Windows. Mas você poderia inicializar um prompt de comando ( cmd.exe ) e
talvez emitir o comando cargo --version . O número de versão impresso confirma que o Rust foi instalado
corretamente.
Se você estiver curioso sobre o uso da palavra-chave cargo acima, Cargo é o nome da ferramenta no ambiente
de desenvolvimento Rust que gerencia e cria seus projetos (mais adequadamente, pacotes) e suas
dependências.
E se você realmente quiser se aprofundar em alguma programação neste ponto (mesmo sem a conveniência de
um IDE), poderá ler o capítulo Hello, word! do livro de Linguagem de Programação Rust no site do Rust.

Usando o Visual Studio Code (VS Code) como seu editor de texto/Ambiente de Desenvolvimento Integrado
(IDE), você pode aproveitar os serviços de linguagem, como completar automaticamente o código, realçar a
sintaxe, formatar e depurar.
O VS Code também contém um terminal interno que permite a você emitir argumentos de linha de comando
(para emitir comandos para Cargo, por exemplo).
1. Primeiro, baixe e instale o Visual Studio Code para Windows.
2. Depois de instalar o VS Code, instale a extensãorust-analyzer . Você pode instalar a extensão Rust-
Analyzer no Visual Studio Marketplace, ou pode abrir o VS Code e pesquisar a Rust-Analyzer no menu
extensões (Ctrl + Shift + X).
3. Para obter compatibilidade com a depuração, instale a extensão CodeLLDB . Você pode instalar a
extensão CodeLLDB no Visual Studio Marketplace, ou pode abrir o VS Code e pesquisar a CodeLLDB no
menu extensões (Ctrl + Shift + X).
NOTE
Uma alternativa à extensão CodeLLDB para a compatibilidade à depuração é a extensão do Microsoft C/C++ . A
extensão C/C++ não se integra tão bem com o IDE quanto a CodeLLDB . Mas a extensão do C/C++ fornece
informações de depuração superiores. Portanto, talvez você queira ela como reserva, caso precise.
Você pode instalar a extensão C/C++ no Visual Studio Marketplace, ou pode abrir o VS Code e pesquisar a
C/C++ no menu extensões (Ctrl + Shift + X).
4. Para abrir o terminal no VS Code, selecione Exibir > Terminal ou, como alternativa, use o atalho Ctrl+`
(usando o caractere de acento grave). O terminal padrão é o PowerShell.
Hello, world! Tutorial (Rust com VS Code)

Vamos analisar o Rust com um simples "Hello, world!" aplicativo.
1. Primeiro, inicialize um prompt de comando ( cmd.exe ) e cd para uma pasta onde você deseja manter
seus projetos do Rust.
2. Em seguida, peça o Cargo para criar um novo projeto Rust com o comando a seguir.
cargo new first_rust_project
O argumento que você passa para o comando cargo new é o nome do projeto que você deseja que o
Cargo crie. Neste exemplo, o nome do projeto é first_rust_project. A recomendação é que você nomeie
seus projetos do Rust usando o Snake Case (em que as palavras são minúsculas, com cada espaço
substituído por um sublinhado).
O Cargo cria um projeto com o nome que você fornece. E, na verdade, os novos projetos contêm o
código-fonte de um aplicativo muito simples que exibe uma mensagem Hello, word! , conforme descrito
a seguir. Além de criar o projeto de first_rust_project, o Cargo criou uma pasta chamada first_rust_project
e nela inseriu os arquivos de código-fonte.
3. Agora cd está nessa pasta e, em seguida, inicie o VS Code de dentro do contexto dessa pasta.
cd first_rust_project
code .
4. No Gerenciador do VS Code, abra o arquivo src > main.rs , que é o arquivo de código-fonte do Rust
com o ponto de entrada do aplicativo (uma função chamada main ). Esta é a aparência dele.
// main.rs
fn main() {
println!("Hello, world!");
}
NOTE
Ao abrir o primeiro arquivo .rs no VS Code, você receberá uma notificação informando que alguns
componentes do Rust não estão instalados e perguntando se deseja instalá-los. Clique em Sim , e o VC Code
instalará o servidor de idioma do Rust.
Basta olhar rapidamente para o código no main.rs , para saber que a main é uma definição de função
que imprime a cadeia de caracteres "Hello, world!". Para obter mais detalhes sobre a sintaxe, consulte a
Anatomia de um Programa Rust no site do Rust.
5. Agora, vamos tentar executar o aplicativo no depurador. Coloque um ponto de interrupção na linha 2 e
clique em Executar > Iniciar Depuração (ou pressione F5 ). Também há comandos Debug e Run
inseridos dentro do editor de texto.
NOTE
Ao executar um aplicativo no depurador pela primeira vez, você verá uma caixa de diálogo dizendo "não é possível
iniciar a depuração porque nenhuma configuração de inicialização foi fornecida". Clique em OK para ver uma
segunda caixa de diálogo dizendo "Cargo.toml foi detectado neste espaço de trabalho. Você gostaria de gerar
configurações de inicialização para seus destinos?". Clique em Sim . Em seguida, feche o arquivo launch.json e
comece a depuração novamente.
6. Como você pode ver, o depurador é interrompido na linha 2. Pressione F5 para continuar e o aplicativo
será executado até a conclusão. No painel Terminal , você verá a saída esperada "Hello, world!".
Rust para Windows

Além de usar o Rust no Windows, você também pode gravar aplicativos para Windows usando o Rust. Por meio
do crate windows, você pode chamar qualquer API do Windows antiga, atual e futura. Há mais detalhes sobre
isso, além de exemplos de código, no Rust para Windows e o crate windows.
Relacionados
WSL (Subsistema do Windows para Linux)
Ferramentas de Compilação do Microsoft C++
Microsoft Visual Studio
Visual Studio Code para Windows
extensão rust-analyzer
Extensão CodeLLDB
Extensão C/C++
Introdução ao Rust para Windows

No tópico Visão geral de desenvolvimento no Windows com o Rust, demonstramos um aplicativo simples que
gera um Olá, mundo. . Mas não é possível apenas usar o Rust no Windows, você também pode gravar
aplicativos para Windows usando o Rust.
O Rust para Windows é a projeção de linguagem mais recente do Windows. No momento, ele está em versão
prévia e você pode vê-lo se desenvolver de versão em versão no log de alterações.
O Rust para Windows permite que usar qualquer API do Windows (antiga, atual e futura) de forma direta e
contínua por meio do crate windows (o crate é o termo do Rust para um binário ou uma biblioteca e/ou o
software livre integrado).
Sejam funções atemporais como CreateEventW e WaitForSingleObject, mecanismos gráficos eficazes como
Direct3D, funções tradicionais de janelas como CreateWindowExW e DispatchMessageW ou estruturas mais
recentes de interface do usuário (IU) como Composição e XAML, o crate windows pode ajudar você.
O projeto win32metadata tem como objetivo fornecer metadados para APIs do Win32. Esses metadados
descrevem as assinaturas, os parâmetros e os tipos de API enfaticamente digitados na superfície— da API. Isso
permite que toda a API do Windows seja projetada de forma automatizada e completa para consumo pelo Rust
(bem como linguagens como C# e C++). Confira também Como tornar as APIs do Win32 mais acessíveis para
mais linguagens.
Como desenvolvedor do Rust, você usará o Cargo (ferramenta de gerenciamento de pacotes do Rust)—
juntamente com o https://crates.io (o registro de crate da comunidade do Rust)—para gerenciar as
dependências nos projetos. A boa notícia é que você pode referenciar o crate windows nos aplicativos do Rust e
começar a chamar APIs do Windows imediatamente. Você também pode encontrar a documentação do Rust
para o crate windows em https://docs.rs .
Semelhante ao C++/WinRT, o Rust para Windows é uma projeção de linguagem de software livre desenvolvida
no GitHub. Use o repositório Rust para Windows se você tiver dúvidas sobre o Rust para Windows ou se desejar
relatar problemas com ele.
O repositório Rust para Windows também tem alguns exemplos simples que você pode seguir. E existe um
excelente aplicativo de exemplo na forma de campo minado de Robert Mikhayelyan.
Contribuir com o Rust para Windows

O Rust para Windows agradece suas contribuições.
Identificar e corrigir bugs no código-fonte
Documentação do Rust para a API do Windows

O Rust para Windows aproveita a cadeia de ferramentas elegante que os desenvolvedores do Rust adoram. Mas
se ter toda a API do Windows ao seu alcance parece um pouco assustador, também existe a documentação do
Rust para a API do Windows.
Esse recurso basicamente documenta como as APIs e os tipos do Windows são projetados no Rust idiomático.
Use-o para procurar ou pesquisar as informações necessárias das APIs.
Como gravar um aplicativo com o Rust para Windows

O próximo tópico é o tutorial do leitor RSS, em que veremos como gravar um aplicativo simples com o Rust
para Windows.
Relacionados
Visão geral do desenvolvimento no Windows com o Rust
Tutorial do leitor RSS
O crate windows
Documentação do crate windows
Metadados do Win32
Como tornar as APIs do Win32 mais acessíveis para mais linguagens
Documentação do Rust para a API do Windows
Rust para Windows
Aplicativo de exemplo do Campo Minado
Tutorial do leitor de RSS (Rust para Windows com
VS Code)
O tópico anterior apresentou o Rust para Windows e o crate windows.

Agora vamos experimentar o Rust para Windows ao gravar um aplicativo simples que baixa os títulos de
postagens de blog de um feed RSS (Really Simple Syndication).
1. Inicialize um prompt de comando ( cmd.exe ) e cd para uma pasta onde você deseja manter seus
projetos do Rust.
2. Em seguida, via Cargo, crie um novo projeto do Rust chamado rss_reader e cd na pasta recém-criada do
projeto.
cargo new rss_reader

cd rss_reader
3. Agora, —novamente via Cargo—, vamos criar um novo subprojeto chamado associações. Como você
pode ver no comando a seguir, esse novo projeto é uma biblioteca e vai servir como o meio pelo qual
vinculamos as APIs do Windows que gostaríamos de chamar. No momento da compilação, o subprojeto
da biblioteca de associações será criado em um crate (que é o termo do Rust para um binário ou uma
biblioteca). Usaremos o crate de dentro do projeto rss_reader, conforme mostrado posteriormente.
cargo new --lib bindings
Fazer associações em um crate aninhado significa que, quando compilamos rss_reader, as associações
poderão armazenar em cache os resultados de quaisquer associações que importarmos.
4. Em seguida, abra o projeto rss_reader no VS Code.
code .
5. Primeiro, vamos trabalhar na biblioteca associações.

No Gerenciador do VS Code, abra o arquivo bindings > Cargo.toml .
Um arquivo Cargo.toml é um arquivo de texto que descreve um projeto do Rust, incluindo as
dependências dele.
Neste momento, a seção dependencies está vazia. Portanto, edite essa seção (e também adicione uma
seção [build-dependencies] ) para que ela tenha a seguinte aparência.
# bindings\Cargo.toml
...
[dependencies]
windows="0.9.1"
[build-dependencies]
windows="0.9.1"
Acabamos de adicionar uma dependência no crate windows, tanto para a biblioteca de associações
quanto para o script de compilação. Isso permite que o Cargo baixe, compile e armazene em cache o
suporte do Windows como um pacote. Defina o número de versão para uma mais recente—você poderá
ver isso na página da Web para o crate windows.
6. Agora, podemos adicionar o script de compilação; em que vamos gerar as associações nas quais nos
basearemos. Em VS Code, clique com o botão direito do mouse na pasta associações e clique em Novo
Arquivo . Digite o nome build.rs e pressione Enter . Edite build.rs para que tenha a aparência a seguir.
// bindings\build.rs
fn main() {
windows::build!(
Windows::Foundation::Collections::IVector,
Windows::Foundation::{IAsyncOperationWithProgress, Uri},
Windows::Web::Syndication::{
ISyndicationText, RetrievalProgress, SyndicationClient, SyndicationFeed, SyndicationItem,
},
);
}
A macro windows::build! cuida da resolução de qualquer dependência na forma de arquivos .winmd e

da geração de associações para tipos selecionados diretamente de metadados. Poderíamos solicitar um
namespace inteiro (com Windows::Web::Syndication::* ). Mas aqui, estamos pedindo que as associações
sejam geradas apenas para os tipos que especificamos (como SyndicationClient ). Dessa forma, você
pode importar o mínimo ou o máximo necessário, e evitar esperar que o código seja gerado e compilado
para algo que você nunca precisará.
Além dos tipos que usaremos explicitamente, também especificaremos todas as suas dependências. Por
exemplo, vamos usar um método de SyndicationClient que espera um parâmetro do tipo Uri .
Portanto, na macro build também incluímos a definição de Windows::Foundation::Uri para que
possamos chamar esse método. Outros tipos fazem parte do próprio crate windows . Por exemplo,
windows::Result (que veremos em uso em breve) é definido pelo crate windows, portanto está sempre
disponível. Observe windows em letra minúscula em windows::Result , em comparação com os nomes
de tipo e namespace em Pascal Case para tipos do Windows.
7. Abra o arquivo do código-fonte bindings > src > lib.rs . Para incluir as associações geradas na etapa
anterior, substitua o código padrão que você encontrará no lib.rs pelo seguinte.
// bindings\src\lib.rs
windows::include_bindings!();
A macro windows::include_bindings! inclui o código-fonte que foi gerado na etapa anterior pelo script de
compilação. Sempre que você precisar de acesso a APIs adicionais, basta listá-las no script de compilação
( build.rs ).
8. Agora, vamos implementar o projeto principal de rss_reader. Primeiro, abra o arquivo Cargo.toml na raiz
do projeto e adicione a dependência a seguir no crate de associações interno, junto com uma
dependência no crate windows.
# Cargo.toml
...
[dependencies]
bindings = { path = "bindings" }
windows = "0.9.1"
9. Por fim, abra o arquivo de código-fonte src > main.rs do projeto rss_reader. Dentro, há o código
simples que gera um Hello, world! . Adicione este código no começo de main.rs .
// src\main.rs
use bindings::{
Windows::Foundation::Uri,
Windows::Web::Syndication::SyndicationClient,
};
fn main() {
println!("Hello, world!");
}
A declaração use reduz o caminho para os tipos que usaremos. Há o tipo Uri que mencionamos
anteriormente.
10. Para criar um novo Uri , adicione este código à função main .
// src\main.rs
...
fn main() -> windows::Result<()> {

let uri = Uri::CreateUri("https://blogs.windows.com/feed")?;
Ok(())
}
Observe que estamos usando windows::Result como o tipo de retorno da função main . Isso facilitará
tudo, pois é comum lidar com erros de APIs do sistema operacional (SO). O windows::Result nos ajuda
com a propagação de erros e com o tratamento de erro conciso.
Você pode ver o operador de ponto de interrogação no final da linha de código que cria um Uri . Para
economizar na digitação, fazemos isso para utilizar a lógica de propagação de erro e curto-circuito do
Rust. Isso significa que não precisamos fazer muito tratamento de erro manual para este exemplo
simples. Para obter mais informações sobre esse recurso do Rust, consulte O operador ? para obter um
tratamento de erros mais fácil.
11. Para baixar este feed RSS, criaremos um novo objeto SyndicationClient .
// src\main.rs
...

let client = SyndicationClient::new()?;
Ok(())
}
A função new e equivalente do construtor padrão do Rust.

12. Agora, podemos usar o objeto SyndicationClient para recuperar o feed.
// src\main.rs
...

let feed = client.RetrieveFeedAsync(uri)?.get()?;
Ok(())
}
Como RetrieveFeedAsync é uma API assíncrona, podemos usar a função de bloqueio Get (como
mostrado acima). Como alternativa, poderíamos usar o operador await dentro de uma função async
(para aguardar os resultados de forma cooperativa), da mesma maneira que faria em C# ou C++.
13. Podemos simplesmente iterar nos itens resultantes e imprimir apenas os títulos.
// src\main.rs
...

let feed = client.RetrieveFeedAsync(uri)?.get()?;
for item in feed.Items()? {

println!("{}", item.Title()?.Text()?);
}
Ok(())
}
14. Vamos confirmar que podemos criar e executar clicando em Executar > Executar sem Depuração (ou
pressionando Ctrl + F5 ). Também há comandos Debug e Run inseridos dentro do editor de texto.
Como alternativa, você pode enviar o comando cargo run do prompt de comando ( cd para a pasta
rss_reader primeiro) que será compilado e executado.
Na parte inferior do painel Terminal , você pode ver que o Cargo baixa e compila com êxito o crate
windows , armazenando em cache os resultados e usando-os para fazer com que as compilações
subsequentes sejam concluídas em menos tempo. Em seguida, ele compila o exemplo e executa-o,
exibindo uma lista de títulos de postagem de blog.
Isso é tão simples quanto programar o Rust para Windows. Mas, no fundo, grande parte da simplicidade
consiste em criar as ferramentas para que o Rust possa analisar arquivos .winmd com base em ECMA-335
(Common Language Infrastructure ou CLI) em tempo de compilação e também usar de forma segura a ABI
(interface binária de aplicativos) baseada em COM em tempo de execução, sempre colocando a segurança e a
eficiência em primeiro lugar.
Mostrar uma caixa de mensagem

Dissemos que o Rust para Windows permite que você chame qualquer API do Windows (antiga, atual e futura).
Portanto, nesta seção, adicionaremos o código para mostrar uma caixa de mensagem do Windows ao usuário.
1. Abra o arquivo de código-fonte bindings > build.rs e adicione a função mostrada abaixo às
associações geradas.
// bindings\build.rs
fn main() {
windows::build!(
...
Windows::Win32::UI::WindowsAndMessaging::MessageBoxA,
);
}
2. Em seguida, abra o arquivo de código-fonte src > main.rs do projeto e atualize a declaração use com
o novo namespace ou módulo. E, finalmente, adicione o código para chamar a função MessageBoxA
(também confira MessageBoxA na documentação do Rust para a API do Windows, que inclui um link
para MESSAGEBOX_STYLE ).
// src\main.rs
use bindings::{
Windows::Foundation::Uri,
Windows::Web::Syndication::SyndicationClient,
Windows::Win32::UI::WindowsAndMessaging::*,
};
fn main() {
...
unsafe {
MessageBoxA(None, "Text", "Caption", MB_OK);
}
Ok(())
}
Como você pode ver, marcamos essas APIs do Win32 mais antigas como unsafe (confira Blocos não
seguros).
Desta vez, quando você cria e executa, o Rust exibe uma caixa de mensagem do Windows após listar os títulos
das postagens do blog.
Relacionados
ECMA-335
O operador ? para tratamento de erro mais fácil
Blocos não seguros
O Gerenciador de Pacotes do Windows é uma solução de gerenciador de pacotes abrangente composta por
uma ferramenta de linha de comando e um conjunto de serviços para instalar aplicativos no Windows 10.
Gerenciador de Pacotes do Windows para desenvolvedores

Os desenvolvedores usam a ferramenta de linha de comando winget para descobrir, instalar, atualizar, remover
e configurar um conjunto selecionado de aplicativos. Após a instalação, os desenvolvedores poderão acessar o
winget por meio do Terminal do Windows, do PowerShell ou do Prompt de Comando.
Para obter mais informações, confira Usar a ferramenta winget para instalar e gerenciar aplicativos.
Gerenciador de Pacotes do Windows para ISVs

ISVs (Fornecedores Independentes de Software) podem usar o Gerenciador de Pacotes do Windows como um
canal de distribuição para pacotes de software que contenham as ferramentas e aplicativos deles. Para enviar
pacotes de software (contendo instaladores .msix, .msi ou .exe) para o Gerenciador de Pacotes do Windows,
fornecemos o Repositório do Manifesto do Pacote da Microsoft Community de software livre no GitHub,
em que os ISVs podem carregar manifestos do pacote para que os pacotes de software deles sejam
considerados para inclusão no Gerenciador de Pacotes do Windows. Os manifestos são validados
automaticamente e também podem ser examinados manualmente.
Para obter mais informações, confira Enviar pacotes para o Gerenciador de Pacotes do Windows.
Noções básicas sobre gerenciadores de pacotes

Um gerenciador de pacotes é um sistema ou conjunto de ferramentas usado para automatizar a instalação, a
atualização, a configuração e o uso do software. A maioria dos gerenciadores de pacotes foi projetada para
descobrir e instalar ferramentas para desenvolvedores.
O ideal é que os desenvolvedores usem um gerenciador de pacotes para especificar os pré-requisitos das
ferramentas de que eles precisam para desenvolver soluções para um determinado projeto. O gerenciador de
pacotes segue, então, as instruções declarativas para instalar e configurar as ferramentas. O gerenciador de
pacotes reduz o tempo gasto para preparar um ambiente e ajuda a verificar se as mesmas versões dos pacotes
estão instaladas no computador.
Os gerenciadores de pacotes de terceiros podem utilizar o Repositório do Manifesto do Pacote da Microsoft
Community para aumentar o tamanho do catálogo de software deles.
Tópicos relacionados
Usar a ferramenta winget para instalar e gerenciar pacotes de software
Enviar pacotes para o Gerenciador de Pacotes do Windows
Usar a ferramenta winget para instalar e gerenciar
aplicativos
A ferramenta de linha de comando winget permite que os desenvolvedores descubram, instalem, atualizem,
removam e configurem aplicativos em computadores Windows 10. Essa ferramenta é a interface do cliente para
o serviço Gerenciador de Pacotes do Windows.
No momento, a ferramenta winget é uma versão prévia; portanto, nem toda a funcionalidade planejada está
disponível no momento.
Instalar o winget
Há várias maneiras de instalar a ferramenta winget :
A ferramenta winget está incluída na versão de pré-lançamento ou na versão prévia do Instalador de
Aplicativo do Windows. Você deve instalar a versão prévia do Instalador de Aplicativo para usar o
winget . Para obter acesso antecipado, envie sua solicitação para o Programa Insiders do Gerenciador de
Pacotes do Windows. Participar do modo de versão de pré-lançamento garantirá que você veja as
atualizações mais recentes da versão prévia.
Participe do Modo de versão de pré-lançamento do Participante do Programa Windows Insider.
Instale o pacote do Instalador de Aplicativo da Área de Trabalho do Windows localizado na Página de
versões do repositório do WinGet.
NOTE
A ferramenta winget requer o Windows 10, versão 1809 (10.0.17763) ou uma versão posterior do Windows 10.
Considerações sobre o administrador

O comportamento do instalador poderá ser diferente dependendo se você estiver executando o winget com
privilégios de administrador.
Ao executar o winget sem privilégios de administrador, alguns aplicativos podem exigir elevação para
serem instalados. Quando o instalador for executado, o Windows solicitará que você eleve. Se você optar
por não elevar, o aplicativo não será instalado.
Ao executar o winget em um Prompt de Comando de Administrador, você não verá prompts de elevação
se o aplicativo os exigir. Sempre tome cuidado ao executar o prompt de comando como administrador e
instale apenas aplicativos confiáveis.
Usar o winget
Depois que o Instalador de Aplicativo estiver instalado, será possível executar o winget digitando "winget"
em um Prompt de Comando.
Um dos cenários de uso mais comuns é pesquisar e instalar uma ferramenta favorita.
1. Para pesquisar uma ferramenta, digite winget search <appname> .
2. Depois de confirmar que a ferramenta que você deseja está disponível, será possível instalá-la digitando
winget install <appname> . A ferramenta winget iniciará o instalador e instalará o aplicativo em seu
computador.
3. Além de instalar e pesquisar, winget fornece vários outros comandos que permitem que você mostre
detalhes sobre aplicativos, altere fontes e validade pacotes. Para obter uma lista completa de comandos,
digite: winget --help .
Comandos
A versão prévia atual da ferramenta winget dá suporte aos comandos a seguir.
C O M A N DO DESC RIÇ Ã O
export Exporta uma lista dos pacotes instalados.
recursos Mostra o status dos recursos experimentais.

C O M A N DO DESC RIÇ Ã O
hash Gera o hash SHA256 para o instalador.
import Instala todos os pacotes em um arquivo.
install Instala o aplicativo especificado.
list Exibir os pacotes instalados.
search Pesquisa um aplicativo.
configurações Abrir as configurações.
show Exibe os detalhes do aplicativo especificado.
source Adiciona, remove e atualiza os repositórios do Gerenciador

de Pacotes do Windows acessados pela ferramenta winget .
validate Valida um arquivo de manifesto para envio ao repositório do

Gerenciador de Pacotes do Windows.
uninstall Desinstala o pacote determinado.
upgrade Atualiza o pacote determinado.
Opções
A versão prévia atual da ferramenta winget dá suporte às opções a seguir.
OPÇ ÃO DESC RIÇ Ã O
-v, --version Retorna a versão atual do WinGet.
--info Fornece todas as informações detalhadas sobre o winget,

incluindo os links para a licença e a política de privacidade,
além das políticas de grupo configuradas.
-?, --help Mostra ajuda adicional para o WinGet.
Formatos de instalador com suporte

A versão prévia atual da ferramenta de WinGet dá suporte aos seguintes tipos de instaladores:
EXE
MSIX
MSI
Winget de script
É possível criar scripts em lote e do PowerShell para instalar vários aplicativos.
@echo off
Echo Install Powertoys and Terminal
REM Powertoys
winget install Microsoft.Powertoys
if %ERRORLEVEL% EQU 0 Echo Powertoys installed successfully.
REM Terminal
winget install Microsoft.WindowsTerminal
if %ERRORLEVEL% EQU 0 Echo Terminal installed successfully. %ERRORLEVEL%
NOTE
Quando tiver script, o winget iniciará os aplicativos na ordem especificada. Quando um instalador retornar êxito ou falha,
o winget iniciará o próximo instalador. Se um instalador iniciar outro processo, será possível que ele retorne ao winget
prematuramente. Isso fará o winget instalar o próximo instalador antes que o instalador anterior tenha sido concluído.
Depuração e solução de problemas

O winget fornece registro em log para ajudar a diagnosticar problemas. Para solução de problemas e detalhes
sobre o registro em log, confira Depuração e solução de problemas.
Ferramentas ausentes
Se o repositório da comunidade não incluir sua ferramenta ou aplicativo, envie um pacote para o nosso
repositório. Ao adicionar sua ferramenta favorita, ela estará disponível para você e todos os outros.
Personalizar configurações de WinGet

Você pode configurar a experiência de linha de comando WinGet modificando o arquivo settings.json . Para
obter mais informações, confira https://aka.ms/winget-settings. Observe que as configurações ainda estão em
um estado experimental e não foram finalizadas para a versão prévia da ferramenta.
Detalhes do software livre

A ferramenta winget é um software livre disponível no GitHub no repositório
https://github.com/microsoft/winget-cli/. A fonte para a criação do cliente está localizada na pasta src.
A fonte para winget está contida em uma solução em C++ do Visual Studio 2019. Para compilar a solução
corretamente, instale a carga de trabalho mais recente do Visual Studio com o C++.
Incentivamos você a contribuir com a fonte do winget no GitHub. Primeiro, você deve concordar e assinar o
CLA da Microsoft.
Comando export (winget)
O comando expor t da ferramenta winget exporta um arquivo JSON de aplicativos para um arquivo
especificado. O comando expor t usa JSON como o formato. O esquema JSON usado pelo winget pode ser
encontrado aqui.
O expor t combinado com o comando impor t permite que você instale aplicativos em lote no seu computador.
O comando expor t geralmente é usado para criar um arquivo que você pode compartilhar com outros
desenvolvedores ou usar ao restaurar seu ambiente de build.
Uso
winget export [-o] <output> [<options>]
Argumentos
Os argumentos a seguir estão disponíveis.
A RGUM EN TO DESC RIÇ Ã O
-o,--output Caminho para o arquivo JSON a ser criado
Opções
As opções permitem que você personalize a experiência de exportação para atender às suas necessidades.
-s, --source [opcional] Especifica uma origem da qual exportar arquivos.

Use essa opção quando quiser apenas arquivos de uma
origem específica.
--include-versions [opcional] Inclui a versão do aplicativo atualmente instalada.

Use essa opção se você desejar uma versão específica. Por
padrão, a menos que especificado, impor t usará a mais
recente.
JSON schema
A força de condução por trás do comando expor t é o arquivo JSON. Você pode encontrar o esquema do
arquivo JSON aqui.
O arquivo JSON inclui a hierarquia a seguir.
EN T RA DA DESC RIÇ Ã O
Fontes As origens das quais os manifestos do aplicativo vêm.
Pacotes A coleção de pacotes a ser instalada.
Id O identificador de pacote do Gerenciador de Pacotes do

Windows usado para especificar o pacote.
Versão [opcional] A versão específica do pacote a ser instalada.
Como exportar arquivos

Quando o Gerenciador de Pacotes do Windows exporta o arquivo JSON, ele tenta exportar todos os aplicativos
instalados no computador. Se o comando winget expor t não puder fazer a correspondência de um aplicativo
com um aplicativo de uma origem disponível, o comando de exportação mostrará um aviso.
NOTE
A correspondência de um aplicativo depende dos metadados no manifesto de uma origem configurada e dos metadados
em Adicionar ou remover programas no Windows com base no instalador do pacote.
Depois que a exportação for concluída, você poderá editar o arquivo JSON resultante em seu editor favorito.
Você pode remover aplicativos que não deseja importar no futuro.
Comando features (winget)
O comando features da ferramenta winget exibe uma lista de recursos experimentais disponíveis com a sua
versão do Gerenciador de Pacotes do Windows.
Cada recurso pode ser ativado individualmente habilitando os recursos por meio das configurações .
Você pode encontrar os recursos de informações mais recentes atualizados na página da Web de recursos
experimentais.
Uso
winget features
Observe acima que o status de cada recurso está listado. Se o recurso estiver desabilitado, você não poderá
usá-lo. Se o recurso estiver habilitado , você observará que o comando estará disponível para você por meio do
winget .
Para habilitar todos os recursos desabilitados, acesse configurações e habilite o recurso.
NOTE
Os recursos podem ser gerenciados pela política de grupo. Você pode usar o comando winget --info para exibir as
políticas em vigor no sistema.
Comando hash (winget)
O comando hash da ferramenta winget gera o hash SHA256 para um instalador. Esse comando será usado se
for necessário criar um arquivo de manifesto para enviar o software para o Repositório do Manifesto do
Pacote da Microsoft Community no GitHub. Além disso, o comando hash também dá suporte à geração de
um hash de certificado SHA256 para arquivos MSIX.
Uso
winget hash [-f] \<file> [\<options>]
O subcomando hash só pode ser executado em um arquivo local. Para usar o subcomando hash , baixe o
instalador para um local conhecido. Em seguida, passe o caminho do arquivo como um argumento para o
subcomando hash .
Argumentos
Os seguintes argumentos estão disponíveis:
-f,--file O caminho para o arquivo a receber o hash.
-m,--msix Especifica que o comando hash também criará o SHA 256

SignatureSha256 para uso com instaladores MSIX.
-?, --help Obtém ajuda adicional sobre esse comando.
Usar a ferramenta winget para instalar e gerenciar aplicativos
Comando help (winget)
O comando help da ferramenta winget exibe a ajuda para todos os comandos e subcomandos com suporte.
Além disso, você pode passar o argumento --help para qualquer outro comando para obter detalhes sobre
todas as opções de comando adicionais.
Uso
Exibir a ajuda para todos os comandos: winget --help
Exibir as opções de um comando: winget <command> --help
Comando import (winget)
O comando impor t da ferramenta winget importa um arquivo JSON de aplicativos a serem instalados. O
comando impor t combinado com o comando expor t permite que você instale aplicativos em lote no seu
computador.
O comando impor t geralmente é usado para compartilhar seu ambiente de desenvolvedor ou criar sua
imagem de computador com seus aplicativos favoritos.
Uso
winget import [-i] <import-file> [<options>]
Argumentos
-i,--impor t-file Arquivo JSON que descreve os pacotes a serem instalados.
Opções
As opções permitem que você personalize a experiência de importação para atender às suas necessidades.
--ignore-unavailable Suprime erros se o aplicativo solicitado não está disponível.
--ignore-versions Ignora as versões especificadas no arquivo JSON e instala a

versão mais recente disponível.
Esquema JSON
A força de condução por trás do comando impor t é o arquivo JSON. Você pode encontrar o esquema do
arquivo JSON aqui.
O arquivo JSON inclui a hierarquia a seguir.
EN T RA DA DESC RIÇ Ã O
Fontes As origens das quais os manifestos do aplicativo vêm.
Pacotes A coleção de pacotes a ser instalada.
Id O identificador de pacote do Gerenciador de Pacotes do

Windows usado para especificar o pacote.
Versão [opcional] A versão específica do pacote a ser instalada.
Como importar arquivos

Quando o Gerenciador de Pacotes do Windows importa o arquivo JSON, ele tenta instalar os aplicativos
especificados de maneira serial. Se o aplicativo não estiver disponível ou se o aplicativo já estiver instalado, ele
notificará o usuário sobre esse caso.
No exemplo anterior, o Microsoft.WindowsTerminal já estava instalado. Portanto, o comando import ignorado

passou pela instalação.
Comando install (winget)
O comando install da ferramenta winget instala o aplicativo especificado. Use o comando search para
identificar o aplicativo que você deseja instalar.
O comando install requer que você especifique a cadeia de caracteres exata a ser instalada. Se houver alguma
ambiguidade, você deverá filtrar ainda mais o comando install para um aplicativo exato.
Uso
winget install [[-q] \<query>] [\<options>]
Argumentos
-q,--quer y A consulta usada para pesquisar um aplicativo.
-?, --help Obtêm ajuda adicional sobre esse comando.
Opções
As opções permitem que você personalize a experiência de instalação para atender às suas necessidades.
-m, --manifest Deve ser seguido pelo caminho para o arquivo de manifesto
(YAML). É possível usar o manifesto para executar a
experiência de instalação de um arquivo YAML local.
--id Limita a instalação à ID do aplicativo.
--name Limita a pesquisa ao nome do aplicativo.
--moniker Limita a pesquisa ao moniker listado para o aplicativo.
-v, --version Permite que você especifique uma versão exata a ser
instalada. Se ela não for especificada, a mais recente instalará
o aplicativo com versão mais alta.
-s, --source Restringe a pesquisa ao nome de origem fornecido. Deve ser

seguido pelo nome de origem.
--scope Permite especificar se o instalador deve ter como destino o

escopo do usuário ou do computador.
-e, --exact Usa a cadeia de caracteres exata na consulta, incluindo a

verificação da diferenciação de maiúsculas e minúsculas. Ele
não usará o comportamento padrão de uma substring.
-i, --interactive Executa o instalador no modo interativo. A experiência

padrão mostra o progresso do instalador.
-h, --silent Executa o instalador no modo sem confirmação. Isso

suprime todas as interfaces do usuário. A experiência padrão
mostra o progresso do instalador.
--locale Especifica qual localidade deve ser usada (formato BCP47).
-o, --log Direciona o log a um arquivo de log. É necessário fornecer

um caminho para um arquivo ao qual você tem direitos de
gravação.
--override Uma cadeia de caracteres que será passada diretamente

para o instalador.
-l, --location Local da instalação (se houver suporte).
--force Substitui a verificação de hash do instalador. Não

recomendado.
Exemplos de consulta
O exemplo a seguir instala uma versão específica de um aplicativo.
winget install powertoys --version 0.15.2
O exemplo a seguir instala um aplicativo por meio da ID dele.

winget install --id Microsoft.PowerToys
O exemplo a seguir instala um aplicativo por versão e ID.
winget install --id Microsoft.PowerToys --version 0.15.2
Seleções múltiplas
Se a consulta fornecida para winget não resultar em um único aplicativo, winget exibirá os resultados da
pesquisa. Isso fornecerá os dados adicionais necessários para refinar a pesquisa para uma instalação correta.
A melhor maneira de limitar a seleção a um arquivo é usar a ID do aplicativo junto com a opção de consulta
exata . Por exemplo:
winget install --id Git.Git -e
Se várias fontes estiverem configuradas, será possível ter entradas duplicadas. É necessário especificar uma
origem para a remoção adicional da ambiguidade.
winget install --id Git.Git -e -source winget
Instalação local
A opção manifesto permite que você instale um aplicativo passando um arquivo YAML diretamente para o
cliente. Se o manifesto for um manifesto de vários arquivos, o diretório que contém os arquivos deverá ser
usado. A opção manifesto tem o uso a seguir.
Uso: winget install --manifest \<path>
-m, --manifest O caminho para o manifesto do aplicativo a ser instalado.
Arquivos de log
Os arquivos de log do winget, a menos que sejam redirecionados, estão localizados na seguinte pasta:
%temp%\AICLI\*.log
Comando list (winget)
O comando list da ferramenta winget exibe uma lista de aplicativos instalados no seu computador no
momento. O comando list mostrará aplicativos que foram instalados por meio do Gerenciador de Pacotes do
Windows, bem como aplicativos que foram instalados por outros meios.
O comando list também será exibido se uma atualização estiver disponível para um aplicativo, e você poderá
usar o comando upgrade para atualizar o aplicativo.
O comando list também dá suporte a filtros que podem ser usados para limitar sua consulta de lista.
Uso
winget list [[-q] \<query>] [\<options>]
Argumentos
Opções
As opções permitem que você personalize a experiência de lista para atender às suas necessidades.
--id Limita a lista à ID do aplicativo.

--name Limita a lista ao nome do aplicativo.
--moniker Limita a lista ao moniker listado para o aplicativo.
-s, --source Restringe a lista ao nome de origem fornecido. Deve ser

--tag Filtra os resultados por marcas.
--command Filtra os resultados por comando especificado pelo aplicativo.
-n, --count Limita o número de aplicativos exibidos em uma consulta.
-l, --location Local para a lista (se houver suporte).
-e, --exact Usa a cadeia de caracteres exata na consulta de lista,

incluindo a verificação da diferenciação de maiúsculas e
minúsculas. Ele não usará o comportamento padrão de uma
substring.
Consultas de exemplo
O exemplo a seguir lista uma versão específica de um aplicativo.
winget list --name powertoys
O exemplo a seguir lista todos os aplicativos por ID de uma origem específica.
winget list --id Microsoft.PowerToys --source winget
O exemplo a seguir limita a saída da lista a doze aplicativos.
winget list -n 12
List with update

Conforme mencionado acima, o comando list permite que você veja quais aplicativos instalados têm
atualizações disponíveis.
Na imagem abaixo, você observará que a versão prévia do Terminal tem uma atualização disponível.
O comando list exibirá não apenas a versão de atualização disponível, mas a origem da qual a atualização está
disponível.
Se não houver nenhuma atualização disponível, list mostrará apenas a versão instalada no momento e a coluna
de atualização não será exibida.
Usar a ferramenta winget para listar e gerenciar aplicativos
Comando search (winget)
O comando search da ferramenta winget consulta as fontes para ver se há aplicativos disponíveis que possam
ser instalados.
O comando search pode mostrar todos os aplicativos disponíveis ou pode ser filtrado para um aplicativo
disponível. O comando search é usado normalmente para identificar a cadeia de caracteres a ser usada para
instalar um aplicativo específico.
Uso
winget search [[-q] \<query>] [\<options>]
Argumentos
Mostrar tudo
Se o comando search não incluir filtros nem opções, ele exibirá todos os aplicativos disponíveis na origem
padrão. Também será possível pesquisar todos os aplicativos em outra fonte se passar apenas a opção de
origem .
Cadeias de caracteres de pesquisa
As cadeias de caracteres de pesquisa podem ser filtradas com as opções a seguir.
--id Limita a pesquisa à ID do aplicativo. A ID inclui o editor e o

nome do aplicativo.
--moniker Limita a pesquisa ao moniker especificado.
--tag Limita a pesquisa às tags listadas para o aplicativo.
--command Limita a pesquisa aos comandos listados para o aplicativo.
A cadeia de caracteres será tratada como uma substring. A pesquisa, por padrão, também não diferencia
maiúsculas de minúsculas. Por exemplo, winget search micro poderia retornar o seguinte:
Microsoft
microscope
MyMicro
Opções de pesquisa
Os comandos de pesquisa dão suporte a várias opções ou filtros para ajudar a limitar os resultados.

-n, --count Restringe a saída da exibição à contagem especificada.
-s, --source Restringe a pesquisa ao nome de origem especificado.
Comando settings (WinGet)
O comando settings da ferramenta WinGet permite personalizar sua experiência de cliente do Gerenciador de
Pacotes do Windows. É possível alterar os padrões e usar recursos experimentais habilitados para seu cliente.
O comando settings inicia o editor de texto padrão. Por padrão, o Windows inicia o Bloco de notas como uma
opção. Recomendamos usar uma ferramenta como o Visual Studio Code.
NOTE
É possível instalar com facilidade o Visual Studio Code digitando winget install Microsoft.VisualStudioCode
Uso
Iniciar a ferramenta padrão de edição JSON: winget settings
Ao iniciar as configurações pela primeira vez, não haverá configurações específicas. Na parte superior do
arquivo JSON, fornecemos um link em que é possível descobrir os recursos experimentais e as configurações
mais recentes.
Também definimos um esquema para executar o arquivo de configurações. Isso permite usar a tecla TAB para
descobrir configurações e sintaxes caso o editor JSON seja compatível com esquemas JSON.
Como atualizar as configurações

As configurações a seguir estão disponíveis no Gerenciador de Pacotes do Windows versão 1.0.
source
As configurações de source incluem a configuração de origem do WinGet.
"source": {
"autoUpdateIntervalInMinutes": 3
},
autoUpdateIntervalInMinutes
Um inteiro positivo representa o intervalo da atualização em minutos. A verificação de atualizações ocorre
somente durante o uso de uma origem. Um zero vai desabilitar a verificação de atualizações em uma origem.
Outros valores são inválidos.
Desabilitar: 0
Padrão: 5
Para atualizar a origem de modo manual, use winget source update .
visual
As configurações do visual incluem elementos visuais exibidos pelo WinGet
"visual": {
"progressBar": "accent"
},
progressBar
A cor da barra de progresso que o WinGet exibe quando ela não é especificada por argumentos.
cor de destaque (padrão)
retrô
arco-íris
installBehavior
As configurações de installBehavior afetam o comportamento padrão de instalação e atualização de pacotes
(quando aplicável).
Preferências e requisitos
Algumas configurações estão duplicadas em preferences e requirements .
A configuração de preferences afeta de que modo que as diversas opções disponíveis são classificadas
durante a escolha de uma delas. Por exemplo, o escopo padrão de instalação do pacote é voltado para o
usuário atual. No entanto, caso essa não seja uma opção, um instalador de nível de computador será
escolhido.
A configuração de requirements filtra as opções, resultando de maneira potencial em uma lista vazia e falha
na instalação. No exemplo anterior, um requisito de escopo do usuário pode resultar em nenhum instalador
aplicável, bem como em um erro.
Os argumentos passados na linha de comando substituirão de modo efetivo a configuração do requirement de
correspondência durante esse comando.
scope
O comportamento do scope afeta a escolha entre instalar um pacote para o usuário atual ou para todo o
computador. O parâmetro correspondente é --scope . Além disso, ele usa os mesmos valores ( user ou
machine ).
"installBehavior": {
"preferences": {
"scope": "user"
}
},
localidade
O comportamento da locale afeta a escolha do instalador com base na localidade. O parâmetro
correspondente é --locale . Além disso, ele usa a marca de idioma bcp47.
"installBehavior": {
"preferences": {
"locale": [ "en-US", "fr-FR" ]
}
},
telemetria
As configurações de telemetry controlam se o WinGet grava eventos ETW que poderão ser enviados à
Microsoft em uma instalação padrão do Windows.
Confira detalhes sobre dados telemétricos e nossa principal política de privacidade.
disable
"telemetry": {
"disable": true
},
Caso seja definido como true, a configuração telemetry.disable impedirá que eventos sejam gravados pelo
programa.
network
As configurações de network influenciam de que modo o WinGet usa a rede para recuperar pacotes e
metadados.
downloader
A configuração do downloader controla qual código é usado durante o download de pacotes. O padrão é
default , que pode ser uma das opções baseadas em nossa determinação.
O wininet usa APIs do WinINet, enquanto o do usa o serviço de Otimização de Entrega.
"network": {
"downloader": "do"
}
Como habilitar recursos experimentais

Para descobrir quais recursos experimentais estão disponíveis, acesse https://aka.ms/winget-settings. Nesse site,
será possível conferir os recursos experimentais que estão disponíveis para você.
Comando show (winget)
O comando show da ferramenta winget exibe detalhes para o aplicativo especificado, incluindo detalhes sobre
a fonte do aplicativo, além dos metadados associados a ele.
O comando show mostra apenas os metadados que foram enviados com o aplicativo. Se o aplicativo enviado
excluir alguns metadados, os dados não serão exibidos.
Uso
winget show [[-q] \<query>] [\<options>]
Argumentos
Opções
As opções a seguir estão disponíveis.
-m,--manifest O caminho para o manifesto do aplicativo a ser instalado.
--id Filtrar resultados por ID.

--name Filtrar resultados por nome.
--moniker Filtrar resultados por moniker do aplicativo.
-v,--version Usar a versão especificada. O padrão é a última versão.
-s,--source Localizar o aplicativo usando a fonte especificada.
-e,--exact Localizar o aplicativo usando a correspondência exata.
--versions Mostrar as versões disponíveis do aplicativo.
Se a consulta fornecida para winget não resultar em um único aplicativo, winget exibirá os resultados da
pesquisa. Isso fornecerá os dados adicionais necessários para refinar a pesquisa.
Resultados de mostrar
Se um único aplicativo for detectado, os dados a seguir serão exibidos.
Metadados
VA LO R DESC RIÇ Ã O
Id Id do aplicativo.
Nome Nome do aplicativo.
Publisher Editor do aplicativo.
Version Versão do aplicativo.
Author Autor do aplicativo.
AppMoniker AppMoniker do aplicativo.
Descrição Descrição do aplicativo.
Licença Licença do aplicativo.
LicenseUrl A URL para o arquivo de licença do aplicativo.
Homepage Página inicial do aplicativo.
Tags As tags fornecidas para auxiliar na pesquisa.
Comando Os comandos compatíveis com o aplicativo.

Channel Os detalhes sobre se o aplicativo é versão prévia ou

lançamento.
Minimum OS Version A versão mínima do sistema operacional compatível com o

aplicativo.
Detalhes do instalador
Arch A arquitetura da instância do instalador.
Idioma O idioma do instalador.
Installer Type O tipo de instalador.
Download Url A URL do instalador.
Hash O Sha-256 do instalador.
Escopo Exibe se o instalador é por computador ou por usuário.
Comando source (winget)
NOTE
No momento, o comando source é somente para uso interno. Por enquanto, não há suporte para fontes adicionais.
O comando source da ferramenta winget gerencia os repositórios acessados pelo Gerenciador de Pacotes do
Windows. Com o comando source , é possível adicionar , remover , listar e atualizar os repositórios.
Uma fonte fornece os dados para você descobrir e instalar aplicativos. Somente adicione uma nova fonte se
você confiar nela como um local seguro.
Uso
winget source \<sub command> \<options>
Argumentos
Subcomandos
A fonte dá suporte aos seguintes subcomandos para manipular as fontes.
SUB C O M A N DO DESC RIÇ Ã O
add Adiciona uma nova fonte.

SUB C O M A N DO DESC RIÇ Ã O
list Enumera a lista de fontes habilitadas.
update Atualiza uma fonte.
remove Remove uma fonte.
reset Redefine winget para a configuração inicial.
Opções
O comando source dá suporte às opções a seguir.
-n,--name O nome pelo qual identificar a fonte.
-a,--arg A URL ou o UNC da fonte.
-t,--type O tipo de fonte.
adicionar
O subcomando add adiciona uma nova fonte. Esse subcomando requer a opção --name e o argumento name .
Uso: winget source add [-n, --name] \<name> [-a] \<url> [[-t] \<type>]
Exemplo: winget source add --name Contoso https://www.contoso.com/cache
O subcomando add também dá suporte ao parâmetro type opcional. O parâmetro type comunica ao cliente a
qual tipo de repositório ele está se conectando. Há suporte para os tipos a seguir.
T IP O DESC RIÇ Ã O
Microsoft.PreIndexed.Package O tipo de fonte <default>.
lista
o subcomando list enumera as fontes habilitadas no momento. Esse subcomando também fornece detalhes
sobre uma fonte específica.
Uso: winget source list [-n, --name] \<name>
list all
O subcomando list por si só revelará a lista completa de fontes com suporte. Por exemplo:
> C:\winget source list
> Name Arg
> -----------------------------------------
> winget https://winget.azureedge.net/cache
list source details

Para obter detalhes completos sobre a fonte, passe o nome usado para identificá-la. Por exemplo:
> C:\winget source list --name contoso

> Name : contoso
> Type : Microsoft.PreIndexed.Package
> Arg : https://pkgmgr-int.azureedge.net/cache
> Data : AppInstallerSQLiteIndex-int_g4ype1skzj3jy
> Updated: 2020-4-14 17:45:32.000
Name exibe o nome pelo qual identificar a fonte. Type exibe o tipo de repositório. Arg exibe a URL ou o
caminho usado pela fonte. Data exibe o nome do pacote opcional usado, se apropriado. Updated exibe a data e
hora da última atualização da fonte.
atualizar
O subcomando update força uma atualização para uma fonte individual ou para todas.
uso: winget source update [-n, --name] \<name>
update all
O subcomando update por si só solicitará e atualizará cada repositório. Por exemplo: C:\winget update
atualizar origem
O subcomando update combinado com a opção --name pode direcionar e atualizar para uma fonte individual.
Por exemplo: C:\winget source update --name contoso
remover
O subcomando remove remove uma fonte. Esse subcomando requer a opção --name e name argument a
fim de identificar a fonte.
Uso: winget source remove [-n, --name] \<name>
Por exemplo: winget source remove --name Contoso
reset
O subcomando reset redefine o cliente para a configuração original dele. O subcomando redefinir remove
todas as fontes e define a fonte como o padrão. Esse subcomando só deve ser usado em casos raros.
Uso: winget source reset
Por exemplo: winget source reset
Repositório padrão
O Gerenciador de Pacotes do Windows especifica um repositório padrão. É possível identificar o repositório
usando o comando list . Por exemplo: winget source list
Comando uninstall (winget)
O comando uninstall da ferramenta winget desinstala o aplicativo especificado.

O comando uninstall requer que você especifique a cadeia de caracteres exata a ser desinstalada. Se houver
alguma ambiguidade, você deverá filtrar ainda mais o comando uninstall para um aplicativo exato.
Uso
winget uninstall [[-q] \<query>] [\<options>]
Argumentos
Opções
As opções permitem que você personalize a experiência de desinstalação para atender às suas necessidades.
(YAML). Você pode usar o manifesto para executar a
experiência de desinstalação de um arquivo YAML local.
--id Limita a desinstalação à ID do aplicativo.
desinstalada. Se ela não for especificada, a mais recente
desinstalará o aplicativo com versão mais alta.



padrão mostra o progresso do desinstalador.

mostra o progresso do desinstalador.

gravação.
Depois de identificar com êxito o aplicativo que você pretende desinstalar, o winget executará o comando
uninstall. No exemplo abaixo, o nome 'orca' e a id foram passados.
O exemplo a seguir desinstala uma versão específica de um aplicativo.
winget uninstall --name powertoys --version 0.15.2
O exemplo a seguir desinstala um aplicativo usando a ID dele.
winget uninstall --id "{24559D0F-481C-F3BE-8DD0-D908923A38F8}"
Se a consulta fornecida a winget não resultar na desinstalação de um único aplicativo, o winget exibirá vários
resultados. Você pode usar filtros adicionais para refinar a pesquisa de um aplicativo correto.
Como desinstalar aplicativos não instalados com o Gerenciador de
Pacotes do Windows
Conforme mencionado em list , o comando winget list exibirá mais do que apenas aplicativos instalados com o
winget . Portanto, você pode usar esses comandos para remover aplicativos de seu computador de maneira
rápida e fácil.
Neste exemplo, list foi usado para localizar o aplicativo e, em seguida, a id foi passada como parte da
desinstalação.
Comando upgrade (winget)
O comando upgrade da ferramenta winget atualiza o aplicativo especificado. Opcionalmente, você pode usar o
comando list para identificar o aplicativo que deseja atualizar.
O comando upgrade requer que você especifique a cadeia de caracteres exata a ser atualizada. Se houver
alguma ambiguidade, você deverá filtrar ainda mais o comando upgrade para um aplicativo exato.
Uso
winget upgrade [[-q] \<query>] [\<options>]
Argumentos
Opções
As opções permitem que você personalize a experiência de upgrade para atender às suas necessidades.

(YAML). É possível usar o manifesto para executar a
experiência de upgrade de um arquivo YAML local.
--id Limita o upgrade à ID do aplicativo.
atualizada. Se ela não for especificada, a mais recente
atualizará o aplicativo com versão mais alta.



padrão mostra o progresso do instalador.

mostra o progresso do instalador.

gravação.
--override Uma cadeia de caracteres que será passada diretamente

para o instalador.
-l, --location Local para upgrade (se houver suporte).
--force Quando uma incompatibilidade de hash for descoberta, o

erro será ignorado e haverá uma tentativa de instalar o
pacote.
--all Atualiza todos os pacotes disponíveis para o aplicativo mais

recente.
O exemplo a seguir atualiza uma versão específica de um aplicativo.
winget upgrade powertoys --version 0.15.2
O exemplo a seguir atualiza um aplicativo por meio da ID dele.
winget upgrade --id Microsoft.PowerToys

O exemplo a seguir mostra a atualização de todos os aplicativos
winget upgrade --all
Como usar list e upgrade

É comum usar o comando list para identificar os aplicativos que precisam de uma atualização e, em seguida,
usar upgrade para instalar a versão mais recente.
No exemplo abaixo, você verá que list identifica que uma atualização está disponível para
Microsoft.WindowsTerminalPreview. Em seguida, o usuário usa upgrade para atualizar o aplicativo.
upgrade --all
upgrade --all identificará todas os aplicativos com upgrades disponíveis. Quando você executar winget
upgrade --all , o Gerenciador de Pacotes do Windows procurará todos os aplicativos que têm atualizações
disponíveis e tentará instalá-los.
NOTE
Alguns aplicativos não fornecem uma versão. Eles são sempre os mais recentes. Como o Gerenciador de Pacotes do
Windows não pode identificar se há uma versão mais recente do aplicativo, uma atualização não será possível.
Comando validate (winget)
O comando validar da ferramenta WinGet valida um manifesto para enviar um software para o Repositório
do Manifesto do Pacote da Microsoft Community no GitHub. O manifesto deve ser um arquivo YAML que
siga a especificação.
Uso
winget validate [--manifest] \<path>
Argumentos
--manifest o caminho para o manifesto a ser validado.
-?, --help obter ajuda adicional sobre esse comando
Enviar pacotes para o Gerenciador de Pacotes do
Windows
Esta seção fornecerá diretrizes sobre como enviar pacotes para o Gerenciador de Pacotes do Windows.
ISV (Fornecedor Independente de Software) ou Distribuidor

Caso seja um ISV ou Distribuidor, será possível usar o Gerenciador de Pacotes do Windows como um canal de
distribuição para executar pacotes de software contendo seus aplicativos. No momento, o Gerenciador de
Pacotes do Windows dá suporte a instaladores nos seguintes formatos: MSIX, MSI e EXE.
Para enviar pacotes de software para o Gerenciador de Pacotes do Windows, siga estas etapas:
1. Crie um manifesto do pacote que forneça informações sobre seu aplicativo. Os manifestos são arquivos
YAML que seguem o esquema do Gerenciador de Pacotes do Windows.
2. Envie seu manifesto para o repositório do Gerenciador de Pacotes do Windows. Esse é um repositório de
software livre no GitHub que contém uma coleção de manifestos que a ferramenta winget pode acessar.
Membro da comunidade
Caso seja um membro da comunidade do GitHub, também será possível enviar pacotes para o Gerenciador de
Pacotes do Windows seguindo as etapas acima.
Como alternativa, também é possível solicitar ajuda para adicionar um pacote ao repositório da comunidade.
Para fazer isso, crie um problema de Solicitação/Envio de Pacote.
Usar a ferramenta winget
Se você desejar enviar um pacote de software para o repositório do Gerenciador de Pacotes do Windows,
comece criando um manifesto do pacote. O manifesto é um arquivo YAML que descreve o aplicativo a ser
instalado.
Este artigo descreve o conteúdo de um manifesto do pacote para o Gerenciador de Pacotes do Windows.
Noções básicas sobre YAML

O formato YAML foi escolhido para manifestos do pacote devido à facilidade relativa de legibilidade por
humanos à consistência com outras ferramentas de desenvolvimento da Microsoft. Se você não estiver
familiarizado com a sintaxe do YAML, poderá aprender as noções básicas em Aprender sobre o YAML em Y
minutos.
NOTE
No momento, os manifestos do Gerenciador de Pacotes do Windows não dão suporte a todos os recursos do YAML. Os
recursos do YAML sem suporte incluem âncoras, chaves complexas e conjuntos.
Convenções
Essas convenções são usadas neste artigo:
À esquerda de : , há uma palavra-chave literal usada em definições de manifesto.
À direita de : , há um tipo de dados. O tipo de dados pode ser um tipo primitivo como cadeia de
caracteres ou uma referência a uma estrutura avançada definida em outro lugar neste artigo.
A notação [ datatype ] indica uma matriz do tipo de dados mencionado. Por exemplo, [ string ] é uma
matriz de cadeias de caracteres.
A notação { datatype : datatype } indica um mapeamento de um tipo de dados para outro. Por exemplo,
{ string: string } é um mapeamento de cadeias de caracteres para cadeias de caracteres.
Conteúdo do manifesto
Um manifesto do pacote deve incluir um conjunto de itens necessários e também pode incluir outros itens
opcionais que podem ajudar a aprimorar a experiência do cliente com a instalação do seu software. Esta seção
fornece breves resumos do esquema de manifesto necessário e dos esquemas de manifesto completos, além de
exemplos de cada um.
Cada campo no arquivo de manifesto deve ser escrito na formatação Pascal e não pode ser duplicado.
Para obter uma lista completa e descrições de itens em um manifesto, confira a especificação de manifesto no
repositório https://github.com/microsoft/winget-cli.
Esquema mínimo necessário
Conforme especificado no esquema JSON singleton, somente determinados campos são obrigatórios. O
arquivo YAML mínimo com suporte seria semelhante ao exemplo abaixo. O formato singleton só é válido para
pacotes que contenham um único instalador e uma única localidade. Se mais de um instalador ou uma
localidade for fornecido, o esquema e o formato do arquivo YAML múltiplo deverão ser usados.
O esquema de particionamento foi adicionado para ajudar com a UX do GitHub. As pastas com milhares de
filhos não são bem renderizadas no navegador.
Esquema mínimo necessário
Exemplo
PackageIdentifier: # Publisher.package format.

PackageVersion: # Version numbering format.
PackageLocale: # BCP 47 format (e.g. en-US)
Publisher: # The name of the publisher.
PackageName: # The name of the application.
License: # The license of the application.
ShortDescription: # The description of the application.
Installers:
- Architecture: # Enumeration of supported architectures.
InstallerType: # Enumeration of supported installer types (exe, msi, msix, inno, wix, nullsoft, appx).
InstallerUrl: # Path to download installation file.
InstallerSha256: # SHA256 calculated from installer.
ManifestType: # The manifest file type
ManifestVersion: 1.0.0
Vários arquivos de manifesto

Para fornecer a melhor experiência do usuário, os manifestos devem conter o máximo possível de metadados.
Para separar as preocupações de validação de instaladores e fornecimento de metadados localizados, os
manifestos devem ser divididos em vários arquivos. O número mínimo de arquivos YAML para esse tipo de
manifesto é três. Outras localidades também devem ser fornecidas.
Um arquivo de versão.
O arquivo de localidade padrão.
Um arquivo do instalador.
Outros arquivos de localidade.
O exemplo abaixo mostra muitos campos de metadados opcionais e várias localidades. Observe que a
localidade padrão tem mais requisitos do que as localidades adicionais. No comando show, todos os campos
obrigatórios que não são fornecidos para localidades adicionais exibirão campos da localidade padrão.
Exemplo de arquivo de versão

Exemplo de arquivo de localidade padrão
Exemplo de arquivo de localidade adicional
Exemplo de arquivo do instalador
Caminho: manifests / m / Microsoft / WindowsTerminal / 1.6.10571.0 / Microsoft.WindowsTerminal.yaml
PackageIdentifier: "Microsoft.WindowsTerminal"
PackageVersion: "1.6.10571.0"
DefaultLocale: "en-US"
ManifestType: "version"
ManifestVersion: "1.0.0"
NOTE
Se o instalador for um .exe e tiver sido criado usando o Nullsoft ou o Inno, será possível especificar esses valores. Quando
o Nullsoft ou o Inno forem especificados, o cliente definirá automaticamente os comportamentos de instalação silenciosa
e silenciosa com progresso para o instalador.
Opções do instalador
Muitas vezes, você pode descobrir quais Switches silenciosas estão disponíveis para um instalador passando
um -? para o instalador da linha de comando. Aqui estão algumas Switches silenciosas comuns que podem
ser usadas para diferentes tipos de instalador.
IN STA L A DO R C O M A N DO DO C UM EN TA Ç Ã O
MSI /q Opções de linha de comando do MSI
InstallShield /s Parâmetros da linha de comando do

InstallShield
Configuração do Inno /SILENT or /VERYSILENT Documentação de configuração do

Inno
Nullsoft /S Instaladores/desinstaladores
silenciosos do Nullsoft
Dicas e melhores práticas

O identificador do pacote precisa ser exclusivo. Não é possível ter vários envios com o mesmo identificador
de pacote. Somente uma solicitação de pull por versão do pacote é permitida.
Evite criar várias pastas do editor. Por exemplo, não crie "Contoso Ltd." se já houver uma pasta "Contoso".
Todas as ferramentas precisam dar suporte a uma instalação silenciosa. Se você tiver um executável que não
dá suporte a uma instalação silenciosa, não poderemos fornecer essa ferramenta no momento.
Forneça o máximo de campos possível. Quanto mais metadados você fornecer, melhor será a experiência do
usuário. Em alguns casos, os campos talvez ainda não tenham suporte do cliente do Gerenciador de Pacotes
do Windows (winget.exe). Por exemplo, o campo AppMoniker é opcional. No entanto, se você incluir esse
campo, os clientes verão os resultados associados ao valor AppMoniker ao executarem o comando search
(por exemplo, vscode para Visual Studio Code ). Se houver apenas um aplicativo com o valor AppMoniker
especificado, os clientes poderão instalar seu aplicativo especificando o moniker em vez do identificador do
pacote totalmente qualificado.
O comprimento das cadeias de caracteres nesta especificação deve ser limitado a 100 caracteres antes de um
quebra de linha.
O PackageName deve corresponder à entrada feita em Adicionar ou remover programas para ajudar a
correlação com manifestos a dar suporte à expor tação e ao upgrade .
O Publisher deve corresponder à entrada feita em Adicionar ou remover programas para ajudar a
correlação com manifestos a dar suporte à expor tação e ao upgrade .
Os instaladores de pacote no formato MSI usam códigos de produto para identificar exclusivamente os
aplicativos. O código do produto para uma determinada versão de um pacote deve ser incluído no manifesto
para ajudar a garantir a melhor experiência de upgrade .
Limite o comprimento de cadeias de caracteres em seu manifesto a 100 caracteres antes de uma quebra de
linha.
Quando houver mais de um tipo de instalador para a versão do pacote especificada, uma instância de
InstallerType poderá ser colocada em cada um dos Installers .
Depois de criar um manifesto do pacote que descreva seu aplicativo, você estará pronto para enviar seu
manifesto para o repositório do Gerenciador de Pacotes do Windows. Esse é um repositório voltado para o
público que contém uma coleção de manifestos que a ferramenta winget pode acessar. Para enviar seu
manifesto, você o carregará pagara o repositório https://github.com/microsoft/winget-pkgs de software livre no
GitHub.
Após enviar uma solicitação de pull para adicionar um manifesto ao repositório do GitHub, um processo
automatizado validará o arquivo de manifesto e verificará se o pacote está em conformidade com as políticas do
Gerenciador de Pacotes do Windows e não é conhecido por ser mal-intencionado. Se essa validação for bem-
sucedida, seu pacote será adicionado ao repositório do Gerenciador de Pacotes do Windows voltado ao público
para que possa ser descoberto pela ferramenta de cliente winget . Observe a distinção entre os manifestos no
repositório do GitHub de software livre e o repositório do Gerenciador de Pacotes do Windows voltado para o
público.
IMPORTANT
A Microsoft se reserva o direito de recusar um envio por qualquer motivo.
Repositórios de terceiros
No momento, não há repositórios de terceiros conhecidos. A Microsoft está trabalhando com vários parceiros
para desenvolver protocolos ou uma API para habilitar repositórios de terceiros.
Validação do manifesto
Quando você envia um manifesto para o repositório https://github.com/microsoft/winget-pkgs no GitHub, seu
manifesto será validado e avaliado automaticamente quanto à segurança do ecossistema do Windows. Os
manifestos também podem ser examinados manualmente.
Para obter mais informações sobre o processo de validação, confira o Processo de validação do Gerenciador de
Pacotes do Windows.
Como enviar seu manifesto

Para enviar um manifesto para o repositório, siga estas etapas.
Etapa 1: Validar seu manifesto
A ferramenta winget fornece o comando validate para confirmar que você criou o manifesto corretamente.
Para validar seu manifesto, use este comando.
winget validate \<manifest-file>
Se a validação falhar, use os erros para localizar o número de linha e fazer uma correção. Depois que o
manifesto for validado, você poderá enviá-lo para o repositório.
Etapa 2: Clone o repositório
Em seguida, crie uma bifurcação do repositório e a clone.
1. Acesse https://github.com/microsoft/winget-pkgs em seu navegador e clique em Bifurcação .
2. Em um ambiente de linha de comando, como o Prompt de Comando do Windows ou o PowerShell, use o

comando a seguir para clonar sua bifurcação.
git clone \<your-fork-name>
3. Se você estiver fazendo vários envios, crie um branch em vez de uma bifurcação. No momento,
permitimos apenas um arquivo de manifesto por envio.
git checkout -b \<branch-name>
Etapa 3: Adicionar seu manifesto ao repositório local

É necessário adicionar o arquivo de manifesto ao repositório na seguinte estrutura de pastas:
manifestos / car ta / editor / aplicativo / versão / arquivo Yaml
A pasta manifests é a pasta raiz para todos os manifestos no repositório.
A pasta car ta representa a primeira letra do nome do editor.
A pasta publisher é o nome da empresa que publica o software. Por exemplo, Microsoft .
A pasta application é o nome do aplicativo ou da ferramenta. Por exemplo, VSCode .
A pasta versão representa a versão do aplicativo ou da ferramenta. Por exemplo: 1.0.0 .
O Arquivo Yaml é o nome do arquivo do manifesto. O nome do arquivo deverá ser definido com o nome e
o editor do aplicativo. Por exemplo: Contoso.ContosoApp.yaml .
O valor PackageIdentifier no manifesto deve corresponder aos nomes do editor e do aplicativo no caminho da
pasta de manifesto, e o valor PackageVersion no manifesto deve corresponder à versão no nome do arquivo.
Para obter mais informações, confira Criar seu manifesto do pacote.
Etapa 4: Enviar seu manifesto para o repositório remoto
Agora você já pode enviar seu novo manifesto por push para o repositório remoto.
1. Use o comando add para preparar o envio.
git add manifests\C\Contoso\ContosoApp\1.0.0\Contoso.ContosoApp.yaml
2. Use o comando commit para confirmar a alteração e fornecer informações sobre o envio.
git commit -m "Submitting ContosoApp version 1.0.0.yaml"
3. Use o comando push para enviar por push as alterações para o repositório remoto.
git push
Etapa 5: Criar uma solicitação pull

Após enviar suas alterações por push, volte para https://github.com/microsoft/winget-pkgs e crie uma
solicitação de pull para mesclar a bifurcação ou o branch com o branch principal.
Processo de envio
Ao criar uma solicitação de pull, um processo automatizado será iniciado que validará os manifestos e verificará
sua solicitação pull. Durante esse processo, executaremos testes no instalador e nos binários instalados para
validar o envio.
Adicionaremos rótulos à sua solicitação de pull para que seja possível rastrear o respectivo progresso. Para
obter mais informações, confira o Processo de validação.
Após a conclusão, o envio será mesclado de modo automático e o aplicativo será adicionado ao catálogo do
Caso ocorra um erro durante o processo, você será notificado. Além disso, nossos rótulos e nosso bot ajudarão
você a corrigir seu envio. Para obter uma lista de erros comuns, confira o Processo de validação.
Processo de validação do Gerenciador de Pacotes
do Windows
Ao criar uma solicitação de pull para enviar seu manifesto ao repositório do Gerenciador de Pacotes do
Windows, você vai iniciar um processo de automação que valida o manifesto e processa sua solicitação de pull.
Os rótulos do GitHub são usados para compartilhar o progresso e permitir que você se comunique conosco.
Expectativas de envio
Os envios de aplicativos para o repositório do Gerenciador de Pacotes do Windows deverão ser adequados e
seguir as políticas de repositório do Gerenciador de Pacotes do Windows. Veja algumas expectativas para
envios:
O manifesto está em conformidade com os requisitos do esquema.
Todas as URLs no manifesto levam a sites seguros.
O instalador e o aplicativo não contêm vírus. O pacote pode ser identificado como um malware por
engano. Caso considere que ele seja um falso positivo, será possível enviar um instalador para a equipe
do Microsoft Defender a fim de executar uma análise.
O aplicativo é instalado e desinstalado corretamente para administradores e não administradores.
O instalador dá suporte a modos não interativos.
Todas as entradas de manifesto são precisas e não enganosas.
O instalador é fornecido diretamente do site do editor.
Para obter uma lista completa de políticas, confira as Políticas do Gerenciador de Pacotes do Windows.
Rótulos de solicitação pull

Durante a validação, aplicamos vários rótulos em solicitações de pull para informar o progresso. Alguns rótulos
vão direcionar você para executar uma ação, enquanto outros serão direcionados para a equipe de engenharia
do Gerenciador de Pacotes do Windows.
Rótulos de status
A tabela a seguir descreverá os rótulos de status que você poderá encontrar.
RÓT ULO DETA L H ES
Azure-Pipeline-Passed O manifesto concluiu a fase de teste. Ele está aguardando

aprovação. Caso nenhum problema seja encontrado durante
a fase de teste, ele será aprovado de modo automático. Caso
haja falha em um teste, ele poderá ser sinalizado para obter
uma revisão manual.
Blocking-Issue Este rótulo indica que não foi possível aprovar a solicitação
de pull porque há um problema de bloqueio. Muitas vezes é
possível identificar o problema de bloqueio analisando o
rótulo de erro incluído.
Requisito: atenção Este rótulo indica que a solicitação de pull precisa ser
investigada pela equipe de desenvolvimento do Gerenciador
de Pacotes do Windows. Isso ocorre devido a uma falha de
teste que precisa de uma revisão manual ou um comentário
adicionado à solicitação de pull pela comunidade.
Requisitos: comentários do autor Indica se há uma falha no envio. Vamos transferir a

solicitação de pull de volta para você. Caso não solucione o
problema em dez dias, o bot fechará a solicitação de pull.
Requisitos: comentários do autor – os rótulos de
comentários do autor geralmente são adicionados quando
há uma falha na solicitação de pull que deve ser atualizada
ou se a pessoa que está examinando a solicitação de pull
tem uma dúvida.
Validation-Completed Indica se a fase de teste foi concluída com êxito e que sua
solicitação de pull será mesclada.
Rótulos de erros
A tabela a seguir descreverá os rótulos de erros que você pode encontrar. Nem todos os casos de erros serão
atribuídos a você de modo imediato. Alguns poderão disparar uma validação manual.
Binar y-Validation-Error Houve falha na aprovação do aplicativo incluído nesta

solicitação de pull durante a execução do teste de
Verificação de Instaladores . Esse teste foi projetado para
garantir a instalação do aplicativo em todos os ambientes
sem gerar avisos. Para obter mais detalhes sobre esse erro,
confira Erros binários de validação.
Error-Analysis-Timeout O teste Binar y-Validation-Test expirou. Portanto, a

solicitação de pull será atribuída a um engenheiro do
Gerenciador de Pacotes do Windows para realizar uma
investigação.
Error-Hash-Mismatch Não foi possível processar o manifesto enviado porque não

houve correspondência com o hash InstallerSha256
fornecido para o InstallerURL . Atualize o InstallerSha256
na solicitação de pull, depois tente de novo.
Error-Installer-Availability Não foi possível baixar o instalador por meio do serviço de

validação. Talvez isso esteja relacionado ao bloqueio dos
intervalos de IP do Azure ou a URL do instalador talvez
esteja incorreta. Verifique se o InstallerURL é adequado,
depois tente de novo. Caso considere que a falha ocorreu
com um erro, adicione um comentário. Desse modo, a
solicitação de pull será atribuída a um engenheiro do
Gerenciador de Pacotes do Windows para realizar uma
investigação.
Manifest-Path-Error Os arquivos de manifesto deverão ser inseridos em uma

estrutura de pasta específica. Este rótulo indica se há um
problema com o caminho do seu envio. Por exemplo, a
estrutura de pastas não tem o formato necessário. Atualize o
manifesto e o caminho, depois reenvie sua solicitação de
pull.
Manifest-Validation-Error o manifesto enviado contém um erro de sintaxe. Solucione o

problema de sintaxe, depois reenvie o manifesto. Para obter
mais detalhes sobre o formato e o esquema do manifesto,
confira o formato necessário.
PullRequest-Error A solicitação de pull é inválida porque nem todos os

arquivos enviados estão na pasta do manifesto ou há mais
de um pacote/versão na solicitação de pull. Atualize sua
solicitação de pull para solucionar o problema, depois tente
de novo.
URL-Validation-Error Não foi possível localizar a URL usando o Teste de

Validação de URLs que respondeu com um código de
status de erro HTTP (403 ou 404) ou ocorreu uma falha no
teste de reputação da URL. É possível identificar qual URL
está na solicitação examinando os detalhes de verificação da
solicitação de pull. Para solucionar esse problema, atualize as
URLs da solicitação a fim de resolver o código de status de
erro HTTP. Caso o problema não seja devido a um código de
status de erro HTTP, será possível enviar a URL para revisão a
fim de evitar a falha de reputação.
Validation-Defender-Error Durante o teste dinâmico, o Microsoft Defender relatou um

problema. Para reproduzir esse problema, instale o aplicativo,
depois execute uma verificação completa no Microsoft
Defender. Caso seja possível reproduzir o problema, corrija o
binário ou envie-o para análise a fim de obter assistência
para lidar com um falso positivo. Caso não seja possível
reproduzir o problema, adicione um comentário para que os
engenheiros do Gerenciador de Pacotes do Windows
realizem uma investigação.
Validation-Domain O teste determinará o domínio caso não haja uma

correspondência entre o InstallerURL e o domínio
esperado. As políticas do Gerenciador de Pacotes do
Windows exigem que o InstallerUrl seja fornecido
diretamente do local de lançamento do ISV. Caso considere
que essa é uma detecção falsa, adicione um comentário à
solicitação de pull para que os engenheiros do Gerenciador
de Pacotes do Windows realizem uma investigação.
Validation-Error Houve falha na validação do Gerenciador de Pacotes do

Windows durante uma aprovação manual. Examine o
comentário correspondente para executar as próximas
etapas.
Validation-Executable-Error Não foi possível localizar o aplicativo primário durante o

teste de instalação. Verifique se o aplicativo está sendo
instalado de modo correto em todas as plataformas. Caso
seu aplicativo não instale outro aplicativo, porém ainda deva
ser incluído no repositório, adicione um comentário à
Validation-Hash-Verification-Failed Durante o teste de instalação, uma falha ocorre na instalação

do aplicativo porque o InstallerSha256 não corresponde
mais ao hash InstallerURL . Isso pode ocorrer caso o
aplicativo esteja protegido por uma URL intuitiva e o
instalador seja atualizado sem uma atualização de
InstallerSha256 . Para solucionar esse problema, atualize o
InstallerSha256 associado ao InstallerURL , depois
execute o reenvio.
Validation-HTTP-Error A URL usada no instalador não usa o protocolo HTTPS.

Atualize o InstallerURL para usar o HTTPS e reenviar a
Solicitação de Pull.
Validation-Indirect-URL A URL não é fornecida diretamente do servidor de ISVs. O

teste identificou que um redirecionador foi usado. Isso não é
permitido porque as políticas do Gerenciador de Pacotes do
diretamente do local de lançamento do ISV. Remova o
redirecionamento, depois execute o reenvio.
Validation-Installation-Error Um erro geral ocorreu durante a validação manual desse

pacote. Examine o comentário correspondente para executar
as próximas etapas.
Validation-Merge-Conflict Não foi possível validar esse pacote devido a um conflito de

mesclagem. Solucione o conflito de mesclagem e reenvie sua
solicitação de pull.
Validation-MSIX-Dependency Não foi possível resolver uma dependência no pacote MSIX.

Atualize o pacote para incluir os componentes ausentes ou
adicione a dependência ao arquivo de manifesto e reenvie a
solicitação de pull.
Validation-Unapproved-URL O teste determinará o domínio caso não haja uma

correspondência entre o InstallerURL e o domínio
esperado. As políticas do Gerenciador de Pacotes do
diretamente do local de lançamento do ISV.
Validation-Unattended-Failed Durante a instalação, o teste atingiu o tempo limite. Isso

provavelmente ocorreu porque o aplicativo não está sendo
instalado de modo silencioso. Também pode ser devido a
outro erro encontrado que interrompeu o teste. Verifique se
é possível instalar o manifesto sem a entrada de usuário.
Caso precise de assistência, adicione um comentário à
Validation-Uninstall-Error Não foi possível limpar o aplicativo de modo integral durante

o teste de instalação nem após a desinstalação. Confira o
comentário correspondente para obter mais detalhes.
Validation-VCRuntime-Dependency Não foi possível resolver uma dependência que o pacote tem
no runtime do C++. Atualize o pacote para incluir os
componentes ausentes ou adicione a dependência ao
arquivo de manifesto e reenvie a solicitação de pull.
Rótulos de políticas de conteúdo

A tabela a seguir listará os rótulos de políticas de conteúdo . Caso um desses rótulos seja adicionado, uma
revisão manual de conteúdo complementar será disparada nos metadados do manifesto para garantir que os
metadados estejam seguindo as políticas do Gerenciador de Pacotes do Windows.
Policy-Test-2.1 Confira os Requisitos gerais do conteúdo.
Policy-Test-2.2 Confira um Conteúdo que inclui nomes/logotipos originais e

de terceiros
Policy-Test-2.3 Confira o Risco de danos.
Policy-Test-2.4 Confira um Conteúdo difamatório, calunioso e ameaçador.
Policy-Test-2.5 Confira um Conteúdo ofensivo.
Policy-Test-2.6 Confira um Conteúdo sobre álcool, tabaco, armas e drogas.
Policy-Test-2.7 Confira um Conteúdo para adulto.
Policy-Test-2.8 Confira uma Atividade ilícita.
Policy-Test-2.9 Confira Blasfêmias graves e conteúdo impróprio.
Policy-Test-2.10 Confira Requisitos específicos ao país/região.
Policy-Test-2.11 Confira a Classificação etária.
Policy-Test-2.12 Confira um Conteúdo gerado pelo usuário.
Rótulos internos
A tabela a seguir listará rótulos de erros internos. Quando erros internos são identificados, sua solicitação de
pull será atribuída aos engenheiros do Gerenciador de Pacotes do Windows para realizar uma investigação.
Internal-Error-Domain Um erro ocorreu durante a validação de domínio da URL.
Internal-Error-Dynamic-Scan Um erro ocorreu durante a validação dos binários instalados.

Internal-Error-Keyword-Policy Um erro ocorreu durante a validação do manifesto.
Internal-Error-Manifest Um erro ocorreu durante a validação do manifesto.
Internal-Error-NoArchitectures Um erro ocorreu porque não foi possível determinar a

arquitetura do aplicativo usando um teste.
Internal-Error-NoSuppor tedArchitectures Um erro ocorreu porque não há suporte para a arquitetura

atual.
Internal-Error-PR Um erro ocorreu durante o processamento da solicitação de

pull.
Internal-Error-Static-Scan Um erro ocorreu durante uma análise estática dos

instaladores.
Internal-Error-URL Um erro ocorreu durante a validação de reputação dos

instaladores.
Internal-Error Uma falha genérica ou um erro desconhecido ocorreu

durante a fase de teste.
Solução de problemas de envio para o Gerenciador
de Pacotes do Windows
Ao processar arquivos de manifesto no pipeline, o Gerenciador de Pacotes do Windows exibe rótulos. Caso haja
falha na solicitação de pull, talvez seja necessário realizar uma investigação para entender a falha de modo mais
adequado.
Este artigo mostrará de que modo é possível obter mais informações sobre uma falha em sua solicitação de
pull.
Passo a passo sobre como investigar uma falha

1. Durante a falha de uma solicitação de pull, a falha será exibida na parte inferior da página da Web. Isso
indicará uma falha na cadeia de caracteres Algumas verificações não foram executadas com êxito .
Clique no link Detalhes .
.
2. Após clicar em Detalhes , você será direcionado para uma página do Azure Pipelines. Clique no link da
cadeia de caracteres 0 erros/0 avisos .
.
3. A próxima página listará um trabalho com falha. Na captura de tela a seguir, o trabalho com falha será a
Validação de Conteúdo do Manifesto . Clique no trabalho com falha.
.
4. A próxima página exibirá a saída do trabalho com falha. É possível usar essas informações para depurar o
problema. No exemplo a seguir, a falha ocorreu durante a tarefa de Validação da Instalação . A saída
ajudará você a identificar uma alteração que precisa ser executada para corrigir o manifesto.
.
Erros de validação binária
Caso haja falha na solicitação de pull durante a fase de teste de Verificação de Instaladores e o rótulo
Binar y-Validation-Error seja fornecido, isso indicará que houve falha na instalação do aplicativo em todos os
ambientes. Este artigo fornecerá diretrizes e mais informações sobre esse erro.
Noções básicas sobre o teste de Verificação dos Instaladores

O Gerenciador de Pacotes do Windows busca criar uma excelente experiência do usuário durante a instalação de
aplicativos. Para fazer isso, precisamos garantir que todos os aplicativos sejam instalados nos PCs sem erros,
não importa o ambiente.
Para esse fim, usamos um teste de chave no Gerenciador de Pacotes do Windows para garantir que todos os
instaladores sejam instalados sem gerar avisos em uma variedade de configurações de antivírus populares.
Embora o Windows forneça o Microsoft Defender como um programa antivírus interno, vários clientes e
usuários corporativos usam uma grande variedade de softwares antivírus.
Portanto, cada envio para o Gerenciador de Pacotes do Windows será executado por meio de vários programas
antivírus. Todos esses programas têm diferentes algoritmos de detecção de vírus usados para identificar um
PUA (aplicativo potencialmente indesejado) e um malware.
Caso ocorra falha na validação de um aplicativo, a Microsoft primeiro vai tentar verificar com os fornecedores
de antivírus se o software sinalizado não é um falso positivo. Em vários casos, após a notificação e a validação, o
fornecedor de antivírus atualizará o respectivo algoritmo e o aplicativo será aprovado.
O que fazer caso veja o rótulo Binary-Validation-Error

Em alguns casos, uma anomalia de código detectada não pode ser identificada como um falso positivo pelos
fornecedores de antivírus. Nesse caso, o aplicativo não pode ser adicionado ao repositório do Gerenciador de
Pacotes do Windows. Além disso, a solicitação de pull será rejeitada com o rótulo Binar y-Validation-Error .
Caso o rótulo Binar y-Validation-Error seja aplicado à sua solicitação de pull, atualize o software para
remover o código detectado como PUA.
O que ocorrerá caso não seja possível remover esse código?

Às vezes, as ferramentas originais usadas para executar a depuração e atividades de baixo nível serão exibidas
como PUA para os fornecedores de antivírus. Isso ocorre porque o código necessário para executar a depuração
terá uma assinatura semelhante à do software indesejado. Embora esse seja um uso legítimo da prática de
codificação, não é possível habilitar esses aplicativos no repositório do Gerenciador de Pacotes do Windows.
Políticas de repositório do Gerenciador de Pacotes
do Windows
Versão do documento: 1.0

Data do documento: 22 de maio de 2021
Data de início de vigência: 22 de maio de 2021
Agradecemos o seu interesse em fornecer um produto ao repositório do Gerenciador de Pacotes do Windows.
Produto se refere ao conteúdo em qualquer formato enviado, incluindo, entre outros, aplicativos, jogos,
títulos e qualquer conteúdo adicional vendido ou oferecido em um Produto .
Envio se refere a uma solicitação de pull de arquivos de manifesto e inclui, entre outros, o Produto e os
metadados sobre o Produto.
Alguns princípios para ajudá-lo a começar:
Ofereça um valor exclusivo e distinto em seu Envio. Forneça um motivo convincente para baixar o Produto
do repositório do Gerenciador de Pacotes do Windows.
Não engane nossos clientes sobre o que seu Envio pode fazer, quem o está oferecendo etc.
Não tente enganar os clientes, o sistema ou o ecossistema. Não há espaço para nenhum tipo de fraude no
repositório, seja manipulação de classificações e avaliações, fraudes de cartão de crédito ou outra atividade
fraudulenta.
A adesão a estas políticas deve ajudar você a fazer escolhas que aprimorem o apelo do seu envio e do público-
alvo.
Os envios são essenciais para a experiência de centenas de milhões de clientes. Estamos ansiosos para ver o que
você vai criar e queremos ajudar a fornecer seus envios para o mundo.
Se você tiver comentários sobre as políticas ou o Gerenciador de Pacotes do Windows, comente em nosso
fórum de problemas do GitHub para sabermos
Sumário
Políticas do Produto:
1.1 Função e Valor Distintos; Representação Precisa
1.2 Segurança
1.3 Produto Testável
1.4 Usabilidade
1.5 Informações Pessoais
1.6 Funcionalidades
1.7 Localização
1.8 Transações Financeiras
1.9 Notificações
1.10 Conteúdo e Conduta de Publicidade
Políticas de Conteúdo:
2.1 Requisitos de Conteúdo Geral
2.2 Conteúdo Original e de Terceiros que Inclua Nomes e Logotipos
2.3 Risco de Danos
2.4 Conteúdo Difamatório, Calunioso e Ameaçador
2.5 Conteúdo Ofensivo
2.6 Álcool, Tabaco, Armas e Drogas
2.7 Conteúdo para Adultos
2.8 Atividade Ilícita
2.9 Blasfêmias Graves e Conteúdo Impróprio
2.10 Requisitos Específicos de Países/Regiões
2.11 Classificações Etárias
2.12 Conteúdo Gerado pelo Usuário
Políticas do Produto
1.1 Função e Valor Distintos; Representação Precisa
O Produto e os metadados associados, incluindo, entre outros, o nome do aplicativo, a descrição, as capturas de
tela, os trailers, a classificação de conteúdo e a categoria do Produto, precisam refletir com precisão e clareza a
origem, a funcionalidade e os recursos do Produto.
1.1.1
Todos os aspectos do Produto devem descrever com precisão as funções, os recursos e limitações importantes
do Produto.
1.1.2
As marcas não podem exceder o número de 16 exclusivas e devem ser relevantes para o Produto.
1.1.3
Além de ter metadados distintos e informativos, o Produto deve fornecer ao usuário uma experiência valiosa e
de qualidade.
1.1.4
InstallerUrl precisa ser o local de lançamento do ISV para o Produto. Os produtos dos sites de download não
serão permitidos.
1.2 Segurança
o Produto não deve prejudicar nem comprometer a segurança do usuário nem a segurança ou a funcionalidade
do dispositivo, do sistema ou dos sistemas relacionados.
1.2.1
O Produto não deve tentar mudar nem ampliar a funcionalidade descrita por meio de qualquer forma de
inclusão dinâmica de código que viole as políticas da do Gerenciador de Pacotes do Windows. O Produto não
deve, por exemplo, baixar um script remoto e depois executar esse script de maneira que não seja consistente
com a funcionalidade descrita.
1.2.2
O Produto não deve conter nem habilitar malware conforme definido pelos critérios da Microsoft para
Softwares Mal-intencionados e Indesejados.
1.2.3
O Produto pode conter middleware totalmente integrado (como mecanismos multiplataforma de terceiros e
serviços de análise de terceiros).
O Produto pode depender de software não integrado (por exemplo, outro Produto, módulo ou serviço) para
fornecer a função principal dele.
1.3 Produto Testável
Deve ser possível testar o produto. Se, por qualquer motivo, não for possível testar o Produto enviado, seu
Produto poderá não ser aprovado nesse requisito.
1.4 Usabilidade
O Produto deve atender aos padrões de usabilidade, incluindo, entre outros, os listados nas subseções abaixo.
1.4.1
Os Produtos devem dar suporte aos dispositivos e às plataformas nos quais eles são baixados, incluindo a
compatibilidade com os requisitos de software, hardware e resolução de tela especificados pelo Produto. Se o
Produto for baixado em um dispositivo com o qual ele não é compatível, ele deverá detectar isso na inicialização
e exibir uma mensagem para o cliente detalhando os requisitos.
1.4.2
O Produto deve apresentar execução contínua e responder à entrada de usuário. Os Produtos devem desligar
normalmente e não fechar inesperadamente. O Produto deve tratar as exceções geradas por APIs nativas ou
gerenciadas do sistema e responder à entrada de usuário depois que a exceção for manipulada.
1.4.3
O Produto deve iniciar imediatamente e deve continuar respondendo à entrada de usuário.
1.5 Informações Pessoais
Os requisitos a seguir aplicam-se aos Produtos que acessam Informações Pessoais. As Informações Pessoais
incluem todas as informações ou os dados que identificam ou possam ser usados para identificar uma pessoa
ou que sejam associados a tais informações ou dados.
1.5.1
Se o Produto acessar, coletar ou transmitir Informações Pessoais ou exigidas por lei, ele deverá manter uma
política de privacidade. O envio deve incluir a PrivacyUrl vinculada à política de privacidade do Produto.
1.5.2
Se o Produto publicar as Informações Pessoais dos clientes do produto para um serviço externo ou terceiros, o
Produto só deverá fazer isso depois de obter consentimento de aceitação desses clientes. O consentimento por
meio de aceitação implica uma permissão explícita do cliente na interface do usuário do Produto para a
atividade solicitada depois que o Produto:
Descrever para o cliente como as informações serão acessadas, usadas ou compartilhadas, além de indicar
para quem elas serão divulgadas;
Fornecer ao cliente um mecanismo na interface do usuário do Produto por meio do qual ele possa cancelar
essa permissão posteriormente e recusá-la.
1.5.3
Se o Produto publicar Informações Pessoais de alguém para um serviço externo ou para terceiros por meio do
Produto ou dos metadados dele, mas essa pessoa não for cliente do Produto, o Produto deverá obter uma
autorização por escrito explícita para publicar essas Informações Pessoais, além de permitir-lhe revogar essa
autorização quando desejar. Se o Produto permitir que um cliente acesse as Informações Pessoais de outra
pessoa, esse requisito também será aplicável.
1.5.4
Se o Produto coleta, armazena ou transmite Informações Pessoais, ele deve fazer isso com segurança, usando
métodos de criptografia moderna.
1.5.5
O Produto não deve coletar, armazenar nem transmitir informações pessoais altamente confidenciais, como
dados financeiros ou relativos à saúde física dos usuários, salvo se as informações estiverem relacionadas à
funcionalidade principal do Produto. O Produto também deve obter consentimento expresso do usuário antes
de coletar, armazenar ou transmitir essas informações. A política de privacidade do Produto deve informar
claramente ao usuário quando e por que ele está coletando Informações Pessoais e como você as usará.
1.5.6
Se o Produto der suporte à autenticação de identidade da Microsoft, ele deverá fazer isso usando somente
métodos aprovados pela Microsoft.
1.5.7
Os Produtos que recebem a localização de um dispositivo devem fornecer configurações que permitam ao
usuário habilitar e desabilitar o acesso e o uso da localização pelo Produto com base na API de Serviço de
Localização.
1.6 Funcionalidades
Se o Produto declarar o uso de funcionalidades, as funcionalidades declaradas pelo Produto deverão estar
relacionadas legitimamente às funções do Produto. O Produto não deve burlar as verificações do sistema
operacional para o uso da funcionalidade.
1.7 Localização
O Produto deve fornecer a localização de todos os idiomas com suporte. A experiência oferecida por um
produto deve ser relativamente semelhante em todos os idiomas aceitos.
1.8 Transações Financeiras
Se incluir compra realizada em produto, assinaturas, moeda virtual, funcionalidade de cobrança ou captura de
informações financeiras, seu produto deverá atender aos seguintes requisitos:
1.8.1
As ofertas em produto vendidas no seu produto não podem ser convertidas em nenhuma moeda legalmente
válida (por exemplo, dólares, euros etc.) nem em bens materiais ou serviços.
1.8.2
O Produto deve usar uma API de compra segura para compras de bens materiais ou serviços e uma API de
compra segura para pagamentos relacionados a jogos de azar do mundo real ou contribuições beneficentes. Se
o Produto for usado para facilitar ou coletar contribuições beneficentes ou para realizar concursos ou sorteios
promocionais, ele deverá fazer isso em conformidade com a lei aplicável. O Produto também deve declarar
claramente que a Microsoft não está levantando fundos, nem é responsável pela promoção.
O Produto deve usar uma API de compra segura para receber doações voluntárias dos usuários.
Os seguintes requisitos se aplicam ao uso que você faz de uma API de compra segura:
No momento da operação ou quando o Produto coletar informações financeiras ou de pagamento do
cliente, o Produto deverá identificar o provedor de transações comerciais, autenticar o usuário e obter a
confirmação do usuário para a transação.
O produto pode oferecer ao usuário a capacidade de salvar essa autenticação, mas o usuário deve ter a
capacidade de exigir uma autenticação em cada operação ou desativar transações no produto.
Se o Produto coletar informações de cartões de crédito ou usar um processador de pagamentos de terceiros
que coleta informações de cartões de crédito, o processador de pagamentos deverá atender ao PCI DSS
(Padrão de Segurança de Dados PCI) atual.
1.8.3
O Produto e os metadados associados a ele devem fornecer informações sobre os tipos de compras no produto
oferecidos e a faixa de preços. O Produto não pode enganar os clientes e deve ser claro quanto à natureza das
ofertas e das promoções no produto, incluindo o escopo e os termos de qualquer experiência de avaliação. Se o
Produto restringir o acesso ao conteúdo criado pelo usuário durante ou após a avaliação, ele deverá notificar os
usuários com antecedência. Além disso, o Produto deve deixar claro para os usuários que eles estão iniciando
uma opção de compra no Produto.
Se o seu jogo oferecer "caixas de loot" ou outros mecanismos que oferecem itens virtuais aleatórios, você
deverá divulgar as chances de receber cada item para os clientes antes da compra. Essas divulgações podem
aparecer: no produto, como em uma loja no aplicativo, na PDP (Página de Descrição de Produtos) da Microsoft
Store e/ou em um site do desenvolvedor ou do publicador, com um link da PDP da Loja e/ou no aplicativo.
10.8.4
Todos os preços, incluindo vendas ou descontos, de seus produtos ou serviços digitais devem estar em
conformidade com todas as leis, regulamentações e diretrizes normativas aplicáveis, incluindo, entre outros, os
Guias Contra Preços Enganosos da Comissão Comercial Federal dos EUA.
1.9 Notificações
Se o Produto der suporte a notificações, o Produto deverá respeitar as configurações do sistema para
notificações e permanecer funcional quando elas estiverem desabilitadas. Isso inclui a apresentação de anúncios
e notificações para o cliente, que também deve ser consistente com as preferências do cliente,
independentemente das notificações serem fornecidas pelo Serviço de Notificação por Push da Microsoft
(MPNS), Serviço de Notificação por Push do Windows (WNS) ou qualquer outro serviço. Se o cliente desabilitar
as notificações, seja de maneira específica no Produto ou em todo o sistema, o Produto deverá permanecer
funcional.
1.10 Conteúdo e Conduta de Publicidade
Os requisitos a seguir aplicam-se a todas as atividades relativas a publicidade:
1.10.1
O objetivo principal do Produto não deve ser fazer com que os usuários cliquem em anúncios.
O Produto não pode fazer nada que interfira ou diminua a visibilidade, o valor ou a qualidade de anúncios
que ele exibe.
O Produto deve respeitar as configurações de ID de anúncio que o usuário selecionou.
Todos os anúncios devem ser confiáveis, não enganosos e estar em conformidade com todas as leis,
regulamentações e diretrizes normativas aplicáveis.
Políticas de conteúdo
As políticas a seguir se aplicam ao conteúdo e aos metadados (incluindo o nome do fornecedor, nome do
Produto, ícone do Produto, descrição do Produto, capturas de tela do Produto, trailers do Produto e miniaturas
de trailers, além de outros metadados do Produto) oferecidos para distribuição no Gerenciador de Pacotes do
Windows. O conteúdo engloba o nome do Produto, o nome do fornecedor, o ícone do Produto, a descrição do
Produto, as imagens, os sons, os vídeos e o texto no Produto, os blocos, as notificações, as mensagens de erro
ou anúncios expostos por meio do Produto e qualquer coisa que seja entregue de um servidor ou com a qual o
Produto se conecta. Como o Produto e o Gerenciador de Pacotes do Windows são usados ao redor do mundo,
esses requisitos serão interpretados e aplicados no contexto de normas regionais e culturais.
2.1 Requisitos de Conteúdo Geral
O conteúdo dos metadados e qualquer outro conteúdo que você enviar para acompanhar seu envio devem
fazer jus à classificação PEGI 12, ESRB EVERYONE 10+ ou inferior.
2.2 Conteúdo Original e de Terceiros que Inclua Nomes e Logotipos
Todo o conteúdo existente em seu Produto e os metadados associados devem ser originalmente criados pelo
fornecedor do aplicativo, devidamente licenciados pelo detentor dos respectivos direitos dele, usados, conforme
permitido pelo detentor desses direitos ou usados de alguma forma permitida por lei.
2.3 Risco de Danos
2.3.1
O Produto não deve ter conteúdo que promova nem idealize as seguintes atividades do mundo real: (a)
violência extrema ou gratuita; (b) violações dos direitos humanos; (c) criação de armas ilícitas ou (d) uso de
armas contra pessoas, animais ou propriedade reais ou pessoais.
2.3.2
O Produto não deve: (a) representar um risco de segurança, nem resultar em desconforto, lesão ou outros
danos aos usuários finais ou a qualquer outra pessoa ou animal nem (b) representar um risco de ou resultar em
danos a propriedades reais ou pessoais. Você é unicamente responsável por todos os testes de segurança do
Produto, a aquisição de certificado e a implementação de proteções de recurso apropriadas. Você não
desabilitará nenhuma proteção nem recursos de conforto da plataforma, e deverá incluir todos os avisos, as
advertências e as isenções de responsabilidade legalmente necessários e padrão do setor no Produto.
2.4 Conteúdo Difamatório, Calunioso e Ameaçador
O Produto não pode ter nenhum conteúdo que seja difamatório, calunioso ou ameaçador.
2.5 Conteúdo Ofensivo
O Produto e os metadados associados não podem ter conteúdo potencialmente sigiloso ou ofensivo. O
conteúdo pode ser considerado ofensivo ou confidencial em determinados países/regiões devido a leis locais ou
normas culturais. Além disso, o Produto e os metadados associados não devem ter conteúdo que preconize a
discriminação, o ódio ou a violência com base em raça, etnia, nacionalidade, idioma, gênero, idade, deficiência,
religião, orientação sexual, status de veterano ou participação em qualquer outro grupo social.
2.6 Álcool, Tabaco, Armas e Drogas
O Produto não pode ter nenhum conteúdo que promova nem idealize o uso excessivo ou irresponsável de
Produtos derivados de álcool ou tabaco, drogas e armas.
2.7 Conteúdo para Adultos
O Produto não pode ter nem exibir conteúdo que uma pessoa razoável considerasse pornográfico ou
sexualmente explícito.
2.8 Atividade Ilícita
O Produto não pode ter conteúdo nem funcionalidade que incentive, promova ou idealize atividade ilícita no
mundo real.
2.9 Blasfêmias Graves e Conteúdo Impróprio
O Produto não pode conter linguagem chula nem blasfêmias gratuitas.
Além disso, não pode ter nem exibir conteúdo que uma pessoa razoável considere obsceno.
2.10 Requisitos Específicos de Países/Regiões
Não é permitido conteúdo ofensivo em qualquer país/região ao qual o Produto se destine. O conteúdo pode ser
considerado ofensivo em determinados países/regiões devido a leis locais ou normas culturais. Exemplos de
conteúdo potencialmente ofensivo em certos países/regiões incluem o seguinte:
China
Conteúdo sexual ofensivo
Referências a territórios ou regiões em disputa
Fornecer ou permitir acesso a conteúdo ou serviços considerados ilegais pelas leis locais pertinentes
2.11 Classificações Etárias
O Produto deve ter uma classificação de idade que seria uma classificação de RATING 12, ESRB EVERYONE 10
ou inferior.
2.11.1
Se o Produto fornecer conteúdo (como conteúdo comercial, gerado pelo usuário ou outro conteúdo baseado na
Web) que possa ser adequado para uma classificação etária superior à classificação etária atribuída, você deverá
permitir que os usuários aceitem receber esse conteúdo usando um filtro de conteúdo ou entrando com uma
conta preexistente.
2.12 Conteúdo Gerado pelo Usuário
O UGC (Conteúdo Gerado pelo Usuário) é o conteúdo com o qual os usuários contribuem para um aplicativo ou
Produto e que pode ser visualizado ou acessado por outros usuários em um estado online. Se o Produto
contiver UGC, o Produto deverá:
Publicar e disponibilizar aos usuários os termos de serviço do Produto e/ou as diretrizes de conteúdo para o
conteúdo gerado pelo usuário, seja no Produto ou no seu site.
Fornecer um meio para que os usuários relatem conteúdo inapropriado dentro do Produto para revisão do
desenvolvedor e remoção/desativação se violarem as diretrizes de conteúdo e/ou implementar um método
de detecção proativa de UGC inadequado ou prejudicial.
Remover ou desabilitar o UGC quando solicitado pela Microsoft.
Confira também
Histórico de alterações das políticas do Gerenciador de Pacotes do Windows
Código de Conduta do Gerenciador de Pacotes do Windows
Requisitos de contribuição do Gerenciador de Pacotes do Windows
Histórico de alterações das políticas do Gerenciador
de Pacotes do Windows
DATA VERSÃ O DO DO C UM EN TO DESC RIÇ Ã O DA A LT ERA Ç Ã O
25/05/2021 1,0 Publicação inicial de políticas do

Microsoft PowerToys: utilitários para personalizar o
Windows 10
O Microsoft PowerToys é um conjunto de utilitários criado para que usuários avançados ajustem e simplifiquem
a experiência do Windows 10 a fim de terem maior produtividade.
Suporte ao processador
x64 : Com suporte
x86 : Em desenvolvimento (confira problema nº 602)
ARM : Em desenvolvimento (confira problema nº 490)
Utilitários atuais do PowerToys

Os utilitários disponíveis no momento incluem:
Modo Ativo do PowerToys
O Modo Ativo foi criado para manter um computador ativo sem a necessidade de gerenciar as configurações de
energia e suspensão dele. Esse comportamento pode ser útil na execução de tarefas demoradas, garantindo que
o computador não entre no estado de suspensão nem desligue as telas.
Seletor de Cor
O Seletor de Cor é um utilitário de seleção de cores de todo o sistema que pode ser ativado com Win+Shift+C.
Escolha cores de qualquer aplicativo em execução; o seletor copiará automaticamente a cor para a área de
transferência em um formato definido. O Seletor de Cor também contém um editor que mostra um histórico
das cores previamente selecionadas, permitindo que você ajuste a cor selecionada e copie diferentes
representações de cadeia de caracteres. Esse código se baseia no Seletor de Cor do Martin Chrzan.
FancyZones
O FancyZones é um gerenciador de janelas que facilita a criação de layouts de janela complexos e o
posicionamento rápido de janelas nesses layouts.
Complementos do File Explorer
Os complementos do File Explorer permitem a renderização do painel de visualização no File Explorer para
exibir ícones SVG (.svg) e visualizações de arquivos Markdown (.md). Para habilitar o painel de visualização,
selecione a guia "Exibir" no File Explorer e selecione "Painel de Visualização".
Redimensionador de Imagem
O Redimensionador de Imagem é uma extensão do Windows Shell para redimensionar imagens rapidamente.
Com um simples clique com o botão direito do mouse no File Explorer, redimensione uma ou várias imagens
instantaneamente. Esse código é baseado no Redimensionador de Imagem do Brice Lambson.
Gerenciador de Teclado
O Gerenciador de Teclado permite que você personalize o teclado para ser mais produtivo remapeando as teclas
e criando seus próprios atalhos de teclado. Este PowerToy requer o Windows 10 1903 (build 18362) ou
posterior.
PowerRename
O PowerRename permite que você execute a renomeação, pesquisa e substituição de nomes de arquivo em
massa. Ele inclui recursos avançados, como o uso de expressões regulares, direcionamento de tipos de arquivo
específicos, visualização de resultados esperados e a capacidade de desfazer as alterações. Esse código é
baseado no SmartRename do Chris Davis.
PowerToys Run
O PowerToys Run pode ajudar você a pesquisar e iniciar seu aplicativo instantaneamente. Basta pressionar o
atalho Alt+Espaço e começar a digitar. Ele é de software livre e é modular para outros plugins. O Navegador
de Janelas também está incluído agora. Este PowerToy requer o Windows 10 1903 (build 18362) ou posterior.
Guia de Atalhos
O Guia de Atalhos da tecla Windows aparece quando um usuário pressiona ⊞ Win+? e mostra os atalhos
disponíveis para o estado atual da área de trabalho.
Futuros utilitários do PowerToys

Instale a versão experimental de pré-lançamento do PowerToys para experimentar os utilitários experimentais
mais recentes, incluindo:
Ativar mudo de videoconferência (experimental)
Ativar mudo de videoconferência é um jeito rápido de "ativar mudo" global do microfone e da câmera usando ⊞
Win+N durante uma chamada em conferência, independentemente do aplicativo atualmente em foco. Isso só
está incluído na versão de pré-lançamento/experimental do PowerToys e requer o Windows 10 1903 (build
18362) ou posterior.
Idiomas
No momento, o PowerToys está disponível nos seguintes idiomas: chinês (simplificado), chinês (tradicional),
tcheco, holandês, alemão, francês, húngaro, italiano, japonês, coreano, polonês, português, português (Brasil),
russo, espanhol e turco.
Observe que, muitas vezes, os novos elementos do aplicativo ainda não serão traduzidos na versão da primeira
versão.
Passo a passo em vídeo do PowerToys

Neste vídeo, Clint Rutkas (PM do PowerToys) instrui como instalar e usar os diversos utilitários disponíveis, além
de compartilhar algumas dicas e informações de como contribuir e muito mais.
Problemas conhecidos
Pesquise problemas conhecidos ou registre um novo problema na guia Problemas do repositório do PowerToys
no GitHub.
Contribuir com o PowerToys (software livre)

O PowerToys aprecia suas contribuições! A equipe de desenvolvimento do PowerToys tem o prazer de fazer
parceria com a comunidade de usuários avançados para criar ferramentas que ajudem os usuários a tirar o
máximo proveito do Windows. Há várias maneiras de contribuir:
Escrever uma especificação técnica
Enviar um conceito de design ou uma recomendação
Contribuir com a documentação
Identificar e corrigir bugs no código-fonte
Codificar novos recursos e utilitários do PowerToys
Antes de começar a trabalhar em um recurso que você gostaria de contribuir, leia o Guia do Colaborador . A
equipe do PowerToys ficará feliz em trabalhar com você para descobrir a melhor abordagem, fornecer diretrizes
e tutoria durante o desenvolvimento de recursos e ajudar a evitar esforços perdidos ou duplicados.
Notas sobre a versão do PowerToys

As notas sobre a versão do PowerToys estão listadas na página de instalação do repositório GitHub. Para
referência, você também pode encontrar a lista de verificação de lançamento no wiki do PowerToys.
Histórico do PowerToys
Inspirado pelo projeto do PowerToys da era Windows 95, esse recomeço oferece aos usuários avançados
maneiras de extrair mais eficiência do shell do Windows 10 e personalizá-lo para fluxos de trabalho individuais.
Uma ótima visão geral do PowerToys do Windows 95 pode ser encontrada aqui.
Roteiro do PowerToys
O PowerToys é uma equipe de software livre de incubação rápida, cujo objetivo é fornecer aos usuários
avançados maneiras de extrair mais eficiência do shell do Windows 10 e personalizá-lo para fluxos de trabalho
individuais. As prioridades de trabalho serão examinadas de maneira consistente, reavaliadas e ajustadas com o
objetivo de melhorar a produtividade dos usuários.
Novas especificações para o possível PowerToys
Lista de prioridade de pendências
Especificação de estratégia da versão 1.0, fevereiro de 2020
Instalar PowerToys
WARNING
Para instalar o PowerToys v0.37 e versões posteriores, é preciso ter o Windows 10 v1903 ou mais recente. As
configurações da v1, que são compatíveis com as versões mais antigas do Windows, foram removidas na v0.37.
É recomendável instalar o PowerToys via GitHub, mas também há métodos de instalação alternativos se você
preferir usar um gerenciador de pacotes.
Instalar com o arquivo executável do Windows

Para instalar PowerToys com um arquivo executável do Windows:
1. Visite a página de versões do Microsoft PowerToys no GitHub.
2. Procure a lista de versões estáveis e experimentais do PowerToys que estão disponíveis.
3. Clique no menu suspenso Ativos para ver os arquivos da versão.
4. Selecione o arquivo PowerToysSetup-0.##.#-x64.exe para baixar o instalador executável de PowerToys.
5. Depois, abra o arquivo executável e siga as instruções de instalação na tela.
Requisitos
O PowerToys (v0.37.0 e posterior) requer Windows 10 v1903 (18362) ou versões posteriores.
Runtime do .NET Core Desktop 3.1. O instalador do PowerToys trata esse requisito.
Arquitetura x64 é compatível no momento. A compatibilidade com ARM e x86 será disponibilizada
posteriormente.
Para garantir que o computador atenda a esses requisitos, verifique a versão e o número de build do Windows
10. Basta selecionar ⊞ Win+R, digitar winver e pressionar OK. Outra opção é digitar o comando ver no
prompt de comando do Windows. É possível atualizar para a versão mais recente do Windows no menu
Configurações do Windows .
Métodos de instalação alternativos

Windows Gerenciador de Pacotes (Versão Prévia)
Ferramentas de instalação controladas pela comunidade (sem suporte oficial)
Instalar com o Gerenciador de Pacotes do Windows (versão prévia)

Para instalar o PowerToys com a versão prévia do Gerenciador de Pacotes do Windows (WinGet):
1. Baixe o PowerToys no Gerenciador de Pacotes do Windows.
2. Execute o seguinte comando na linha de comando/no PowerShell:
WinGet install powertoys

Ferramentas de instalação controladas pela comunidade
Esses métodos de instalação alternativa controlados pela comunidade não têm suporte oficial e a equipe do
PowerToys não atualiza nem gerencia esses pacotes.
Instalar com o Chocolatey
Para instalar o PowerToys com o Chocolatey, execute o seguinte comando na linha de comando/no PowerShell:
choco install powertoys
Para atualizar o PowerToys, execute:
choco upgrade powertoys
Em caso de problemas de instalação/atualização, visite o pacote do PowerToys em Chocolatey.org e siga o

processo de triagem do Chocolatey.
Instalar com o Scoop
Para instalar o PowerToys com o Scoop, execute o seguinte comando na linha de comando/no PowerShell:
scoop bucket add extras

scoop install powertoys
Para atualizar o PowerToys, execute o seguinte comando na linha de comando/no PowerShell:
scoop update powertoys
Em caso de problemas na instalação/atualização, registre um problema no repositório do Scoop no GitHub.
Pós-instalação
Após a instalação do PowerToys, uma janela de visão geral mostrará as diretrizes introdutórias de cada utilitário
disponível.
Atualizações
O PowerToys usa um atualizador automático que verifica se há novas versões quando o aplicativo está em
execução. Se ele estiver habilitado, uma notificação do sistema será exibida quando uma atualização estiver
disponível. As atualizações também podem ser verificadas manualmente no menu "Configurações" do
PowerToys na página "Geral".
PowerToys executando com permissões elevadas do
administrador
Se você estiver executando qualquer aplicativo como administrador (também conhecido como permissões
elevadas), PowerToys o pode não funcionar corretamente quando os aplicativos com privilégios elevados
estiverem em foco ou tentar interagir com um PowerToys recurso como o FancyZones . Isso pode ser abordado
também em execução PowerToys como administrador.
Opções
Há duas opções para PowerToys dar suporte a aplicativos em execução como administrador (com permissões
elevadas):
[Recomendado] : PowerToys exibirá um prompt quando um processo elevado for detectado. abra
PowerToys Configurações. Na página geral, selecione reiniciar como administrador.
habilite sempre executar como administrador no PowerToys Configurações.
Processos elevados do administrador do execute as explicações

Windows os aplicativos são executados no modo de usuário por padrão. Executar um aplicativo no modo
administrativo ou como um processo elevado significa que o aplicativo será executado com acesso adicional ao
sistema operacional.
A maneira mais simples de executar um aplicativo ou programa no modo administrativo é clicar com o botão
direito do mouse no programa e selecionar Executar como administrador. Se o usuário atual não for um
administrador, Windows o solicitará o nome de usuário e a senha do administrador.
A maioria dos aplicativos não precisa ser executada com permissão elevada. Um cenário comum, no entanto,
para exigir permissão de administrador seria executar determinados comandos do PowerShell ou editar o
registro.
Se você vir esse prompt de controle de conta de usuário, o aplicativo está solicitando a permissão elevada de
nível de administrador:
No caso de uma linha de comando com privilégios elevados, normalmente o texto "administrador" será
anexado à barra de título.
Suporte para o modo admin com PowerToys

PowerToys o só precisa de permissão de administrador elevado ao interagir com outros aplicativos em execução
no modo de administrador. Se esses aplicativos estiverem em foco, PowerToys o poderá não funcionar, a menos
que também seja elevado.
Estes são os dois cenários nos quais não trabalharemos:
Interceptando determinados tipos de traços de teclado
Redimensionamento/movimentação de janelas
PowerToysUtilitários afetados
As permissões do modo de administrador podem ser necessárias nos seguintes cenários:
FancyZones
Ajustar uma janela com privilégios elevados (por exemplo, prompt de comando) em um FancyZone
Movendo a janela com privilégios elevados para uma zona diferente
Guia de atalho
Exibir atalho
Remapeador de teclado
Chave para remapeamento de chave
Remapeamento de atalhos de nível global
Remapeamento de atalhos direcionados para o aplicativo
PowerToys Funcionam
Exibir atalho
Utilitário Desacordado
O Sleep é uma ferramenta de utilitário para Windows projetado para manter um computador ativas sem
precisar gerenciar sua energia & de sleep. Esse comportamento pode ser útil na execução de tarefas demoradas,
garantindo que o computador não entre no estado de suspensão nem desligue as telas.
Introdução
O Alerta pode ser usado diretamente PowerToys configurações ou como um executável autônomo. Quando a
ferramenta está sendo PowerToys, ela pode ser gerenciada de PowerToys configurações ou da bandeja do
sistema.
NOTE
A opção Ativas não modifica nenhuma das Windows do plano de energia e não depende de uma configuração
personalizada do plano de energia. Em vez disso, ele gera threads em segundo plano que Windows que eles exigem um
estado específico do computador.
PowerToys configurações
Na exibição PowerToys configurações, inicie Ativar usando a alternância Habilitar Ativado. Uma vez
habilitado, o aplicativo gerenciará o estado de adoção do computador.
Os seguintes estados Desacordados podem ser selecionados:
Off (Passivo) – o estado de adoção do computador não é afetado. O aplicativo está aguardando a entrada
do usuário.
Manter-se ativamente indefinidamente – o computador permanece ativas indefinidamente até que o
usuário coloque explicitamente o computador em sleep ou saia/desabilite o aplicativo.
Manter a suspensão temporária – mantenha o computador a meio de um tempo limitado pré-definido.
Depois que o tempo passar, o computador retomará seu estado de adoção anterior.
NOTE
Alterar as horas ou minutos enquanto o computador é mantido amanhado temporariamente redefini o temporizador.
Manter a tela em
Embora o Modo Desacordado possa manter o computador ativas indefinidamente ou temporariamente, em seu
estado padrão, as exibições conectadas ao computador serão desligadas, mesmo que o computador não vá para
suspensão. Se você precisar que as exibições fiquem disponíveis, use a tela Manter na opção , que garantirá que
todos os monitores permaneçam ativas.
Bandeja do sistema
Para gerenciar a execução da ferramenta na bandeja do sistema, clique com o botão direito do mouse no ícone
Desacordado.
CLI (interface de linha de comando)

O Afuniado também pode ser executado como um aplicativo autônomo, diretamente da pasta PowerToys dados.
Os seguintes argumentos de linha de comando podem ser usados durante a execução PowerToys.Awake.exe no
terminal ou por meio de um arquivo de .lnk atalho:

--use-pt-config Use o arquivo PowerToys configuração para gerenciar as

configurações. Isso pressuém que há um arquivo para o
Awake, gerado por PowerToys, que contém todas as
settings.json informações de runtime necessárias. Isso
inclui o Modo de Comportamento (indefinido ou tempo), se
as telas devem ser mantidas e quais são os valores de horas
e minutos para um keep-on temporário.
Quando esse argumento é usado, todos os outros
argumentos são ignorados. O Alerta procurará alterações no
settings.json arquivo para atualizar seu estado.
--display-on Determina se as telas devem ser mantidas ou desligadas

enquanto a máquina é mantida ativas. Os valores esperados
são true ou false .
--time-limit Duração, em segundos, durante a qual a operação

Desacordada mantém o computador adorado. Pode ser
usado em combinação com --display-on .
--pid Anexa a execução de Desacordado a uma ID de Processo

(PID). Quando o processo com um determinado PID é
encerrado, o Desacordado também é encerrado.
Na ausência de argumentos de linha de comando, o Tipo Desacordado manterá o computador ativas

indefinidamente.
Utilitário seletor de cores
Um utilitário de separação de cores de todo o sistema para Windows 10 que permite que você escolha cores de
qualquer aplicativo em execução no momento e o copie automaticamente em um formato configurável para
sua área de transferência.
Introdução
Habilitar
Para começar a usar o seletor de cores, verifique se ele está habilitado na PowerToys seção Configurações
(seletor de cores).
Ativar
Uma vez habilitado, você pode escolher um dos três comportamentos a seguir para ser executado ao iniciar o
seletor de cores com o atalho de ativação Win + Shift + C (Observe que esse atalho pode ser alterado na
janela Configurações):
Seletor de cores com modo de editor habilitado – abre o seletor de cores. Depois de selecionar uma
cor, o editor é aberto e a cor selecionada é copiada para a área de transferência (no formato padrão-
configurável na caixa de diálogo Configurações).
Editor – abre o editor diretamente, a partir daqui, você pode escolher uma cor no histórico, ajustar uma cor
selecionada ou capturar uma nova cor com abrindo o seletor de cores.
Somente seletor de cores – abre apenas o seletor de cores e a cor selecionada será copiada para a área de
transferência.
Selecionar cor
Depois que o seletor de cores for ativado, passe o cursor do mouse sobre a cor que deseja copiar e clique com o
botão esquerdo do mouse para selecionar uma cor. Se você quiser ver a área ao seu cursor mais
detalhadamente, role para cima para ampliar.
A cor copiada será armazenada na área de transferência no formato configurado nas configurações (HEX, por
padrão).
Uso do editor
O editor permite que você veja o histórico de cores selecionadas (até 20) e copie sua representação em
qualquer formato de cadeia de caracteres predefinido. Você pode configurar quais formatos de cor são visíveis
no editor e em qual ordem eles aparecem. Essa configuração pode ser encontrada em PowerToys configurações.
O editor também permite ajustar qualquer cor separada ou obter uma nova cor semelhante. O editor visualiza
diferentes tons de cor atualmente selecionados: 2 mais claro e 2 mais escuros.
Clicar em qualquer um desses tons de cores alternativos adicionará a seleção ao histórico de cores selecionadas
(aparecerá na parte superior da lista de histórico de cores). A cor no meio representa a cor selecionada no
momento no histórico de cores. Ao clicar nele, o controle de configuração de ajuste fino aparecerá, onde você
poderá alterar os valores de matiz ou RGB da cor atual. Pressionar Select adicionará a cor recentemente
configurada no histórico de cores.
Para remover qualquer cor do histórico de cores, clique com o botão direito do mouse em uma cor e selecione
remover .
Configurações
O seletor de cor permitirá que você altere as seguintes configurações:
Atalho de ativação
Comportamento do atalho de ativação
Formato de uma cor copiada (HEX, RGB, etc.)
Ordem e aparência dos formatos de cor no editor
Limitações
O seletor de cores não pode ser exibido na parte superior do menu iniciar ou da central de ações (você ainda
pode escolher uma cor).
Se o aplicativo focalizado atualmente tiver sido iniciado com uma elevação de administrador (executar como
administrador), o atalho de ativação do seletor de cor não funcionará, a menos que PowerToys também
tenha sido iniciado com uma elevação de administrador.
FancyZones utilitários
FancyZones o é um utilitário do Gerenciador de janelas para organizar e encaixar janelas em layouts eficientes
para melhorar a velocidade do fluxo de trabalho e restaurar os layouts rapidamente. FancyZones permite que o
usuário defina um conjunto de locais de janela para uma área de trabalho que são destinos de arrastar para
Windows. Quando o usuário arrasta uma janela para uma zona, a janela é redimensionada e reposicionada para
preencher essa zona.
Introdução
Habilitar
Para começar a usar FancyZones o, você precisa habilitar o utilitário em PowerToys configurações e, em seguida,
invocar a FancyZones interface do usuário do editor.
Iniciar editor de zonas
inicie o editor de zonas usando o botão no PowerToys menu Configurações ou pressionando Win + ` ("back-
tick" ou "acento grave"; observe que esse atalho pode ser alterado na caixa de diálogo configurações).
Aplicativos de administrador de permissão elevada
Se você tiver aplicativos com privilégios elevados, execute no modo de administrador, leia PowerToys e execute
como administrador para obter mais informações.
Escolha seu layout (editor de layout)

Quando iniciado pela primeira vez, o editor de zonas apresenta uma lista de layouts que podem ser ajustados
por quantas janelas estão no monitor. A escolha de um layout mostra uma visualização desse layout no monitor.
O layout selecionado é aplicado automaticamente. Clicar duas vezes no layout irá aplicá-lo e fechar
automaticamente o editor.
Se vários monitores estiverem em uso, o editor detectará os monitores disponíveis e os exibirá para que o
usuário escolha entre. O monitor escolhido será então o destino do layout selecionado.
Espaço em volta de zonas

A caixa de seleção Mostrar espaço ao redor de zonas permite que você determine qual tipo de borda ou
margem envolverá cada Fancy Zone janela. O campo espaço ao contrário de zonas permite que você defina
um valor personalizado para a largura da margem. Com o Zones Editor aberto, altere o espaço de exibição
ao contrário das zonas depois de alterar os valores para ver o novo valor aplicado.
A distância para realçar zonas adjacentes permite que você defina um valor personalizado para a
quantidade de espaço entre as zonas até que elas se encaixem ou antes de ambas serem realçadas, permitindo
que elas sejam mescladas.
Criando um layout personalizado

O editor de zonas também dá suporte à criação e ao salvamento de layouts personalizados. Selecione o botão +
criar novo layout na parte inferior direita.
Há duas maneiras de criar layouts de zona personalizados: layout de grade e layout de tela . Eles também
podem ser considerados como modelos subtraíis e aditivos.
O modelo de grade subtraído começa com uma grade de três colunas e permite que as zonas sejam criadas
pela divisão e mesclagem de zonas, redimensionando a medianiz entre as zonas conforme desejado.
Para mesclar duas zonas, selecione e mantenha o botão esquerdo do mouse e arraste o mouse até que uma
segunda zona seja selecionada e, em seguida, solte o botão e um menu pop-up será exibido.
O modelo de tela aditiva começa com um layout em branco e dá suporte à adição de zonas que podem ser
arrastadas e redimensionadas de forma semelhante ao Windows.
O layout da tela também tem suporte de teclado para edição de zona. Use as teclas de direção (para cima, para
baixo, para a esquerda, para a direita) para mover uma zona por 10 pixels ou para Ctrl + para mover uma zona
em 1 pixel. Use as + teclas deseta Shift para redimensionar uma zona por 10 pixels (5 por borda) ou Ctrl +
Shift + para redimensionar uma zona por 2 pixels (1 por borda). Para alternar entre o editor e a caixa de
diálogo, pressione as teclas Ctrl + Tab .
Alteração rápida entre layouts
Com um layout personalizado, esse layout pode ser configurado para uma tecla de atalho definida pelo usuário
para aplicá-la rapidamente à área de trabalho desejada. A tecla de atalho pode ser definida abrindo o menu
Editar do layout personalizado. Uma vez definido, o layout personalizado pode ser aplicado pressionando-se a
ligação do Win + Ctrl + ALT + [number] . O layout também pode ser aplicado pressionando a tecla de atalho
ao arrastar uma janela.
Na demonstração abaixo, começamos com um modelo padrão aplicado à tela e 2 layouts personalizados para
os quais atribuímos teclas de transferência. Em seguida, usamos a associação de " + + ALT + [number] do Win
para aplicar o primeiro layout personalizado e ajustar uma janela a ela. Por fim, aplicamos o segundo layout
personalizado ao arrastar uma janela e ajustar a janela a ela.
Ajustando uma janela a duas ou mais zonas
Se duas zonas estiverem adjacentes, uma janela poderá ser encaixada na soma de sua área (arredondada para o
retângulo mínimo que contém ambos). Quando o cursor do mouse está próximo da borda comum de duas
zonas, ambas as zonas são ativadas simultaneamente, permitindo que você descarte a janela em ambas as
zonas.
Também é possível se ajustar a qualquer número de zonas: primeiro, arraste a janela até que uma zona seja
ativada, pressione e mantenha pressionada a tecla Control enquanto arrasta a janela para selecionar várias
zonas.
Para ajustar uma janela a várias zonas usando apenas o teclado, primeiro marque as duas opções substituir
Windows teclas de aderência (Win + Seta) para mover entre zonas e mover as janelas com base
em sua posição . Depois de ajustar uma janela a uma zona, use Win + Ctrl + ALT + [Arrows] para expandir
a janela para várias zonas.
Teclas de Atalho
ATA L H O AÇÃO
⊞ Win+` Inicia o editor (esse atalho pode ser alterado na janela

Configurações)
⊞ Win + esquerda/direita Mover janela focada entre zonas (somente se a configuração

substituir Windows teclas de aderência estiver ativada,
nesse caso, somente os ⊞ Win + ← e ⊞ Win + → serão
substituídos, enquanto o ⊞ Win + ↑ e o ⊞ Win + ↓
continuarão funcionando como de costume)
FancyZonesnão substitui a Windows seta de 10 ⊞ do Win + Shift + para mover rapidamente uma janela para
um monitor adjacente.
Configurações
C O N F IGURA Ç Ã O DESC RIÇ Ã O
Configurar a tecla de atalho do editor de zona Para alterar a tecla de atalho padrão, clique na caixa de texto
e pressione a combinação de teclas desejada no teclado (não
é necessário selecionar ou excluir o texto)
Seguir o cursor do mouse em vez de se concentrar ao iniciar Quando marcada, o editor será iniciado no monitor onde
o editor em um ambiente de vários monitores está o cursor do mouse. Quando desmarcada, o editor será
iniciado no monitor em que a janela ativa atual é
Manter a tecla Shift pressionada para ativar zonas ao Alterna entre o modo de ajuste automático com a tecla
arrastar Shift (desabilitando o ajuste durante um arrastar) e o
modo de ajuste manual onde pressionar a tecla Shift durante
uma operação de arrastar habilita o ajuste
Usar um botão não primário do mouse para alternar a Clicar em um botão não primário do mouse alterna a
ativação da zona ativação de zonas
Mostrar zonas em todos os monitores ao arrastar uma Por padrão, FancyZones o mostra apenas as zonas
janela disponíveis no monitor atual. (Esse recurso pode ter um
impacto no desempenho quando marcado)
Permitir que as zonas abranjam entre monitores (todos os Permite tratar todos os monitores conectados como uma
monitores devem ter o mesmo ajuste de DPI) tela grande. Para funcionar corretamente, é necessário que
todos os monitores tenham o mesmo fator de escala de DPI
(pode haver efeitos inesperados ao usar monitores em
orientações diferentes)
Substituir as Windows teclas de aderência de ajuste (Win + Quando essa opção está marcada e FancyZones está em
Seta) para mover entre zonas execução, ela substitui duas Windows chaves de ajuste: ⊞
Win + Left e ⊞ Win + Right
Mover janelas com base em sua posição Permite usar setas de vitória ⊞ + para ajustar uma janela
com base em sua posição em relação ao layout da zona
Mover janelas entre zonas em todos os monitores Desmarcado: o ajuste com a seta do ⊞ Win + circula a janela
pelas zonas no monitor atual.
Marcado: circula a janela por todas as zonas em todos os
monitores
Manter as janelas em suas zonas quando a resolução da tela FancyZones redimensionará e reposicionará janelas nas
for alterada zonas em que estavam antes após uma alteração de
resolução de tela
Durante as alterações de layout de zona, o Windows FancyZones irá redimensionar e posicionar janelas no novo
atribuído a uma zona corresponderá ao novo layout de zona mantendo o local de número de zona
tamanho/posição anterior de cada janela
Mover as janelas recém-criadas para a última zona Mover automaticamente uma janela aberta recentemente
conhecida para a última localização de zona em que o aplicativo estava
Mover as janelas recém-criadas para o monitor ativo atual Quando essa opção estiver marcada e Mover janelas recém-
[experimental] criadas para a última zona conhecida estiver desmarcada ou
o aplicativo não tiver uma última zona conhecida, ele
manterá o aplicativo no monitor ativo atual
Restaurar o tamanho original das janelas ao desatar Desaquear uma janela restaurará seu tamanho como antes
de ser encaixada
Tornar a janela arrastada transparente Quando as zonas são ativadas, a janela que está sendo
arrastada fica transparente para melhorar a visibilidade das
zonas
Habilitar a opção de layout rápido Permite que as teclas de atalho mudem rapidamente os
layouts – consulte configurações de layout individuais
Zonas flash ao alternar o layout As zonas piscarão quando um layout for selecionado por
meio do atalho
Zone cor de realçada A cor de uma zona quando ela é o destino de soltar ativo
durante um arrastar de janela (padrão: #008CFF)
Zone Cor inativa A cor das zonas quando elas não são uma queda ativa
durante um arrastar de janela (padrão: #F5FCFF)
Zone cor da borda A cor da borda de zonas ativas e inativas (padrão: #FFFFFF)
Zone opacidade (%) O percentual de opacidade de zonas ativas e inativas

(padrão: 50%)
Excluir aplicativos de ajuste para zonas Adicione o nome do aplicativo ou parte do nome, um por
linha (por exemplo, adicionar corresponderá a e ; para
corresponder apenas Notepad Notepad.exe adicionar a
Notepad++.exe Notepad.exe .exe extensão)
File Explorer Utilitário de complementos
File Explorer Os complementos atualmente incluem:

Renderização do Painel de Visualização de ícones SVG (.svg)
Renderização do Painel de Visualização de arquivos Markdown (.md)
Renderização do painel de visualização de arquivos PDF (.pdf)
Visualização do ícone de miniatura para ícones de SVG
Visualização do ícone de miniatura para arquivos PDF
Visualize o painel
O Painel de Visualização é um recurso existente no que mostra uma versão prévia leve, rica e somente leitura do
conteúdo do arquivo no painel Windows File Explorer de leitura da exibição. PowerToys adiciona três extensões,
Markdown, SVG e PDF.
Habilitando o Painel de Visualização

Para habilitar, primeiro verifique se na versão prévia Configurações "Habilitar versão prévia do PowerToys SVG
(.svg)", "Habilitar miniaturas SVG (.svg)", "Habilitar visualização de PDF (.pdf)", "Habilitar miniaturas de PDF
(.pdf) " e "Habilitar visualização de Markdown (.md) estão todas definidas como On .
Em seguida, Windows File Explorer abra , selecione a guia Exibir na faixa de opções e selecione File Explorer
Visualizar Painel .
Image Resizer Utilitário
Image Resizer é uma Windows extensão de shell para reespacoriação de imagem em massa. Depois de instalar
o , clique com o botão direito do mouse em um ou mais arquivos de imagem selecionados no e selecione
PowerToys File Explorer Resize pictures no menu.
Arrastar e soltar
Image Resizer também permite que você reize imagens arrastando e soltando os arquivos selecionados com o
botão direito do mouse . Isso permite que você salve rapidamente suas imagens resized em uma pasta
diferente.
Configurações
Dentro da PowerToys Image Resizer guia, você pode definir as configurações a seguir.
Tamanhos
Adicione novos tamanhos predefinidos. Cada tamanho pode ser configurado como Fill, Fit ou Stretch. A
dimensão a ser usada para re dimensionamento também pode ser configurada como Centímetros, Polegadas,
Porcentagem e Pixels.
Fill vs Fit vs Stretch
Preenchimento: Preenche todo o tamanho especificado com a imagem. Dimensiona a imagem
proporcionalmente. Esvae a imagem conforme necessário.
Ajustar : Ajusta toda a imagem ao tamanho especificado. Dimensiona a imagem proporcionalmente. Não
recorta a imagem.
Stretch: Preenche todo o tamanho especificado com a imagem. Alonga a imagem desproporcionalmente
conforme necessário. Não recorta a imagem.
NOTE
Se Ignorar a orientação das imagens estiver marcada, a largura e a altura do tamanho especificado poderão ser
trocadas para corresponder à orientação (retrato/paisagem) da imagem atual. Em outras palavras: se marcada, o menor
número (em largura/altura) nas configurações será aplicado à menor dimensão da imagem. Independentemente de isso
ser declarado como largura ou altura. A ideia é que fotos diferentes com diferentes orientações (como fotos de férias)
ainda terão o mesmo tamanho.
Codificação de fallback
O codificador de fallback é usado quando o arquivo não pode ser salvo em seu formato original. Por exemplo, o
formato de imagem Metafile (.wmf) tem um decodificador para ler a imagem, mas nenhum codificador para
Windows gravar uma nova imagem. Nesse caso, a imagem não pode ser salva em seu formato original. Image
Resizer permite que você especifique qual formato o codificador de fallback usará: configurações PNG, JPEG,
TIFF, BMP, GIF ou WMPhoto. Essa não é uma ferramenta de conversão de tipo de arquivo, mas funciona apenas
como um fallback para formatos de arquivo sem suporte.
Arquivo
O nome do arquivo da imagem resized pode ser modificado com os seguintes parâmetros:
PA RÂ M ET RO RESULTA DO
%1 Nome do arquivo original
%2 Nome do tamanho (conforme configurado nas PowerToys

Image Resizer configurações)
%3 Largura selecionada
%4 Altura selecionada
%5 Altura real
%6 Largura real
Por exemplo, definir o formato de nome de arquivo como: no arquivo e selecionar a configuração de tamanho
do arquivo %1 (%2) example.png Small resultaria no nome do arquivo example (Small).png . Definir o
formato como no arquivo e selecionar a %1_%4 example.jpg configuração de Medium 1366 x 768px tamanho
resultaria no nome do arquivo: example_768.jpg .
Você pode especificar um diretório no formato de nome de arquivo para agrupar imagens resized em subd
diretórios. Por exemplo, um valor de %2\%1 salvaria as imagens resized em Small\example.jpg
Você também pode optar por manter a data da última modificação original na imagem relizada.
Largura/altura automática
Você pode deixar a altura ou a largura vazia. Isso vai seguir a dimensão especificada e "bloquear" a outra
dimensão a um valor proporcional à taxa de proporção da imagem original.
Keyboard Manager Utilitário
O PowerToys Keyboard Manager permite redefinir as teclas no teclado.

Por exemplo, você pode trocar a letra A pela letra B no teclado. Quando você pressionar a tecla A, um B
será exibido.
Você também pode trocar combinações de teclas de atalho. Por exemplo: a tecla de atalho Ctrl + C copiará o
texto Microsoft Word. Com PowerToys Keyboard Manager o utilitário , você pode trocar esse atalho por ⊞ Win +
C. Agora, ⊞ O Win + C copiará o texto. Se você não especificar um aplicativo de alvo no , a PowerToys Keyboard
Manager troca de atalhos será aplicada globalmente em Windows .
PowerToysKeyboard Managerdeve ser habilitado (com a execução em segundo plano) para que as PowerToys
teclas e atalhos remapped sejam aplicados. Se PowerToys não estiver em execução, o remapeamento de chave
não será mais aplicado.
NOTE
Há algumas teclas de atalho reservadas para o sistema operacional e não podem ser substituídas. As chaves que não
podem ser remapped incluem:
⊞ Win + L e Ctrl + Alt + Del não podem ser remapped, pois são reservados pelo Windows sistema operacional.
A chave Fn (função) não pode ser remapped (na maioria dos casos). As teclas ~ F1 F12 (e F13 ~ F24) podem ser
mapeadas.
Pausar enviará apenas um único evento keydown. Portanto, mapeá-lo em relação à chave de backspace, por
exemplo, e pressionar e segurar excluirá apenas um único caractere.
Configurações
Para criar mapeamentos com Keyboard Manager , você precisará abrir o PowerToys Configurações. Dentro
PowerToys Configurações, na Keyboard Manager guia , você verá opções para:
Iniciar a janela de configurações Remapear Chaves pressionando Remapear uma chave
Iniciar a janela de configurações Remapear Atalhos pressionando Remapear um atalho
Remapear chaves
Para remapear uma chave, alterando-a para um novo valor, iniciar a janela Remapa de configurações do teclado
com o botão Remapear uma Chave. Quando lançado pela primeira vez, nenhum mapeamento predefinido
será exibido. Você deve selecionar o + botão para adicionar um novo remapa.
Depois que uma nova linha de remapa for exibida, selecione a chave de entrada cuja saída você deseja alterar na
coluna "Chave". Selecione o novo valor de chave a ser atribuído na coluna "Mapeado para".
Por exemplo, se você quiser pressionar A e B aparecer:
C H AVE: M A P EA DO PA RA :
A B
Para trocar posições de chave entre as chaves A e B, adicione outro remapeamento com:
B A
Tecla para atalho

Para remapear uma chave para um atalho (combinação de teclas), insira a combinação de teclas de atalho na
coluna "Mapeado para".
Por exemplo, se você quiser selecionar a tecla Ctrl e fazer com que ela resulte ⊞ Win + ← em (seta para a
esquerda):
Ctrl ⊞ Win + ←
NOTE
O remapeamento de chave será mantido mesmo que a chave remapeada seja usada dentro de outro atalho. A ordem do
keypress é importante nesse cenário, pois a ação é executada durante o keydown, não o keyup. Por exemplo, pressionar
Ctrl + C resultaria em ⊞ Win + left arrow + C . Pressionar a tecla Ctrl primeiro executará ⊞ Win +
left arrow . Pressionar a tecla C primeiro executará C + ⊞ Win + left arrow .
Remapear atalhos
Para remapear uma combinação de teclas de atalho, como Ctrl + C,pressione Remapear um atalho para
iniciar a janela De novo mapa de configurações de atalhos.
Quando lançado pela primeira vez, nenhum mapeamento predefinido será exibido. Você deve selecionar o +
botão para adicionar um novo remapa.
Depois que uma nova linha de remapa for exibida, selecione as chaves de entrada cuja saída você deseja alterar
na coluna "Atalho". Selecione o novo valor de atalho a ser atribuído na coluna "Mapeado para".
Por exemplo, o atalho Ctrl + C copia o texto selecionado. Para remapear os atalhos para usar a tecla Alt,
em vez da tecla Ctrl:
ATA L H O : M A P EA DO PA RA :
Alt + C Ctrl + C
Há algumas regras a seguir ao remapear atalhos (essas regras se aplicam apenas à coluna "Atalho"):
Os atalhos devem começar com uma tecla modificadora: Ctrl, Shift, Altou ⊞ Win
Os atalhos devem terminar com uma tecla de ação (todas as chaves não modificadora): A, B, C, 1, 2, 3 etc.
Os atalhos não podem ter mais de 3 teclas
Remapear um atalho para uma única chave
É possível remapear um atalho (combinação de teclas) para uma única tecla pressionando selecionando o botão
Remapear um atalho no PowerToys Configurações.
Por exemplo, para substituir o atalho ⊞ Win← (seta para a esquerda) por uma única tecla, + pressione Alt:
ATA L H O : M A P EA DO PA RA :
⊞ Win + ← Alt
NOTE
O remapeamento de atalho será mantido mesmo se a tecla remapeada for usada dentro de outro atalho. A ordem do
keypress é importante nesse cenário, pois a ação é executada durante o keydown, não o keyup. Por exemplo, pressionar ⊞
Win + ← + Shift resultaria em Alt + Shift .
Atalhos específicos do aplicativo

Keyboard Manager permite que você remapear atalhos somente para aplicativos específicos (em vez de
globalmente em Windows ).
Por exemplo, no aplicativo Outlook email, o atalho CtrlE é definido por padrão para + pesquisar um email. Se
preferir definir CtrlF para pesquisar seu email (em vez de encaminhar um email conforme definido por
padrão), você poderá remapear o atalho com "Outlook" definido como seu "Aplicativo de + destino".
Keyboard Manager usa os nomes de processo (não nomes de aplicativo) para direcionar aplicativos. Por
exemplo, Microsoft Edge é definido como "msedge" (nome do processo), não "Microsoft Edge" (nome do
aplicativo). Para encontrar o nome do processo de um aplicativo, abra o PowerShell e insira o comando ou abra
o Prompt de Comando get-process e insira o comando tasklist . Isso resultará em uma lista de nomes de
processo para todos os aplicativos que você tem abertos no momento. Abaixo está uma lista de alguns nomes
de processo de aplicativo populares.
A P L IC AT IVO N O M E DO P RO C ESSO
Microsoft Edge msedge.exe
OneNote onenote.exe
Outlook outlook.exe
Teams Teams.exe
Adobe Photoshop Photoshop.exe
File Explorer explorer.exe
Spotify Música spotify.exe
Google Chrome chrome.exe
Excel excel.exe
A P L IC AT IVO N O M E DO P RO C ESSO
Word winword.exe
PowerPoint powerpnt.exe
Chaves que não podem ser remapped

Há certas teclas de atalho que não são permitidas para remapeamento. Estão incluídos:
Ctrl + Alt + Del (comando de interrupção)
⊞ Win + L (bloquear o computador)
A chave de função Fn não pode ser remapped (na maioria dos casos), mas F1 ~ F12 pode ser mapeada.
Como selecionar uma chave

Para selecionar uma tecla ou atalho para remapear, você pode:
Use o botão Tecla de Tipo ou Atalho de Tipo.
Use o menu suspenso.
Depois de selecionar o botão Tecla de Tipo ou Atalho de Tipo, uma janela de diálogo será aberta na qual você
poderá inserir a tecla ou o atalho usando o teclado. Quando estiver satisfeito com a saída, mantenha Enter para
continuar. Se você quiser sair do diálogo, mantenha o botão Esc pressionado.
Usando o menu suspenso, você pode pesquisar com o nome da chave e os valores suspensos adicionais serão
exibidos conforme o progresso. No entanto, você não pode usar o recurso type-key enquanto o menu suspenso
está aberto.
Chaves órfãs
Órfão de uma chave significa que você a mapeou para outra chave e não tem mais nada mapeado para ela.
Por exemplo, se a chave for remapped de para , uma tecla não existirá mais no teclado A B que resulta em A
. Para garantir que isso não aconteça por acidente, um aviso será exibido para todas as chaves órfãs. Para
corrigir isso, use + para criar outra chave mapeada mapeada para resultar em A .
Perguntas frequentes
Eu remapped as chaves erradas, como posso parar isso rapidamente?
Para que o remapeamento de chave funcione, PowerToys deve estar em execução em segundo plano e deve ser
Keyboard Manager habilitado. Para interromper as chaves remapped, feche PowerToys ou desabilite o Keyboard
Manger nas PowerToys configurações.
Posso usar Keyboard Manager na tela de logoff?
Não, só está disponível quando está em execução e não funciona em nenhuma tela Keyboard Manager
PowerToys de senha, incluindo enquanto Executar como Administrador.
Preciso reiniciar meu computador ou PowerToys para que o remapeamento entre em vigor?
Não, o remapeamento deve ocorrer imediatamente após pressionar OK.
Onde estão os perfis do Mac/Linux?
No momento, os perfis do Mac e do Linux não estão incluídos.
Isso funcionará em jogos de vídeo?
Depende de como o jogo acessa suas chaves. Determinadas APIs de teclado não funcionam com Keyboard
Manager .
O remapeamento funcionará se eu alterar meu idioma de entrada?
Sim, ele fará isso. Agora, se você remapear A para B no teclado inglês (EUA) e, em seguida, alterar a
configuração de idioma para francês, digitar A no teclado francês (Q no teclado físico inglês dos EUA) resultará
em , isso é consistente com como o trata a entrada B Windows multilíngue.
Solução de problemas
Se você tentou remapear uma tecla ou atalho e está tendo problemas, pode ser um dos seguintes problemas:
Executar como administrador : O remapeamento não funcionará em um aplicativo ou janela se essa
janela estiver em execução no modo de administrador (com privilégios elevados) e não estiver em
execução PowerToys como administrador. Tente executar PowerToys como administrador.
Não interceptando chaves: O Keyboard Manger intercepta ganchos de teclado para remapear suas
chaves. Alguns aplicativos que também fazem isso podem interferir no Keyboard Manager . Para corrigir
isso, vá para as configurações e desabilite e reabilitar Keyboard Manager .
Indicador de luz de caps não está sendo agregação corretamente
Os remapas não estão funcionando para o FancyZones e Guia de Atalhos
Remapear chaves como Win, Ctrl, Alt ou Shift pode quebrar gestos e alguns botões especiais
Consulte a lista de problemas abertos do gerenciador de teclado.
PowerRename utilitários
PowerRename o é uma ferramenta de renomeação em massa que permite que você:

Modifique os nomes de arquivo de um grande número de arquivos (sem dar a todos os arquivos o mesmo
nome).
Execute uma pesquisa e substitua em uma seção de destino de nomes de arquivo.
Executar uma expressão regular renomear em vários arquivos.
Verifique os resultados de renomeação esperados em uma janela de visualização antes de finalizar uma
renomeação em massa
Desfazer uma operação de renomeação depois que ela for concluída.
Demonstração
Nesta demonstração, todas as instâncias do nome de arquivo " Pampalona " são substituídas por "Pamplona".
Como todos os arquivos são nomeados exclusivamente, isso levaria muito tempo para ser concluído
manualmente um por um. PowerRename habilita uma única renomeação em massa. Observe que o comando
"desfazer renomear" do Gerenciador (Ctrl + Z) habilita a capacidade de desfazer a última alteração.
PowerRename AdicionarMenu
depois de selecionar alguns arquivos Windows File Explorer , clicar com o botão direito do mouse e selecionar
PowerRename (que será exibido somente quando habilitado no PowerToys), a PowerRename janela será
exibida. O número de itens que você selecionou será exibido, juntamente com os valores de Pesquisar e
substituir, uma lista de opções e uma janela de visualização que exibe os resultados da pesquisa e os valores de
substituição que você inseriu.
Procurar
Insira texto ou uma expressão regular para localizar os arquivos em sua seleção que contêm os critérios
correspondentes à sua entrada. Você verá os itens correspondentes na janela de Visualização .
Substitua por
Insira o texto para substituir a pesquisa pelo valor inserido anteriormente que corresponde aos arquivos
selecionados. Você pode exibir o nome do arquivo original e o arquivo renomeado na janela de Visualização .
Opções-usar expressões regulares
Se marcada, o valor de pesquisa será interpretado como uma expressão regular ( regex ). O valor de replace
também pode conter regex variáveis (veja os exemplos abaixo). Se não estiver marcada, o valor de pesquisa será
interpretado como texto sem formatação a ser substituído pelo texto no campo substituir.
Para obter mais informações sobre a opção usar a biblioteca de aumento no menu configurações para
funcionalidades estendidas regex , consulte a seção expressões regulares.
Opções-diferencia maiúsculas de minúsculas
Se marcada, o texto especificado no campo de pesquisa só corresponderá ao texto nos itens se o texto for o
mesmo caso. A correspondência de maiúsculas e minúsculas não será diferenciada (não reconhecendo uma
diferença entre letras maiúsculas e minúsculas) por padrão.
Opções – corresponder todas as ocorrências
Se marcada, todas as correspondências de texto no campo de pesquisa serão substituídas pelo texto de
substituição. Caso contrário, somente a primeira instância da pesquisa de texto no nome do arquivo será
substituída (da esquerda para a direita).
Por exemplo, dado o nome do arquivo: powertoys-powerrename.txt :
Pesquisar por: power
Renomear com: super
O valor do arquivo renomeado resultaria em:
Corresponder todas as ocorrências (desmarcadas): supertoys-powerrename.txt
Corresponder todas as ocorrências (marcadas): supertoys-superrename.txt
Opções-excluir arquivos
Os arquivos não serão incluídos na operação.
Opções-excluir pastas
As pastas não serão incluídas na operação.
Opções-excluir itens de subpasta
Os itens dentro das pastas não serão incluídos na operação. Por padrão, todos os itens de subpastas são
incluídos.
Opções – enumerar itens
Acrescenta um sufixo numérico aos nomes de arquivo que foram modificados na operação. Por exemplo:
foo.jpg → foo (1).jpg
Opções-somente nome do item

Somente a parte do nome do arquivo (não a extensão do arquivo) é modificada pela operação. Por exemplo:
txt.txt → NewName.txt
Opções-somente extensão de item

Somente a parte da extensão de arquivo (não o nome do arquivo) é modificada pela operação. Por exemplo:
txt.txt → txt.NewExtension
Substituir usando data e hora de criação de arquivo

Os atributos de data e hora de criação de um arquivo podem ser usados no substituir por texto inserindo um
padrão de variável de acordo com a tabela abaixo.
PA DRÃ O DE VA RIÁVEL EXP L IC A Ç Ã O
$YYYY Ano representado por um total de quatro ou cinco dígitos,

dependendo do calendário usado.
$YY Ano representado apenas pelos dois últimos dígitos. Um

zero à esquerda é adicionado a anos de um único dígito.
$Y Ano representado apenas pelo último dígito.
$MMMM Nome do mês
$MMM Nome abreviado do mês
$MM Mês como dígitos com zeros à esquerda para meses de

dígito único.
$M Mês como dígitos sem zeros à esquerda para meses de

dígito único.
$DDDD Nome do dia da semana

PA DRÃ O DE VA RIÁVEL EXP L IC A Ç Ã O
$DDD Nome abreviado do dia da semana
$DD Dia do mês como dígitos com zeros à esquerda para dias de
dígito único.
$D Dia do mês como dígitos sem zeros à esquerda para dias de

dígito único.
$hh Horas com zeros à esquerda para horas de dígito único
$h Horas sem zeros à esquerda para horas de dígito único
$mm Minutos com zeros à esquerda para minutos de dígito único.
$m Minutos sem zeros à esquerda para minutos de dígito único.
$ss Segundos com zeros à esquerda para segundos de dígito

único.
$s Segundos sem zeros à esquerda para segundos de dígito

único.
$fff Milissegundos representados por três dígitos completos.
$ff Milissegundos representados apenas pelos dois primeiros

dígitos.
$f Milissegundos representados somente pelo primeiro dígito.
Por exemplo, considerando os nomes de arquivo:

powertoys.png , criado em 11/02/2020 (novembro de segundo)
powertoys-menu.png , criado em 11/03/2020 (novembro de terceiro)
Insira os critérios para renomear os itens:

Pesquisar por: powertoys
Renomear com: $MMM-$DD-$YY-powertoys
O valor do arquivo renomeado resultaria em:

Nov-02-20-powertoys.png
Nov-03-20-powertoys-menu.png
Expressões regulares
Para a maioria dos casos de uso, uma pesquisa simples e uma substituição são suficientes. No entanto, pode
haver ocasiões em que as tarefas de renomeação complicadas exigem mais controle. As expressões regulares
podem ajudar.
Expressões regulares definem um padrão de pesquisa para texto. Eles podem ser usados para pesquisar, editar e
manipular texto. O padrão definido pela expressão regular pode corresponder uma vez, várias vezes ou não
para uma determinada cadeia de caracteres. PowerRename usa a gramática ECMAScript , que é comum entre
linguagens de programação modernas.
Para habilitar expressões regulares, marque a caixa de seleção usar expressões regulares .
Obser vação: Provavelmente, você desejará verificar a correspondência de todas as ocorrências ao usar
expressões regulares.
Para usar a biblioteca Boost em vez da biblioteca padrão, marque a opção Usar a biblioteca Boost nas
PowerToys configurações. Ele habilita recursos estendidos, como lookbehind,que não têm suporte na biblioteca
padrão.
Exemplos de expressões regulares
Exemplos de correspondência simples
P RO C URA R DESC RIÇ Ã O
^ Corresponder ao início do nome do arquivo
$ Corresponder ao final do nome do arquivo
.* Corresponder a todo o texto no nome
^foo Corresponder texto que começa com "foo"
bar$ Corresponder texto que termina com "barra"
^foo.*bar$ Corresponder texto que começa com "foo" e termina com

"bar"
.+?(?=bar) Corresponder tudo à "barra"
foo[\s\S]*bar Corresponder tudo entre "foo" e "bar"
Exemplos de correspondência e variável

Ao usar as variáveis, a opção "Corresponder a Todas as Ocorrências" deve ser habilitada.
P RO C URA R SUB ST IT UA P O R DESC RIÇ Ã O
(.*).png foo_$1.png Anexa _ "foo" ao nome do arquivo

existente
(.*).png $1_foo.png Anexa _ "foo" ao nome do arquivo

existente
(.*) $1.txt Anexa a extensão ".txt" ao arquivo

existente
(^\w+\.$)¦(^\w+$) $2.txt Anexa a extensão ".txt" ao nome de

arquivo existente somente se ela não
tiver uma extensão
(\d\d)-(\d\d)-(\d\d\d\d) $3-$2-$1 Mover números no nome do arquivo:

"29-03-2020" torna-se "2020-03-29"
Recursos adicionais para aprender expressões regulares

Há ótimos exemplos/planilhas disponíveis online para ajudá-lo
Tutorial do Regex – uma folha de dicas rápida por exemplos
Tutorial de expressões regulares ECMAScript
Filtros de lista de arquivos

Os filtros podem ser PowerRename usados em para restringir os resultados do renomear. Use a janela
Visualização para verificar os resultados esperados. Selecione os headers de coluna para alternar entre filtros.
Original , a primeira coluna na janela Visualização alterna entre:
Checked: o arquivo está selecionado para ser renomeado.
Desmarcado: o arquivo não está selecionado para ser renomeado (embora ele se ajuste ao valor
inserido nos critérios de pesquisa).
Renomeado , a segunda coluna na janela Visualização pode ser alternada.
A visualização padrão mostrará todos os arquivos selecionados, com apenas os arquivos
correspondentes à Pesquisa de critérios que exibem o valor de renomeação atualizado.
Selecionar o header Renomeado alterna a visualização para exibir apenas os arquivos que serão
renomeados. Outros arquivos selecionados da seleção original não estarão visíveis.
PowerToys Run Utilitário
PowerToys Run é um launcher rápido para usuários avançados que contém alguns recursos adicionais sem
sacrificar o desempenho. Ele é de software livre e é modular para outros plugins.
Para usar PowerToys Run , selecione Espaço Alt + e comece a digitar! (observe que esse atalho pode ser
alterado na janela de configurações)
Requisitos
Windows 10 versão 1903 ou superior
Após a instalação, PowerToys deve ser habilitado e executado em segundo plano para que esse utilitário
funcione
Recursos
PowerToys Run os recursos incluem:
Pesquisar aplicativos, pastas ou arquivos
Pesquisar processos em execução (anteriormente conhecido como WindowWalker )
Botões clicáveis com atalhos de teclado (como Abrir como administrador ou Abrir pasta que contém)
Invocar o plug-in do Shell > usando (por exemplo, > Shell:startup abrirá a pasta Windows de
inicialização)
Fazer um cálculo simples usando a calculadora
Configurações
As opções Executar a seguir estão disponíveis no PowerToys menu de configurações.
C O N F IGURA Ç Õ ES AÇÃO
Abra PowerToys Run Definir o atalho de teclado para abrir/ocultar PowerToys Run
Ignorar atalhos no modo de tela inteira Quando estiver em tela inteira (F11), Executar não será
envolvido com o atalho
Número máximo de resultados Número máximo de resultados mostrados sem rolagem
Limpar a consulta anterior na iniciação Quando lançado, as pesquisas anteriores não serão
realçadas
Atalhos do teclado
ATA L H O S AÇÃO
Alt + Espaço Abrir ou ocultar PowerToys Run
Esc Esconder PowerToys Run
Ctrl + Shift + Insira Abra o aplicativo selecionado como administrador (aplicável

somente a aplicativos)
Ctrl + Shift + E Abra a pasta que contém no File Explorer (aplicável somente
a aplicativos e arquivos)
Ctrl + C Local do caminho de cópia (aplicável somente a pastas e

arquivos)
Tab Navegue pelos botões de menu de contexto e resultado da

pesquisa
Teclas de ação
Essas frases de ativação padrão serão forçadas PowerToys Run apenas em plug-ins direcionados.
C H AVE DE A Ç Ã O AÇÃO EXEM P LO
= Somente calculadora =2+2
? Somente pesquisa de arquivo ?road Achar roadmap.txt
. Somente programas instalados .code para obter Visual Studio Code.

Confira Parâmetros do programa para
opções sobre como adicionar
parâmetros à inicialização de um
programa
// Somente URLs // para iniciar o navegador padrão

ou //docs.microsoft.com para que
o navegador padrão acesse
https://docs.microsoft.com
C H AVE DE A Ç Ã O AÇÃO EXEM P LO
< Somente processos em execução <outlook para encontrar todos os

processos que contêm o Outlook
> Somente comando do Shell >ping localhost para fazer uma

consulta de ping
: Somente chaves do Registro :hkcu para pesquisar a chave

HKEY_CURRENT_USER registro
! Windows somente serviços !alg para pesquisar o serviço

gateway de camada de aplicativo a ser
iniciado ou interrompido
{ Visual Studio Code workspaces abertos {powertoys para pesquisar

anteriormente, máquinas remotas (SSH workspaces que contêm 'powertoys'
ou Codespaces) e contêineres. Esse em seus caminhos
plug-in está desligado por padrão.
%% Somente conversor de unidade %% 10 ft in m para calcular o

número de metros em 10 pés
$ Windows somente configurações $ Add/Remove Programs para iniciar

o Windows menu de configurações
para gerenciar programas instalados.
Para listar todas as configurações de
uma categoria de área, digite : após
o nome da categoria. $ Device: para
exibir todas as configurações de
dispositivo disponíveis
Comandos do sistema
PowerToys Run habilita um conjunto de ações no nível do sistema que podem ser executadas.
C H AVE DE A Ç Ã O AÇÃO
Shutdown Desliga o computador
Restart Reinicia o computador
Sign Out Des saída do usuário atual
Lock Bloqueia o computador
Sleep Sleeps the computer
Hibernate Hiberna o computador
Empty Recycle Bin Esvazia a lixeira
Gerenciador de plug-ins
O PowerToys Run menu de configurações inclui um gerenciador de plug-ins que permite habilitar/desabilitar os
vários plug-ins disponíveis. Ao selecionar e expandir as seções, você pode personalizar as frases de ativação
usadas por cada plug-in. Além disso, você pode selecionar se um plug-in aparece em resultados globais, bem
como definir opções de plug-in adicionais quando disponível.
Parâmetros do programa
O PowerToys Run plug-in do programa permite que os argumentos do programa sejam adicionados ao iniciar
um aplicativo. Os argumentos do programa devem seguir o formato esperado, conforme definido pela interface
de linha de comando do programa.
Por exemplo, ao iniciar Visual Studio Code, você pode especificar a pasta a ser aberta com:
Visual Studio Code -- C:\myFolder
Visual Studio Code também dá suporte a um conjunto de parâmetrosde linha de comando , que podem ser
utilizados com seus argumentos correspondentes no para, por exemplo, exibir a diferença PowerToys Run entre
arquivos:
Visual Studio Code -d C:\foo.txt C:\bar.txt
Se a opção "Incluir no resultado global" do plug-in do programa não estiver selecionada, inclua a frase de
ativação, por padrão, para invocar o comportamento . do plug-in:
.Visual Studio Code -- C:\myFolder
Monitorar posicionamento
Se vários monitores estão em uso, o pode ser lançado no monitor desejado configurando o comportamento de
lançamento apropriado no PowerToys Run menu Configurações aplicativo. As opções estão sendo abertas em:
Monitor primário
Monitorar com o cursor do mouse
Monitorar com janela focalizada
Windows Configurações de pesquisa
Se o Windows plug-in de pesquisa não estiver definido para abranger todas as unidades, você receberá o
seguinte aviso:
Você pode desativar o aviso nas opções do PowerToys Run Gerenciador de plug-ins para Windows pesquisa ou
selecionar o aviso para expandir quais unidades estão sendo indexadas. Depois de selecionar o aviso, o
Windows menu de opções de 10 configurações "pesquisa Windows " será aberto.
Neste menu de "pesquisa Windows ", você pode:

Selecione o modo "avançado" para habilitar a indexação em todas as unidades em seu Windows computador
10.
Especifique os caminhos de pasta a serem excluídos.
selecione o "indexador de pesquisa avançada Configurações" (próximo à parte inferior das opções de menu)
para definir configurações avançadas de índice, adicionar ou remover locais de pesquisa, indexar arquivos
criptografados, etc.
Para obter uma lista de todos os problemas e sugestões conhecidos, consulte os PowerToys problemas do
repositório de produtos em github.
Attribution
Wox
Janela do Tadele da versão beta
Windows guia de atalho de tecla
Este guia usa PowerToys para exibir atalhos de teclado comuns que usam a Windows tecla .
Uso
Abra o guia de atalho com a combinação de teclas de atalho: ⊞ Win + ? (isso pode exigir o uso da tecla Shift) ou
manter o ⊞ Win para o tempo definido no Configurações. Uma sobreposição será exibida mostrando atalhos de
teclado que usam a Windows chave, incluindo:
atalhos Windows comuns
atalhos para alterar a posição da janela ativa
Atalhos da barra de tarefas
Atalhos de teclado usando Windows a tecla ⊞ O Win pode ser usado enquanto o guia é exibido. O resultado
desses atalhos ( janela ativa movida, alterações de comportamento de atalho de seta etc.) será exibido no guia.
Pressionar a combinação de teclas de atalho novamente descartará a sobreposição.
Tocar na Windows tecla exibirá o Windows menu Iniciar.
IMPORTANT
O aplicativo deve estar em execução e Guia de Atalhos deve ser habilitado nas PowerToys PowerToys configurações para
que esse recurso seja usado.
Configurações
Essas configurações podem ser editadas no PowerToys Configurações:
Método de ativação Escolha seu próprio schortcut ou use a tecla Win ⊞
Atalho de ativação O atalho personalizado usado para iniciar o guia de atalho
Duração da pressão Tempo (em milissegundos) para conter a tecla Win ⊞ para
abrir Guia de Atalhos
Tema do aplicativo Claro, escuro ou Windows tema
Opacidade da segundo plano Essa barra de controle deslizante controla a opacidade da

Guia de Atalhos sobreposição
Excluir aplicativos Ignora Guia de Atalhos quando esses aplicativos estão em

foco
Video Conference Mute (versão prévia)
IMPORTANT
Esse é um recurso de versão prévia e está incluído apenas na versão de pré-lançamento do PowerToys . A execução desta
pré-versão requer Windows a versão 10 1903 (build 18362) ou posterior.
Desligue rapidamente o microfone (áudio) e desligue a câmera (vídeo) com um único botão de tecla durante
uma chamada de conferência, independentemente de qual aplicativo tenha o foco em seu computador.
Uso
Os atalhos padrão a usar Video Conference Mute são:
⊞ Win + N para alternar áudio e vídeo ao mesmo tempo
⊞ Win + Shift + Um para alternar o microfone
⊞ Win + Shift + O para alternar vídeo
Ao usar o microfone e/ou teclas de atalho de alternância da câmera, você verá uma pequena barra de
ferramentas que permite que você saiba se o Microfone e a Câmera estão definidos como ligado, desligado ou
não em uso. Você pode definir a posição dessa barra de ferramentas na Video Conference Mute guia de
PowerToys configurações.
Configurações
A Video Conference Mute guia nas PowerToys configurações fornece as seguintes opções:
Atalhos Altere a tecla de atalho usada para desativar o microfone, a

câmera ou ambos combinados
Microfone selecionado Selecione o microfone em seu computador que esse utilitário

usará
Câmera selecionada Selecione a câmera em seu computador que esse utilitário

usará
Imagem de sobreposição da câmera Selecione uma imagem para que será usada como um
espaço reservado quando a câmera estiver desligada. Por
padrão, uma tela preta será exibida quando a câmera estiver
desligada com esse utilitário.
Barra de ferramentas Definir a posição em que a barra de ferramentas Microfone

Ligado, Câmera Na Tela é exibida quando alternada (padrão:
canto superior direito)
Mostrar barra de ferramentas em Selecione se você prefere que a barra de ferramentas seja
exibida somente no monitor principal (padrão) ou em todos
os monitores
Ocultar barra de ferramentas quando a câmera e o Uma caixa de seleção está disponível para alternar essa
microfone não sãomutados opção
Como isso funciona nos hood

Os aplicativos interagem com áudio e vídeo de maneiras diferentes. Se uma câmera parar de funcionar, o
aplicativo que o usa tende a não se recuperar até que a API faça uma redefinição completa. Para alternar e
desligar a câmera de privacidade global ao usar a câmera em um aplicativo, normalmente, ela falhará e não será
recuperada.
Então, como lida PowerToys com isso para que você possa continuar transmitindo?
Áudio: PowerToys usa a API de mute de microfone global no Windows . Os aplicativos devem se recuperar
quando isso é alternado e desligado.
Vídeo: PowerToys tem um driver virtual para a câmera. O vídeo é roteado pelo driver e, em seguida, para o
aplicativo. Selecionar a Video Conference Mute tecla de atalho interrompe o streaming do vídeo, mas o
aplicativo ainda acha que está recebendo vídeo. O vídeo é substituído apenas por preto ou o espaço
reservado da imagem que você salvou nas configurações.
Depurar o driver da câmera
Para depurar o driver da câmera, abra esse arquivo em seu computador:
C:\Windows\ServiceProfiles\LocalService\AppData\Local\Temp\PowerToysVideoConference.log
Você também pode criar um vazio PowerToysVideoConferenceVerbose.flag no mesmo diretório para habilitar o
modo de log detalhado no driver.
Para exibir todos os problemas conhecidos atualmente abertos no utilitário, consulte acompanhamento de
problemas Video Conference Mute PowerToys #6246 no GitHub. A equipe de desenvolvimento e a comunidade
colaboradora estão trabalhando ativamente para resolver esses problemas e planejam manter o utilitário em
pré-lançamento até que os problemas PowerToys essenciais sejam resolvidos.

Microsoft C#

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Microsoft C#

Enviado por

Direitos autorais:

Formatos disponíveis

Contents

Ambiente de desenvolvimento do Windows

Introdução ao Docker Desktop para Windows

Subsistema do Windows para Linux

Gerenciador de Pacotes do Windows

Executar o Windows e o Linux

Fazer a transição entre Mac e Windows

Usar atalhos para abrir um projeto no VS Code ou no Explorador de

Usar o Gerenciador de Credenciais para o processo de autenticação

Use o WSL para testar seu pipeline de produção antes de implantar

Melhorar a velocidade de desempenho do WSL evitando o

Melhorar as velocidades de compilação adicionando exclusões no

wt -p "Command Prompt" `; split-pane -p "Windows PowerShell" `; split-pane -H wsl.exe

Compartilhar sua dicas

Criar um banco de dados

Compilar um aplicativo Android

Criar um aplicativo multiplataforma

Compilar um aplicativo Web ou chamar uma API

Compilar um aplicativo de console

Copiar Command+C Ctrl+C

Recortar Command+X Ctrl+X

Colar Command+V Ctrl+V

Desfazer Command+Z Ctrl+Z

Salvar Command+S Ctrl+S

Abrir Command+O Ctrl+O

Bloquear o computador Command+Control+Q Tecla do Windows+L

Mostrar a área de trabalho Command+F3 Tecla do Windows+D

Abrir o navegador de arquivos Command+N Tecla do Windows+E

Minimizar janelas Command+M Tecla do Windows+M

Pesquisar Command+Espaço Tecla do Windows

Fechar janela ativa Command+W Control+W

Alternar para a tarefa atual Command+Tab Alt+Tab

Salvar tela (captura de tela) Command+Shift+3 Tecla do Windows+Shift+S

Salvar janela Command+Shift+4 Tecla do Windows+Shift+S

Exibir informações ou propriedades do Command+I Alt+Enter

Selecionar todos os itens Command+A Ctrl+A

Digitar caracteres especiais Option+tecla de caractere Alt+tecla de caractere

Rolagem Passar dois dedos na vertical Passar dois dedos na vertical

Abrir informações adicionais Tocar com três dedos N/D

Observação: as opções de trackpad são configuráveis nas duas plataformas.

Terminais e shells de linha de comando

Configurações e Preferências Preferências do Sistema Settings

Gerenciador de tarefas Monitor de Atividade Gerenciador de Tarefas

Formatação de disco Utilitário de disco Gerenciamento de disco

Edição de texto TextEdit Bloco de notas

Exibição de evento Console Visualizador de Eventos

Localizar arquivos/aplicativos Command+Espaço Tecla do Windows

Copiar Command+C Ctrl+C

Recortar Command+X Ctrl+X

Colar Command+V Ctrl+V

Desfazer Command+Z Ctrl+Z

Salvar Command+S Ctrl+S

Abrir Command+O Ctrl+O

Bloquear o computador Command+Control+Q Tecla do Windows+L

Mostrar a área de trabalho Command+F3 Tecla do Windows+D

Abrir o navegador de arquivos Command+N Tecla do Windows+E

Minimizar janelas Command+M Tecla do Windows+M

Pesquisar Command+Espaço Tecla do Windows

Fechar janela ativa Command+W Control+W

Alternar para a tarefa atual Command+Tab Alt+Tab

Salvar tela (captura de tela) Command+Shift+3 Tecla do Windows+Shift+S

Salvar janela Command+Shift+4 Tecla do Windows+Shift+S