વિન્ડોઝ પાવરશેલ શું છે અને તે શેની સાથે ખવાય છે? ભાગ 2: પ્રોગ્રામિંગ ભાષાનો પરિચય

ઐતિહાસિક રીતે, યુનિક્સ સિસ્ટમ્સ પર કમાન્ડ-લાઇન યુટિલિટીઝ વિન્ડોઝ કરતાં વધુ સારી રીતે વિકસિત છે, પરંતુ નવા ઉકેલના આગમન સાથે, પરિસ્થિતિ બદલાઈ ગઈ છે.

પાવરશેલ તમને ક્લાસિક પ્રક્રિયાગત, ઑબ્જેક્ટ-ઓરિએન્ટેડ અને ફંક્શનલ પ્રોગ્રામિંગના ઘટકો સમાવે છે તે અર્થઘટન કરાયેલ, બહુ-પેરાડાઈમ ભાષામાં સ્ક્રિપ્ટો લખવાની મંજૂરી આપે છે: શરતી શાખા, લૂપ્સ, ચલો, એરે, હેશ કોષ્ટકો, વર્ગો, ભૂલ હેન્ડલિંગ, તેમજ કાર્યો, cmdlets અને પાઇપલાઇન્સ. અગાઉનો લેખ પર્યાવરણમાં કામ કરવાની મૂળભૂત બાબતોને સમર્પિત હતી, અને હવે અમે અમારા વાચકોને પ્રોગ્રામરો માટે એક નાની સંદર્ભ પુસ્તક ઓફર કરીએ છીએ.

ઑગ્લેવલેનિએ:

Комментарии
ચલો અને તેમના પ્રકારો
સિસ્ટમ ચલો
અવકાશ
પર્યાવરણીય ચલો
અંકગણિત અને સરખામણી ઓપરેટર્સ
સોંપણી ઓપરેટરો
લોજિકલ ઓપરેટરો
શરતી જમ્પ
સાયકલ
અરે
હેશ કોષ્ટકો
કાર્યો
પ્રક્રિયામાં ભૂલ

તમે કોઈપણ ટેક્સ્ટ એડિટરમાં કોડ લખી શકો છો અથવા સંકલિત વિકાસ પર્યાવરણનો ઉપયોગ કરી શકો છો - સૌથી સહેલો રસ્તો એ છે કે Windows PowerShell ISE લેવાનો જે Microsoft સર્વર ઑપરેટિંગ સિસ્ટમ્સ સાથે આવે છે. આ ફક્ત એકદમ જટિલ સ્ક્રિપ્ટો માટે જ જરૂરી છે: આદેશોના ટૂંકા સેટ્સ ઇન્ટરેક્ટિવ રીતે ચલાવવા માટે સરળ છે.

Комментарии

યોગ્ય ઇન્ડેન્ટેશન અને વ્હાઇટસ્પેસ સાથે ટિપ્પણીઓનો ઉપયોગ સારી પ્રોગ્રામિંગ શૈલીનો ભાગ માનવામાં આવે છે:

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

<# 

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

#>

ચલો અને તેમના પ્રકારો

પાવરશેલમાં વેરીએબલ્સને ઓબ્જેક્ટ નામ આપવામાં આવ્યું છે. તેમના નામોમાં અન્ડરસ્કોર અક્ષર, તેમજ અક્ષરો અને સંખ્યાઓ શામેલ હોઈ શકે છે. નામ હંમેશા $ ચિન્હથી આગળ આવે છે, અને ચલ જાહેર કરવા માટે, તમારે ફક્ત દુભાષિયાને માન્ય નામ પ્રદાન કરવાની જરૂર છે:

ચલ શરૂ કરવા માટે (તેને મૂલ્ય સોંપો), અસાઇનમેન્ટ ઓપરેટરનો ઉપયોગ કરો (= પ્રતીક):

$test = 100

તમે નામ અથવા મૂલ્યની પહેલા ચોરસ કૌંસ (ટાઈપ કાસ્ટ ઓપરેટર) માં તેનો પ્રકાર સૂચવીને ચલ જાહેર કરી શકો છો:

[int]$test = 100

$test = [int]100

