DEV Community: arnostorg

PowerShell Clear-Content: Empty Files Without Deleting Them

arnostorg — Mon, 28 Sep 2026 07:21:50 +0000

The PowerShell Clear-Content cmdlet empties a file’s contents but keeps the file itself. The path stays; the bytes go. That is the opposite of deleting the file, and different from rewriting it with new text.

For the official reference, see Microsoft Learn’s Clear-Content.

Want to practice PowerShell in a live browser terminal (no install)? Try the free interactive lessons on CMD Master — PowerShell file management. CMD Master is a free online interactive learning platform for the command line: practice CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no VM or local setup. Most lessons are free; premium unlocks deeper paths.

Empty one file

Clear-Content -Path .\log.txt

After this runs, log.txt still exists (same name, same folder), but Get-Content .\log.txt returns nothing. Size goes to zero (or near-zero, depending on filesystem metadata).

The short alias works the same way:

clc .\log.txt

Clear several logs with wildcards

Target a pattern when you want to reset a batch of files without removing them:

Clear-Content -Path .\logs\*.log

Or pipe specific items:

Get-ChildItem .\logs\*.log |
  Where-Object { $_.Length -gt 1MB } |
  Clear-Content

That pattern is useful when old log files must keep their names for an app that reopens the same path every boot.

Preview with -WhatIf and -Confirm

Before wiping production-sized logs, dry-run:

Clear-Content -Path .\logs\*.log -WhatIf

PowerShell prints what it would clear and touches nothing. For an interactive check:

Clear-Content -Path .\app.cache -Confirm

You get a yes/no prompt per target. Use these flags until the path filter looks right.

Clear-Content vs Remove-Item vs Set-Content

Keep the three mental models straight:

# Empty the file, keep the path
Clear-Content -Path .\scratch.txt

# Delete the file entirely
Remove-Item -Path .\scratch.txt

# Replace contents with a new value (here: an empty string)
Set-Content -Path .\scratch.txt -Value ""

Goal	Cmdlet
Empty file, keep path	`Clear-Content`
Delete the file	`Remove-Item`
Write / overwrite text	`Set-Content`
Append text	`Add-Content`
Read text	`Get-Content`

Set-Content "" can look similar to clearing, but it is still a write of new content (and may change encoding). Prefer Clear-Content when your intent is “make this file empty.”

Realistic example: rotate a log without breaking the path

Many services expect C:\Apps\MyService\app.log to exist. Deleting it can break the next write. Emptying it keeps the contract:

$log = "C:\Apps\MyService\app.log"
$archive = "C:\Apps\MyService\archive\app-$(Get-Date -Format 'yyyyMMdd-HHmmss').log"

# Keep a copy of today’s noise, then empty the live file
if (Test-Path $log) {
  New-Item -ItemType Directory -Path (Split-Path $archive) -Force | Out-Null
  Copy-Item -Path $log -Destination $archive
  Clear-Content -Path $log -WhatIf   # remove -WhatIf when ready
  Clear-Content -Path $log
}

Same idea for temp scratch files your script reuses every run: clear once at start instead of deleting and recreating.

Quick checklist

Need an empty file that still exists → Clear-Content
Need the file gone → Remove-Item
Need brand-new text → Set-Content
Unsure which paths match → add -WhatIf first

Practice it live

CMD Master is a free online interactive learning platform for the command line. Practice PowerShell file commands in a live browser terminal with instant feedback — no install or VM. Start at CMD Master PowerShell lessons; most lessons are free, with premium for deeper paths.

PowerShell Add-Content: Append Text to Files Fast

arnostorg — Fri, 25 Sep 2026 07:25:36 +0000

The PowerShell Add-Content cmdlet appends text to a file. Use it when you want to keep existing lines and add more — the opposite of Set-Content, which replaces the whole file.

For the official reference, see Microsoft Learn’s Add-Content.

Want to practice PowerShell in a live browser terminal (no install)? Try the free interactive lessons on CMD Master — PowerShell file and text commands.

Append a line

Add-Content -Path .\log.txt -Value "Started at $(Get-Date -Format o)"

If log.txt does not exist yet, PowerShell creates it. If it already has lines, your new value is written after them.

Append several lines

Pass multiple strings and each becomes its own line:

Add-Content -Path .\notes.txt -Value "Todo: backup", "Todo: test deploy", "Todo: ping ops"

Or build an array first:

$entries = @(
  "Build finished",
  "Tests passed",
  "Artifact uploaded"
)
Add-Content -Path .\build.log -Value $entries

Append vs replace

Remember the pair:

# wipe and rewrite the file
Set-Content -Path .\status.txt -Value "Fresh start"

# keep existing lines, add more
Add-Content -Path .\status.txt -Value "Still running"

Set-Content means “make the file equal this.” Add-Content means “append.” Mixing them up is how logs get accidentally wiped.

Pipe output into a growing file

Any string pipeline works:

Get-ChildItem -Name *.log | Add-Content -Path .\inventory.txt
"Heartbeat $(Get-Date -Format 'HH:mm:ss')" | Add-Content -Path .\health.log

That pattern is ideal for inventories, heartbeat files, and append-only audit trails.

Encoding when tools care

Be explicit when other tools expect UTF-8:

Add-Content -Path .\events.jsonl -Value '{"ok":true}' -Encoding utf8

Use -Encoding utf8 (or utf8BOM / unicode when a consumer needs those) so appended bytes match the rest of the file.

Create the folder first if needed

Add-Content writes the file. Create a missing parent folder before the first append:

New-Item -ItemType Directory -Path .\logs -Force | Out-Null
Add-Content -Path .\logs\app.log -Value "Boot"

Safe append habit

For important files, confirm the path before you grow it in a loop:

$path = ".\prod-notes.txt"
if (-not (Test-Path $path)) {
  Set-Content -Path $path -Value "# Prod notes" -Encoding utf8
}
Add-Content -Path $path -Value "$(Get-Date -Format o) — deploy ok"

That keeps the first write intentional and every later write additive.

Quick checklist

Goal	Cmdlet
Append lines	`Add-Content`
Replace / create file text	`Set-Content`
Read file text	`Get-Content`
Copy the file itself	`Copy-Item`

Practice it live

CMD Master is a free online interactive learning platform for the command line: practice in a live browser terminal with instant feedback, no install or VM. It covers Windows CMD, PowerShell, and Bash.

Start here: CMD Master — interactive PowerShell practice.

PowerShell Set-Content: Write Text to Files Fast

arnostorg — Wed, 23 Sep 2026 07:38:00 +0000

The PowerShell Set-Content cmdlet writes text into a file. It is the clear, readable way to create a new file or replace what is already there — cleaner than juggling > redirects when you want intentional writes in scripts.

For the official reference, see Microsoft Learn’s Set-Content.

Want to practice PowerShell in a live browser terminal (no install)? Try the free interactive lessons on CMD Master — PowerShell file and text commands.

Write a simple file

Set-Content -Path .\hello.txt -Value "Hello from PowerShell"

That creates hello.txt (or fully replaces it if it already exists) with one line of text. Multiple strings become multiple lines:

Set-Content -Path .\notes.txt -Value "Line one", "Line two", "Line three"

Replace vs append

Set-Content replaces the whole file. If you need to add lines without wiping what is there, use Add-Content instead:

# wipe and rewrite
Set-Content -Path .\log.txt -Value "Fresh start"

# keep existing lines, add more
Add-Content -Path .\log.txt -Value "Another entry"

Remembering that split saves a lot of accidental data loss: Set-Content means “make the file equal this”; Add-Content means “append.”

Write output from other commands

Pipe any string output into Set-Content:

Get-ChildItem -Name *.ps1 | Set-Content -Path .\scripts-list.txt
Get-Date -Format "yyyy-MM-dd HH:mm" | Set-Content -Path .\last-run.txt

That is handy for snapshots, inventories, and small status files your scripts leave behind.

Encoding matters

On Windows, default encoding can surprise you when tools expect UTF-8. Be explicit when you care:

Set-Content -Path .\config.json -Value '{"env":"dev"}' -Encoding utf8

Use -Encoding utf8 (or utf8BOM / unicode when a consumer needs those) so cross-tool files stay readable.

Create folders first when needed

Set-Content writes the file. If the parent folder is missing, create it first:

New-Item -ItemType Directory -Path .\out -Force | Out-Null
Set-Content -Path .\out\readme.txt -Value "Build artifacts go here"

Safe overwrite pattern

When a file already holds something important, back it up, then rewrite:

if (Test-Path .\app.config) {
  Copy-Item .\app.config .\app.config.bak -Force
}
Set-Content -Path .\app.config -Value $newConfig -Encoding utf8

That habit pairs well with Copy-Item and keeps experiments reversible.

Quick checklist

Goal	Cmdlet
Replace / create file text	`Set-Content`
Append lines	`Add-Content`
Read file text	`Get-Content`
Copy the file itself	`Copy-Item`

Practice it live

Start here: CMD Master — interactive PowerShell practice.

PowerShell Copy-Item: Duplicate Files Fast and Safely

arnostorg — Mon, 21 Sep 2026 07:31:47 +0000

The PowerShell Copy-Item cmdlet duplicates files and folders — the modern replacement for classic CMD copy and xcopy. When you need a backup of a config, to stage assets into a deploy folder, or to clone a directory tree with filters, Copy-Item is clearer and safer than typing long xcopy switches.

