JavaScript, масиви: описание

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

JavaScript масивът е съвременна форма на представяне на данни, която се различава от подобни структури на други езици. Опит в областта на представителството и. T обработка на информация за javascript винаги е имало значително значение. Тук, в браузъра, работи диалогът с клиента. Тук е важно бързо да разглобите линия от информация от сървъра и да я нарисувате с помощта на необходимите тагове. Сървърните езици формират съдържанието и структурата на страниците, но тяхното правилно използване е грижата на езика на браузъра.

Представяне на информацията: променливи и данни

Професионалният разработчик използва променливи в прости случаи, когато той „прави“ за (...) {...}, „контроли“, докато (...) {...}, „използва“ „switch“ () {case "": ...}, ... структурата в Във всички останали случаи информацията е представена от структури за данни.

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

Масивът на JavaScript е по-динамична и обемна версия на променлива, когато е структура от данни. Чрез индексиране на масив, например чрез стойност, време или друг параметър, можете да имате различно съдържание за всеки индекс. Масивът може да бъде набор (дефинирана структура) на променливи, които, когато се поставят в друг масив, ще представят динамиката на такава структура или чрез параметър, или по време.

И накрая, можете да създадете масив от обекти или система от обекти - концептуална комбинация от данни, която има структура, съдържание и набор от методи, които „сами” показват съответните свойства.

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

Синтактични езикови конструкции

В първото приближение, масивът на JavaScript е подобен на синтактичните конструкции на други езици. Семантиката също е еквивалентна, с изключение на формите на нейното изразяване. Можете да използвате синтаксиса и семантиката на JavaScript и успешно да решите всяка сложна задача.

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

Определяне на стандартен синтаксис на език Масиви на Javascript Функциите и методите са доста обширни, но на практика обикновено се използва само част.

forEach е най-интересният метод за масив. JavaScript предоставя на разработчика възможността да дефинира собствената си функция, за да работи с всеки елемент от масива. Не съществува концепция за „прекъсване“, т.е. за всеки трябва да се разглежда като операция върху всички елементи на масива.

• aData.forEach (функция (val, ind, arr) {...});

тук 'val' е елемент, 'ind' е неговият индекс, а 'arr' е действителният масив 'aData'. Функцията може да извършва всякакви действия върху елементите на масива. Ако има определен смисъл, това ще бъде операция на разработчика, а не синтаксис на езика, т.е. масивът ще има не само съдържанието, но и операциите, с които разполага, според предназначението му в общия контекст на алгоритъма.

Отвъд синтаксиса

Използвайки масив от JavaScript обекти, можете да надхвърлите синтаксиса. Формално, всяка обектна променлива и всяка конструкция на неговия метод се намира в синтаксиса на езика, но в контекста на обектно-ориентираното програмиране възниква системен ефект - ново качество, което предлага свой собствен синтаксис: “независими” отношения между обектите.

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

Обектно-ориентираната формула изглежда коренно различна. Има обекти, които имат съдържание и свойства. Това е, което осигурява връзката (кода, който ги изпълнява) на обектите помежду си. Не трябва да има код извън тези отношения.

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

Масив на Javascript: създаване

Идеална и красива конструкция на масива:

• var aData = []; // по същество винаги е масив;
• var aData = {}; // по съдържание, евентуално асоциативен масив;

Можете да пишете и още "интелигентно":

• var aData = new Array ();

или много "известен":

• var aData = new Array (13).

JavaScript не настоява за задължително посочване на броя на елементите и не налага правила относно индексирането, размерите или типовете елементи. На тази проста основа не се препоръчва да се злоупотребяват с техните права, като ги ограничават: всички масиви трябва да бъдат представени и използвани възможно най-свободно.

Използвайте масиви

Всеки елемент от масива има индекс - цифрова стойност от 0 до 2 ³² , но не трябва да се приближава тази цифра. Практичен и прагматичен JavaScript масив е десетки, стотици, хиляди елементи, но не повече. Ако се нуждаете от повече, по-добре е първо да преразгледате алгоритъма или техническата задача, и ако нищо не се случи, тогава в дълбините на браузъра могат да се проектират само многомилионни масивни структури.

Индексите на масивите не винаги са последователни. В JavaScript премахването на елемент от масив означава да се направи „дупка“ в него. В процеса на използване на масив, той може да се превърне в “сито” на индекси, което не засяга неговото изпълнение, безопасността на други елементи.

JavaScript е лишен от кратък PHP конструкт: $ aData [] = "нов елемент"; и предлага да се посочи строго какво се добавя и в кой елемент (с кой индекс) се променя стойността. Типът елемент не е от значение. Масивът може да съдържа всичко, което е позволено от синтаксиса, в произволен ред и асортимент.

Методите push () и pop () премахват липсата на "$ aData [] = ...", но привличат вниманието на разработчика към идеята за последния елемент и ви напомнят за концепцията на стека. Подобна двойка методи - unshift () и shift () - работи с първия елемент на масива, измествайки другите елементи към големи индекси.

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

Размер на масива

Системите са “винаги едномерни”, но всяка система се състои от вътрешни подсистеми и сама по себе си е част от нещо по-глобално. Подобно на общата концепция за системите, в JavaScript няма двуизмерен масив, но може лесно да бъде създаден чрез добавяне на други масиви като елементи на масив.

Индексирането чрез вътрешни масиви се формира по естествен начин: "aData [i] [j] ... [z]", но идеята винаги е за предпочитане:

• var aElement = aData [i]; // избира вътрешния масив;
• aElement [j] = ...; // използваме елемента на вътрешния масив.

В JavaScript е позволено добавянето на променлива от всякакъв вид и в произволен ред към масив. Можете също да добавите нещо към вътрешния масив по общите правила. За достъп до елементите, можете да използвате последователност от [] скоби, но винаги е за предпочитане да извършите преназначаване, ограничено само до една двойка [] във всеки израз.

Многоизмерни JavaScript масиви - това е добре предоставен от синтаксиса и е напълно приложим на практика. Но, както и на други езици, най-добре е, когато размерите са по-малки и четливостта на кода е по-висока. Програмите, разбира се, са написани за компютри, преводачи и компилатори, но хората ги пишат, хората също ги придружават, и колкото по-голяма е достъпността на кода за автора и трета страна, толкова по-практичен е той.

Добавете и премахнете елементи

Синтаксисът на JavaScript ви позволява да добавяте елементи към масив, като просто създавате нов индекс:

• aData [3] = "някаква стойност";
• aData [100] = "последен елемент".

След тези JavaScript отчети масивът aData ще има 101 елемента. Номерирането започва от индекс 0. За метода на дължината няма значение колко елемента има в масива по време на изпълнение на “aData [100] = ...;”.

За да премахнете елемент на масив в JavaScript, можете да използвате неговите методи pop () или shift (). В първия случай резултатът от var last = aInfo.pop () ще бъде „диня“, а в масива ще останат: „apple“, „pear“, „mandarin“. Във втория случай var first = aInfo.shift () ще бъде 'apple', а останалите елементи ще се преместят в началото.

Тази опция е много ефективна, когато масивът от обекти на JavaScript е обект на промяна на семантиката и съдържанието. Механизмът за вземане на проби от елемент с неговото отстраняване ви позволява да използвате текущия елемент на масива и да отидете направо към следващия. Както и в стека: взети от стека, използван - и има достъп до следващия елемент.

Когато използвате JavaScript оператора, можете да изтриете елемента на масива както следва:

• изтриване на aInfo [1].

След като изпълните този оператор, елементът действително ще остане в масива, но неговата стойност ще бъде 'undefined'. С помощта на метода отрязък, масив на JavaScript може да бъде "разделен"

• aData = aInfo.slice (0, 2).

Оригиналният масив на aInfo ще остане непроменен, а само данни за ябълки и круши ще попаднат в данните. Ако пишете:

• aData = aInfo.slice (2);

тогава само мандаринът и динята остават в масива aData.

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

JavaScript операции: сортиране на масив, конвертиране на масив в низ, формиране на масив от низ и промяна на реда на елементите са най-търсени. Тези операции се извършват с помощта на методите:

• сортиране (елементи на сортиране),
• присъединяване (преобразуване на масив в низ),
• разделяне (преобразуване на низ в масив),
• обратно (промяна на реда на елементите).

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

Използването на двойката съединяване / разделяне е особено оригинално: обединението на елементите на масива в низ възниква върху един разделител (често празен, т.е. елементите се сливат в един низ), а обратното преобразуване в масив се извършва на друг разделител.

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

Функцията reverse () се прилага директно към масива и обръща реда на елементите в нея. Функцията sort () сортира елементите в изходния масив, връща сортираните по азбучен ред резултати.

Ако предадете функция като параметър за сортиране (функция (a, b) {...; return result;}), можете да контролирате реда на сортиране, като използвате собствен алгоритъм. Такава функция трябва да върне '0', ако 'а' и 'b' са еквивалентни, '-1' - ако 'a' трябва да предхожда 'b' и '1' - ако 'b' предхожда 'a'.

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

Интелигентни масиви и собствени индекси

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

В този пример се използва масивът cSortCols, чиито елементи заемат три стойности:

• '' - без сортиране;
• 'u' - сортиране по възходящ (нагоре);
• 'd' - сортиране в низходящ ред (надолу).

В зависимост от това какво точно е сортирано (в този пример сайтът е предназначен за пътнически трафик на автобуси): пътници, превозвачи, автобуси или градове. Следователно в таблиците с елементи е позволено да се сортират само по конкретни колони. Следователно, на всяка конкретна страница, масивът cSortCols има специфично съдържание: cUsersSort, cCompaniesSort, cBusesSort или cCitiesSort.

Създаването на асоциативен масив в JavaScript може да отиде много по-далеч. Даденият пример за сортиране е конкретно решение на една много специфична задача: излизането от ситуацията, когато собствената JavaScript функция (сортиране) не е приложима.

Структурите на данните са много добри и използването на набори от променливи е много непрактично. Но никой не забранява използването на имена на променливи като индекси. Масивът, в който индексите са представени от имена на променливи, е чудесна мобилна структура от данни. Той не е задължително да съдържа всички индекси, но във всяко място на програмата те ще бъдат в правилния състав.

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

Практикувайте работа с масиви

За разлика от сървърните езици, в които винаги е ясно какво да се обработва и какъв трябва да бъде резултатът, JavaScript изисква специфично мулти-ниво мислене. Страницата на сайта може да създаде скрити събития и обаждания по неочакван начин. Дори когато техническата задача за обекта е направена по идеален начин, а диалогът с посетителя не може да излезе извън установените граници, се случват изненади.

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

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

Вие не можете да посрещнете обектно-ориентирано програмиране и да не се стремите да гарантирате, че всички страници на сайта са снабдени с пълнофункционални системи от обекти, които сами влизат във взаимоотношения и няма нито един ред код извън методите на такива обекти, но дори и в случай на изключително класически стил на развитие JavaScript масивите, особено асоциативните и въоръжените набори от реализации на функцията forEach, са отличен инструмент за надежден и практичен код.