ਵਿੰਡੋਜ਼ ਪਾਵਰਸ਼ੇਲ ਕੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਸ ਨਾਲ ਖਾਧਾ ਜਾਂਦਾ ਹੈ? ਭਾਗ 2: ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਾਲ ਜਾਣ-ਪਛਾਣ

ਇਤਿਹਾਸਕ ਤੌਰ 'ਤੇ, ਯੂਨਿਕਸ ਸਿਸਟਮਾਂ 'ਤੇ ਕਮਾਂਡ-ਲਾਈਨ ਉਪਯੋਗਤਾਵਾਂ ਵਿੰਡੋਜ਼ ਨਾਲੋਂ ਬਿਹਤਰ ਵਿਕਸਤ ਹੁੰਦੀਆਂ ਹਨ, ਪਰ ਇੱਕ ਨਵੇਂ ਹੱਲ ਦੇ ਆਉਣ ਨਾਲ, ਸਥਿਤੀ ਬਦਲ ਗਈ ਹੈ।

PowerShell ਨੂੰ ਇੱਕ ਵਿਆਖਿਆ ਕੀਤੀ, ਬਹੁ-ਪੈਰਾਡਾਈਮ ਭਾਸ਼ਾ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਕਲਾਸਿਕ ਪ੍ਰੋਸੀਜਰਲ, ਆਬਜੈਕਟ-ਓਰੀਐਂਟਿਡ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਫੰਕਸ਼ਨਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਤੱਤ ਵੀ ਹਨ: ਕੰਡੀਸ਼ਨਲ ਬ੍ਰਾਂਚਿੰਗ, ਲੂਪਸ, ਵੇਰੀਏਬਲ, ਐਰੇ, ਹੈਸ਼ ਟੇਬਲ, ਕਲਾਸਾਂ, ਐਰਰ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਨਾਲ ਹੀ ਫੰਕਸ਼ਨ, cmdlets, ਅਤੇ ਪਾਈਪਲਾਈਨਾਂ। ਪਿਛਲਾ ਲੇਖ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਨੂੰ ਸਮਰਪਿਤ ਸੀ, ਅਤੇ ਹੁਣ ਅਸੀਂ ਆਪਣੇ ਪਾਠਕਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮਰਾਂ ਲਈ ਇੱਕ ਛੋਟੀ ਹਵਾਲਾ ਪੁਸਤਕ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ।

ਵਿਸ਼ਾ - ਸੂਚੀ:

Comments
ਵੇਰੀਏਬਲ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਕਿਸਮਾਂ
ਸਿਸਟਮ ਵੇਰੀਏਬਲ
ਦਾਇਰੇ
ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ (ਵਾਤਾਵਰਨ)
ਅੰਕਗਣਿਤ ਅਤੇ ਤੁਲਨਾ ਆਪਰੇਟਰ
ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ
ਲਾਜ਼ੀਕਲ ਆਪਰੇਟਰ
ਸ਼ਰਤੀਆ ਛਾਲ
ਸਾਈਕਲ
ਐਰੇ
ਹੈਸ਼ ਟੇਬਲ
ਫੰਕਸ਼ਨ
ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਤਰੁੱਟੀ

ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਟੈਕਸਟ ਐਡੀਟਰ ਵਿੱਚ ਜਾਂ ਇੱਕ ਏਕੀਕ੍ਰਿਤ ਵਿਕਾਸ ਵਾਤਾਵਰਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹੋ - ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਹੈ Windows PowerShell ISE ਲੈਣਾ ਜੋ Microsoft ਸਰਵਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਨਾਲ ਆਉਂਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਕਾਫ਼ੀ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ: ਕਮਾਂਡਾਂ ਦੇ ਛੋਟੇ ਸੈੱਟ ਇੰਟਰਐਕਟਿਵ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਣਾ ਆਸਾਨ ਹਨ।

Comments

ਟਿੱਪਣੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਹੀ ਇੰਡੈਂਟੇਸ਼ਨ ਅਤੇ ਵ੍ਹਾਈਟਸਪੇਸ ਦੇ ਨਾਲ ਚੰਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸ਼ੈਲੀ ਦਾ ਹਿੱਸਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ:

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

<# 

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

#>

ਵੇਰੀਏਬਲ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਕਿਸਮਾਂ

PowerShell ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਆਬਜੈਕਟ ਨਾਮ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਉਹਨਾਂ ਦੇ ਨਾਵਾਂ ਵਿੱਚ ਅੰਡਰਸਕੋਰ ਅੱਖਰ, ਨਾਲ ਹੀ ਅੱਖਰ ਅਤੇ ਨੰਬਰ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ। $ ਚਿੰਨ੍ਹ ਹਮੇਸ਼ਾਂ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ, ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਇੱਕ ਵੈਧ ਨਾਮ ਦੇਣਾ ਕਾਫ਼ੀ ਹੈ:

ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ (ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰੋ), ਅਸਾਈਨਮੈਂਟ ਓਪਰੇਟਰ (ਪ੍ਰਤੀਕ =) ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:

$test = 100

ਤੁਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਨਾਮ ਜਾਂ ਮੁੱਲ ਤੋਂ ਪਹਿਲਾਂ ਵਰਗ ਬਰੈਕਟਾਂ (ਟਾਈਪ ਕਾਸਟਿੰਗ ਆਪਰੇਟਰ) ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਕੇ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ:

[int]$test = 100

$test = [int]100

ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ PowerShell ਵਿੱਚ ਵੇਰੀਏਬਲ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਧੀਆਂ ਦੇ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਦੀਆਂ ਵਸਤੂਆਂ (ਕਲਾਸਾਂ) ਹਨ ਜਿਨ੍ਹਾਂ ਦੀਆਂ ਕਿਸਮਾਂ .NET ਕੋਰ ਵਿੱਚ ਉਹਨਾਂ 'ਤੇ ਆਧਾਰਿਤ ਹਨ। ਅਸੀਂ ਮੁੱਖ ਦੀ ਸੂਚੀ ਦਿੰਦੇ ਹਾਂ:

ਕਿਸਮ (.NET ਕਲਾਸ)

ਵੇਰਵਾ

ਕੋਡ ਉਦਾਹਰਨ

[ਸਟ੍ਰਿੰਗ] ਸਿਸਟਮ।ਸਟ੍ਰਿੰਗ

ਯੂਨੀਕੋਡ ਸਤਰ 

$test = "ਟੈਸਟ"
$test = 'ਟੈਸਟ'

[char]ਸਿਸਟਮ।ਚਾਰ

ਯੂਨੀਕੋਡ ਅੱਖਰ (16 ਬਿੱਟ)

[char]$test = 'c'

[bool] ਸਿਸਟਮ।ਬੂਲੀਅਨ

ਬੂਲੀਅਨ ਕਿਸਮ (ਬੁਲੀਅਨ ਸੱਚ ਜਾਂ ਗਲਤ)

[bool]$ਟੈਸਟ = $ਸੱਚਾ

[int] System.Int32

ਬੱਤੀ ਬਿੱਟ ਪੂਰਨ ਅੰਕ (32 ਬਿੱਟ)

[int]$ਟੈਸਟ = 123456789

[long] System.Int64

ਚੌਹਠ ਬਿੱਟ ਪੂਰਨ ਅੰਕ (64 ਬਿੱਟ)

[ਲੰਬਾ]$ਟੈਸਟ = 12345678910

[ਸਿੰਗਲ] ਸਿਸਟਮ।ਸਿੰਗਲ

ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰ 32 ਬਿੱਟ ਲੰਬਾ

[ਸਿੰਗਲ] $ਟੈਸਟ = 12345.6789

[ਡਬਲ]ਸਿਸਟਮ।ਡਬਲ

ਲੰਬਾਈ 64 ਬਿੱਟ (8 ਬਾਈਟ) ਦਾ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰ

[ਡਬਲ]$ਟੈਸਟ = 123456789.101112

[ਦਸ਼ਮਲਵ] ਸਿਸਟਮ। ਦਸ਼ਮਲਵ

128-ਬਿੱਟ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰ (d ਨਾਲ ਖਤਮ ਹੋਣ ਲਈ ਲੋੜੀਂਦਾ)

[ਦਸ਼ਮਲਵ]$ਟੈਸਟ = 12345.6789d

[DateTime]ਸਿਸਟਮ।DateTime

дата ਅਤੇ время 

$ਟੈਸਟ = GetDate

[ਐਰੇ] ਸਿਸਟਮ। ਆਬਜੈਕਟ[]

ਇੱਕ ਐਰੇ ਜਿਸਦਾ ਤੱਤ ਸੂਚਕਾਂਕ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ

$test_array = 1, 2, "ਟੈਸਟ", 3, 4

[hashtable] System.collections.Hashtable