For the official reference, see Microsoft Learn’s Copy-Item.

Want to practice PowerShell in a live browser terminal (no install)? Try the free interactive lessons on CMD Master — PowerShell and command-line training.

What does Copy-Item do?

Copy-Item -Path .\report.txt -Destination .\backup\

That copies report.txt into the backup folder. If the destination is a folder that already exists, the file keeps its name. If the destination includes a new file name, PowerShell renames on copy:

Copy-Item -Path .\report.txt -Destination .\backup\report-2026-09-21.txt

Copy one file or many

Point -Path at a single file, a wildcard, or several paths:

Copy-Item -Path .\notes.txt -Destination .\archive\
Copy-Item -Path .\*.log -Destination .\logs-backup\
Copy-Item -Path .\a.txt,.\b.txt -Destination .\out\

Create the destination folder first when it might not exist:

New-Item -ItemType Directory -Path .\backup -Force
Copy-Item -Path .\*.csv -Destination .\backup\

Copy folders: -Recurse

To copy a directory and everything inside it, add -Recurse:

Copy-Item -Path .\project -Destination .\project-backup -Recurse

Without -Recurse, PowerShell can create an empty destination folder (or fail, depending on version and path shape) — always use -Recurse when you mean “copy the tree.”

Overwrite existing files: -Force

By default, Copy-Item may refuse to overwrite a read-only or existing file. Use -Force when you intentionally want to replace:

Copy-Item -Path .\app.config -Destination .\deploy\app.config -Force

Be deliberate: -Force skips the “are you sure?” friction. Prefer an explicit backup first when the destination is production config.

Filter while you copy

Combine wildcards with -Include / -Exclude (often clearest when you pipe from Get-ChildItem):

# copy only .ps1 scripts from a tree
Get-ChildItem -Path .\src -Filter *.ps1 -Recurse |
  Copy-Item -Destination .\scripts-backup\ -Force

Or exclude junk folders by filtering upstream:

Get-ChildItem -Path .\app -Recurse -File |
  Where-Object { $_.FullName -notmatch '\\node_modules\\|\\.git\\' } |
  Copy-Item -Destination {
    Join-Path .\clean-copy ($_.FullName.Substring((Resolve-Path .\app).Path.Length + 1))
  } -Force

For day-to-day work, a simple wildcard plus -Recurse is usually enough:

Copy-Item -Path .\docs\*.md -Destination .\site\content\ -Force

Keep the original timestamps (when you care)

Copy-Item updates the new file’s timestamps to “now.” If you need a byte-for-byte archival copy that preserves metadata, reach for robocopy or a dedicated sync tool. For scripts and deploy staging, the default timestamps are fine.

Copy-Item vs copy vs xcopy vs robocopy

Tool	Best for
`Copy-Item`	PowerShell scripts, pipelines, clear Verb-Noun readability
`copy`	Tiny one-file CMD jobs
`xcopy`	Older batch trees with `/E` / `/I` habits
`robocopy`	Large mirrors, retries, multi-thread, detailed logs

Prefer Copy-Item when you are already in PowerShell. Prefer robocopy for huge folder mirrors or scheduled backups.

Safe habits

Confirm the destination exists (Test-Path / New-Item -Force) before a bulk copy.
Use -WhatIf to preview:

Copy-Item -Path .\*.log -Destination .\archive\ -WhatIf

Prefer -Recurse for folders — never assume an empty folder copy did what you wanted.
Use -Force only when overwrite is intentional; backup first for critical files.
Avoid copying node_modules, .git, or build caches unless you truly need them.

Practice it live

Open a free PowerShell lesson on CMD Master’s interactive CLI platform and try Copy-Item in a real terminal in your browser — no VM, no install.

Quick cheat sheet

Copy-Item -Path .\file.txt -Destination .\backup\
Copy-Item -Path .\file.txt -Destination .\backup\renamed.txt
Copy-Item -Path .\folder -Destination .\folder-copy -Recurse
Copy-Item -Path .\*.log -Destination .\logs\ -Force
Copy-Item -Path .\src\*.ps1 -Destination .\out\ -WhatIf

Once this clicks, pair it with Get-ChildItem for discovery and Remove-Item when you clean up after a copy. That trio covers most day-to-day file moves on Windows.

PowerShell Select-String: Find Text in Files Fast

arnostorg — Fri, 18 Sep 2026 07:32:45 +0000

The PowerShell Select-String cmdlet finds text inside files — the same job grep does on Linux/macOS and findstr does in classic CMD. When you are hunting for an error code in logs, checking whether a config key exists, or scanning a repo for a TODO, it is faster than opening every file by hand.

For the official reference, see Microsoft Learn’s Select-String.

Want to practice PowerShell in a live browser terminal (no install)? Try the free interactive lessons on CMD Master — PowerShell and command-line training.

