Scripting Basics: Batch, PowerShell, Bash

Scripting is the process of writing a series of commands in a file (a script) that can be executed by a command interpreter without manual intervention. On the 220-1102 exam, you must be familiar with three primary scripting environments: Batch (Windows command-line scripts), PowerShell (advanced Windows automation), and Bash (Linux/macOS command-line scripts). Each has its own syntax, strengths, and typical use cases. Scripts are used to automate repetitive tasks, deploy software, configure systems, gather information, and perform maintenance. The exam focuses on recognizing correct syntax, understanding control structures, and identifying appropriate scripting languages for given scenarios.

Batch scripts are plain text files with a .bat or .cmd extension that contain commands for the Windows Command Prompt (cmd.exe). They are the oldest form of Windows scripting and are still widely used for simple automation.

#### Syntax and Commands

- @echo off – Hides the command itself from output. - echo – Outputs text to the console. - set – Defines or displays environment variables. Syntax: set variable=value (no spaces around =). - if – Conditional execution. Common forms: - if exist filename (command) - if %variable%==value (command) - for – Looping. Syntax: for %%variable in (set) do (command). Note the double percent sign in scripts. - goto – Jumps to a label. Labels are defined with a colon, e.g., :label. - call – Calls another batch file. - exit /b – Exits the script and returns control. - rem – Comment.

#### Example Batch Script

@echo off
set source=C:\Data
set dest=D:\Backup
if not exist %dest% mkdir %dest%
for %%f in (%source%\*.txt) do (
    copy %%f %dest%
    echo Copied %%f
)
echo Backup complete.

This script copies all .txt files from C:\Data to D:\Backup, creating the destination folder if needed.

#### Common Exam Traps - Forgetting @echo off leads to messy output. - Using single % in a script (only valid at command line). - Spaces around = in set command cause errors. - Using if %var%==value without quotes can break if variable is empty.

PowerShell is a task automation and configuration management framework from Microsoft, consisting of a command-line shell and scripting language built on .NET. PowerShell scripts use .ps1 extension. PowerShell introduces the concept of cmdlets (pronounced command-lets), which are lightweight commands that return objects, not text.

#### Key Concepts

- Cmdlets: Verb-Noun pairs, e.g., Get-ChildItem, Set-ExecutionPolicy. - Pipelines: Pass objects between cmdlets using |. Example: Get-Process | Where-Object { $_.CPU -gt 100 }. - Variables: Prefixed with $, e.g., $name = "Alice". - Execution Policy: Controls script execution. Default is Restricted on desktop editions. Use Set-ExecutionPolicy RemoteSigned to run local scripts. - Common Cmdlets for A+: - Get-ChildItem – Lists files and folders (alias dir, ls). - Set-Location – Changes directory (alias cd). - Get-Content – Reads file content (alias cat, type). - Copy-Item – Copies files/folders. - Remove-Item – Deletes files/folders. - New-Item – Creates new items. - Get-Process – Lists running processes. - Get-Service – Lists services. - Write-Host – Outputs to console. - Write-Output – Sends output to pipeline.

#### Example PowerShell Script

$source = "C:\Data"
$dest = "D:\Backup"
if (-not (Test-Path $dest)) {
    New-Item -ItemType Directory -Path $dest
}
Get-ChildItem -Path $source -Filter *.txt | Copy-Item -Destination $dest
Write-Host "Backup complete."

This script achieves the same as the Batch example but uses objects and cmdlets.

#### Common Exam Traps - Confusing Write-Host (directly to console, bypasses pipeline) with Write-Output (sends to pipeline). - Forgetting to change execution policy before running scripts. - Using -eq for comparison instead of =. - Assuming PowerShell is case-sensitive (it is not, but best practice to use PascalCase).

