Windows PowerShell क्या है और इसे किसके साथ खाया जाता है? भाग 2: प्रोग्रामिंग भाषा का परिचय

ऐतिहासिक रूप से, यूनिक्स सिस्टम पर कमांड-लाइन उपयोगिताएँ विंडोज़ की तुलना में बेहतर विकसित हैं, लेकिन एक नए समाधान के आगमन के साथ, स्थिति बदल गई है।

पॉवरशेल को एक व्याख्या की गई, बहु-प्रतिमान भाषा में स्क्रिप्ट किया जा सकता है जिसमें क्लासिक प्रक्रियात्मक, ऑब्जेक्ट-ओरिएंटेड और यहां तक ​​कि कार्यात्मक प्रोग्रामिंग के तत्व हैं: सशर्त शाखा, लूप, चर, सरणी, हैश टेबल, कक्षाएं, त्रुटि प्रबंधन, साथ ही फ़ंक्शन, सीएमडीलेट्स, और पाइपलाइन। पिछला लेख पर्यावरण में काम करने की बुनियादी बातों के लिए समर्पित था, और अब हम अपने पाठकों को प्रोग्रामर्स के लिए एक छोटी संदर्भ पुस्तक प्रदान करते हैं।

सामग्री की तालिका:

टिप्पणियाँ
चर और उनके प्रकार
सिस्टम चर
कार्यक्षेत्र
पर्यावरण चर (पर्यावरण)
अंकगणित और तुलना ऑपरेटर
असाइनमेंट ऑपरेटर
लॉजिकल ऑपरेटर्स
सशर्त छलांग
चक्र
सरणियों
हैश टेबल
कार्य
प्रसंस्करण में त्रुटि

आप किसी भी टेक्स्ट एडिटर में या एकीकृत विकास वातावरण का उपयोग करके कोड लिख सकते हैं - सबसे आसान तरीका विंडोज पावरशेल आईएसई लेना है जो माइक्रोसॉफ्ट सर्वर ऑपरेटिंग सिस्टम के साथ आता है। यह केवल काफी जटिल स्क्रिप्ट के लिए आवश्यक है: कमांड के छोटे सेट को अंतःक्रियात्मक रूप से निष्पादित करना आसान होता है।

टिप्पणियाँ

उचित इंडेंटेशन और रिक्त स्थान के साथ-साथ टिप्पणियों का उपयोग करना अच्छी प्रोग्रामिंग शैली का हिस्सा माना जाता है:

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

<# 

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

#>

चर और उनके प्रकार

PowerShell में वेरिएबल्स को ऑब्जेक्ट नाम दिया गया है। उनके नामों में अंडरस्कोर वर्ण, साथ ही अक्षर और संख्याएं शामिल हो सकती हैं। $ प्रतीक का उपयोग हमेशा नाम से पहले किया जाता है, और एक चर घोषित करने के लिए, दुभाषिया को एक वैध नाम देना पर्याप्त है:

किसी वेरिएबल को प्रारंभ करने (उसे एक मान निर्दिष्ट करने) के लिए, असाइनमेंट ऑपरेटर (प्रतीक =) का उपयोग किया जाता है:

$test = 100

आप नाम या मान से पहले वर्गाकार कोष्ठक (टाइप कास्टिंग ऑपरेटर) में इसके प्रकार को निर्दिष्ट करके एक चर घोषित कर सकते हैं:

[int]$test = 100

$test = [int]100

यह समझना महत्वपूर्ण है कि PowerShell में वेरिएबल गुणों और विधियों के साथ पूर्ण ऑब्जेक्ट (वर्ग) हैं जिनके प्रकार .NET कोर पर आधारित होते हैं। हम मुख्य सूचीबद्ध करते हैं:

प्रकार (.NET क्लास)

विवरण

कोड उदाहरण

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

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

$ परीक्षण = "परीक्षण"
$ परीक्षण = 'परीक्षण'

[चार]प्रणाली.चार

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

[चार]$परीक्षण = 'सी'

[बूल] सिस्टम.बूलियन

बूलियन प्रकार (बूलियन सही या गलत)

[बूल]$परीक्षण = $सत्य

[int] System.Int32

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

[int]$परीक्षण = 123456789

[लंबा] System.Int64

चौसठ बिट पूर्णांक (64 बिट)

[लंबा]$परीक्षण = 12345678910

[एकल] सिस्टम.एकल

फ़्लोटिंग पॉइंट नंबर 32 बिट लंबा

[एकल]$परीक्षण = 12345.6789

[डबल] सिस्टम। डबल

लंबाई की फ़्लोटिंग पॉइंट संख्या 64 बिट्स (8 बाइट्स)

[डबल]$टेस्ट = 123456789.101112

[दशमलव]प्रणाली.दशमलव

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

[दशमलव]$परीक्षण = 12345.6789डी

[दिनांकसमय]प्रणाली.दिनांकसमय

दिनांक और समय 

$ परीक्षण = GetDate

[सरणी] सिस्टम.ऑब्जेक्ट[]

एक सरणी जिसका तत्व सूचकांक 0 से शुरू होता है

$test_array = 1, 2, "परीक्षण", 3, 4

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

हैश टेबल नामित कुंजियों के साथ सहयोगी सरणी हैं, जो सिद्धांत के अनुसार बनाई गई हैं: @{key = "value"}

$test_hashtable = @{one='one'; दो='दो'; तीन='तीन'}

पॉवरशेल अंतर्निहित प्रकार के रूपांतरण का समर्थन करता है, इसके अलावा, एक चर के प्रकार को तुरंत बदला जा सकता है (उदाहरण के लिए, असाइनमेंट ऑपरेटर का उपयोग करके), यदि इसे जबरन निर्दिष्ट नहीं किया गया है - इस मामले में, दुभाषिया एक त्रुटि देगा। आप GetType() विधि को कॉल करके पिछले उदाहरण से वेरिएबल का प्रकार निर्धारित कर सकते हैं:

$test.GetType().FullName

चरों में हेर-फेर करने के लिए कई cmdlet हैं। उनकी सूची सुविधाजनक रूप में कमांड का उपयोग करके प्रदर्शित की जाती है:

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

घोषित चर और उनके मान देखने के लिए, आप एक विशेष cmdlet का उपयोग कर सकते हैं:

Get-Variable | more

यह विधि अत्यधिक बोझिल लगती है, ऑपरेटरों के माध्यम से या सीधे उनके गुणों और विधियों तक पहुंच कर चर के साथ काम करना अधिक सुविधाजनक है। हालाँकि, cmdlet को अस्तित्व में रहने का अधिकार है क्योंकि वे आपको कुछ अतिरिक्त पैरामीटर सेट करने की अनुमति देते हैं। यह समझना महत्वपूर्ण है कि उपयोगकर्ता चर केवल वर्तमान सत्र के भीतर ही परिभाषित किए गए हैं। जब कंसोल बंद हो जाता है या स्क्रिप्ट समाप्त हो जाती है, तो उन्हें हटा दिया जाता है।

सिस्टम चर

उपयोगकर्ता द्वारा घोषित किए गए चर के अलावा, अंतर्निहित (सिस्टम) चर भी हैं जो वर्तमान सत्र समाप्त होने के बाद हटाए नहीं जाते हैं। उन्हें दो प्रकारों में विभाजित किया गया है, जबकि PowerShell स्थिति डेटा स्वचालित चर में संग्रहीत किया जाता है जिन्हें अपने आप मनमाना मान निर्दिष्ट नहीं किया जा सकता है। इनमें शामिल हैं, उदाहरण के लिए, $PWD:

$PWD.Path

उपयोगकर्ता की प्राथमिकताओं को संग्रहीत करने के लिए वरीयता चर की आवश्यकता होती है, जिसके मानों को बदला जा सकता है। उदाहरण के लिए, $ErrorActionPreference का उपयोग करके, गैर-घातक त्रुटियों की घटना पर कमांड दुभाषिया की प्रतिक्रिया सेट की जाती है।

घोषित वेरिएबल्स तक पहुंचने के लिए ऑपरेटरों और सीएमडीलेट्स के अलावा, एक वेरिएबल है: छद्म-संचायक। आप अन्य ड्राइव के अनुरूप इसके साथ काम कर सकते हैं, और इस मामले में चर फ़ाइल सिस्टम ऑब्जेक्ट से मिलते जुलते हैं:

Get-ChildItem Variable: | more

या

ls Variable: | more

कार्यक्षेत्र

PowerShell में वेरिएबल्स के लिए स्कोप (स्कोप) की अवधारणा है। वैश्विक दायरे (ग्लोबल) की कार्रवाई पूरे वर्तमान सत्र पर लागू होती है - इसमें, उदाहरण के लिए, सिस्टम चर शामिल हैं। स्थानीय (स्थानीय) चर केवल उस दायरे में उपलब्ध हैं जहां उन्हें परिभाषित किया गया था: किसी फ़ंक्शन के अंदर कहें। स्क्रिप्ट (स्क्रिप्ट) के दायरे की अवधारणा भी है, लेकिन स्क्रिप्ट कमांड के लिए, यह अनिवार्य रूप से स्थानीय है। डिफ़ॉल्ट रूप से, वेरिएबल घोषित करते समय, उन्हें एक स्थानीय दायरा दिया जाता है, और इसे बदलने के लिए, आपको एक विशेष निर्माण की आवश्यकता होती है जैसे: $ग्लोबल: वेरिएबल = मान।

