# Hva er PowerShell-kommandoer? De 40 viktigste kommandoene på et øyeblikk

Ved å bruke de riktige PowerShell-kommandoene kan du utnytte modulene på en presis måte. Disse oversiktlige cmdletene kan tilpasses ytterligere ved hjelp av valgfrie parametere. Vi presenterer de 40 viktigste PowerShell-kommandoene, slik at du kan arbeide optimalt i systemet eller nettverket ditt.

## Hva er en PowerShell-kommando?

PowerShell, som har vært forhåndsinstallert siden Windows 7, lar deg skrive inn PowerShell-kommandoer som deretter utføres av Windows. I tillegg til cmd-kommandoene i kommandolinjen finnes det en rekke andre kommandoer eller cmdlets som kun forstås av PowerShell selv. Disse cmdlets **består av et verb og et substantiv**, adskilt av en bindestrek. I tillegg kan du utvide disse PowerShell-kommandoene med **valgfrie parametere**, adskilt av mellomrom. PowerShells nytteverdi strekker seg utover administratorer; det viser seg også å være uvurderlig innen utvikling. Med en mengde forhåndsinstallerte PowerShell-kommandoer tilgjengelig, gjør vi deg kjent med de viktigste.

## De viktigste PowerShell-kommandoene

Med PowerShell-kommandoer kan du utføre omfattende administratoroppgaver med bare noen få kommandoer. Blant de grunnleggende kommandoene du sannsynligvis vil bruke oftest, er de som gir en innledende oversikt over nettverksstrukturen, viser en liste over andre PowerShell-kommandoer, hjelper deg med viktige sikkerhetskonfigurasjoner og muliggjør nyttige analyser. Her er noen av de viktigste PowerShell-kommandoene du bør kjenne til:

### 1. Get-Module -All

For å få en første oversikt over alle importerte PowerShell-moduler, bruker du kommandoen **Get-Module -All**.

```shell
Get-Module -All
```

### 2. Get-Command

Det finnes en rekke forhåndsdefinerte PowerShell-kommandoer. For å få oversikt over de tilgjengelige PowerShell-kommandoene, bruker du ganske enkelt kommandoen **Get-Command**. Denne kommandoen viser en oversiktlig liste over alle mulige handlinger og gir korte forklaringer på hver enkelt cmdlet. Dette gjelder også selv om du har installert tilleggsmoduler.

```shell
Get-Command
```

### 3. Få hjelp

Listen over Get-kommandoer beskrevet ovenfor gir en innledende oversikt. For mer detaljert informasjon om en kommando og dens alternativer, bruk cmdlet-en **Get-Help**. Denne kommandoen henter hjelpefilene på PC-en din og viser deretter all tilgjengelig informasjon. For å aktivere den, kombinerer du Get-Help med kommandoen du ønsker å se syntaksen til.

```shell
Get-Help [[-Name] <String>] [-Path <String>] [-Category <String[]>] [-Component <String[]>] [-Functionality <String[]>] [-Role <String[]>] [-Examples] [<CommonParameters>]
```

### 4. Get-Process

For å raskt sjekke listen over applikasjoner, programmer og prosesser som for øyeblikket kjører på systemet ditt, kan du bruke kommandoen **Get-Process**. Hvis du angir en bestemt applikasjon, får du ytterligere informasjon om akkurat den applikasjonen.

```shell
Get-Process
```

### 5. Get-Service

Kommandoen **Get-Service** fungerer på samme måte som cmdlet-en Get-Process. Den skiller seg imidlertid ut ved å gi informasjon om alle aktive tjenester. Hvis du ønsker å få informasjon om en bestemt tjeneste eller en bestemt kategori av tjenester, kan du enkelt spesifisere forespørselen din.

```shell
Get-Service
```

### 6. Stopp prosess

Du kan også bruke ulike PowerShell-kommandoer til å stoppe prosesser via kommandolinjen. En mulighet er kommandoen **Stop-Process**. Du angir den aktuelle prosessen ved hjelp av navn, ID eller andre attributter. Her er et eksempel:

