Share
PowerShell är ett interaktivt skal och skriptspråk från Microsoft som omprövar vad ett kommandoskal handlar om. Den har mycket intressanta möjligheter utöver de välbekanta Unix-skalen, och det finns ett starkt ekosystem och samhälle.
I denna tvådelade handledning läser du om några av de coola sakerna du kan göra med PowerShell, dess historia, dess arkitektur, dess koncept och hur det jämförs med ett Unix-skal som Bash. Gör dig redo för en spännande resa!
Om du är på Windows 10 är du bra att gå. I annat fall ladda ner den från Microsofts webbplats.
När PowerShell är installerat är det första du vill göra, att aktivera script-körning. Starta PowerShell som administratör och typ: Set-ExecutionPolicy RemoteSigned. Du behöver göra det bara en gång. Nu uppdatera hjälpfilerna: Uppdatering-Hjälp-Förbättra.
Låt oss börja med en snabb demonstration av bredden och djupet i PowerShell. Det här är bara en godtycklig lista för att göra din aptit. Det är inte heltäckande, och det är inte nödvändigtvis de mest imponerande sakerna du kan göra med PowerShell.
Här är en cool en-liner för att spela videofiler (eller någon mediefil):
(Nytt objekt -COM WMPlayer.OCX) .openPlayer ("Path to your video")
Det öppnar ett mediaspelarfönster och börjar omedelbart spela upp ditt videoklipp.
PowerShell har en av de mest läsbara och visuellt tilltalande lösningarna på flera linjesträngar, AKA "här strängar". Du börjar bara med @" och sluta med "@. Observera att start- och slutmarkörerna måste vara på egen linje, åtskilda från innehållet däremellan. Här är ett exempel:
$ x = "@ 123 456 789 @"
Välj ett slumptal mellan 1 och 100:
1 ... 50 | Get-Random
Detta är en enkel rörledning. Den vänstra sidan kan generera alla heltal från 1 till 50 (inklusive), och sedan matas den till Random cmdlet som väljer en av dem.
PowerShell stöder urklippet i djupet. Du kan få och ställa in föremål av olika format. Tydlig text är självklart, men du kan också arbeta med bilder, HTML, RTF och till och med filer.
Här väljer jag några filer i explorer och sedan får jag dem från klippbordet i PowerShell:
23:43:05 C: \ Users \ the_g> Get-Clipboard -Files Mode LastWriteTime Längd Namn ---- ------------- ------ ---- -a ---- 9/15/2016 11:41 135890 Capture.PNG -a ---- 9/16/2016 10:09 3179548 20160917_110605.jpg -a ---- 9/16/2016 10:09 PM 4623977 20160917_110734.jpg
PowerShell kan också tala!
Accentsconagua
Add-Type -AssemblyName System.speech $ synth = Ny-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer $ synth.Speak ("PowerShell to the people")Här är en liten pipeline för att lista alla virtuella virtuella maskiner:
Get-VM | Var-objekt $ _. State -eq "Running"
PowerShell kan visa en bra framdriftsfält under långa operationer. Här är ett exempel som rekursivt beräknar den totala storleken på alla filer under den aktuella katalogen:
$ files = Get-ChildItem. -Recurse $ total = 0 För ($ i = 1; $ i -le $ files.Count-1; $ i ++) Write-Progress -Activity "Beräkna totalstorlek ..." -status $ filer [$ i] .Name - PercentComplete ($ i / $ files.Count * 100) $ totalt + = $ filer [$ i] .Längd Start-Sleep -Milliseconds 50 Skriv-värd "Total storlek: $ ($ total / 1 MB)"
PowerShell 1.0 släpptes 2006, men uppfinnaren Jeffery Snover började arbeta mycket tidigare. Kolla in 2002-manifestet. PowerShell har kommit långt. Windows var långt ifrån när det gäller kommandoradsanläggningar. Systemadministratörer och strömanvändare måste göra med de milda erbjudandenen av cmd.exe och batch-filer. Det fanns några svaga försök att förbättra situationerna med Windows scripting-värdar som tillåter skriptystemobjekt med VBScript eller JScript, men det finns många problem med den metoden.
PowerShell ändrade allt det och mycket snabbt. Det matchade inte bara kommandoradsfunktionerna i * nix-miljöer utan sprang framåt med många innovationer och oöverträffad konsistens och användarvänlighet.
Idag är PowerShell på version 5.1. Under årens och versionerna ökade PowerShells kapacitet och värdmiljö betydligt.
PowerShell 1.0 stödd lokal administration av Windows-maskiner (inklusive Windows Server 2003).
PowerShell 2.0 integrerades med Windows 7 och Windows Server 2008 R2. Det lade till stöd för avlägsnande och avsevärt ökade PowerShells möjligheter med bakgrundsjobb, transaktioner, händelser, debugging, en GUI-utvecklingsmiljö och många nya cmdlets.
PowerShell 3.0 släpptes som en del av Windows Management Framework. Den installerades på Windows 8 och Windows Server 2012. Den lade till schemalagda jobb, sessionskoppling, automatisk modulladdning och många nya kommandon.
PowerShell 4.0 integrerades med Windows 8.1 och Windows Server 2012 R2. Det lade till stöd för önskad tillståndskonfiguration, förbättrad debugging, nätverksdiagnos och -PipelineVariable växla.
PowerShell 5.0 släpptes som en del av Windows Management Framework 5. PowerShell 5.1 släpptes som en del av Windows 10 årsjubileum uppdateringar. Nya funktioner inkluderar PowerShell klassdefinitioner, .NET-uppräkningar, fjärrfelsökning och felsökning av bakgrundsjobb, DSC-lokal konfigurationshanterare och många fler DSC-förbättringar.
PowerShell är ett mycket kraftfullt programmeringsspråk. Det kan köra skript, självklart, men det har också mer avancerade mekanismer som moduler, anpassade cmdlets och klasser. PowerShell är ett språk med flera paradigm som stöder objektorienterade, funktionella och processuella paradigmer.
Men kanske den viktigaste aspekten av PowerShell är att det är ett fulländat .NET-språk. Det skapar och använder .NET-sammansatta objekt som är programmerade på något språk, och objekt som passerar PowerShells pipeline är .NET-objekt. PowerShell skrivs också starkt, men när det är bekvämt kan du ignorera det, och du behöver inte ange typerna om du inte vill.
För att programmera procedurellt behöver du funktioner, villkor och loopar. PowerShell har allt detta. Jämförelseoperatörerna kan överraska dig eftersom de inte använder de typiska symbolerna. I stället har du: -eq (lika), -lt (mindre än), -gt (större än), -gE (större eller lika), etc.
Här är ett villkorat logiskt exempel som får inmatning från användaren och verifierar att den är giltig. Notera användningen av -som operatör för att försöka konvertera ingången till ett heltal. Om det misslyckas är resultatet $ null.
$ värde = 44 $ in = läs-värd "Gissa ett tal mellan 1 - 100" $ gissning = $ i -as [int] om ((($ gissa -qq $ null) -eller ($ giss -lt 1)) -or ($ guess -gt 100)) Write-Host "$ gissning är INTE ett heltal mellan 1 - 100" Exit om ($ gissning -qq $ värde) Write-Host "You Win!" elseif ($ guess -lt $ value) Skriv-värd "För låg" Annat Skriv-värd "För hög"
PowerShell har många faciliteter och cmdlets att arbeta med samlingar och skivor och tärningar dem, så det behövs inte slingor ofta. Men bara om du är så benägen finns det många loopy-konstruktioner i PowerShell. Du kan använda För slingor, ForEach-slingor, Medan slingor, Do-While-slingor, och till och med speciella ForEach-Object-slingor. Här är några exempel.
För ($ i = 0; $ i-100, $ i + = 20) $ i 0 20 40 60 80 $ list = 1 ... 5 FörEach ($ item in $ list) $ item * 3 3 6 9 12 15 $ senare = $ (Get-Date) .AddSeconds (5) medan ($ (Get-Date) -lt $ senare) "Är vi där ännu?" sova 1 PS C: \ WINDOWS \ system32> $ senare = $ (Get-Date) .AddSeconds (5) medan ($ (Get-Date) -lt $ senare) "Är vi där ännu?" sova 1 Är vi där än? Är vi där än? Är vi där än? Är vi där än? Är vi där än?
PowerShell handlar om funktionell programmering. Rörledningen är en funktionell exekveringsmiljö där du komponerar funktioner / cmdlets dynamiskt. Du kan göra det interaktivt eller du kan göra i ett manus. Om du vill göra explicit funktionell programmering kan du också göra det, men syntaxen är lite besvärlig. Kolla in den här artikeln: Funktionsprogrammering i PowerShell.
Du har redan sett hur du använder .NET-objekt och objekten som passerar genom rörledningen. Låt oss definiera en klass i PowerShell och göra några grundläggande OO. Jag skapar här en klass för ett speltecken med hälsa och rustning som kan ta skada och beräkna dess hälsa. Det finns också en Lever() metod som kontrollerar om hälsa> 0. Jag använder en konstruktör.
Observera att du måste inställa PowerShell-klasser med [. Syntagmen New Object stöds inte av PowerShell 5.1.
klassen Karaktär [string] $ Namn [int] $ Hälsa [int] $ AttackDamage [float] $ Armor Character ([string] $ namn, [int] $ hälsa, [int] $ attackDamage, [float] $ armor) $ this.Name = $ name $ this.Health = $ hälsa $ this.AttackDamage = $ attackDamage $ this.Armor = $ rustning [bool] IsAlive () returnera $ this.Health -gt 0 [void] TakeDamage $ $ damage $ c = [Character] :: nytt ("xxx", 50, 10, 1.0) $ c.TakeDamage (20) $ c.IsAlive () True $ c.Health 38 $ c.TakeDamage (40) $ c.Hälsa 14 $ c.TakeDamage 40) $ c. Hälsa -10 $ c.IsAlive () False Du kan till och med göra arv om du vill, men jag känner att du förmodligen ska använda ett annat språk vid denna tidpunkt.
PowerShell kommer med sin egen IDE för skriptutveckling som innehåller ett interaktivt fönster, multi-tabbed för skript med kodavslutning, inbyggd hjälp på alla cmdlets och mycket mer. Det är ett mycket smidigt verktyg, och jag rekommenderar att du provar.
Du har nu sett PowerShells möjligheter som skriptspråk och lärt dig lite om dess designmål och dess historia. I del två kommer jag att fördjupa de interaktiva aspekterna av PowerShell på djupet.
