about_Comparison_Operators

업데이트 날짜: 2014년 5월

적용 대상: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0

여기에 소개를 삽입합니다.

항목

about_comparison_operators

간단한 설명

Windows PowerShell®의 값을 비교하는 연산자에 대해 설명합니다.

자세한 설명

비교 연산자를 사용하여 지정된 패턴과 일치하는 값을 찾고 값을 비교하기 위한 조건을 지정할 수 있습니다. 비교 연산자를 사용하려면 이러한 값을 구분하는 연산자와 함께 비교할 값을 지정합니다.

Windows PowerShell에는 다음 비교 연산자가 포함됩니다.

-eq
      -ne
      -gt
      -ge   
      -lt
      -le
      -Like
      -NotLike
      -Match
      -NotMatch
      -Contains
      -NotContains
      -In
      -NotIn
      -Replace

기본적으로 모든 비교 연산자는 대/소문자를 구분하지 않습니다. 비교 연산자의 대/소문자를 구분하려면 연산자 이름 앞에 "c"를 추가합니다. 예를 들어 "-eq"의 대/소문자 구분 버전은 "-ceq"입니다. 명시적으로 대/소문자를 구분하지 않으려면 연산자 앞에 "i"를 추가합니다. 예를 들어 "-eq"의 명시적으로 대/소문자를 구분하지 않는 버전은 "-ieq"입니다.

연산자에 대한 입력이 스칼라 값이면 비교 연산자는 부울 값을 반환합니다. 입력이 값 컬렉션이면 비교 연산자는 일치하는 값을 반환합니다. 컬렉션에 일치 항목이 없으면 비교 연산자는 아무것도 반환하지 않습니다.

예외는 항상 부울 값을 반환하는 포함 연산자(-Contains, -NotContains), In 연산자(-In, -NotIn) 및 형식 연산자(-Is, -IsNot)입니다.

Windows PowerShell에서는 다음 비교 연산자를 지원합니다.

-eq

설명: 같음을 나타냅니다. 동일 값을 포함합니다.

예:

        PS C:\> "abc" -eq "abc"
        True

        PS C:\> "abc" -eq "abc", "def"
        False

        PS C:\> "abc", "def" -eq "abc"
        abc

-ne

설명: 같지 않음을 나타냅니다. 다른 값을 포함합니다.

예:

        PS C:\> "abc" -ne "def"
        True

        PS C:\> "abc" -ne "abc"
        False

        PS C:\> "abc" -ne "abc", "def"
        True

        PS C:\> "abc", "def" -ne "abc"
        def


-gt

설명: 보다 큼을 나타냅니다.

예:

          PS C:\> 8 -gt 6
          True

          PS C:\> 7, 8, 9 -gt 8
          9

-ge

설명: 보다 크거나 같음을 나타냅니다.

예:

          PS C:\> 8 -ge 8
          True         

          PS C:\> 7, 8, 9 -ge 8
          8
          9

-lt

설명: 보다 작음을 나타냅니다.

예:

          PS C:\> 8 -lt 6
          False

          PS C:\> 7, 8, 9 -lt 8
          7

-le

설명: 보다 작거나 같음을 나타냅니다.

예:

          PS C:\> 6 -le 8
          True

          PS C:\> 7, 8, 9 -le 8
          7
          8


-Like

설명: 와일드카드 문자(*)를 사용하여 일치시킵니다.

예:

          PS C:\> "Windows PowerShell" -like "*shell"
          True

          PS C:\> "Windows PowerShell", "Server" -like "*shell"
          Windows PowerShell

-NotLike

설명: 와일드카드 문자(*)를 사용하여 일치시키지 않습니다.

예:

          PS C:\> "Windows PowerShell" -NotLike "*shell"
          False

          PS C:\> "Windows PowerShell", "Server" -NotLike "*shell"
          Server   

-Match

설명: 정규식을 사용하여 문자열을 일치시킵니다. 입력이 스칼라인 경우 $Matches 자동 변수가 입력으로 채워집니다.

예:

           PS C:\> "Sunday" -Match "sun" 
          True 

          PS C:\> $matches 
          Name Value 
          ---- ----- 
          0    Sun
 
          PS C:\> "Sunday", "Monday" -Match "sun" 
          Sunday

-NotMatch

설명: 문자열을 일치시키지 않습니다. 정규식을 사용합니다. 입력이 스칼라인 경우 $Matches 자동 변수가 입력으로 채워집니다.

예:

          PS C:\> "Sunday" -NotMatch "sun"
          False

          PS C:\> $matches 
          Name Value 
          ---- ----- 
          0    sun

          PS C:\> "Sunday", "Monday" -NotMatch "sun" 
          Monday


-Contains

설명: 포함 연산자입니다. 참조 값 컬렉션에 단일 테스트 값이 포함되는지 알려줍니다. 항상 부울 값을 반환합니다. 테스트 값이 참조 값의 하나 이상과 정확히 일치하면 TRUE를 반환합니다.

테스트 값이 컬렉션이면 Contains 연산자에서 참조 같음을 사용합니다. 참조 값의 하나가 테스트 값 개체의 동일 인스턴스인 경우에만 TRUE를 반환합니다.

구문:

<Reference-values> -Contains <Test-value>

예:

          PS C:\> "abc", "def" -Contains "def"
          True

          PS C:\> "Windows", "PowerShell" -Contains "Shell"
          False  #Not an exact match


          # Does the list of computers in $domainServers
          # include $thisComputer?
          # -------------------------------------------
          PS C:\> $domainServers -Contains $thisComputer
          True

          PS C:\> "abc", "def", "ghi" -Contains "abc", "def"
          False

          PS C:\> $a = "abc", "def"
          PS C:\> "abc", "def", "ghi" -Contains $a
          False
          PS C:\> $a, "ghi" -Contains $a
          True

-NotContains

설명: 포함 연산자입니다. 참조 값 컬렉션에 단일 테스트 값이 포함되는지 알려줍니다. 항상 부울 값을 반환합니다. 테스트 값이 참조 값의 하나 이상과 정확히 일치하지 않으면 TRUE를 반환합니다.

테스트 값이 컬렉션이면 NotContains 연산자에서 참조 같음을 사용합니다.

구문:

<Reference-values> -NotContains <Test-value>

예:

PS C:\> "Windows", "PowerShell" -NotContains "Shell"
          True  #Not an exact match


          # Get cmdlet parameters, but exclude common parameters
          function get-parms ($cmdlet)
          {
              $Common = "Verbose", "Debug", "WarningAction", "WarningVariable", `
                        "ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer" 
    
              $allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | `
                          foreach {$_.Name} | Sort-Object | Get-Unique
    
              $allparms | where {$Common -NotContains $_ }
          }


          # Find unapproved verbs in the functions in my module
          # -------------------------------------------
          PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
          PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}

          PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_}      
          ForEach
          Sort
          Tee
          Where

-In

설명: In 연산자입니다. 참조 값이 참조 값 컬렉션에 나타나는지 알려줍니다. 항상 부울 값으로 반환합니다. 테스트 값이 참조 값의 하나 이상과 정확히 일치하면 TRUE를 반환합니다.

테스트 값이 컬렉션이면 In 연산자에서 참조 같음을 사용합니다. 참조 값의 하나가 테스트 값 개체의 동일 인스턴스인 경우에만 TRUE를 반환합니다.

In 연산자는 Windows PowerShell 3.0에 도입되었습니다.

구문:

<Test-value> -in <Reference-values> 

예:

PS C:\> "def" -in "abc", "def"
          True

          PS C:\> "Shell" -in "Windows", "PowerShell"
          False  #Not an exact match

          PS C:\> "Windows" -in "Windows", "PowerShell"
          True  #An exact match

          PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
          False  #Using reference equality

          PS C:\> $a = "Windows", "PowerShell"
          PS C:\> $a -in $a, "ServerManager"
          True  #Using reference equality

          # Does the list of computers in $domainServers
          # include $thisComputer?
          # -------------------------------------------
          PS C:\> $thisComputer -in  $domainServers
          True

-NotIn

설명: NotIn 연산자입니다. 참조 값이 참조 값 컬렉션에 나타나는지 알려줍니다. 항상 부울 값을 반환합니다. 테스트 값이 참조 값의 하나 이상과 정확히 일치하지 않으면 TRUE를 반환합니다.

테스트 값이 컬렉션이면 In 연산자에서 참조 같음을 사용합니다. 참조 값의 하나가 테스트 값 개체의 동일 인스턴스인 경우에만 TRUE를 반환합니다.

NotIn 연산자는 Windows PowerShell 3.0에 도입되었습니다.

구문:

<Test-value> -NotIn <Reference-values> 

예:

PS C:\> "def" -NotIn "abc", "def"
          False

          PS C:\> "ghi" -NotIn "abc", "def"
          True

          PS C:\> "Shell" -NotIn "Windows", "PowerShell"
          True  #Not an exact match

          PS C:\> "Windows" -NotIn "Windows", "PowerShell"
          False  #An exact match



          # Find unapproved verbs in the functions in my module
          # -------------------------------------------
          PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
          PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}

          PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs}      
          ForEach
          Sort
          Tee
          Where

-Replace

설명: 대체 연산자입니다. 값의 지정된 요소를 변경합니다.

예:

PS C:\> "Get-Process" -Replace "Get", "Stop"
          Stop-Process

          # Change all .GIF file name extension to .JPG
          PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"} 

같음 연산자

같음 연산자(-eq, -ne)는 입력 값의 하나 이상이 지정된 패턴과 동일하면 TRUE 값 또는 일치 항목을 반환합니다. 전체 패턴이 전체 값과 일치해야 합니다.

C:PS> 2 -eq 2
          True

          C:PS> 2 -eq 3
          False

          C:PS> 1,2,3 -eq 2
          2

          C:PS> "PowerShell" -eq "Shell"
          False

          C:PS> "Windows", "PowerShell" -eq "Shell"
          C:PS> 

          PS C:\> "abc", "def", "123" -eq "def"
          def
 
          PS C:\> "abc", "def", "123" -ne "def"
          abc
          123

포함 연산자

포함 연산자(-Contains 및 -NotContains)는 같음 연산자와 비슷합니다. 하지만 포함 연산자는 입력이 컬렉션이더라도 항상 부울 값을 반환합니다.

또한 같음 연산자와 달리 포함 연산자는 첫 번째 일치 항목을 발견하면 바로 값을 반환합니다. 같음 연산자는 모든 입력을 평가하고 컬렉션의 모든 일치 항목을 반환합니다. 다음 예제에서는 -Contains 연산자의 효과를 보여 줍니다.

C:PS> 1,2,3 -contains 2
          True

          C:PS> "PowerShell" -contains "Shell"
          False

          C:PS> "Windows", "PowerShell" -contains "Shell"
          False

          PS C:\> "abc", "def", "123" -contains "def"
          True

          PS C:\> "true", "blue", "six" -contains "true"
          True

다음 예제에서는 포함 연산자가 같음 연산자와 어떻게 다른지를 보여 줍니다. 포함 연산자는 첫 번째 일치 항목을 발견하면 TRUE 값을 반환합니다.

PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2
          2
          2

          PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2
          True

매우 큰 컬렉션에서는 -Contains 연산자가 같음 연산자보다 빠르게 결과를 반환합니다.

일치 연산자

일치 연산자(-Match 및 -NotMatch)는 정규식을 사용하여 지정된 패턴과 일치하거나 일치하지 않는 요소를 찾습니다.

구문은 다음과 같습니다.

<string[]> -Match <regular-expression>
          <string[]> -NotMatch <regular-expression>

다음 예제에서는 -Match 연산자의 몇 가지 사용 방법을 보여 줍니다.

PS C:\> "Windows", "PowerShell" -Match ".shell"
          PowerShell

          PS C:\> (Get-Command Get-Member -Syntax) -Match "-view"
          True

          PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path"
          True

          PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d"
          Server01
          Server02

