Share
PowerShell is een interactieve shell- en scriptingtaal van Microsoft die opnieuw bedenkt wat een commandoschil precies inhoudt. Het heeft zeer interessante mogelijkheden die verder gaan dan de bekende Unix-shells, en er is een sterk ecosysteem en een gemeenschap.
In deze tweedelige zelfstudie leer je over enkele coole dingen die je kunt doen met PowerShell, de geschiedenis, de architectuur, de concepten en hoe het zich verhoudt tot een Unix-shell zoals Bash. Maak je op voor een spannende reis!
Als u op Windows 10 werkt, bent u klaar om te gaan. Download anders het van de Microsoft-website.
Nadat PowerShell is geïnstalleerd, is het eerste wat u wilt doen het uitvoeren van scripts inschakelen. Start PowerShell als beheerder en typ: Set-ExecutionPolicy RemoteSigned. Je hoeft het maar één keer te doen. Update nu de helpbestanden: Update-Help-Kracht.
Laten we beginnen met een snelle demonstratie van de breedte en diepte van PowerShell. Dit is slechts een ietwat willekeurige lijst om je eetlust te wekken. Het is niet allesomvattend, en dit zijn ook niet de meest indrukwekkende dingen die je met PowerShell kunt doen.
Hier is een coole one-liner om videobestanden (of een mediabestand) af te spelen:
(Nieuw-object -COM WMPlayer.OCX) .openPlayer ("Pad naar uw video")
Er wordt een mediaspelervenster geopend en je video wordt meteen afgespeeld.
PowerShell heeft een van de meest leesbare en visueel aantrekkelijke oplossingen voor multi-line strings, AKA "here strings". Je begint gewoon met @" en eindigen met "@. Merk op dat de begin- en eindmarkeringen op hun eigen regel moeten staan, gescheiden van de inhoud ertussen. Hier is een voorbeeld:
$ x = "@ 123 456 789 @"
Kies een willekeurig getal tussen 1 en 100:
1 ... 50 | Get-Random
Dit is een eenvoudige pijplijn. De linkerkant kan alle gehele getallen genereren van 1 tot 50 (inclusief), en dan wordt het gevoerd naar de Get-Random cmdlet die een van hen kiest.
PowerShell ondersteunt het klembord in de diepte. Je kunt objecten van verschillende formaten krijgen en instellen. Uiteraard is platte tekst mogelijk, maar je kunt ook werken met afbeeldingen, HTML, RTF en zelfs bestanden.
Hier selecteer ik een aantal bestanden in verkenner en dan haal ik ze uit het klembord in PowerShell:
23:43:05 C: \ Users \ the_g> Get-Clipboard-Files Mode LastWriteTime Length Name ---- ------------- ------ ---- -a ---- 15-9-2016 23:41 135890 Capture.PNG -een ---- 16-9-2016 22:09 3179548 20160917_110605.jpg -a ---- 16-09-2016 10:09 PM 4623977 20160917_110734.jpg
PowerShell kan ook praten!
Accentsconagua
Add-Type -AssemblyName System.speech $ synth = New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer $ synth.Speak ("PowerShell to the people")Hier is een kleine pipeline om alle lopende virtuele machines te tonen:
Get-VM | Where-Object $ _. State -eq "Running"
PowerShell kan tijdens lange bewerkingen een mooie voortgangsbalk weergeven. Hier is een voorbeeld dat recursief de totale grootte berekent van alle bestanden onder de huidige map:
$ files = Get-ChildItem. -Recurse $ total = 0 For ($ i = 1; $ i -le $ files.Count-1; $ i ++) Write-Progress -Activity "Berekening van de totale grootte ..." -status $ files [$ i] .Name - PercentComplete ($ i / $ files.Count * 100) $ total + = $ files [$ i] .Length Start-Sleep -Milliseconds 50 Write-Host "Totale grootte: $ ($ totaal / 1MB)"
PowerShell 1.0 werd uitgebracht in 2006, maar uitvinder Jeffery Snover begon er al veel eerder aan te werken. Bekijk het manifest van 2002. PowerShell heeft een lange weg afgelegd. Windows liep ver achter wat betreft commandoregelfaciliteiten. Systeembeheerders en hoofdgebruikers moesten het doen met de magere aanbiedingen van cmd.exe en batchbestanden. Er waren een paar zwakke pogingen om de situaties te verbeteren met Windows scripting hosts die scripting system-objecten toelaten met VBScript of JScript, maar er zijn veel problemen met die benadering.
PowerShell veranderde dat allemaal en heel snel. Het kwam niet alleen overeen met de commandoregelmogelijkheden van * nix-omgevingen, maar sprong vooruit met vele innovaties en ongekende consistentie en gebruiksgemak..
Vandaag staat PowerShell op versie 5.1. In de loop van de jaren en versies groeiden de capaciteiten en hostingomgevingen van PowerShell aanzienlijk.
PowerShell 1.0 ondersteund lokaal beheer van Windows-machines (inclusief Windows Server 2003).
PowerShell 2.0 is geïntegreerd met Windows 7 en Windows Server 2008 R2. Het voegde ondersteuning voor remoting toe en verhoogde de mogelijkheden van PowerShell aanzienlijk met achtergrondtaken, transacties, gebeurtenissen, debugging, een GUI-ontwikkelomgeving en veel nieuwe cmdlets.
PowerShell 3.0 werd uitgebracht als onderdeel van het Windows-beheerraamwerk. Het is geïnstalleerd op Windows 8 en Windows Server 2012. Het heeft geplande taken, sessieconnectiviteit, automatisch laden van modules en veel nieuwe opdrachten toegevoegd.
PowerShell 4.0 is geïntegreerd met Windows 8.1 en Windows Server 2012 R2. Het voegde ondersteuning toe voor de gewenste statusconfiguratie, verbeterde foutopsporing, netwerkdiagnostiek en de -PipelineVariable schakelaar.
PowerShell 5.0 is uitgebracht als onderdeel van Windows-beheerraamwerk 5. PowerShell 5.1 is uitgegeven als onderdeel van de Windows 10-jubileumupdates. Nieuwe functies zijn onder meer PowerShell-klassedefinities, .NET-opsommingen, foutopsporing op afstand en achtergrondtaken voor foutopsporing, DSC Local Configuration Manager en nog veel meer DSC-verbeteringen.
PowerShell is een zeer krachtige programmeertaal. Het kan uiteraard scripts uitvoeren, maar het heeft ook meer geavanceerde mechanismen zoals modules, aangepaste cmdlets en klassen. PowerShell is een taal voor meerdere paradigma's die de objectgeoriënteerde, functionele en procedurele paradigma's ondersteunt.
Maar misschien is het belangrijkste aspect van PowerShell dat het een volwaardige .NET-taal is. Het maakt en gebruikt .NET-assembly-objecten die in welke taal dan ook zijn geprogrammeerd, en objecten die door de pipeline van PowerShell gaan, zijn .NET-objecten. PowerShell is ook sterk getypt, maar als het handig is, kunt u het negeren en hoeft u de typen niet op te geven als u niet wilt dat.
Om procedureel te programmeren, hebt u functies, conditionals en loops nodig. PowerShell heeft dat allemaal. De vergelijkingsoperators zullen u misschien verrassen omdat ze geen gebruik maken van de typische symbolen. In plaats daarvan heb je: -eq (Gelijk), -lt (minder dan), -gt (groter dan), -ge (groter of gelijker), enz.
Hier is een voorwaardelijk logisch voorbeeld dat wordt ingevoerd door de gebruiker en verifieert of het geldig is. Let op het gebruik van de -zoals operator om de invoer naar een geheel getal te converteren. Als het mislukt, is het resultaat $ null.
$ value = 44 $ in = Read-Host "Guess een getal tussen 1 - 100" $ guess = $ in -as [int] if ((($ guess -eq $ null) -of ($ guess -lt 1)) -of ($ guess -gt 100)) Write-Host "$ guess is GEEN geheel getal tussen 1 - 100" Exit als ($ guess -eq $ value) Write-Host "You Win!" elseif ($ guess -lt $ value) Write-Host "Too low" else Write-Host "Too high"
PowerShell heeft vele faciliteiten en cmdlets om met verzamelingen te werken en ze te slicen en te dobbelen, dus lussen zijn niet vaak nodig. Maar, voor het geval u zo geneigd bent, zijn er veel loopy-constructies in PowerShell. U kunt For-lussen, ForEach-lussen, While-lussen, Do-While-loops en zelfs speciale ForEach-Object-loops gebruiken. Hier zijn enkele voorbeelden.
Voor ($ i = 0; $ i -lt 100; $ i + = 20) $ i 0 20 40 60 80 $ list = 1 ... 5 For Each ($ item in $ list) $ item * 3 3 6 9 12 15 $ later = $ (Get-Date) .AddSeconds (5) while ($ (Get-Date) -lt $ later) "Zijn we er al?" slaap 1 PS C: \ WINDOWS \ system32> $ later = $ (Get-Date). AddSeconds (5) while ($ (Get-Date) -lt $ later) "Zijn we er al?" slaap 1 Zijn we er al? Zijn we er al? Zijn we er al? Zijn we er al? Zijn we er al?
Bij PowerShell draait alles om functioneel programmeren. De pijplijn is een functionele uitvoeringsomgeving waarin u functies / cmdlets dynamisch samenstelt. Je kunt het interactief doen of je kunt het in een script doen. Als u expliciete functionele programmering wilt doen, kunt u het ook doen, maar de syntaxis is een beetje omslachtig. Bekijk dit artikel: Functioneel programmeren in PowerShell.
U hebt al gezien hoe u .NET-objecten en de objecten die door de pijpleiding gaan, moet gebruiken. Laten we een klasse in PowerShell definiëren en een basis OO doen. Ik creëer hier een les voor een gamekarakter met gezondheid en uitrusting die schade kan aanrichten en de gezondheid ervan kan berekenen. Er is ook een Is levend() methode die controleert of gezondheid> 0. Ik gebruik een constructor.
Merk op dat u PowerShell-klassen moet instantiëren met behulp van [. De syntaxis van het nieuwe object wordt niet ondersteund vanaf PowerShell 5.1.
class Character [string] $ Name [int] $ Health [int] $ AttackDamage [float] $ Armor Character ([string] $ name, [int] $ health, [int] $ attackDamage, [float] $ armour) $ this.Name = $ name $ this.Health = $ health $ this.AttackDamage = $ attackDamage $ this.Armor = $ armor [bool] IsAlive () return $ this.Health -gt 0 [void] TakeDamage ( [int] $ damage) if ($ this.armor -gt 0) $ damage = $ damage - 0.4 * $ this.Armor * $ damage $ this.Health - = $ damage $ c = [Character] :: new ("xxx", 50, 10, 1.0) $ c.TakeDamage (20) $ c.IsAlive () True $ c.Health 38 $ c.TakeDamage (40) $ c.Health 14 $ c.TakeDamage ( 40) $ c.Health -10 $ c.IsAlive () Niet waar Je kunt zelfs overerving doen als je wilt, maar ik denk dat je op dit moment waarschijnlijk een andere taal moet gebruiken.
PowerShell wordt geleverd met een eigen IDE voor scriptontwikkeling met een interactief venster, multi-tabbladen voor scripts met code-aanvulling, ingebouwde hulp voor alle cmdlets en nog veel meer. Het is een zeer gladde tool en ik raad aan om het eens te proberen.
U hebt nu de mogelijkheden van PowerShell gezien als een scripttaal en iets geleerd over de ontwerpdoelstellingen en de geschiedenis ervan. In deel twee zal ik ingaan op de interactieve aspecten van PowerShell.
