Низ

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

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

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

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

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

• с фиксирана дължина – имат постоянна максимална дължина и използват същото количество памет, независимо дали този максимум е достигнат;
• с променлива дължина.

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

Нека означим със Σ азбуката, която е непразно крайно множество. Елементите на Σ се наричат букви. Низ (или дума) от Σ (Σ*) е всяка крайна последователност от буквите на Σ. Например ако Σ = {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;

// GeorgiGeorgiev

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

Трябва да се отбележи, че символните низове са неизменими и всяка промяна на един низ води до създаване на нов, в който се пази резултатът и пренасочване към него. Това може силно да забави изпълнението на една програма при много редакции на един низ (например долепване на символи в цикъл). В такива случаи използваме класа 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

String Builder

Конкатенирането на низове е много бавна операция. Това е заради факта, че всеки път трябва да се заделя нов буфер и да се презипише цялата информация в низа наново, освен това старият буфер е неизползваем и той трябва да бъде изтрит от Garbage collector.

Затова се използва специално направен клас StringBuilder, този клас има предварително зададен буфер, който може да бъде динамично променян, благодарение на което работата със символни низове е много по-бърза. Когато сме завършили низа можем да извикаме метода ToString(), който да го преобразува в нормален низ.

int bufferSize = 300;
StringBuilder sb = new StringBuilder(bufferSize);
// Ако оставим конструктора празен, той ще задели зададената му памет по подразбиране.

for (int i = 0; i < 100; i++)
{
     sb.Append(i); // Слепва зададената стойност с предишната.
}

Console.WriteLine(sb.ToString()); // Принтира на конзолата
//NOTE: Конзолата автоматично извиква метода ToString(), затова той може да бъде пропустнат.

StringBuilder притежава много разнообразни методи можете да погледнете повече за тях тук [1]

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

В езика за програмиране Java, символните низове са обекти.

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

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

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

String greeting = "Hello, world!";

В този случай "Hello, world!" е низов литерал – поредица от символи в кода, които са заградени с двойни кавички.

За отпечатване на съобщение в кавички е необходимо да се използва екраниращ символ (escaping character) – обратна наклонена черта (\).

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:

• capacity() – връща дължината на символния низ – включва общия брой символи – заети и свободни

StringBuffer stringBuffer = new StringBuffer(“Hello World”);
System.out.println(stringBuffer.capacity());
// 27

• length() – връща дължината на записания низ в променлива

StringBuffer stringBuffer = new StringBuffer(“Hello World!”);
System.out.println(stringBuffer.length());
// 11

• charAt(int index) – връща символа на указаната позиция

String example = "Welcome to Java";
char result = example.charAt(11);
System.out.println(result);
//J

• append(…) – слепва низ, число или друга стойност след последния записан символ в буфера

StringBuffer example = new StringBuffer("Welcome");
example.append(" to Wikipedia");
System.out.println(example);
// Welcome to Wikipedia

• delete(int start, int end)– изтрива част от низ по зададена начална и крайна позиция

StringBuffer example = new StringBuffer("Welcome");
example.delete(2,5);
System.out.println(example);
// Wecoe

• insert(int offset, String str) – вмъква символен низ на дадена позиция

StringBuffer example = new StringBuffer("Welcome to Wiki");
example.insert(15, "pedia");
System.out.println(example.toString());
// Welcome to Wikipedia

• replace(int start, int end, String str) – замества записания низ между началната и крайната позиция със стойността на променливата str

StringBuffer example = new StringBuffer("Welcome to Java");
example.replace(11, 15, "Wiki");
//Welcome to Wiki

• StringBuilder reverse() – записва символите в нова променлива в обратен ред

StringBuilder example = new StringBuilder("wikipedia");
System.out.println(example.reverse());
//aidepikiw

• toString() – връща записаната информация в обекта на StringBuilder като резултат от тип String, който може да се запише в променлива на String

Integer example = 5;
System.out.println(example.toString());
System.out.println(Integer.toString(12))
//5
//12

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

• boolean endsWith(String suffix)/ boolean startsWith(String prefix) – връща стойност true, ако низът завършва или започва с подниз, деклариран като стойност на метода.

String example = new String("Welcome to Wikipedia!");
boolean returnValue;

returnValue = example.endsWith(" Wikipedia!");
System.out.println(returnValue);

returnValue = example.endsWith("Wiki");
System.out.println(returnValue);
//true
//false

String example = " https://bg.wikipedia.org";
String startString1 = "www";
String startString2 = "https://";
boolean returnValue1 = example.startsWith(startString1);
boolean returnValue2= example.startsWith(startString2);
System.out.println(returnValue1);
System.out.println(returnValue2);
// false
// true

• int compareTo(String anotherString) – сравнява два низа лексикографски. За да бъдат два низа еднакви, то те трябва да имат еднакъв брой символи и да бъдат подредени в един и същ ред. Този метод връща цяло положително, отрицателно число или 0 в зависимост от лексикографската наредба.

String example = "Hello, World";
String anotherExample = "hello, world";
Object objectExample = example;
System.out.println(example.compareTo(anotherExample));
System.out.println(example.compareTo(objectExample));
//-32
//0

• int compareToIgnoreCase(String str) – този метод сравнява два низа лексикографски, без да взима предвид дали са малки или големи буквите.

String example = "Hello, World";
String anotherExample = "hello, world";
System.out.println(example.compareToIgnoreCase(anotherExample));
//0

• boolean equals(Object anObject) – връща резултат true ако стойностите на двата низа са еднакви и false ако са различни

boolean boolObject1 = new Boolean(true);
boolean boolObject2 = new Boolean(false);

boolean result = boolObject1.equals(boolObject2);

String example = " boolObject1: " + boolObject1+ " and boolObject2: " + boolObject2+ " are equal: " + result;
System.out.println(example);
// boolObject1: true and boolObject2: false are equal: false

• boolean equalsIgnoreCase(String anotherString) – сравнява двата низа дали са еднакви, без да взима предвид дали буквите са малки или големи.

String example1 = new String("Welcome to Wikipedia!");
String example2= example1;
String example3 = new String("welcome to wikipedia!");
String example4 = new String("WELCOME TO WIKIPEDIA!");
boolean returnValue;

returnValue = example1.equalsIgnoreCase(example2);
System.out.println(returnValue);
returnValue = example1.equalsIgnoreCase(example3);
System.out.println(returnValue);
returnValue = example1.equalsIgnoreCase(example4);
System.out.println(returnValue);

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

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

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

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

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); // Разменяне на низовете.

Низове в PHP

В PHP символът е един байт, т.е. съществуват точно 256 възможни символа. Това също означава, че PHP няма естествена поддръжка за Unicode.

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

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

$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");

Още функции можете да намерите тук [2].

Низове в 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() – Връща символа, който се намира на дадената позиция в низа

var myString = 'Some text';
console.log(myString.charAt(4));
// Tози пример ще върне елементът на позиция 4: e

• charCodeAt() – Намира смволния код на символ от дадена позиция в низа

var message="Hello"
alert(message.charAt(1))

• concat() – Слепва (конкатенира) два или повече низа и връща новата комбинирана низова стойност

//concat(v1, v2,..)
var message="Education"
var final=message.concat(" is important"," for your future.")
//alerts "Education important for your future."
alert(final)

• fixed() – Добавя таговете <TT> и </TT> около низова стойност
• fontcolor() – Добавя таговете <FONT color="color"> и </FONT> около низова стойност. Те сменят цвета на низа с указания цвят
• fontsize() – Добавя таговете <FONT size="number"> и </FONT> около низова стойност. Те променят размера на шрифта на низа с указано число
• fromCharCode() – Използва символни кодове, предадени като параметри за създаване на нов низ

//fromCharCode(c1, c2,...)
console.log(String.fromCharCode(97,98,99,120,121,122))
//output: abcxyz
console.log(String.fromCharCode(72,69,76,76,79))
//output: HELLO

• indexOf() – Търси символ, предаден като параметър, в низа. Ако бъде намерен, връща позицията на първото срещане на символа, иначе връща -1

//indexOf(char/substring)
var sentence="Hi, my name is Pesho!"
if (sentence.indexOf("Pesho")!=-1)
alert("Pesho is in there!")

• italics() – Добавя таговете <I> и </I> около низова стойност
• lastindexOf() – Търси символ, предаден като параметър в низа. Ако бъде намерен, връща позицията на последното срещане на символа, иначе връща -1

//lastIndexOf(substr, [start])
var myString = 'Hello Wikipedia';
console.log(myString.lastIndexOf('e'));
//output: 11

• link() – Създава HTML връзки чрез използване на низа като текст на връзката и свързване с URL адреса, предаден като параметър
• match() – Сравнява низ и регулярен израз, за да провери дали съвпадат

//match(regexp) //select integers only
var intRegex = /[0-9 -()+]+$/;

var myNumber = '22';
var myInt = myNumber.match(intRegex);
console.log(isInt);
//output: 22

var myString = 'Pesho is 22 years old';
var myInt = myString.match(intRegex);
console.log(isInt);
//output: null

• replace() – Открива дали един регулярен израз съвпада с низ и след това замества съвпадналия низ с нов низ

//replace(substr, replacetext)
var myString = 'Pesho is 22 years old';
console.log(myString.replace(/Pesho/i, "Ivan"));
//output: Ivan is 22 years old

• search() – Изпълнява търсене на съвпадение между регулярен израз и указан низ
• slice() – Изпълнява търсене на съвпадение между регулярен израз и указан низ

/slice(start, end)
var text="legendary"
text.slice(0,5) //returns "legen"
text.slice(5,8) //returns "dar"

• small() – Добавя таговете <SMALL> и </SMALL> около низовата стойност
• split() – Разделя низа на масив от низове на базата на някакъв символ, предаден като параметър на метода

//split(delimiter)
var message="Welcome to Wikipedia"
//word[0] contains "We"
//word[1] contains "lcome to Wikipedia"
var word=message.split("l")

• strike() – Добавя таговете <STRIKE> и </STRIKE> около низова стойност
• sub() – Добавя таговете <SUB> и </SUB> около низова стойност
• substr() – Позволява да се върне част от низа, указана като начална позиция и завършваща след определен брой символи
• substring() – Позволява да се върне част от низа, указана като начална позиция и крайна позиция

//substring(from, [to])
var myString = 'Wikipedia is helpful';
myString = myString.substring(0,9);
console.log(myString)
//output: Wikipedia

• sup() – Добавя таговете <SUP> и </SUP> около низова стойност
• toString() – Връща низовата стойност на String обекта
• toLowerCase() – Конвертира целия низ в малки букви и връща резултата

//toLowerCase()
var myString = 'HELLO WIKIPEDIA';
myString = myString.toLowerCase();
console.log(myString)
//output: hello wikipedia

• toUpperCase() – Конвертира целия низ в големи букви и връща резултата

//toUpperCase()
var myString = 'hello wikipedia';
myString = myString.toUpperCase();
console.log(myString)
//output: HELLO WIKIPEDIA

Източници

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