```shell
Stop-Process -Name "processname"
```

```shell
Stop-Process -Id 3582 -Confirm -PassThru
```

Med -Confirm blir det bedt om bekreftelse av kommandoen. Kommandoen -PassThru ber om bekreftelse av den stoppede prosessen. Dette skjer ikke automatisk.

### 7. Konverter til HTML

For å raskt kunne oppdage problemer eller potensielle komplikasjoner er det svært nyttig å ha en oversiktlig visning. Dette oppnår du ved å bruke kommandoen **ConvertTo-HTML**, som konverterer utdataene fra PowerShell-kommandoene dine til en HTML-fil. Dette presenterer informasjonen i et brukervennlig kolonneformat. Kommandostrukturen ser vanligvis slik ut:

```shell
Get-Command | ConvertTo-Html > c:\temp\AllCommands.html
```

### 8. ConvertTo-Xml

Du kan gå frem på samme måte hvis du trenger en XML-basert representasjon av et bestemt objekt. Dette gjør du ved hjelp av kommandoen **ConvertTo-Xml**. I eksemplet nedenfor konverterer du dagens dato til XML-format:

```shell
Get-Date | ConvertTo-Xml
```

### 9. Hvor-objekt

Du kan bruke kommandoen **Where-Object** til å filtrere resultatet av en cmdlet. Når du kjører en kommando, får du ofte mange objekter som inneholder mer informasjon enn du trenger. Ved å bruke Where-Object sammen med en pipe kan du vise bare den spesifikke informasjonen du er ute etter. Hvis du for eksempel vil se tjenester som er opprettet eller oppdatert i år, kan du gjøre det på følgende måte:

```shell
Get-Service | Where-Object { $_.LastWriteTime -gt "01.01.2023" }
```

### 10. Vis historikk

Hvis du vil vise alle PowerShell-kommandoer du har skrevet inn i løpet av en økt, er **Get-History** det rette cmdletet. Slik viser du alle PowerShell-kommandoer:

```shell
Get-History
```

Med denne spesifikasjonen henter du bare de ti siste PowerShell-kommandoene:

```shell
Get-History -Count 10
```

### 11. Slett historikk

Du kan også slette listen over brukte PowerShell-kommandoer. For å fjerne alle oppføringene bruker du cmdlet-kommandoen **Clear-History**:

```shell
Clear-History
```

For å slette bestemte PowerShell-kommandoer, legger du bare til de aktuelle parametrene. Følgende innspill fjerner alle PowerShell-kommandoer som inneholder «Help» eller slutter på «Syntax».

```shell
Clear-History -Command *Help*, *Syntax
```

### 12. Legg til historikk

Det er også mulig å legge til PowerShell-kommandoer i en økt. På den måten kan du hente dem frem igjen senere. Kommandoen som brukes til dette, er **Add-History**.

```shell
Add-History
```

### 13. Ut-fil

Hvis du vil lagre utdataene fra PowerShell-kommandoene dine på datamaskinen, bruker du cmdlet-en **Out-File**. Dette lagrer PowerShell-kommandoene i en ren tekstfil under den angitte banen.

```shell
Get-Process | Out-File -FilePath .\Process.txt
```

### 14. Kopier element

I PowerShell kan du også kopiere elementer og lagre kopien på et annet sted. Bruk kommandoen **Copy-Item** og angi mappen der kopien skal lagres. Dette gjøres på følgende måte:

```shell
Copy-Item "C:\folder1\file.txt" -Destination "C:\folder2"
```

### 15. Get-ChildItem

Du kan bruke kommandoen **Get-ChildItem** til å hente elementer fra ett eller flere lagringssteder. Hvis det finnes underelementer, vises også disse. Denne kommandoen viser som standard attributter, tidsstempelet for den siste endringen, filstørrelsen og elementets navn. Hvis et lagringssted er tomt, utelates utdataene.

```shell
Get-ChildItem -Path C:\example
```

