Comment démarrer un script à un point spécifié dans Powershell

Question

J'ai un script PowerShell Je veux être en mesure de définir différents points de départ pour. Une fois que le point de départ est atteint, le script reprend à partir de ce point et continue à travers le code restant dans le script. Je ne crois pas qu'une déclaration de cas fonctionnera puisque je ne pense pas que cela laissera simplement passer le script à partir du point de départ défini.

Je m'attendrais à voir quelque chose comme ça lorsque le script a été lancé.

S'il vous plaît choisir votre point de départ:

1. À partir
2. Début à l'étape 2
3. Démarrer à l'étape 3 etc .....

Lorsque la sélection est faite le script saute à ce moment-là, puis passera par le reste du script.

Réponse: Le code va finir par quelque chose comme ceci:

#steps 
$stepChoice = read-host 'Where would you like to start.' 

switch($stepChoice) 
{ 
    1{Step1} 
    2{Step2} 
    3{Step3} 

} 

function Step1 { 
    'Step 1' 
    Step2 
} 
function Step2 { 
    'Step 2' 
    Step3 
} 
function Step3 { 
    'Step 3' 
    'Done!' 
} 

Merci pour votre aide

Answer 1

AFAIK, il n'y a rien de tel dans PowerShell. Si vous avez besoin de quelque chose de simple cela peut fonctionner pour vous:

*) Créez un script avec des étapes définies en tant que fonctions. Chaque fonction à la fin appelle la prochaine étape fonction:

# Steps.ps1 
function Step1 { 
    'Step 1' 
    Step2 
} 
function Step2 { 
    'Step 2' 
    Step3 
} 
function Step3 { 
    'Step 3' 
    'Done!' 
} 

*) Si vous voulez commencer à l'étape 1: source point le Steps.ps1 et appelez Etape 1:

. .\Steps.ps1 
Step1 

*) Si vous voulez commencer à l'étape 2: source point le Steps.ps1 et appelez Etape 2:

. .\Steps.ps1 
Step2 

Answer 2

PowerShell ne contient pas une commande de type GOTO, vous devez donc résumer chacun des étapes logiques (Début, étape2, étape3, ...) dans une procédure/bloc de code quelconque et appelez selon le cas. Alors qu'une instruction switch ne sera pas l'échelle bien si vous avez besoin beaucoup de choix, pour trois, il serait assez simple - voici une idée, mais je suis sûr que cette idée peut être mis en œuvre mieux:

function Begin() { "Starting" } 
function Step-1() { "One" } 
function Step-2() { "Two" } 

function Take-Action() { 
    param([string]$choice); 
    switch ($choice) { 
    "Start" { & Begin ; Take-Action "One" } 
    "One" { & Step-1; Take-Action "Two" } 
    "Two" { & Step-2 } 
    } 
} 

& Take-Action "Start" 

sortie:

Starting 
One 
Two 

Answer 3

une approche plus directe serait d'utiliser une série de déclarations if, de sorte que toutes les fonctions d'aide peuvent être utilisés indépendamment sans avoir à croiser d'autres étapes.

[int]$stepChoice = read-host 'Where would you like to start.' 

if($stepChoice -le 1) { 
    'Step 1' 
} 

if($stepChoice -le 2) { 
    'Step 2' 
} 

if($stepChoice -le 3) { 
    'Step 3' 
} 

'Done!' 

Notez également qu'une déclaration switch continuera d'évaluer les conditions jusqu'à ce qu'il rencontre une déclaration break, cette forme travaillera également:

switch($stepChoice) { 
    { $_ -le 1 } { 'Step 1' } 
    { $_ -le 2 } { 'Step 2' } 
    { $_ -le 3 } { 'Step 3' } 
} 

'Done!' 

Answer 4

Cette réponse supplémentaire est probablement trop pour cette tâche particulière . Mais il peut être utile de connaître l'outil. Il peut être utilisé pour des tâches similaires et plus compliquées.

L'outil est Invoke-Build.ps1. C'est un script autonome, placez-le n'importe où dans le chemin, c'est tout. Utilisez ensuite le code comme ceci:

Steps.ps1

# Invoke-Build task is a sequence of scripts and other tasks. 
# This task does its job and then calls the task Step2. 
task Step1 { 
    'Step 1' 
}, 
Step2 

# This task does its job and then calls the task Step3. 
task Step2 { 
    'Step 2' 
}, 
Step3 

# The last task, just its name and code. 
task Step3 { 
    'Step 3' 
} 

Test.ps1

Invoke-Build step1 Steps.ps1 # do steps 1, 2, 3 
Invoke-Build step2 Steps.ps1 # do steps 2, 3 
Invoke-Build step3 Steps.ps1 # do just step 3 

---

La différence entre cette situation et la réponse précédente est que, avec tâche approche les blocs de code pas réels ne doivent pas être dépendants explicitement, c'est-à-dire appeler d'autres étapes. C'est l'infrastructure de tâche qui colle les actions ensemble.