일치 연산자는 문자열에서만 검색합니다. 정수 배열이나 다른 개체에서는 검색할 수 없습니다.

-Match 및 -NotMatch 연산자는 연산자에 대한 입력(왼쪽 인수)이 단일 스칼라 개체이면 $Matches 자동 변수를 채웁니다. 입력이 스칼라이면 -Match 및 -NotMatch 연산자는 부울 값을 반환하고 $Matches 자동 변수 값을 인수의 일치된 구성 요소로 설정합니다.

입력이 컬렉션이면 -Match 및 -NotMatch 연산자는 컬렉션의 일치하는 멤버를 반환하지만 $Matches 변수를 채우지 않습니다.

예를 들어 다음 명령은 문자열 컬렉션을 -Match 연산자로 전송합니다. -Match 연산자는 일치하는 컬렉션의 항목을 반환합니다. $Matches 자동 변수를 채우지 않습니다.

PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun"
          Sunday

          PS C:\> $matches
          PS C:\>

반대로 다음 명령은 단일 문자열을 -Match 연산자로 전송합니다. -Match 연산자는 부울 값을 반환하고 $Matches 자동 변수를 채웁니다.

PS C:\> "Sunday" -Match "sun"
          True

          PS C:\> $matches

          Name                           Value
          ----                           -----
          0                              Sun


-NotMatch 연산자는 입력이 스칼라이고 결과가 False이면(일치 항목을 발견하면) $Matches 자동 변수를 채웁니다.

PS C:\> "Sunday" -NotMatch "rain"
          True

          PS C:\> $matches
          PS C:\>
          
          PS C:\> "Sunday" -NotMatch "day"
          False

          PS C:\> $matches
          PS C:\>

          Name                           Value
          ----                           -----
          0                              day

대체 연산자

-Replace 연산자는 정규식을 사용하여 모든 값이나 일부 값을 지정된 값으로 바꿉니다. 파일 이름 바꾸기와 같은 다양한 관리 작업에 -Replace 연산자를 사용할 수 있습니다. 예를 들어 다음 명령은 모든 .gif 파일의 파일 이름 확장명을 .jpg로 변경합니다.

Get-ChildItem | Rename-Item -NewName { $_ -Replace '.gif$','.jpg$' }

-Replace 연산자 구문은 다음과 같습니다. 여기서 <original> 자리 표시자는 바뀔 문자를 나타내고 <substitute> 자리 표시자는 바꿀 문자를 나타냅니다.

<input> <operator> <original>, <substitute> 

기본적으로 -Replace 연산자는 대/소문자를 구분하지 않습니다. 대/소문자를 구분하려면 -cReplace를 사용합니다. 명시적으로 대/소문자를 구분하지 않으려면 -iReplace를 사용합니다. 다음 예제를 참조하세요.

PS C:\> "book" -Replace "B", "C"
          Cook
          PS C:\> "book" -iReplace "B", "C" 
          Cook
          PS C:\> "book" -cReplace "B", "C"
          book
 
         PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'`
                 | foreach {$_ -replace 'globbing="false"', 'globbing="true"'}
         <command:parameter required="false" variableLength="true" globbing="true"

비트 연산자

Windows PowerShell에서는 비트-AND(-bAnd), 포함 및 제외 비트-OR 연산자(-bOr 및 -bXor), 비트-NOT(-bNot)을 포함하여 표준 비트 연산자를 지원합니다.

Windows PowerShell 2.0부터 모든 비트 연산자는 64비트 정수에서 작동합니다.

Windows PowerShell에서 비트 산술을 지원하도록 Windows PowerShell 3.0부터 -shr(오른쪽으로 이동) 및 -shl(왼쪽으로 이동)이 도입되었습니다.

Windows PowerShell에서는 다음 비트 연산자를 지원합니다.

      Operator  Description               Example  
      --------  ----------------------    -------------------
      -bAnd     Bitwise AND               PS C:\> 10 -band 3
                                          2
 
      -bOr      Bitwise OR (inclusive)    PS C:\> 10 -bor 3
                                          11    

      -bXor     Bitwise OR (exclusive)    PS C:\> 10 -bxor 3
                                          9

      -bNot     Bitwise NOT               PS C:\> -bNot 10
                                          -11

      -shl      Shift-left                PS C:\> 100 -shl 2
                                          400
 
      -shr      Shift-right               PS C:\> 100 -shr 1
                                          50

비트 연산자는 이진 형식 값에서 작동합니다. 예를 들어 숫자 10의 비트 구조는 00001010(1바이트 기준)이고 숫자 3의 비트 구조는 00000011입니다. 비트 연산자를 사용하여 10과 3을 비교하면 각 바이트의 개별 비트가 비교됩니다.

비트 AND 연산에서는 두 입력 비트가 모두 1인 경우에만 결과 비트가 1로 설정됩니다.

1010      (10)
          0011      ( 3)
          --------------  bAND
          0010      ( 2)

비트 OR(포함) 연산에서는 두 입력 비트 중 하나 또는 모두가 1인 경우에 결과 비트가 1로 설정됩니다. 두 입력 비트가 모두 0으로 설정된 경우에만 결과 비트가 0으로 설정됩니다.

1010      (10)
          0011      ( 3)
          --------------  bOR (inclusive)
          1011      (11)

비트 OR(제외) 연산에서는 입력 비트 하나가 1인 경우에만 결과 비트가 1로 설정됩니다.

1010      (10)
          0011      ( 3)
          --------------  bXOR (exclusive)
          1001      ( 9)

비트 NOT 연산자는 값의 이진 보수를 생성하는 단항 연산자입니다. 1 비트는 0으로 설정되고 0 비트는 1로 설정됩니다.

예를 들어 0의 이진 보수는 -1(최대 부호 없는 정수(0xffffffff))이고 -1의 이진 보수는 0입니다.

PS C:\> -bNOT 10
          -11


          0000 0000 0000 1010  (10)
          ------------------------- bNOT
          1111 1111 1111 0101  (-11, xfffffff5) 

비트 왼쪽으로 이동 연산에서 모든 비트는 왼쪽으로 "n" 위치로 이동됩니다. 여기서 "n"은 오른쪽 피연산자의 값입니다. 1 위치에 0이 삽입됩니다.

왼쪽 피연산자가 정수(32비트) 값이면 이동되는 왼쪽 피연산자의 비트 수는 오른쪽 피연산자의 아래쪽 5비트에 따라 결정됩니다.

왼쪽 피연산자가 Long(64비트) 값이면 이동되는 왼쪽 피연산자의 비트 수는 오른쪽 피연산자의 아래쪽 6비트에 따라 결정됩니다.

PS C:\> 21 -shl 1
        42

          00010101  (21)
          00101010  (42)

        PS C:\> 21 -shl 2
        84

          00010101  (21)
          00101010  (42)
          01010100  (84)

비트 오른쪽으로 이동 연산에서 모든 비트는 오른쪽으로 "n" 위치로 이동됩니다. 여기서 "n"은 오른쪽 피연산자로 지정됩니다. 오른쪽으로 이동 연산자(-shr)는 양수 또는 부호 없는 값을 오른쪽으로 이동할 때 맨 왼쪽 위치에 0을 삽입합니다.

왼쪽 피연산자가 정수(32비트) 값이면 이동되는 왼쪽 피연산자의 비트 수는 오른쪽 피연산자의 아래쪽 5비트에 따라 결정됩니다.

왼쪽 피연산자가 Long(64비트) 값이면 이동되는 왼쪽 피연산자의 비트 수는 오른쪽 피연산자의 아래쪽 6비트에 따라 결정됩니다.

        PS C:\> 21 -shr 1
        10

          00010101  (21)
          00001010  (10)

        PS C:\> 21 -shr 2
        5

          00010101  (21)
          00001010  (10)
          00000101  ( 5)

참고 항목

about_Operators

about_Regular_Expressions

about_Wildcards

Compare-Object

Foreach-Object

Where-Object

커뮤니티 추가 항목

추가
표시: