Ang PowerShell ay isang matatag na command-line shell at scripting language na kadalasang ginagamit para sa pagkontrol sa mga computer system at pag-automate ng mga gawaing pang-administratibo. Ang paggamit ng mga pahayag ay isa sa pinakamahalagang batayan ng PowerShell. Sa partikular, ang ' gamit ” na pahayag ay gumaganap ng isang mahalagang papel sa pamamahala ng mga mapagkukunan at pagtiyak ng mahusay na pagpapatupad ng code.
I-explore ng artikulong ito ang iba't ibang aspeto ng 'paggamit' na pahayag sa PowerShell, kasama ang syntax, layunin, at praktikal na mga aplikasyon nito.
Layunin ng 'paggamit' ng Pahayag
Hinahayaan ka ng 'paggamit' na pahayag na tukuyin kung aling mga namespace ang ginagamit sa session. Sa pamamagitan ng pagdaragdag ng mga namespace, maaari kang mag-import ng mga klase mula sa mga script module at assemblies at pasimplehin ang paggamit ng mga .NET na klase at miyembro.
Mga DAPAT sa 'paggamit' ng Pahayag
- Ang 'paggamit' na pahayag ay dapat lumitaw bago ang anumang iba pang mga script o module na mga pahayag. Hindi ito maaaring unahan ng anumang mga pahayag na walang komento, kabilang ang mga parameter.
- Ang anumang mga variable ay hindi dapat naroroon sa 'paggamit' na pahayag.
- Ang 'paggamit' na pahayag ay hindi dapat malito sa 'paggamit:' scope modifier para sa mga variable. Pareho silang magkaiba sa kanilang layunin at kahulugan.
Syntax ng 'gamit' na Pahayag
Ang syntax para sa 'paggamit' na pahayag ay:
gamit ang namespace < .NET-namespace >
Tingnan natin ang sumusunod na halimbawa:
gamit ang namespace System.IO
$Bytes = [ file ] ::ReadAllBytes ( 'D:\c sharp\Linuxhint1.txt' )
[ FileInfo ] ::bago ( 'D:\c sharp\Linuxhint1.txt' )
Sa code sa itaas, una naming itinalaga ang namespace na 'System.IO'. Ang pangalawang linya ng programa, [File]::ReadAllBytes('D:c sharpLinuxhint1.txt'), ay nagbabasa ng bawat byte mula sa ibinigay na file at inilalagay ang mga ito sa $Bytes variable. Sa ikatlong linya, ang [FileInfo]::new('D:c sharpLinuxhint1.txt') ay lumilikha ng bagong instance ng klase ng FileInfo at ibinabalik ang object ng FileInfo.
'gamit' na Pahayag para sa mga Module
Maaari rin nating gamitin ang 'paggamit' na pahayag para sa paglo-load ng mga klase ng isang module.
Syntax
gamit ang modyul < pangalan ng module >
Sa syntax na ito, ang '
Maaari mong gamitin ang alinman sa isang ganap na kwalipikado o kamag-anak na landas kapag ang 'module-name>' ay isang landas. Kapag ang isang 'paggamit' na pahayag ay naroroon sa isang script, isang kamag-anak na landas ay nalutas sa script na iyon.
Hinahanap ng PowerShell ang ibinigay na module sa PSModulePath kapag ang '
ModuleName - Kailangan. Pangalanan ang modyul na pinag-uusapan.
Opsyonal na GUID – tumutukoy sa GUID ng module.
Bukod pa rito, dapat mong tukuyin ang isa sa tatlong key na nakalista sa ibaba.
ModuleVersion – Ang pinakamababang pinapayagang bersyon ng module ay tinukoy sa pamamagitan ng property na “ModuleVersion”.
MaximumVersion – Tinutukoy ang pinakamataas na pinapayagang bersyon ng module.
Kinakailangang Bersyon – Tinutukoy ang tumpak, kinakailangang bersyon ng module gamit ang “RequiredVersion”. Ang iba pang mga key ng Bersyon ay hindi magagamit dito.
Ang root module (ModuleToProcess) ng isang binary module o script module ay ini-import ng 'paggamit' ng deklarasyon ng module. Ang mga klase na tinukoy sa mga nested na module o script na dot-sourced sa module ay hindi mapagkakatiwalaang na-import. Anumang mga klase na gusto mong maging available sa mga user sa labas ng module ay dapat na tukuyin sa root module.
Narito ang isang halimbawa:
gamit ang module PSReadline
'gamit' na Pahayag para sa Asembleya
Ang 'paggamit' na pahayag ay maaari ding gamitin upang i-preload ang mga uri mula sa isang .NET na pagpupulong.
Syntax
gamit ang pagpupulong < .NET-assembly-path >
Sa syntax na ito, kapag na-load ang isang assembly, ang mga uri ng .NET mula sa assembly na iyon ay paunang na-load sa script bago ito ma-parse. Bilang resulta, posibleng bumuo ng mga bagong klase ng PowerShell na gumagamit ng mga preloaded na uri ng assembly.
Tumingin sa isang halimbawa ng paglalapat ng 'paggamit' na pahayag na may 'assembly':
gamit ang assembly System.Windows.Forms
Sa utos na ito, na-load namin ang pagpupulong ' System.Windows.Forms” sa PowerShell gamit ang 'gamit' na pahayag.
'paggamit' ng pahayag para sa Hashtable Keys
“ Mga Hash Table ” ay mga naaangkop na istruktura ng data na ginagamit sa PowerShell para sa iba't ibang layunin, kabilang ang pag-iimbak ng data ng configuration, pagbibigay ng mga argumento sa mga cmdlet, at pag-iimbak ng data sa mga script.
Ang cryptographic hash para sa string na ' LinuxHint! ” ay nakuha sa pamamagitan ng sumusunod na script:
gamit ang namespace System.Textgamit ang namespace System.IO [ string ] $string = 'LinuxHint!'
[ string ] $algorithm = 'SHA1'
[ byte [ ] ] $stringbytes = [ UnicodeEncoding ] ::Unicode.GetBytes ( $string )
[ Stream ] $memorystream = [ MemoryStream ] ::bago ( $stringbytes )
$hashfromstream = Get-FileHash -InputStream $memorystream `
-Algorithm $algorithm
$hashfromstream .Hash.ToString ( )
Nagsisimula ang PowerShell code sa itaas sa pamamagitan ng pag-import ng mga namespace na kinakailangan para sa mga pagpapatakbo ng file at pag-encode. Ang input string at ang hashing algorithm (sa kasong ito ' SHA1 ”), pagkatapos ay tinukoy. Ang input string ay pagkatapos ay naka-encode gamit ang ' Unicode ” upang lumikha ng hanay ng mga byte.
Ang nilalaman ng byte array ay pagkatapos ay ginagamit upang bumuo ng isang ' memorystream ”. Ang halaga ng hash mula sa memorystream ay kinakalkula gamit ang ibinigay na 'SHA1' algorithm ng ' Get-FileHash ” cmdlet. Nagtatapos ang script sa pamamagitan ng pag-print ng nakuhang hash value bilang string sa output.
Output
Konklusyon
Ang ' gamit ” na pahayag sa PowerShell ay isang mahusay na tool para sa pagtukoy ng mga namespace, module, o assemblies. Ang syntax at layunin nito ay nagbibigay ng pamantayan at ligtas na diskarte para sa paghawak ng mga mapagkukunan, pagpapadali sa tamang pagtatapon, at pagbabawas ng pagdoble ng code.