What does Select-String do?

Select-String -Path .\notes.txt -Pattern "TODO"

That prints every line in notes.txt that contains TODO, plus the file name and line number. Matches are case-insensitive by default on Windows PowerShell 5.1; add -CaseSensitive when case matters.

Search one file or many

Point -Path at a single file, a wildcard, or a list:

Select-String -Path .\app.log -Pattern "ERROR"
Select-String -Path .\*.log -Pattern "timeout"
Select-String -Path .\config.json,.\settings.json -Pattern "apiKey"

Preview what you will search with Get-ChildItem first when the wildcard is broad:

Get-ChildItem .\*.log
Select-String -Path .\*.log -Pattern "Exception"

Recurse into folders: -Recurse

To walk a directory tree, combine a path with -Recurse (or pipe files in):

Select-String -Path .\logs\*.log -Pattern "FATAL" -Recurse

Or pipe from Get-ChildItem for tighter filters:

Get-ChildItem .\src -Filter *.ps1 -Recurse |
  Select-String -Pattern "Write-Host"

Piping is often clearer when you want to exclude folders, filter by extension, or skip huge binary files.

Patterns: simple text and regex

-Pattern accepts a string or a regular expression:

# literal-ish search (still regex — escape special characters)
Select-String -Path .\readme.md -Pattern "C:\\Windows"

# regex: lines that look like IPv4 addresses
Select-String -Path .\access.log -Pattern '\d{1,3}(\.\d{1,3}){3}'

To treat the pattern as plain text (no regex), use -SimpleMatch:

Select-String -Path .\notes.txt -Pattern "C:\temp\file[1].txt" -SimpleMatch

Show surrounding lines: -Context

-Context shows lines before and after each match — perfect for log forensics:

# 2 lines before, 3 lines after
Select-String -Path .\app.log -Pattern "NullReference" -Context 2,3

You can also pass a single number for the same count on both sides: -Context 2.

List only matching files

Sometimes you care which files contain a string, not every hit:

Select-String -Path .\*.config -Pattern "ConnectionString" -List

-List stops after the first match in each file, which is faster on large trees.

Case, invert, and quiet checks

# case-sensitive
Select-String -Path .\code.ps1 -Pattern "Error" -CaseSensitive

# lines that do NOT match
Select-String -Path .\hosts.txt -Pattern "^#" -NotMatch

In scripts, test whether anything matched with the boolean result of a capture:

$hits = Select-String -Path .\app.log -Pattern "FATAL" -Quiet
if ($hits) {
  Write-Host "Found FATAL entries — investigate."
}

-Quiet returns $true / $false instead of match objects.

Select-String vs findstr vs Get-Content

Tool	Best for
`Select-String`	PowerShell pipelines, regex, recursion, rich match objects
`findstr`	Quick CMD one-liners without loading PowerShell
`Get-Content` + `Where-Object`	When you already have content in memory and need custom filters

Prefer Select-String when you are already in PowerShell. Prefer findstr only for tiny CMD scripts that must stay .bat-only.

Safe habits

Narrow the path before a recursive search — start with Get-ChildItem, then pipe.
Prefer -SimpleMatch when the pattern includes brackets, dots, or backslashes you did not mean as regex.
Use -Context on production logs so you see the failure, not just the keyword.
Avoid searching huge binary folders (node_modules, .git) unless you filter them out.

Practice it live

Open a free PowerShell lesson on CMD Master’s interactive CLI platform and try Select-String in a real terminal in your browser — no VM, no install.

Quick cheat sheet

Select-String -Path .\file.txt -Pattern "text"
Select-String -Path .\*.log -Pattern "ERROR" -Recurse
Select-String -Path .\app.log -Pattern "FAIL" -Context 2,2
Select-String -Path .\*.ps1 -Pattern "TODO" -List
Select-String -Path .\data.csv -Pattern "id,name" -SimpleMatch

Once this clicks, pair it with Get-ChildItem for discovery and Get-Content when you need the full file after a hit. That trio covers most day-to-day text hunting on Windows.

Windows DEL Command: Delete Files Safely From CMD

arnostorg — Wed, 16 Sep 2026 07:26:03 +0000

The Windows DEL command (also known as ERASE) removes one or more files from Command Prompt. When you are cleaning temp folders, pruning build artifacts, or wiping test outputs, it is faster — and more scriptable — than clicking through File Explorer. Used carelessly, it is also one of the easiest ways to lose work. This guide focuses on safe patterns first.

For the official reference, see Microsoft Learn’s del command.

What does DEL do?

del notes.tmp

That deletes notes.tmp from the current directory. Relative paths resolve from where you are now. Confirm that with cd before you delete anything important.

erase is the same command with a different name:

erase notes.tmp

Confirm before you delete: /P

The single most important safety flag is /P. It asks you to confirm each file before removing it:

del /P *.tmp

CMD prints something like Delete (Y/N)? for every match. Answer Y to delete that file, N to skip it. Use /P whenever you are not 100% sure the wildcard is right.

Quiet mode vs prompts: /Q

By default, deleting a wildcard pattern can trigger a “Are you sure (Y/N)?” prompt. To skip that confirmation (common in scripts):

del /Q *.log

/Q means quiet. Pair it with a tight wildcard you have already tested with dir first:

dir *.log
del /Q *.log

Never start with /Q on a broad pattern like *.* until you have previewed the match list.

Force read-only deletes: /F

Read-only files normally refuse to delete. /F forces removal of read-only attributes and deletes the file:

del /F locked.txt

Useful for cleaning build caches. Dangerous if you did not mean to touch that file — combine with /P when exploring:

del /F /P *.bak

Include subfolders: /S

/S deletes matching files in the current folder and every subdirectory:

del /S *.tmp

This is powerful and easy to overreach. Always preview with dir /S first:

dir /S *.tmp
del /S /P *.tmp

/P with /S walks the tree and confirms file by file — slow, but safe while you learn the pattern.

Attribute filters: /A

/A lets you target files by attributes (hidden, system, read-only, archive, and more). Example — delete only hidden matches:

del /A:H *.tmp

Attribute letters follow the same style as dir /A. Prefer explicit filters over “delete everything and hope.”

Useful workflows

Preview, then delete

dir *.tmp
del /P *.tmp

Clean a known temp pattern quietly

del /Q C:\builds\out\*.obj

Wipe read-only leftovers after a failed build

del /F /Q C:\builds\out\*.pdb

Recursive cleanup with confirmation

del /S /P *.log

DEL vs File Explorer

Need	Why DEL helps
Exact patterns	Wildcards beat hunting files by hand
Scripts / automation	Repeatable cleanup in a `.bat` file
Already in a prompt	No context switch to Explorer
Safety prompts	`/P` confirms each match before it goes

Common mistakes

Wrong current directory

Relative deletes always resolve from the current directory. If the “wrong” files disappear, check where you are:

cd
dir

Prefer a full path when the stakes are high:

del /P C:\Users\Public\temp\*.tmp

Deleting folders with DEL

del removes files, not directories. Empty folders stay behind. To remove a directory tree, use rmdir / rd (often with /S) after the files are gone — that is a separate command with its own risks.

Broad wildcards + quiet mode

This combination is the classic foot-gun:

del /Q *.*

If you must clear a folder of files, preview with dir first, prefer a narrower pattern, and use /P until the habit sticks.

Assuming Recycle Bin

Files removed with del do not go to the Recycle Bin. Recovery means backups, shadow copies, or undo tools — not Ctrl+Z in Explorer. Treat every delete as permanent.

Quick reference

Goal	Command
Delete one file	`del file.tmp`
Confirm each match	`del /P *.tmp`
Quiet (no prompt)	`del /Q *.log`
Force read-only	`del /F locked.txt`
Include subfolders	`del /S *.tmp`
Safe recursive cleanup	`del /S /P *.tmp`
Same as DEL	`erase notes.tmp`

Practice DEL hands-on

Typing the command a few times sticks better than reading about it — especially the safety flags.

CMD Master is a free online interactive learning platform for the command line. Practice Windows CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no install and no VM. Most lessons are free. For a structured Windows path that covers core commands like DEL, start the interactive Windows Command Prompt course.

Tip: run del /? once in a real prompt, then practice del /P on a throwaway *.tmp folder until the confirm loop feels automatic.

Windows COPY Command: Duplicate Files Fast From CMD

arnostorg — Mon, 14 Sep 2026 07:26:31 +0000

The Windows COPY command duplicates one or more files from Command Prompt. When you are already in a terminal — staging builds, backing up configs, or moving samples into a project — it is faster than opening File Explorer and dragging files around.

This guide covers the basics, wildcards, overwrite behavior, useful patterns, and common mistakes. For the official reference, see Microsoft Learn’s copy command.

What does COPY do?

copy notes.txt backup\

That copies notes.txt from the current directory into the backup folder. You can also name the destination file explicitly:

copy notes.txt backup\notes-old.txt

Relative paths resolve from where you are now. Confirm that with cd before you copy anything important.

Copy into a folder vs rename on copy

If the destination ends with a backslash (or is an existing folder), COPY keeps the original filename:

copy report.csv archive\

If the destination is a file path, COPY creates (or overwrites) that exact name:

copy report.csv archive\report-2026-09-14.csv

Wildcards for batches

Asterisks and question marks let you copy groups of files in one shot:

copy *.txt docs\
copy data?.csv staging\

