Come eseguire i comandi CMD in PowerShell

1. Utilizzare l’Operatore di Invocazione di PowerShell &
2. Eseguire comandi CMD utilizzando cmd.exe
3. Inviare a CMD utilizzando PowerShell
4. Conclusione

Molti comandi legacy del Prompt dei comandi (CMD) funzionano nell’ambiente di scripting di Windows PowerShell. L’ambiente PowerShell porta avanti questi comandi dai più utilizzati come ping ai comandi più informativi come tracert dall’ambiente legacy utilizzando alias.

Tuttavia, alcuni comandi eseguiti nel terminale del Prompt dei comandi non funzioneranno nell’ambiente di scripting di Windows PowerShell. Questo articolo discuterà di come possiamo trascriverli correttamente in Windows PowerShell.

Utilizzare l’Operatore di Invocazione di PowerShell &

Nel variegato mondo dello scripting, PowerShell si distingue per la sua capacità di incorporare ed eseguire comandi da altri ambienti di scripting, in particolare il Prompt dei comandi (CMD). Uno dei metodi più diretti per ottenere ciò è attraverso l’Operatore di Invocazione (&).

Questo articolo approfondisce l’uso dell’Operatore di Invocazione per eseguire comandi CMD all’interno di PowerShell, un’abilità inestimabile per coloro che desiderano collegare le funzionalità di PowerShell e degli script CMD tradizionali.

La sintassi di base per utilizzare l’Operatore di Invocazione è la seguente:

& <Command-String> <Arguments>

• &: Questo è l’Operatore di Invocazione.
• <Command-String>: Questo è il comando che desideri eseguire. Può essere un comando CMD, un cmdlet di PowerShell o un blocco di script.
• <Arguments>: Questo è facoltativo e rappresenta eventuali argomenti o parametri richiesti dal comando.

Esempio di codice:

& cmd.exe /c echo "Hello from CMD"

In questo script, utilizziamo l’Operatore di Invocazione & per eseguire senza problemi un comando CMD all’interno di PowerShell. Inizialmente, chiamiamo cmd.exe, l’eseguibile designato per il Prompt dei comandi, assicurandoci di lavorare nell’ambiente della riga di comando corretto.

Passiamo quindi il parametro /c a cmd.exe, un’istruzione cruciale che dirige il Prompt dei comandi ad eseguire il nostro comando specificato e terminare prontamente dopo. Il nostro comando di scelta, echo "Hello from CMD", è una dimostrazione semplice ma efficace, in quanto stampa semplicemente il messaggio Hello from CMD sulla console.

Output:

Questo output dimostra che il comando CMD echo è stato eseguito con successo all’interno di PowerShell, visualizzando il messaggio previsto.

Eseguire comandi CMD utilizzando cmd.exe

Un altro esempio di esecuzione di comandi CMD è tramite l’uso di cmd.exe. Possiamo aggiungere cmd.exe all’interno di Windows PowerShell come nel nostro metodo precedente.

Una volta aggiunto ed eseguito, chiamerà l’interfaccia della riga di comando all’interno del prompt dei comandi di Windows PowerShell.

La sintassi per utilizzare cmd.exe direttamente in PowerShell è la seguente:

cmd.exe /c "<Command-String>"

• cmd.exe: Questo è l’eseguibile per il Prompt dei comandi.
• /c: Questo è un parametro che istruisce cmd.exe a eseguire il comando specificato dalla stringa e poi terminare.
• "<Command-String>": Questo è il comando CMD o serie di comandi che desideri eseguire.

Esempio di codice:

cmd.exe /c "echo Hello from CMD"

In questo script, integriamo senza problemi la funzionalità CMD in PowerShell invocando direttamente cmd.exe con il parametro /c, seguito dal nostro comando di interesse, echo Hello from CMD. Utilizzando cmd.exe /c, stabilisci un ponte tra PowerShell e CMD, permettendoci di accedere all’ambiente e alle funzionalità familiari della riga di comando di CMD all’interno del nostro script PowerShell.

Il comando "echo Hello from CMD" è un esempio semplice ma illustrativo di questa integrazione, in cui utilizziamo un comando CMD di base per stampare il nostro testo desiderato sulla console.

Output:

Questo output dimostra l’esecuzione riuscita di un comando CMD echo in PowerShell, visualizzando il messaggio Hello from CMD.

Inviare a CMD utilizzando PowerShell

In Windows PowerShell, possiamo anche inviare comandi al terminale del prompt dei comandi tramite piping nel cmdlet cmd al comando che desideri inviare.

Il piping a CMD in PowerShell è utilizzato principalmente per eseguire comandi CMD o script batch all’interno di un contesto di PowerShell. Questo metodo è particolarmente utile quando devi eseguire un comando CMD che non ha un equivalente diretto in PowerShell o quando hai a che fare con script CMD legacy.

La sintassi di base per inviare a CMD in PowerShell è:

"<Command-String>" | cmd.exe /c -

• "<Command-String>": Questo è il comando CMD che desideri eseguire.
• |: Questo è l’operatore pipe di PowerShell, che passa l’output di un comando come input a un altro.
• cmd.exe /c -: Questo chiama il Prompt dei comandi per eseguire il comando passato tramite la pipe. Il - indica che cmd.exe dovrebbe aspettarsi il comando dall’input standard (stdin).

Esempio di codice:

"echo Hello from CMD" | cmd.exe

In questo esempio, utilizziamo la tecnica del piping per inviare la stringa "echo Hello from CMD" a cmd.exe, dimostrando un elegante connubio delle capacità di piping di PowerShell con l’esecuzione dei comandi di CMD.

Il nostro percorso inizia con "echo Hello from CMD", un semplice ma efficace comando CMD racchiuso come stringa, progettato per visualizzare un messaggio specifico quando eseguito nell’ambiente CMD.

Utilizziamo quindi l’operatore pipe |, uno strumento potente in PowerShell, per inoltrare senza problemi questa stringa di comando a cmd.exe. Il culmine di questo processo è osservato in cmd.exe /c -, dove il simbolo - gioca un ruolo cruciale, istruendo cmd.exe a leggere e eseguire attentamente il comando in arrivo dalla pipeline.

Output:

Questo output è il risultato del comando CMD echo, che stampa Hello from CMD sullo schermo.

Eseguire comandi CMD in PowerShell utilizzando Invoke-Expression

Un metodo versatile e potente per eseguire comandi CMD all’interno di PowerShell è tramite il cmdlet Invoke-Expression. Questo approccio è particolarmente utile quando è necessario costruire ed eseguire dinamicamente un comando o un blocco di script.

Questo articolo approfondisce lo scopo, l’applicazione e l’uso del metodo Invoke-Expression in PowerShell per eseguire comandi CMD.

La sintassi per Invoke-Expression è:

Invoke-Expression -Command "<Command-String>"

• -Command: Questo specifica il comando da eseguire. Questo parametro può essere abbreviato come -C.
• "<Command-String>": Questa è la stringa che contiene il comando da eseguire.

Esempio di codice:

Invoke-Expression -Command "cmd.exe /c echo Hello from CMD"

Nel nostro script, sfruttiamo il potere di Invoke-Expression per eseguire abilmente un comando CMD racchiuso all’interno di una stringa. Il nostro processo inizia con Invoke-Expression -Command, una combinazione di cmdlet e parametro fondamentale che fornisce a PowerShell la capacità di interpretare ed eseguire la stringa di comando fornita.

Introduciamo quindi "cmd.exe /c echo Hello from CMD" come nostra stringa di comando scelta. Questa stringa istruisce abilmente cmd.exe ad utilizzare il parametro /c, una direttiva che comanda CMD ad eseguire il comando successivo e poi concludere il suo processo.

Il comando echo, racchiuso all’interno di questa stringa, è il cuore della nostra esecuzione, progettato per produrre Hello from CMD in CMD.

Output:

Questo output è il risultato diretto dell’elaborazione del comando echo da parte di CMD, che è invocato da Invoke-Expression in PowerShell.

Conclusione

In questa esplorazione completa, abbiamo approfondito la versatilità dell’esecuzione dei comandi del Prompt dei comandi (CMD) all’interno dell’ambiente di Windows PowerShell, coprendo quattro metodi distinti: l’Operatore di Invocazione &, l’uso diretto di cmd.exe, la tecnica innovativa di piping dei comandi a CMD e il cmdlet dinamico Invoke-Expression. Ciascun approccio offre vantaggi unici per integrare le funzionalità familiari di CMD nell’avanzato regno della scrittura di script di PowerShell.

Per coloro che cercano di ampliare la propria esperienza con PowerShell, è altamente raccomandato approfondire argomenti avanzati come la creazione di cmdlet personalizzati di PowerShell o tecniche di scripting avanzato di PowerShell, aprendo porte a soluzioni di scripting più sofisticate e robuste che armonizzano i punti di forza di PowerShell e CMD.