Низ

от Уикипедия, свободната енциклопедия
Направо към: навигация, търсене

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

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

Дължина на низ[редактиране | edit source]

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

Формална теория[редактиране | edit source]

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

Кодиране на символи[редактиране | edit source]

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

Символни низове в C#[редактиране | edit source]

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

Създаване на String[редактиране | edit source]

За да работим с променлива от тип 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

Операции със символни низове[редактиране | edit source]

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

Конкатенирането на низове е много бавна операция. Това е заради факта, че всеки път трябва да се заделя нов буфер и да се презипише цялата информация в стринга наново, освен това стария буфер е неизползваем и той трябва да бъде изтрит от 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[редактиране | edit source]

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

Създаване на символни низове[редактиране | edit source]

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

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

Долепване на низове (конкатенция)[редактиране | edit source]

Класът 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()[редактиране | edit source]

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

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

Извличане на част от низ[редактиране | edit source]

Извличането на част от низ в отделна променлива се прави чрез метода 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

Разцепване на низ по разделител[редактиране | edit source]

Методът 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[редактиране | edit source]

Класовете 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

Сравняване на символни низове[редактиране | edit source]

  • 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[редактиране | edit source]

Низът в езика С представлява последователност от символи, които завършват с терминираща нула ('\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 можете да намерите [[2]]

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

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

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

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

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++[редактиране | edit source]

В С++ съществува клас, намиращ се в 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 можете да намерите [[4]].

Низове в PHP[редактиране | edit source]

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

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

Низове в JavaScript[редактиране | edit source]

Низът в 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

Източници[редактиране | edit source]

  1. Въведение в C#, 465-509.