Egenskapene vises under «Mode»-linjen. Følgende egenskaper er vanlige:

- a (arkiv)
- d (katalog)
- h (skjult)
- l (lenke)
- r (skrivebeskyttet)
- s (system)

### 16. Angi Authenticode-signatur

For å beskytte filene dine kan du utstyre dem med en Authenticode-signatur ved hjelp av kommandoen **Set-AuthenticodeSignature**. Dette fungerer imidlertid bare for filer som støtter Subject Interface Package (SIP).

```shell
$cert=Get-ChildItem -Path Cert:\CurrentUser\My -CodeSigningCert
Set-AuthenticodeSignature -FilePath PsTestInternet2.ps1 -Certificate $cert
```

### 17. Invoke-Item

**Invoke-Item** er den enkleste måten å utføre standardhandlingen for en bestemt fil på. Denne kommandoen sørger for eksempel for at en kjørbar fil kjøres direkte, eller at en dokumentfil åpnes i standardprogrammet. I dette eksemplet åpnes filen som standard i Microsoft Word:

```shell
Invoke-Item "C:\Test\example.doc"
```

### 18. Start jobb

For å starte en bakgrunnsoppgave på din lokale datamaskin kan du bruke den aktuelle kommandoen. Med **Start-Job** kan du kjøre en bestemt kommando i bakgrunnen uten å forstyrre den aktuelle økten.

```shell
Start-Job -ScriptBlock { Get-Process -Name pwsh }
```

## Utfør handlinger med disse PowerShell-kommandoene

Mens de tidligere PowerShell-kommandoene hovedsakelig var rettet mot å gi oversikter, kan du også utføre ulike handlinger ved hjelp av de aktuelle cmdletene, og dermed øke systemets produktivitet. Følgende PowerShell-kommandoer effektiviserer arbeidsflyten din.

### 19. Slett innhold

For å slette innholdet i et element uten å fjerne selve elementet, er kommandoen **Clear-Content** det beste valget. Et eksempel på bruken av denne kommandoen er å fjerne teksten fra et dokument uten å endre selve filen. Prosessen utføres på følgende måte:

```shell
Clear-Content C:\Temp\example.txt
```

### 20. ForEach-Object

Kommandoen **ForEach-Object** lar deg utføre en operasjon på alle elementene i en samling av inndataobjekter. I dette eksemplet deler vi tre heltall i en matrise med 10:

```shell
10000, 1000, 100 | ForEach-Object -Process {$_/10}
1000
100
10
```

### 21. Sammenlign-Objekt

For å unngå manuell sammenligning av ulike sett med objekter, kan du bruke cmdlet-kommandoen **Compare-Object**. Denne kommandoen genererer en rapport som fremhever forskjellene mellom postene. Den første posten fungerer som referanseobjekt, og den andre posten som forskjellsobjekt. Du kan angi hvilke faktorer som skal sammenlignes, og hvis denne informasjonen utelates, vil kun strengresultatene bli sammenlignet. Utdataene er delt inn i egenskaper som bare finnes i referanseobjektet (&lt;) og egenskaper som bare finnes i forskjellsobjektet (&gt;). I dette eksemplet inneholder document1.txt verdiene Berlin, London og Paris. Document2.txt inneholder Berlin, Wien og Amsterdam.

```shell
Compare-Object -ReferenceObject (Get-Content -Path C:\Test\Document1.txt) -DifferenceObject (Get-Content -Path C:\Test\Document2.txt)
InputObject	SideIndicator
---------------	-----------------
Wien		==>
Amsterdam	==>
London		<==
Paris		<==
```

Innhold som forekommer i begge dokumentene (i dette tilfellet «Berlin») vises ikke som standard.

### 22. Nytt objekt

En av de mest nyttige PowerShell-kommandoene er **New-Object**. Du kan bruke denne cmdletten til å opprette en instans av et objekt fra .NET Framework eller Component Object Model (COM). Hvis du for eksempel ønsker å opprette et System.Version-objekt med «1.2.3.4» som konstruktorstreng, utføres kommandoen slik:

```shell
New-Object -TypeName System.Version -ArgumentList "1.2.3.4"
```

### 23. Select-Object

Bruk kommandoen **Select-Object** til å velge et objekt eller en gruppe objekter som har de egenskapene du har definert. Du kan angi følgende parametere:

- Først
- Siste
- Unikt
- Hopp over
- Indeks

I det følgende eksemplet bruker vi PowerShell-kommandoene Get-Process og Sort-Object til å vise de tre prosessene som bruker mest minne på det tidspunktet kommandoen utføres.

```shell
Get-Process | Sort-Object -Property WS | Select-Object -Last 3
```

### 24. Opprett alias

Windows-hurtigtaster er nyttige for å utføre handlinger enda raskere. PowerShell tilbyr også denne muligheten. Du kan bruke cmdlet-en **Set-Alias** til å definere en hurtigtast for ulike PowerShell-kommandoer. I eksemplet nedenfor oppretter vi aliaset «ci» for kommandoen Get-ChildItem for den aktuelle økten.

```shell
PS> Set-Alias -Name ci -Value Get-ChildItem
PS> Get-Alias -Name ci
```

### 25. Set-Location

For å endre plasseringen av arbeidsminnet bruker du kommandoen **Set-Location**. Mulige nye plasseringer er kataloger, underkataloger, registerplasseringer eller leverandørstier. I følgende eksempel angir vi C:-stasjonen som gjeldende lagringsplassering:

```shell
PS C:\Windows\> Set-Location HKLM:\
PS HKLM:\> Set-Location C:
PS C:\Windows\>
```

### 26. Innstillings- og vedlikeholdstjeneste

Du kan bruke cmdlet-kommandoen **Set-Service** til å kommunisere med en tjeneste og starte, stoppe eller sette den på pause. Det er også mulig å endre tjenestens egenskaper. I eksemplet nedenfor endrer vi visningsnavnet til en tjeneste fra «New Workstation» til «Old Workstation».

```shell
Set-Service -Name New Workstation -DisplayName "Old Workstation"
```

### 27. Angi tidssone

Hvis du vil endre tidssonen på systemet ditt, er kommandoen **Set-TimeZone** det riktige valget. Bruk denne kommandoen for å angi koordinert universaltid som ny systemtid:

```shell
Set-TimeZone -Id "UTC"
```

### 28. Start datamaskinen på nytt

Du kan starte operativsystemet på nytt på din lokale datamaskin eller en ekstern datamaskin ved hjelp av den aktuelle PowerShell-kommandoen **Restart-Computer**. Den kan kjøres på følgende måte:

For din lokale datamaskin:

```shell
Restart-Computer
```

For utvalgte datamaskiner i nettverket ditt:

```shell
Restart-Computer -ComputerName Server01, Server03
```

### 29. Start tjenesten på nytt

For å stoppe og starte en tjeneste på nytt ved hjelp av PowerShell-kommandoer, er **Restart-Service** det riktige cmdletet. Du kan for eksempel starte alle tjenester som begynner med «Net» på nytt:

```shell
PS C:\> Restart-Service -DisplayName "net*"
```

### 30. Tøm papirkurven

Papirkurven bør tømmes regelmessig, noe som også kan gjøres via PowerShell. Kommandoen er **Clear-RecycleBin**.

```shell
Clear-RecycleBin
```

### 31. Get-ComputerInfo

Kommandoen **Get-ComputerInfo** brukes til å hente informasjon om system- og operativsystemegenskaper.

```shell
Get-ComputerInfo
```

### 32. Flytt element

Når du trenger å flytte et element fra ett sted til et annet, har du flere PowerShell-kommandoer til rådighet. Det mest brukte alternativet er imidlertid **Move-Item**. I dette eksemplet flytter vi filen old.txt fra C:-stasjonen til katalogen D:\\Temp, samtidig som vi gir den nytt navn til new.txt.

