Microsoft’s PowerShell is no longer an arcane tool for sysadmins alone — it’s the modern command-line and automation engine that replaces many Command Prompt habits while offering far richer control, scripting and safety nets for everyday Windows users. The Tom’s Hardware primer the user supplied walks readers through the ten basic PowerShell cmdlets that will get you started — from help and discovery (Get-Help, Get-Command) to file and process management (Get-ChildItem, Copy-Item, Move-Item, Remove-Item) and simple network checks (Test-Connection). That primer is a solid, user-friendly launch point for newcomers and makes practical comparisons to legacy DOS-style commands so long-time Windows hands can get comfortable quickly.
Background / Overview
PowerShell is a command-line shell
and a scripting language built on .NET that treats pipeline output as rich objects rather than plain text. That design change is the single biggest reason PowerShell feels more powerful and flexible than the old Command Prompt: instead of parsing text, you pipe objects and manipulate properties directly. For example,
Get-ChildItem returns file objects with properties such as Name, Length and LastWriteTime, so you can filter, sort and export without brittle text parsing. This object-oriented model is core to PowerShell’s workflow and is documented in Microsoft’s learning resources. At the same time, PowerShell preserves familiarity by providing aliases for classic commands —
dir,
ls, and
copy still work, but behind the scenes they map to cmdlets such as
Get-ChildItem and
Copy-Item. That makes the transition easier while nudging users toward the more robust cmdlet equivalents. The Tom’s Hardware guide emphasizes those parallels and lists ten commands every Windows user should know to begin automating routine tasks.
The ten commands (what Tom’s Hardware covered — verified and expanded)
Below is a practical, verified rundown of the ten essentials, expanded with notes on gotchas, permissions and real-world usage.
1. Get-Help — your built-in manual
- What it does:
Get-Help <CmdletName> shows help text for a cmdlet; -Full, -Detailed, -Examples refine output.
- Why it matters: PowerShell’s help system is robust and designed to be updated. Use
Update-Help to download the latest local help content; without updated help you will see the auto-generated minimal help. Microsoft documents how Get-Help and Update-Help work and why you should run Update-Help occasionally (it requires admin rights to update system modules and a working internet connection to download help packages).
Important caveats:
Update-Help may fail on some older or third‑party modules that simply don’t publish updateable help. If you see errors, they’re often module-specific and not necessarily a system problem.
2. Get-Command — discover what’s available
- What it does:
Get-Command lists all commands (cmdlets, functions, aliases, scripts, applications) available in your session. Use -Type or -Module to filter results.
- Practical tip: If a module isn’t imported,
Get-Command can still discover and auto-import certain cmdlets when invoked. Use Get-Command -Name <Name> to inspect origin and syntax.
3. Get-Service / Start-Service / Stop-Service — list and control Windows services
- What they do:
Get-Service shows service status; Stop-Service and Start-Service control services.
- When to use: Troubleshooting hung background services, restarting update/print services, or controlling service state during maintenance.
- Safety notes: Changing service state typically requires elevated privileges and may impact dependent services or system behavior; always verify dependencies first. Major Windows documentation and community guidance demonstrate using these cmdlets for service management.
4. Get-Process / Stop-Process — inspect and terminate processes
- What they do:
Get-Process lists running processes; Stop-Process kills one or more processes by name or PID.
- Practical example:
Get-Process chrome | Sort-Object CPU -Descending | Select-Object -First 5 helps find CPU hogs. To kill: Stop-Process -Id <PID> -Force.
- Important caution: Using
-Force or killing system-critical processes can crash the system or corrupt data. Run PowerShell elevated if you must stop processes owned by other users; expect access-denied errors otherwise. Microsoft’s process-management guidance explains these constraints and demonstrates patterns to perform safe operations.
5. Get-ChildItem (dir / ls / gci) — list files and directories
- What it does:
Get-ChildItem lists items in a location across providers (filesystem, registry, certificate store). Aliases include dir and ls.
- Why it’s better than
dir: it returns objects you can filter, pipe and export. Use parameters like -Recurse, -File, -Directory, -Filter, -Exclude and -Depth for fine-grained control.
- Real-world uses: directory size reports, ACL audits and scripted backups. SS64 and numerous PowerShell tutorials offer exhaustive parameter examples and explain provider behavior.
6. Copy-Item — copy files and folders
- What it does:
Copy-Item -Path <source> -Destination <dest> copies files or entire folder trees when combined with -Recurse.
- Differences from legacy
copy: Copy-Item is the cmdlet-native way and supports provider semantics (it can work with registry keys under the right provider). Classic copy remains an alias for backward compatibility but is less consistent in scripts.
- Performance and edge cases: In some environments and with complex providers (network share, WebDAV),
Copy-Item -Recurse can exhibit bugs or behavior differences; for bulk/robust file replication, tools such as robocopy are often recommended. Microsoft’s cmdlet documentation and community threads document syntax, parameters and occasional edge-case reports.
7. Move-Item — move or rename
- What it does:
Move-Item moves files or directories; supplying a destination filename renames the item in one step.
- Use case: Reorganizing folders, atomic rename-and-move operations in scripts.
- Note: When moving across volumes, Move-Item performs a copy-then-delete under the hood; ensure adequate permissions and disk space.
8. Remove-Item — delete files, folders, registry keys
- What it does:
Remove-Item deletes items. Use -Recurse to delete directories and -Force to bypass read-only attributes.
- Dangerous by design:
Remove-Item is permanently destructive; scripts should include -Confirm or safe-check logic (e.g., -WhatIf and -Confirm) to avoid catastrophes.
- Best practices:
- Test with
-WhatIf before destructive runs.
- Use
Test-Path and size checks before wholesale removal.
- Avoid running destructive commands as SYSTEM or in broad loops without extra validation.
9. Get-Content / Set-Content / Add-Content — read and write file content
- What they do:
Get-Content reads file contents to the pipeline (like cat).Set-Content writes or replaces content (overwrites).Add-Content appends to a file.- When to use: quick log inspection, script-driven config edits, and pipe-based transformations.
- Encoding caveats: PowerShell’s default encodings differ between Windows PowerShell (UTF-16 LE historically) and PowerShell Core (UTF-8 by default in newer versions). When working with existing files, explicitly set
-Encoding to avoid accidental mangling. Community reports and Microsoft docs highlight encoding mismatches as a common gotcha.
10. Test-Connection — ping from PowerShell
- What it does:
Test-Connection is PowerShell’s version of ping, sending ICMP echo requests and returning objects that include ResponseTime and status.
- Advantages over raw
ping: returns objects, integrates with Test-NetConnection for richer TCP/port checks, and is easily used programmatically to check multiple hosts. Microsoft’s documentation explains parameters and recommended patterns.
How the Tom’s Hardware primer stacks up (strengths)
- Practical, low-friction approach: The guide shows direct comparisons between legacy CMD commands and the PowerShell equivalents, which is an effective teaching technique for users migrating from Command Prompt to PowerShell. The examples are short, achievable and focused on day-to-day tasks.
- Emphasis on the “get/set” mindset: Showing
Get- and Set- flows (for example, Get-Content and Set-Content) helps readers think in terms of pipeline transformations rather than single-line text outputs.
- Good ergonomics for beginners: Short commands and aliases make immediate use comfortable; the primer doesn’t bury newcomers in advanced pipeline constructs on the first pass.
Risks, limitations and important caveats (what the primer underplays)
- Destructive power: The primer mentions deletion and stopping services/processes but doesn’t always emphasize how destructive
Remove-Item -Recurse -Force and Stop-Process -Force can be when run incorrectly or as SYSTEM. Scripts that delete files or stop services should include confirmation prompts, logging, and rollback plans for production systems.
- Encoding and cross-version behavior: Commands like
Set-Content and Get-Content behave differently across Windows PowerShell 5.1 and PowerShell 7.x families because default encodings changed. This can silently break scripts that process text files — a subtle cross-version pitfall. Always specify -Encoding when scripts will run across environments.
- Provider differences:
Get-ChildItem works across many providers (filesystem, registry, certificate store). Some parameters and wildcard semantics behave differently by provider; assuming filesystem semantics for registry paths can lead to unexpected results. SS64 and Microsoft docs provide provider-specific notes and examples.
- Update-Help network and permission needs: Young users running
Get-Help may be surprised by terse output; the fully featured help requires Update-Help, which requires admin elevation and internet access to Microsoft’s help repository. The primer notes Update-Help but users should be warned to run it with elevated privileges and to expect module-specific failures on older modules.
- Copy-Item and large-scale file transfer reliability: For bulk file moves or large recursive copies,
Copy-Item -Recurse can be slow or encounter provider-specific issues; robust file migration often leans on specialized tools (e.g., robocopy) for performance and error recovery. Real-world forum threads and Microsoft community posts document edge cases and show when an alternative is preferable.
Practical safety checklist: triage before you run a cmdlet
- Confirm the target:
- Use
Test-Path or Get-ChildItem -WhatIf/-Filter to preview.
- Dry-run destructive actions:
- Use
-WhatIf and -Confirm where available.
- Check permissions:
- Run
Get-ExecutionPolicy and ensure scripts call out elevation needs; use an elevated shell for system actions.
- Lock down encoding:
- When reading/writing files across systems, set
-Encoding explicitly in Get-Content/Set-Content.
- Log everything:
- Append action notes to a timestamped log with
Add-Content so you can audit what ran.
These steps reduce the human error factor that turns useful cmdlets into disaster vectors.
Examples and idioms for everyday admins
Quick process kill (safe-ish)
- Identify top CPU consumers:
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10- Target a single PID:
Stop-Process -Id 12345 -Confirm (omit -Confirm only after you’re certain)
Directory audit and export
- Export ACLs to CSV for review:
Get-ChildItem 'N:\Data' -Recurse | Get-Acl | Select-Object @{n='Path';e={$_.PSPath}},AccessToString | Export-Csv C:\temp\acls.csv -NoTypeInformation
Script-friendly ping sweep
- Test reachability programmatically:
1..254 | ForEach-Object { Test-Connection -ComputerName "192.168.1.$_" -Count 1 -Quiet }
Each of these idioms uses PowerShell’s object-rich pipeline to produce predictable, scriptable results.
Cross-checks and verification (what I validated)
- The behavior and usage of
Get-Help / Update-Help was verified against Microsoft Learn’s PowerShell training material and PowerShell Team blog posts explaining updateable help mechanics. These confirm the need for admin rights and Microsoft's automated help publishing pipeline.
- Core cmdlets (
Get-Command, Get-ChildItem, Copy-Item, Move-Item, Remove-Item, Get-Content, Set-Content, Add-Content, Get-Process, Stop-Process, Test-Connection) were cross-referenced with official Microsoft documentation pages and authoritative references such as SS64, PDQ and Microsoft’s cmdlet references to ensure syntax and common parameters are accurately described.
- Known real-world caveats (encoding, provider differences, Copy-Item scale issues) were corroborated with community reports and vendor documentation where those behaviors are discussed. When a behavior appears environment-specific or flaky (for example,
Copy-Item edge cases with WebDAV or network shares), that claim is flagged as an area requiring testing and fallback tools.
If any claim in your environment looks different from the examples above, it’s worth checking the PowerShell version (
$PSVersionTable.PSVersion), module versions and whether you’re running Windows PowerShell 5.1 or PowerShell 7.x — behavior and defaults (especially encoding) can differ across those lines.
Recommended next steps for readers
- Adopt a safe learning loop:
- Open PowerShell as a normal user and practice discovery:
Get-Command, Get-Help Get-ChildItem -Examples.
- Try non-destructive queries:
Get-ChildItem -Path C:\Windows -Filter *.log -Recurse -WhatIf.
- When confident, practice admin tasks in a VM or lab before running them on production hardware.
- Build a personal cheatsheet of aliases you use regularly, but prefer script-safe cmdlet names in production scripts.
- Start small automation projects: a scheduled log-rotation script, a user-provisioning sample with dry-run/confirm steps, or a simple backup routine that logs actions so you can rehearse and refine.
Conclusion
The Tom’s Hardware “top ten” primer is an excellent practical entry point: it’s clear, approachable and gets readers from nostalgia-driven DOS aliases to modern PowerShell usage quickly. The guide’s examples map well to everyday Windows tasks and the included cmdlets form a solid foundation for automation. That said, PowerShell’s power brings responsibility: encoding differences, provider semantics and destructive cmdlet options make careful testing and explicit safety checks essential. Use
Get-Help and
Get-Command to learn interactively, rely on
-WhatIf/
-Confirm for destructive operations, and favor explicit encodings and logging in scripts that run across multiple machines.
For Windows enthusiasts and admins, mastering these ten cmdlets opens the door to predictable, automatable workflows — but always test, log and add safety checks before running anything that could affect production systems.
Source: Tom's Hardware
https://www.tomshardware.com/softwa...ommands-in-windows-that-will-get-you-started/