์ญ์ฌ์ ์ผ๋ก Unix ์์คํ ์ ๋ช ๋ น์ค ์ ํธ๋ฆฌํฐ๋ Windows๋ณด๋ค ๋ ์ ๊ฐ๋ฐ๋์์ง๋ง ์๋ก์ด ์๋ฃจ์ ์ด ๋ฑ์ฅํ๋ฉด์ ์ํฉ์ด ๋ฐ๋์์ต๋๋ค.
PowerShell์ ์กฐ๊ฑด๋ถ ๋ถ๊ธฐ, ๋ฃจํ, ๋ณ์, ๋ฐฐ์ด, ํด์ ํ
์ด๋ธ, ํด๋์ค, ์ค๋ฅ ์ฒ๋ฆฌ, ํจ์, cmdlet ๋ฐ ํ์ดํ๋ผ์ธ .
๋ชฉ์ฐจ :
ํ ์คํธ ํธ์ง๊ธฐ๋ ํตํฉ ๊ฐ๋ฐ ํ๊ฒฝ์ ์ฌ์ฉํ์ฌ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์ Microsoft ์๋ฒ ์ด์ ์ฒด์ ์ ํจ๊ป ์ ๊ณต๋๋ Windows PowerShell ISE๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋๋ค. ์ด๋ ์๋นํ ๋ณต์กํ ์คํฌ๋ฆฝํธ์๋ง ํ์ํฉ๋๋ค. ์งง์ ๋ช ๋ น ์ธํธ๋ ๋ํ์์ผ๋ก ์คํํ๊ธฐ๊ฐ ๋ ์ฝ์ต๋๋ค.
๋๊ธ
์ฃผ์์ ์ฌ์ฉํ๋ ๊ฒ์ ์ ์ ํ ๋ค์ฌ์ฐ๊ธฐ ๋ฐ ๊ณต๋ฐฑ๊ณผ ํจ๊ป ์ข์ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ์ผ๋ถ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
# ะะปั ัััะพัะฝัั
ะบะพะผะผะตะฝัะฐัะธะตะฒ ะธัะฟะพะปัะทัะตััั ัะธะผะฒะพะป ัะตัะตัะบะธ โ ัะพะดะตัะถะธะผะพะต ัััะพะบะธ ะธะฝัะตัะฟัะตัะฐัะพั ะฝะต ะพะฑัะฐะฑะฐััะฒะฐะตั.
<#
ะขะฐะบ ะพะฑะพะทะฝะฐัะฐัััั ะฝะฐัะฐะปะพ ะธ ะบะพะฝะตั ะฑะปะพัะฝะพะณะพ ะบะพะผะผะตะฝัะฐัะธั.
ะะฐะบะปััะตะฝะฝัะน ะผะตะถะดั ะฝะธะผะธ ัะตะบัั ะธะฝัะตัะฟัะตัะฐัะพั ะธะณะฝะพัะธััะตั.
#>
๋ณ์ ๋ฐ ์ ํ
PowerShell์ ๋ณ์๋ ๋ช ๋ช ๋ ๊ฐ์ฒด์ ๋๋ค. ์ด๋ฆ์๋ ๋ฐ์ค ๋ฌธ์์ ๋ฌธ์ ๋ฐ ์ซ์๊ฐ ํฌํจ๋ ์ ์์ต๋๋ค. $ ๊ธฐํธ๋ ํญ์ ์ด๋ฆ ์์ ์ฌ์ฉ๋๋ฉฐ ๋ณ์๋ฅผ ์ ์ธํ๋ ค๋ฉด ์ธํฐํ๋ฆฌํฐ์ ์ ํจํ ์ด๋ฆ์ ์ง์ ํ๋ ๊ฒ์ผ๋ก ์ถฉ๋ถํฉ๋๋ค.
๋ณ์๋ฅผ ์ด๊ธฐํ(๊ฐ ํ ๋น)ํ๋ ค๋ฉด ํ ๋น ์ฐ์ฐ์(๊ธฐํธ =)๋ฅผ ์ฌ์ฉํฉ๋๋ค.
$test = 100
์ด๋ฆ์ด๋ ๊ฐ ์์ ์ ํ์ ๋๊ดํธ(์ ํ ๋ณํ ์ฐ์ฐ์)๋ก ์ง์ ํ์ฌ ๋ณ์๋ฅผ ์ ์ธํ ์ ์์ต๋๋ค.
[int]$test = 100
$test = [int]100
PowerShell์ ๋ณ์๋ .NET Core์ ๋ณ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์์ฑ ๋ฐ ๋ฉ์๋ ์ ํ์ ๊ฐ์ง ์์ ํ ๊ฐ์ฒด(ํด๋์ค)๋ผ๋ ์ ์ ์ดํดํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ฐ๋ฆฌ๋ ์ฃผ์ ํญ๋ชฉ์ ๋์ดํฉ๋๋ค.
์ ํ(.NET ํด๋์ค)
๊ธฐ์
์ฝ๋ ์
[๋ฌธ์์ด] ์์คํ .๋ฌธ์์ด์ ๋์ฝ๋ ๋ฌธ์์ด
$ํ
์คํธ = "ํ
์คํธ"
$ํ
์คํธ = 'ํ
์คํธ'
์ ๋์ฝ๋ ๋ฌธ์(16๋นํธ)
[๋ฌธ์]$ํ ์คํธ = 'c' [๋ถ์ธ] System.Boolean๋ถ์ธ ์ ํ(๋ถ์ธ True ๋๋ False)
[๋ถ์ธ]$test = $true [int] ์์คํ .Int3232๋นํธ ์ ์(XNUMX๋นํธ)
[int]$test = 123456789 [๊ธด] System.Int6464๋นํธ ์ ์(XNUMX๋นํธ)
[๊ธด]$test = 12345678910 [์ฑ๊ธ] ์์คํ .์ฑ๊ธ๋ถ๋ ์์์ ์ซ์ 32๋นํธ ๊ธธ์ด
[๋จ์ผ]$ํ ์คํธ = 12345.6789 [๋๋ธ]์์คํ .๋๋ธ๊ธธ์ด 64๋นํธ(8๋ฐ์ดํธ)์ ๋ถ๋ ์์์ ์
[๋๋ธ]$ํ ์คํธ = 123456789.101112 [์ญ์ง์]System.Decimal128๋นํธ ๋ถ๋ ์์์ ์ซ์(d๋ก ๋๋์ผ ํจ)
[์ญ์ง์]$test = 12345.6789d [DateTime]System.DateTime๋ ์ง์ ์๊ฐ
$test = GetDate
[๋ฐฐ์ด] System.Object[]์์ ์ธ๋ฑ์ค๊ฐ 0์์ ์์ํ๋ ๋ฐฐ์ด
$test_array = 1, 2, "ํ ์คํธ", 3, 4
[ํด์ ํ ์ด๋ธ] System.Collections.Hashtableํด์ ํ ์ด๋ธ์ @{key = "value"} ์์น์ ๋ฐ๋ผ ๊ตฌ์ถ๋ ๋ช ๋ช ๋ ํค๊ฐ ์๋ ์ฐ๊ด ๋ฐฐ์ด์ ๋๋ค.
$test_hashtable = @{one="ํ๋"; ๋="๋"; ์ธ = ์ธ"}
PowerShell์ ์์์ ์ ํ ๋ณํ์ ์ง์ํ๋ฉฐ, ๋ณ์ ์ ํ์ ๊ฐ์ ๋ก ์ง์ ํ์ง ์์ ๊ฒฝ์ฐ ์ฆ์์์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค(์: ํ ๋น ์ฐ์ฐ์ ์ฌ์ฉ). ์ด ๊ฒฝ์ฐ ์ธํฐํ๋ฆฌํฐ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค. GetType() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ด์ ์์ ์์ ๋ณ์์ ์ ํ์ ๊ฒฐ์ ํ ์ ์์ต๋๋ค.
$test.GetType().FullName
๋ณ์๋ฅผ ์กฐ์ํ๊ธฐ ์ํ ์ฌ๋ฌ cmdlet์ด ์์ต๋๋ค. ํธ๋ฆฌํ ํ์์ ๋ชฉ๋ก์ ๋ค์ ๋ช
๋ น์ ์ฌ์ฉํ์ฌ ํ์๋ฉ๋๋ค.
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
์ ์ธ๋ ๋ณ์์ ํด๋น ๊ฐ์ ๋ณด๋ ค๋ฉด ํน์ cmdlet์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
Get-Variable | more
์ด ๋ฐฉ๋ฒ์ ์ง๋์น๊ฒ ๋ฒ๊ฑฐ๋ก์ ๋ณด์ด์ง๋ง ์ฐ์ฐ์๋ฅผ ํตํด ๋ณ์๋ฅผ ์ฌ์ฉํ๊ฑฐ๋ ํด๋น ์์ฑ ๋ฐ ๋ฉ์๋์ ์ง์ ์ก์ธ์คํ์ฌ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์ฌ ๋ ํธ๋ฆฌํฉ๋๋ค. ๊ทธ๋ฌ๋ cmdlet์ ๋ช ๊ฐ์ง ์ถ๊ฐ ๋งค๊ฐ ๋ณ์๋ฅผ ์ค์ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์กด์ฌํ ๊ถ๋ฆฌ๊ฐ ์์ต๋๋ค. ์ฌ์ฉ์ ๋ณ์๋ ํ์ฌ ์ธ์ ๋ด์์๋ง ์ ์๋๋ค๋ ์ ์ ์ดํดํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ฝ์์ด ๋ซํ๊ฑฐ๋ ์คํฌ๋ฆฝํธ๊ฐ ์ข ๋ฃ๋๋ฉด ์ญ์ ๋ฉ๋๋ค.
์์คํ ๋ณ์
์ฌ์ฉ์๊ฐ ์ ์ธํ ๋ณ์ ์ธ์๋ ํ์ฌ ์ธ์ ์ด ์ข ๋ฃ๋ ํ์๋ ์ญ์ ๋์ง ์๋ ๋ด์ฅ(์์คํ ) ๋ณ์๊ฐ ์์ต๋๋ค. ๋ ๊ฐ์ง๋ก ๋๋๋๋ฐ ํ์์ ์ํ ๋ฐ์ดํฐ๋ ์ค์ค๋ก ์์์ ๊ฐ์ ํ ๋นํ ์ ์๋ ์๋ ๋ณ์์ ์ ์ฅ๋๋ค. ์ฌ๊ธฐ์๋ ์๋ฅผ ๋ค์ด $PWD๊ฐ ํฌํจ๋ฉ๋๋ค.
$PWD.Path
์ฌ์ฉ์ ์ ํธ๋๋ฅผ ์ ์ฅํ๋ ค๋ฉด ์ ํธ๋ ๋ณ์๊ฐ ํ์ํ๋ฉฐ ๊ทธ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด $ErrorActionPreference ๋ฅผ ์ฌ์ฉํ๋ฉด ์น๋ช
์ ์ด์ง ์์ ์ค๋ฅ ๋ฐ์์ ๋ํ ๋ช
๋ น ํด์๊ธฐ์ ๋ฐ์์ด ์ค์ ๋ฉ๋๋ค.
์ ์ธ๋ ๋ณ์์ ์ก์ธ์คํ๊ธฐ ์ํ ์ฐ์ฐ์ ๋ฐ cmdlet ์ธ์๋ Variable: pseudo-accumulator๊ฐ ์์ต๋๋ค. ๋ค๋ฅธ ๋๋ผ์ด๋ธ์ ์ ์ฌํ๊ฒ ์์ ํ ์ ์์ผ๋ฉฐ ์ด ๊ฒฝ์ฐ ๋ณ์๋ ํ์ผ ์์คํ ๊ฐ์ฒด์ ์ ์ฌํฉ๋๋ค.
Get-ChildItem Variable: | more
๋๋
ls Variable: | more
๋ฒ์
PowerShell์ ๋ณ์์๋ ๋ฒ์(Scope)๋ผ๋ ๊ฐ๋ ์ด ์์ต๋๋ค. ์ ์ญ ๋ฒ์(Global)์ ์์ ์ ์ ์ฒด ํ์ฌ ์ธ์ ์ ์ ์ฉ๋๋ฉฐ ์๋ฅผ ๋ค์ด ์์คํ ๋ณ์๊ฐ ํฌํจ๋ฉ๋๋ค. ๋ก์ปฌ(๋ก์ปฌ) ๋ณ์๋ ์ ์๋ ๋ฒ์, ์ฆ ํจ์ ๋ด๋ถ์์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. ์คํฌ๋ฆฝํธ(Script)์ ๋ฒ์ ๊ฐ๋ ๋ ์์ง๋ง ์คํฌ๋ฆฝํธ ๋ช ๋ น์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ก์ปฌ์ ๋๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ๋ณ์๋ฅผ ์ ์ธํ ๋ ๋ก์ปฌ ๋ฒ์๊ฐ ์ง์ ๋๋ฉฐ ์ด๋ฅผ ๋ณ๊ฒฝํ๋ ค๋ฉด $Global: variable = value์ ๊ฐ์ ํน์ ๊ตฌ์ฑ์ด ํ์ํฉ๋๋ค.
์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
$Global:test = 100
ํ๊ฒฝ ๋ณ์(ํ๊ฒฝ)
๋ ๋ค๋ฅธ ์์ฌ ๋๋ผ์ด๋ธ์ธ Env:๋ PowerShell์์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ ํ๊ฒฝ ๋ณ์์ ์ก์ธ์คํ๋ ๋ฐ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ ธ์ด ์์๋๋ฉด ์์ ํ๋ก์ธ์ค(์ฆ, ํ์ฌ ์ธ์ ์ ์์ํ ํ๋ก๊ทธ๋จ)์์ ๋ณต์ฌ๋๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก ์ด๊ธฐ ๊ฐ์ ์ ์ดํ์ ๊ฐ๊ณผ ๋์ผํฉ๋๋ค. ํ๊ฒฝ ๋ณ์๋ฅผ ๋ณด๋ ค๋ฉด Get-ChildItem cmdlet ๋๋ ํด๋น ๋ณ์นญ(ls ๋ฐ dir)์ ์ฌ์ฉํ์ญ์์ค.
dir Env:
์ด๋ฌํ ๋ณ์๋ ๋ฐ์ดํธ(๋๋ ์ํ๋ ๊ฒฝ์ฐ ๋ฌธ์)์ ์ํ์ค์ด๋ฉฐ, ํด์์ ์ด๋ฅผ ์ฌ์ฉํ๋ ํ๋ก๊ทธ๋จ์๋ง ์์กดํฉ๋๋ค. *-Variable cmdlet์ ํ๊ฒฝ ๋ณ์์ ํจ๊ป ์๋ํ์ง ์์ต๋๋ค. ์ก์ธ์คํ๋ ค๋ฉด ๋๋ผ์ด๋ธ ์ ๋์ฌ๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
$env:TEST = "Hello, World!"
์ฐ์ ๋ฐ ๋น๊ต ์ฐ์ฐ์
PowerShell์ +(๋ํ๊ธฐ), -(๋นผ๊ธฐ), *(๊ณฑํ๊ธฐ), /(๋๋๊ธฐ) ๋ฐ %(๋ชจ๋๋ก ๋๋ ๋ชจ๋๋ก)์ ๊ฐ์ ์ฐ์ ์ฐ์ฐ์๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ฐ์ ์์ ๊ฒฐ๊ณผ๋ ์ผ๋ฐ์ ์ผ๋ก ํ์ฉ๋๋ ์ฐ์ฐ ์์์ ๋ฐ๋ผ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ํ๊ฐ๋๋ฉฐ ๊ดํธ๋ ์์ ์ผ๋ถ๋ฅผ ๊ทธ๋ฃนํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ฐ์ฐ์ ์ฌ์ด์ ๊ณต๋ฐฑ์ ๋ฌด์๋๋ฉฐ ์ฝ๊ธฐ ์ฝ๋๋ก๋ง ์ฌ์ฉ๋ฉ๋๋ค. + ์ฐ์ฐ์๋ ์ฐ๊ฒฐํ๊ณ * ์ฐ์ฐ์๋ ๋ฌธ์์ด์ ๋ฐ๋ณตํฉ๋๋ค. ๋ฌธ์์ด์ ์ซ์๋ฅผ ์ถ๊ฐํ๋ ค๊ณ ํ๋ฉด ๋ฌธ์์ด๋ก ๋ณํ๋ฉ๋๋ค. ๋ํ PowerShell ์ธ์ด์๋ ๋ ๊ฐ ๊ฐ์ ์ผ์น๋ฅผ ํ์ธํ๊ณ ๋ถ์ธ True ๋๋ False๋ฅผ ๋ฐํํ๋ ๋ง์ ๋น๊ต ์ฐ์ฐ์๊ฐ ์์ต๋๋ค.
์ฐ์ฐ์
๊ธฐ์
์ฝ๋ ์
-eq
Equal / Equals(๋ค๋ฅธ ์ธ์ด์ = ๋๋ ==์ ์ ์ฌ)
$ํ
์คํธ = 100
$ํ
์คํธ -eq 123
-๋ค
๊ฐ์ง ์์ / ๊ฐ์ง ์์(<> ๋๋ !=์ ์ ์ฌ)
$ํ
์คํธ = 100
$ ํ
์คํธ -ne 123
-gt
๋ณด๋ค ํผ / ์ด์(์๋ ๋ก๊ทธ >)
$ํ
์คํธ = 100
$ํ
์คํธ -gt 123
-๊ฒ
ํฌ๊ฑฐ๋ ๊ฐ์ / ํฌ๊ฑฐ๋ ๊ฐ์(>=์ ์ ์ฌ)
$ํ
์คํธ = 100
$ํ
์คํธ -ge 123
-๊ทธ
๋ฏธ๋ง / ๋ฏธ๋ง(<์ ์ ์ฌ)
$ํ
์คํธ = 100
$ํ
์คํธ -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) ๋ฐ 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 ะธะปะธ ะทะฝะฐัะตะฝะธะต ะฝะต ะพะฟัะตะดะตะปะตะฝะพ"}
}
์ฌ์ดํด
PowerShell์๋ WHILE, DO WHILE, DO UNTIL, FOR ๋ฐ FOREACH์ ๊ฐ์ ์ฌ๋ฌ ์ข ๋ฅ์ ๋ฃจํ๊ฐ ์์ต๋๋ค.
์ ์ ์กฐ๊ฑด์ด ์๋ ๋ฃจํ๋ true์ธ ๊ฒฝ์ฐ ์๋ํฉ๋๋ค.
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
์กฐ๊ฑด์ด ๋ฐ๋ณต ํ์ ํ์ธ๋๊ธฐ ๋๋ฌธ์ ์ฌํ ์กฐ๊ฑด์ด ์๋ ๋ฃจํ๋ ์ ์ด๋ ํ ๋ฒ ์คํ๋ฉ๋๋ค. ๋์์ DO WHILE์ ์กฐ๊ฑด์ด ์ฐธ์ผ ๋ ์๋ํ๊ณ DO UNTIL์ ๊ฑฐ์ง์ผ ๋ ์๋ํฉ๋๋ค.
[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
๋ฐฐ์ด ์์๋ XNUMX๋ถํฐ ์์ํ๋ ์ ์ ์ธ๋ฑ์ค์ ์ธ๋ฑ์ค ์ฐ์ฐ์(๋๊ดํธ)๋ฅผ ์ฌ์ฉํ์ฌ ์ก์ธ์คํฉ๋๋ค.
$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, XNUMX, XNUMX) ๋ฐฐ์ด์ ์ถ๋ ฅํฉ๋๋ค.
๋ฒ์ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฐ์ด($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() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ๊ธฐ์กด ํค์ ํ ๋นํ๋ฉด ํด๋น ๊ฐ์ด ๋ณ๊ฒฝ๋ฉ๋๋ค. 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๋ ๊ณ ๋ คํ ๊ฒ์
๋๋ค.
๊ธฐ๋ฅ
PowerShell์๋ ํจ์๋ฅผ ํฌํจํ์ฌ ์ ์ฐจ์ ํ๋ก๊ทธ๋๋ฐ์ ํ์ํ ๋ชจ๋ ๊ฒ์ด ์์ต๋๋ค. ์ด๋ฅผ ์ค๋ช ํ๊ธฐ ์ํด ํจ์ ๋จ์ด Function์ด ์ฌ์ฉ๋๋ฉฐ ๊ทธ ํ์๋ ์ฐ์ฐ์ ๊ดํธ๋ก ๋ฌถ์ธ ํจ์ ์ด๋ฆ๊ณผ ๋ณธ๋ฌธ์ ์ง์ ํด์ผ ํฉ๋๋ค. ํจ์์ ์ธ์๋ฅผ ์ ๋ฌํด์ผ ํ๋ ๊ฒฝ์ฐ ๊ดํธ ์์ ์ด๋ฆ ๋ฐ๋ก ๋ค์ ์ง์ ํ ์ ์์ต๋๋ค.
function ะธะผั-ััะฝะบัะธะธ (ะฐัะณัะผะตะฝั1, ..., ะฐัะณัะผะตะฝัN)
{
ัะตะปะพ-ััะฝะบัะธะธ
}
ํจ์๋ ํญ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค. ํ๋ ์ด์์ด ์๋ ๊ฒฝ์ฐ ๋ชจ๋ ๋ช ๋ น๋ฌธ์ ๊ฒฐ๊ณผ ๋ฐฐ์ด์ ๋๋ค. ๋ฌธ์ด ํ๋๋ง ์๋ ๊ฒฝ์ฐ ํด๋น ์ ํ์ ๊ฐ๋ง ๋ฐํ๋ฉ๋๋ค. return $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) {
#ัะตะปะพ ััะฝะบัะธะธ
}
ํจ์ ์ธ์๋ฅผ ์ค๋ช ํ๋ ๋ ๋ค๋ฅธ ๊ตฌ๋ฌธ์ด ์์ผ๋ฉฐ ๋งค๊ฐ ๋ณ์๋ ํ์ดํ๋ผ์ธ์์ ์ฝ์ ์ ์์ต๋๋ค. ์ด ๋ชจ๋ ๊ฒ์ ๋ค์ ๋ฌธ์์์ ๋ด๋ณด๋ธ ๋ชจ๋์ ์ดํด๋ณด๊ณ ์์ฒด cmdlet์ ๋ง๋ค ๋ ์ ์ฉํ ๊ฒ์ ๋๋ค.
์ค๋ฅ ์ฒ๋ฆฌ
PowerShell์๋ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ Try...Catch...Finally ๋ฉ์ปค๋์ฆ์ด ์์ต๋๋ค. Try ๋ธ๋ก์๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ ์ฝ๋๊ฐ ํฌํจ๋๊ณ Catch ๋ธ๋ก์๋ ํด๋น ํธ๋ค๋ฌ๊ฐ ํฌํจ๋ฉ๋๋ค. ์ค๋ฅ๊ฐ ์์ผ๋ฉด ์คํ๋์ง ์์ต๋๋ค. finally ๋ธ๋ก์ ์ค๋ฅ ๋ฐ์ ์ฌ๋ถ์ ๊ด๊ณ์์ด Try ๋ธ๋ก ์ดํ์ ์คํ๋๋ฉฐ, ์์ธ ์ ํ์ ๋ฐ๋ผ Catch ๋ธ๋ก์ด ์ฌ๋ฌ ๊ฐ ์์ ์ ์์ต๋๋ค. ์์ธ ์์ฒด๋ ์ ์ธ๋์ง ์์ ๊ธฐ๋ณธ ๋ณ์($_)์ ๊ธฐ๋ก๋๋ฉฐ ์ฝ๊ฒ ๊ฒ์ํ ์ ์์ต๋๋ค. ์๋ ์์์๋ ์ ํจํ์ง ์์ ๊ฐ์ ์ ๋ ฅํ์ง ๋ชปํ๋๋ก ๋ณดํธํฉ๋๋ค.
try {
[int]$test = Read-Host "ะะฒะตะดะธัะต ัะธัะปะพ"
100 / $test
} catch {
Write-Warning "ะะตะบะพััะตะบัะฝะพะต ัะธัะปะพ"
Write-Host $_
}
์ด๊ฒ์ผ๋ก PowerShell ์ธ์ด๋ก ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ๋ณธ ์ฌํญ์ ๋ํ ๊ฒํ ๋ฅผ ๋ง์นฉ๋๋ค. ๋ค์ ๋ฌธ์์์๋ ๋ค์ํ ์ ํ์ ๋ณ์, ์ปฌ๋ ์
, ์ ๊ท์, ํจ์, ๋ชจ๋ ๋ฐ ์ฌ์ฉ์ ์ง์ cmdlet ๋ง๋ค๊ธฐ, ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ ์์
์ ๋ํด ์์ธํ ์์๋ด
๋๋ค.
์ถ์ฒ : habr.com