എന്താണ് വിൻഡോസ് പവർഷെൽ, അത് എന്താണ് കഴിക്കുന്നത്? ഭാഗം 2: പ്രോഗ്രാമിംഗ് ഭാഷയിലേക്കുള്ള ആമുഖം

ചരിത്രപരമായി, Unix സിസ്റ്റങ്ങളിലെ കമാൻഡ്-ലൈൻ യൂട്ടിലിറ്റികൾ വിൻഡോസിനേക്കാൾ നന്നായി വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്, എന്നാൽ ഒരു പുതിയ പരിഹാരത്തിന്റെ വരവോടെ സ്ഥിതി മാറി.

ക്ലാസിക് പ്രൊസീജറൽ, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ്, കൂടാതെ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് എന്നിവയുടെ ഘടകങ്ങളുള്ള ഒരു വ്യാഖ്യാനിച്ച, മൾട്ടി-പാരഡൈം ഭാഷയിൽ PowerShell സ്ക്രിപ്റ്റ് ചെയ്യാൻ കഴിയും: സോപാധിക ബ്രാഞ്ചിംഗ്, ലൂപ്പുകൾ, വേരിയബിളുകൾ, അറേകൾ, ഹാഷ് ടേബിളുകൾ, ക്ലാസുകൾ, പിശക് കൈകാര്യം ചെയ്യൽ, അതുപോലെ പ്രവർത്തനങ്ങൾ, cmdlets, പൈപ്പ് ലൈനുകൾ. മുൻ ലേഖനം പരിസ്ഥിതിയിൽ ജോലി ചെയ്യുന്നതിനുള്ള അടിസ്ഥാനകാര്യങ്ങൾക്കായി സമർപ്പിച്ചു, ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ വായനക്കാർക്ക് പ്രോഗ്രാമർമാർക്കായി ഒരു ചെറിയ റഫറൻസ് പുസ്തകം വാഗ്ദാനം ചെയ്യുന്നു.

ഉള്ളടക്ക പട്ടിക:

അഭിപ്രായങ്ങള്
വേരിയബിളുകളും അവയുടെ തരങ്ങളും
സിസ്റ്റം വേരിയബിളുകൾ
സ്കോപ്പുകൾ
പരിസ്ഥിതി വേരിയബിളുകൾ (പരിസ്ഥിതി)
കണക്ക്, താരതമ്യ ഓപ്പറേറ്റർമാർ
അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർ
ലോജിക്കൽ ഓപ്പറേറ്റർമാർ
സോപാധിക ജമ്പ്
സൈക്കിളുകൾ
അണികൾ
ഹാഷ് ടേബിളുകൾ
ഫങ്ഷനുകൾ
പ്രോസസ്സ് ചെയ്യുന്നതിൽ പിശക്

നിങ്ങൾക്ക് ഏത് ടെക്സ്റ്റ് എഡിറ്ററിലും അല്ലെങ്കിൽ ഒരു സംയോജിത വികസന പരിസ്ഥിതി ഉപയോഗിച്ച് കോഡ് എഴുതാം - മൈക്രോസോഫ്റ്റ് സെർവർ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളോടൊപ്പം വരുന്ന Windows PowerShell ISE എടുക്കുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം. ഇത് വളരെ സങ്കീർണ്ണമായ സ്ക്രിപ്റ്റുകൾക്ക് മാത്രമേ ആവശ്യമുള്ളൂ: ചെറിയ കമാൻഡുകൾ ഇന്ററാക്ടീവ് ആയി എക്സിക്യൂട്ട് ചെയ്യാൻ എളുപ്പമാണ്.

അഭിപ്രായങ്ങള്

ശരിയായ ഇൻഡന്റേഷനും വൈറ്റ്‌സ്‌പെയ്‌സും സഹിതം അഭിപ്രായങ്ങൾ ഉപയോഗിക്കുന്നത് നല്ല പ്രോഗ്രാമിംഗ് ശൈലിയുടെ ഭാഗമായി കണക്കാക്കപ്പെടുന്നു:

# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.

<# 

       Так обозначаются начало и конец блочного комментария. 
       Заключенный между ними текст интерпретатор игнорирует.

#>

വേരിയബിളുകളും അവയുടെ തരങ്ങളും

PowerShell-ലെ വേരിയബിളുകൾക്ക് ഒബ്‌ജക്‌റ്റുകൾ എന്ന് പേരിട്ടിരിക്കുന്നു. അവരുടെ പേരുകളിൽ അടിവരയിടുന്ന പ്രതീകവും അക്ഷരങ്ങളും അക്കങ്ങളും ഉൾപ്പെടുത്താം. $ ചിഹ്നം എല്ലായ്പ്പോഴും പേരിന് മുമ്പായി ഉപയോഗിക്കുന്നു, ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ, വ്യാഖ്യാതാവിന് സാധുവായ ഒരു പേര് നൽകിയാൽ മതി:

ഒരു വേരിയബിൾ ആരംഭിക്കുന്നതിന് (അതിന് ഒരു മൂല്യം നൽകുക), അസൈൻമെന്റ് ഓപ്പറേറ്റർ (ചിഹ്നം =) ഉപയോഗിക്കുന്നു:

$test = 100