Bash (Bourne Again SHell) is the default shell on Linux and macOS. Bash scripts have no extension required but often use .sh. They are text files with a shebang line (#!/bin/bash) at the top.

#### Key Concepts

- Shebang: #!/bin/bash tells the system which interpreter to use. - Variables: name="Alice" (no spaces around =). Access with $name. - Conditionals: - if [ condition ]; then ... fi - [ -f file ] checks if file exists. - [ $a -eq $b ] numeric comparison. - [ $a = $b ] string comparison. - Loops: - for var in list; do ... done - while [ condition ]; do ... done - Command substitution: $(command) or backticks. - Pipes: | passes stdout from one command to stdin of next. - Common commands: ls, cp, mv, rm, grep, awk, sed, chmod, chown.

#### Example Bash Script

#!/bin/bash
source="/home/user/Data"
dest="/mnt/backup"
mkdir -p "$dest"
for file in "$source"/*.txt; do
    cp "$file" "$dest"
    echo "Copied $file"
done
echo "Backup complete."

#### Common Exam Traps - Forgetting the shebang line – script may run with wrong shell. - Spaces around = in variable assignment. - Using if [ $var == "value" ] – == is not POSIX; use = for string comparison. - Not quoting variables – causes word splitting and globbing issues.

| Feature | Batch | PowerShell | Bash | |---------|-------|------------|------| | Platform | Windows | Windows | Linux/macOS | | Extension | .bat/.cmd | .ps1 | .sh (or none) | | Object-based? | No (text) | Yes (.NET objects) | No (text) | | Execution policy | None | Required | None | | Common use | Simple tasks | System administration | System administration | | Loop syntax | for %%i in (set) do | foreach ($i in $set) | for i in list; do | | Variable prefix | %var% | $var | $var |

#### Variables and Environment Variables - Batch: set var=value, access with %var%. Environment variables like %PATH%, %USERNAME%. - PowerShell: $var = "value". Environment variables via $env:VAR. - Bash: var="value", access with $var. Environment variables like $HOME, $PATH.

#### Conditional Statements - Batch:

if exist file.txt (
      echo Found
  ) else (
      echo Not found
  )

- PowerShell:

if (Test-Path file.txt) {
      Write-Host "Found"
  } else {
      Write-Host "Not found"
  }

- Bash:

if [ -f file.txt ]; then
      echo "Found"
  else
      echo "Not found"
  fi

#### Loops - Batch:

for %%f in (*.txt) do (
      echo %%f
  )

- PowerShell:

foreach ($file in Get-ChildItem *.txt) {
      Write-Host $file.Name
  }

- Bash:

for file in *.txt; do
      echo "$file"
  done

#### Comments - Batch: rem comment or :: comment (though :: can cause issues in certain contexts). - PowerShell: # comment. - Bash: # comment.

#### Input and Output - Batch: echo text, set /p var=prompt for input. - PowerShell: Read-Host "prompt" for input, Write-Host/Write-Output for output. - Bash: read -p "prompt" var for input, echo for output.

In a medium-sized enterprise IT department, scripting is used daily to automate routine tasks. For example, a Windows administrator might use a PowerShell script to deploy software updates to 200 workstations. The script would use Invoke-Command to run commands remotely via WinRM, checking each machine's OS version and installing the appropriate patch. The script includes error handling to log failures and retry logic. A common issue is WinRM not being enabled on target machines, causing the script to fail. The administrator must ensure that the execution policy is set to RemoteSigned on the management workstation and that the script is signed or run with appropriate privileges.

Another scenario: a Linux system administrator writes a Bash script to monitor disk usage across 50 servers. The script uses ssh to connect to each server, runs df -h, greps for partitions over 80% usage, and sends an email alert. The script is scheduled via cron to run daily. Challenges include SSH key management, handling server unavailability, and parsing df output correctly. The script must be robust against variations in output format across different Unix flavors.

A third scenario involves a help desk technician who needs to reset user passwords and unlock accounts in Active Directory. Instead of using the GUI for each user, they create a PowerShell script that takes a CSV list of usernames and uses Set-ADAccountPassword and Unlock-ADAccount cmdlets. The script includes logging and confirmation prompts. A common pitfall is insufficient privileges—the script must run with domain admin credentials. The technician might use RunAs or store credentials securely.

In all these cases, scripting reduces human error, saves time, and ensures consistency. Misconfigurations can lead to security vulnerabilities (e.g., scripts with hardcoded passwords) or unintended changes (e.g., deleting wrong files due to incorrect paths). Best practices include testing in a lab, using version control, and implementing proper error handling.