விண்டோஸ் பவர்ஷெல் என்றால் என்ன, அது எதனுடன் உண்ணப்படுகிறது? பகுதி 2: நிரலாக்க மொழி அறிமுகம்

வரலாற்று ரீதியாக, யுனிக்ஸ் கணினிகளில் உள்ள கட்டளை வரி பயன்பாடுகள் விண்டோஸை விட சிறப்பாக உருவாக்கப்பட்டுள்ளன, ஆனால் ஒரு புதிய தீர்வின் வருகையுடன், நிலைமை மாறிவிட்டது.

பவர்ஷெல் ஒரு விளக்கப்பட்ட, பல முன்னுதாரண மொழியில் ஸ்கிரிப்ட் செய்யப்படலாம், இது கிளாசிக் செயல்முறை, பொருள் சார்ந்த மற்றும் செயல்பாட்டு நிரலாக்கத்தின் கூறுகளைக் கொண்டுள்ளது: நிபந்தனை கிளைகள், சுழல்கள், மாறிகள், வரிசைகள், ஹாஷ் அட்டவணைகள், வகுப்புகள், பிழை கையாளுதல் மற்றும் செயல்பாடுகள், cmdlets, மற்றும் குழாய்கள் . முந்தைய கட்டுரை சுற்றுச்சூழலில் வேலை செய்வதற்கான அடிப்படைகளுக்கு அர்ப்பணிக்கப்பட்டது, இப்போது வாசகர்களுக்கு புரோகிராமர்களுக்கான சிறிய வழிகாட்டியை நாங்கள் வழங்குகிறோம்.

உள்ளடக்க அட்டவணை:

கருத்துரைகள்
மாறிகள் மற்றும் அவற்றின் வகைகள்
கணினி மாறிகள்
நோக்கங்கள்
சுற்றுச்சூழல் மாறிகள் (சுற்றுச்சூழல்)
எண்கணிதம் மற்றும் ஒப்பீட்டு ஆபரேட்டர்கள்
பணி ஆபரேட்டர்கள்
தருக்க ஆபரேட்டர்கள்
நிபந்தனை தாவல்
சுழற்சிகள்
அணிவரிசைகள்
ஹாஷ் அட்டவணைகள்
செயல்பாடுகளை
செயலாக்கத்தில் பிழை

நீங்கள் எந்த டெக்ஸ்ட் எடிட்டரிலும் குறியீட்டை எழுதலாம் அல்லது ஒருங்கிணைந்த மேம்பாட்டு சூழலைப் பயன்படுத்தலாம் - மைக்ரோசாஃப்ட் சர்வர் இயக்க முறைமைகளுடன் வரும் விண்டோஸ் பவர்ஷெல் ஐஎஸ்இ எடுப்பதே எளிதான வழி. இது மிகவும் சிக்கலான ஸ்கிரிப்டுகளுக்கு மட்டுமே அவசியம்: குறுகிய கட்டளைகளின் தொகுப்புகள் ஊடாடும் வகையில் செயல்படுத்த எளிதானது.

கருத்துரைகள்

சரியான உள்தள்ளல் மற்றும் இடைவெளியுடன் கருத்துகளைப் பயன்படுத்துவது நல்ல நிரலாக்க பாணியின் ஒரு பகுதியாகக் கருதப்படுகிறது:

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

<# 

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

#>

மாறிகள் மற்றும் அவற்றின் வகைகள்

பவர்ஷெல்லில் உள்ள மாறிகள் பொருள்கள் என்று பெயரிடப்படுகின்றன. அவர்களின் பெயர்களில் அடிக்கோடிடும் எழுத்தும், எழுத்துக்கள் மற்றும் எண்களும் இருக்கலாம். $ சின்னம் எப்போதும் பெயருக்கு முன் பயன்படுத்தப்படுகிறது, மேலும் ஒரு மாறியை அறிவிக்க, மொழிபெயர்ப்பாளருக்கு சரியான பெயரைக் கொடுத்தால் போதும்:

ஒரு மாறியை துவக்க (அதற்கு ஒரு மதிப்பை ஒதுக்க), அசைன்மென்ட் ஆபரேட்டர் (சின்னம் =) பயன்படுத்தப்படுகிறது:

$test = 100

பெயர் அல்லது மதிப்புக்கு முன் அதன் வகையை சதுர அடைப்புக்குறிக்குள் (வகை காஸ்டிங் ஆபரேட்டர்) குறிப்பிடுவதன் மூலம் நீங்கள் ஒரு மாறியை அறிவிக்கலாம்:

[int]$test = 100

$test = [int]100

பவர்ஷெல்லில் உள்ள மாறிகள் முழு அளவிலான பொருள்கள் (வகுப்புகள்) பண்புகள் மற்றும் முறைகள் .NET கோரில் உள்ளவற்றை அடிப்படையாகக் கொண்டவை என்பதை புரிந்துகொள்வது அவசியம். முக்கியவற்றை நாங்கள் பட்டியலிடுகிறோம்:

வகை (.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

[ஒற்றை] சிஸ்டம்.ஒற்றை

மிதக்கும் புள்ளி எண் 32 பிட்கள் நீளம்

[ஒற்றை]$ சோதனை = 12345.6789

[இரட்டை]அமைப்பு.இரட்டை

நீளம் 64 பிட்கள் (8 பைட்டுகள்) மிதக்கும் புள்ளி எண்

[இரட்டை]$ சோதனை = 123456789.101112

[decimal]அமைப்பு.தசம

128-பிட் மிதக்கும் புள்ளி எண் (d உடன் முடிக்க வேண்டும்)

[தசமம்]$test = 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

நோக்கங்கள்

பவர்ஷெல்லில் உள்ள மாறிகளுக்கு, நோக்கம் (ஸ்கோப்) என்ற கருத்து உள்ளது. உலகளாவிய நோக்கத்தின் (குளோபல்) செயல் முழு நடப்பு அமர்வுக்கும் பொருந்தும் - எடுத்துக்காட்டாக, கணினி மாறிகள் இதில் அடங்கும். உள்ளூர் (உள்ளூர்) மாறிகள் அவை வரையறுக்கப்பட்ட நோக்கத்தில் மட்டுமே கிடைக்கும்: ஒரு செயல்பாட்டிற்குள் சொல்லுங்கள். ஸ்கிரிப்ட்டின் (ஸ்கிரிப்ட்) நோக்கம் பற்றிய கருத்தும் உள்ளது, ஆனால் ஸ்கிரிப்ட் கட்டளைகளுக்கு, இது அடிப்படையில் உள்ளூர். முன்னிருப்பாக, மாறிகளை அறிவிக்கும் போது, ​​அவற்றுக்கு உள்ளூர் நோக்கம் கொடுக்கப்படுகிறது, இதை மாற்ற, உங்களுக்கு ஒரு சிறப்பு கட்டுமானம் தேவை: $Global: variable = value.

உதாரணமாக, இது:

$Global:test = 100

சுற்றுச்சூழல் மாறிகள் (சுற்றுச்சூழல்)

மற்றொரு போலி இயக்கி, Env:, PowerShell இலிருந்து கிடைக்கிறது மற்றும் சூழல் மாறிகளை அணுக பயன்படுத்தலாம். ஷெல் தொடங்கும் போது, ​​அவை பெற்றோர் செயல்முறையிலிருந்து நகலெடுக்கப்படுகின்றன (அதாவது, நடப்பு அமர்வைத் தொடங்கிய நிரலிலிருந்து) பொதுவாக அவற்றின் ஆரம்ப மதிப்புகள் கட்டுப்பாட்டுப் பலகத்தில் உள்ள மதிப்புகளைப் போலவே இருக்கும். சூழல் மாறிகளைப் பார்க்க, Get-ChildItem cmdlet அல்லது அதன் மாற்றுப்பெயர்களை (மாற்றுப்பெயர்கள்) பயன்படுத்தவும்: ls மற்றும் dir.

dir Env:

இந்த மாறிகள் பைட்டுகளின் வரிசைகள் (அல்லது எழுத்துக்கள், நீங்கள் விரும்பினால்), அவற்றின் விளக்கம் அவற்றைப் பயன்படுத்தும் நிரலைப் பொறுத்தது. *-மாறும் cmdlets சூழல் மாறிகளுடன் வேலை செய்யாது. அவற்றை அணுக, நீங்கள் இயக்கி முன்னொட்டைப் பயன்படுத்த வேண்டும்:

$env:TEST = "Hello, World!"

எண்கணிதம் மற்றும் ஒப்பீட்டு ஆபரேட்டர்கள்

PowerShell பின்வரும் எண்கணித ஆபரேட்டர்களை வழங்குகிறது: + (கூடுதல்), - (கழித்தல்), * (பெருக்கல்), / (வகுத்தல்), மற்றும் % (மாடுலோ அல்லது மாடுலோ). ஒரு எண்கணித வெளிப்பாட்டின் முடிவு, பொதுவாக ஏற்றுக்கொள்ளப்பட்ட செயல்பாடுகளின் வரிசைக்கு ஏற்ப இடமிருந்து வலமாக மதிப்பிடப்படுகிறது, மேலும் வெளிப்பாட்டின் பகுதிகளை குழுவாக்க அடைப்புக்குறிகள் பயன்படுத்தப்படுகின்றன. ஆபரேட்டர்களுக்கிடையேயான இடைவெளிகள் புறக்கணிக்கப்படுகின்றன, அவை வாசிப்பதை எளிதாக்க மட்டுமே பயன்படுத்தப்படுகின்றன. + ஆபரேட்டரும் இணைகிறது, மேலும் * ஆபரேட்டர் சரங்களை மீண்டும் செய்கிறது. நீங்கள் ஒரு சரத்தில் ஒரு எண்ணைச் சேர்க்க முயற்சித்தால், அது ஒரு சரமாக மாற்றப்படும். கூடுதலாக, பவர்ஷெல் மொழியில் பல ஒப்பீட்டு ஆபரேட்டர்கள் உள்ளன, அவை இரண்டு மதிப்புகளுக்கு இடையே உள்ள பொருத்தத்தை சரிபார்த்து பூலியன் உண்மை அல்லது தவறு:

ஆபரேட்டர்

விளக்கம்

குறியீடு உதாரணம்

- சம

சமம் / சமம் (மற்ற மொழிகளில் = அல்லது == போன்றது)

$ சோதனை = 100
$test -eq 123 

-நே

சமமாக இல்லை / சமமாக இல்லை ( <> அல்லது != போன்றது)

$ சோதனை = 100
$test -ne 123   

-ஜிடி

/ அதிகமாக (அனலாக்>)

$ சோதனை = 100
$test -gt 123

-ஜி

பெரியதை விட அல்லது சமம் / பெரியதை விட அல்லது சமம் (>= போன்றது)

$ சோதனை = 100
$test -ge 123

-எல்.டி

குறைவாக / குறைவாக (ஒத்த <)

$ சோதனை = 100
$test -lt 123  

-லே

குறைவாக அல்லது சமமாக / குறைவாகவோ அல்லது சமமாகவோ (<= போன்றது)

$ சோதனை = 100
$test -le 123

எடுத்துக்காட்டாக, வைல்டு கார்டின் அடிப்படையில் சரங்களை ஒப்பிட்டுப் பார்க்க அல்லது பேட்டர்னைப் பொருத்த வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்த உங்களை அனுமதிக்கும் இதே போன்ற பிற ஆபரேட்டர்கள் உள்ளன. அடுத்த கட்டுரைகளில் அவற்றை விரிவாகப் பார்ப்போம். <, > மற்றும் = குறியீடுகள் மற்ற நோக்கங்களுக்காகப் பயன்படுத்தப்படுவதால் ஒப்பிடுவதற்குப் பயன்படுத்தப்படவில்லை.

பணி ஆபரேட்டர்கள்

மிகவும் பொதுவான = ஆபரேட்டருக்கு கூடுதலாக, பிற அசைன்மென்ட் ஆபரேட்டர்கள் உள்ளனர்: +=, -=, *=, /= மற்றும் %=. அவர்கள் பணிக்கு முன் மதிப்பை மாற்றுகிறார்கள். ஒரு மாறியின் மதிப்பை அதிகரிக்கும் அல்லது குறைக்கும் unary ஆபரேட்டர்கள் ++ மற்றும் - இதேபோல் செயல்படுகின்றன - அவை அசைன்மென்ட் ஆபரேட்டர்களுக்கும் பொருந்தும்.

தருக்க ஆபரேட்டர்கள்

சிக்கலான நிலைமைகளை விவரிக்க ஒப்பீடு மட்டும் போதாது. ஆபரேட்டர்களைப் பயன்படுத்தி நீங்கள் எந்த தர்க்கரீதியான வெளிப்பாடுகளையும் எழுதலாம்: -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 или значение не определено"}
}

சுழற்சிகள்

பவர்ஷெல் பல வகையான சுழல்களைக் கொண்டுள்ளது: WHILE, 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
}

அணிவரிசைகள்

பவர்ஷெல் மாறிகள் ஒற்றை பொருள்களை (எண், சரம், முதலியன) மட்டுமல்ல, பலவற்றையும் சேமிக்கின்றன. அத்தகைய மாறிகளில் எளிமையான வகை வரிசைகள். ஒரு வரிசையானது பல கூறுகளைக் கொண்டிருக்கலாம், ஒரு உறுப்பு அல்லது காலியாக இருக்கலாம், அதாவது. கூறுகள் இல்லை. இது @() ஆபரேட்டரைப் பயன்படுத்தி அறிவிக்கப்படுகிறது, இது அடுத்த கட்டுரையில் நமக்குத் தேவைப்படும் - ஒரு வரிசையில் மற்ற வரிசைகளைச் சேர்ப்பது (பல பரிமாண வரிசைகளை உருவாக்குதல்), வரிசைகளை ஒரு வாதமாக செயல்பாடுகளுக்கு அனுப்புவது மற்றும் இதே போன்ற பணிகள் மிகவும் முக்கியமானது:

$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 திரும்பப் பெறப்படும்.

பவர்ஷெல்லில், வரிசைகள் பல்வேறு வகையான கூறுகளைக் கொண்டிருக்கலாம் அல்லது வலுவாக தட்டச்சு செய்யலாம்:

$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.

செயல்பாடுகளை

செயல்பாடுகள் உட்பட, செயல்முறை நிரலாக்கத்திற்கு தேவையான அனைத்தையும் பவர்ஷெல் கொண்டுள்ளது. அவற்றை விவரிக்க, செயல்பாடு என்ற சொல் பயன்படுத்தப்படுகிறது, அதன் பிறகு நீங்கள் செயல்பாட்டின் பெயரையும் ஆபரேட்டர் அடைப்புக்குறிக்குள் இணைக்கப்பட்ட உடலையும் குறிப்பிட வேண்டும். நீங்கள் செயல்பாட்டிற்கு வாதங்களை அனுப்ப வேண்டும் என்றால், அடைப்புக்குறிக்குள் பெயருக்குப் பிறகு உடனடியாக அவற்றைக் குறிப்பிடலாம்.

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