പേരിനോ മൂല്യത്തിനോ മുമ്പായി ചതുര ബ്രാക്കറ്റുകളിൽ (തരം കാസ്റ്റിംഗ് ഓപ്പറേറ്റർ) അതിന്റെ തരം വ്യക്തമാക്കി നിങ്ങൾക്ക് ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ കഴിയും:

[int]$test = 100

$test = [int]100

PowerShell-ലെ വേരിയബിളുകൾ .NET Core-ൽ ഉള്ളവയെ അടിസ്ഥാനമാക്കിയുള്ള ഗുണങ്ങളും രീതികളും ഉള്ള പൂർണ്ണമായ ഒബ്‌ജക്‌റ്റുകൾ (ക്ലാസ്സുകൾ) ആണെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. പ്രധാനവ ഞങ്ങൾ പട്ടികപ്പെടുത്തുന്നു:

തരം (.NET ക്ലാസ്)

വിവരണം

കോഡ് ഉദാഹരണം

[സ്ട്രിംഗ്] System.String

യൂണികോഡ് സ്ട്രിംഗ് 

$test = "ടെസ്റ്റ്"
$test = 'ടെസ്റ്റ്'

[char]System.Char

യൂണികോഡ് പ്രതീകം (16 ബിറ്റുകൾ)

[char]$test = 'c'

[bool] System.Boolean

ബൂളിയൻ തരം (ബൂളിയൻ ശരിയോ തെറ്റോ)

[bool]$test = $true

[int] System.Int32

മുപ്പത്തിരണ്ട് ബിറ്റ് പൂർണ്ണസംഖ്യ (32 ബിറ്റുകൾ)

[int]$test = 123456789

[നീണ്ട] System.Int64

അറുപത്തിനാല് ബിറ്റ് പൂർണ്ണസംഖ്യ (64 ബിറ്റുകൾ)

[ദൈർഘ്യം]$ടെസ്റ്റ് = 12345678910

[ഒറ്റ] System.Single

ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ 32 ബിറ്റുകൾ നീളം

[ഒറ്റ]$ടെസ്റ്റ് = 12345.6789

[ഇരട്ട]സിസ്റ്റം.ഇരട്ട

64 ബിറ്റുകൾ (8 ബൈറ്റുകൾ) നീളമുള്ള ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ

[ഇരട്ട]$ടെസ്റ്റ് = 123456789.101112

[ദശാംശം] സിസ്റ്റം. ഡെസിമൽ

128-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ (d യിൽ അവസാനിക്കേണ്ടത് ആവശ്യമാണ്)

[ദശാംശം]$ടെസ്റ്റ് = 12345.6789d

[DateTime]System.DateTime

തീയതിയും സമയവും 

$test = GetDate

[അറേ] System.Object[]

മൂലക സൂചിക 0-ൽ ആരംഭിക്കുന്ന ഒരു ശ്രേണി

$test_array = 1, 2, "ടെസ്റ്റ്", 3, 4

[hashtable] System.Collections.Hashtable

ഹാഷ് ടേബിളുകൾ പേരുള്ള കീകളുള്ള അസോസിയേറ്റീവ് അറേകളാണ്, തത്ത്വമനുസരിച്ച് നിർമ്മിച്ചിരിക്കുന്നത്: @{key = "മൂല്യം"}

$test_hashtable = @{one="one"; രണ്ട്="രണ്ട്"; മൂന്ന്="മൂന്ന്"}

പവർഷെൽ ഇംപ്ലിസിറ്റ് തരം പരിവർത്തനത്തെ പിന്തുണയ്ക്കുന്നു, കൂടാതെ, ഒരു വേരിയബിളിന്റെ തരം ഈച്ചയിൽ മാറ്റാൻ കഴിയും (ഉദാഹരണത്തിന്, ഒരു അസൈൻമെന്റ് ഓപ്പറേറ്റർ ഉപയോഗിച്ച്), അത് നിർബന്ധിതമായി വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ - ഈ സാഹചര്യത്തിൽ, വ്യാഖ്യാതാവ് ഒരു പിശക് നൽകും. GetType() രീതി വിളിച്ച് മുമ്പത്തെ ഉദാഹരണത്തിൽ നിന്ന് നിങ്ങൾക്ക് വേരിയബിളിന്റെ തരം നിർണ്ണയിക്കാനാകും:

$test.GetType().FullName

വേരിയബിളുകൾ കൈകാര്യം ചെയ്യുന്നതിനായി നിരവധി cmdlets ഉണ്ട്. കമാൻഡ് ഉപയോഗിച്ച് അവരുടെ ലിസ്റ്റ് സൗകര്യപ്രദമായ രൂപത്തിൽ പ്രദർശിപ്പിക്കും:

Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap

പ്രഖ്യാപിത വേരിയബിളുകളും അവയുടെ മൂല്യങ്ങളും കാണുന്നതിന്, നിങ്ങൾക്ക് ഒരു പ്രത്യേക cmdlet ഉപയോഗിക്കാം:

Get-Variable | more

ഈ രീതി വളരെ ബുദ്ധിമുട്ടുള്ളതായി തോന്നുന്നു, ഓപ്പറേറ്റർമാർ മുഖേന അല്ലെങ്കിൽ അവയുടെ ഗുണങ്ങളും രീതികളും നേരിട്ട് ആക്സസ് ചെയ്യുന്നതിലൂടെ വേരിയബിളുകളുമായി പ്രവർത്തിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണ്. എന്നിരുന്നാലും, cmdlets-ന് നിലനിൽക്കാൻ അവകാശമുണ്ട്, കാരണം അവ ചില അധിക പാരാമീറ്ററുകൾ സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉപയോക്തൃ വേരിയബിളുകൾ നിലവിലെ സെഷനിൽ മാത്രമേ നിർവചിച്ചിട്ടുള്ളൂ എന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. കൺസോൾ അടച്ചതിനുശേഷം അല്ലെങ്കിൽ സ്ക്രിപ്റ്റ് അവസാനിച്ചതിന് ശേഷം, അവ ഇല്ലാതാക്കപ്പെടും.

സിസ്റ്റം വേരിയബിളുകൾ

ഉപയോക്താവ് പ്രഖ്യാപിച്ചവയ്ക്ക് പുറമേ, നിലവിലെ സെഷൻ അവസാനിച്ചതിന് ശേഷം ഇല്ലാതാക്കാത്ത ബിൽറ്റ്-ഇൻ (സിസ്റ്റം) വേരിയബിളുകൾ ഉണ്ട്. അവയെ രണ്ട് തരങ്ങളായി തിരിച്ചിരിക്കുന്നു, അതേസമയം പവർഷെൽ സ്റ്റേറ്റ് ഡാറ്റ സ്വയമേവ അനിയന്ത്രിതമായ മൂല്യങ്ങൾ നൽകാനാവാത്ത ഓട്ടോമാറ്റിക് വേരിയബിളുകളിൽ സംഭരിക്കുന്നു. ഇവയിൽ ഉൾപ്പെടുന്നു, ഉദാഹരണത്തിന്, $PWD:

$PWD.Path

ഉപയോക്തൃ മുൻഗണനകൾ സംഭരിക്കുന്നതിന് മുൻഗണന വേരിയബിളുകൾ ആവശ്യമാണ്, അവയുടെ മൂല്യങ്ങൾ മാറ്റാൻ കഴിയും. ഉദാഹരണത്തിന്, $ErrorActionPreference ഉപയോഗിച്ച്, മാരകമല്ലാത്ത പിശകുകൾ ഉണ്ടാകുന്നതിനുള്ള കമാൻഡ് ഇന്റർപ്രെറ്ററിന്റെ പ്രതികരണം സജ്ജീകരിച്ചിരിക്കുന്നു.

പ്രഖ്യാപിത വേരിയബിളുകൾ ആക്‌സസ് ചെയ്യുന്നതിനായി ഓപ്പറേറ്റർമാർക്കും cmdlets-നും പുറമേ, ഒരു വേരിയബിൾ ഉണ്ട്: കപട-ശേഖരണം. മറ്റ് ഡ്രൈവുകളുമായുള്ള സാമ്യം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് പ്രവർത്തിക്കാൻ കഴിയും, കൂടാതെ ഈ കേസിലെ വേരിയബിളുകൾ ഫയൽ സിസ്റ്റം ഒബ്‌ജക്റ്റുകളോട് സാമ്യമുള്ളതാണ്:

Get-ChildItem Variable: | more

അഥവാ

ls Variable: | more

സ്കോപ്പുകൾ

PowerShell-ലെ വേരിയബിളുകൾക്ക്, സ്കോപ്പ് (സ്കോപ്പ്) എന്ന ആശയം ഉണ്ട്. ഗ്ലോബൽ സ്കോപ്പിന്റെ (ഗ്ലോബൽ) പ്രവർത്തനം നിലവിലെ മുഴുവൻ സെഷനിലും ബാധകമാണ് - ഉദാഹരണത്തിന്, സിസ്റ്റം വേരിയബിളുകൾ ഇതിൽ ഉൾപ്പെടുന്നു. ലോക്കൽ (പ്രാദേശിക) വേരിയബിളുകൾ അവ നിർവചിച്ചിരിക്കുന്ന പരിധിയിൽ മാത്രമേ ലഭ്യമാകൂ: ഒരു ഫംഗ്ഷനിൽ പറയുക. സ്ക്രിപ്റ്റിന്റെ (സ്ക്രിപ്റ്റ്) വ്യാപ്തി എന്ന ആശയവും ഉണ്ട്, എന്നാൽ സ്ക്രിപ്റ്റ് കമാൻഡുകൾക്ക് ഇത് പ്രധാനമായും പ്രാദേശികമാണ്. സ്ഥിരസ്ഥിതിയായി, വേരിയബിളുകൾ പ്രഖ്യാപിക്കുമ്പോൾ, അവയ്ക്ക് ഒരു ലോക്കൽ സ്കോപ്പ് നൽകും, ഇത് മാറ്റുന്നതിന്, നിങ്ങൾക്ക് ഒരു പ്രത്യേക നിർമ്മാണം ആവശ്യമാണ്: $Global: variable = value.

ഉദാഹരണത്തിന്, ഇതുപോലെ:

$Global:test = 100

പരിസ്ഥിതി വേരിയബിളുകൾ (പരിസ്ഥിതി)

മറ്റൊരു കപട-ഡ്രൈവ്, Env:, PowerShell-ൽ നിന്ന് ലഭ്യമാണ്, പരിസ്ഥിതി വേരിയബിളുകൾ ആക്സസ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം. ഷെൽ ആരംഭിക്കുമ്പോൾ, അവ പാരന്റ് പ്രോസസ്സിൽ നിന്ന് പകർത്തുന്നു (അതായത്, നിലവിലെ സെഷൻ ആരംഭിച്ച പ്രോഗ്രാമിൽ നിന്ന്) സാധാരണയായി അവയുടെ പ്രാരംഭ മൂല്യങ്ങൾ നിയന്ത്രണ പാനലിലെ മൂല്യങ്ങൾക്ക് തുല്യമാണ്. പരിസ്ഥിതി വേരിയബിളുകൾ കാണുന്നതിന്, Get-ChildItem cmdlet അല്ലെങ്കിൽ അതിന്റെ അപരനാമങ്ങൾ (അപരനാമങ്ങൾ) ഉപയോഗിക്കുക: ls, dir.

dir Env:

ഈ വേരിയബിളുകൾ ബൈറ്റുകളുടെ സീക്വൻസുകളാണ് (അല്ലെങ്കിൽ പ്രതീകങ്ങൾ, നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ), അവയുടെ വ്യാഖ്യാനം അവ ഉപയോഗിക്കുന്ന പ്രോഗ്രാമിനെ മാത്രം ആശ്രയിച്ചിരിക്കുന്നു. പരിസ്ഥിതി വേരിയബിളുകളിൽ *-വേരിയബിൾ cmdlets പ്രവർത്തിക്കില്ല. അവ ആക്‌സസ് ചെയ്യുന്നതിന്, നിങ്ങൾ ഡ്രൈവ് പ്രിഫിക്‌സ് ഉപയോഗിക്കേണ്ടതുണ്ട്:

$env:TEST = "Hello, World!"

കണക്ക്, താരതമ്യ ഓപ്പറേറ്റർമാർ

PowerShell ഇനിപ്പറയുന്ന ഗണിത ഓപ്പറേറ്റർമാരെ നൽകുന്നു: + (കൂട്ടിച്ചേർക്കൽ), - (കുറക്കൽ), * (ഗുണനം), / (വിഭജനം), % (മൊഡ്യൂളോ അല്ലെങ്കിൽ മൊഡ്യൂളോ). ഒരു ഗണിത പദപ്രയോഗത്തിന്റെ ഫലം പൊതുവായി അംഗീകരിച്ച പ്രവർത്തന ക്രമത്തിന് അനുസൃതമായി ഇടത്തുനിന്ന് വലത്തോട്ട് വിലയിരുത്തുന്നു, കൂടാതെ പദപ്രയോഗത്തിന്റെ ഭാഗങ്ങൾ ഗ്രൂപ്പുചെയ്യാൻ പരാൻതീസിസുകൾ ഉപയോഗിക്കുന്നു. ഓപ്പറേറ്റർമാർക്കിടയിലുള്ള ഇടങ്ങൾ അവഗണിക്കപ്പെടുന്നു, അവ വായിക്കുന്നത് എളുപ്പമാക്കാൻ മാത്രമാണ് ഉപയോഗിക്കുന്നത്. + ഓപ്പറേറ്ററും സംയോജിപ്പിക്കുന്നു, കൂടാതെ * ഓപ്പറേറ്റർ സ്ട്രിംഗുകൾ ആവർത്തിക്കുന്നു. നിങ്ങൾ ഒരു സ്ട്രിംഗിലേക്ക് ഒരു നമ്പർ ചേർക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ, അത് ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടും. കൂടാതെ, പവർഷെൽ ഭാഷയിൽ രണ്ട് മൂല്യങ്ങൾ തമ്മിലുള്ള പൊരുത്തം പരിശോധിക്കുകയും ബൂളിയൻ ശരിയോ തെറ്റോ നൽകുകയും ചെയ്യുന്ന നിരവധി താരതമ്യ ഓപ്പറേറ്റർമാർ ഉണ്ട്:

ഓപ്പറേറ്റർ

വിവരണം

കോഡ് ഉദാഹരണം

-eq

തുല്യം / തുല്യം (മറ്റ് ഭാഷകളിൽ = അല്ലെങ്കിൽ == എന്നതിന് സമാനമായത്)

$ടെസ്റ്റ് = 100
$test -eq 123 

-നെ

തുല്യമല്ല / തുല്യമല്ല ( <> അല്ലെങ്കിൽ != ന് സമാനമാണ്)

$ടെസ്റ്റ് = 100
$test -ne 123   

-ജിടി

/ അതിലും വലുത് (അനലോഗ്>)

$ടെസ്റ്റ് = 100
$test -gt 123

-ജി

വലുതോ തുല്യമോ / വലുതോ തുല്യമോ (>= എന്നതിന് സമാനം)

$ടെസ്റ്റ് = 100
$test -ge 123

-lt

കുറവ് / കുറവ് (< എന്നതിന് സമാനമായത്)

$ടെസ്റ്റ് = 100
$test -lt 123  

-ലെ

കുറവ് അല്ലെങ്കിൽ തുല്യം / കുറവ് അല്ലെങ്കിൽ തുല്യം (<= ന് സമാനമായത്)

$ടെസ്റ്റ് = 100
$test -le 123

സമാനമായ മറ്റ് ഓപ്പറേറ്റർമാരുണ്ട്, ഉദാഹരണത്തിന്, ഒരു വൈൽഡ്കാർഡിനെ അടിസ്ഥാനമാക്കിയുള്ള സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യാൻ അല്ലെങ്കിൽ ഒരു പാറ്റേൺ പൊരുത്തപ്പെടുത്തുന്നതിന് സാധാരണ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുക. ഭാവിയിലെ ലേഖനങ്ങളിൽ ഞങ്ങൾ അവ വിശദമായി ചർച്ച ചെയ്യും. <, >, = എന്നീ ചിഹ്നങ്ങൾ മറ്റ് ആവശ്യങ്ങൾക്ക് ഉപയോഗിക്കുന്നതിനാൽ താരതമ്യത്തിന് ഉപയോഗിക്കുന്നില്ല.

അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർ

ഏറ്റവും സാധാരണമായ = ഓപ്പറേറ്റർ കൂടാതെ, മറ്റ് അസൈൻമെന്റ് ഓപ്പറേറ്റർമാരുമുണ്ട്: +=, -=, *=, /= കൂടാതെ %=. അസൈൻമെന്റിന് മുമ്പ് അവർ മൂല്യം മാറ്റുന്നു. ഒരു വേരിയബിളിന്റെ മൂല്യം കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യുന്ന unary operators ++, - എന്നിവ സമാനമായി പ്രവർത്തിക്കുന്നു - അവ അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർക്കും ബാധകമാണ്.

ലോജിക്കൽ ഓപ്പറേറ്റർമാർ

സങ്കീർണ്ണമായ അവസ്ഥകളെ വിവരിക്കാൻ താരതമ്യം മാത്രം പോരാ. ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലോജിക്കൽ എക്സ്പ്രഷനുകൾ എഴുതാം: -and, -or, -xor, -not and!

("Тест" -eq "Тест") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

സോപാധിക ജമ്പ്

PowerShell-ലെ ബ്രാഞ്ച് ഓപ്പറേറ്റർമാർ സ്റ്റാൻഡേർഡ് ആണ്: IF(IF...ELSE, IF...ELSEIF...ELSE) കൂടാതെ SWITCH. ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് അവയുടെ ഉപയോഗം നോക്കാം:

[int]$test = 100
if ($test -eq 100) {
      Write-Host "test = 100"
}



[int]$test = 50
if ($test -eq 100) {
       Write-Host "test = 100"
}
else {
      Write-Host "test <> 100"
}



[int]$test = 10
if ($test -eq 100) {
      Write-Host "test = 100"
}
elseif ($test -gt 100) {
      Write-Host "test > 100"
}
else {
       Write-Host "test < 100"
}



[int]$test = 5
switch ($test) {
     0 {Write-Host "test = 0"}
     1 {Write-Host "test = 1"}
     2 {Write-Host "test = 2"}
     3 {Write-Host "test = 3"}
     4 {Write-Host "test = 4"}
     5 {Write-Host "test = 5"}
     default {Write-Host "test > 5 или значение не определено"}
}

സൈക്കിളുകൾ

PowerShell-ൽ നിരവധി തരം ലൂപ്പുകൾ ഉണ്ട്: WHILE, DO WHILE, DO UNTIL, FOR, FOREACH.

ഒരു മുൻവ്യവസ്ഥയുള്ള ഒരു ലൂപ്പ് അത് ശരിയാണെങ്കിൽ/അത് വരെ പ്രവർത്തിക്കുന്നു:

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

ഒരു പോസ്റ്റ്കണ്ടീഷൻ ഉള്ള ലൂപ്പുകൾ ഒരിക്കലെങ്കിലും പ്രവർത്തിക്കും, കാരണം ആവർത്തനത്തിന് ശേഷം അവസ്ഥ പരിശോധിക്കുന്നു. അതേ സമയം, വ്യവസ്ഥ ശരിയായിരിക്കുമ്പോൾ പ്രവർത്തിക്കുമ്പോൾ ചെയ്യുക, അത് തെറ്റായിരിക്കുമ്പോൾ പ്രവർത്തിക്കുന്നത് വരെ ചെയ്യുക:

[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
while ($test -lt 10)



[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
until ($test -gt 9)

ഫോർ ലൂപ്പിന്റെ ആവർത്തനങ്ങളുടെ എണ്ണം മുൻകൂട്ടി അറിയാം:

for ([int]$test = 0; $test -lt 10; $test++) {
       Write-Host $test
}

FOREACH ലൂപ്പിൽ, ഒരു അറേയുടെയോ ശേഖരത്തിന്റെയോ (ഹാഷ് ടേബിൾ) ഘടകങ്ങളുടെ മേൽ ആവർത്തിക്കുന്നു:

$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
        Write-Host $item
}

അണികൾ

PowerShell വേരിയബിളുകൾ ഒറ്റ ഒബ്‌ജക്‌റ്റുകൾ (നമ്പർ, സ്ട്രിംഗ് മുതലായവ) മാത്രമല്ല, ഒന്നിലധികം വസ്‌തുക്കളും സംഭരിക്കുന്നു. അത്തരം വേരിയബിളുകളുടെ ഏറ്റവും ലളിതമായ തരം അറേകളാണ്. ഒരു അറേയിൽ നിരവധി ഘടകങ്ങൾ അടങ്ങിയിരിക്കാം, ഒരു ഘടകം, അല്ലെങ്കിൽ ശൂന്യമായിരിക്കും, അതായത്. ഘടകങ്ങൾ അടങ്ങിയിട്ടില്ല. അടുത്ത ലേഖനത്തിൽ ഞങ്ങൾക്ക് ആവശ്യമായ @() ഓപ്പറേറ്റർ ഉപയോഗിച്ചാണ് ഇത് പ്രഖ്യാപിച്ചിരിക്കുന്നത് - ഒരു അറേയിലേക്ക് മറ്റ് അറേകൾ ചേർക്കുന്നതിനും (മൾട്ടിഡൈമൻഷണൽ അറേകൾ സൃഷ്ടിക്കുന്നതിനും), അറേകൾ ഫംഗ്ഷനുകളിലേക്ക് ഒരു ആർഗ്യുമെന്റായി കൈമാറുന്നതിനും സമാനമായ ജോലികൾക്കും ഇത് വളരെ പ്രധാനമാണ്:

$test_array = @() #создаем пустой массив

ഒരു അറേ സമാരംഭിക്കുമ്പോൾ, അതിന്റെ മൂല്യങ്ങൾ കോമകളാൽ വേർതിരിച്ചിരിക്കുന്നു (പ്രത്യേക ഓപ്പറേറ്റർ ,):

$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 

മിക്ക കേസുകളിലും, @() ഓപ്പറേറ്ററെ ഒഴിവാക്കാം:

$test_array = 1, 2, 3, 4

ഈ സാഹചര്യത്തിൽ, ഒരു മൂലകത്തിന്റെ ഒരു ശ്രേണി ഇനിപ്പറയുന്ന രീതിയിൽ ആരംഭിക്കുന്നു

$test_array = , 1

പൂജ്യം അടിസ്ഥാനമാക്കിയുള്ള പൂർണ്ണസംഖ്യ സൂചികയും സൂചിക ഓപ്പറേറ്ററും (സ്ക്വയർ ബ്രാക്കറ്റുകൾ) ഉപയോഗിച്ചാണ് അറേ ഘടകങ്ങൾ ആക്സസ് ചെയ്യുന്നത്:

$test_array[0] = 1

കോമകളാൽ വേർതിരിച്ച നിരവധി സൂചികകൾ നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും, ഉൾപ്പെടെ. ആവർത്തിച്ചുള്ള:

$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

ഓപ്പറേറ്റർ .. (രണ്ട് ഡോട്ടുകൾ - റേഞ്ച് ഓപ്പറേറ്റർ) നിർദ്ദിഷ്‌ട മുകളിലും താഴെയുമുള്ള അതിരുകൾക്കുള്ളിൽ പൂർണ്ണസംഖ്യകളുടെ ഒരു നിര നൽകുന്നു. ഉദാഹരണത്തിന്, 1..4 എന്ന എക്സ്പ്രഷൻ @(1, 2, 3, 4) എന്ന നാല് മൂലകങ്ങളുടെ ഒരു ശ്രേണിയെ ഔട്ട്പുട്ട് ചെയ്യുന്നു, കൂടാതെ 8..5 എന്ന എക്സ്പ്രഷൻ ഒരു അറേ @(8, 7, 6, 5) ഔട്ട്പുട്ട് ചെയ്യുന്നു.

റേഞ്ച് ഓപ്പറേറ്റർ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു അറേ ($test_array = 1..4) ആരംഭിക്കാം അല്ലെങ്കിൽ ഒരു സ്ലൈസ് (സ്ലൈസ്) നേടാം, അതായത്. ഒരു ശ്രേണിയിൽ നിന്നുള്ള മൂലകങ്ങളുടെ ഒരു ശ്രേണി, മറ്റൊന്നിൽ നിന്നുള്ള സൂചികകൾ. ഈ സാഹചര്യത്തിൽ, ഒരു നെഗറ്റീവ് നമ്പർ -1 എന്നത് അറേയുടെ അവസാന ഘടകത്തെ സൂചിപ്പിക്കുന്നു, -2 - അവസാനത്തേത് മുതലായവ.

$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

പൂർണ്ണസംഖ്യ അറേ മൂല്യങ്ങൾ ഡാറ്റ അറേയുടെ പരമാവധി സൂചിക മൂല്യത്തേക്കാൾ വലുതായിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക. ഈ സാഹചര്യത്തിൽ, എല്ലാ മൂല്യങ്ങളും അവസാനത്തേത് വരെ നൽകുന്നു:

$test_array[0..100]

നിങ്ങൾ ഒരു നിലവിലില്ലാത്ത അറേ എലമെന്റ് ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, $null തിരികെ നൽകും.

PowerShell-ൽ, അറേകളിൽ വ്യത്യസ്ത തരത്തിലുള്ള ഘടകങ്ങൾ അടങ്ങിയിരിക്കാം അല്ലെങ്കിൽ ശക്തമായി ടൈപ്പ് ചെയ്യാം:

$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
          Write-Host $test_array[$i]
}

ഇവിടെ $test_array.count പ്രോപ്പർട്ടി അറേ ഘടകങ്ങളുടെ എണ്ണമാണ്.

ശക്തമായി ടൈപ്പ് ചെയ്ത അറേ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

ഹാഷ് ടേബിളുകൾ

പവർഷെൽ ഭാഷയിലെ മറ്റൊരു അടിസ്ഥാന തരം വേരിയബിളുകൾ ഹാഷ് ടേബിളുകളാണ്, അസോസിയേറ്റീവ് അറേകൾ എന്നും അറിയപ്പെടുന്നു. ഹാഷ്‌ടേബിളുകൾ JSON ഒബ്‌ജക്‌റ്റുകൾക്ക് സമാനമാണ്, അവ ഒരു പ്രധാന മൂല്യത്തിന്റെ അടിസ്ഥാനത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്. സാധാരണ അറേകളിൽ നിന്ന് വ്യത്യസ്തമായി, അവയുടെ ഘടകങ്ങൾ നാമകരണം ചെയ്ത കീകൾ വഴി ആക്സസ് ചെയ്യപ്പെടുന്നു, അവ ഒബ്ജക്റ്റിന്റെ ഗുണങ്ങളാണ് (നിങ്ങൾക്ക് സൂചിക ഓപ്പറേറ്റർ - സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കാം).

@ ചിഹ്നവും ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകളും ഉപയോഗിച്ച് ഒരു ശൂന്യമായ ഹാഷ് പട്ടിക പ്രഖ്യാപിക്കുന്നു:

$test_hashtable = @{}

പ്രഖ്യാപിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഉടനടി കീകൾ സൃഷ്ടിക്കാനും അവയ്ക്ക് മൂല്യങ്ങൾ നൽകാനും കഴിയും:

$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}

ഒരു ഹാഷ് ടേബിളിലേക്ക് ഒരു ഘടകം ചേർക്കുന്നതിന്, അതിന് ഇതുവരെ നിലവിലില്ലാത്ത ഒരു കീ നിങ്ങൾ നൽകണം, അല്ലെങ്കിൽ ചേർക്കുക () രീതി ഉപയോഗിക്കുക. നിലവിലുള്ള ഒരു കീയിലേക്ക് ഒരു അസൈൻമെന്റ് നൽകിയാൽ, അതിന്റെ മൂല്യം മാറും. ഒരു ഹാഷ് ടേബിളിൽ നിന്ന് ഒരു ഘടകം നീക്കം ചെയ്യാൻ Remove() രീതി ഉപയോഗിക്കുന്നു.

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")

ഈ തരത്തിലുള്ള വേരിയബിളുകൾ ഫംഗ്ഷനുകളിലേക്കും cmdlet കളിലേക്കും ആർഗ്യുമെന്റുകളായി കൈമാറാൻ കഴിയും - അടുത്ത ലേഖനത്തിൽ ഇത് എങ്ങനെ ചെയ്യുന്നുവെന്ന് ഞങ്ങൾ പഠിക്കും, കൂടാതെ സമാനമായ മറ്റൊരു തരം പരിഗണിക്കുക - PSCustomObject.

ഫങ്ഷനുകൾ

ഫംഗ്‌ഷനുകൾ ഉൾപ്പെടെ പ്രൊസീജറൽ പ്രോഗ്രാമിംഗിന് ആവശ്യമായ എല്ലാം PowerShell-ലുണ്ട്. അവയെ വിവരിക്കുന്നതിന്, ഫംഗ്ഷൻ എന്ന ഫംഗ്ഷൻ വാക്ക് ഉപയോഗിക്കുന്നു, അതിനുശേഷം നിങ്ങൾ പ്രവർത്തനത്തിന്റെ പേരും ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ബോഡിയും വ്യക്തമാക്കേണ്ടതുണ്ട്. നിങ്ങൾക്ക് ഫംഗ്‌ഷനിലേക്ക് ആർഗ്യുമെന്റുകൾ കൈമാറണമെങ്കിൽ, പരാൻതീസിസിലെ പേരിന് ശേഷം നിങ്ങൾക്ക് അവ ഉടൻ വ്യക്തമാക്കാം.

function имя-функции (аргумент1, ..., аргументN) 
{ 
        тело-функции 
} 

ഫംഗ്ഷൻ എല്ലായ്പ്പോഴും ഒരു ഫലം നൽകുന്നു - ഒന്നിൽ കൂടുതൽ ഉണ്ടെങ്കിൽ അതിന്റെ എല്ലാ പ്രസ്താവനകളുടെയും ഫലങ്ങളുടെ ഒരു ശ്രേണിയാണിത്. ഒരു പ്രസ്താവന മാത്രമേ ഉള്ളൂവെങ്കിൽ, അനുബന്ധ തരത്തിന്റെ ഒരേയൊരു മൂല്യം തിരികെ നൽകും. റിട്ടേൺ $value കൺസ്ട്രക്‌റ്റ് ഫല ശ്രേണിയിലേക്ക് $value മൂല്യമുള്ള ഒരു ഘടകം ചേർക്കുകയും സ്റ്റേറ്റ്‌മെന്റ് ലിസ്റ്റിന്റെ എക്‌സിക്യൂഷൻ നിർത്തലാക്കുകയും ചെയ്യുന്നു, കൂടാതെ ശൂന്യമായ ഫംഗ്‌ഷൻ $null നൽകുന്നു.

ഉദാഹരണത്തിന്, ഒരു സംഖ്യയുടെ വർഗ്ഗീകരണത്തിനായി നമുക്ക് ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കാം:

function sqr ($number)
{
      return $number * $number
}

ഒരു ഫംഗ്‌ഷന്റെ ബോഡിയിൽ, വിളിക്കുന്നതിന് മുമ്പ് പ്രഖ്യാപിച്ചിട്ടുള്ള ഏതെങ്കിലും വേരിയബിളുകൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാമെന്നത് ശ്രദ്ധിക്കുക, കൂടാതെ PowerShell-ലെ കോളിംഗ് ഫംഗ്‌ഷനുകൾ അസാധാരണമായി തോന്നിയേക്കാം: ആർഗ്യുമെന്റുകൾ (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല, അവ സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കപ്പെടുന്നു.

sqr 2

അല്ലെങ്കിൽ അങ്ങനെ:

sqr -number 2

ആർഗ്യുമെന്റുകൾ പാസാക്കുന്ന രീതി കാരണം, ഫംഗ്ഷൻ തന്നെ ചിലപ്പോൾ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്:

function test_func ($n) {}
test_func -eq $null     # функция не вызывалась
(test_func) -eq $null   # результат выражения — $true

ഒരു ഫംഗ്ഷൻ വിവരിക്കുമ്പോൾ, ആർഗ്യുമെന്റുകൾക്ക് സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ നൽകാം:

function func ($arg = value) {
         #тело функции
}

ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകൾ വിവരിക്കുന്നതിന് മറ്റൊരു വാക്യഘടനയുണ്ട്, കൂടാതെ, പൈപ്പ്ലൈനിൽ നിന്ന് പാരാമീറ്ററുകൾ വായിക്കാൻ കഴിയും - കയറ്റുമതി ചെയ്ത മൊഡ്യൂളുകൾ നോക്കുകയും ഞങ്ങളുടെ സ്വന്തം cmdlets സൃഷ്ടിക്കുകയും ചെയ്യുമ്പോൾ ഇതെല്ലാം അടുത്ത ലേഖനത്തിൽ ഉപയോഗപ്രദമാകും.

പ്രോസസ്സ് ചെയ്യുന്നതിൽ പിശക്

പവർഷെല്ലിന് ഒരു ട്രൈ...ക്യാച്ച്...ഒടുവിൽ ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യാനുള്ള സംവിധാനം ഉണ്ട്. ട്രൈ ബ്ലോക്കിൽ ഒരു പിശക് സംഭവിക്കാനിടയുള്ള കോഡും ക്യാച്ച് ബ്ലോക്കിൽ അതിന്റെ ഹാൻഡ്‌ലറും അടങ്ങിയിരിക്കുന്നു. ഒരു പിശകും ഇല്ലെങ്കിൽ, അത് നടപ്പിലാക്കില്ല. ഒരു പിശക് സംഭവിച്ചാലും, ട്രൈ ബ്ലോക്കിന് ശേഷം അവസാന ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, കൂടാതെ വ്യത്യസ്ത തരം ഒഴിവാക്കലുകൾക്കായി നിരവധി ക്യാച്ച് ബ്ലോക്കുകൾ ഉണ്ടാകാം. അപവാദം തന്നെ ഒരു അൺഡിക്ലെയർ ഡിഫോൾട്ട് വേരിയബിളിൽ ($_) എഴുതിയിരിക്കുന്നു, അത് എളുപ്പത്തിൽ വീണ്ടെടുക്കാൻ കഴിയും. ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ഒരു അസാധുവായ മൂല്യം നൽകുന്നതിൽ നിന്ന് ഞങ്ങൾ സംരക്ഷണം നടപ്പിലാക്കുന്നു:

try {

        [int]$test = Read-Host "Введите число"
        100 / $test

} catch {

         Write-Warning "Некорректное число"
         Write-Host $_

}

പവർഷെൽ ഭാഷയിലെ പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാനകാര്യങ്ങളുടെ അവലോകനം ഇത് അവസാനിപ്പിക്കുന്നു. ഇനിപ്പറയുന്ന ലേഖനങ്ങളിൽ, വ്യത്യസ്ത തരം വേരിയബിളുകൾ, ശേഖരങ്ങൾ, റെഗുലർ എക്സ്പ്രഷനുകൾ, ഫംഗ്ഷനുകൾ, മൊഡ്യൂളുകൾ, ഇഷ്‌ടാനുസൃത cmdlets എന്നിവ സൃഷ്‌ടിക്കുന്നത്, അതുപോലെ ഒബ്‌ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് എന്നിവയുമായി ഞങ്ങൾ കൂടുതൽ വിശദമായി പഠിക്കും.

അവലംബം: www.habr.com