Низ

В компютърните науки низ е крайна поредица от символи. Елементите му евентуално могат да бъдат променяни, както и дължината му. Низовете обикновено се разглеждат като тип данни и често са имплементирани като масиви от байтове (или думи), които съхраняват последователност от елементи, използвайки кодиране на символите.

В зависимост от езика за програмиране и използваният тип данни, променлива декларирана като низ може да бъде съхранена в паметта статично (предварително определена максимална дължина) или динамично (може да съдържа различен брой елементи). Във формалните езици, които се използват в математическата логика и теоретичната информатика, низ е крайна последователност от символи от дадено множество, наречено азбуката.

Дължина на низ

Въпреки че низовете могат да имат произволна (но ограничена) дължина, в повечето езици за програмиране дължината е ограничена до изкуствен максимум. По принцип има два вида низови: с фиксирана дължина - имат постоянна максимална дължина и използват същото количество памет независимо дали този максимум е достигнат; низове с променлива дължина.

Формална теория

Нека означим със Σ азбуката, която е непразно крайно множество. Елементите на Σ се наричат букви. Низ (или дума) от Σ (Σ*) е всяка крайна последователност от буквите на Σ. Например ако Σ = {0, 1}, то 0101 е низ на азбуката Σ.

Множеството от всички низове над Σ с дължина n се записва Σn. Пример: ако Σ = {0, 1}, тогава Σ2 = {00, 01, 10, 11}. Имайте предвид, че Σ0 = {ε} за всяка азбука Σ.

Множество от низове над Σ (например всяко подмножество от Σ*) се нарича формален език над Σ. Пример: ако Σ = {0, 1}, множеството от низове с равен брой нули и единици ({ε, 1, 00, 11, 001, 010, 100, 111, 0000, 0011, 0101, 0110, 1001, 1010, 1100, 1111, ...}) е формален език над Σ.

Кодиране на символи

Низовите типове данни в миналото са използвали един байт за символ. Някои езици като китайски, японски и др. (познати още като CJK) се нуждаят от много повече от 256 символа. Едно от решенията на този проблем е запазването на еднобайтовото представяне на ASCII и използване на двубайтово за CJK езиците. Това довежда до проблеми със съпоставянето на низовете, загуби на дължина и др. Unicode е опростил нещата значително в това отношение и повечето програмни езици го поддържат.

Символни низове в C#

В C# символните низове са дефинирани в класа System.String. За декларация по време на писане на код се използва служебната дума String. Тъй като String е клас, той е референтен тип данни и в стека на програмата се съхранява само указателя, сочещ към поле от динамичната памет, където се съхранява реалната стойност на обекта..

Създаване на String

За да работим с променлива от тип string трябва първо да я създадем и инициализираме. Трябва да се има предвид, че създаването на референтен тип само заделя част от динамичната памет със стойност null. Ако се опитаме да извикаме инстанцирания обект, ще получим грешка за достъп до липсваща стойност NullReferenceException. Има три начина за инициализиране на променливи:
Задаване на литерал за символен низ. По този начин задаваме предефинирано текстово съдържание на променливата. Използва се когато знаем стойността, която трябва да бъде съхранена.

string greeting = "Hello, World!";

Присвояване на стойност от друг низ. При присвояване стойността на един низ на друг новата променлива приема референцията към същото място в динамичната памет, към което сочи първата.

string initial = "Some Text";
string assigned = initial;

Приемане на стойност от операция, която връща string. Това може да бъде метод, който валидира данни; преобразуване на друг тип променлива; събиране на няколко низа.

string firstName = "Georgi";
string lastName = "Georgiev";
string fullName = firstName+lastName;

// Georgi Georgiev

Операции със символни низове

Трябва да се отбележи, че символните низове са неизменими и всяка промяна на един низ води до създаване на нов, в който се пази резултата и пренасочване към него. Това може силно да забави изпълнението на една програма при много редакции на един низ (например долепване на символи в цикъл). В такива случаи използваме класа StringBuilder, който оптимизира работата с низове.

Сравняване на низове

Сравняване за еднаквост. Удобен за това е метода Equals(), който работи еквивалентно на ==. Метода връща булев резултат true при еднакви низове и false при различни. Трябва да се има в предвид, че по този начин се сравняват побуквено елементите на масива, като се прави разлика между главни и малки букви. Често ще ни интересува само текстовото съдържание без регистъра на буквите, затова може да използваме метода Equals() с параметър StringComparison.CurrentCultureIgnoreCase

string word1 = "C#";
string word2 = "c#";
Console.WriteLine(word1.Equals("C#"));
Console.WriteLine(word1.Equals(word2));
Console.WriteLine(word1=="C#");
Console.WriteLine(word1==word2);

// True
// False
// True
// False

Сравняване на низове по азбучен ред. За тази цел се ползва метода String.CompareTo(), който връща отрицателна стойност, когато първият низ е лексикографски преди втория, нула при равни стойности и положителна стойност при втори преди първи низ. Отново трябва да се има в предвид, че сравнението взима под внимание регистъра на буквите като малките са преди големите. Ако искаме да сравним двата низа без да взимаме под внимание регистъра ползваме статичния метод string.Compare(string strA, string strB, bool ignoreCase). Вместо булевата променлива ignoreCase можем да подадем StringComparison.CurrentCultureIgnoreCase, с което метода отново ще работи.

string str1 = "sCore";
string str2 = "score";
Console.WriteLine(str1.CompareTo(str2));
Console.WriteLine(str2.CompareTo(str1));
Console.WriteLine(str1.CompareTo(str1));
Console.WriteLine(string.Compare(str1, str2 , true));
Console.WriteLine(string.Compare(str1, str2 , StringComparison.CurrentCultureIgnoreCase));

// 1
// -1
// 0
// 0
// 0

Долепване на низове (конкатенация)
Долепването на символни низове става чрез операторите +, += и метода Concat(). Към всеки низ може да се добави всеки друг тип, който може да се представи под формата на низ.

string greeting = "Hello, ";
string name = "Pesho!";
string result = string.Concat(greeting, name);
result = result + " How are you?\n";
result += "It's " + DateTime.Now;
Console.WriteLine(result);

//Hello, Pesho! How are you?
//It's 22.8.2013 г. 7:33:31

Промяна на регистъра на символен низ
Понякога се налага да приведем един низ в единен регистър (при записване на потребителски имена в база данни, проверка на парола и т.н.). Това става с двата метода ToUpper() и ToLower().

string text = "SoMe teXt";
Console.WriteLine(text.ToUpper());
Console.WriteLine(text.ToLower());

//SOME TEXT
//some text

Търсене на низ в друг низ
За търсене в даден низ се ползват двата метода IndexOf() и LastIndexOf(), като първия търси от началото на низа към края му, а втория на обратно. И двата метода връщат цяло число когато намерят индекс и -1 ако няма намерена стойност, като регистъра на текста е от значение. Ако искаме да търсим от определена стойност, можем да подадем параметър с индекса, от който да започва търсенето.

string text = "Some text";
int indexEFirst = text.IndexOf("e");
int indexESecond = text.IndexOf("e",5);
int lastIndex = text.LastIndexOf("e");
Console.WriteLine(indexEFirst);
Console.WriteLine(indexESecond);
Console.WriteLine(lastIndex);

// 3
// 6
// 6

Извличане на част от низ
За тази цел използваме метода Substring() с подадени параметри за начален индекс и дължина. Ако не подадем дължина на подниз се взима от дадения индекс до края на първия низ.

string text = "Some text here";
string extracted = text.Substring(5, 4);
string extractedToEnd = text.Substring(5);
Console.WriteLine(extracted);
Console.WriteLine(extractedToEnd);

// text
// text here

Разцепване на низ по разделител
За да се изведат в масив елементите от списък записан в стринг се ползва метода Split(), на който подаваме разделител или масив от разделители. Тъй като при списъците има допиране на разделители, често се получават празни полета в новосъздадения масив, затова в параметрите на метода подаваме StringSplitOptions.RemoveEmptyEntries, който да приема два съседни разделителя за един.

string listOfNames = "Gosho, Pesho, Tosho, Ivan";
char[] separators = new char[] {' ',',','.'};
string[] Names = listOfNames.Split(separators,StringSplitOptions.RemoveEmptyEntries);

Премахване на ненужни символи от стринг
За да премахнем празни места (нови редове, интервали и табулации) в началото и в края на един символен низ използваме метода Trim(). При подаване на масив със символи същият метод ги търси и изтрива само тях в символния низ. Ако искаме да премахнем ненужните символи и празни места само в началото или само в края използваме съответно TrimStart() и TrimEnd()

string data1 = " 111 $ % Text Example ### s ";
string data2 = "     \n\n Text Example      ";
char[] trimChars = new char[] { ' ', '1', '$', '%', '#', 's' };
Console.WriteLine(data2.Trim());
Console.WriteLine(data1.Trim(trimChars));
Console.WriteLine(data1.TrimEnd(trimChars));

// Text Example
// Text Example
//  111 $ % Text Example

Оптимизация на паметта при символни низове
Когато инициализираме променлива от тип string с низов литерал, динамичната памет се обхожда и се прави проверка дали такава стойност вече съществува. Ако съществува, новата променлива просто се пренасочва към нея. Ако не, референцията се препраща да сочи към нов блок памет. Интернирането на низове в .NET е възможно, защото низовете по концепция са неизменими и няма опасност някой да промени областта, сочена от няколко стрингови променливи едновременно. Когато не инициализираме низовете с литерали, не се ползва интерниране. Все пак, ако искаме да използваме интерниране изрично, можем да го направим чрез метода Intern(). За да демонстрираме това по-долу използваме статичния метод Object.ReferenceEquals(), който проверява дали два обекта сочат към един и същ блок памет.

string declared = "Some text";
string built = new StringBuilder ("Some text").ToString();
string interned = string.Intern(built);
Console.WriteLine(object.ReferenceEquals(declared, built));
Console.WriteLine(object.ReferenceEquals(declared, interned));

// False
// True

Символни низове в Java

В езика за програмиране Java, символните низове са обекти. В Java класът String се използва за създаване и обработка на символни низове. Последователностите от символи, записани в променлива от класа, са неизменими (immutable). Веднъж записано съдържанието на едно място, то не може да бъде променяно директно.

Създаване на символни низове

Най-лесния начин за създаване на стринг е да се напише следното:

String greeting = "Hello, world!";

В този случай, "Hello, world!" е низов литерал – поредица от символи в кода, които са заградени с двойни кавички. За отпечатване на съобщение в кавички е необходимо да се използва escape символ – обратна наклонена черта (\).

String quotedString = "She said \"Hello, World!\""; //She said "Hello, world!"

Може да се създаде String обект като се използва ключовата дума new и конструктор. Класът String съдържа конструктори, които позволяват да се инициализира стойността на низа, чрез използване на различни източници, като масив от символи:

char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
String helloString = new String(helloArray);
System.out.println(helloString);

Долепване на низове (конкатенция)

Класът String включва метод за долепване на два низа:

String greet = "Hello, ";
String name = "world!";
String result = greet.concat(name); //Hello, world!

Резултата от това връща символен низ, който представлява String greet и долепен след него String name. Може да се използва метода concat() с низов литерал:

"Hello, ".concat("world"); //Hello, world!

Често за долепване на низове се използва оператора +, при който резултата отново е същият както и при горните два начина:

"Hello, " + "world" + "!"  //Hello, world!

Операторът + често се използва с конструкцията print :

String greet = "Hello,";
String name = "world!";
String fullGreeting = greet + " " + name;
System.out.println(fullGreeting); //Hello, world!

Възможно е долепване на различни типове обекти. За всеки обект, който не е от тип String, съществува метод за преобразуването му - toString().

Използване на String.format()

Класът String включва статичния метод String.format() за създаване на форматирани символни низове. Този метод позволява създаването на форматирани стрингове, които могат да се използват повторно, като само се променят параметрите. Този метод е подобен на метода System.out.printf(), който също форматира шаблонен низ и извежда стойности на местата на параметрите.

String example = String.format("%.2f", 3.141593); // "3.14"

Извличане на част от низ

Извличането на част от низ в отделна променлива се прави чрез метода substring(), като зададем начална и крайна позиция в текста. String substring(int beginIndex, int endIndex) - Резултата е нов стринг, като beginIndex показва от къде да започва новият стринг, а краят е endIndex – 1. В случай че, не е упоменат endIndex, за край се счита последния символ от оригиналния символен низ.

String example = new String("Welcome to Wikipedia!");
System.out.println(example.substring(10)); // Wikipedia!");
System.out.println(example.substring(10, 15)); // Wiki

Разцепване на низ по разделител

Методът split в класа String връща масив от символни низове състоящи се от поднизове разцепени от един или група от разделители.

String example = "Hello_World";
String example [] = example.split("_");
for (int i = 0; i < example.length; i++)
    {
        System.out.println(example[i]);
    }			
// Hello              
//World

Методите toLowerCase() и toUpperCase() връщат нов стринг като конвертират всички букви в малки или главни.

String example = new String("Welcome to Wikipedia");
System.out.println(example.toLowerCase()); // welcome to wikipedia

String example = new String("Welcome to Wikipedia");
System.out.println(example.toUpperCase()); //WELCOME TO WIKIPEDIA

trim методът връща нов стринг премахвайки интервалите в началото и края на оригиналния символен низ.

String example = new String("           Welcome to Wikipedia        ");
System.out.println(example.trim()); // Welcome to Wikipedia

Класовете StringBuilder/StringBuffer

Класовете StringBuilder/StringBuffer са алтернатива на класът String. Те могат да бъдат използвани навсякъде където се използват символни низове. Тези класове са по-приспособими от класът String. При тях може да се добавя ново съдържание. По-важни методи в StringBuilder:

• StringBuilder(int capacity) – конструктор с параметър начален капацитет.
• capacity() – връща дължината на символния низ – включва общия брой символи – заети и свободни
• length() - връща дължината на записания низ в променлива
• charAt(int index) - връща символа на указаната позиция
• append(…) - слепва низ, число или друга стойност след последния записан символ в буфера
• delete(int start, int end)– изтрива част от низ по зададена начална и крайна позиция
• insert(int offset, String str) – вмъква символен низ на дадена позиция
• replace(int start, int end, String str) – замества записания низ между началната и крайната позиция със стойността на променливата str
• StringBuilder reverse() – записва символите в нова променлива в обратен ред
• toString() - връща записаната информация в обекта на StringBuilder като резултат от тип String, който може да се запише в променлива на String

Сравняване на символни низове

• boolean endsWith(String suffix)/ boolean startsWith(String prefix) - връща стойност true ако стринга завършва или започва с подниз деклариран като стойност на метода.
• int compareTo(String anotherString) - сравнява два стринга лексикографски. За да бъдат два стринга еднакви, то те трябва да имат еднакъв брой символи и да бъдат подредени в един и същ ред. Този метод връща цяло положително, отрицателно число или 0 в зависимост от лексикографската наредба.
• int compareToIgnoreCase(String str) – този метод сравнява два стринга лексикографкски, без да взима предвид дали са малки или големи буквите.
• boolean equals(Object anObject) - връща резултат true ако стойностите на двата низа са еднакви и false ако са различни
• boolean equalsIgnoreCase(String anotherString) - сравнява двата низа дали са еднакви, без да взима предвид дали буквите са малки или големи.

Низове в C

Низът в езика С представлява последователност от символи, които завършват с терминираща нула ('\0'). Използва се ASCII таблица за символи. Няма запазена дума string, затова трябва да използваме ето тези конструкции:

char str[13] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd','!', '\0'};

В този пример се вижда какво представлява стринга отвътре. Забележете, че трябва да се остави място за терминиращата нула, защото благодарение на нея се разбира кога сме достигнали края на низа. Тази конструкция може да се запише и съкратено по този начин:

char str[] = "Hello world!";

В този пример макар да не записваме терминиращата нула компилаторът си оставя място за нея и я слага.

Ето още един пример, но този път с указател(pointer)

char* str = "Hello world!";

Тук указателят запазва адреса на първият символ, а останалите символи са следващите, докато не се достине до '\0'.

В 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, ако резултат не е намерен.

Още за библиотеката string.h можете да намерите [[1]]

Друга полезна библиотека е stdlib.h, благодарение на нея може да превръщаме стрингове в числа.

int atoi(const char *str);    //Връща целочислено число.
double atof(const char *str); //Връща реално число.

Още за библиотеката stdlib.h можете да намерите [[2]]

Ето пример за конкатерине на низове:

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.

Низове в C++

В С++ съществува клас, намиращ се в namespace std, който поддържа работа с низове. Думата string е ключова дума. Запазването на стрингове в памета е по начина по който се запазват и в C(накрая има терминираща нула). Работата със стрингове е много по-удобна, защото са предефинирани аритметичните знаци + и =.

string str = "Hello world!";             // Ако сме импортнали std.
std::string str2 = "Hello again world!"; // Aко не сме импортнали std.

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

string str1 = "Hello";
string str2 = " world!";
string str3 = str1 + str2; // Копираме два стринга и ги даваме на трети.
str1 += str2; // Добавяне към първия стринг.

Освен това, класът стринг поддържа и много допълнителни помощни функции.

string str = "Hello world!";
str.size();
str.length(); // И двете функции показват дължината на низа (size == length).
str.empty();  // Връща 0 ако не е празен, а ако е празен връща 1.
str.begin();  // Връща указател към началото на низа.
str.end();    // Връща указател към края на низа.

Има вградена функция за размяната на низове.

string str1 = "first";
string str2 = "second";
str1.swap(str2); // Разменяне на низовете.

Още методи в класът "string можете да намерите [[3]].

Низове в PHP

В PHP символът един байт, т.е., съществуват точно 256 възможни символа. Това също означава, че PHP няма естествена поддръжка за Unicode. Знаците в даден низ могат да бъдат достъпвани и изменяни чрез указване на отместване от нулата за желания знак след низа посредством квадратни скоби, например $str[42], така че бихте могли да мислите за даден низ като за масив от знаци.

Дeфиниране и инициализиране

$txt="Hello world!";
echo $txt;

Полезни функции и оператори

Конкатенация

$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2;

strlen() - връща дължината на стринга

echo strlen("Hello world!");

strpos() - за търсене на символ/и в низ

echo strpos("Hello world!","world");

Низове в JavaScript

Низът в JavaScript са последователност от знаци/символи, които започват и завършват с единични или двойни кавички. Освен да се работи с низовете като букви/знаци, JavaScript предлага възможността да се работи с тях и като обекти с много свойства и функции. Това е полезно, когато трябва да се приложат определени процеси върху низът.

Как се създават низове:

1. Обект от вида String

var myString = new String("Life gets better");

2. Низов литерал

var myString = "Life";

Функции на низ: Низовете имат няколко функции, които са удобни в случай, че искате бързо и лесно да ги манипулирате по някакъв начин.

Методи

• anchor() - Създава HTML таг за котва с цел на страницата
• big() - Добавя таговете <BIG> и </BIG> около стойността на низа
• bold() - Добавя таговете <b> и </b> около низова стойност
• charAt()- Връща символа, който се намира на дадената позиция в низа
• charCodeAt() - Намира смволния код на символ от дадена позиция в низа
• concat() - Слепва/конкатенира/ два или повече низа и връща новата комбинирана низова стойност
• fixed() - Добавя таговете <TT> и </TT> около низова стойност
• fontcolor() - Добавя таговете <FONT color="color"> и </FONT> около низова стойност. Те сменят цвета на низа с указания цвят
• fontsize() - Добавя таговете <FONT size="number"> и </FONT> около низова стойност. Те променят размера на шрифта на низа с указано число
• fromCharCode() - Използва символни кодове, предадени като параметри за създаване на нов низ
• indexOf() - Търси символ, предаден като параметър, в низа. Ако бъде намерен, връща позицията на първото срещане на символа, иначе връща -1
• italics() - Добавя таговете <I> и </I> около низова стойност
• lastindexOf() - Търси символ, предаден като параметър в низа. Ако бъде намерен, връща позицията на последното срещане на символа, иначе връща -1
• link() - Създава HTML връзки чрез използване на низа като текст на връзката и свързване с URL адреса, предаден като параметър
• match() - Сравнява низ и регулярен израз, за да провери дали съвпадат
• replace() - Открива дали един регулярен израз съвпада с низ и след това замества съвпадналия низ с нов низ
• search() - Изпълнява търсене на съвпадение между регулярен израз и указан низ
• slice() - Изпълнява търсене на съвпадение между регулярен израз и указан низ
• small() - Добавя таговете <SMALL> и </SMALL> около низовата стойност
• split() - Разделя низа на масив от низове на базата на някакъв символ, предаден като параметър на метода
• strike() - Добавя таговете <STRIKE> и </STRIKE> около низова стойност
• sub() - Добавя таговете <SUB> и </SUB> около низова стойност
• substr() - Позволява да се върне част от низа, указана като начална позиция и завършваща след определен брой символи
• substring() - Позволява да се върне част от низа, указана като начална позиция и крайна позиция
• sup() - Добавя таговете <SUP> и </SUP> около низова стойност
• toString() - Връща низовата стойност на String обекта
• toLowerCase() - Конвертира целият низ в малки букви и връща резултата
• toUpperCase() - Конвертира целият низ в големи букви и връща резултата

Източници

• Въведение в програмирането с Java
• http://docs.oracle.com/