Intro to PowerShell: Master the Basics in 30 Days

By /

Okay, here’s a comprehensive article, approximately 5000 words in length, covering an “Intro to PowerShell: Master the Basics in 30 Days” curriculum:

Intro to PowerShell: Master the Basics in 30 Days

PowerShell is more than just a command-line interface; it’s a powerful scripting language and automation framework built on the .NET framework. It’s an essential tool for system administrators, developers, and anyone who wants to efficiently manage and automate tasks on Windows (and increasingly, Linux and macOS). This 30-day plan provides a structured approach to learning the fundamentals of PowerShell, taking you from a complete beginner to someone comfortable with writing basic scripts and automating common tasks. Each day builds upon the previous one, so consistent effort is key.

Prerequisites:

  • A computer running Windows (Windows 7 SP1 or later, Windows Server 2008 R2 SP1 or later). While PowerShell is cross-platform, this guide focuses on Windows. If you are using Linux or macOS, you’ll need to install PowerShell Core.
  • Basic familiarity with the concept of a command-line interface (CLI) is helpful but not strictly required.
  • A text editor (like Notepad++, VS Code, or the built-in PowerShell ISE) for writing scripts. VS Code with the PowerShell extension is highly recommended.

Learning Methodology:

This plan combines theoretical understanding with hands-on practice. Each day includes:

  • Concepts: Explaining the “why” behind PowerShell features.
  • Commands: Introducing key cmdlets (PowerShell commands) and their usage.
  • Examples: Illustrating practical applications of the concepts and commands.
  • Exercises: Hands-on tasks to reinforce learning and build confidence.
  • Further Exploration: Links to official documentation and resources for deeper dives.

The 30-Day Curriculum

Day 1: Introduction and Setup

  • Concepts:
    • What is PowerShell? Understand its role as a shell and scripting language.
    • Why use PowerShell? Learn about its automation capabilities, object-oriented nature, and integration with the .NET framework.
    • PowerShell vs. Command Prompt (cmd.exe): Recognize the key differences and advantages of PowerShell.
    • PowerShell Editions: Windows PowerShell (versions 1.0 – 5.1) and PowerShell (version 6 and onwards, also know as PowerShell Core). PowerShell 7 is the recommended version.
  • Commands:
    • Get-Help: The most important cmdlet! Learn how to access PowerShell’s built-in help system. Use it with wildcards (*) and the -Online parameter.
    • Get-Command: Discover available cmdlets.
    • Get-Alias: Find aliases for cmdlets (shortcuts).
  • Examples:
    • Get-Help Get-Process
    • Get-Help *service*
    • Get-Help Get-ChildItem -Online
    • Get-Command -CommandType Cmdlet
    • Get-Alias -Definition Get-ChildItem
  • Exercises:
    • Open PowerShell (as an administrator, for some tasks).
    • Use Get-Help to explore the help for Get-Process, Get-Service, and Get-ChildItem.
    • Find at least five cmdlets using Get-Command.
    • Identify the aliases for Get-ChildItem and Get-Location.
  • Further Exploration:

Day 2: Basic Navigation and Object Manipulation

  • Concepts:
    • The PowerShell Pipeline: Understand how objects are passed from one cmdlet to another.
    • Objects and Properties: Learn that PowerShell works with objects, not just text. Objects have properties (attributes) and methods (actions).
    • Current Location: Working with directories (similar to Command Prompt).
  • Commands:
    • Get-ChildItem (alias: ls, dir): List files and directories.
    • Set-Location (alias: cd): Change the current directory.
    • Get-Location (alias: pwd): Display the current directory.
    • Select-Object: Choose specific properties of an object.
    • Where-Object (alias: ?): Filter objects based on conditions.
  • Examples:
    • Get-ChildItem
    • Set-Location C:\Windows
    • Get-ChildItem | Select-Object Name, Length
    • Get-Process | Where-Object {$_.WorkingSet -gt 100MB}
    • Get-Service | Where-Object {$_.Status -eq 'Running'}
  • Exercises:
    • Navigate to your Documents folder using Set-Location.
    • List all files and folders in the current directory.
    • List only the names of files in the current directory.
    • Find all running services.
    • Find processes using more than 50MB of memory.
  • Further Exploration:

Day 3: Working with Files and Folders

  • Concepts:
    • Creating, deleting, and manipulating files and folders.
    • Understanding file paths (absolute vs. relative).
  • Commands:
    • New-Item: Create new files and folders.
    • Remove-Item (alias: del, rm, rmdir): Delete files and folders.
    • Copy-Item (alias: cp, copy): Copy files and folders.
    • Move-Item (alias: mv, move): Move files and folders.
    • Rename-Item (alias: ren, rename): Rename files and folders.
    • Get-Content (alias: cat, type): Display the content of a file.
    • Set-Content: Write content to a file (overwrites existing content).
    • Add-Content: Append content to a file.
  • Examples:
    • New-Item -ItemType Directory -Path "C:\MyNewFolder"
    • New-Item -ItemType File -Path "C:\MyNewFolder\MyFile.txt"
    • Remove-Item -Path "C:\MyNewFolder\MyFile.txt"
    • Copy-Item -Path "C:\Source\File.txt" -Destination "C:\Destination"
    • Get-Content -Path "C:\MyFile.txt"
    • Set-Content -Path "C:\MyFile.txt" -Value "Hello, PowerShell!"
    • Add-Content -Path "C:\MyFile.txt" -Value "This is a new line."
  • Exercises:
    • Create a new folder on your desktop.
    • Create a new text file inside that folder.
    • Write some text to the file using Set-Content.
    • Append more text to the file using Add-Content.
    • Copy the file to a different location.
    • Rename the file.
    • Delete the file and the folder.
  • Further Exploration:

Day 4: Variables and Data Types

  • Concepts:
    • Variables: Storing data for later use.
    • Data Types: Understanding different types of data (strings, integers, booleans, arrays, hashtables, etc.).
    • Variable Scopes: Local, global, script.
  • Commands:
    • $variableName = value: Assign a value to a variable.
    • Get-Variable: List variables.
    • [string], [int], [bool], [array], [hashtable]: Type casting and declaration.
  • Examples:
    • $name = "Alice"
    • $age = 30
    • $isLoggedIn = $true
    • $numbers = 1, 2, 3, 4, 5
    • $person = @{ Name = "Bob"; Age = 40 }
    • $myString = [string]123
  • Exercises:
    • Create variables to store your name, age, and city.
    • Display the values of these variables.
    • Create an array of your favorite colors.
    • Create a hashtable to store information about a book (title, author, year).
    • Concatenate string variables together.
  • Further Exploration:

Day 5: Operators

  • Concepts:
    • Arithmetic Operators: +, -, *, /, % (modulo).
    • Assignment Operators: =, +=, -=, *=, /=, %=.
    • Comparison Operators: -eq, -ne, -gt, -ge, -lt, -le, -like, -notlike, -match, -notmatch.
    • Logical Operators: -and, -or, -xor, -not, !.
    • Redirection Operators: >, >>, 2>, 2>>, *>&1.
  • Examples:
    • $result = 10 + 5
    • $count += 1
    • if ($age -gt 18) { "Adult" } else { "Minor" }
    • if ($name -like "*Smith*") { "Found Smith" }
    • if ($x -gt 10 -and $y -lt 20) { "Within range" }
    • Get-Process > processes.txt
    • Write-Error "This is an error" 2> errors.txt
  • Exercises:
    • Write expressions to calculate the sum, difference, product, and quotient of two numbers.
    • Use comparison operators to compare two strings.
    • Use logical operators to combine multiple conditions.
    • Redirect the output of a command to a file.
    • Redirect error output to a separate file.
  • Further Exploration:

Day 6: Conditional Logic (if, elseif, else)

  • Concepts:
    • Controlling the flow of execution based on conditions.
    • if, elseif, else statements.
    • Test-Path: Check if a file or folder exists.
  • Commands:
    • if (condition) { ... } elseif (condition) { ... } else { ... }
    • Test-Path: Verifies that all elements of the path exist.
  • Examples:
    • powershell
      if ($age -ge 18) {
      Write-Host "You are an adult."
      } else {
      Write-Host "You are a minor."
      }

    • powershell
      if (Test-Path -Path "C:\MyFile.txt") {
      Write-Host "File exists."
      } else {
      Write-Host "File does not exist."
      }
      “`powershell
      $number = 7
      if($number -gt 10){
      Write-Host “Number is greater than 10”
      }
      elseif($number -gt 5){
      Write-Host “Number is greater than 5 but not greater than 10”
      }
      else{
      Write-Host “Number is 5 or less”
      }

      “`
      * Exercises:
      * Write a script that checks if a file exists and displays a message accordingly.
      * Write a script that prompts the user for their age and displays a different message based on whether they are an adult or a minor.
      * Write a script to determine if a number is positive, negative or zero.
      * Write a script that checks if a number is even or odd.
      * Further Exploration:
      * about_If

Day 7: Loops (foreach, for, while, do-while)

  • Concepts:
    • Repeating blocks of code.
    • foreach: Iterate over items in a collection (array, list, etc.).
    • for: Loop based on a counter.
    • while: Loop while a condition is true.
    • do-while: Loop at least once, then continue while a condition is true.
    • break: Exit a loop prematurely.
    • continue: Skip the current iteration and go to the next.
  • Commands:
    • foreach ($item in $collection) { ... }
    • for ($i = 0; $i -lt 10; $i++) { ... }
    • while (condition) { ... }
    • do { ... } while (condition)
  • Examples:
    • powershell
      $colors = "red", "green", "blue"
      foreach ($color in $colors) {
      Write-Host $color
      }
    • powershell
      for ($i = 1; $i -le 5; $i++) {
      Write-Host "Iteration: $i"
      }
    • powershell
      $count = 0
      while ($count -lt 5) {
      Write-Host "Count: $count"
      $count++
      }
      powershell
      $number = 0
      do{
      Write-Host "Number: $number"
      $number++
      }
      while($number -lt 5)
  • Exercises:
    • Write a script to display each item in an array.
    • Write a script to print numbers from 1 to 10 using a for loop.
    • Write a script that prompts the user for input until they enter “quit”.
    • Write a script that counts down from 10 to 1 using a do-while loop.
    • Use break and continue inside loops to modify their behavior.
  • Further Exploration:

Day 8: Functions

  • Concepts:
    • Reusable blocks of code.
    • Defining functions.
    • Passing parameters to functions.
    • Returning values from functions.
    • Parameter validation.
  • Commands:
    • function FunctionName { ... }
    • param(...)

  • Examples:

    • powershell
      function Get-Greeting {
      return "Hello, World!"
      }
      $greeting = Get-Greeting
      Write-Host $greeting

    • “`powershell
      function Add-Numbers {
      param(
      [int]$num1,
      [int]$num2
      )
      return $num1 + $num2
      }

      $sum = Add-Numbers -num1 5 -num2 3
      Write-Host $sum
      powershell
      function Get-FullName{
      param(
      [string]$FirstName,
      [string]$LastName
      )
      return “$FirstName $LastName”
      }

      $fullName = Get-FullName -FirstName “John” -LastName “Doe”
      Write-Host $fullName
      “`

  • Exercises:

    • Create a function that takes two numbers as input and returns their product.
    • Create a function that takes a string as input and returns its length.
    • Create a function that takes a file path as input and returns whether the file exists.
    • Create a function that accepts an array and returns the sum of its elements.
  • Further Exploration:

Day 9: Scripting Basics

  • Concepts:
    • Creating and running PowerShell scripts (.ps1 files).
    • Execution policies (security settings that control script execution).
    • Using comments (#) to document your code.
    • Basic error handling (try-catch).
  • Commands:
    • Set-ExecutionPolicy: Change the execution policy (requires administrator privileges). RemoteSigned is a common setting for development.
    • try { ... } catch { ... }

  • Examples:

    • Create a file named MyScript.ps1 with the following content:
      powershell
      # This is a comment
      Write-Host "Hello from a script!"
      $name = Read-Host "Enter your name"
      Write-Host "Hello, $name!"
    • Run the script from PowerShell: .\MyScript.ps1
    • Example of error handling:
      powershell
      try {
      $result = 10 / 0 # This will cause an error
      }
      catch {
      Write-Host "An error occurred: $($_.Exception.Message)"
      }

  • Exercises:

    • Create a script that performs a series of file operations (create, copy, delete).
    • Create a script that prompts the user for input and performs calculations based on the input.
    • Add error handling to your scripts to gracefully handle potential errors.
    • Modify the script’s execution policy if needed (be cautious and understand the security implications).
  • Further Exploration:

Day 10: Working with Services

  • Concepts:
    • Windows Services: Background processes that provide core operating system functionality.
  • Commands:
    • Get-Service: List services.
    • Start-Service: Start a service.
    • Stop-Service: Stop a service.
    • Restart-Service: Restart a service.
    • Set-Service: Modify a service’s properties (e.g., startup type).
  • Examples:
    • Get-Service | Where-Object {$_.Status -eq 'Running'}
    • Start-Service -Name Spooler
    • Stop-Service -Name Spooler -Force
    • Set-Service -Name "MyService" -StartupType Automatic
  • Exercises:
    • List all services on your computer.
    • Find all services that are currently stopped.
    • Start and stop the Print Spooler service (if it’s safe to do so).
    • Change the startup type of a service (be careful when modifying system services).
  • Further Exploration:

(Days 11-30) Intermediate and Advanced Topics

The remaining days build upon the foundational knowledge gained in the first 10 days. Here’s a breakdown of topics and suggested activities:

Day 11-12: Working with Processes

  • Commands: Get-Process, Start-Process, Stop-Process, Wait-Process, Debug-Process.
  • Concepts: Process management, starting and stopping applications, debugging.
  • Exercises: Start Notepad, find its process ID, stop it using PowerShell. Start a process and wait for it to complete.

Day 13-14: PowerShell Remoting

  • Commands: Enter-PSSession, Invoke-Command, New-PSSession.
  • Concepts: Running commands on remote computers, configuring remoting (requires administrator privileges and careful configuration).
  • Exercises: Connect to a remote computer (if you have access and permissions) and execute commands.

Day 15-16: Modules

  • Commands: Get-Module, Import-Module, Install-Module, Update-Module, Remove-Module.
  • Concepts: Extending PowerShell functionality with modules, finding and installing modules from the PowerShell Gallery.
  • Exercises: Install a module (e.g., Pester for testing), explore its cmdlets, and use them.

Day 17-18: Regular Expressions

  • Commands: -match, -replace, Select-String.
  • Concepts: Pattern matching with regular expressions, extracting data from text.
  • Exercises: Use regular expressions to find specific patterns in text files, extract email addresses or phone numbers.

Day 19-20: Error Handling (Advanced)

  • Commands: try-catch-finally, $Error, Write-Error, throw.
  • Concepts: Advanced error handling techniques, trapping errors, logging errors.
  • Exercises: Write scripts that handle different types of errors gracefully, log errors to a file.

Day 21-22: Working with Dates and Times

  • Commands: Get-Date, [datetime].
  • Concepts: Formatting dates and times, calculating time spans.
  • Exercises: Get the current date and time, format it in different ways, calculate the difference between two dates.

Day 23-24: Working with the Registry

  • Commands: Cmdlets within the Microsoft.Win32.Registry namespace, Get-ItemProperty, Set-ItemProperty, New-Item, Remove-Item.
  • Concepts: Accessing and modifying the Windows Registry (use with extreme caution!).
  • Exercises: Read registry values, create new registry keys and values (in a test environment).

Day 25-26: WMI/CIM (Windows Management Instrumentation/Common Information Model)

  • Commands: Get-CimInstance, Invoke-CimMethod, Get-WmiObject (deprecated, but still useful for older systems).
  • Concepts: Querying system information and managing Windows components.
  • Exercises: Get information about the operating system, disks, network adapters, etc.

Day 27-28: Creating Custom Objects

  • Commands: New-Object, [PSCustomObject].
  • Concepts: Creating custom objects to represent data in a structured way.
  • Exercises: Create custom objects to represent employees, products, or other entities.

Day 29: Script Reusability and Best Practices

  • Concepts: Writing modular scripts, using functions and modules, commenting code, following naming conventions.
  • Exercises: Refactor existing scripts to improve their structure and reusability. Write a script that uses functions from a separate module.

Day 30: Putting It All Together – Project Day

  • Project: Choose a real-world task that you can automate with PowerShell. This could be anything from managing files and folders to monitoring system resources or configuring network settings.
  • Goal: Apply all the concepts and skills you’ve learned to create a complete and functional PowerShell script.

Example Project Ideas:

  • Log File Parser: A script that reads a log file, extracts specific information (e.g., errors), and generates a report.
  • User Account Management: A script to create, modify, or delete user accounts (requires administrator privileges).
  • Disk Space Monitor: A script that monitors disk space usage and sends an email alert if a threshold is reached.
  • Software Installer: A script that automates the installation of software packages.
  • Website Status Checker: A script that periodically checks if a website is up and running.

Key Takeaways and Next Steps

By the end of these 30 days, you should have a solid understanding of PowerShell basics and be able to:

  • Use the PowerShell console effectively.
  • Navigate the file system and manipulate files and folders.
  • Work with variables, data types, and operators.
  • Use conditional logic and loops to control script flow.
  • Create and use functions.
  • Write basic PowerShell scripts.
  • Manage services and processes.
  • Understand the basics of PowerShell remoting.
  • Work with modules and extend PowerShell.
  • Handle errors gracefully.
  • Begin to explore more advanced concepts.

Next Steps:

  • Practice Regularly: The key to mastering PowerShell is consistent practice. Try to use it for everyday tasks whenever possible.
  • Explore Advanced Topics: Dive deeper into topics like PowerShell remoting, WMI/CIM, DSC (Desired State Configuration), and scripting with the .NET framework.
  • Read the Documentation: The official Microsoft PowerShell documentation is an invaluable resource.
  • Join the Community: Connect with other PowerShell users online (forums, communities, social media) to learn from their experiences and share your knowledge.
  • Consider Certification: Microsoft offers certifications for PowerShell, which can demonstrate your skills to potential employers.
  • PowerShell Gallery: Look for pre-built solutions to common challenges.

This 30-day plan provides a strong foundation for your PowerShell journey. Remember that learning is a continuous process, and with dedication and practice, you can become proficient in this powerful tool. Good luck!

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top