Powershell сравнение строк: Строки в PowerShell — Клёвый код

Содержание

Строки (Часть 2) » Pechenek.NET

Powershell – Строки (Часть 1). В первой части мы рассмотрели примерно половину всех возможных свойств и методов работы со строкой. В этой статье мы разберем оставшуюся половину и попробуем написать интересные кейсы, которые помогут вам экспериментировать.

Powershell – Строки

Не будет ходить вокруг да около Давайте продолжим с места, на котором остановились. А остановились мы на сравнении строк методом CompareTo.

  • Как сравнить строки? – str.Equals()

Метод проводит сравнение между строками. В отличии от CompareTo, который выводит нули и единицы, метод Equals выводит True или False:

$text=»Too many of random object models» $text2 = $text $text2.Equals($text) True $text2 = $text2 + «on page» $text2.Equals($text) False

$text=»Too many of random object models»

$text2 = $text

$text2.Equals($text)

True

$text2 = $text2 + «on page»

$text2.Equals($text)

False

У метода Equals есть реализация в виде оператора -eq, который выполняет такую же операцию. Соответственно можно воспользоваться инструкцией:

  • Как найти совпадения в строке? – str.Contains()

Этот метод определяет, содержится ли подстрока в строке и в зависимости от результата выводит True или False:

$text2.Contains(«Too») True $text2.Contains($text) True $text2.Contains($text + «on page») True $text2.Contains($text + «on street») False

$text2.Contains(«Too»)

True

$text2.Contains($text)

True

$text2.Contains($text + «on page»)

True

$text2.Contains($text + «on street»)

False

  • Как найти значение в начале или конце строки? – str.StartsWith()/str.EndsWith()

Это регистрозависимые методы, которые определяют начинается ли строка с указанной подстроки(StartWith) и заканчивается ли строка указанной подстрокой (EndsWith). В зависимости от результата методы возвращают True или False:

$text.StartsWith(«Too») True $text.StartsWith(«many») False $text.EndsWith(«many») False $text.EndsWith(«models») True

$text.StartsWith(«Too»)

True

$text.StartsWith(«many»)

False

$text.EndsWith(«many»)

False

$text.EndsWith(«models»)

True

  • Как сделать все символы строки строчными или заглавнойstr.ToUpper()/str.ToLower()

Это два регистрозависимых метода, которые приводят всю строку к заглавным буквам (ToUpper) и наоборот вся строка приводится к строчным буквам (ToLower):

$text3 = $text $text3.ToUpper() TOO MANY OF RANDOM OBJECT MODELS $text3.ToLower() too many of random object models

$text3 = $text

$text3.ToUpper()

TOO MANY OF RANDOM OBJECT MODELS

$text3.ToLower()

too many of random object models

  • Как найти первое вхождение значения? – str.IndexOf()

Метод определяет индекс первого вхождения подстроки в строке. Создаем новую переменную:

$string = «i’m the best, i’m best of the best, i’m best of best of the best» $string.IndexOf(«best») 8

$string = «i’m the best, i’m best of the best, i’m best of best of the best»

$string.IndexOf(«best»)

8

  • Как найти последнее вхождение значения? – str.LastIndexOf()

А этот метод определяет индекс последнего вхождения подстроки в строке и выглядит это так:

$string.LastIndexOf(«best») 60

$string.LastIndexOf(«best»)

60

  • Как найти первое вхождение любого из переданных значений? – str.IndexOfAny()

Этот метод будет искать самое первое вхождение любого из символов слова или букв, переданных параметром методу:

$string.IndexOfAny(«best») 4

$string.IndexOfAny(«best»)

4

В строке в индексом 4 у нас находится буква t.

  • Как найти последнее вхождение любого из переданных значений? – str.LastIndexOfAny()

Будет искать самое последнее вхождение любого из символов слова или букв, которые будут переданы в качестве параметра методу:

$string.LastIndexOfAny(«best») 63

$string.LastIndexOfAny(«best»)

63

Снова попала буква t, которая является последним символом переменной.

  • Как добавить в начало или конец строки символы? – str.PadLeft/Right()

Методы позволяют дополнять строку до нужного количества символов. Можно использовать как совместно, так и раздельно:

$string.PadLeft(67, «.») …i’m the best, i’m best of the best, i’m best of best of the best $string.PadRight(71, «!») i’m the best, i’m best of the best, i’m best of best of the best!!!!!!! $string.PadRight(67, «!»).PadLeft(71, «.») ….i’m the best, i’m best of the best, i’m best of best of the best!!!

$string.PadLeft(67, «.»)

…i’m the best, i’m best of the best, i’m best of best of the best

 

$string.PadRight(71, «!»)

i’m the best, i’m best of the best, i’m best of best of the best!!!!!!!

 

$string.PadRight(67, «!»).PadLeft(71, «.»)

….i’m the best, i’m best of the best, i’m best of best of the best!!!

  • Как обрезать повторяющиеся символы в начале или конце строки? – str.TrimStart/str.TrimEnd/str.Trim

Методы TrimStartTrimEnd и Trim обрезают повторяющиеся символы по бокам строки. Start делает это в начале, End в конце, а Trim по обеим сторонам:

$substring.TrimStart(«.») i’m the best, i’m best of the best, i’m best of best of the best!!! $substring.TrimEnd(«!») ….i’m the best, i’m best of the best, i’m best of best of the best $substring.Trim(«!», «.») i’m the best, i’m best of the best, i’m best of best of the best

$substring.TrimStart(«.»)

i’m the best, i’m best of the best, i’m best of best of the best!!!

 

$substring.TrimEnd(«!»)

….i’m the best, i’m best of the best, i’m best of best of the best

 

$substring.Trim(«!», «.»)

i’m the best, i’m best of the best, i’m best of best of the best

Итог:

В целом обработка строк обычными методами на этом завершается. Тем не менее, есть еще статические методы, которые позволяют обрабатывать строки. В ближайшее время появится статья и на тему работы статических методов. А на сегодня спринт по обработке строк завершен! Надеемся статья была для вас полезна! Если у вас остались вопросы – задавайте их в комментариях, ответим всем и каждому. Не забывайте про сообщество в контакте и канал на ютубчике!

Powershell — Операторы сравнения » Pechenek.NET

Уже неоднократно в наших статьях встречались операторы сравнения, например, когда мы разбирали Where-Object. В этой статье мы наконец-то разберем их все, чтобы уже понять окончательно как работают эти операторы. Как ни странно, вас ожидает длиннопост.

Powershell – Операторы сравнения

Equal / -eq

Начнем с самого известного и часто встречающегося. Оператор equal. Он проводит сравнение сравнение двух выражений и определяет равны ли они. Давайте попробуем использовать его самым простым способом:

Здесь все просто. Equal в своей сущности эквивалентен оператору = в других языках программирования. Рассмотрим более сложный пример и попробуем сравнить строки:

$a = «123» $b = 123 $a -eq $b True

$a = «123»

$b = 123

$a -eq $b

True