ਹੈਸ਼ ਟੇਬਲ ਨਾਮਕ ਕੁੰਜੀਆਂ ਦੇ ਨਾਲ ਐਸੋਸੀਏਟਿਵ ਐਰੇ ਹਨ, ਜੋ ਸਿਧਾਂਤ ਦੇ ਅਨੁਸਾਰ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ: @{key = "value"}

$test_hashtable = @{one="one"; two="ਦੋ"; three="ਤਿੰਨ"}

PowerShell ਅਪ੍ਰਤੱਖ ਕਿਸਮ ਦੇ ਪਰਿਵਰਤਨ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨੂੰ ਫਲਾਈ 'ਤੇ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਅਸਾਈਨਮੈਂਟ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ), ਜੇਕਰ ਇਹ ਜ਼ਬਰਦਸਤੀ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ - ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਦੁਭਾਸ਼ੀਏ ਇੱਕ ਗਲਤੀ ਦੇਵੇਗਾ। ਤੁਸੀਂ GetType() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਪਿਛਲੀ ਉਦਾਹਰਨ ਤੋਂ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ:

$test.GetType().FullName

ਵੇਰੀਏਬਲ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਬਹੁਤ ਸਾਰੇ cmdlets ਹਨ। ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਰੂਪ ਵਿੱਚ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੈ:

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

ਘੋਸ਼ਿਤ ਵੇਰੀਏਬਲ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਦੇਖਣ ਲਈ, ਤੁਸੀਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ cmdlet ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

Get-Variable | more

ਇਹ ਵਿਧੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੋਝਲ ਜਾਪਦੀ ਹੈ, ਓਪਰੇਟਰਾਂ ਦੁਆਰਾ ਜਾਂ ਉਹਨਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਤਰੀਕਿਆਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਐਕਸੈਸ ਕਰਕੇ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਹੈ। ਹਾਲਾਂਕਿ, cmdlets ਕੋਲ ਮੌਜੂਦ ਹੋਣ ਦਾ ਅਧਿਕਾਰ ਹੈ ਕਿਉਂਕਿ ਉਹ ਤੁਹਾਨੂੰ ਕੁਝ ਵਾਧੂ ਪੈਰਾਮੀਟਰ ਸੈੱਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਵੇਰੀਏਬਲ ਕੇਵਲ ਮੌਜੂਦਾ ਸੈਸ਼ਨ ਦੇ ਅੰਦਰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ. ਜਦੋਂ ਕੰਸੋਲ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ ਜਾਂ ਸਕ੍ਰਿਪਟ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਉਹ ਮਿਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

ਸਿਸਟਮ ਵੇਰੀਏਬਲ

ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਘੋਸ਼ਿਤ ਕੀਤੇ ਗਏ ਲੋਕਾਂ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਬਿਲਟ-ਇਨ (ਸਿਸਟਮ) ਵੇਰੀਏਬਲ ਹਨ ਜੋ ਮੌਜੂਦਾ ਸੈਸ਼ਨ ਦੇ ਖਤਮ ਹੋਣ ਤੋਂ ਬਾਅਦ ਨਹੀਂ ਮਿਟਾਏ ਜਾਂਦੇ ਹਨ। ਉਹਨਾਂ ਨੂੰ ਦੋ ਕਿਸਮਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ, ਜਦੋਂ ਕਿ PowerShell ਸਟੇਟ ਡੇਟਾ ਆਟੋਮੈਟਿਕ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਆਰਬਿਟਰੇਰੀ ਮੁੱਲ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਹਨਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ, ਉਦਾਹਰਨ ਲਈ, $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 ਹੇਠਾਂ ਦਿੱਤੇ ਅੰਕਗਣਿਤ ਓਪਰੇਟਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: + (ਜੋੜ), - (ਘਟਾਓ), * (ਗੁਣਾ), / (ਭਾਗ), ਅਤੇ % (ਮੋਡਿਊਲੋ ਜਾਂ ਮੋਡਿਊਲੋ)। ਇੱਕ ਅੰਕਗਣਿਤ ਸਮੀਕਰਨ ਦੇ ਨਤੀਜੇ ਦਾ ਮੁਲਾਂਕਣ ਆਮ ਤੌਰ 'ਤੇ ਪ੍ਰਵਾਨਿਤ ਕਾਰਵਾਈਆਂ ਦੇ ਕ੍ਰਮ ਦੇ ਅਨੁਸਾਰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਮੀਕਰਨ ਦੇ ਭਾਗਾਂ ਨੂੰ ਸਮੂਹ ਕਰਨ ਲਈ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਓਪਰੇਟਰਾਂ ਵਿਚਕਾਰ ਖਾਲੀ ਥਾਂਵਾਂ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਸਿਰਫ਼ ਇਸਨੂੰ ਪੜ੍ਹਨ ਲਈ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। + ਆਪਰੇਟਰ ਵੀ ਜੋੜਦਾ ਹੈ, ਅਤੇ * ਆਪਰੇਟਰ ਸਤਰ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਨੰਬਰ ਜੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲ ਜਾਵੇਗਾ। ਇਸ ਤੋਂ ਇਲਾਵਾ, PowerShell ਭਾਸ਼ਾ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਤੁਲਨਾਤਮਕ ਓਪਰੇਟਰ ਹਨ ਜੋ ਦੋ ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਮੇਲ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ ਅਤੇ ਬੁਲੀਅਨ ਸਹੀ ਜਾਂ ਗਲਤ ਵਾਪਸ ਕਰਦੇ ਹਨ:

ਓਪਰੇਟਰ

ਵੇਰਵਾ

ਕੋਡ ਉਦਾਹਰਨ

-eq

ਬਰਾਬਰ / ਬਰਾਬਰ (ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ = ਜਾਂ == ਦੇ ਸਮਾਨ)

$ਟੈਸਟ = 100
$ਟੈਸਟ -eq 123 

- ਹੈ

ਬਰਾਬਰ ਨਹੀਂ / ਬਰਾਬਰ ਨਹੀਂ (<> ਜਾਂ != ਦੇ ਸਮਾਨ)

$ਟੈਸਟ = 100
$test -ne 123   

-ਜੀ.ਟੀ

ਇਸ ਤੋਂ ਵੱਡਾ / ਹੋਰ (ਐਨਾਲਾਗ>)

$ਟੈਸਟ = 100
$test -gt 123

-ਜੀ

ਇਸ ਤੋਂ ਵੱਡਾ ਜਾਂ ਬਰਾਬਰ / ਇਸ ਤੋਂ ਵੱਡਾ ਜਾਂ ਬਰਾਬਰ (>= ਦੇ ਸਮਾਨ)

$ਟੈਸਟ = 100
$ਟੈਸਟ -ge 123

-ਲ.ਟੀ

ਘੱਟ / ਘੱਟ (< ਦੇ ਸਮਾਨ)

$ਟੈਸਟ = 100
$test -lt 123  

-ਲੇ

ਇਸ ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ / ਇਸ ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ (<= ਦੇ ਸਮਾਨ)

$ਟੈਸਟ = 100
$ਟੈਸਟ -le 123

ਹੋਰ ਸਮਾਨ ਓਪਰੇਟਰ ਹਨ ਜੋ ਤੁਹਾਨੂੰ, ਉਦਾਹਰਨ ਲਈ, ਵਾਈਲਡਕਾਰਡ 'ਤੇ ਆਧਾਰਿਤ ਸਤਰ ਦੀ ਤੁਲਨਾ ਕਰਨ ਜਾਂ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਅਸੀਂ ਭਵਿੱਖ ਦੇ ਲੇਖਾਂ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਕਵਰ ਕਰਾਂਗੇ। ਚਿੰਨ੍ਹ <, > ਅਤੇ = ਤੁਲਨਾ ਲਈ ਨਹੀਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਹੋਰ ਉਦੇਸ਼ਾਂ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ

ਸਭ ਤੋਂ ਆਮ = ਆਪਰੇਟਰ ਤੋਂ ਇਲਾਵਾ, ਹੋਰ ਅਸਾਈਨਮੈਂਟ ਓਪਰੇਟਰ ਹਨ: +=, -=, *=, /= ਅਤੇ %=। ਉਹ ਅਸਾਈਨਮੈਂਟ ਤੋਂ ਪਹਿਲਾਂ ਮੁੱਲ ਬਦਲਦੇ ਹਨ। ਯੂਨਰੀ ਓਪਰੇਟਰ ++ ਅਤੇ -, ਜੋ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਨੂੰ ਵਧਾਉਂਦੇ ਜਾਂ ਘਟਾਉਂਦੇ ਹਨ, ਉਸੇ ਤਰ੍ਹਾਂ ਦਾ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ - ਉਹ ਅਸਾਈਨਮੈਂਟ ਓਪਰੇਟਰਾਂ 'ਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।

ਲਾਜ਼ੀਕਲ ਆਪਰੇਟਰ

ਗੁੰਝਲਦਾਰ ਸਥਿਤੀਆਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਸਿਰਫ਼ ਤੁਲਨਾ ਹੀ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਈ ਵੀ ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨ ਲਿਖ ਸਕਦੇ ਹੋ: -and, -or, -xor, -not and! .. ਉਹ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਤੁਸੀਂ ਮੁਲਾਂਕਣ ਦੇ ਕ੍ਰਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

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

-not (123 -gt 321) 

!(123 -gt 321)

ਸ਼ਰਤੀਆ ਛਾਲ

PowerShell ਵਿੱਚ ਬ੍ਰਾਂਚ ਓਪਰੇਟਰ ਮਿਆਰੀ ਹਨ: IF(IF…ELSE, IF…ELSEIF…ELSE) ਅਤੇ ਸਵਿੱਚ। ਆਓ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਵੇਖੀਏ:

[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 ਵਿੱਚ ਲੂਪਸ ਦੀਆਂ ਕਈ ਕਿਸਮਾਂ ਹਨ: ਜਦੋਂ ਤੱਕ, ਜਦੋਂ ਤੱਕ ਕਰੋ, ਉਦੋਂ ਤੱਕ ਕਰੋ, FOR, ਅਤੇ FOREACH।

ਇੱਕ ਪੂਰਵ ਸ਼ਰਤ ਵਾਲਾ ਲੂਪ ਕੰਮ ਕਰਦਾ ਹੈ ਜੇਕਰ/ਜਦੋਂ ਤੱਕ ਇਹ ਸੱਚ ਹੈ:

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

ਪੋਸਟ-ਕੰਡੀਸ਼ਨ ਵਾਲੇ ਲੂਪਸ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਵਾਰ ਚੱਲਣਗੇ, ਕਿਉਂਕਿ ਦੁਹਰਾਓ ਤੋਂ ਬਾਅਦ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਦੇ ਨਾਲ ਹੀ, DO WHILE ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਸ਼ਰਤ ਸਹੀ ਹੈ, ਅਤੇ DO UNTI ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਇਹ ਗਲਤ ਹੈ:

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

ਐਰੇ

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

ਹੈਸ਼ ਟੇਬਲ

PowerShell ਭਾਸ਼ਾ ਵਿੱਚ ਇੱਕ ਹੋਰ ਬੁਨਿਆਦੀ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲ ਹੈਸ਼ ਟੇਬਲ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਐਸੋਸੀਏਟਿਵ ਐਰੇ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਹੈਸ਼ਟਬਲ JSON ਆਬਜੈਕਟਸ ਦੇ ਸਮਾਨ ਹਨ ਅਤੇ ਇੱਕ ਮੁੱਖ-ਮੁੱਲ ਦੇ ਆਧਾਰ 'ਤੇ ਬਣਾਏ ਗਏ ਹਨ। ਆਮ ਐਰੇ ਦੇ ਉਲਟ, ਉਹਨਾਂ ਦੇ ਤੱਤਾਂ ਨੂੰ ਨਾਮ ਵਾਲੀਆਂ ਕੁੰਜੀਆਂ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਆਬਜੈਕਟ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ (ਤੁਸੀਂ ਇੰਡੈਕਸ ਓਪਰੇਟਰ - ਵਰਗ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ)।

ਇੱਕ ਖਾਲੀ ਹੈਸ਼ ਟੇਬਲ @ ਚਿੰਨ੍ਹ ਅਤੇ ਆਪਰੇਟਰ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

$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 'ਤੇ ਵੀ ਵਿਚਾਰ ਕਰਾਂਗੇ।

ਫੰਕਸ਼ਨ

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

}

ਇਹ PowerShell ਭਾਸ਼ਾ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਦੀ ਸਮੀਖਿਆ ਨੂੰ ਸਮਾਪਤ ਕਰਦਾ ਹੈ। ਅਗਲੇ ਲੇਖਾਂ ਵਿੱਚ, ਅਸੀਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਵੇਰੀਏਬਲਾਂ, ਸੰਗ੍ਰਹਿ, ਨਿਯਮਤ ਸਮੀਕਰਨ, ਫੰਕਸ਼ਨ, ਮੋਡੀਊਲ ਅਤੇ ਕਸਟਮ cmdlets ਬਣਾਉਣ ਦੇ ਨਾਲ-ਨਾਲ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਬਾਰੇ ਵਧੇਰੇ ਵਿਸਥਾਰ ਨਾਲ ਅਧਿਐਨ ਕਰਾਂਗੇ।

ਸਰੋਤ: www.habr.com