*.txt grabs every text file in the current directory. data?.csv matches single-character wildcards like data1.csv and dataA.csv.

Overwrite prompts and quiet mode

When the destination file already exists, CMD usually asks before replacing it. To force overwrite without a prompt (handy in scripts):

copy /Y source.txt dest\source.txt

To always get a prompt even in batch files:

copy /-Y source.txt dest\source.txt

/Y is the flag you want for unattended .bat jobs. Leave the default interactive prompt when you are copying by hand and might overwrite something you care about.

Useful workflows

Backup a config next to the original

copy app.config app.config.bak

Stage build outputs into a release folder

copy bin\Release\*.dll release\lib\

Copy then verify the destination

copy readme.md docs\ && dir docs\readme.md

&& runs dir only if the copy succeeds.

Copy from another drive without changing directory

copy D:\usb\keys.env C:\projects\app\.env

COPY vs File Explorer

Need	Why COPY helps
Exact names	No accidental drag-and-drop into the wrong folder
Scripts / automation	Repeatable file staging in a `.bat` file
Already in a prompt	No context switch to Explorer
Wildcards	One command moves a whole pattern of files

Common mistakes

Destination folder missing

COPY does not create the destination folder for you. If backup does not exist, create it first:

mkdir backup
copy notes.txt backup\

Copying a folder tree

copy works on files, not whole directory trees. For recursive folder copies, use xcopy or robocopy instead. Start with single files and wildcards here; graduate to those tools when you need deep trees.

Wrong current directory

Relative sources always resolve from the current directory. If the file “isn’t found,” check where you are:

cd
dir

Then retry with a full path if needed:

copy C:\Users\Public\notes.txt D:\backups\

Overwriting without noticing

In scripts, forgotten /Y can hang on a prompt. In interactive use, an accidental /Y can silently replace a file. Match the flag to the situation.

Quick reference

Goal	Command
File into a folder	`copy file.txt dest\`
Rename on copy	`copy file.txt dest\new.txt`
All matching files	`copy *.log logs\`
Force overwrite	`copy /Y a.txt b.txt`
Prompt before overwrite	`copy /-Y a.txt b.txt`
Copy then check	`copy a.txt b\ && dir b\a.txt`

Practice COPY hands-on

Typing the command a few times sticks better than reading about it.

CMD Master is a free online interactive learning platform for the command line. Practice Windows CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no install and no VM. Most lessons are free. For a structured Windows path that covers core commands like COPY, start the interactive Windows Command Prompt course.

Tip: run copy /? in a real prompt once, then practice a /Y backup copy until the overwrite behavior feels obvious.

Windows MKDIR Command: Create Folders Fast From CMD

arnostorg — Fri, 11 Sep 2026 07:25:25 +0000

The Windows MKDIR command (short alias: md) creates new folders from Command Prompt. When you are already in a terminal — scripting, fixing a project layout, or setting up a deploy tree — it is faster than opening File Explorer and clicking New Folder.

This guide covers the basics, nested paths, useful patterns, and common mistakes. For the official reference, see Microsoft Learn’s mkdir command.

What does MKDIR do?

mkdir projects

That creates a folder named projects in the current directory. The short form does the same thing:

md projects

mkdir and md are interchangeable in CMD.

Create nested folders in one shot

On modern Windows, mkdir creates missing parents automatically:

mkdir projects\cli-tools\scripts

You get projects, then cli-tools inside it, then scripts — without three separate commands.

If any segment already exists, CMD reuses it and only creates what is missing. That makes nested creates safe to re-run.

Multiple folders at once

Space-separated names create siblings in the current directory:

mkdir docs src tests

Three folders appear side by side: docs, src, and tests.

Quoted names work when a folder name has spaces:

mkdir "My Notes" "Raw Data"

Useful workflows

Scaffold a small project tree

mkdir app\src app\tests app\docs

Create a dated backup folder

mkdir backups\2026-09-11

Jump in immediately after creating

mkdir reports && cd reports

&& runs cd only if mkdir succeeds.

MKDIR vs File Explorer

Need	Why MKDIR helps
Nested path	One command builds the whole tree
Scripts / automation	Repeatable folder layout in a `.bat` file
Already in a prompt	No context switch to Explorer
Exact names	No accidental typos from clicking Rename

Common mistakes

Path not found (older expectation)

People coming from older docs sometimes expect parents to fail. On current Windows CMD, nested mkdir usually just works. If you still hit a path error, check that the drive/root exists and that you have write permission.

Creating in the wrong place

mkdir always creates relative to the current directory unless you pass a full path:

mkdir C:\Users\Public\scratch

Confirm where you are first:

cd

Name already exists as a file

If notes is a file, mkdir notes fails. Rename or move the file, then retry.

Quick reference

Goal	Command
One folder	`mkdir projects`
Short alias	`md projects`
Nested path	`mkdir a\b\c`
Several siblings	`mkdir docs src tests`
Name with spaces	`mkdir "My Notes"`
Create then enter	`mkdir reports && cd reports`

Practice MKDIR hands-on

Typing the command a few times sticks better than reading about it.

CMD Master is a free online interactive learning platform for the command line. Practice Windows CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no install and no VM. Most lessons are free. For a structured Windows path that covers core commands like MKDIR, start the interactive Windows Command Prompt course.

Tip: run mkdir /? in a real prompt once, then practice nested creates until muscle memory takes over.

Windows TREE Command: Map Folders From the Command Line

arnostorg — Wed, 09 Sep 2026 18:31:49 +0000

The Windows TREE command prints a folder hierarchy as a text tree. When a project has nested src, tests, docs, and build output, tree shows the shape in one glance — no clicking through Explorer windows.

Microsoft’s reference: TREE command.

What does TREE do?

tree

From the current directory, CMD draws every subdirectory using line characters. Folders nest under parents so you can see depth and structure immediately.

Useful TREE flags

`/f` — include files

tree /f

Shows folders and files. Perfect for understanding what actually lives in a repo or project folder.

`/a` — ASCII characters

tree /a

Uses plain +-- style characters instead of box-drawing glyphs. Better for logs, older fonts, and copy-paste into chats that mangle Unicode.

Point at a path

tree C:\Projects\my-app /f

You do not have to cd first — pass the path as an argument.

Practical workflows

Map a project before you change it

cd /d C:\Projects\my-app
tree /f

You will spot leftover node_modules, old dist folders, or misplaced configs fast.

Save a structure snapshot

tree /f > structure.txt

Commit structure.txt in docs, or attach it to a ticket so others see the layout without cloning yet.

Keep output readable

Huge trees (with node_modules) are noisy. Either:

cd src
tree /f

or exclude heavy folders by running TREE from a narrower path.

TREE vs DIR /s

Need	Prefer
Visual hierarchy	`tree` / `tree /f`
Flat recursive file hunt	`dir /s *.ext`
Scriptable name list	`dir /b /s`

Use TREE to understand shape. Use DIR to find or list specific files.

Practice folder mapping hands-on

Once you can read a tree dump, navigating and cleaning projects gets easier.

CMD Master is a free online interactive learning platform for the command line. Learn Windows CMD, PowerShell, and Bash in a browser terminal with instant feedback — no install required. Most lessons are free; the Windows Command Prompt course covers core file and folder skills step by step.

Windows CD Command Explained: Move Through Folders Fast

arnostorg — Wed, 09 Sep 2026 18:29:50 +0000

The Windows CD command (Change Directory) moves your Command Prompt session into another folder. Almost every CLI workflow starts here: you cd to the right place, then run dir, scripts, builds, or tools.

Official reference: Microsoft Learn — CD / CHDIR.

What does CD do?

cd Documents

If you were in C:\Users\You, you are now in C:\Users\You\Documents. The prompt path updates so you always know where you are.

chdir is the same command — cd is the short form everyone uses.

Essential CD patterns

Go up one level

cd ..

From C:\Users\You\Documents you land in C:\Users\You.

Go up two levels:

cd ..\..

Jump to a drive’s root

cd \

That goes to the root of the current drive (for example C:\).

Switch drives

cd alone does not change the active drive letter the way beginners expect. To work on D::

D:
cd \Projects

Or in one step with /d:

cd /d D:\Projects

/d means: change drive and directory together. Memorize this — it saves constant confusion.

Paths with spaces

Quote them:

cd "C:\Program Files"

Without quotes, CMD splits on the space and fails.

Absolute vs relative

Relative: cd Documents (from where you are)
Absolute: cd C:\Users\You\Documents (full path)

Use absolute paths in scripts; relative paths when exploring by hand.

Handy navigation tricks

See where you are

cd

With no arguments, cd prints the current directory.

Tab completion

Type cd Doc then press Tab — CMD expands matching folder names. Fewer typos, faster moves.

Jump back with pushd / popd

pushd C:\Windows\System32
rem ... do work ...
popd

pushd saves your place and moves; popd returns. Great for quick detours.

Quick reference

Goal	Command
Enter folder	`cd FolderName`
Up one level	`cd ..`
Drive root	`cd \`
Drive + folder	`cd /d D:\Work`
Path with spaces	`cd "Program Files"`
Print location	`cd`

Practice CD until it is automatic

Folder navigation is the foundation of every other command.

CMD Master is a free online interactive learning platform for the command line. Practice Windows CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no install, no VM. Most lessons are free. For a guided Windows path, open the interactive Windows Command Prompt course.

What Does the Windows DIR Command Do? 5 Flags Worth Memorizing

arnostorg — Wed, 09 Sep 2026 18:28:34 +0000

The Windows DIR command lists files and folders in Command Prompt. Used well, it is faster than clicking through File Explorer — especially when you need hidden files, recursive searches, or script-friendly file lists.

This guide explains what dir does, then covers five switches worth memorizing. For the official switch list, see Microsoft Learn’s DIR command reference.

What does DIR do?

Open Command Prompt and run:

dir

You get every file and folder in the current directory: last write time, size (files), and <DIR> for folders.

That is the whole job: inventory the current folder. Flags change how the inventory is shown and filtered.

DIR vs File Explorer

Need	Why DIR helps
Hidden / system files	`/a` surfaces attributes Explorer may hide by default
Find `*.log` deep in a tree	`/s` recurses without opening every folder
Feed a script	`/b` prints bare names — one per line
Sort by date or size	`/o:` sorts without clicking column headers

5 DIR flags worth memorizing

1. `/w` — wide view

dir /w

Names in columns, less metadata. Fast visual scan of a crowded folder.

2. `/a` — include attributes (and hidden items)

dir /a

Without /a, many hidden and system items stay out of the listing. Narrow it:

dir /a:h

Hidden only — useful when a “missing” file is just marked Hidden.

3. `/s` — search subfolders

dir /s *.log

Lists matches in the current folder and every subfolder. Pair with a pattern when you know the name shape but not the path.

4. `/o:` — sort the listing

dir /o:n

Common sort keys:

/o:n — name
/o:d — date (oldest first)
/o:-d — date (newest first)
/o:s — size

5. `/b` — bare format (names only)

dir /b

One name per line. No headers. Ideal for scripts:

dir /b /s *.txt > file-list.txt

Combine flags (real workflows)

Newest .dll files under this tree, names only:

dir /b /s /o:-d *.dll

Everything including hidden, sorted by name:

dir /a /o:n

Quick reference

Goal	Command
Clean scan	`dir /w`
Include hidden	`dir /a`
Deep pattern search	`dir /s *.ext`
Script-friendly list	`dir /b`
Newest first	`dir /o:-d`

Practice DIR hands-on

Reading flags helps. Typing them until they stick is better.

CMD Master is a free online interactive learning platform for the command line. Practice Windows CMD, PowerShell, and Bash in a live browser terminal with instant feedback — no install and no VM. Most lessons are free. For a structured Windows path that covers core commands like DIR, start the interactive Windows Command Prompt course.

Tip: run dir /? once in a real prompt to skim Microsoft’s full switch list, then drill the five above until they are muscle memory.

Read Files in PowerShell: Get-Content Explained

arnostorg — Sat, 25 Apr 2026 08:07:21 +0000

Read Files in PowerShell: Get-Content Explained

Before running operations on files, read them first to understand what you're working with.

How It Works

Get-Content reads file contents and displays them. You can read a few lines to preview, or read the entire file. This is your safety check before running operations.

Code Examples

Read Entire File

# Read complete file contents
Get-Content notes.txt

# Shows everything in the file

Read First Lines Only

# Preview first 10 lines (safe for big files)
Get-Content notes.txt | Select-Object -First 10

# Useful before operating on large files!

Read Last Lines Only

# See most recent entries (like log tail)
Get-Content logfile.txt | Select-Object -Last 5

# Shows last 5 lines - good for log files

Inspect Configuration Files

# Read config file to understand settings
Get-Content app-config.txt

# Review before making changes!

Most Used Options

-Path - File to read
| Select-Object -First 10 - Show only first 10 lines
| Select-Object -Last 5 - Show only last 5 lines
| Select-Object -Index 0..10 - Show specific lines

The Trick: Power Usage

Always preview before operating:

# About to process a file? Read it first!
Get-Content myfile.txt | Select-Object -First 5

# See what you're dealing with
# Now safe to run actual operations

Read logs to diagnose issues:

Get-Content error.log | Select-Object -Last 20

# See most recent errors
# Helps you understand what went wrong

Learn It Through Practice

Stop reading and start practicing:

👉 Practice on your browser

The interactive environment lets you type these commands and see real results.

Part of PowerShell for Beginners

This is part of the PowerShell for Beginners series:

Getting Started - Your first commands
Command Discovery - Find what exists
Getting Help - Understand commands
Working with Files - Copy, move, delete
Filtering Data - Where-Object and Select-Object
Pipelines - Chain commands together

Related Resources

Summary

You now understand:

How this command works
The most useful options
One powerful trick
Where to practice hands-on

Practice these examples until they're automatic. Mastery comes from repetition.

Practice now: Head to the interactive environment and try these commands yourself. That's how PowerShell clicks for you!

What would you like to master next?