Здесь сложнее, казалось бы, переменные имеют разный тип с одинаковым значением. Разве не должно ли вернуться false? Нет, потому что equal ищет совпадения, а не проверяет тип данных. Оператором equal можно пользоваться в циклах. Например:

if ($a -eq $b) { «переменные равны» } else { «переменные неравны» } переменные равны

if ($a -eq $b) {

   «переменные равны»

} else {

   «переменные неравны»

}

переменные равны

В такой ситуации проверяется условие находящееся в скобках. Так как переменные по значениям не отличаются возвращается True и выполняется первый блок кода.

Not equal / -ne

Здесь все работает с точностью, да наоборот. Если переменные не равны, возвращается true, если равны возвращается false. Пример:

Думаю понятно. Применение такое же – любые логические сравнения. Перейдем к следующему оператору.

Greater than or equal / -ge

Этот оператор вычисляет равно или больше левое выражение правому. Здесь важно понимать логику. Если выражение слева равно правому, возвращается True. Если выражение слева больше, возвращает тоже True. Тоже самое работает и в обратную сторону. То есть если выражение слева, меньше возвращается false. Например:

if (3 -ge 2) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева больше или равно if (2 -ge 2) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева больше или равно if (2 -ge 3) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева меньше

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

if (3 -ge 2) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева больше или равно

 

if (2 -ge 2) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева больше или равно

 

if (2 -ge 3) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева меньше

Надеюсь с этим разобрались. Опять же, применение такое же, как и у операторов выше.

Greater Than / -gt

Этот оператор вычисляет больше ли левое выражение, чем правое или нет. Эквивалентен оператору > в других языках программирования. Что интересно, если попробовать выяснить одинаковые ли значения по обе стороны от оператора, то вернется false. Этот оператор не сравнивает, а выясняет больше или нет. Пример:

if (3 -gt 2) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева больше if (3 -gt 4) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева меньше if (3 -gt 3) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева меньше

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

if (3 -gt 2) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева больше

 

if (3 -gt 4) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева меньше

 

if (3 -gt 3) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева меньше

Less Than / -lt

Противоположность Greater Than. Выясняет меньше ли левое значение, чем правое. Возвращает True, если левое выражение меньше, и false, если левое выражение больше. Например:

1 -lt 2 True 3 -lt 2 False

1 -lt 2

True

 

3 -lt 2

False

Less than or equal / -le

Меньше или равно. Противоположность оператору Greater than or equal. Возвращает значение True, если левое выражение меньше или равно, чем правое. Возвращает false, если левое выражение больше, чем правое. Пример:

3 -le 2 False 1 -le 2 True 2 -le 2 True

3 -le 2

False

 

1 -le 2

True

 

2 -le 2

True

Все это были простые логические операторы. Теперь перейдем к более сложным.

Wildcard comparison / -like

Допустим у вас есть выборка сервисов, из которых вам нужен только единственный. Из его названия вы знаете только часть. В таком случае на помощь приходит оператор -like. В той же статье, про оператор Where мы использовали его. Like ищет соответствия в исходной строке, и выводит все, которые полностью или частично подходят:

get-service | Where Name -like «search»

get-service | Where Name -like «search»

Обратите внимание, сейчас вывода никакого не последовало. В такой конструкции like будет искать исключительно точные совпадения. Чтобы найти все неточные, нужно поставить звездочки вокруг целевого имени:

get-service | Where Name -like «*search*» Status Name DisplayName —— —- ———— Running WSearch Windows Search

get-service | Where Name -like «*search*»

 

Status   Name               DisplayName

——   —-               ————

Running  WSearch            Windows Search

Еще пример:

ls | Where Name -like «D*» Каталог: C:\Users\Дом Mode LastWriteTime Length Name —- ————- —— —- d-r— 29.01.2020 19:51 Desktop d-r— 18.01.2020 20:38 Documents d-r— 27.01.2020 19:15 Downloads

ls | Where Name -like «D*»

 

    Каталог: C:\Users\Дом

 

 

Mode                LastWriteTime         Length Name

—-                ————-         —— —-

d-r—       29.01.2020     19:51                Desktop

d-r—       18.01.2020     20:38                Documents

d-r—       27.01.2020     19:15                Downloads

Обратный Wildcard comparison / -notlike

Этот оператор работает наоборот. Ищет все несовпадения. Допустим нам нужны файлы где нет буквы D:

ls | Where Name -notlike «*D*» Каталог: C:\Users\Дом Mode LastWriteTime Length Name —- ————- —— —- d—— 26.08.2019 21:04 .config d—— 26.08.2019 21:38 .nuget d—— 18.01.2020 20:39 .oracle_jre_usage d—— 26.08.2019 18:58 .templateengine d—— 26.08.2019 18:56 .vsts d—— 26.08.2019 20:02 .WebStorm2019.1 d—— 30.11.2019 20:10 ansel d-r— 17.11.2019 11:30 Contacts d-r— 17.11.2019 11:30 Favorites d-r— 17.11.2019 11:30 Links d-r— 17.11.2019 11:30 Music d-r— 17.11.2019 11:30 Pictures d-r— 17.11.2019 11:30 Searches d—— 26.08.2019 21:09 WebstormProjects -a—- 24.09.2019 21:24 121 .yarnrc -a—- 26.08.2019 21:08 90 yarn.lock

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

ls | Where Name -notlike «*D*»

 

    Каталог: C:\Users\Дом

 

Mode                LastWriteTime         Length Name

—-                ————-         —— —-

d——       26.08.2019     21:04                .config

d——       26.08.2019     21:38                .nuget

d——       18.01.2020     20:39                .oracle_jre_usage

d——       26.08.2019     18:58                .templateengine

d——       26.08.2019     18:56                .vsts

d——       26.08.2019     20:02                .WebStorm2019.1

d——       30.11.2019     20:10                ansel

d-r—       17.11.2019     11:30                Contacts

d-r—       17.11.2019     11:30                Favorites

d-r—       17.11.2019     11:30                Links

d-r—       17.11.2019     11:30                Music

d-r—       17.11.2019     11:30                Pictures

d-r—       17.11.2019     11:30                Searches

d——       26.08.2019     21:09                WebstormProjects

-a—-       24.09.2019     21:24            121 .yarnrc

-a—-       26.08.2019     21:08             90 yarn.lock

Получаем соответствующий вывод.

Regular expression comparison / -match

Оператор match может быть использован по-разному. Например так:

«powershell» <strong>-match</strong> «power» True «powershell» <strong>-match</strong> «powerstring» False

«powershell» <strong>-match</strong> «power»

True

 

«powershell» <strong>-match</strong> «powerstring»

False

Или вот так:

$WMI = Get-WmiObject -List | Where-Object {$_.name <strong>-Match</strong> «network»} $WMI NameSpace: ROOT\cimv2 Name Methods Properties —- ——- ———- Win32_NetworkLoginProfile {} {AccountExpires, AuthorizationFlags, BadPasswordCount, Capt… Win32_NetworkAdapterConfiguration {EnableDHCP, Rene… {ArpAlwaysSourceRoute, ArpUseEtherSNAP, Caption, DatabasePa… Win32_NetworkAdapterSetting {} {Element, Setting}

$WMI = Get-WmiObject -List | Where-Object {$_.name <strong>-Match</strong> «network»}

$WMI

NameSpace: ROOT\cimv2

 

Name                                Methods              Properties

—-                                ——-              ———-

Win32_NetworkLoginProfile           {}                   {AccountExpires, AuthorizationFlags, BadPasswordCount, Capt…

Win32_NetworkAdapterConfiguration   {EnableDHCP, Rene… {ArpAlwaysSourceRoute, ArpUseEtherSNAP, Caption, DatabasePa…

Win32_NetworkAdapterSetting         {}                   {Element, Setting}

Обратный Regular expression comparison / -notmatch

Оператор -notmatch делает все наоборот, если совпадений выводится True и False, если совпадения есть. Пример:

«powershell» -notmatch «powerstring» True

«powershell» -notmatch «powerstring»

True

Есть еще операторы -replace, -contains и -not-contains. Но их мы рассмотрим позднее.

Так же есть операторы проверяющие принадлежность переменной к типу -is, -isnot и -as. Например:

$a=»123″ $b=123 $a -is «Int» False $a -is «String» True $b -is «String» False $b -is «Int» True $b -as «Int» 123 $b -as «Bool» True $b -isnot «Bool» True $b -isnot «String» True $b -isnot «Int» False

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

$a=»123″

$b=123

 

$a -is «Int»

False

 

$a -is «String»

True

 

$b -is «String»

False

 

$b -is «Int»

True

 

$b -as «Int»

123

 

$b -as «Bool»

True

 

$b -isnot «Bool»

True

 

$b -isnot «String»

True

 

$b -isnot «Int»

False

Оператор -as представляет выражение в типе, который вы ему укажете.

$b -as «Int» 123 $b -as «String» 123 $b -as «Boolean» True

$b -as «Int»

123

 

$b -as «String»

123

 

$b -as «Boolean»

True

Итог

В данной статье мы рассмотрели все операторы сравнения в powershell. В следующих двух мы выделим для операторов -replace, -contains и -notcontains, а так же -and, -or, -not, xor и !. Надеюсь данная статья была для вас полезной! Если у вас остались вопросы, тогда пишите их в комментариях, ответим на все. Подписывайтесь на нашу группу в ВК, канал на ютубе, а так же канал в телеграме! Благодарим за проявленный интерес.

Операторы сравнения в PowerShell | Digital Cub.

В powershell операторы сравнения отличаются от принятой номенклатуры используемой в других языках.
Все популярные операторы сведены к нескольким таблицам

by Gistek


По умолчанию все операторы сравнения не являются чувствительными к регистру.

-eq Equal Равно
-ne Not equal Не Равно
-ge Greater than or equal Больше или Равно
-gt Greater than Больше
-lt Less than Меньше
-le Less than or equal Меньше или Равно
-like Wildcard comparison Использование символов подстановки для поиска соответствия образцу
-notlike Wildcard comparison Использование символов подстановки для поиска несоответствия образцу
-match Regular expression comparison Использование регулярных выражений для поиска соответствия образцу, например Regexp для IP-адреса такой: «\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}» (правда он не распознает невалидные адреса, но это уже проблема логики скрипта, а не Regexp’а)
-notmatch Regular expression comparison Использование регулярных выражений для поиска несоответствия образцу. Подробнее про regexp в powershell можно почитать на Technet
-replace Replace operator Заменяет часть или все значение слева от оператора
-contains Containment operator Определение, содержит ли значение слева от оператора значение справа. В отличие от предыдущих операторов, результатом является булево значение
-notcontains Containment operator Определение того, что значение слева от оператора не содержит значение справа. Результатом является булево значение

Для сравнения с учетом регистра к команде подставляется префикс “c“. Для примера, оператор -eq с зависимостью от регистра изменяется на “-ceq”.

Для явно заданного независящего от регистра сравнения к команде подставляется префикс “i“. Пример: оператор -replace без зависимости от регистра будет -ireplace

Типы

-is Является типом (e.g. $a -is [int] )
-isnot Не является типом (e.g. $a -isnot [int] )
-as Как тип, без ошибки если возникает неудача преобразования (e.g. 1 -as [string] treats 1 as a string )

Логические операторы PowerShell

-and Оба условия должны быть истины, чтобы выражение было истинно (e.g. ($a -ge 5 -AND $a -le 15) )
-or Одно или оба условия должны быть истины, чтобы выражение было истинно (e.g. ($a –eq “A” –OR $a –eq “B”) )
-xor Одно условие должно быть истинно, а второе должно иметь значение “ложь”, чтобы выражение было истинно
-not Указанные условия должны иметь значение “ложь”, чтобы выражение было истинно
-band binary and
-bor binary or
-bnot binary not
! Указанное условие должно иметь значение “ложь”, чтобы выражение было истинно
.. Range operator (e.g.   foreach ($i in 1..10) {$i } )
& call operator (e.g. $a = “Get-ChildItem” &$a executes Get-ChildItem)
. (dot followed by a space) call operator (e.g. $a = “Get-ChildItem” . $a executes Get-ChildItem in the current scope)
-F Format operator (e.g. foreach ($p in Get-Process) { “{0,-15} has {1,6} handles” –F   $p.processname,$p.Handlecount } )

Операторы сравнения Powershell | FixMyPC

С помощью операторов сравнения в powershell мы можем выяснить содержит ли значение какую-то строку, равно, больше или меньше какого-то значения и т.д. Обычно мы привыкли использовать <, >, !=, = и другие символы, но в powershell все работает иначе. 

У нас есть такие операторы в powershell:

Операторы возвращают True, если утверждение верно и False, если нет

 

Оператор сравнения Powershell EQ

На примере сравнения дат:


(Get-Date).Day -eq 8

Вернет True, т.к. сегодня 8-ой день месяца и оба значения равны. Даты, за исключением дня месяца, должны быть в специальном формате datetime.

Или иначе:


(Get-Date) -eq ((Get-Date).AddDays(-15))

Вернет False т.к. слева сегодняшняя дата с права 15 дней до.

Так мы можем найти файлы, которые были 7 дней назад:


Get-ChildItem | where {$_.CreationTime -eq ((Get-Date).AddDays(-7))}

 

Оператор сравнения Powershell LT и LE

Опять же сравним даты powershell:


$today = Get-Date
$next_week = Get-Date -Day 15 -Year 2019 -Month 7
$today -lt $next_week

Вернет False т.к. дата справа меньше чем слева.


$last_year = Get-Date -Year 2018
$today_year = (Get-Date).Year
$last_year.Year -lt $today_year

Вернет True.

Оператор LE в отличие от LT вернет True так же, если значение равно:


2018 -le 2018

Так мы найдем файлы, которые были созданы менее чем 7 дней назад или созданные в 18 день месяца:


Get-ChildItem | where {$_.CreationTime -le ((Get-Date).AddDays(-7)) -or ($_.CreationTime).Day -eq 18 }

 

Оператор сравнения Powershell GT и GE

Работает аналогично:


1 -GT 2

Вернет False т.к. 1 не больше 2


1 -GE 1

Вернут True т.к. мы проверяем еще и равенство.


"Four".length -GE 4

Тоже вернет True т.к. длина строки Four 4.

На примере поиска процессов:


Get-Process | where {$_.Processname -eq "svchost" -and $_.CPU -gt 5}

Т.е. мы ищем процессы, где имя равно svchost и значение CPU больше 5.

 

Оператор сравнения Powershell Like и Match

Like от Match отличается в тем, что в Like мы ищем строчки используя Wildcardr *, а в Match мы можем использовать регулярные выражения:


"fixmypc" -like "*fix*"

Вернет True, т.к. * говорит что слева и справа может находиться еще символы.

Если добавить букву c, получится -clike, что значит Case-Sensetive (чувствителен к регистру). В этом случае буква А и а будут разными. По умолчанию, в windows регистр не имеет значение:


"Fixmypc" -clike "fix"

Так мы уберем из вывода все процессы, которые не содержат sv в начале и t в конце строки:


Get-Process | where {$_.Name -notlike "sv*t"}

В этом случае вернется True:


"TestWord" -match "estW"

А в этом только строковые значения:


"Один", 1 ,"два", 2, "три", 3 -match "[А-я]"

В этом только значения, где есть числа от 2 до 9:


"Один1", 1, "два2", 2, "три3", 3 -match "[2-9]"

Теги: #powershell

PowerShell — Операторы сравнения | powershell Tutorial

пример

Операторы сравнения PowerShell состоят из ведущего тире ( - ), за которым следует имя ( eq для equal , gt для greater than и т. Д.).

Именам могут предшествовать специальные символы для изменения поведения оператора:

i # Case-Insensitive Explicit (-ieq)
c # Case-Sensitive Explicit (-ceq)

Нечувствительность к регистру — это значение по умолчанию, если не указано, («a» -eq «A») такое же, как («a» -ieq «A»).

Простые операторы сравнения:

2 -eq 2    # Equal to (==)
2 -ne 4    # Not equal to (!=)
5 -gt 2    # Greater-than (>)
5 -ge 5    # Greater-than or equal to (>=)
5 -lt 10   # Less-than (<)
5 -le 5    # Less-than or equal to (<=)

Операторы сравнения строк:

"MyString" -like "*String"            # Match using the wildcard character (*)
"MyString" -notlike "Other*"          # Does not match using the wildcard character (*)
"MyString" -match "$String^"          # Matches a string using regular expressions
"MyString" -notmatch "$Other^"        # Does not match a string using regular expressions

Операторы сравнения коллекции:

"abc", "def" -contains "def"            # Returns true when the value (right) is present
                                        # in the array (left)
"abc", "def" -notcontains "123"         # Returns true when the value (right) is not present
                                        # in the array (left)
"def" -in "abc", "def"                  # Returns true when the value (left) is present
                                        # in the array (right)
"123" -notin "abc", "def"               # Returns true when the value (left) is not present
                                        # in the array (right)



Функции по работе со строками в Powershell

Любой тип данных в Powershell может использовать методы объектов .NET. Каждый из этих методов можно использовать либо в виде команды, ключа или метода .Net. Узнать тип данных, у любого объекта Powershell, который находится в переменной можно через один из таких методов:


$a = 'Journey'
$a.GetType()

В колонке Name отображается тип строка. Со строками часто нужно переводить их в другой регистр, измерять длину, заменять символы.

Для примера переведем строку в верхний регистр:


'RegisTR'.ToLower()

Или обратная операция, которая переведет строку Powershell в верхний регистр:


'RegisTR'.ToUpper()

Можно проверить содержание символов в конце строки, которое вернет булевое значение True при положительном результате:


'Konec'.EndsWith('ec')

Или в начале:


'Konec'.StartsWith('Ko')

Обратите внимание, что регистр букв имеет значение:

Можно использовать несколько методов один за другим:


'Konec'.ToLower().StartsWith('ko')

Поиск подстроки в Powershell, тоже возвращает булевое значение:


'Один два три'.Contains('два')

Можно вернуть номер первого упомянутого символа — это называется индексом:


'Один два три'.IndexOf('и')

Или вернуть последний индекс последнего символа, так как в этой строке несколько букв ‘И’


'Один два три'.LastIndexOf('и')

По этим индексам можно получить срез подстроки в Powershell. В моем случае первый индекс — это знак пробела:


$first_index = 'Вырез срез slice'.IndexOf(' ')
'Вырез срез slice'.Substring($first_index)

Можно указать второй индекс, но нужно помнить, что после объявления первого индекса второй должен объявляться относительно первого:


'Вырез срез slice'.Substring(6,5)

Вставка новой строки по индексу:


'cрез'.Insert(0, 'Как делать ')

Измерение длины строки в Powershell:


'Длина строки'.Length

Метод replace в Powershell мы уже разбирали в виде ключа и регулярных значений. Это пример метода .NET. Как и методы выше тут важен регистр символов:


'Длина строки'.Replace('Длина', 'Замена')

Один из самых частых методов в Powershell это преобразование строки в массив. В моем случае разделитель пробел, но может быть любой другой:


'Логин пароль'.Split(' ')

 

Удаление пробелов в Powershell в начале и конце строки:


'    Удаление пробелов    '.Trim()

Теги: #powershell

Оптимизация работы со строками в Powershell / Хабр

Вводная: с данной заметке описывается как получить ускорение в 5-10 (и более раз) при обработке большого количества строк используя вместо String объект StringBuilder.

Вызов конструктора System.Text.StringBuilder:

$SomeString = New-Object System.Text.StringBuilder

Обратное преобразование в String:
$Result = $Str.ToString()

Во время написании скрипта, обрабатывающего много текстовых файлов, была обнаружена особенность работы со строками в powershell, а именно — значительно снижается скорость парсинга, если пытаться обработать строки при помощи стандартного объекта string.

Исходные данные — файл забитый строками по типу:

key;888;0xA9498353,888_FilialName

В сырой версии скрипта для контроля обработки применялись промежуточные текстовые файлы, потери времени на обработку файла в 1000 строк — 24 секунды, при увеличении размера файла задержка быстро растет. Пример:

function test 
    {
    $Path = 'C:\Powershell\test\test.txt'

    $PSGF = Get-Content $Path

    # создаем файл
    $PSGFFileName = $Path + '-compare.txt'
    Remove-Item -Path $PSGFFileName -ErrorAction SilentlyContinue | Out-Null
    New-Item $PSGFFileName -Type File -ErrorAction SilentlyContinue | Out-Null

    # ToDo
    # в этом блоке теряется время, надо оптимизировать.
    # не использовать промежуточный файл Add-Content, потери на нем
    foreach ($Key in $PSGF)
    {
        $Val = $Key.ToString().Split(';')
        $test = $val[2]
        $Val = $test.ToString().Split(',')
        $test = $Val[0]
        Add-Content $PSGFFileName -Value $Test
    }

    $Result = Get-Content $PSGFFileName
    Remove-Item -Path $PSGFFileName -ErrorAction SilentlyContinue | Out-Null
    ### не оптимизированный код # end ################################
    return $Result
    }

Результат прогона:

99 строк — 1,8 секунды
1000 строк — 24,4 секунды
2000 строк — 66,17 секунды

Оптимизация №1

Ясно, что это никуда не годится. Заменяем выгрузку в файл операциями в памяти:
function test 
    {
    $Path = 'C:\Powershell\test\test.txt'

    $PSGF = Get-Content $Path
    $Result = ''

    # 
    foreach ($Key in $PSGF)
    {
        $Val = $Key.ToString().Split(';')
        $test = $val[2]
        $Val = $test.ToString().Split(',')
        $test = $Val[0]
        $Result = $Result + "$test`r`n"
    }

    return $Result
    }

Measure-Command {  test }

Результат прогона:

99 строк — 0.0037 секунды
1000 строк — 0.055 секунды
2000 строк — 0.190 секунды

Вроде бы все хорошо, ускорение получено, но давайте посмотрим что происходит если строк в объекте больше:

10000 строк — 1,92 секунды
20000 строк — 8,07 секунды
40000 строк — 26,01 секунд

Такой метод обработки подходит для списков не более чем 5-8 тысяч строк, после начинаются потери на конструкторе объекта, менеджер памяти постоянно выделяет новую память при добавлении строки и копирует объект.

Оптимизация №2

Попробуем сделать лучше, используем «программистский» подход:
function test 
    {
    $Path = 'C:\Powershell\test\test.txt'

    $PSGF = Get-Content $Path

    # берем объект из дотнета
    $Str = New-Object System.Text.StringBuilder

    foreach ($Key in $PSGF)
    {
        $Val = $Key.ToString().Split(';')
        $temp = $val[2].ToString().Split(',')
        $Val = $temp
        $temp = $Str.Append( "$Val`r`n" )
    }

    $Result = $Str.ToString()
    }

Measure-Command {  test }

Результат прогона: 40000 строк — 1,8 секунды.

Дальнейшие улучшения типа замены foreach на for, выбрасывание внутренней переменной $test не дали значимого прироста скорости.

Кратко:

Для эффективной работы с большим количеством строк используйте объект System.Text.StringBuilder. Вызов конструктора:

$SomeString = New-Object System.Text.StringBuilder

Преобразование в строку:
$Result = $Str.ToString()

Объяснение работы StringBuilder (весь секрет в более эффективной работе менеджера памяти).

Операторы сравнения — PowerShell — SS64.com

Операторы сравнения — PowerShell — SS64.com

Все следующие операторы по умолчанию не чувствительны к регистру:

 -экв Равно
 -ne Не равно
 -ge Больше или равно
 -gt Больше чем
 -lt меньше чем
 -le Меньше или равно
 -like Сравнение подстановочных знаков
 -notlike Сравнение подстановочных знаков
 -match Сравнение регулярных выражений
 -notmatch Сравнение регулярных выражений
 -replace Заменить оператор
 -содержит оператор сдерживания
 -notcontains Оператор сдерживания
 -in Подобно –contains, но с обратными операндами.(PowerShell 3.0)
 -notin Аналогично –notcontains, но с перевернутыми операндами (PowerShell 3.0) 

Чтобы выполнить сравнение с учетом регистра, просто добавьте к любому из вышеперечисленных префиксов «c»
например -ceq для чувствительного к регистру Равно или -creplace для чувствительного к регистру замены.

Точно так же префикс с «i» явно сделает оператор нечувствительным к регистру.
Кажется вероятным, что эти короткие имена, такие как -eq, были выбраны для операторов вместо символов (= / <> и т. Д.), Чтобы разрешить эти чувствительные к регистру параметры.

 Типы
 -это типа
 -isnot Не является типом
 -as Как тип, нет ошибки при сбое преобразования

Логические операторы
 -и логическое И
 -или логический или
 -xor Логический эксклюзив Или
 -не логично не
  ! логическое не

Побитовые операторы
 -band Побитовый и
 -bor Побитовое или
 -bXor Побитовое ИЛИ (исключающее)
 -b Не побитовое НЕ
 -shl Сдвиг бит влево (PowerShell 3.0)
 -shr Сдвиг бит вправо - сохраняет знак для значений со знаком.(PowerShell 3.0)
 
Оператор формата
 " format_string "  -f   Object1 ,  Object2 , ...
 

Формат_строка имеет вид: {0, -5} {1, -20} {2, -10}
В каждом наборе фигурных скобок первое число перед запятой. относится к столбцу.
Второе число после запятой определяет отступ (сколько символов)
Если второе число отрицательное, оно не только дополняет элемент, но и выравнивает его по вертикали.При желании второе число может использоваться для форматирования: чч: мм: C: p

При применении к массиву операторы сравнения будут работать как фильтр, возвращающий все совпадающие значения.

Фильтры

Фильтр PowerShell принимает следующие операторы
-eq
-ne
-ge
-gt
-lt
-le
-как
-не как
-приблизительно
-бор
-полоса
-рекурсивное совпадение

Обратите внимание, что в этом списке отсутствуют несколько полезных операторов, таких как -match и -contains, но они все еще могут быть использованы путем передачи по конвейеру к предложению Where-Object:
… | Где {$ _. Name –match ‘value’}

Примеры

$ демо = $ null
if ( -Not ($ demo) ) {напишите «Zero, null or Empty»}
if (! ($ demo) ) {напишите «Ноль, ноль или пустой»}

$ myVar -is «Строка»
$ myVar -eq 123
$ myVar -ceq $ myVar2
«abcdef» -подобный «abc *»
«abcdef» — ​​заменить «dEf», «xyz»
$ myVar1 -is «String» -and $ myVar2 -is «Int»
«{2: N}» -f 24.4567
(1 -eq 1) -and -not (2 -gt 2)

$ mycmd = ps | выберите идентификатор, ProcessName
foreach ($ proc в $ mycmd) { «{0, -8} {1, -20}» -f $ proc.id, $ proc.ProcessName }

«Правило 50-50-90: каждый раз, когда у вас есть 50-50 шансов сделать что-то правильно, существует 90% -ная вероятность, что вы сделаете это неправильно» ~ Энди Руни

Связанные командлеты PowerShell:

if — Условно выполнить команду.
Операторы присваивания ($ variable = X, $ variable + = Y)
Регулярные выражения PowerShell
Таблица форматов


Авторские права © 1999-2020 SS64.com
Некоторые права защищены.

Ускорение сравнения массивов в Powershell с помощью регулярного выражения среды выполнения

Резюме : узнайте, как ускорить сравнение массивов в Windows PowerShell с помощью регулярного выражения времени выполнения

Эй, сценарист! Я заинтересован в ускорении сравнения массивов при использовании Windows PowerShell. Можешь мне помочь?

—CR

Здравствуйте, CR,

Microsoft Scripting Guy, Эд Уилсон, здесь. Мы все еще находимся в Неделе приглашенного блоггера, поэтому я передам ваш вопрос сегодняшнему приглашенному блоггеру Робу Кэмпбеллу.

Вот описание Роба своего опыта в написании сценариев:

Я работаю в корпоративном финансовом учреждении среднего и крупного размера в качестве администратора AD и Exchange. Я проработал в ИТ более 35 лет, начав ночным оператором на мэйнфреймах IBM System 3 и 360. Я никогда особо не разбирался в VB, но мне нравится Windows PowerShell. Я написал несколько крупномасштабных сценариев, но большая часть моей работы над сценариями — это специальные отчеты, отчеты по запросу и изменения обслуживания. Не знаю, могу ли я претендовать на какую-то конкретную область специализации.Ближайшее, что я когда-либо придумал для хорошего описания должности, было «тактический логик».

Иногда вам нужно сравнить содержимое пары массивов строк в Windows PowerShell, и есть несколько хороших встроенных операторов, которые помогут вам в этом, в частности –содержит , –не содержит , и объект сравнения . Обычно я использую — содержит и — не содержит операторов. Здесь мы находим все элементы массива $ b , которые присутствуют и не появляются в массиве $ a :

$ a = «красный.»,« Синий »,« желтый »,« зеленый »,« оранжевый »,« фиолетовый ».

$ b = «синий.», «Зеленый.», «Оранжевый.», «Белый.», «Серый».

$ млрд |? {$ a -contains $ _}

синий.

зеленый.

оранжевый.

$ млрд |? {$ a -notcontains $ _}

белый.

серый.

Это отлично подходит для отдельных экземпляров, повторяющихся сравнений или относительно небольшого количества массивов. Это лаконично и интуитивно понятно. Однако иногда вам нужно сравнить массив с набором из тысяч массивов.Это могут быть адреса получателей электронной почты в журналах отслеживания сообщений, членство в группах AD, списки управления доступом NTFS или практически любая большая коллекция объектов, имеющих многозначные строковые свойства, которые необходимо сравнить с некоторым другим массивом строковых свойств. Для этого типа сценария есть другой метод, который обеспечивает гораздо лучшую производительность — соответствие регулярному выражению (regex).

Сопоставления регулярных выражений обычно используются для сопоставления одиночных строк, и мы говорим о сравнении массивов — сравнении одного набора нескольких значений с другим набором нескольких значений.(красный \. | синий \. | желтый \. | зеленый \. | оранжевый \. | фиолетовый \.) $ ”

Со всеми значениями мы хотим сопоставить группы, заключенные в круглые скобки и разделенные вертикальной чертой . Следующий код использует это регулярное выражение для замены нашей конструкции –contains на операции –match .

$ b -соответствие $ a_regex

синий.

зеленый.

оранжевый.

$ b -не соответствует $ a_regex

белый.

серый.

Оба метода дают одинаковый результат, но есть существенная разница во времени, которое им требуется.

Вы можете использовать следующий код, если вам нужно сравнить массивы $ a с 10 000 $ b , находя общие или разные элементы в каждом из них.

$ counter = 1..10000

$ test = measure-command {

foreach ($ i в $ counter) {

$ b | где {$ a -contains $ _}

$ b | где {$ a -notcontains $ _}

}

}

$ test.totalseconds

9.2625084

Здесь мы запускаем тот же тест с использованием нашего регулярного выражения 10 000 раз.

$ counter = 1..10000

$ test = measure-command {

foreach ($ i в $ counter) {

$ b -match $ a

$ b -notmatch $ a

}

}

$ test.totalseconds

0.6718625

Фактическое время тестирования будет варьироваться в зависимости от процессора и фоновых процессов, но я обнаружил, что регулярное выражение чередования постоянно работает во много раз быстрее, чем — содержит операторов.

Теперь, как мы можем использовать это в сценарии, когда то, что находится в $, не известно до времени выполнения? Просто.Мы ждем времени выполнения, чтобы создать наше регулярное выражение на основе того, что находится в $ а .

Во-первых, мы хотим убедиться, что мы литерально соответствуем нашим входящим элементам массива. К счастью, тип регулярного выражения содержит статический метод (escape), который сделает это за нас. Итак, начиная с нашего массива $ a , сначала мы экранируем все специальные символы в каждом элементе:

$ a | foreach {[regex] :: escape ($ _)}

red \.

синий \.

желтый \.

зеленый \.

оранжевый \.

фиолетовый \.

Кроме того, для нас экранируются все зарезервированные символы. Теперь мы соединяем элементы нашего массива с вертикальной чертой, обозначающей чередование:

($ a | foreach {[regex] :: escape ($ _)}) –join «|»

красный \. | Синий \. | Желтый \. | Зеленый \. | Оранжевый \. | Фиолетовый \.

Мы почти у цели. Все, что осталось, это добавить наши группирующие скобки, якоря и любые параметры регулярного выражения, которые мы хотим. Я собираюсь добавить (? I ), которое обозначает регулярное выражение без учета регистра, к этому, и использовать привязки начала строки ( ^ ) и конца строки ( $ ):

‘(? I) ^ (‘ + (($ a | foreach {[regex] :: escape ($ _)}) –join «|») + ‘) $’

(? I) ^ ( красный \.(‘+ (($ A | foreach {[regex] :: escape ($ _)}) –join« | ») +‘) $ ’

$ b -match $ a_regex

blue.

зеленый.

оранжевый.

$ b -не соответствует $ a_regex

белый.

серый.

CR, вот и все, что нужно для использования регулярных выражений для ускорения сравнения массивов. Спасибо, Роб, за то, что поделились с нами сегодня. На этом Неделя гостевых блоггеров подошла к концу. Присоединяйтесь ко мне завтра в Weekend Scripter.

Я приглашаю вас подписаться на меня в Twitter и Facebook.Если у вас есть какие-либо вопросы, отправьте мне письмо по адресу [email protected] или разместите свои вопросы на официальном форуме Scripting Guys. До завтра. А пока мир.

Эд Уилсон, Microsoft Scripting Guy

.

PowerShell String Replace | 8 лучших примеров замены строки PowerShell

Введение в PowerShell String Replace

Манипуляции со строками неотъемлемая часть любого языка программирования. Строковые функции являются неотъемлемой частью PowerShell, и существуют различные функции для обработки задач, связанных с манипуляциями со строками. В PowerShell все является объектом, а строка также является объектом типа System.String. Чтобы удалить определенную часть строки или заменить часть или всю строку другим текстом, можно воспользоваться командлетом replace в PowerShell.Функция replace принимает текст, который нужно заменить в строке, в качестве параметра, а текст, которым необходимо заменить желаемый текст, в качестве другого параметра. В этой статье подробно рассматривается командлет replace с примерами.

Синтаксис:

Заменить (strOldChar, strNewChar)

  • Stroldchar: Найденный символ
  • Strnewchar: символов для замены найденного текста.

Примеры реализации замены строки PowerShell

Ниже приведены примеры замены строки PowerShell:

Пример # 1

Код:

Write-Host "заменяет текст в строке"
$ test = "старый текст должен быть заменен"
Write-Host "заменяет старый"
$ test.Replace ("old", "New")
Write-Host "Текст заменен"

Выход:

Пример # 2

Код:

Write-Host "Добро пожаловать в демонстрацию функции замены в PowerShell"
Write-Host "Демонстрация замены одного текста"
$ input = "Vignesh Krishnakumar"
Write-Host "Фактический текст перед заменой:" $ input
Write-Host "Приведенный ниже код заменит vignesh на Viki"
#replace function
$ input = $ input -replace "vignesh", "Viki"
Write-Host "Замененный текст:" $ input
Write-Host "Заменить с помощью функции замены"
$ input1 = "это хороший день"
Write-Host "Фактический текст -" $ input1
Write-Host "Приведенный ниже текст заменит это на"
#replace function
$ input1 = $ input1.Replace ("this", "That")
Write-Host "После замены" $ input1
Write-Host "Демонстрация одновременной замены нескольких"
$ actual = "Австралия выиграла чемпионат мира в 1999 г."
# множественная замена
$ актуально -заменить «Австралия», «1999» -заменить «потерянный», »-«

»

Выход:

Замена с использованием хэш-таблицы

Другой эффективный способ одновременной замены нескольких текстов — использование хеш-таблицы. Хеш-таблица — это тип массива, в котором значения хранятся в виде пары ключ-значение.Ключевые значения должны быть уникальными, а значения могут быть не уникальными. Встроенные свойства хеш-таблицы — это ключ, значение и количество. В случае замены текста с помощью хэш-таблицы ключ будет представлять текст, который нужно заменить, а значение будет представлять текстовое значение, которое будет использоваться для замены.

Синтаксис :

$ hashtable = @
{
Text1 = value1;
Текст2 = значение2;
Text3 = value3;
Text4 = value4
}

Значения хеш-таблицы можно изменить следующим образом.

  • Чтобы добавить новую пару в хеш-таблицу:

$ hashtable.Add («text5», «value5»)

$ hashtable.Set_Item («текст5», «значение6»)

или

$ hastable. ”Text5” = ”value6”

$ hashtable.Remove («text5»)

$ хеш-таблица

Пример # 3

Код:

Write-Host "Добро пожаловать в демонстрацию замены с использованием хэш-таблицы"
$ input = "Am from chennai.Работаю фрилансером. Это мое хобби. Это пример. Давайте посмотрим, как заменяется текст "
Write-Host" Текст перед заменой `n" $ input -ForegroundColor Yellow
$ hashtable = @ {}
$ hashtable.'Am '=' We '
$ hashtable.'This' = 'Эта'
$ hashtable.'is '=' была '
$ hashtable.'us' = 'we'
$ hashtable. '.' = '!'
Write-Host "Ключи хэш-таблицы имеют следующий вид:` n "$ hashtable.Keys -ForegroundColor Yellow
Write-Host" Значения хеш-таблицы следующие: `n" $ hashtable.Values ​​-ForegroundColor Yellow
# итерируйте входную строку и замените значения
Foreach ($ key в $ hashtable.Ключи) {
$ input = $ input.Replace ($ key, $ hashtable. $ Key)
}
Write-Host «После замены» $ input -ForegroundColor Yellow
Write-Host «Демонстрация замены чисел и специальных символов»
$ input1 = "this 1 35 78 90. Пример замены чисел.% * # $. 12 34 56 78"
Write-Host "Текст перед заменой` n "$ input1 -ForegroundColor Желтый
$ hashtable1 = @ {}
$ hashtable1.'35 '=' 350 '
$ hashtable1.'78' = '780'
$ hashtable1.'90 '=' 900 '
$ hashtable1.'% '=' ответил '
$ hashtable1.'*' = 'sfdsfdsfds'
$ hashtable1. '#' = '####'
Foreach ($ key в $ hashtable1.Keys) {
$ input1 = $ input1.Replace ($ key, $ hashtable1. $ key )
}
Запись-Хост "После замены" $ input1 -ForegroundColor Желтый

Выход:

Пример # 4

Код:

Write-Host "Замена множественного текста"
$ string = "меня зовут billa, vazhaikai elam naanum super"
$ string-replace "vazhikai", "replace" -replace "elam", "All"
Write- Хост «Замена текста в файле»
(Get-Content -path C: \ Users \ educationba.txt -Raw) -replace 'was', 'is'
Write-Host "текст в файле заменяется на"

»

Выход:

Пример # 5

Код:

Write-Host "Пример замены текста в файле"
$ filePath = 'C: \ Users \ educationba.txt'
$ find = 'this'
$ replace = 'that'
$ file = Get-Content -Path $ filePath
Write-Host "Содержимое файла -` n "$ file -ForegroundColor Yellow
(Get-Content $ filePath) -replace $ Find, $ Replace | Add-Content -Path $ filePath
$ newtext = Get-Content -Path $ filePath
Write-Host "Теперь текст в файле" $ newtext -ForegroundColor Yellow

Выход:

.

Обрезайте строки с помощью PowerShell

Dr Scripto

Резюме : Разработчик сценариев Microsoft, Эд Уилсон, рассказывает об использовании Windows PowerShell для обрезки строк и очистки данных.

Разработчик сценариев Microsoft, Эд Уилсон, здесь. Жена-сценарист отправляется сегодня, чтобы провести время со своей второй страстью на шоу классических лошадей Blue Ridge. К сожалению, я не смогу посетить большую часть этого мероприятия из-за недели тренировок, которые проводит моя группа. Но у меня будет возможность увидеть хотя бы один день событий.

PowerShell Summit Europe

Говоря об увлечениях жены-писателя, теперь открыта регистрация на саммит Windows PowerShell в Европе. Мероприятие состоится 29 сентября — 1 октября 2014 года в Амстердаме, Нидерланды. Это будет отличное мероприятие, и это будет отличная возможность познакомиться с другими PowerShellers. Ранее в этом году мы с Терезой были в Амстердаме. Город красивый, и люди были очень дружелюбны.

Обрезка строк с помощью методов String

Note Этот пост является последним в серии о строках.Вам также может понравиться читать:

Одно из самых фундаментальных правил работы с данными — «мусор на входе, мусор на выходе». Это означает, что важно очистить данные перед их сохранением. Не имеет значения, является ли постоянное хранилище Active Directory, SQL Server или простым файлом CSV. Одна из проблем с «необработанными данными» заключается в том, что они могут включать такие вещи, как начальные или конечные пробелы, которые могут влиять на процедуры сортировки и поиска. К счастью, с помощью Windows PowerShell и нескольких методов String я могу легко исправить эту ситуацию.

Класс System.String .NET Framework (который задокументирован в MSDN) имеет четыре метода Trim , которые позволяют мне легко очищать строки, удаляя ненужные символы и пробелы. В следующей таблице перечислены эти методы.

Метод

Значение

Trim ()

Удаляет все начальные и конечные символы пробелов из текущего объекта String.

Trim (Char [])

Удаляет все начальные и конечные вхождения набора символов, указанного в массиве, из текущего объекта String.

TrimEnd

Удаляет все завершающие вхождения набора символов, указанных в массиве, из текущего объекта String.

TrimStart

Удаляет все начальные вхождения набора символов, указанных в массиве, из текущего объекта String.

Обрезать пустое пространство с обоих концов строки

Самый простой метод Trim — это метод Trim () . Это очень полезно, и я использую его чаще всего. Он легко удаляет все символы пробелов в начале и в конце строки. Это показано здесь:

PS C: \> $ string = «a String»

PS C: \> $ string.Trim ()

a String

Метод настолько прост в использовании. Я просто вызываю Trim () для любой строки, и она очищается.К сожалению, предыдущий вывод немного сложно понять, поэтому позвольте мне попробовать другой подход. На этот раз я получаю длину строки перед ее обрезкой и сохраняю полученную строку после операции обрезки обратно в переменную. Затем я второй раз получаю длину струны. Вот команда:

$ string = «a String»

$ string.Length

$ string = $ string.Trim ()

$ string

$ string.Length

Команда и соответствующий вывод из команда показана на следующем изображении:

Обрезать определенные символы

Если есть определенные символы, которые мне нужно удалить с обоих концов строки, я могу использовать метод Trim (char []) .Это позволяет мне указать массив символов для удаления с обоих концов строки. Вот пример, в котором у меня есть строка, которая начинается с «а» и заканчивается «а» . Я использую массив, состоящий из «a», «», и он удаляет оба конца строки. Вот команда:

$ string = «a String a»

$ string1 = $ string.Trim («a», «»)

Команда и связанные с ней выходные данные показаны на следующем изображении:

Замечательно то, что я также могу указать Unicode в моем массиве символов.Этот метод показан здесь:

$ string = «a String a»

$ string1 = $ string.Trim ([char] 0x0061, [char] 0x0020)

Доктор Скрипто говорит:

«Удобный Unicode таблицы доступны в Википедии ».

Следующее изображение иллюстрирует этот метод, отображая команду и связанный с ней вывод этой команды:

Обрезать конечные символы

Бывают случаи, когда я точно знаю, что мне нужно обрезать символы с конца строки .Однако эти символы также могут присутствовать в начале строки, и мне нужно сохранить эти символы. Для таких ситуаций я использую метод TrimEnd . Замечательно то, что я могу автоматически использовать этот метод тремя способами:

  1. Я могу удалить определенный символ, если я наберу этот конкретный код символа Unicode.
  2. Я могу удалить определенный символ, если наберу этот конкретный символ.
  3. Я могу удалить символы пробела Unicode, если ничего не делаю, кроме как вызываю метод.

Удалить определенный символ

В этом примере я создаю строку, а затем указываю массив определенных символов Unicode, используя значение кода Unicode. Поскольку строка начинается с тех же символов, которыми она заканчивается, это хороший тест, чтобы показать, как я могу удалить определенные символы из конца строки. Вот строка:

$ string = «a String a»

Теперь я указываю два символа Unicode по значению кода, которые нужно удалить с конца строки.Я сохраняю возвращаемую строку в переменной, как показано здесь:

$ string1 = $ string.TrimEnd ([char] 0x0061, [char] 0x0020)

Команда и связанный вывод показаны на следующем изображении:

Я также могу указать конкретный символ для обрезки, введя символы. В этом примере я ввожу <пробел> символов как один элемент массива, поэтому он удалит только <пробел> а из конца строки:

PS C: \> $ string = «a String a «

PS C: \> $ string.Длина

10

PS C: \> $ string1 = $ string.TrimEnd («a»)

PS C: \> $ string1

a String

PS C: \> $ string1. Длина

8

В следующем примере я указываю символы как отдельные элементы в массиве. Фактически, у меня даже нет их в том порядке, в котором они появляются в строке. Тем не менее, результаты те же.

PS C: \> $ string = «a String a»

PS C: \> $ string1 = $ string.TrimEnd («a», «»)

PS C: \> $ string1.Длина

8

PS C: \> $ string1

a String

PS C: \>

Удалить пробелы

Если я не укажу никаких символов, метод TrimEnd автоматически удалит все Unicode символы пробела в конце строки. В этом примере строка содержит как пробел, так и символ табуляции в конце строки. Длина составляет 20 символов. После того, как я обрезал конец, длина всего 18 символов, а пробел и табуляция исчезли.Этот метод показан здесь:

PS C: \> $ string = «строка и табуляция t»

PS C: \> $ string1 = $ string.TrimEnd ()

PS C: \> $ string .Length

20

PS C: \> $ string1

строка и табуляция

PS C: \> $ string1.length

18

Обрезать начальные символы

Если мне нужно обрезать материал из начало строки, я использую метод TrimStart . Он работает точно так же, как метод TrimEnd .Таким образом, он также будет работать тремя способами:

  1. Удалить определенный символ из начала строки, если я введу этот конкретный код символа Unicode.
  2. Удалить определенный символ из начала строки, если я ввожу этот конкретный символ.
  3. Удалите символы пробела Unicode из начала строки, если я ничего не делаю, кроме вызова метода.

Удалить определенные символы с начала

Подобно методу TrimEnd , я могу указать символы Unicode по значению кода Unicode.Когда я это делаю, метод TrimStart удаляет эти символы из начала строки. Этот метод показан здесь:

PS C: \> $ string = «a String a»

PS C: \> $ string.Length

10

PS C: \> $ string1 = $ string.TrimStart ( [char] 0x0061, [char] 0x0020)

PS C: \> $ string1.Length

8

PS C: \> $ string1

String a

Вместо использования значений кода Unicode я могу просто введите массив строковых символов, которые я хочу удалить.

Примечание Одним из недостатков набора определенных символов является то, что ““ довольно сложно интерпретировать. Это пробел, табуляция или пустое значение? Это опечатка или намеренная? Используя конкретное значение кода Unicode, я точно знаю, что имеется в виду, и, следовательно, сценарий более конкретен.

В этом примере я ввожу определенные символы, которые необходимо удалить из начала строки:

PS C: \> $ string = «a String a»

PS C: \> $ string.Длина

10

PS C: \> $ string1 = $ string.TrimStart («», «a»)

PS C: \> $ string1.Length

8

PS C: \> $ string1

String a

PS C: \>

Удалить пробелы

Если я вызываю метод TrimStart и не указываю определенные символы, метод просто удалит все пробелы Unicode с начала строки. Этот метод показан здесь:

PS C: \> $ string = «String a»

PS C: \> $ string.Длина

11

PS C: \> $ string1 = $ string.TrimStart ()

PS C: \> $ string1. Длина

8

PS C: \> $ string1

Строка

PS C: \>

Вот и все, что нужно для использования методов String . На этом же завершается Неделя струн. Присоединяйтесь ко мне завтра, когда я расскажу об изучении переменной Windows PowerShell $ Profile .

Я приглашаю вас подписаться на меня в Twitter и Facebook. Если у вас есть какие-либо вопросы, отправьте мне письмо по адресу scripter @ microsoft.com, или разместите свои вопросы на официальном форуме Scripting Guys. До завтра. А пока мир.

Эд Уилсон, Microsoft Scripting Guy

Dr Scripto

Scripter, PowerShell, vbScript, BAT, CMD

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa