Отваря главното меню

Промени

154 байта изтрити ,  преди 1 година
м
Бот: Поправка на уикисинтаксис; козметични промени
В компютърните науки '''низ''' е крайна поредица от символи (представляващи краен брой '''знаци'''). Елементите му евентуално могат да бъдат променяни, както и дължината му. Низовете обикновено се разглеждат като тип данни и често са имплементирани като масиви от байтове (или думи), които съхраняват последователност от елементи, използвайки [[Символно_кодиранеСимволно кодиране|кодиране на символите]].
 
В зависимост от [[Език_за_програмиранеЕзик за програмиране|езика за програмиране]] и използваният тип данни, [[Променлива_Променлива (програмиране)|променлива]] декларирана като низ може да бъде съхранена в паметта статично (предварително определена максимална дължина) или динамично (може да съдържа различен брой елементи).
 
Във [[Формални_езициФормални езици|формалните езици]], които се използват в математическата логика и теоретичната информатика, низ е крайна последователност от символи от дадено множество, наречено азбука.
 
== Дължина на низ ==
 
== Символни низове в C# ==
В [[Си_ШарпСи Шарп|C#]] символните низове са дефинирани в класа <code>System.String</code>. За декларация по време на писане на код се използва служебната дума <code>String</code>. Тъй като <code>String</code> е клас, той е референтен тип данни и в стека на програмата се съхранява само указателя, сочещ към поле от динамичната памет, където се съхранява реалната стойност на обекта..<ref name="Въведение в C#">[http://downloads.academy.telerik.com/svn/csharppart1/Materials/Intro-CSharp-Book-1.00.pdf Въведение в C#], 465 – 509.</ref>
 
=== Създаване на <code>String</code> ===
За да работим с променлива от тип <code>string</code> трябва първо да я създадем и инициализираме. Трябва да се има предвид, че създаването на референтен тип само заделя част от динамичната памет със стойност <code>null</code>. Ако се опитаме да извикаме инстанцирания обект, ще получим грешка за достъп до липсваща стойност <code>NullReferenceException</code>. Има три начина за инициализиране на [[Променлива_Променлива (програмиране)|променливи]]:<br />
'''Задаване на литерал за символен низ.''' По този начин задаваме предефинирано текстово съдържание на променливата. Използва се когато знаем стойността, която трябва да бъде съхранена.
<big><source lang="csharp">string greeting = "Hello, World!";</source></big>
 
=== Операции със символни низове ===
Трябва да се отбележи, че символните низове са неизменими и всяка промяна на един низ води до създаване на нов, в който се пази резултата и пренасочване към него. Това може силно да забави изпълнението на една програма при много редакции на един низ (например долепване на символи в [[Цикъл_Цикъл (програмиране)|цикъл]]). В такива случаи използваме класа <code>StringBuilder</code>, който оптимизира работата с низове.<br><br>
'''Сравняване на низове'''
:'''Сравняване за еднаквост.''' Удобен за това е метода <code>Equals()</code>, който работи еквивалентно на <code>==</code>. Метода връща булев резултат <code>true</code> при еднакви низове и <code>false</code> при различни. Трябва да се има в предвид, че по този начин се сравняват побуквено елементите на масива, като се прави разлика между главни и малки букви. Често ще ни интересува само текстовото съдържание без регистъра на буквите, затова може да използваме метода <code>Equals()</code> с параметър <code>StringComparison.CurrentCultureIgnoreCase</code>
<big><source lang="csharp">
string data1 = " 111 $ % Text Example ### s ";
string data2 = " \n\n Text Example ";
char[] trimChars = new char[] { ' ', '1', '$', '%', '#', 's' };
Console.WriteLine(data2.Trim());
// Text Example
// Text Example
// 111 $ % Text Example
</source></big>
'''Оптимизация на паметта при символни низове''' <br>
Когато инициализираме променлива от тип string с низов [[литерал]], динамичната памет се обхожда и се прави проверка дали такава стойност вече съществува. Ако съществува, новата променлива просто се пренасочва към нея. Ако не, референцията се препраща да сочи към нов блок памет. Интернирането на низове в [[.NET_FrameworkNET Framework|.NET]] е възможно, защото низовете по концепция са неизменими и няма опасност някой да промени областта, сочена от няколко низови променливи едновременно. Когато не инициализираме низовете с литерали, не се ползва интерниране. Все пак, ако искаме да използваме интерниране изрично, можем да го направим чрез метода <code>Intern()</code>. За да демонстрираме това по-долу използваме статичния метод <code>Object.ReferenceEquals()</code>, който проверява дали два обекта сочат към един и същ блок памет.
<big><source lang="csharp">
string declared = "Some text";
</source>
 
<code>StringBuilder</code> притежава много разнообразни методи можете да погледнете повече за тях тук [[http://msdn.microsoft.com/en-us/library/system.text.stringbuilder.aspx]]
 
== Символни низове в Java ==
В езика за програмиране [[Java]], символните низове са [[Обект_Обект (програмиране)|обекти]].
 
В Java [[Клас_Клас (програмиране)|класът]] <code>String</code> се използва за създаване и обработка на символни низове. Последователностите от символи, записани в [[Променлива_Променлива (програмиране)|променлива]] от класа, са [[Неизменим_обектНеизменим обект|неизменими]] (immutable). Веднъж записано съдържанието на едно място, то не може да бъде променяно директно.
 
=== Създаване на символни низове ===
В този случай, <code>"Hello, world!"</code> е низов [[литерал]] – поредица от символи в кода, които са заградени с двойни кавички.
 
За отпечатване на съобщение в кавички е необходимо да се използва [[Екранираща_последователностЕкранираща последователност|екраниращ]] символ (escaping character) – обратна наклонена черта (\).
<source lang="java">String quotedString = "She said \"Hello, World!\""; //She said "Hello, world!" </source>
Може да се създаде <code>String</code> обект като се използва ключовата дума <code>new</code> и [[Конструктор_Конструктор (обектно-ореинтирано_програмиранеореинтирано програмиране)|конструктор]]. Класът <code>String</code> съдържа конструктори, които позволяват да се инициализира стойността на низа, чрез използване на различни източници, като [[Масив_Масив (програмиране)|масив]] от символи:
<source lang="java">
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
 
=== Долепване (последователно слепване) на низове (конкатенция) ===
Класът <code>String</code> включва [[Метод_Метод (програмиране)|метод]] за долепване на два низа:
<source lang="java">
String greet = "Hello, ";
Често за долепване на низове се използва оператора +, при който резултата отново е същият както и при горните два начина:
<source lang="java">
"Hello, " + "world" + "!" //Hello, world!
</source>
 
<code>trim</code> методът връща нов низ премахвайки интервалите в началото и края на оригиналния символен низ.
<source lang="java">
String example = new String(" Welcome to Wikipedia ");
System.out.println(example.trim()); // Welcome to Wikipedia
</source>
 
== Низове в C ==
Низът в езика [[C_C (език_за_програмиранеезик за програмиране)|С]] представлява последователност от символи, които завършват с терминираща нула ('\0'). Използва се [[ASCII]] таблица за символи.
 
Няма запазена дума <code>string</code>, затова трябва да използваме ето тези конструкции:
char str[13] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd','!', '\0'};
</source>
В този пример се вижда какво представлява низа отвътре. Забележете, че трябва да се остави място за [[Терминираща_нулаТерминираща нула|терминиращата нула]], защото благодарение на нея се разбира кога сме достигнали края на низа.
 
Тази конструкция може да се запише и съкратено по този начин:
В този пример макар да не записваме терминиращата нула [[компилатор]]ът си оставя място за нея и я слага.
 
Ето още един пример, но този път с [[Указател_Указател (програмиране)|указател]](pointer)
<source lang="c">
char* str = "Hello world!";
Тук указателят запазва адреса на първият символ, а останалите символи са следващите, докато не се достине до '\0'.
 
В C има [[Библиотека_Библиотека (програмиране)|библиотека]] предназначена за работа със низове. За да я добавим трябва да поставим това отгоре на файла:
<source lang="c">
#include <string.h>
#include <string.h>
 
int strlen(char* str); //Връща дължината на низа.
char* strcpy(char* dest, char *src); //Копира един низ в друг. "Src" се копира в "dest".
int strcmp(char* str1, char* str2); //Сравнява двата низа и връща 0 ако са еднакви,
//отрицателна стойност ако "str1" е по-голям, и положителна ако "str2" е по-голям.
char* strcat(char* dest, char* src); //Добавя (append) "src" в "dest".
char* strstr(char* str, char* substr); // Търси дали в "str" се съдържа низ "substr" и връща указател сочещ към мястото където започва.
// Връща NULL, ако резултат не е намерен.
</source>
Още за библиотеката <code>string.h</code> можете да намерите [[http://www.cplusplus.com/reference/cstring/]]
 
Друга полезна библиотека е <code>stdlib.h</code>, благодарение на нея може да превръщаме низове в числа.
<source lang="c">
int atoi(const char *str); //Връща целочислено число.
double atof(const char *str); //Връща реално число.
</source>
Още за библиотеката <code>stdlib.h</code> можете да намерите [[http://www.cplusplus.com/reference/cstdlib/]]
 
Ето пример за [[Конкатенация|конкатерине]] на низове:
<source lang="c">
char* str1 = strdup("Hello"); //Друг начин за инициализиране.
char* str2 = malloc(strlen (str1) + 8); // Заделяме памет с malloc, колкото дължината на предишния низ + допълнително.
strcpy(str2, str1 ); // Копиране на str1 в str2.
strcat(str2, " world!"); // Конкатениране на получения низ с " world!".
free(str1); // Освобождаване на първия низ.
 
// Можем освен това да пренасочваме и [[Указател_Указател (програмиране)|указателите]] ако искаме стойността да е в str1. С "str1 = str2;",
// но тогава ще е добре и да освободим и памета от str2 с ключовата дума free.
</source>
 
== Низове в C++ ==
В [[C%2B%2B++|С++]] съществува клас, намиращ се в <code>namespace std</code>, който поддържа работа с низове. Думата <code>string</code> е ключова дума. Запазването на низове в памета е по начина по който се запазват и в C(накрая има терминираща нула).
 
Работата със низове е много по-удобна, защото са предефинирани аритметичните знаци <code>+</code> и <code>=</code>.
<source lang="cpp">
string str = "Hello world!"; // Ако сме импортнали std.
std::string str2 = "Hello again world!"; // Aко не сме импортнали std.
</source>
str1 += str2; // Добавяне към първия низ.
</source>
Освен това, [[Клас_Клас (програмиране)|класът]] низ поддържа и много допълнителни помощни функции.
<source lang="cpp">
string str = "Hello world!";
str.size();
str.length(); // И двете функции показват дължината на низа (size == length).
str.empty(); // Връща 0 ако не е празен, а ако е празен връща 1.
str.begin(); // Връща указател към началото на низа.
str.end(); // Връща указател към края на низа.
</source>
Има вградена функция за размяната на низове.
str1.swap(str2); // Разменяне на низовете.
</source>
Още [[Метод_Метод (програмиране)|методи]] в класът <code>"string</code> можете да намерите [[http://www.cplusplus.com/reference/string/string/]].
 
== Низове в PHP ==
В [[PHP]] символът един байт, т.е., съществуват точно 256 възможни символа. Това също означава, че PHP няма естествена поддръжка за Unicode.
 
Знаците в даден низ могат да бъдат достъпвани и изменяни чрез указване на отместване от нулата за желания знак след низа посредством квадратни скоби, например $str[42], така че бихте могли да мислите за даден низ като за [[Масив_Масив (програмиране)|масив]] от знаци.
 
Дефиниране и инициализиране
</source>
 
Още функции можете да намерите тук [[http://php.net/manual/en/ref.strings.php]].
 
== Низове в JavaScript ==
Низът в [[JavaScript]] са последователност от знаци/символи, които започват и завършват с единични или двойни кавички. Освен да се работи с низовете като букви/знаци, JavaScript предлага възможността да се работи с тях и като [[Обект_Обект (програмиране)|обекти]] с много свойства и функции. Това е полезно, когато трябва да се приложат определени процеси върху низът.
 
'''Как се създават низове:'''
 
{{Типове данни}}
 
[[Категория:Информатика]]
[[Категория:Формални езици]]