В C# литералами называются постоянные значения, представленные в удобной для восприятия форме. Например, число 100 является литералом. Сами литералы и их назначение настолько понятны, что они применялись во всех предыдущих примерах программ без всяких пояснений. Но теперь настало время дать им формальное объяснение.
В C# литералы могут быть любого простого типа. Представление каждого литерала зависит от конкретного типа. Как пояснялось ранее, символьные литералы заключаются в одинарные кавычки. Например, ‘а’ и ‘%’ являются символьными литералами.
Целочисленные литералы указываются в виде чисел без дробной части. Например, 10 и -100 — это целочисленные литералы. Для обозначения литералов с плавающей точкой требуется указывать десятичную точку и дробную часть числа. Например, 11.123 — это литерал с плавающей точкой. Для вещественных чисел с плавающей точкой в C# допускается также использовать экспоненциальное представление.
Регулярные выражения #1: литералы и символьный класс
У литералов должен быть также конкретный тип, поскольку C# является строго типизированным языком. В этой связи возникает естественный вопрос: к какому типу следует отнести числовой литерал, например 2, 12 3987 или 0.23? К счастью, для ответа на этот вопрос в C# установлен ряд простых для соблюдения правил:
- Во-первых, у целочисленных литералов должен быть самый мелкий целочисленный тип, которым они могут быть представлены, начиная с типа int. Таким образом, у целочисленных литералов может быть один из следующих типов: int, uint, long или ulong в зависимости от значения литерала.
- Литералы с плавающей точкой относятся к типу double.
- Если вас не устраивает используемый по умолчанию тип литерала, вы можете явно указать другой его тип с помощью суффикса. Так, для указания типа long к литералу присоединяется суффикс l или L. Например, 12 — это литерал типа int, a 12L — литерал типа long. Для указания целочисленного типа без знака к литералу присоединяется суффикс u или U. Следовательно, 100 — это литерал типа int, a 100U — литерал типа uint. А для указания длинного целочисленного типа без знака к литералу присоединяется суффикс ul или UL. Например, 984375UL — это литерал типа ulong. Кроме того, для указания типа float к литералу присоединяется суффикс F или f. Например, 10.19F — это литерал типа float. Можете даже указать тип double, присоединив к литералу суффикс d или D, хотя это излишне. Ведь, как упоминалось выше, по умолчанию литералы с плавающей точкой относятся к типу double. И наконец, для указания типа decimal к литералу присоединяется суффикс m или М. Например, 9.95М — это десятичный литерал типа decimal. Несмотря на то что целочисленные литералы образуют по умолчанию значения типа int, uint, long или ulong, их можно присваивать переменным типа byte, sbyte, short или ushort, при условии, что присваиваемое значение может быть представлено целевым типом.
Шестнадцатеричные литералы
Вам, вероятно, известно, что в программировании иногда оказывается проще пользоваться системой счисления по основанию 16, чем по основанию 10. Система счисления по основанию 16 называется шестнадцатеричной. В ней используются числа от 0 до 9, а также буквы от А до F, которыми обозначаются десятичные числа 10,11,12,13, 14 и 15.
Программа на Python , высчитывающая количество пробелов,символов,слов в тексте.
Например, десятичному числу 16 соответствует шестнадцатеричное число 10. Вследствие того что шестнадцатеричные числа применяются в программировании довольно часто, в C# разрешается указывать целочисленные литералы в шестнадцатеричном формате. Шестнадцатеричные литералы должны начинаться с символов 0x, т.е. нуля и последующей латинской буквы «икс». Ниже приведены некоторые примеры шестнадцатеричных литералов:
count = 0xFF; // равно 255 в десятичной системе incr = 0x1a; // равно 26 в десятичной системе
Управляющие последовательности символов
Большинство печатаемых символов достаточно заключить в одинарные кавычки, но набор в текстовом редакторе некоторых символов, например возврата каретки, вызывает особые трудности. Кроме того, ряд других символов, в том числе одинарные и двойные кавычки, имеют специальное назначение в C#, поэтому их нельзя использовать непосредственно. По этим причинам в C# предусмотрены специальные управляющие последовательности символов:
| a | Звуковой сигнал (звонок) |
| b | Возврат на одну позицию |
| f | Перевод страницы (переход на новую страницу) |
| n | Новая строка (перевод строки) |
| r | Возврат каретки |
| t | Горизонтальная табуляция |
| v | Вертикальная табуляция |
| Пустой символ | |
| ‘ | Одинарная кавычка |
| « | Двойная кавычка |
| \ | Обратная косая черта |
Строковые литералы
В C# поддерживается еще один тип литералов — строковый. Строковый литерал представляет собой набор символов, заключенных в двойные кавычки. Например следующий фрагмент кода:
«This is text»
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Используем перенос строки Console.WriteLine(«Первая строкаnВторая строкаnТретья строкаn»); // Используем вертикальную табуляцию Console.WriteLine(«Первый столбец v Второй столбец v Третий столбец n»); // Используем горизонтальную табуляцию Console.WriteLine(«OnetTwotThree»); Console.WriteLine(«FourtFivetSixn»); //Вставляем кавычки Console.WriteLine(«»Зачем?», — спросил он»); Console.ReadLine(); >> >
Источник: professorweb.ru
Последовательности символов
Класс string был кратко представлен в предыдущих главах. Это очень мощный класс для обработки и манипуляции строками символов. Однако, по той причине, что строки фактически являются последовательностями символов, мы можем представить их также как простой массив из элементов символьного типа.
Например, следующий массив:
char foo [20];
это массив, который хранит до 20 элементов типа char. Он может быть представлен как:
Следовательно, этот массив имеет емкость (capacity) для хранения последовательностей длиной до 20 символов. Но эта емкость не обязательно должна использоваться полностью: массив способен хранить более короткие последовательности. Например, в некоторой точке программы, foo может хранить последовательность «Hello» или последовательность «Merry Christmas», т.к. обе соответствуют последовательности длиной до 20 символов.
По соглашению, конец строки, представленной в виде последовательности символов, обозначается специальным символом: нулевым символом (null character), фактическое значение которого может быть записано как ’ ′ (обратный слэш, ноль).
В этом случае, массив из 20 элементов типа char с именем foo, хранящий последовательности символов «Hello» и «Merry Christmas», может быть представлен как:
Обратите внимание, что после непосредственного содержимого строки добавлен нулевой символ (’ ′), чтобы обозначить конец последовательности. Панели серого цвета представляют элементы типа char с неопределенными значениями.
Инициализация нуль-терминированных последовательностей символов
По той причине, что массивы символов являются обычными массивами, они подчиняются тем же правилам. Например, чтобы инициализиорвать массив символов некоторой предопределенной последовательностью символов, необходимо сделать то же, что и для любого другого массива:
char myword[] = < ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ’ >;
Это выражение объявляет массив из 6 элементов типа char, инициализированных символами, формирующими слово «Hello», плюс нулевой символ ’ ′ в конце.
Но массивы символов можно инициализировать другим способом: используя строковые литералы непосредственно.
В выражениях, использованных в некоторых примерах в предыдущих главах, строковые литералы уже появлялись несколько раз. Они указываются в виде текста, заключенного в двойные кавычки («). Например:
«the result is: »
Это строковый литерал, который, вероятно, использовался в предыдущих примерах.
Последовательности символов, заключенные в двойные кавычки («), являются литеральными константами. Их типом, фактически, является нуль-терминированный массив символов. Это означает, что строковые литералы всегда имеют нулевой символ (’ ′), автоматически добавляемый в конец.
Следовательно, массив элементов типа char с именем myword может быть инициализирован нуль-терминированной последовательностью символов любым из следующих двух выражений:
char myword[] = < ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ’ >; char myword[] = «Hello»;
В обоих случаях, массив символов myword объявлен с размером 6 элементов типа char: 5 символов составляют слово «Hello», плюс конечный нулевой символ (’ ′), который обозначает конец последовательности. Во втором случае, при использовании двойных кавычек («), нулевой символ добавляется автоматически.
Обратите внимание, что мы говорим об инициализации массива символов в момент объявления, а не о присваивании ему значения позже (когда он уже объявлен). Фактически, по той причине, что строковые литералы являются обычными массивами, они имеют такие же ограничения и им нельзя присваивать значения.
Выражения (когда myword уже был объявлен, как указано выше), такие как:
myword = «Bye»; myword[] = «Bye»;
будут некорректными, как и:
myword = < ‘B’, ‘y’, ‘e’, ‘ ’ >;
Это связано с тем, что массивам нельзя присваивать значения. Обратите внимание, что каждому из его элементов может быть присвоено значение индивидуально. Например, это будет правильно:
myword[0] = ‘B’; myword[1] = ‘y’; myword[2] = ‘e’; myword[3] = ‘ ’;
Строки и нуль-терминированные последовательности символов
Простые массивы с нуль-терминированными последовательностями символов являются обычными типами, используемыми в языке Си для представления строк (поэтому они известны как Си-строки). В C++, хотя стандартная библиотека определяет конкретный тип для строк (класс string), тем не менее, простые массивы с нуль-терминированными последовательностями символов (Си-строки) являются естественным способом представления строк в языке; фактически, строковые литералы по-прежнему всегда создают нуль-терминированные последовательности символов, а не объеты string.
В стандартной библиотеке сосуществуют оба представления строк (Си-строки и библиотечные строки), и большинство функций, принимающих строки, перегружены для поддержки как одного, так и другого типа строк.
Например, cin и cout поддерживают нуль-терминированные строки, позволяя непосредственно извлекать их из cin или помещать в cout, так же, как и строки типа string. Например:
#include #include using namespace std; int main () < char question1[] = «What is your name? «; string question2 = «Where do you live? «; char answer1 [80]; string answer2; cout > answer1; cout > answer2; cout
What is your name? Homer Where do you live? Greece Hello, Homer from Greece!
В этом примере используются как строки типа string, так и нуль-терминированные последовательности.
Они вполне взаимозаменяемы при совместном использовании с cin и cout, но есть заметная разница в их объявлениях: массивы имеют фиксированный размер, который должен быть указан либо неявным, либо явным образом при объявлении; question1 имеет размер ровно 20 символов (включая завершающий нулевой символ), а answer1 имеет размер 80 символов; в то время как строки типа string не требуют указания размера. Это связано с тем, что строки типа string имеют динамический размер, определяемый во время выполнения, тогда как размер массивов определен во время компиляции, до запуска программы.
В любом случае, нуль-терминированные последовательности и библиотечные строки легко трансформируются друг в друга:
Нуль-терминированная последовательность символов может быть преобразована в string неявно, а объект string может быть преобразован в нуль-терминированную последовательность символов, используя методы класса string c_str или data:
char myntcs[] = «some text»; // преобразует си-строку в string string mystring = myntcs; // печатает как библиотечную строку cout
(обратите внимание: методы c_str и data являются эквивалентными)
Источник: pvoid.pro
Escape-последовательности и числовые нотации в PHP
Многие современные языки программирования поддерживают различные способы использования различных символов, таких как обычные английские латинские буквы, числа, символы, эмодзи и различные специальные символы, такие как символ новой строки или символ табуляции.
Большинство символов можно просто набрать с клавиатуры и использовать в коде PHP в их исходном виде. Например, $string = «php.watch» — это полностью допустимая строка в PHP, а $num = 42 — допустимое число. Также можно использовать многобайтные символы (для хранения которых требуется более одного байта), например, этот совершенно допустимый эмодзи: $emoji = «?» .
PHP, наряду со многими другими языками программирования, поддерживает определенное количество escape-последовательностей для использования различных символов, которые не могут быть набраны с обычной клавиатуры, не могут быть представлены в текстовой форме (например, невидимые символы или различные управляющие символы) или иным образом не считываются. Эти символы используют escape-последовательности, которые распознает PHP.
Что касается чисел, PHP поддерживает стандартные десятичные числа, но также может использовать и другие нотиции, такие как двоичное, восьмеричное, шестнадцатеричное и даже научное (scientific) представление. Они могут сделать код более читаемым и понятным в зависимости от контекста.
Двойные кавычки и Heredoc
В PHP строка с двойными кавычками ( «string» ) или Heredoc (смотрите ниже) поддерживает escape-последовательности и интерполяцию переменных.
PHP будет пытаться интерполировать переменные, если строковый литерал находится внутри строки с двойными кавычками или Heredoc.
$name = ‘John’; echo «Hi $name»; // «Hi John»
$name = ‘John’; echo
Альтернативно (и желательно) интерполируемые переменные могут быть выделены фигурными скобками, так они будут выглядеть более удобочитаемыми:
$name = ‘John’; echo «Hi «; // «Hi John»
Строки в одинарных кавычках ( ‘string’ ) и синтаксис Nowdoc не интерполируют переменные:
$name = ‘John’; echo ‘Hi $name’; // «Hi $name»
$name = ‘John’; echo
Hi $name NOWDOC; // «Hi $name»
Только строки в двойных кавычках и Heredoc поддерживают escape-символы.
Экранирование символов
Поскольку PHP интерпретирует и интерполирует специальные символы внутри строковых литералов в двойных кавычках и heredoc, знак обратной косой черты ( ) используется как «escape-символ».
Например, использование $name вместо $name не даст PHP интерполировать переменную $name .
$name = ‘John’; echo «Hi $name»; // «Hi $name»
Использование второго символа обратной косой черты предотвращает преобразование первого символа обратной косой черты в escape-символ.
$name = ‘John’; echo «Hi \$name»; // «Hi John»
PHP поддерживает несколько специальных escape-последовательностей для специальных символов. В приведенном выше примере $ считается escape-последовательностью, потому что он отменяет интерполяцию PHP, заставляя PHP буквально использовать символ $ .
Символы табуляции: t и v
Возможно, самые простой из управляющих символов — это символ табуляции. Символ табуляции (по нажатию клавиши tab) можно использовать внутри строкового литерала, но использование t вместо визуального пропуска делает его наглядным. Использование t вместо буквального символа табуляции также позволяет избежать автоматической замены символов табуляции на пробелы в различных IDE.
echo «FootBar»; Foo Bar
v — это вертикальная табуляция. На поддерживаемых терминалах символ вертикальной табуляции переходит к следующему символу в следующей строке:
echo «FoovBarvBaz»;
Foo Bar Baz
Новые строки: r и n
r («возврат каретки») и n («перевод строки») являются символами новой строки.
Исторически так сложилось, что различные системы начали использовать либо r , либо n , и даже Windows использует rn . Например, Linux и MacOS по умолчанию используют символ «перевода строки» ( n ) в качестве символа новой строки, тогда как Windows использует комбинацию rn (возврат каретки, за которым следует перевод строки). Старые системы MacOS использовали в качестве символа новой строки r .
PHP имеет константу PHP_EOL , которая всегда ссылается на системный символ новой строки.
echo «LeftnLeftnRightnRight»;
Left Left Right Right
Escape-символ: e
Escape-символы часто используется для отправки управляющих последовательностей ANSI в терминал. Например, e , за которым следует [32m , указывает терминалу изменить цвет на зеленый, а [33m — на желтый.
echo «e[32mGreen texte[0m e[33mYellow texte[0»;
Если приведенный выше фрагмент выполняется в терминале, который поддерживает управляющие последовательности ANSI, он интерпретирует его и изменяет текст:
Символ новой страницы: f
Символ новой страницы — это управляющий символ ASCII для обозначения конца страницы. С его помощью принтеры могут вывести текущую страницу и начать с верхней части следующей. Когда f передается на дисплейный терминал, он может результировать в очистке экрана, хотя это очень редкое поведение для большинства программ эмуляции терминала.
Восьмеричные escape-последовательности символов ASCII
PHP поддерживает экранирование восьмеричного числа в его соответствующий ASCII символ.
Например, ASCII символ P равен 80 в десятичной системе (смотрите диаграмму). 80 из десятичной системы счисления в переводе в восьмеричную — 120 .
Для символа P можно использовать восьмеричную escape-последовательность:
echo «120»; P
Любой базовый символ ASCII можно представить с помощью такой записи:
echo «12011012056127141164143150»; PHP.Watch
Любое значение в диапазоне от до 377 будет интерпретироваться как восьмеричная escape-последовательность ASCII символа.
Обратите внимание, что числа для расширенных символов ASCII (от 128 до 255) несовместимы с UTF-8. PHP считает значение 128 (восьмеричное: 200 ; шестнадцатеричное: 80 ) недопустимым, поскольку оно не является допустимым значением UTF-8.
Хотя PHP принимает такие значения, они считаются недопустимыми символами в контексте UTF-8.
Шестнадцатеричные escape-последовательности символов ASCII
Подобно восьмеричным escape-последовательностям символов, PHP также допускает использование шестнадцатеричных чисел в escape-последовательности символов с префиксом x .
Допускается только один байт, что подразумевает допустимый диапазон от x0 до xFF . Однако ограничение UTF-8 по-прежнему присутствует, и только значения до x80 будут считаться допустимыми символами.
Кроме того, шестнадцатеричные символы не чувствительны к регистру (т.е. AF равно af и aF ).
ASCII P — 80, что равно x50 :
echo «x50»; P
Тот же «PHP.Watch» пример можно переписать с помощью шестнадцатеричных escape-последовательностей:
echo «x50x48x50x2Ex57x61x74x63x68»; PHP.Watch
Escape-последовательности символов Unicode
PHP поддерживает использование любого Unicode символа с префиксом u и шестнадцатеричным значением code point внутри фигурных скобок.
echo «u — uuuuuuuuu»; ? — PHP.Watch
PHP выдаст ошибку парсера, если символ Unicode превышает значение 10FFFF :
echo «u» Invalid UTF-8 codepoint escape sequence: Codepoint too large on line .
10FFFF является верхним пределом, потому что спецификация UTF-8 объявляет диапазон от U+0000 до U+10FFFF .
В предыдущей версии этой статьи верхний предел неверно упоминался как FFFFF , что было исправлено на 10FFFF . Спасибо Саре Големон за то, что она указала на это.
Форму записи Unicode u<> можно использовать качестве escape-последовательности для любого символа. Вот несколько примеров:
Символ
Code point (Dec)
Code point (Hex)
Escape-последовательность Unicode
Источник: habr.com