Jump into PowerShell with these introductory concepts.

Getting Started

Well-executed PowerShell commands can accomplish a lot, but sometimes we must perform complex tasks requiring multiple commands. In such cases, we can write a PowerShell script and run it in the terminal when needed.

To run a script, we open up any text editor, write our commands and name the file with a `.ps1` file extension. 

For example, the following commands can be put into a script file called **host-commands.ps1**.
```PowerShell
Write-Host "All commands that act on Host:" 
Get-Command -Noun Host
```
With these two commands in the **host-commands.ps1** file, we can now run our script using the following command in the terminal:
```
.\host-commands.ps1
```
This will run the script and produce the following output:
```
All commands that act on Host:

CommandType     Name
-----------     ----                                   
Function        Clear-Host                             
Cmdlet          Get-Host                               
Cmdlet          Out-Host                               
Cmdlet          Read-Host                              
Cmdlet          Write-Host 
```
The `.\` notation before the script name tells the shell to look for a file in the current directory and run it. In most shells, the forward slash notation `./` may also be used.

Writing Scripts

PowerShell is a command-line shell and scripting language. This means that we can run individual commands within the terminal as well as create and execute more complex scripts. Both are equally useful when automating computer administration tasks.

While most computing interfaces involve a GUI, **G**raphical **U**ser **I**nterface, there is a clear reason why developers and administrators still use command-line tools like PowerShell: they are just better at certain tasks. 

If we look at essential file system management, creating folders for 20 users might involve dozens or hundreds of mouse movements and clicks using a graphical interface. Alternatively, a single command in the PowerShell terminal can take a list of names and create folders for each. 

The above example gets more convincing when our users are in the thousands, and the tasks for each user become more complex. While graphical interfaces can be programmed to perform any group of actions, it is quicker and cheaper to accomplish our goals using PowerShell.




What is PowerShell

Great work getting through this primer on PowerShell! We covered several topics, such as:
- How PowerShell can automate our work within an operating system
- Common commands such as:
  - `Get-Date`
  - `Write-Host`
  - `Get-Command`
  - `Get-History`
- Using terminal shortcuts to increase productivity
- Writing scripts help us run complex tasks

Summary

When working in the PowerShell terminal, a few practical actions can make running commands easier.

##### Command Completion
If you type in only a few letters of a command and then hit the <kbd>Tab</kbd> key, the terminal will attempt to autocomplete the command. 

If there is only one command that the partial command can be, such as `Get-D`, hitting <kbd>Tab</kbd> will autofill the rest of the command with `Get-date`.

If more than one command matches the partial command, such as `Get-H`, <kbd>Tab</kbd> will list the potential commands. 
```
Get-Help   Get-History   Get-Host
```
This can help us identify what command we want to use.

##### Command History
As with most modern terminals, a command history is stored in a file and can be accessed using: 
```
Get-History
```
This command is helpful if you forget how you previously accomplished a task and want to look back.

##### History with Up/Down Keys
If there are commands that you plan on using a lot or ones that are long that you have to run again, the Up, <kbd>↑</kbd> and Down <kbd>↓</kbd> keys on the keyboard can be used to cycle through your command history. Start this process using the up arrow key to scroll from newer to older commands. You can scroll back with the down arrow key toward more recent commands.

Using quick shortcuts like these allows us to navigate the text-based world of PowerShell a little bit easier, so we can focus on our primary task. 

Using the Terminal

Running commands in PowerShell can help us accomplish many different tasks. PowerShell commands are called _CmdLets_, which is pronounced command-lets. Their names help us understand their action because they are given a "Verb"-"Noun" command format, such as:
```PowerShell
Get-Date
```
The above PowerShell command has the verb `Get`, and the noun `Date`, which leads us to believe the current date will be retrieved and printed to the terminal.

In the last exercise, you may have printed "Hello, World!" in the terminal using:
```PowerShell
Write-Host "Hello, World!"
```
This command will write to the host, printing a given argument to the terminal. In this case, the string "Hello, World!" is used as an argument to `Write-Host`. As we will see in the next exercise and future lessons, `Write-Host` is used within scripts to create output for the user and display data being processed.

`Get-Date` and `Write-Host` are just a couple of the many CmdLets we can run in the PowerShell terminal. To discover more commands available to us, use the following:
```PowerShell
Get-Command
```
Without any argument, `Get-Command` will output all available CmdLets. We can also request specific CmdLets. To output all `Get` commands, we need to pass an argument using the `-Verb` flag:
```PowerShell
Get-Command -Verb Get
```
The `-Verb` flag looks for any commands whose verb matches the argument given: `Get`.

We can also look for specific nouns:
```PowerShell
Get-Command -Noun Host
```
This command outputs all the commands acting on `Host`, the terminal.

Lastly, as with any terminal session, our screen can get filled with a lot of text. To clear the terminal, use the following:
```PowerShell
Clear-Host
```
Run this to clear the terminal session.

Basic Commands

Welcome to Learn PowerShell. Whether you work in DevOps or SysAdmin roles or want to add PowerShell to your digital toolbox, this lesson's content will get you started with this powerful command-line tool.

PowerShell was introduced to the Windows operating system in 2006 and has since become a popular tool for automating many Windows tasks. While the shell focuses on Windows administration, PowerShell command-line applications are now available to install on the Mac OS and Linux operating systems. 

In this lesson, you will learn about using PowerShell, including common commands, navigating the terminal, and writing scripts. Let's get ready to learn this fundamental tool and how it can help you accomplish tasks more efficiently!

Text image with the title, Getting Started, and a quote, PowerShell is a command-line shell and scripting language that can run individual commands within the terminal as well as create and execute more complex scripts.
