Do {

• Do
  A ‘keyword’ or ‘statement’. It’s saying, “I want you to do all of the stuff within the curly brackets, and keep doing all this stuff within the curly brackets, until…” Do is always paired with an Until statement. Keep an eye out for that later.

• {
  The curly bracket (or ‘curly brace’) is used in PowerShell (and many other programming languages) to define ‘blocks’ (as in, ‘bricks’, ‘squares’, ‘units’) of code. Consider this: Even if you don’t know any programming languages, you could probably decipher Do x + 1 until x = 10 because you are a reasonable human. The computer is not a reasonable human. The computer needs clearly defined markers to tell it “When I say this, I want you to apply it to this” with strictly NO room for ambiguity. The curly brackets (and the concept of ‘blocks’) are used to help the computer interpret what parts of the code we want our statements to apply to. In this line, we are using the curly braces with Do so,

  “Do {<everything within the curly braces>}”

  Later in the script, we will ‘close’ this block with the closing brace } to mark the end of the Do statement, and then we’ll have our Until statement (I promise Do{} Unitl() will be made more clear when we reach the ‘Unitl’ keyword later in the code).

 	Write-Host @"

• This line beings with an indent (one ‘tab’ space). In PowerShell, line indents and trailing spaces do not matter like they do in some other languages. But it is good practice to use them as it helps organise your blocks of code and keep things readable. This line is in the first code block, (the Do statement), so it has one indent.

• Write-Host
  Our first ‘command’, technically called a ‘cmdlet’ in PowerShell language (pronounced ‘Command-let’, as in, ‘anklet’ or ‘booklet’). Write-Host tells the computer to output whatever text is fed to it into the terminal window. Read more in my other post here.

• @"
  Normally Write-Host would just write whatever comes after it on the same line. In this case, I want it to write several lines of text to the screen (to create our CLI’s ‘main menu’). I mark the text as a ‘multi-line string’ by using the @ in-front of the " quote marks. We will ‘close’ the multi-line string later with "@ , so in other words we tell the computer, Write @”Everything enclosed in here”@

[?] Display help
[Q] Quit

• This text is ‘wrapped’ in our Write-Host‘s multi-line quotation markers @" "@. This means they are being ‘defined’ as a string, (we’ll cover ‘data types’ like strings and integers another time. Just know in short that a ‘string’ is text) that is getting ‘passed’ to our Write-Host command. In other words, these lines of text are what Write-Host is going to ‘write’ to the terminal window.
• This is the display of the ‘main menu’ of our CLI. I want to tell the user they can input “?” to get some direction, or input “Q” to quit the app. If you want to modify the main-menu, you can make your desired changes to these lines of text.

"@ -ForeGroundColor Cyan

• "@ 
  This closes the multi-line string, ending the text that the Write-Host command will effect.
• -ForeGroundColor Cyan
  This is our first ‘parameter’. Commands will often have parameters (marked by a - hyphen) that modify the way they behave, or give them additional required information to use. In this instance, -ForeGroundColour is an optional parameter for the Write-Host command. It is used to… you guessed it… change the colour of the text that Write-Host writes. Cyan in this case, is an ‘argument’ for the parameter. ‘Argument’ is a programmer-y term. You could think of it as an ‘input’, or a ‘parameter-for-the-parameter’. I’m sure you can figure out what Cyan does, given the example: Write-Host "This is cyan-coloured text" -ForeGroundColor Cyan. PowerShell has several pre-set colour values. You can use Red, Green, Magenta, (and more). It’s worth noting there’s also a -BackgroundColor parameter, so you can really customise the ‘look’ of your CLI if you want to play with different colour combinations. My other blog post covers this.

$menuChoice = Read-Host

• $menuChoice
  This is our first ‘variable’. Variables are a common concept in all programming languages. They are a store of value. In PowerShell, they can store pretty much any value, and can be re-assigned at any time. Variables are always marked by a $ in PowerShell. If I wrote $x = 1 then it would be correct to say $x + 1 = 2 . If I wrote $x = "Snubble Flub" then Write-Host $x would write “Snubble Flub” to the window.
• =
  Is an ‘assignment operator`. It assigns the value of whatever is on its right, to the variable on its left.
• Read-Host
  Is another cmdlet. It waits for the user to hit the ‘enter’ key, and then ‘reads’ the value of whatever was typed before the ‘enter’ key was pressed.
• So this line of code as a whole tells the computer to “store whatever the user types here as $menuChoice”. And so subsequently, “Whenever I say $menuChoice in the code henceforth- I want you to refer to whatever the user input when we did Read-Host”.

switch ($menuChoice) {

• Here we begin our second code-block with a switch statement. A switch will look at whatever is passed to it inside its brackets () (in this case- it’s looking at the value of $menuChoice) and will compare it to the possible values you present in its code block (note the opening { brace marking the beginning of the switch block).

'?' {

• Two indents at the start of this line, since it sits in our second code-block (the switch is ‘nested’ inside of the the Do)
• '?'
  This is the first value that our switch will compare $menuChoice against. In other words, if $menuChoice is a ‘?’, then the script will execute the block of code wrapped in these curly braces. I wrap the ? in single-quotes (’’) so that the computer knows this is a ‘string’ of text that I want to compare $menuChoice to.

Write-Host "Created by Barclay McClay"

• Three indents at the start of this line, as it is nested three layers deep- inside the Do block, the switch block, and the ? block. We can start to see why we ‘indent’ (add those spaces) to the start of our lines of code to visually organise them into ‘blocks’. By glancing at how ‘deep’ this line of code is, we can determine that it will only be run if three pre-conditions are met- in this case, the Do has to run, we need to reach the switch , and the switch value has to match ?
• This line will be executed if $menuChoice is equal to “?”. In other words, “If the user inputs ‘?’ at the main menu, the program will write the words ‘Created by Barclay McClay’ to the window.”

break

• break
  Tells the program to stop and exit the current code-block it is in. To be honest, the way I’ve used it here isn’t actually necessary in PowerShell; but it’s how you’re meant do switch statements in other programming languages so I’m kind-of stuck in the habit. In this case, we’re at the end of the code-block anyway, so even if the break wasn’t there, it’d still finish up the statement.

}

• We see the our first closing of a code block here. In this case, we are ending the ? code block within the switch statement. So we are done telling the computer what to do if $menuChoice is equal to “?”.

'q' {
	break
}

• Just like the ‘?’ block above it, these lines tell the program what to do if the switch finds that $menuChoice is equal to ‘q’ (the comparison is not case-sensitive, so ‘Q’ will also trigger this).
• It will immediately run into a break and exit the code-block. This code is ‘redundant’- it doesn’t actually action anything, but it’s in there to make extending/customising this script easier down the line.
• ‘Q’ is our menu option for ‘Quit’, so it’s expected that users will be commonly be inputting ‘q’ as $menuChoice. If we wanted to display a message like “Thanks for using my App!”, or implement some sort of check such-as, ”Are you sure you want to quit?”, we could add the functionality for that here in this code-block before the break.
• We will handle the actual ‘quitting’ of our application later-on in the code. Note this block (with nothing but a break statement in it) would be executed after the user has input ‘q’, but before the app actually exits.

default {
	Write-Host "- Invalid Input -" -ForegroundColor Red
}

• default {
  This keyword is unique to switch statements. It is run if none of the other options (in this case- ‘?’ or ‘q‘ ) are found to match the switch value ($menuChoice).
• If the user of our app inputs anything other than one of the possible listed menu options, then the script will write a default message (- Invalid Input -) to the terminal window, in the colour Red.

}

• There’s another closing curly brace to note here. This one closes the switch statement’s code block. So we’re done comparing different values to $menuChoice

} Until ($menuChoice -eq 'q')

• Here’s where it all comes together. This closing curly brace } ends our Do statement’s code block, which has been the entire script up to this point. Remember how I said Do is always paired with an Until? So everything in the Do block will keep being done, over-and-over again, Until (whatever it says in these brackets comes true) .
• ($menuChoice -eq 'q')
  Inside the Until brackets, we are checking if our variable $menuChoice is equal -eq to 'q' .

# If we've made it out of the Do{}Until() loops somehow- then exit gracefully.

• This writing has a # in-front of it. This means the PowerShell interpreter will treat it as a ‘comment’ and totally ignore whatever is written after the #
• Write lots of comments all over your code. You will thank yourself later for it. This comment explains what happens after the main-loop.

Write-Host "Exiting..."
exit

• Just as the comment above it says- once the script has made it out of the Do code-block (the Until condition has been resolved as ‘true’), we will write ‘Exiting…’ to the terminal window, then exit the app.