Уроки Tcl

Уроки Tcl
Начало Уроки Tk Файлы
Статьи Уроки Tcl Гостевая книга

Предыдущий урок — #17: Подкоманды string — length index range

Часто выполняемые над строками операции включают поиск по шаблону, или сравнение одной строки с другой, они будут рассмотрены в этом уроке.

Tcl обладает несколькими способами для поиска в строке. Подкомманды first и last возвращают первую и последнюю позицию подстроки в строке.

Команда match проверяет на строки шаблону. В ней используются такие же правила globbing, как и в команде lsearch.

Команда string compare проверяет, какая строка идёт раньше по алфавитному порядку.

Вот описание этих команд:

string compare строка1 строка2
   Сравнивает строку1 со строкой2 и возвращает:
  • -1 … если строка1 меньше строки2
  • 0 … если строка1 равна строке2
  • 1 … если строка1 больше, чем строка2
string first строка1 строка2
 Возвращает номер символа в строке1, с которой начинается первое соответствие строке2, или -1 если нет соответствия
строке2 в строке1.
string last строка1 строка2
 Возвращает номер символа в строке1, с которой начинается последнее соответствие строке2, или -1 если нет соответствия строке2 в строке1.
string wordend строка индекс
 Возвращает позицию символа сразу после последнего символа слова, на которое указывает индекс в строке. Слово — любая последовательность последовательность букв, цифр или символов подчеркивания, а так же одиночный символ.
string match образец строка
 Возвращает 1 если шаблон соответствует строке. Шаблон задаётся в стиле glob.

Globbing — система шаблонов, аналогичная используемой в файловой системе. Шаблоны globbing бывают следующими:

*Соответствует любому количеству символов.
lsearch $list a*
возвратит номер первого элемента списка, который начинается с буквы ‘a’, независимо от следующих.
?		Соответствует любому символу
lsearch $list a?
возвратит индекс первого элемента списка, который начинается с буквы ‘a’, и имеет только один символ после ‘a’.
\XОбратная дробь отменяет действие специального символа, так же как и при подстановке в Tcl. Использование обратной дроби позволяет искать символы ‘*’ и ‘?’.
lsearch $list a\*
возвратит номер элемента списка равного «a*».
[…]Соответствует любому символу, из перечисленных в квадратных скобках. Например, [А-Я] соответствует любой заглавной букве.
lsearch $list [0-9]*
возвратит номер первого элемента, начинающегося с цифры.

В примере first и last используются чтобы найти первый и последний слэш (знак деления — /) в строке, содержащей путь к файлу. Если первый символ пути — «/», то это абсолютный путь, иначе — относительный. Это верно только для файловой системы Unix-подобных систем.

В последней части кода первая буква сравнивается с буквой «a», так как по порядку символов в компьютере идут цифры от 0 до 9, затем A-Z, а потом a-z. Потом идут русские буквы А-Я и а-я. Поэтому при сравнении с «a» можно определить регистр буквы. Это самый простой способ.

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

Пример:


set fullpath "/usr/home/clif/TCL_STUFF/TclTutor/Lsn.17"
set relativepath "CVS/Entries"
set directorypath "/usr/bin/"

set paths [list $fullpath $relativepath $directorypath]

foreach path $paths  {
	set first [string first "/" $path];
	set last [string last "/" $path];

	;# Сообщение о том, абсолютный путь или относительный

	if {$first != 0} {
		puts "$path - это относительный путь"
	} else {
		puts "$path - это абсолютный путь"
	}

  ;# Если "/" не последний символ в $path, выделить последнее слово.
  ;# иначе, удалить последний символ "/", и найти предпоследний "/", и
  ;# выделить последнее слово.
 
 

	incr last;
	if {$last != [string length $path]} {
		set name [string range $path $last end];
		puts "Путь - $path, имя файла - $name"
    } else {
		incr last -2;
		set tmp [string range $path 0 $last];
		set last [string last "/" $tmp];
		incr last;
		set name [string range $tmp $last end]
		puts "последняя папка в пути $path, это $name"
	}

  ;# CVS это папка созданная программой CVS

	if {[string match "*CVS*" $path]} {
		puts "$path - это часть системы контроля версий исходного кода CVS"
	}

  ;# Сравнение с буквой "а" для выяснения, большой или маленкий первый символ
	set comparison [string  compare $name "a"]
	if {$comparison >= 0} {
		puts "$name начинается с маленькой буквы\n"
	} else {
		puts "$name начинается с большой буквы\n"
	}
}

Следующий урок — #19: Обработка строк — tolower toupper trim format

jpg»>
Горбачев «Yurez» Юрий  

Хостинг от uCoz

Как сравнить строки в Bash

23.11.20202020-11-23T14:07:11+03:002021-01-14T12:59:06+03:00 Linux, Команды Комментариев нет

При написании сценариев Bash вам часто нужно сравнивать две строки, чтобы проверить, равны они или нет. Две строки равны, если они имеют одинаковую длину и содержат одинаковую последовательность символов.

В этом руководстве описывается, как сравнивать строки в Bash.

Содержание

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

Операторы сравнения — это операторы, которые сравнивают значения и возвращают истину или ложь. При сравнении строк в Bash вы можете использовать следующие операторы:

  • string1 = string2 и string1 == string2 — оператор равенства возвращает истину, если операнды равны.
    • Используйте оператор = с командой test [ .
    • Используйте оператор == с командой [[ для сопоставления с образцом.
  • string1 != string2 — оператор неравенства возвращает истину, если операнды не равны.
  • string1 =~ regex — Оператор регулярного выражения возвращает истину, если левый операнд совпадает с расширенным регулярным выражением справа.
  • string1 > string2 — оператор «больше» возвращает истину, если левый операнд больше правого, отсортированный в лексикографическом (алфавитном) порядке.
  • string1 < string2 — оператор «меньше» возвращает истину, если правый операнд больше правого, отсортированный в лексикографическом (алфавитном) порядке.
  • -z string — Истина, если длина строки равна нулю.
  • -n string — Истина, если длина строки отлична от нуля.

При сравнении строк следует учитывать несколько моментов:

  • Между бинарным оператором и операндами должен использоваться пробел.
  • Всегда используйте двойные кавычки вокруг имен переменных, чтобы избежать проблем с разделением слов или подстановкой слов.
  • Bash не разделяет переменные по «типу», переменные обрабатываются как целые или строковые в зависимости от контекста.

Проверьте, равны ли две строки

В большинстве случаев при сравнении строк вам нужно проверить, равны ли строки или нет.

Следующий сценарий использует оператор if и команду test [

чтобы проверить, совпадают ли строки с оператором = :

#!/bin/bash
VAR1="Linuxize"
VAR2="Linuxize"
if [ "$VAR1" = "$VAR2" ]; then
    echo "Strings are equal."
else
    echo "Strings are not equal."
fi

Когда сценарий будет выполнен, он напечатает следующий вывод.

Strings are equal.

Вот еще один сценарий, который принимает ввод от пользователя и сравнивает заданные строки. В этом примере мы будем использовать команду [[ и оператор == .

#!/bin/bash
read -p "Enter first string: " VAR1
read -p "Enter second string: " VAR2
if [[ "$VAR1" == "$VAR2" ]]; then
    echo "Strings are equal."
else
    echo "Strings are not equal."
fi

Запустите сценарий и введите строки при появлении запроса:

Enter first string: Linuxize
Enter second string: Ubuntu
Strings are not equal.

Вы также можете использовать логические и && и или || для сравнения строк:

[[ "string1" == "string2" ]] && echo "Equal" || echo "Not equal"

Not equal

Проверьте, содержит ли строка подстроку

Есть несколько способов проверить, содержит ли строка подстроку.

Один из подходов — использовать окружение подстроки символами звездочки * что означает соответствие всем символам.

#!/bin/bash
VAR='GNU/Linux is an operating system'
if [[ $VAR == *"Linux"* ]]; then
  echo "It's there. "
fi

Скрипт отобразит следующее:

It's there.

Другой вариант — использовать оператор регулярного выражения =~ как показано ниже:

#!/bin/bash
VAR='GNU/Linux is an operating system'
if [[ $VAR =~ .*Linux.* ]]; then
  echo "It's there."
fi

Точка, за которой следует звездочка .* Соответствует нулю или более вхождений любого символа, кроме символа новой строки.

Проверьте, пуста ли строка

Довольно часто вам также нужно будет проверить, является ли переменная пустой строкой или нет. Вы можете сделать это с помощью операторов -n и -z .

#!/bin/bash
VAR=''
if [[ -z $VAR ]]; then
  echo "String is empty."
fi

String is empty.

#!/bin/bash
VAR='Linuxize'
if [[ -n $VAR ]]; then
  echo "String is not empty."
fi

String is not empty.

Сравнение строк с оператором Case

Вместо использования тестовых операторов вы также можете использовать оператор case для сравнения строк:

#!/bin/bash
VAR="Arch Linux"
case $VAR in
  "Arch Linux")
    echo -n "Linuxize matched"
    ;;
  Fedora | CentOS)
    echo -n "Red Hat"
    ;;
esac

Linuxize matched.

Лексикографическое сравнение

Лексикографическое сравнение — это операция, при которой две строки сравниваются в алфавитном порядке путем последовательного сравнения символов в строке слева направо. Такое сравнение используется редко.

Следующие сценарии лексикографически сравнивают две строки:

#!/bin/bash
VAR1="Linuxize"
VAR2="Ubuntu"
if [[ "$VAR1" > "$VAR2" ]]; then
    echo "${VAR1} is lexicographically greater then ${VAR2}."
elif [[ "$VAR1" < "$VAR2" ]]; then
    echo "${VAR2} is lexicographically greater than ${VAR1}."
else
    echo "Strings are equal"
fi

Скрипт выдаст следующее:

Ubuntu is lexicographically greater than Linuxize.

Выводы

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

Если у вас есть какие-либо вопросы или отзывы, не стесняйтесь оставлять комментарии.

Различные способы сравнения строк в Swift

Сравнение строк является важной операцией в повседневной работе. Swift предоставляет несколько вариантов для этого. Мы посетим их в этой статье.

Проверка на равенство строк в Swift

В Swift вы можете проверить равенство строк и символов с помощью оператора «равно» ( == ) и оператора «не равно» ( != ).

 let password = "123456" 
 let passwordConfirmation = "123456" 
 password == passwordConfirmation 
 // true

Проверка на равенство символов в Swift

Мы используем тот же оператор для Character .

 let a: Character = "a" 
 let alsoA: Character = "a" 
 a == alsoA 
 // true

Этот оператор «равно» подходит для простого сравнения строк, когда требуется точное совпадение. Если вы больше контролируете критерии соответствия, такие как игнорирование регистра или диакритические знаки, вам понадобится помощь compare .

Сравните две строки без учета регистра в Swift

Чтобы сделать сравнение без учета регистра, мы используем compare(_:options:) .

 let a = "a" 
 let capitalA = "A" 
 a.compare(capitalA, options: .caseInsensitive) 
 // ComparisonResult.orderedSame 
 
 if a.compare(capitalA, options: .caseInsensitive) == . orderSame { 
 // a равно A 
 }

Вы также можете использовать краткую форму caseInsensitiveCompare(_:) .

 let a = "a" 
 let capitalA = "A" 
 a.caseInsensitiveCompare(capitalA) 
 // ComparisonResult.orderedSame

Предостережение

У вас может возникнуть соблазн использовать lowercased() и 900 07 в верхнем регистре() с оператором «равно» для сравнения без учета регистра.

 let a = "a" 
 let capitalA = "A" 
 a.lowercased() == capitalA.lowercased() 
 // true 
 a.uppercased() == capitalA.uppercased() 
 // true

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

Единственная известная мне проблема — это слово «Straße», что в переводе с немецкого означает «улица».

 let street = "Straße" 
 let alsoStreet = "STRASSE" 
 print(street.lowercased()) 
 // straße 
 print(alsoStreet.uppercased()) 
 // STRASSE 
 
 street.lowercased() == alsoStreet.lowercased() 
 // false 
 
 street.uppercased() == alsoStreet.uppercased() 
 // true 
 
 street.compare(alsoStreet, options: .caseInsensitive) == .orderedSame 
 // true

Проблема в том, что «ß» пишется в нижнем регистре, который не преобразуется с помощью в нижнем регистре() , но преобразуется в SS с помощью в верхнем регистре() . Такое особое обращение с языком может привести к неожиданному поведению. Это только один пример из одного языка, но мы не можем знать наверняка, может ли это произойти в другом месте, поэтому я предлагаю вам использовать , сравнить для такого рода работы.

Я тоже думаю, что street. compare(alsoStreet, options: .caseInsensitive) == .orderedSame посылает более ясное сообщение читателю.

Это передаст сообщение о том, что вы хотите сравнить две строки, игнорируя их регистры ( .caseInsensitive ).

 street.compare(alsoStreet, options: .caseInsensitive) == .orderedSame

Хотя это означает, что строчные буквы двух строк должны быть равны. Очень разные, правда?

 street.lowercased() == alsoStreet.lowercased()

Возможно, я ошибаюсь в значении и предположении слова «Straße», потому что не знаю немецкого. Я хочу сказать, что вы не можете предполагать, что прописные или строчные буквы в других языках будут такими же простыми и понятными, как английский.

Вы можете прочитать больше здесь: Как правильно использовать заглавную букву «ß»?

Сравните две строки, игнорируя диакритические знаки в Swift

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

Для сравнения строк, игнорирующих диакритические знаки, мы также используем compare(_:options:) , но на этот раз мы передаем .diacriticInsensitive в качестве опции.

 let e = "e" 
 let eWithAcuteAccent = "é" 
 e.compare(eWithAcuteAccent, варианты: .diacriticInsensitive) 
 // ComparisonResult.orderedSame 
 
 if e.compare(eWithAcuteAccent, options: .diacriticInsensitive) == .orderedSame { 
 // e равно é 
 }
  • compare(_:options:range:) 9014 7
  • Какая заглавная буква «ß» уместна?

Не стесняйтесь подписываться на меня в Твиттере и задавать вопросы, связанные с этим постом. Спасибо за чтение и увидимся в следующий раз.

Если вам нравится то, что я пишу, зайдите на мой Patreon https://www.patreon.com/sarunw и поддержите меня. Распространение статьи также приветствуется.

Сравнение строк Bash {Руководство}

Введение

Bash — это оболочка Unix и язык командной строки, используемый по умолчанию в большинстве дистрибутивов Linux. Используя Bash, разработчики могут создавать сценарии для выполнения различных действий, включая сравнение строк.

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

Из этого туториала вы узнаете, как сравнивать строки с помощью скрипта Bash.

Предпосылки

  • Система под управлением Linux.
  • Доступ к терминалу ( Ctrl + Alt + T ).
  • Текстовый редактор для кодирования.

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

В отличие от некоторых стандартных языков программирования, Bash не имеет встроенных функций сравнения, поэтому пользователям необходимо использовать операторы сравнения. Операторы сравнения сравнивают значения входных строк и выводят ИСТИНА или ЛОЖЬ значение.

Примечание: Помимо Bash, в Linux есть другие полезные инструменты для работы с текстом и обработки, такие как редактор sed, команда awk, команда grep или команда sort.

Некоторые из наиболее часто используемых операторов сравнения строк перечислены в таблице ниже: 1] = [строка2] Оператор равенства возвращает TRUE , если оба операнда равны. Используется с командой [  . [str1] == [str2] Оператор равенства возвращает TRUE , если оба операнда равны. Используется с командой [[  . [str1] != [str2] Оператор неравенства возвращает TRUE  если указанные операнды не равны. [str1] =~ регулярное выражение Оператор регулярного выражения возвращает TRUE  если указано [ str1] строка соответствует расширенному регулярному выражению. [str1] > [str2] Оператор «больше чем» возвращает TRUE  if [str 1]  больше [str2]  на основе лексикографического порядка. [str1] < [str2] Оператор «меньше чем» возвращает TRUE  if [str1]  меньше, чем  [str2]  на основе лексикографического заказ. -z [строка] Возвращает TRUE , если длина строки равна 0. -n [строка] Возвращает TRUE , если длина строки не равна 0.

При сравнении строк убедитесь, что:

  • Используйте пробел между двоичными оператор и операнды.
  • Используйте двойные кавычки вокруг имен переменных. Отсутствие двойных кавычек приводит к проблемам с разделением слов или подстановкой.

Примечание: Bash также позволяет использовать == для равенства с [ , но это не стандартное использование.

Примеры сравнения строк Bash

Различные операторы предлагают разные способы сравнения строк в зависимости от требований.

Ниже приведены примеры распространенных способов использования операторов сравнения для сравнения строк в Bash. В приведенных ниже примерах мы используем сценарии Bash, которые позволяют пользователям сохранять функцию и повторно использовать ее при необходимости.

Проверить, равны ли строки

Используйте = или == операторы при проверке равенства строк. Выполните следующие действия, чтобы создать сценарий Bash и сравнить две строки:

Проверить предопределенные строки

1. Откройте терминал ( Ctrl + Alt + T ) и создайте новый сценарий Bash. Мы будем использовать текстовый редактор vi/vim:

 vi script1.sh

2. Введите следующий код:

 #!/bin/bash
str1="Феникс"
стр2 = "NAP"
если [ "$str1" = "$str2" ]; затем
    echo "Строки равны."
еще
    echo "Строки разные."
фи
  • Сценарий содержит две переменные ( str1 и str2 ), которые уже определены.
  • В сценарии используется оператор if и оператор = с командой [ . Оператор if либо переходит к первому предложению, либо к предложению else , в зависимости от того, равны строки или нет.

3. Сохраните сценарий и выйдите из vi:

 :wq

4. Запустите сценарий Bash:

 bash script1. sh

Сценарий выводит, что две строки различны.

Проверка входных строк

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

1. Введите следующие строки:

 #!/bin/bash
читать -p "Введите первую строку: " STR1
читать -p "Введите вторую строку: " STR2
если [[ "$STR1" == "$STR2" ]]; затем
   echo "Строки равны."
еще
   echo "Строки разные."
фи

2. Запустите сценарий для проверки кода:

Сначала сценарий запрашивает две строки, а затем выводит результат.

Примечание: Команда чтения запрашивает у пользователя ввод. Без него вы должны указать переменные внутри скрипта.

Проверить, различаются ли строки

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

1. Создайте скрипт со следующим кодом:

 #!/бин/баш
стр1 = "данные"
стр2 = "сервер"
если [ "$str1" != "$str2" ]; затем
   echo "Строки разные."
еще
   echo "Строки одинаковые."
fi

2. Запустите скрипт:

Две строки разные, что и указано в результате.

Проверка подстрок

Подстрока — это непрерывная последовательность символов в строке. Например, NAP является подстрокой строки phoenixNAP .

Есть два способа проверить частичное значение в строке (т. е. содержит ли строка подстроку):

Заменить символы звездочкой

Используйте символ звездочки ( * ) для замены символов в указанной подстроке. Звездочка — это подстановочный знак, позволяющий пользователям выполнять частичное сопоставление. Выполните следующие шаги, чтобы использовать частичное совпадение при сравнении строк:

1. Создайте новый сценарий Bash и введите следующие строки:

 #!/bin/bash
VAR='Добро пожаловать в phoenixNAP!'
если [[ $VAR == *"NAP"* ]]; затем
  echo "Строка содержит подстроку NAP. "
еще
  echo "Строка не содержит указанной подстроки."
фи

2. Запустите скрипт:

В выводе указано, что указанная подстрока является частью строки.

Использование оператора регулярного выражения

Другой способ проверки подстрок — использование оператора регулярного выражения =~ . Выполните следующие действия:

1. Создайте сценарий Bash и введите следующие строки:

 #!/bin/bash
VAR='Добро пожаловать в phoenixNAP.'
если [[ $VAR =~ .*topho.* ]]; затем
  echo "Подстрока существует."
еще
  echo "Строка не содержит указанной подстроки."
фи
  • .* , окружающая указанную подстроку, соответствует нулю или более вхождений любого символа, кроме символа новой строки.

2. Запустите скрипт:

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

Проверка на наличие пустых строк

Bash также позволяет пользователям проверять, является ли переменная пустой строкой или нет. Проверьте наличие пустых строк с помощью -n и -z операторы. Следуйте приведенным ниже шагам, чтобы создать пример сценария для каждого оператора:

Оператор -Z

Поиск пустых строк с -z Оператор, выполняя шаги ниже:

1. Создать новый сценарий Bash и скопируйте следующие строки:

 #!/bin/bash
ВАР=''
если [[ -z $VAR ]]; затем
  echo "Строка пуста."
fi

2. Сохраните и запустите скрипт:

Сценарий сообщает, что строка пуста. Когда строка не пуста, вывод невозможен. Чтобы обеспечить вывод, если строка не пуста, укажите в скрипте условие else , как в примере ниже.

Оператор -n

1. Создайте новый сценарий и введите следующие строки:

 #!/bin/bash
VAR='phoenixNAP'
если [[ -n $VAR ]]; затем
  echo "Строка не пуста."
еще
  echo "Строка пуста. "
фи

2. Запустите сценарий Bash и проверьте результат:

Сценарий проверяет переменную $VAR и выдает, что строка не пуста.

Сравнение строк с операторами case

Оператор case в Bash — это форма условного оператора if elif else, упрощающая сложные условия и предлагающая несколько вариантов выбора. При использовании оператора case нет необходимости указывать тестовые операторы для сравнения строк. Однако оператор сопоставляет строку только с указанными шаблонами.

Выполните следующие действия, чтобы создать пример оператора case:

1. Создайте новый сценарий Bash и введите следующие строки:

 #!/bin/bash
shopt -s nocasematch
echo "Введите имя ОС: "
читать VAR
случай $VAR в
окна)
   echo -n "ОС - Windows."
   ;;
Федора | Дебиан | Убунту | Андроид)
   echo -n "Операционная система основана на Linux."
   ;;
esac
  • Команда shopt делает сопоставление с образцом нечувствительным к регистру.
  • Сценарий сравнивает входную переменную $VAR против шаблонов в каждом предложении, пока не будет найдено совпадение.
  • Символ трубы | разделяет несколько шаблонов в предложении.

2. Запустите сценарий и введите строку, чтобы проверить, работает ли она:

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

Лексикографическое сравнение

Лексикографическое сравнение — это сравнение двух строк по алфавиту. Символы в каждой строке преобразуются в Unicode, и их значения последовательно сравниваются слева направо. Сравнение начинается с первого символа строки до 9-го.0164 NULL найден символ.

Используйте операторы меньше ( < ) и больше ( > ) для лексикографического сравнения строк.

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

1.

No related posts.