CMD vs PowerShell vs Bash — équivalences de commandes

La même tâche dans l’invite de commandes, PowerShell et bash, côte à côte : fichiers, grep, variables d’environnement, processus, réseau, services et scripts.

CMD vs PowerShell vs Bash · freetoolsforweb.com/tools/cmd-vs-powershell-vs-bash · vérifié le 2026-10-18

Dernière vérification : 2026-10-18 selon la référence Microsoft Learn de PowerShell 7.6 et de Windows PowerShell 5.1, la référence des commandes Windows et le manuel de GNU Bash 5.2.

Rechercher par tâche ou par commande (appuyez sur / pour y accéder)

107 tâches réparties en 9 groupes, plus des notes sur les alias, les guillemets et la stratégie d’exécution

Fichiers et dossiers

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Lister les fichiers # Alias PowerShell : gci, dir, et sous Windows ls.	`dir`	`Get-ChildItem`	`ls -l`
Lister en incluant les fichiers cachés #	`dir /a`	`Get-ChildItem -Force`	`ls -la`
Lister tous les fichiers récursivement #	`dir /s /b`	`Get-ChildItem -Recurse -File`	`find . -type f`
Afficher le répertoire courant # Dans CMD, cd sans argument affiche le répertoire courant. Alias PowerShell : pwd, gl ; il y a aussi la variable $PWD.	`cd`	`Get-Location`	`pwd`
Changer de répertoire # CMD a besoin de /d pour changer de lecteur en plus du dossier. Alias PowerShell : cd, sl, chdir.	`cd /d D:\work`	`Set-Location D:\work`	`cd /home/me/work`
Aller au répertoire personnel #	`cd %USERPROFILE%`	`Set-Location ~`	`cd ~`
Créer un dossier (avec ses parents) # Le mkdir de CMD crée les dossiers intermédiaires quand les extensions de commande sont activées (par défaut). Dans PowerShell, mkdir est une fonction qui encapsule New-Item -ItemType Directory.	`mkdir a\b\c`	`New-Item -ItemType Directory -Path a\b\c`	`mkdir -p a/b/c`
Créer un fichier vide #	`type nul > file.txt`	`New-Item file.txt`	`touch file.txt`
Copier un fichier #	`copy src.txt dst.txt`	`Copy-Item src.txt dst.txt`	`cp src.txt dst.txt`
Copier un dossier récursivement # xcopy src dst /E /I fonctionne aussi ; robocopy est l’outil recommandé et sait reprendre et réessayer.	`robocopy src dst /E`	`Copy-Item src dst -Recurse`	`cp -r src dst`
Créer un miroir exact d’un dossier Dangereux # Attention : Les deux suppriment dans la destination les fichiers absents de la source. Inverser les deux chemins efface le dossier que vous vouliez garder. robocopy /L et rsync -n font une simulation.	`robocopy src dst /MIR`	`(no cmdlet; call robocopy)`	`rsync -a --delete src/ dst/`
Déplacer un fichier #	`move a.txt archive\`	`Move-Item a.txt archive\`	`mv a.txt archive/`
Renommer un fichier #	`ren old.txt new.txt`	`Rename-Item old.txt new.txt`	`mv old.txt new.txt`
Supprimer un fichier #	`del file.txt`	`Remove-Item file.txt`	`rm file.txt`
Supprimer un dossier et son contenu Dangereux # Attention : Pas de Corbeille ni de confirmation avec /q, -Force ou -f. Vérifiez d’abord le chemin ; dans PowerShell, ajoutez -WhatIf pour voir ce qui serait supprimé.	`rmdir /s /q folder`	`Remove-Item folder -Recurse -Force`	`rm -rf folder`
Créer un lien symbolique # Sous Windows, créer des liens symboliques exige une invite élevée, sauf si le mode développeur est activé. Attention à l’ordre des arguments : le lien d’abord dans CMD/PowerShell, la cible d’abord avec ln.	`mklink link.txt target.txt mklink /D linkdir targetdir`	`New-Item -ItemType SymbolicLink -Path link.txt -Target target.txt`	`ln -s target.txt link.txt`
Modifier les permissions d’un fichier # Windows utilise des ACL, pas des bits rwx ; icacls est généralement plus simple que Set-Acl.	`icacls file.txt /grant alice:F`	`Get-Acl / Set-Acl`	`chmod 644 file.txt`
Somme de contrôle d’un fichier (SHA-256) # Get-FileHash utilise SHA256 par défaut ; -Algorithm MD5 ou SHA1 pour les autres. macOS : shasum -a 256.	`certutil -hashfile file.iso SHA256`	`Get-FileHash file.iso`	`sha256sum file.iso`
Créer un fichier zip # tar.exe (bsdtar) est fourni avec Windows 10 1803 et ultérieur ; -a choisit le format d’après l’extension .zip.	`tar -a -c -f out.zip folder`	`Compress-Archive -Path folder -DestinationPath out.zip`	`zip -r out.zip folder`
Extraire un fichier zip #	`tar -xf out.zip`	`Expand-Archive out.zip -DestinationPath dest`	`unzip out.zip -d dest`

Lire et écrire le contenu des fichiers

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Afficher un fichier # Alias PowerShell : gc, type, et sous Windows cat.	`type file.txt`	`Get-Content file.txt`	`cat file.txt`
Parcourir un fichier page par page #	`more file.txt`	`Get-Content file.txt \| Out-Host -Paging`	`less file.txt`
Les 10 premières lignes # -Head est un alias de -TotalCount.	Aucune commande intégrée	`Get-Content file.txt -TotalCount 10`	`head -n 10 file.txt`
Les 10 dernières lignes #	Aucune commande intégrée	`Get-Content file.txt -Tail 10`	`tail -n 10 file.txt`
Suivre un fichier journal #	Aucune commande intégrée	`Get-Content app.log -Tail 10 -Wait`	`tail -f app.log`
Écrire du texte dans un fichier (écraser) # Dans CMD, une espace avant > se retrouve dans le fichier. Dans Windows PowerShell 5.1, > écrit en UTF-16 LE ; PowerShell 7 écrit en UTF-8 sans BOM. Set-Content -Encoding utf8 est explicite dans les deux.	`echo hello> file.txt`	`'hello' \| Set-Content file.txt`	`echo hello > file.txt`
Ajouter du texte à la fin d’un fichier #	`echo hello>> file.txt`	`Add-Content file.txt 'hello'`	`echo hello >> file.txt`
Compter les lignes #	`find /c /v "" file.txt`	`(Get-Content file.txt).Count`	`wc -l file.txt`
Comparer deux fichiers # Dans PowerShell sous Windows, diff est un alias de Compare-Object, pas un diff de texte.	`fc a.txt b.txt`	`Compare-Object (Get-Content a.txt) (Get-Content b.txt)`	`diff a.txt b.txt`
Trier les lignes #	`sort file.txt`	`Get-Content file.txt \| Sort-Object`	`sort file.txt`
Lignes uniques #	Aucune commande intégrée	`Get-Content file.txt \| Sort-Object -Unique`	`sort -u file.txt`
Remplacer du texte dans un fichier # -replace utilise des expressions régulières ; les parenthèses lisent tout le fichier avant que Set-Content ne le rouvre. Le sed de macOS nécessite -i ''.	Aucune commande intégrée	`(Get-Content f.txt) -replace 'old','new' \| Set-Content f.txt`	`sed -i 's/old/new/g' f.txt`

Recherche (équivalents de grep)

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Chercher du texte dans des fichiers # Select-String ne tient pas compte de la casse par défaut (-CaseSensitive pour changer). Pour les sous-dossiers : Get-ChildItem -Recurse -Filter *.log \| Select-String error.	`findstr /s /i /n "error" *.log`	`Select-String -Path *.log -Pattern error`	`grep -rin 'error' --include='*.log' .`
Filtrer la sortie d’une commande #	`ipconfig \| findstr IPv4`	`ipconfig \| Select-String IPv4`	`ip a \| grep inet`
Lignes qui ne correspondent PAS #	`findstr /v "DEBUG" app.log`	`Select-String -Path app.log -Pattern DEBUG -NotMatch`	`grep -v DEBUG app.log`
Rechercher avec une regex # findstr ne prend en charge qu’un petit sous-ensemble des regex (pas de \|, pas de {n}). Select-String utilise les expressions régulières .NET.	`findstr /r "^ERR.*timeout" app.log`	`Select-String -Path app.log -Pattern '^ERR.*timeout'`	`grep -E '^ERR.*timeout' app.log`
Trouver des fichiers par nom #	`dir /s /b *.log`	`Get-ChildItem -Recurse -Filter *.log`	`find . -name '*.log'`
Trouver où se trouve un programme # Dans PowerShell, where est un alias de Where-Object ; tapez where.exe pour obtenir l’outil CMD.	`where git`	`Get-Command git`	`command -v git`

Variables d’environnement

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Lister toutes les variables #	`set`	`Get-ChildItem Env:`	`env`
Lire une variable #	`echo %PATH%`	`$env:PATH`	`echo "$PATH"`
Définir pour cette session # CMD : pas d’espaces autour de =, sinon elles font partie du nom et de la valeur.	`set MY_VAR=hello`	`$env:MY_VAR = 'hello'`	`export MY_VAR=hello`
Définir de façon permanente (pour votre utilisateur) # setx et SetEnvironmentVariable ne s’appliquent qu’aux nouvelles fenêtres, pas à la fenêtre actuelle. setx tronque les valeurs de plus de 1024 caractères : ne l’utilisez pas pour modifier PATH.	`setx MY_VAR hello`	`[Environment]::SetEnvironmentVariable('MY_VAR','hello','User')`	`echo 'export MY_VAR=hello' >> ~/.bashrc`
Supprimer une variable #	`set MY_VAR=`	`Remove-Item Env:MY_VAR`	`unset MY_VAR`
Ajouter un dossier au PATH (session) # PowerShell 7 sous Linux/macOS sépare les entrées de PATH par : au lieu de ;. [IO.Path]::PathSeparator donne le bon séparateur.	`set PATH=%PATH%;C:\tools`	`$env:PATH += ';C:\tools'`	`export PATH="$PATH:/opt/tools"`
Définir pour une seule commande #	Aucune commande intégrée	`$env:DEBUG = '1'; ./app; Remove-Item Env:DEBUG`	`DEBUG=1 ./app`

Processus

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Lister les processus #	`tasklist`	`Get-Process`	`ps aux`
Trouver un processus par nom #	`tasklist /FI "IMAGENAME eq chrome.exe"`	`Get-Process chrome`	`pgrep -a chrome`
Tuer un processus par son ID # Sans /F ni -Force, Windows demande au processus de se fermer. kill envoie SIGTERM ; kill -9 force l’arrêt.	`taskkill /PID 1234 /F`	`Stop-Process -Id 1234 -Force`	`kill 1234`
Tuer un processus par nom #	`taskkill /IM notepad.exe /F`	`Stop-Process -Name notepad`	`pkill notepad`
Lancer un programme # Le "" vide dans start est le titre de la fenêtre ; sans lui, un chemin de programme entre guillemets est pris pour le titre.	`start "" notepad.exe`	`Start-Process notepad`	`gedit &`
Exécuter avec élévation (admin/root) # Utilisez powershell au lieu de pwsh pour Windows PowerShell 5.1. Windows 11 24H2 et ultérieur permet aussi d’activer une commande sudo intégrée dans les Paramètres.	`runas /user:Administrator cmd`	`Start-Process pwsh -Verb RunAs`	`sudo command`
Les 10 processus les plus gourmands en CPU # Dans Get-Process, CPU correspond au total de secondes processeur depuis le démarrage, pas au % actuel.	Aucune commande intégrée	`Get-Process \| Sort-Object CPU -Descending \| Select-Object -First 10`	`ps aux --sort=-%cpu \| head`
Qui utilise un port # Get-NetTCPConnection n’existe que sous Windows. La dernière colonne de netstat -ano est le PID : identifiez-le avec tasklist /FI "PID eq 1234".	`netstat -ano \| findstr :8080`	`Get-NetTCPConnection -LocalPort 8080`	`sudo ss -ltnp \| grep :8080`

Réseau

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Afficher les adresses IP # Get-NetIPAddress et les autres cmdlets Net* n’existent que sous Windows (module NetTCPIP).	`ipconfig /all`	`Get-NetIPAddress`	`ip addr`
Pinger un hôte # Le ping de Windows s’arrête après 4 envois par défaut ; celui de Linux continue jusqu’à Ctrl+C.	`ping -n 4 example.com`	`Test-Connection example.com -Count 4`	`ping -c 4 example.com`
Tester un port TCP # Test-NetConnection n’existe que sous Windows. Dans PowerShell 7 : Test-Connection example.com -TcpPort 443.	Aucune commande intégrée	`Test-NetConnection example.com -Port 443`	`nc -zv example.com 443`
Résolution DNS # Resolve-DnsName n’existe que sous Windows ; nslookup est disponible dans les trois.	`nslookup example.com`	`Resolve-DnsName example.com`	`dig example.com`
Tracer l’itinéraire #	`tracert example.com`	`Test-NetConnection example.com -TraceRoute`	`traceroute example.com`
Vider le cache DNS # La ligne bash s’applique aux systèmes utilisant systemd-resolved.	`ipconfig /flushdns`	`Clear-DnsClientCache`	`sudo resolvectl flush-caches`
Requête HTTP GET (appel d’API) # Invoke-RestMethod convertit le JSON en objets ; Invoke-WebRequest renvoie le statut, les en-têtes et le contenu brut.	`curl.exe https://api.example.com/items`	`Invoke-RestMethod https://api.example.com/items`	`curl https://api.example.com/items`
Télécharger un fichier # curl.exe est fourni avec Windows 10 1803 et ultérieur. Dans Windows PowerShell 5.1, ajoutez -UseBasicParsing à Invoke-WebRequest sur les machines où Internet Explorer n’est pas configuré.	`curl.exe -L -o file.zip https://example.com/file.zip`	`Invoke-WebRequest https://example.com/file.zip -OutFile file.zip`	`curl -LO https://example.com/file.zip`
Envoyer du JSON en POST # CMD n’a pas de guillemets simples : les guillemets doubles internes sont échappés par des barres obliques inversées pour curl.exe.	`curl.exe -X POST -H "Content-Type: application/json" -d "{\"a\":1}" https://api.example.com`	`Invoke-RestMethod https://api.example.com -Method Post -ContentType 'application/json' -Body (@{a=1} \| ConvertTo-Json)`	`curl -X POST -H 'Content-Type: application/json' -d '{"a":1}' https://api.example.com`
Se connecter en SSH à un serveur # Le client OpenSSH est installé par défaut sur Windows 10 1809+ et Windows 11.	`ssh user@host`	`ssh user@host`	`ssh user@host`

Services et système

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Lister les services # Dans Windows PowerShell 5.1, sc est un alias de Set-Content : tapez sc.exe. PowerShell 6+ a supprimé cet alias.	`sc query`	`Get-Service`	`systemctl list-units --type=service`
État d’un service #	`sc query Spooler`	`Get-Service Spooler`	`systemctl status nginx`
Démarrer / arrêter un service #	`net start Spooler net stop Spooler`	`Start-Service Spooler Stop-Service Spooler`	`sudo systemctl start nginx sudo systemctl stop nginx`
Redémarrer un service #	`net stop Spooler && net start Spooler`	`Restart-Service Spooler`	`sudo systemctl restart nginx`
Lancer au démarrage # sc.exe exige une espace après start= et aucune avant.	`sc config Spooler start= auto`	`Set-Service Spooler -StartupType Automatic`	`sudo systemctl enable nginx`
Infos système et matériel #	`systeminfo`	`Get-ComputerInfo`	`uname -a; cat /etc/os-release`
Nom de l’ordinateur #	`hostname`	`$env:COMPUTERNAME`	`hostname`
Utilisateur actuel # Également $env:USERNAME dans PowerShell sous Windows.	`whoami`	`whoami`	`whoami`
Espace disque libre # Les anciennes versions de Windows exigent une invite élevée pour fsutil. Get-Volume (Windows uniquement) affiche aussi la taille et l’espace libre.	`fsutil volume diskfree C:`	`Get-PSDrive -PSProvider FileSystem`	`df -h`
Durée de fonctionnement (uptime) # Get-Uptime nécessite PowerShell 6+. En 5.1 : (Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime.	`systeminfo \| find "Boot Time"`	`Get-Uptime`	`uptime`
Redémarrer maintenant #	`shutdown /r /t 0`	`Restart-Computer`	`sudo reboot`
Effacer l’écran # cls et clear fonctionnent tous deux dans PowerShell sous Windows.	`cls`	`Clear-Host`	`clear`
Historique des commandes # Get-History ne couvre que la session en cours. PSReadLine conserve l’historique plus ancien dans le fichier indiqué par (Get-PSReadLineOption).HistorySavePath ; Ctrl+R y effectue une recherche dans les trois shells.	`doskey /history`	`Get-History`	`history`
Aide sur une commande # Lancez Update-Help une fois (avec élévation en 5.1) pour télécharger l’aide complète de PowerShell.	`dir /?`	`Get-Help Get-ChildItem -Examples`	`man ls`
Date actuelle # %date% suit le format régional de la machine : les scripts qui l’analysent ne fonctionnent plus d’une langue à l’autre.	`echo %date%`	`Get-Date -Format 'yyyy-MM-dd'`	`date +%F`
Attendre 5 secondes #	`timeout /t 5`	`Start-Sleep -Seconds 5`	`sleep 5`
Copier la sortie dans le presse-papiers # macOS : pbcopy. Wayland : wl-copy. Get-Clipboard le relit dans PowerShell.	`dir \| clip`	`Get-ChildItem -Name \| Set-Clipboard`	`ls \| xclip -selection clipboard`

Pipe d’objets ou de texte

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Choisir des colonnes / propriétés # PowerShell transmet des objets .NET dans le pipe : on choisit les propriétés par leur nom au lieu d’analyser des colonnes.	Aucune commande intégrée	`Get-Process \| Select-Object Name, Id, WS`	`ps -eo comm,pid,rss`
Filtrer les lignes selon une valeur # PowerShell comprend les littéraux 500MB, 1GB. awk compare la colonne 6 (RSS en Ko).	`tasklist \| findstr chrome`	`Get-Process \| Where-Object WS -gt 500MB`	`ps aux \| awk '$6 > 500000'`
Agir sur chaque élément # $_ (ou $PSItem) est l’objet courant. Dans un fichier .bat, écrivez %%f au lieu de %f.	`for %f in (*.txt) do echo %f`	`Get-ChildItem *.txt \| ForEach-Object { $_.Name }`	`for f in *.txt; do echo "$f"; done`
Voir les propriétés d’un objet # La commande d’exploration la plus utile de PowerShell ; essayez aussi \| Format-List *.	Aucune commande intégrée	`Get-Process \| Get-Member`	Aucune commande intégrée
Analyser du JSON # Utilisez -Raw pour que le fichier arrive en une seule chaîne ; ConvertTo-Json -Depth 10 en sortie (la profondeur par défaut est 2).	Aucune commande intégrée	`Get-Content data.json -Raw \| ConvertFrom-Json`	`jq . data.json`
Lire et filtrer un CSV # Les valeurs d’Import-Csv sont des chaînes ; convertissez-les avec [int] pour les comparaisons numériques.	Aucune commande intégrée	`Import-Csv users.csv \| Where-Object { [int]$_.Age -gt 30 }`	`awk -F, 'NR>1 && $3 > 30' users.csv`
Exporter en CSV # -NoTypeInformation est le comportement par défaut dans PowerShell 6+, mais reste nécessaire en 5.1.	Aucune commande intégrée	`Get-Process \| Export-Csv procs.csv -NoTypeInformation`	`ps -eo pid,comm --no-headers \| awk '{print $1","$2}' > procs.csv`
Compter, additionner, moyenne #	`find /c /v "" file.txt`	`Get-ChildItem -File \| Measure-Object Length -Sum -Average`	`ls -l \| awk '{s+=$5} END {print s}'`

Scripts : variables, conditions, boucles, fonctions

Tâche	CMD (Invite de commandes)	PowerShell	Bash (Linux/macOS)
Définir une variable # bash : pas d’espaces autour de = (name = Ada lance une commande nommée name).	`set name=Ada`	`$name = 'Ada'`	`name=Ada`
Utiliser une variable dans une chaîne #	`echo Hello %name%`	`"Hello $name"`	`echo "Hello $name"`
Calcul arithmétique # CMD et bash ne calculent qu’en entiers ; PowerShell utilise les nombres .NET.	`set /a n=5*3`	`$n = 5 * 3`	`n=$((5 * 3))`
Lire une saisie utilisateur #	`set /p name=Name:`	`$name = Read-Host 'Name'`	`read -rp 'Name: ' name`
Arguments du script # Dans les fichiers .bat, %~1 retire les guillemets qui entourent l’argument. Un bloc param() donne aux scripts PowerShell des paramètres nommés et typés.	`%1 %2 … %*`	`$args[0] or param($Path)`	`$1 $2 … "$@"`
If / else sur une chaîne # Les opérateurs de comparaison de PowerShell sont des mots : -eq -ne -gt -lt -like -match. = et > servent à l’affectation et à la redirection.	`if "%a%"=="yes" (echo on) else (echo off)`	`if ($a -eq 'yes') { 'on' } else { 'off' }`	`if [ "$a" = "yes" ]; then echo on; else echo off; fi`
Comparer des nombres # CMD : EQU NEQ LSS LEQ GTR GEQ.	`if %n% GTR 5 echo big`	`if ($n -gt 5) { 'big' }`	`if (( n > 5 )); then echo big; fi`
Si un fichier existe #	`if exist file.txt echo yes`	`if (Test-Path file.txt) { 'yes' }`	`if [ -f file.txt ]; then echo yes; fi`
Code de sortie du dernier programme # Dans PowerShell, $? vaut $true/$false pour la dernière commande ; $LASTEXITCODE est le code numérique du dernier programme natif.	`echo %ERRORLEVEL%`	`$LASTEXITCODE`	`echo $?`
Lancer la commande suivante uniquement en cas de succès / d’échec # Les opérateurs de chaîne de pipeline && et \|\| sont arrivés avec PowerShell 7.0 ; Windows PowerShell 5.1 les refuse.	`build && deploy build \|\| echo failed`	`build && deploy (PowerShell 7+) build; if ($?) { deploy } (5.1)`	`build && deploy build \|\| echo failed`
Boucler sur une liste #	`for %i in (a b c) do echo %i`	`foreach ($x in 'a','b','c') { $x }`	`for x in a b c; do echo "$x"; done`
Boucler de 1 à 5 #	`for /l %i in (1,1,5) do echo %i`	`foreach ($i in 1..5) { $i }`	`for i in {1..5}; do echo "$i"; done`
Boucler sur les lignes d’un fichier #	`for /f "usebackq delims=" %l in ("file.txt") do echo %l`	`foreach ($line in Get-Content file.txt) { $line }`	`while IFS= read -r line; do echo "$line"; done < file.txt`
Boucle while # CMD n’a pas de while ; utilisez goto avec une étiquette dans un fichier .bat.	`:loop set /a i+=1 if %i% lss 5 goto loop`	`while ($i -lt 5) { $i++ }`	`while [ "$i" -lt 5 ]; do i=$((i+1)); done`
Définir et appeler une fonction # Appelez les fonctions PowerShell comme des commandes : Greet Ada, et non Greet("Ada").	`call :greet Ada goto :eof :greet echo Hello %~1 exit /b`	`function Greet($Name) { "Hello $Name" } Greet Ada`	`greet() { echo "Hello $1"; } greet Ada`
Stocker la sortie d’une commande dans une variable #	`for /f "delims=" %i in ('hostname') do set h=%i`	`$h = hostname`	`h=$(hostname)`
Ignorer la sortie #	`command >nul 2>&1`	`command *> $null`	`command >/dev/null 2>&1`
Commentaire #	`rem comment :: comment`	`# comment <# block #>`	`# comment`
Fichier de script et comment l’exécuter # PowerShell n’exécute pas les scripts du dossier courant sans .\ et peut les bloquer complètement : voir la stratégie d’exécution ci-dessous.	`script.bat`	`.\script.ps1`	`chmod +x script.sh && ./script.sh`

Pièges des alias PowerShell : ls, curl, wget, sc, where

PowerShell fournit des alias qui ressemblent à des commandes Unix ou CMD, mais qui lancent des cmdlets aux paramètres différents. Leur présence dépend de l’édition et du système d’exploitation. Get-Alias name indique vers quoi pointe un nom dans votre session.

Vous tapez	Windows PowerShell 5.1	PowerShell 7 sous Windows	PowerShell 7 sous Linux/macOS
`curl` Tapez curl.exe en 5.1 pour obtenir le vrai curl. Ses options (-X, -H, -d) ne signifient rien pour Invoke-WebRequest.	Invoke-WebRequest	pas un alias : lance curl.exe	curl natif
`wget` Utilisez Invoke-WebRequest url -OutFile nom, ou curl.exe -LO url.	Invoke-WebRequest	pas un alias (pas de wget par défaut sous Windows)	wget natif, s’il est installé
`ls, dir` Les options comme ls -la échouent sous Windows : utilisez Get-ChildItem -Force.	Get-ChildItem	Get-ChildItem	ls = ls natif ; dir = Get-ChildItem
`cat, type`	Get-Content	Get-Content	cat = cat natif ; type = Get-Content
`cp, mv, rm, rmdir` rm -rf n’est pas du PowerShell valide : utilisez Remove-Item -Recurse -Force.	Copy-Item, Move-Item, Remove-Item	mêmes cmdlets	commandes natives
`ps, kill`	Get-Process, Stop-Process	mêmes cmdlets	commandes natives
`sort, tee, diff` Dans PowerShell sous Windows, diff a b compare des objets, pas les lignes de deux fichiers.	Sort-Object, Tee-Object, Compare-Object	mêmes cmdlets	commandes natives
`sc` En 5.1, sc query écrit un fichier nommé query. Utilisez sc.exe.	Set-Content	pas un alias : lance sc.exe	sans objet
`where` Utilisez where.exe pour trouver un programme, ou Get-Command.	Where-Object	Where-Object	Where-Object
`echo` echo -n ne supprime pas le retour à la ligne ; utilisez Write-Host -NoNewline.	Write-Output	Write-Output	Write-Output
`man`	help	help	man natif

Guillemets et échappement

La plupart des bugs du type « ça marche dans un shell, pas dans l’autre » viennent des guillemets. Le caractère d’échappement diffère d’un shell à l’autre.

Quoi	CMD	PowerShell	Bash
Chaîne littérale (sans expansion)	`Pas de guillemets littéraux : %VAR% est développé même entre "…"`	`'Cost: $5'`	`'Cost: $5'`
Chaîne avec variables	`"Hello %name%"`	`"Hello $name, it is $(Get-Date -Format t)"`	`"Hello $name, it is $(date +%R)"`
Caractère d’échappement	`^ (ex. ^& ^\| ^>)`	` accent grave (ex. `n nouvelle ligne, `t tabulation, `$ $ littéral)	`\ barre oblique inversée`
Guillemet dans une chaîne entre guillemets	`"" entre "…" pour de nombreux programmes ; varie selon le programme`	'It''s' ou "Say `"hi`""	`'It'\''s' ou "Say \"hi\""`
Continuation de ligne	`^ en fin de ligne`	` en fin de ligne (ou terminer une ligne par \| )	`\ en fin de ligne`
% ou $ littéral dans un script	`%% dans un fichier .bat`	'$' entre guillemets simples ou `$	`'$' entre guillemets simples ou \$`
Transmettre les arguments tels quels à un programme natif	`(inutile)`	`--% empêche PowerShell d’analyser le reste de la ligne`	`(inutile)`

Le passage des guillemets aux programmes natifs (curl.exe, git, node) a changé avec PowerShell 7.3 : les arguments contenant des guillemets doubles sont désormais transmis tels quels, comportement contrôlé par $PSNativeCommandArgumentPassing. Dans Windows PowerShell 5.1, le même corps JSON exige souvent d’échapper deux fois les guillemets internes, d’où le passage fréquent à Invoke-RestMethod avec ConvertTo-Json.

Stratégie d’exécution : « l’exécution de scripts est désactivée sur ce système »

PowerShell refuse d’exécuter les fichiers .ps1 lorsque la stratégie d’exécution est Restricted, ce qui est en pratique le réglage par défaut de Windows PowerShell sur les éditions clientes de Windows (Windows 10 et 11). Windows Server utilise RemoteSigned par défaut : les scripts locaux s’exécutent, ceux téléchargés doivent être signés ou débloqués. Sous Linux et macOS, la stratégie est Unrestricted et ne peut pas être modifiée.

Get-ExecutionPolicy -List affiche la stratégie pour chaque étendue ; l’étendue définie la plus spécifique l’emporte (la stratégie de groupe prime sur tout).
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser permet à vos propres scripts de s’exécuter sans droits administrateur.
Unblock-File .\script.ps1 retire la marque « téléchargé depuis Internet » d’un script de confiance.
pwsh -ExecutionPolicy Bypass -File script.ps1 (ou powershell pour la 5.1) applique une stratégie à une seule session.

La stratégie d’exécution est un garde-fou contre l’exécution accidentelle de scripts, pas une barrière de sécurité : n’importe qui peut coller le contenu du script dans la console.

Windows PowerShell 5.1 vs PowerShell 7

Deux programmes : powershell.exe est Windows PowerShell 5.1, intégré à Windows et qui ne reçoit plus de nouvelles fonctionnalités. pwsh est PowerShell 7, installé séparément et multiplateforme ; les deux peuvent cohabiter.
Opérateurs ajoutés dans la 7.0 : && et || entre les commandes, l’opérateur ternaire $a ? 'yes' : 'no' et la fusion null ?? / ??=.
Encodage des fichiers : dans la 5.1, > et Out-File écrivent en UTF-16 LE, et Set-Content utilise la page de codes ANSI. PowerShell 7 écrit partout en UTF-8 sans BOM, ce qu’attendent Git, les outils Linux et la plupart des éditeurs.
Alias : la 7 a supprimé curl, wget et sc sous Windows, et sous Linux/macOS elle laisse ls, cp, rm, cat, ps et d’autres aux commandes natives (tableau ci-dessus).
Modules manquants : les cmdlets propres à Windows comme Get-NetIPAddress, Test-NetConnection et Resolve-DnsName fonctionnent dans PowerShell 7 sous Windows, mais n’existent pas sous Linux ni macOS.

Utiliser bash sous Windows : WSL

Le Sous-système Windows pour Linux exécute une vraie distribution Linux à côté de Windows : chaque commande bash de la colonne de droite fonctionne telle quelle. wsl --install depuis une invite élevée l’installe avec Ubuntu par défaut (Windows 10 version 2004 et ultérieures, et Windows 11) ; wsl -l -v liste les distributions installées.

Lancer une commande Linux depuis CMD ou PowerShell : wsl ls -la, ou enchaîner avec un pipe : dir | wsl grep txt.
Les lecteurs Windows apparaissent sous Linux dans /mnt/c ; les fichiers Linux sont accessibles depuis l’Explorateur à l’adresse \\wsl.localhost\Ubuntu (anciennes versions : \\wsl$\Ubuntu).
Gardez vos projets dans le système de fichiers Linux (~/), pas dans /mnt/c : l’accès aux fichiers d’un système à l’autre est beaucoup plus lent.

Pour approfondir côté Linux, consultez l’aide-mémoire des commandes Linux.

Sources

Une référence statique qui s’exécute dans votre navigateur ; vos recherches ne sont envoyées nulle part. Parcourir tous les outils gratuits.

Un problème, ou quelque chose à améliorer ? Nous lisons chaque message et corrigeons vite.

Ce tableau CMD vs PowerShell vs Bash présente la même tâche dans l’invite de commandes Windows, PowerShell et bash sur une seule ligne : lister et copier des fichiers, chercher du texte dans des fichiers (l’équivalent PowerShell de grep est Select-String), variables d’environnement, processus, réseau, services, lecture et écriture de contenu de fichiers, et scripts avec variables, conditions, boucles et fonctions. Cherchez une commande de n’importe lequel des trois shells pour obtenir ses équivalents, chacun avec un bouton Copier.

L’aide-mémoire couvre aussi ce qui coince habituellement quand on passe de l’un à l’autre : les alias PowerShell qui ressemblent à des commandes Unix mais n’en sont pas (curl et wget dans Windows PowerShell 5.1, ls et rm partout sous Windows), les guillemets et caractères d’échappement différents, l’erreur de stratégie d’exécution qui bloque les scripts .ps1, et les différences entre Windows PowerShell 5.1 et PowerShell 7. Les commandes PowerShell fonctionnent dans les deux versions sauf mention contraire ; quand il n’existe pas d’équivalent CMD, le tableau le dit au lieu d’en inventer un.

Mode d’emploi

Cherchez la commande que vous connaissez, dans n’importe quel shell (par exemple « grep », « findstr » ou « Select-String »), ou la tâche (« tuer un processus », « variable d’environnement »).
Lisez la ligne pour trouver l’équivalent dans les deux autres shells et cliquez sur Copier à côté de celui dont vous avez besoin.
Consultez la note sous le nom de la tâche : elle signale les différences de version (PowerShell 5.1 ou 7) et les cmdlets propres à Windows.
Descendez jusqu’aux sections sur les alias, les guillemets et la stratégie d’exécution si une commande ne se comporte pas comme prévu.
Utilisez Imprimer / Enregistrer en PDF pour en garder une copie sur votre bureau ; la page fonctionne aussi sur téléphone, où chaque ligne devient une carte.

Questions fréquentes

Quel est l’équivalent PowerShell de grep ?

Select-String. Cherchez dans un fichier avec Select-String -Path app.log -Pattern error, ou filtrez la sortie d’une commande avec ipconfig | Select-String IPv4. Il est insensible à la casse par défaut (ajoutez -CaseSensitive), utilise les expressions régulières .NET, et -NotMatch équivaut à grep -v. Pour une recherche récursive, redirigez Get-ChildItem -Recurse -Filter *.log vers Select-String. Son alias court est sls.

Pourquoi curl se comporte-t-il bizarrement dans PowerShell ?

Dans Windows PowerShell 5.1, curl et wget sont des alias d’Invoke-WebRequest : les options de curl comme -X, -H et -d sont donc refusées ou signifient autre chose. Tapez curl.exe pour lancer le vrai curl fourni avec Windows 10 1803 et versions ultérieures. PowerShell 7 a supprimé ces alias, donc curl y lance curl.exe. Sous Linux et macOS, curl n’a jamais été un alias.

PowerShell est-il meilleur que CMD ?

Pour tout ce qui dépasse le lancement d’un programme ou un court fichier batch, oui. PowerShell fait transiter des objets structurés dans le pipeline au lieu de texte : vous filtrez et triez par nom de propriété (Where-Object, Sort-Object) au lieu d’analyser des colonnes, et il offre de vraies fonctions, la gestion des erreurs, la prise en charge de JSON et CSV et l’exécution à distance. CMD reste adapté aux anciens fichiers .bat et à certains installateurs, et tous les outils CMD (ipconfig, robocopy, netstat) peuvent aussi être lancés depuis PowerShell.

Comment corriger « running scripts is disabled on this system » (« l’exécution de scripts est désactivée sur ce système ») ?

C’est la stratégie d’exécution, réglée sur Restricted par défaut sur les éditions client de Windows 10 et 11. Lancez Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser dans PowerShell (sans droits d’administrateur). Vos propres scripts s’exécutent alors, et les scripts téléchargés sur Internet doivent être signés ou débloqués avec Unblock-File. Get-ExecutionPolicy -List montre ce qui est défini et où ; un paramètre de stratégie de groupe l’emporte sur tout ce que vous définissez vous-même.

Puis-je lancer des commandes bash sous Windows ?

Oui, avec le Sous-système Windows pour Linux (WSL). Lancez wsl --install depuis une invite avec élévation de privilèges (Windows 10 version 2004 ou ultérieure, ou Windows 11) pour installer Ubuntu, puis ouvrez-le depuis le menu Démarrer ou lancez des commandes isolées depuis CMD ou PowerShell avec wsl suivi de la commande, par exemple wsl grep -rn TODO. Git pour Windows inclut aussi Git Bash, un bash plus léger avec les outils Unix courants.

Quelle est la différence entre Windows PowerShell et PowerShell 7 ?

Windows PowerShell 5.1 (powershell.exe) est intégré à Windows et ne reçoit plus que des correctifs. PowerShell 7 (pwsh) est la version actuelle et multiplateforme, qui tourne sous Windows, Linux et macOS et s’installe séparément ; les deux peuvent coexister. La version 7 ajoute && et || entre les commandes, les opérateurs ternaire et ??, écrit les fichiers en UTF-8 par défaut et abandonne certains alias source de confusion comme curl et wget.

Objets contre texte : l’idée qui fait comprendre PowerShell

Dans CMD et bash, un pipe transporte du texte. Pour trouver le processus qui utilise le plus de mémoire en bash, vous extrayez la bonne colonne de la sortie de ps avec sort -k ou awk, et la commande casse si la disposition des colonnes change. Dans PowerShell, le pipe transporte des objets avec des propriétés nommées : la même tâche s’écrit Get-Process | Sort-Object WS -Descending | Select-Object -First 1. Rien n’est analysé, et les noms de propriétés sont les mêmes sur toutes les machines.

La conséquence pratique est une autre façon de découvrir les commandes. En bash, vous lisez une page de man pour connaître le format de sortie ; en PowerShell, vous redirigez n’importe quelle commande vers Get-Member pour voir les propriétés et méthodes de ses objets, puis vous filtrez avec Where-Object et choisissez les champs avec Select-Object. PowerShell ne convertit la sortie en texte qu’au moment où elle arrive à l’écran ou dans un fichier.

Les programmes natifs comme ipconfig, git ou curl.exe produisent toujours du texte dans PowerShell : Select-String et -match fonctionnent donc sur leur sortie comme le ferait grep. Leur code de sortie se trouve dans $LASTEXITCODE, pas dans $?.

Traduire un script d’un shell à l’autre

Une traduction ligne par ligne fonctionne pour les scripts simples, mais quelques différences piègent presque tout le monde :

• Opérateurs de comparaison : CMD utilise == pour les chaînes et EQU, GTR, LSS pour les nombres ; PowerShell utilise -eq, -gt, -lt, -like et -match (un > seul est une redirection) ; bash utilise = dans [ ] pour les chaînes et -gt ou (( )) pour les nombres.

• Variables : %name% dans CMD (et !name! dans les boucles après setlocal EnableDelayedExpansion), $name dans PowerShell, $name dans bash, sans espace autour de = lors de l’affectation.

• Dans les fichiers .bat, les boucles doublent le signe pourcentage : for %%f in (*.txt) dans un fichier, for %f à l’invite.

• Chemins : PowerShell accepte / et \ sous Windows ; bash sous Linux exige /. Les variables d’environnement sont insensibles à la casse sous Windows et sensibles à la casse sous Linux.

• Erreurs : CMD continue après un échec sauf si vous vérifiez %ERRORLEVEL% ; bash continue sauf avec set -e ; PowerShell continue après les erreurs non bloquantes sauf si $ErrorActionPreference = 'Stop'.

Quand un script doit tourner sous Windows et Linux, PowerShell 7 ou bash sous WSL évite de maintenir deux versions.

Outils gratuits similaires

Aide-mémoire des commandes Linux — Les commandes Linux par tâche, des fichiers et permissions au réseau, à systemd et au traitement de texte. Chaque entrée comporte options, exemples à copier et remarques pour macOS.
Raccourcis clavier Windows — Tous les raccourcis de Windows 11 dans une liste consultable et imprimable : touche Windows, ancrage, bureaux, captures d’écran, Explorateur de fichiers.
Raccourcis clavier Mac — Tous les raccourcis macOS avec les symboles ⌘ ⌥ ⌃ ⇧ expliqués : captures d’écran, disposition des fenêtres, Finder, Safari et caractères spéciaux.
curl en code — Collez une commande curl, y compris un « Copy as cURL » de Chrome, et obtenez la même requête en Python, JavaScript, Node, Go, PHP, Ruby, Java, C#, wget ou HTTPie.
Aide-mémoire Git — Les commandes Git classées selon ce que vous voulez faire : annuler le dernier commit, renommer une branche, supprimer une branche distante. switch/restore modernes avec leurs équivalents classiques et badges de danger.