🥇विंडोज पॉवरशेल म्हणजे काय आणि ते कशासह खाल्ले जाते? भाग २: प्रोग्रामिंग भाषेचा परिचय

ऐतिहासिकदृष्ट्या, युनिक्स सिस्टमवरील कमांड-लाइन युटिलिटीज विंडोजच्या तुलनेत चांगल्या प्रकारे विकसित केल्या गेल्या आहेत, परंतु नवीन सोल्यूशनच्या आगमनाने, परिस्थिती बदलली आहे.

पॉवरशेल एका अर्थ लावलेल्या, मल्टी-पॅराडाइम भाषेत स्क्रिप्ट केले जाऊ शकते ज्यामध्ये क्लासिक प्रक्रियात्मक, ऑब्जेक्ट-ओरिएंटेड आणि अगदी फंक्शनल प्रोग्रामिंगचे घटक आहेत: कंडिशनल ब्रँचिंग, लूप, व्हेरिएबल्स, अॅरे, हॅश टेबल, क्लासेस, एरर हँडलिंग, तसेच फंक्शन्स, cmdlets, आणि पाइपलाइन. मागील लेख वातावरणात काम करण्याच्या मूलभूत गोष्टींसाठी समर्पित होते आणि आता आम्ही वाचकांना प्रोग्रामरसाठी एक लहान मार्गदर्शक ऑफर करतो.

लेख:

टिप्पण्या
चल आणि त्यांचे प्रकार
सिस्टम व्हेरिएबल्स
व्याप्ती
पर्यावरण परिवर्तने (पर्यावरण)
अंकगणित आणि तुलना ऑपरेटर
असाइनमेंट ऑपरेटर
तार्किक ऑपरेटर
सशर्त उडी
सायकल
अॅरे
हॅश टेबल
कार्ये
प्रक्रिया करताना त्रुटी

तुम्ही कोणत्याही टेक्स्ट एडिटरमध्ये किंवा एकात्मिक विकास वातावरणाचा वापर करून कोड लिहू शकता - मायक्रोसॉफ्ट सर्व्हर ऑपरेटिंग सिस्टीमसह येणारा Windows PowerShell ISE घेणे हा सर्वात सोपा मार्ग आहे. हे फक्त बर्‍यापैकी जटिल स्क्रिप्टसाठी आवश्यक आहे: कमांडचे छोटे संच परस्पर क्रियाशीलपणे कार्यान्वित करणे सोपे आहे.

टिप्पण्या

टिप्पण्या वापरणे हे योग्य इंडेंटेशन आणि व्हाईटस्पेससह चांगल्या प्रोग्रामिंग शैलीचा भाग मानले जाते:

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

<# 

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

#>

चल आणि त्यांचे प्रकार

पॉवरशेलमधील व्हेरिएबल्सना ऑब्जेक्ट्स असे नाव दिले जाते. त्यांच्या नावांमध्ये अंडरस्कोर वर्ण, तसेच अक्षरे आणि संख्या समाविष्ट असू शकतात. $ चिन्ह नेहमी नावापूर्वी वापरले जाते आणि व्हेरिएबल घोषित करण्यासाठी, दुभाष्याला वैध नाव देणे पुरेसे आहे:

व्हेरिएबल सुरू करण्यासाठी (त्याला मूल्य नियुक्त करा), असाइनमेंट ऑपरेटर (प्रतीक =) वापरला जातो:

$test = 100

तुम्ही व्हेरिएबलचा प्रकार नाव किंवा मूल्यापूर्वी चौरस कंसात (कास्टिंग ऑपरेटर प्रकार) निर्दिष्ट करून घोषित करू शकता:

[int]$test = 100

$test = [int]100

हे समजून घेणे महत्त्वाचे आहे की PowerShell मधील व्हेरिएबल्स हे गुणधर्म आणि पद्धतींसह पूर्ण वाढीव वस्तू (वर्ग) आहेत ज्यांचे प्रकार .NET Core वर आधारित आहेत. आम्ही मुख्य यादी करतो:

प्रकार (.NET वर्ग)

वर्णन

कोड उदाहरण

[स्ट्रिंग] सिस्टम.स्ट्रिंग

युनिकोड स्ट्रिंग

$test = "चाचणी"
$test = 'चाचणी'

[char]सिस्टम.चार

युनिकोड वर्ण (16 बिट)

[char]$test = 'c'

[बूल] प्रणाली.बूलियन

बुलियन प्रकार (बुलियन खरे किंवा खोटे)

[bool]$test = $true

[int] System.Int32

बत्तीस बिट पूर्णांक (३२ बिट)

[int]$test = 123456789

[long] System.Int64

चौसष्ट बिट पूर्णांक (६४ बिट)

[long]$test = १२३४५६७८९१०

[एकल] प्रणाली.सिंगल

फ्लोटिंग पॉइंट क्रमांक 32 बिट लांब

[एकल]$test = 12345.6789

[दुहेरी]प्रणाली.दुहेरी

लांबीचा फ्लोटिंग पॉइंट क्रमांक ६४ बिट (८ बाइट)

[दुहेरी]$test = 123456789.101112

[दशांश]सिस्टम.दशांश

128-बिट फ्लोटिंग पॉइंट नंबर (d ने समाप्त करणे आवश्यक आहे)

[दशांश]$test = 12345.6789d

[DateTime]सिस्टम.DateTime

तारीख आणि वेळ

$test = GetDate

[अॅरे] सिस्टम.ऑब्जेक्ट[]

एक अ‍ॅरे ज्याचा घटक निर्देशांक 0 पासून सुरू होतो

$test_array = 1, 2, "चाचणी", 3, 4

[हॅशटेबल] सिस्टम.कलेक्शन्स.हॅशटेबल

हॅश टेबल्स हे नामांकित की सह सहयोगी अ‍ॅरे आहेत, तत्त्वानुसार तयार केले आहेत: @{key = "value"}

$test_hashtable = @{one="one"; two="दोन"; three="तीन"}

पॉवरशेल अंतर्निहित प्रकार रूपांतरणास समर्थन देते, त्याव्यतिरिक्त, व्हेरिएबलचा प्रकार फ्लायवर बदलला जाऊ शकतो (उदाहरणार्थ, असाइनमेंट ऑपरेटर वापरणे), जर ते जबरदस्तीने निर्दिष्ट केले नसेल - या प्रकरणात, दुभाषी त्रुटी देईल. तुम्ही 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 खालील अंकगणित ऑपरेटर प्रदान करते: + (अ‍ॅडिशन), - (वजाबाकी), * (गुणाकार), / (भागाकार), आणि % (मॉड्युलो किंवा मोड्युलो). अंकगणित अभिव्यक्तीचे परिणाम डावीकडून उजवीकडे ऑपरेशन्सच्या सामान्यतः स्वीकारल्या जाणार्‍या क्रमानुसार मूल्यमापन केले जातात आणि कंस अभिव्यक्तीचे भाग गट करण्यासाठी वापरले जातात. ऑपरेटरमधील मोकळ्या जागा दुर्लक्षित केल्या जातात, ते फक्त वाचणे सोपे करण्यासाठी वापरले जातात. + ऑपरेटर देखील एकत्र करतो आणि * ऑपरेटर स्ट्रिंगची पुनरावृत्ती करतो. तुम्ही स्ट्रिंगमध्ये संख्या जोडण्याचा प्रयत्न केल्यास, ते स्ट्रिंगमध्ये रूपांतरित केले जाईल. याव्यतिरिक्त, पॉवरशेल भाषेमध्ये अनेक तुलना ऑपरेटर आहेत जे दोन मूल्यांमधील जुळणी तपासतात आणि बुलियन खरे किंवा चुकीचे परत करतात:

ऑपरेटर

वर्णन

कोड उदाहरण

-eq

समान / समान (इतर भाषांमध्ये = किंवा == सारखे)

$test = 100
$test -eq 123

-ने

समान नाही / समान नाही (<> किंवा != सारखे)

$test = 100
$test -ne 123

-gt

पेक्षा मोठे / अधिक (एनालॉग >)

$test = 100
$test -gt १२३

-गे

पेक्षा मोठे किंवा समान / पेक्षा मोठे किंवा समान (>= सारखे)

$test = 100
$test -ge 123

-lt

पेक्षा कमी / कमी (< सारखे)

$test = 100
$test -lt 123

-ते

पेक्षा कमी किंवा समान / पेक्षा कमी किंवा समान (<= सारखे)

$test = 100
$test -le 123

असे इतर समान ऑपरेटर आहेत जे तुम्हाला उदाहरणार्थ, वाइल्डकार्डवर आधारित स्ट्रिंग्सची तुलना करण्यास किंवा पॅटर्नशी जुळण्यासाठी रेग्युलर एक्सप्रेशन्स वापरण्याची परवानगी देतात. आम्ही भविष्यातील लेखांमध्ये त्यांचा तपशीलवार समावेश करू. <, > आणि = ही चिन्हे तुलना करण्यासाठी वापरली जात नाहीत कारण ती इतर कारणांसाठी वापरली जातात.

असाइनमेंट ऑपरेटर

सर्वात सामान्य = ऑपरेटर व्यतिरिक्त, इतर असाइनमेंट ऑपरेटर आहेत: +=, -=, *=, /= आणि %=. असाइनमेंट करण्यापूर्वी ते मूल्य बदलतात. युनरी ऑपरेटर ++ आणि -, जे व्हेरिएबलचे मूल्य वाढवतात किंवा कमी करतात, त्याचप्रमाणे वागतात - ते असाइनमेंट ऑपरेटरना देखील लागू होतात.

तार्किक ऑपरेटर

जटिल परिस्थितीचे वर्णन करण्यासाठी केवळ तुलना करणे पुरेसे नाही. तुम्ही ऑपरेटर वापरून कोणतीही तार्किक अभिव्यक्ती लिहू शकता: -and, -or, -xor, -not आणि! .. ते इतर प्रोग्रामिंग भाषांप्रमाणे कार्य करतात, तर तुम्ही मूल्यांकनाचा क्रम निर्दिष्ट करण्यासाठी कंस वापरू शकता:

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

-not (123 -gt 321) 

!(123 -gt 321)

सशर्त उडी

पॉवरशेल मधील शाखा ऑपरेटर मानक आहेत: 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, DO WHILE, DO NTIL, FOR आणि FOREACH.

पूर्वस्थिती असलेला लूप कार्य करतो/जोपर्यंत ते सत्य आहे:

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

पोस्ट कंडिशनसह लूप किमान एकदा चालतील, कारण पुनरावृत्तीनंतर स्थिती तपासली जाते. त्याच वेळी, DO WHILE अट सत्य असताना कार्य करते आणि ती असत्य असताना कार्य करत नाही:

[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

हॅश टेबल

पॉवरशेल भाषेतील व्हेरिएबल्सचा आणखी एक मूळ प्रकार म्हणजे हॅश टेबल्स, ज्याला असोसिएटिव्ह अॅरे देखील म्हणतात. हॅशटेबल्स जेएसओएन ऑब्जेक्ट्ससारखेच असतात आणि ते की-व्हॅल्यूच्या आधारावर तयार केले जातात. सामान्य अॅरेच्या विपरीत, त्यांचे घटक नामांकित की द्वारे ऍक्सेस केले जातात, जे ऑब्जेक्टचे गुणधर्म आहेत (आपण इंडेक्स ऑपरेटर - स्क्वेअर ब्रॅकेट देखील वापरू शकता).

@ चिन्ह आणि ऑपरेटर कंस वापरून रिक्त हॅश टेबल घोषित केले जाते:

$test_hashtable = @{}

घोषित करताना, तुम्ही ताबडतोब की तयार करू शकता आणि त्यांना मूल्ये नियुक्त करू शकता:

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

हॅश टेबलमध्ये घटक जोडण्यासाठी, तुम्ही त्यामध्ये अद्याप अस्तित्वात नसलेली की नियुक्त केली पाहिजे किंवा Add () पद्धत वापरा. विद्यमान कीला असाइनमेंट केले असल्यास, त्याचे मूल्य बदलेल. हटवा() पद्धत हॅश टेबलमधून घटक काढून टाकण्यासाठी वापरली जाते.

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

या प्रकारचे व्हेरिएबल्स फंक्शन्स आणि cmdlets मध्ये वितर्क म्हणून पास केले जाऊ शकतात - पुढील लेखात आपण हे कसे केले जाते याचा अभ्यास करू, आणि आणखी एक समान प्रकार - 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

विंडोज पॉवरशेल म्हणजे काय आणि ते कशासह खाल्ले जाते? भाग 2: प्रोग्रामिंग भाषेचा परिचय