Búsqueda de sitios web

Cómo comprobar si una matriz contiene una cadena que no distingue entre mayúsculas y minúsculas en PowerShell

Una tarea común cuando se trabaja con matrices en PowerShell es verificar si una matriz contiene una cadena específica. En PowerShell, la comparación de cadenas se puede realizar distinguiendo entre mayúsculas y minúsculas o sin distinguir entre mayúsculas y minúsculas. En este tutorial de PowerShell, explicaré cómo comprobar si una matriz contiene una cadena que no distingue entre mayúsculas y minúsculas en PowerShell.

Para verificar si una matriz contiene una cadena sin considerar mayúsculas y minúsculas en PowerShell, use el operador -inotcontains, que realiza una comparación que no distingue entre mayúsculas y minúsculas. Por ejemplo, $containsString=$array -inotcontains ‘string’ devolverá $true si la cadena ‘string’ se encuentra en la matriz $array, independientemente del caso. Alternativamente, puede usar -ccontains para una verificación que distinga entre mayúsculas y minúsculas.

Compruebe si una matriz contiene una cadena que no distingue entre mayúsculas y minúsculas en PowerShell

Una verificación que distingue entre mayúsculas y minúsculas tiene en cuenta las letras mayúsculas (mayúsculas o minúsculas) al comparar cadenas. Por el contrario, una verificación que no distingue entre mayúsculas y minúsculas ignora el caso y trata "PowerShell" de la misma manera que "powershell" o "POWERSHELL".

PowerShell proporciona diferentes operadores y métodos para realizar comparaciones de cadenas. Algunos no distinguen inherentemente entre mayúsculas y minúsculas, mientras que otros sí lo hacen de forma predeterminada, pero pueden modificarse para realizar comparaciones que no distingan entre mayúsculas y minúsculas.

Usando el operador -contiene

PowerShell tiene un operador integrado llamado -contains que verifica si una colección, como una matriz, incluye un elemento específico. El operador -contains no distingue entre mayúsculas y minúsculas de forma predeterminada.

He aquí un ejemplo sencillo:

$array = 'Apple', 'Banana', 'Cherry'
$stringToCheck = 'apple'

if ($array -contains $stringToCheck) {
    Write-Host "The array contains the string."
} else {
    Write-Host "The array does not contain the string."
}

En este ejemplo, aunque 'Apple' en la matriz tiene una 'A' mayúscula y la variable $stringToCheck está en minúsculas, el operador -contains confirmará que 'apple' ' está en la matriz.

Puedes ver la captura de pantalla a continuación:

Usando el método .Contains()

Otra forma de comprobar la presencia de una cadena en una matriz es utilizar el método .Contains() en PowerShell. Sin embargo, a diferencia del operador -contains, el método .Contains() distingue entre mayúsculas y minúsculas. Para que no distinga entre mayúsculas y minúsculas, tanto los elementos de la matriz como la cadena a verificar deben convertirse al mismo caso usando los métodos .ToLower() o .ToUpper() antes. comparación.

A continuación se explica cómo puede utilizar el método .Contains() sin distinguir entre mayúsculas y minúsculas:

$array = 'Apple', 'Banana', 'Cherry'
$stringToCheck = 'apple'

# Convert both to the same case
$lowerCaseArray = $array.ToLower()
$lowerCaseStringToCheck = $stringToCheck.ToLower()

if ($lowerCaseArray.Contains($lowerCaseStringToCheck)) {
    Write-Host "The array contains the string."
} else {
    Write-Host "The array does not contain the string."
}

Una vez que ejecute el script de PowerShell usando vs. code o Windows PowerShell ISE, podrá ver el resultado en la siguiente captura de pantalla:

Uso del cmdlet Where-Object

El cmdlet Where-Object de PowerShell le permite filtrar objetos según sus propiedades o bloques de script. Puede usar este cmdlet para realizar una búsqueda que no distinga entre mayúsculas y minúsculas mediante un bloque de secuencia de comandos que compara los elementos de la matriz con la cadena deseada y convierte ambos al mismo caso.

Aquí hay un ejemplo usando Where-Object:

$array = 'Apple', 'Banana', 'Cherry'
$stringToCheck = 'apple'

$result = $array | Where-Object { $_.ToLower() -eq $stringToCheck.ToLower() }

if ($result) {
    Write-Host "The array contains the string."
} else {
    Write-Host "The array does not contain the string."
}

Usando el operador -match

El operador -match utiliza expresiones regulares (expresiones regulares) para comparar cadenas y no distingue entre mayúsculas y minúsculas de forma predeterminada en PowerShell. Este operador puede resultar útil cuando necesita comprobar patrones en lugar de cadenas exactas.

Aquí hay un ejemplo usando -match:

$array = 'Apple', 'Banana', 'Cherry'
$stringToCheck = 'apple'

$result = $array -match $stringToCheck

if ($result) {
    Write-Host "The array contains the string."
} else {
    Write-Host "The array does not contain the string."
}

Conclusión

Comprobar si una matriz contiene una cadena específica es una tarea común en las secuencias de comandos de PowerShell. PowerShell proporciona varias formas de realizar esta verificación, siendo la distinción entre mayúsculas y minúsculas el comportamiento predeterminado para algunos operadores y métodos, como -contains y -match. Para los métodos que distinguen entre mayúsculas y minúsculas de forma predeterminada, como .Contains(), puede realizar fácilmente una comparación que no distingue entre mayúsculas y minúsculas convirtiendo las cadenas al mismo caso antes de verificar.

En este tutorial de PowerShell, explicaré cómo verificar si una matriz contiene una cadena que no distingue entre mayúsculas y minúsculas en PowerShell usando los siguientes métodos:

  • Usando el operador -contiene
  • Usando el método .Contains()
  • Uso del cmdlet Where-Object
  • Usando el operador -match

Artículos relacionados