उदाहरण के लिए, इस तरह:

$Global:test = 100

पर्यावरण चर (पर्यावरण)

एक अन्य छद्म ड्राइव, Env:, PowerShell से उपलब्ध है और इसका उपयोग पर्यावरण चर तक पहुंचने के लिए किया जा सकता है। जब शेल प्रारंभ होता है, तो उन्हें मूल प्रक्रिया से कॉपी किया जाता है (अर्थात, उस प्रोग्राम से जिसने वर्तमान सत्र शुरू किया है) और आमतौर पर उनके प्रारंभिक मान नियंत्रण कक्ष के मानों के समान होते हैं। पर्यावरण चर देखने के लिए, Get-ChildItem cmdlet या उसके उपनाम (उपनाम) का उपयोग करें: ls और dir।

dir Env:

ये चर बाइट्स (या यदि आप चाहें तो वर्ण) के अनुक्रम हैं, जिनकी व्याख्या केवल उनका उपयोग करने वाले प्रोग्राम पर निर्भर करती है। *-वेरिएबल सीएमडीलेट पर्यावरण चर के साथ काम नहीं करते हैं। उन तक पहुंचने के लिए, आपको ड्राइव उपसर्ग का उपयोग करना होगा:

$env:TEST = "Hello, World!"

अंकगणित और तुलना ऑपरेटर

पॉवरशेल निम्नलिखित अंकगणितीय ऑपरेटर प्रदान करता है: + (जोड़), - (घटाव), * (गुणा), / (विभाजन), और % (मॉड्यूलो या मॉड्यूलो)। अंकगणितीय अभिव्यक्ति के परिणाम का मूल्यांकन संचालन के आम तौर पर स्वीकृत क्रम के अनुसार बाएं से दाएं किया जाता है, और अभिव्यक्ति के कुछ हिस्सों को समूहीकृत करने के लिए कोष्ठक का उपयोग किया जाता है। ऑपरेटरों के बीच रिक्त स्थान को नजरअंदाज कर दिया जाता है, उनका उपयोग केवल समझने में आसानी के लिए किया जाता है। + ऑपरेटर भी संयोजित होता है, और * ऑपरेटर स्ट्रिंग्स को दोहराता है। यदि आप किसी स्ट्रिंग में कोई संख्या जोड़ने का प्रयास करते हैं, तो यह एक स्ट्रिंग में परिवर्तित हो जाएगी। इसके अलावा, PowerShell में कई तुलना ऑपरेटर हैं जो दो मानों के बीच मिलान का परीक्षण करते हैं और बूलियन सही या गलत लौटाते हैं:

ऑपरेटर

विवरण

कोड उदाहरण

-ईक्यू

बराबर/बराबर (अन्य भाषाओं में = या == के समान)

$ परीक्षण = 100
$परीक्षण -eq 123 

-ने

बराबर नहीं / बराबर नहीं (<> या != के समान)

$ परीक्षण = 100
$परीक्षण -न 123   

-gt

इससे अधिक / अधिक (एनालॉग>)

$ परीक्षण = 100
$परीक्षण -gt 123

-देना

इससे अधिक या इसके बराबर / इससे अधिक या इसके बराबर (>= के समान)

$ परीक्षण = 100
$टेस्ट-जीई 123

-एलटीई

इससे कम / कम (<के समान)

$ परीक्षण = 100
$परीक्षण -lt 123  

-इस

इससे कम या बराबर / इससे कम या बराबर (<= के समान)

$ परीक्षण = 100
$परीक्षण -ले 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 UNTIL, FOR, और FOREACH।

पूर्व शर्त वाला एक लूप तब तक काम करता है जब तक यह सत्य है:

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

पोस्टकंडीशन वाले लूप कम से कम एक बार चलेंगे, क्योंकि पुनरावृत्ति के बाद स्थिति की जाँच की जाती है। उसी समय, DO WHIL तब तक काम करता है जब तक कि स्थिति सत्य न हो, और DO जब तक कि यह तब तक काम न करता रहे जब तक कि यह गलत न हो:

[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 लूप की पुनरावृत्तियों की संख्या पहले से ज्ञात होती है:

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"}

हैश तालिका में एक तत्व जोड़ने के लिए, आपको एक कुंजी निर्दिष्ट करनी होगी जो अभी तक मौजूद नहीं है, या ऐड () विधि का उपयोग करें। यदि किसी मौजूदा कुंजी को असाइनमेंट दिया जाता है, तो उसका मान बदल जाएगा। हैश तालिका से किसी तत्व को हटाने के लिए रिमूव() विधि का उपयोग किया जाता है।

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

इस प्रकार के वेरिएबल्स को फ़ंक्शंस और सीएमडीलेट्स के तर्क के रूप में पारित किया जा सकता है - अगले लेख में हम अध्ययन करेंगे कि यह कैसे किया जाता है, और एक अन्य समान प्रकार - PSCustomObject पर भी विचार करें।

कार्य

पॉवरशेल में वह सब कुछ है जो आपको प्रक्रियात्मक प्रोग्रामिंग के लिए चाहिए, जिसमें फ़ंक्शंस भी शामिल हैं। उनका वर्णन करने के लिए, फ़ंक्शन शब्द Function का उपयोग किया जाता है, जिसके बाद आपको ऑपरेटर ब्रैकेट में संलग्न फ़ंक्शन और बॉडी का नाम निर्दिष्ट करने की आवश्यकता होती है। यदि आपको फ़ंक्शन में तर्क पारित करने की आवश्यकता है, तो आप उन्हें कोष्ठक में नाम के तुरंत बाद निर्दिष्ट कर सकते हैं।

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

फ़ंक्शन हमेशा एक परिणाम देता है - यह उसके सभी कथनों के परिणामों की एक सरणी है, यदि एक से अधिक हैं। यदि केवल एक कथन है, तो संबंधित प्रकार का एकमात्र मान लौटाया जाता है। रिटर्न $वैल्यू निर्माण परिणाम सरणी में मान $वैल्यू के साथ एक तत्व जोड़ता है और कथन सूची के निष्पादन को रोकता है, और खाली फ़ंक्शन $null लौटाता है।

उदाहरण के लिए, आइए किसी संख्या का वर्ग करने के लिए एक फ़ंक्शन बनाएं:

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

ध्यान दें कि किसी फ़ंक्शन के मुख्य भाग में, आप इसे कॉल करने से पहले घोषित किए गए किसी भी वेरिएबल का उपयोग कर सकते हैं, और पावरशेल में फ़ंक्शन को कॉल करना असामान्य लग सकता है: तर्क (यदि कोई हो) कोष्ठक में संलग्न नहीं हैं और रिक्त स्थान से अलग किए गए हैं।

sqr 2

या तो:

sqr -number 2

तर्क पारित करने के तरीके के कारण, फ़ंक्शन को कभी-कभी कोष्ठक में संलग्न करने की आवश्यकता होती है:

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

किसी फ़ंक्शन का वर्णन करते समय, आप तर्कों को डिफ़ॉल्ट मान निर्दिष्ट कर सकते हैं:

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

फ़ंक्शन तर्कों का वर्णन करने के लिए एक और वाक्यविन्यास है, इसके अलावा, पैरामीटर को पाइपलाइन से पढ़ा जा सकता है - यह सब अगले लेख में काम आएगा, जब हम निर्यात किए गए मॉड्यूल को देखेंगे और अपने स्वयं के सीएमडीलेट बना रहे होंगे।

प्रसंस्करण में त्रुटि

PowerShell में अपवादों को संभालने के लिए एक Try...Catch...Finally तंत्र है। ट्राई ब्लॉक में वह कोड होता है जिसमें त्रुटि हो सकती है, और कैच ब्लॉक में उसका हैंडलर होता है। यदि कोई त्रुटि नहीं थी, तो इसे निष्पादित नहीं किया जाता है। किसी त्रुटि की घटना की परवाह किए बिना, अंत में ब्लॉक को ट्राई ब्लॉक के बाद निष्पादित किया जाता है, और विभिन्न प्रकार के अपवादों के लिए कई कैच ब्लॉक हो सकते हैं। अपवाद स्वयं एक अघोषित डिफ़ॉल्ट चर ($_) में लिखा गया है और इसे आसानी से पुनर्प्राप्त किया जा सकता है। नीचे दिए गए उदाहरण में, हम अमान्य मान दर्ज करने के विरुद्ध सुरक्षा लागू करते हैं:

try {

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

} catch {

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

}

यह पॉवरशेल भाषा में प्रोग्रामिंग की बुनियादी बातों की समीक्षा को समाप्त करता है। निम्नलिखित लेखों में, हम विभिन्न प्रकार के चर, संग्रह, नियमित अभिव्यक्ति, फ़ंक्शन बनाने, मॉड्यूल और कस्टम सीएमडीलेट के साथ-साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के साथ काम करने के बारे में अधिक विस्तार से अध्ययन करेंगे।

स्रोत: www.habr.com