તે સમજવું અગત્યનું છે કે PowerShell માં વેરીએબલ એ પ્રોપર્ટીઝ અને પદ્ધતિઓ સાથે સંપૂર્ણ સુવિધાયુક્ત ઑબ્જેક્ટ્સ (વર્ગો) છે, જેના પ્રકારો .NET કોરમાં જોવા મળે છે તેના પર આધારિત છે. ચાલો મુખ્યને સૂચિબદ્ધ કરીએ:

પ્રકાર (.NET વર્ગ)

વર્ણન

કોડ ઉદાહરણ

[સ્ટ્રિંગ] સિસ્ટમ.સ્ટ્રિંગ

યુનિકોડ સ્ટ્રિંગ 

$test = "પરીક્ષણ"
$test = 'ટેસ્ટ'

[char]સિસ્ટમ.ચાર

યુનિકોડ અક્ષર (16 બીટ)

[char]$test = 'c'

[બૂલ] સિસ્ટમ.બૂલિયન

બુલિયન પ્રકાર (બુલિયન મૂલ્ય સાચું કે ખોટું)

[bool]$test = $true

[int]સિસ્ટમ.Int32

બત્રીસ-બીટ પૂર્ણાંક (32 બિટ્સ)

[int]$ટેસ્ટ = 123456789

[long] System.Int64

ચોસઠ-બીટ પૂર્ણાંક (64 બિટ્સ)

[long]$test = 12345678910

[સિંગલ]સિસ્ટમ.સિંગલ

ફ્લોટિંગ પોઈન્ટ નંબર 32 બિટ્સ લાંબો

[સિંગલ]$ટેસ્ટ = 12345.6789

[ડબલ]સિસ્ટમ.ડબલ

ફ્લોટિંગ પોઈન્ટ નંબર 64 બિટ્સ લાંબો (8 બાઈટ્સ)

[ડબલ]$ટેસ્ટ = 123456789.101112

[દશાંશ] સિસ્ટમ.દશાંશ

ફ્લોટિંગ પોઈન્ટ નંબર 128 બિટ્સ લાંબો (અંતમાં d શામેલ હોવો જોઈએ)

[દશાંશ]$ટેસ્ટ = 12345.6789d

[DateTime] સિસ્ટમ.DateTime

તારીખ અને સમય 

$ટેસ્ટ = મેળવો-તારીખ

[એરે]સિસ્ટમ.ઓબ્જેક્ટ[]

એરે જેની એલિમેન્ટ ઇન્ડેક્સ 0 થી શરૂ થાય છે

$test_array = 1, 2, "ટેસ્ટ", 3, 4

[હેશટેબલ] સિસ્ટમ.સંગ્રહો.હેશટેબલ

હેશ કોષ્ટકો એ નામવાળી કી સાથે સહયોગી એરે છે, જે સિદ્ધાંત અનુસાર બનેલ છે: @{key = “value”}

$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

પર્યાવરણીય ચલો

PowerShell, Env: માંથી બીજી સ્યુડો-ડ્રાઇવ ઉપલબ્ધ છે, જેનો ઉપયોગ તમે પર્યાવરણ ચલોને ઍક્સેસ કરવા માટે કરી શકો છો. જ્યારે શેલ શરૂ થાય છે, ત્યારે તે પિતૃ પ્રક્રિયામાંથી નકલ કરવામાં આવે છે (એટલે ​​​​કે, વર્તમાન સત્રની શરૂઆત કરનાર પ્રોગ્રામમાંથી) અને સામાન્ય રીતે તેમના પ્રારંભિક મૂલ્યો નિયંત્રણ પેનલમાંના મૂલ્યો સાથે મેળ ખાય છે. પર્યાવરણ ચલો જોવા માટે, Get-ChildItem cmdlet અથવા તેના ઉપનામોનો ઉપયોગ કરો: ls અને dir.

dir Env:

આ ચલો એ બાઇટ્સનો ક્રમ છે (અથવા અક્ષરો, જો તમે પસંદ કરો છો), જેનું અર્થઘટન ફક્ત તેનો ઉપયોગ કરીને પ્રોગ્રામ પર આધારિત છે. *-પર્યાવરણ ચલો સાથેના ચલ cmdlets કામ કરતા નથી. તેમનો સંદર્ભ લેવા માટે, તમારે ડિસ્ક ઉપસર્ગનો ઉપયોગ કરવો પડશે:

$env:TEST = "Hello, World!"

અંકગણિત અને સરખામણી ઓપરેટર્સ

પાવરશેલ પાસે નીચેના અંકગણિત ઓપરેટરો છે: + (ઉમેર), - (બાદબાકી), * (ગુણાકાર), / (ભાગાકાર), અને % (મોડ્યુલો અથવા ભાગાકારનો બાકીનો ભાગ). અંકગણિત અભિવ્યક્તિના પરિણામનું મૂલ્યાંકન સામાન્ય રીતે સ્વીકૃત કામગીરીના ક્રમ અનુસાર ડાબેથી જમણે કરવામાં આવે છે, અને કૌંસનો ઉપયોગ અભિવ્યક્તિના ભાગોને જૂથ કરવા માટે થાય છે. ઓપરેટરો વચ્ચેની જગ્યાઓ અવગણવામાં આવે છે અને તેનો ઉપયોગ ફક્ત વસ્તુઓને વાંચવામાં સરળ બનાવવા માટે કરવામાં આવે છે. + ઓપરેટર પણ જોડાય છે, અને * ઓપરેટર શબ્દમાળાઓનું પુનરાવર્તન કરે છે. જો તમે શબ્દમાળામાં સંખ્યા ઉમેરવાનો પ્રયાસ કરો છો, તો તે શબ્દમાળામાં રૂપાંતરિત થશે. વધુમાં, પાવરશેલ પાસે ઘણા સરખામણી ઓપરેટર્સ છે જે બે મૂલ્યોની તુલના કરે છે અને બુલિયન સાચું કે ખોટું પરત કરે છે:

Ratorપરેટર

વર્ણન

કોડ ઉદાહરણ

-eq

સમાન / સમાન (અન્ય ભાષાઓમાં = અથવા == સમાન)

$ટેસ્ટ = 100
$ટેસ્ટ -eq 123 

-ને

સમાન નથી / સમાન નથી (<> અથવા !=ના સમાન)

$ટેસ્ટ = 100
$test -ne 123   

-જીટી

કરતાં વધુ / વધુ (એનાલોગ >)

$ટેસ્ટ = 100
$test -gt 123

-જીઇ

તેના કરતા મોટો અથવા સમાન / તેનાથી મોટો અથવા સમાન (એનાલોગ >=)

$ટેસ્ટ = 100
$test -ge 123

-lt

કરતાં ઓછું / ઓછું (એનાલોગ <)

$ટેસ્ટ = 100
$test -lt 123  

-લે

કરતાં ઓછા અથવા સમાન / તેનાથી ઓછા અથવા સમાન (એનાલોગ <=)

$ટેસ્ટ = 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
}

ફોરેચ લૂપમાં, એરે અથવા કલેક્શન (હેશ ટેબલ) ના તત્વો દ્વારા પુનરાવર્તિત થાય છે:

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

Ratorપરેટર .. (બે બિંદુઓ - શ્રેણી ઓપરેટર) સ્પષ્ટ કરેલ ઉપલા અને નીચલા બાઉન્ડ પર પૂર્ણાંકોની શ્રેણી આપે છે. ઉદાહરણ તરીકે, અભિવ્યક્તિ 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"}

હેશ ટેબલમાં તત્વ ઉમેરવા માટે, તમારે તેને એક કી સોંપવાની જરૂર છે જે હજી અસ્તિત્વમાં નથી અથવા Add() પદ્ધતિનો ઉપયોગ કરો. જો હાલની કીને સોંપણી કરવામાં આવે છે, તો તેનું મૂલ્ય બદલાશે. હેશ ટેબલમાંથી તત્વ દૂર કરવા માટે, Remove() પદ્ધતિનો ઉપયોગ કરો.

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

નોંધ કરો કે ફંક્શનના મુખ્ય ભાગમાં તમે તેને કૉલ કરવામાં આવે તે પહેલાં જાહેર કરાયેલ કોઈપણ ચલોનો ઉપયોગ કરી શકો છો, અને પાવરશેલમાં કૉલિંગ ફંક્શન્સ અસામાન્ય લાગે છે: દલીલો (જો કોઈ હોય તો) કૌંસમાં બંધ નથી અને ખાલી જગ્યાઓ દ્વારા અલગ કરવામાં આવી છે.

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