1. Bash (Linux/MacOS):
Questo approccio utilizza la gestione e il reindirizzamento degli errori integrati di Bash:
`` `Bash
#!/bin/bash
comand_to_execute ="some_invalid_command arg1 arg2"
$ comand_to_execute 2> &1> errorlog.txt
Se [$? -ne 0]; Poi
Echo "Command '$ Command_to_Execute' non riuscito. Vedi Errorlog.txt per i dettagli."> &2
fi
`` `
* `2> &1`:questo reindirizza l'errore standard (Stderr, File Descriptor 2) su Output standard (StDout, File Descriptor 1). Ciò garantisce che sia i messaggi di errore che qualsiasi output dal comando vengano acquisiti in `Errorlog.txt`.
* `> errorlog.txt`:questo reindirizza StDout (che ora include anche Stderr) al file` Errorlog.txt`. Qualsiasi contenuto esistente nel file verrà sovrascritto. Per aggiungere invece di sovrascrivere, utilizzare `>> ERRIRLOG.TXT`.
* `$?`:Questa variabile contiene lo stato di uscita del comando eseguito più recentemente. 0 indica il successo, mentre qualsiasi altro valore indica il fallimento.
2. PowerShell (Windows):
PowerShell offre una gestione degli errori più sofisticata:
`` `PowerShell
$ comando ="some_invalid_command arg1 arg2"
Tentativo {
&$ comando
}
presa {
# Scrivi il messaggio di errore nel file di registro.
$ _. Eccezione.Message | Out -file -filePath "Errorlog.txt" -Append
Write-error "comando '$ comando' non riuscita. Vedi errore.txt per i dettagli."
}
`` `
* `Prova ... Catch`:questo blocco gestisce potenziali eccezioni durante l'esecuzione del comando.
* `$ _. Eccezione.Message`:questo estrae il messaggio di errore dall'oggetto eccezione.
* `Out -file -filePath" errorlog.txt "-append`:questo aggiunge il messaggio di errore al file` Errorlog.txt`.
3. Python (cross-piattaforma):
Python consente un maggiore controllo programmatico ed è indipendente dalla piattaforma:
`` `Python
Sottoprocesso di importazione
Import sys
comand =["some_invalid_command", "arg1", "arg2"]
Tentativo:
risultato =subprocess.run (comando, stderr =subprocess.pipe, text =true, controllo =true)
#Se riuscito, result.stderr sarà vuoto.
Tranne Subprocess.CalledProcesserror come E:
con aperto ("Errorlog.txt", "a") come f:
F.Write (f "Command '{Command}' non riuscito con il codice di ritorno {E.ReturnCode}:\ n")
F.Write (E.stderr + "\ n")
print (f "Command '{Command}' non riuscito. Vedi Errorlog.txt per i dettagli.", file =sys.stderr)
Tranne FileNotFounderror:
con aperto ("Errorlog.txt", "a") come f:
f.write (f "comando '{comando}' non trovato. \ n")
print (f "Command '{Command}' non trovato. Vedi Errorlog.txt per i dettagli.", File =sys.stderr)
`` `
* `subprocess.run`:questo esegue il comando.
* `stderr =subprocess.pipe`:cattura stderr.
* `text =true`:garantisce che l'output venga decodificato come testo.
* `Check =true`:aumenta un'eccezione se il comando restituisce un codice di uscita diverso da zero.
* `FileNotFounderror` è esplicitamente gestito per gestire i comandi che non esistono.
Ricorda di sostituire `" some_invalid_command arg1 arg2 "` con il tuo comando reale. Gli esempi utilizzano `Errorlog.txt`, ma puoi scegliere qualsiasi nome file che preferisci. Prendi sempre in considerazione la gestione appropriata degli errori per evitare che lo script si arrestasse in modo imprevisto. L'esempio Python dimostra una robusta gestione degli errori; Si consiglia di adottare un approccio simile per scenari più complessi.
Domanda © www.354353.com