```shell
Move-Item -Path C:\old.txt -Destination D:\Temp\new.txt
```

## Overvåking og feilsøking ved hjelp av de riktige PowerShell-kommandoene

PowerShell-kommandoer som muliggjør systemovervåking og -kontroll, er svært verdifulle, særlig når man skal teste ytelsen til et nytt nettverk under realistiske forhold. Følgende PowerShell-kommandoer er spesielt nyttige til dette formålet.

### 33. Feilsøkingsprosess

Feilsøking er en viktig prosess for å sikre at alle innstillinger og prosesser kjører feilfritt. For å gjøre dette må du laste ned og konfigurere de aktuelle feilsøkingsprogrammene. Når dette er gjort, bruker du kommandoen **Debug-Process**. I følgende eksempel bruker vi et feilsøkingsprogram for Explorer:

```shell
PS C:\> Debug-Process -Name "Explorer"
```

For å feilsøke flere prosesser samtidig, skiller du dem ganske enkelt med komma.

### 34. Aktiver-PSBreakpoint

For å aktivere bestemte stoppunkter bruker du kommandoen **Enable-PSBreakpoint**. Dette setter cmdlet-verdien til «true» fra et teknisk perspektiv. Bruk disse PowerShell-kommandoene for å aktivere alle stoppunkter i den aktuelle økten:

```shell
Get-PSBreakpoint | Enable-PSBreakpoint
```

Bruk denne kommandoen til å aktivere stoppunkter ved hjelp av deres ID:

```shell
Enable-PSBreakpoint -ID 0, 3, 4
```

### 35. Deaktiver-PSBreakpoint

For å deaktivere PowerShell-brytpunkter igjen, er cmdlet-kommandoen **Disable-PSBreakpoint** egnet til dette formålet. Teknisk sett settes verdien for kommandoen Enable-PSBreakpoint til «false». For å deaktivere et brytpunkt med ID 0, skriver du inn følgende:

```shell
Disable-PSBreakpoint -Id 0
```

### 36. Get-Counter

For Windows-enheter kan du hente ytelsesdata ved hjelp av PowerShell. Kommandoen som egner seg til denne oppgaven er **Get-Counter**, som kan brukes både på din lokale datamaskin og på eksterne datamaskiner. I eksemplet nedenfor henter vi data fra den lokale datamaskinen:

```shell
Get-Counter -ListSet *
```

### 37. Start-Søvn

Det kan være avgjørende å sette et skript eller en økt på pause, særlig når systemet er overbelastet. PowerShell har kommandoen **Start-Sleep** til dette formålet, som lar deg angi hvor lenge aktivitetene skal settes på pause. I eksemplet nedenfor settes utførelsen på pause i to sekunder:

```shell
Start-Sleep -Seconds 2
```

### 38. Test-Path

Bruk kommandoen **Test-Path** til å sjekke om alle elementene i en bestemt bane er til stede. De mulige resultatene er «True» eller «False».

```shell
Test-Path -Path "C:\Documents and Settings\user"
False
```

### 39. Test tilkobling

Du kan også vurdere nettverkstilkoblingen i nettverket ditt ved hjelp av PowerShell. Dette gjøres ved å sende ICMP-ekkoforespørselspakker til angitte mottakere via kommandoen **Test-Connection**, som ber om svar via ICMP (Internet Control Message Protocol). I vårt eksempel sender vi en forespørsel til Server02 via IPv6-protokollen.

```shell
Test-Connection -TargetName Server02 -IPv6
```

### 40. Get-WinEvent

Når du trenger å se på en eller flere hendelseslogger, har du flere PowerShell-kommandoer til rådighet. Den mest praktiske cmdlet-en til dette formålet er **Get-WinEvent**. For å hente alle loggene fra den lokale datamaskinen din, kan du bruke følgende kommando:

```shell
Get-WinEvent -ListLog *
```


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/powershell-kommandoer/](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/powershell-kommandoer/) for AI/LLM consumption.