Как очистить массив в javascript?

Методы для добавления и удаления элементов массива

Итак, допустим у вас есть массив, в который вам необходимо добавить новый элемент. Для этого в JavaScript есть несколько методов.

push()

Этот метод добавляет новые элементы в конец массива. Принимает как аргумент элементы, которые нужно добавить, а возвращает длину нового массива:

  let arr = ;
  arr.push("Banana"); // добавление одного элемента
  arr.push("Cherry", "Lemon"); // добавление сразу нескольких элементов

  console.log(arr); // 

  let arrLength = arr.push("Lime"); // В переменной arrLength будет сохранена длина нашего массива - 6 элементов

  console.log('Length', arrLength); // Length 6

pop()

С помощью данного метода можно удалить последний элемент массива, а возвращает он значение этого элемента

Допустим вы хотите удалить элемент Lime, который мы добавили в массив раннее.

  let arr = ;
  let removedEl = arr.pop(); // Удаляем элемент массива и получаем его значение, если это нужно для дальнейшей работы.
  console.log('Удаленный элемент - ', removedEl); // Lime
  
  arr.pop() // А так мы просто удалим последний элемент

shift()

С помощью данного метода мы можем извлечь элемент из начала массива.

Также есть «зеркальный» метод для добавления элемента в начало массива — . Только тут при добавлении нового элемента возвращается длинна нового массива (см. строку 9):

  let arr = ;
  let firstEl = arr.shift();

  console.log('Первый элемент - ', firstEl);
  console.log('Массив', arr); // 

  let lengthArr = arr.unshift('Apple 2');
  console.log('Новый массив', arr); // 
  console.log('Длинна нового массива', lengthArr); // 6

splice()

Этот метод более сложный… он как кухонный комбайн может делать всё — удалять, добавлять, заменять… Наиболее часто он используется если вам нужно произвести операции внутри массива, а не только с первыми или последними элементами.

Итак, он принимает в качестве аргумента:

— индекс элемента, с которого нужно начать изменения

— количество элементов для удаления. Если вы не хотите удалять, тогда нужно передать 0 в этот аргумент.

— добавляемый элемент массива. Если третьим параметром ничего не передать, тогда будет произведено просто удаление

Теперь давайте рассмотрим на примере как удалить несколько элементов из массива:

  let arr = ;
  arr.splice(0, 3); // удалит с 0 (включительно) по 3 элемент (не включая его)

  console.log(arr); // 

Чтобы удалить например элементы Bannana, Cherry нам нужно начать с индекса 2 и передать 2 (количество удаляемых элементов):

  let arr = ;
  arr.splice(2, 2); // удалим элементы "Banana" и "Cherry"

  console.log(arr); // 

Теперь давайте добавим эти же элементы в середину массива:

  let arr = ;
  arr.splice(2, 0, "Banana", "Cherry");

  console.log(arr); // 

slice()

Этот метод возвращает новый массив, «вырезанный» по заданным в аргументах индексам. При этом оригинальный массив остается неизменным.

— необязательный — индекс элемента, от которого следует начинать отсчет. Если задать отрицательное число, отсчет пойдет с конца массива.

— необязательный — индекс последнего элемента «вырезаемого» из массива. Если этот аргумент не передан, будет вырезан отрезок от start до конца массива.

  let arr = ;

  let newArr = arr.slice(1, 3); // 

  let newArr2 = arr.slice(3); // 

concat()

Возвращает новый массив, к которому добавлены новые элементы, переданные как аргументы в данный метод.

  let arr1 = ;
  let arr2 = ;

  let arr3 = arr1.concat(arr2); 

  console.log(arr3); // 

Мы взяли массив arr2 и с помощью метода соединили его с arr1. В итоге мы получили новый массив из 6 элементов.

Вы можете передать столько аргументов, сколько необходимо. Например,

Практика: Топ 5 поисковых запросов

Хорошим тоном, является использование методов массива, таких как и — это когда вы ведёте запись активных элементов в веб-приложении. Например, в анимированной сцене может быть массив объектов, представляющих текущую отображаемую фоновую графику и вам может потребоваться только 50 одновременных отображений по причинам производительности или беспорядка. Когда новые объекты создаются и добавляются в массив, более старые могут быть удалены из массива для поддержания нужного числа.

В этом примере мы собираемся показать гораздо более простое использование — ниже мы даём вам поддельный поисковый сайт с полем поиска. Идея заключается в том, что когда в поле поиска вводятся запросы, в списке отображаются 5 предыдущих поисковых запросов. Когда число терминов превышает 5, последний член начинает удаляться каждый раз, когда новый член добавляется в начало, поэтому всегда отображаются 5 предыдущих терминов.

Примечание: В реальном приложении для поиска вы, вероятно, сможете щёлкнуть предыдущие условия поиска, чтобы вернуться к предыдущим поисковым запросам и отобразите фактические результаты поиска! На данный момент мы просто сохраняем его.

Чтобы завершить приложение, вам необходимо:

1. Добавьте строку под комментарием , которая добавляет текущее значение, введённое в ввод поиска, к началу массива. Его можно получить с помощью .
2. Добавьте строку под комментарием , которая удаляет значение, находящееся в конце массива.

Работа с массивами JS — удаление из массива

Как мы знаем, массивы — это объекты, поэтому мы могли бы использовать delete, чтобы удалить значение:

var arr = 
delete arr
// теперь arr = 
alert(arr) // не задано

Вы видите, что значение удаляется, но не так, как мы хотели бы, потому что массив содержит незаданный элемент.

Оператор delete удаляет пару ключ-значение, и это все. Естественно, так как массив — это только хэш, позиция удаленного элемента становится undefined.

Чаще всего нам нужно удалить элемент, не оставляя «дыр» между индексами. Существует еще один метод, который поможет нам в этом.

Метод splice

Метод splice может удалять элементы и заменять их в JavaScript многомерных массивах. Его синтаксис:

arr.splice(index, deleteCount)

Удаляет элемент deleteCount, начиная с index, а затем вставляет на его место elem1, …, elemN.

Давайте рассмотрим несколько примеров:

var arr = 
arr.splice(1, 1)  // удалить 1 элемент, начиная с индекса 1
alert( arr.join(',') ) //  (1 элемент удален)

Таким образом, вы можете использовать splice, чтобы удалить один элемент из массива. Номера элементов массива сдвигаются, чтобы заполнить пробел:

var arr = 
arr.splice(0, 1)  // удаляем 1 элемент, начиная с индекса 0
alert( arr ) // "to" стал первым элементом

В следующем примере показано, как заменять элементы:

var arr = ;
// remove 3 first elements and add two
arr.splice(0, 3, "Come", "here") 
alert( arr ) // 

Метод splice возвращает массив удаленных элементов:

var arr = ;
// удаляем 2 первых элемента 
var removed = arr.splice(0, 2) 
alert( removed ) // "Go", "to" <-- массив удаленных элементов
splice может вставлять элементы, задайте 0 для deleteCount.
var arr = ;
// со второй позиции 
// удаляем 0 
// и вставляем "my", "sweet"
arr.splice(2, 0, "my", "sweet") 
alert( arr) // "Go", "to", "my", "sweet", "home"

Данный метод также может использовать отрицательный индекс, который отсчитывается с конца массива:

var arr = 
// для элемента -1 (предпоследнего)
// удаляем 0 элементов, 
// и вставляем 3 и 4
arr.splice(-1, 0, 3, 4)
alert(arr)  // 1,2,3,4,5

Задание для самостоятельного выполнения

Объект содержит свойство className, в котором содержатся имена классов, разделенные пробелами:

var obj = {
	className: 'open menu'
}

Напишите функцию removeClass(obj, cls), которая удаляет класс cls, если он задан:

removeClass(obj, 'open') // obj.className='menu'

removeClass(obj, 'blabla')  // без изменений (класса для удаления не существует)

Решение

Нужно разделить className на части и перебрать эти части через цикл. Если найдено совпадение, оно удаляется из JavaScript массива объектов, а затем добавляется обратно в конец.

Немного оптимизируем это:

function removeClass(elem, cls) {
  for(var c = elem.className.split(' '), i=c.length-1; i>=0; i--) {
    if (c == cls) c.splice(i,1)
  }
	
  elem.className = c.join(' ')
}
var obj = { className: 'open menu' }
removeClass(obj, 'open')
removeClass(obj, 'blabla')
alert(obj.className)   // menu

В приведенном выше примере переменная c задана в начале цикла, и для i задан ее последний индекс.

Сам цикл выполняется в обратном направлении, заканчиваясь условием i>=0. Это сделано потому, что i>=0 проверяется быстрее, чем i. Что ускоряет поиск свойства в c.

Перебор элементов

Одним из самых старых способов перебора элементов массива является цикл for по цифровым индексам:

Но для массивов возможен и другой вариант цикла, :

Цикл не предоставляет доступа к номеру текущего элемента, только к его значению, но в большинстве случаев этого достаточно. А также это короче.

Технически, так как массив является объектом, можно использовать и вариант :

Но на самом деле это – плохая идея. Существуют скрытые недостатки этого способа:

1. Цикл выполняет перебор всех свойств объекта, а не только цифровых.

   В браузере и других программных средах также существуют так называемые «псевдомассивы» – объекты, которые выглядят, как массив. То есть, у них есть свойство и индексы, но они также могут иметь дополнительные нечисловые свойства и методы, которые нам обычно не нужны. Тем не менее, цикл выведет и их. Поэтому, если нам приходится иметь дело с объектами, похожими на массив, такие «лишние» свойства могут стать проблемой.

2. Цикл оптимизирован под произвольные объекты, не массивы, и поэтому в 10-100 раз медленнее. Увеличение скорости выполнения может иметь значение только при возникновении узких мест. Но мы всё же должны представлять разницу.

В общем, не следует использовать цикл для массивов.

JavaScript объекты

Javascript — объектно-ориентированный язык. Это значит, что с некоторыми типами данных можно работать как с объектами, что позволяет применять к ним дополнительные функции для работы с объектами. К примеру, со строками можно работать и как с обычным типом данных и как с объектами:

// обычная строковая переменная myStr:
let myStr = "Текст";
 
// создание строкового объекта myStr:
let myStr = new String();

• Object(объекты)
• Number (обработка чисел)
• String (обработка строк)
• Array (массивы)
• Math (математические формулы, функции и константы)
• Date (работа с датами и временем)
• RegExp
• Global (его свойства Infinity, NaN, undefined)
• Function

Со всеми данными объектами мы познакомимся позже, с некоторыми из них мы частично уже знакомы.

Object — объект, который содержится во всех остальных объектах и обеспечивает их общую функциональность.

Объект function — функции являются объектами первого класса, т.е. могут присваиваться переменным, выступать аргументами других функций и быть результатом функций

Объявление новых объектов происходит одинаково, независимо от объекта (используется служебное слово new):

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

Как очистить массив в JavaScript?

Есть ли способ очистить массив и, если возможно, с .remove() ?

Как я могу удалить это?

21 ответ

Способы очистки существующего массива A :

Метод 1

(это был мой первоначальный ответ на вопрос)

Этот код установит переменную A в новый пустой массив. Это идеально, если у вас нет ссылок на исходный массив A где-либо еще, потому что это фактически создает совершенно новый (пустой) массив. Вы должны быть осторожны с этим методом, потому что, если вы ссылаетесь на этот массив из другой переменной или свойства, исходный массив останется неизменным. Используйте это только в том случае, если вы ссылаетесь только на массив по его исходной переменной A .

Это также самое быстрое решение.

В этом примере кода показана проблема, с которой вы можете столкнуться при использовании этого метода:

Это очистит существующий массив, установив его длину равным 0. Некоторые утверждают, что это может не работать во всех реализациях JavaScript, но оказывается, что это не так. Он также работает при использовании «строгого режима» в ECMAScript 5, потому что свойство length массива является свойством чтения/записи.

Метод 3 (как предложил Anthony)

Использование .splice() будет работать отлично, но поскольку функция .splice() вернет массив со всеми удаленными элементами, он фактически вернет копию исходного массива. Тесты показывают, что это не влияет на производительность вообще.

Метод 4 (как предложил tanguy_k)

Это решение не очень кратким, и оно также является самым медленным решением, в отличие от предыдущих эталонных тестов, упомянутых в исходном ответе.

Производительность

Из всех методов очистки существующего массива методы 2 и 3 очень похожи по производительности и намного быстрее, чем метод 4. См. этот тест.

Как указано Diadistis в их ответе ниже, исходные критерии, которые были использованы для определить эффективность четырех описанных выше методов были ошибочными. Исходный тест повторно использовал очищенный массив, поэтому вторая итерация очищала массив, который был уже пуст.

Следующий критерий устраняет этот недостаток: http://jsben.ch/#/hyj65. Он ясно показывает, что методы # 2 (свойство длины) и # 3 (сращивание) являются самыми быстрыми (не считая метод # 1, который не меняет исходный массив).

Это была горячая тема и причина многих споров. На самом деле есть много правильных ответов, и поскольку этот ответ был отмечен как принятый ответ в течение очень долгого времени, я буду включать все методы здесь. Если вы проголосуете за этот ответ, пожалуйста, подтвердите другие ответы, на которые я ссылался.

Описание

Если оператор успешно выполняет удаление, он полностью удаляет свойство из объекта. Однако, если свойство с таким же именем существует в цепочке прототипов, объект унаследует это свойство из прототипа.

эффективен только применительно к свойствам объектов. Он не оказывает никакого влияния на имена переменных и функций.
Присвоение значения свойству без указания объекта (без оператора var) иногда неверно характеризуется, как глобальная переменная, (например ). На самом деле происходит присвоение значения свойству глобального объекта.

не может удалить определённые свойства встроенных объектов (таких как Object, Array, Math и так далее). В спецификации ECMA-262 они обозначены как DontDelete.

Если объект наследует свойство от прототипа и не имеет собственного свойства с таким же именем, свойство не может быть удалено при обращении через этот объект. Однако можно удалить это свойство напрямую в прототипе.

Когда с помощью оператора delete удаляется элемент массива, длина массива не меняется. Например, если вы удалите a, a по прежнему a, а a не определено. Так будет даже если вы удалите последний элемент массива ().

Когда оператор удаляет элемент массива, этот элемент больше не существует в массиве. В следующем примере, trees удаляется с помощью .

Если вы хотите, чтобы элемент массива существовал, но имел значение undefined, используйте значение вместо оператора . В следующем примере, trees принимает значение undefined, но элемент массива все ещё существует:

Javascript: работа с массивами

Обращение или доступ к элементам массива в javaScript происходит так:

1
2
3
4

let mas=new Array(1,25,'Привет');
 
mas='Пока';
mas1=35;

При инициализации массива элемент mas был равен 1. Затем мы изменили его значение на ‘Пока’. Значение элемента массива mas было изменено с 25 на 35.

Вывод элементов массива

При выводе значений массива в документ с помощью метода , его элементы выводятся через запятую:

1
2

let mas=new Array(1,25,'Привет');
document.write(mas)

Результат:

1,25,Привет

1. Рассмотрим, как осуществляется в javascript вывод массива с использованием обычного цикла :

1
2
3
4
5
6
7

let mas=new Array(1,25,'Привет');
 
function showElement(){
	for(i=;i<3;i++)
	  document.writeln(masi);
}
showElement();

Результат:

1 25 Привет

Использование цикла для перебора элементов массива ( — цикл для работы с объектами):

1
2
3
4
5
6
7
8

let mas=new Array(1,25,'Привет');
 
function showElement(){
	for(let i in mas){
		document.writeln(masi);
	}
}
showElement();

Результат:

1 25 Привет

Использование цикла для перебора элементов массива (результат такой же):

1
2
3
4
5
6
7
8

let mas=new Array(1,25,'Привет');
 
function showElement(){
	for(let i of mas){
		document.writeln(i);
	}
}
showElement();

Нужно иметь в виду, что цикл выполняет перебор всех свойств объекта, а не только индексированных.
В браузере имеются так называемые «псевдомассивы» – объекты, которые выглядят, как массив. То есть, у них есть свойство length и индексы, но они также могут иметь дополнительные свойства и методы. Однако цикл выведет и их.
Цикл во много раз медленнее, чем .

Задание array 5_1. Создать два массива: – с названием стран, и – с населением этих стран. Вывести название страны и ее население (использовать метод ).

Комментарии к выполнению:

• Вывод элементов массива оформить в виде функции.
• Сначала выполнить задание с помощью цикла , затем — с помощью цикла .

Задание array 5_2. Что выведет на экран следующий фрагмент кода?

 let e = 1024;
 let table = e, e + 1, e + 2, e + 3;
 document.write(table);

Пример: Что выведет на экран следующий фрагмент кода?

1
2
3
4
5

let arr = 1, 2, 3;
 arr5 = 5;
  for (let i = ; i < arr.length; i++) {
 document.write(arri + "<br />");
 }

В примере в строке происходит расширение массива – в 5-й индекс заносится значение . Цикл заполняет элементы типом , элементы которые мы не использовали — они остаются пустыми.
Удаление элементов массива

В javascript удалить элемент массива можно при помощи оператора :

1
2
3

let myColors = new Array("red", "green", "blue");
delete myColors1;
alert(myColors); // red,,blue

Задание array 5_3. Создать массив из трех элементов, значения элементов запрашивать у пользователя. Удалить второй по счету элемент, после чего вывести элементы массива на экран, каждый элемент с новой строки

Cómo vaciar o borrar un array en Javascript y sus implicaciones

Para realizar el vaciado o borrado de un array podemos hacer uso de dos implementaciones o soluciones, las cuales vamos a ver a continuación. Supongamos que tenemos un array en una variable miArray con el siguiente contenido:

JavaScript

var miArray = ;

Podemos realizar el vaciado del array mediante la asignación de un array vacío a la variable en cuestión:

JavaScript

miArray = [];

Por lo que la variable miArray ahora estará apuntando a un array vacío. Es decir, no se trata del array anterior vacío, sino que la variable está apuntando a una nueva posición de memoria. Para entenderlo, supongamos las variables siguientes:

JavaScript

var miArray = ;

var miOtroArray = miArray;

Si ahora, realizamos el borrado del primer array tal como hemos visto anteriormente:

JavaScript

miArray = [];

//Los valores de las variables anteriores son:
//miArray = [];
//miOtroArray = ;

la variable miOtroArray seguirá apuntando a la posición de memoria donde se aloja el array que tenía anteriormente asignado la variable miArray, ya que con esta solución, lo único que hacemos es asignar a dicha variable un nuevo array vacío en otra posición de memoria.

Para evitar esto, otro método de vaciado o borrado de un array en Javascript es mediante la propiedad length, así, podemos vaciar nuestro primer array de la siguiente forma:

JavaScript

miArray.length = 0; //No reasignamos a un nuevo valor, sino que reducimos la longitud del actual.

//Los valores de las variables anteriores son:
//miArray = [];
//miOtroArray = [];

De esta forma, estamos haciendo que la longitud de nuestro array actual sea cero, por lo que lo estamos vaciando, y la variable sigue apuntando al mismo array, por lo que las otras posibles variables y/o punteros, que apuntaban a la misma, tendrán el mismo valor que esta. Así nos evitamos cualquier problema con variables y punteros que pueda ocasionar una reasignación a un nuevo array como en el primer caso.

Además, esta última solución, es una solución mejor en cuanto a rendimiento ya que realmente libera la memoria asignada a dicho array. Si usamos la primera solución, además de asignar memoria para el nuevo array vacío, no liberamos la memoria asignada al array anterior, en caso de que alguna otra variable o puntero esté apuntando a la misma.

Déjanos un comentario o entra al  Foro

reduce/reduceRight

Метод «arr.reduce(callback)» используется для последовательной обработки каждого элемента массива с сохранением промежуточного результата.

Это один из самых сложных методов для работы с массивами. Но его стоит освоить, потому что временами с его помощью можно в несколько строк решить задачу, которая иначе потребовала бы в разы больше места и времени.

Метод используется для вычисления на основе массива какого-либо единого значения, иначе говорят «для свёртки массива». Чуть далее мы разберём пример для вычисления суммы.

Он применяет функцию по очереди к каждому элементу массива слева направо, сохраняя при этом промежуточный результат.

Аргументы функции :

• – последний результат вызова функции, он же «промежуточный результат».
• – текущий элемент массива, элементы перебираются по очереди слева-направо.
• – номер текущего элемента.
• – обрабатываемый массив.

Кроме , методу можно передать «начальное значение» – аргумент . Если он есть, то на первом вызове значение будет равно , а если у нет второго аргумента, то оно равно первому элементу массива, а перебор начинается со второго.

Проще всего понять работу метода на примере.

Например, в качестве «свёртки» мы хотим получить сумму всех элементов массива.

Вот решение в одну строку:

Разберём, что в нём происходит.

При первом запуске – исходное значение, с которого начинаются вычисления, равно нулю (второй аргумент ).

Сначала анонимная функция вызывается с этим начальным значением и первым элементом массива, результат запоминается и передаётся в следующий вызов, уже со вторым аргументом массива, затем новое значение участвует в вычислениях с третьим аргументом и так далее.

Поток вычислений получается такой

В виде таблицы где каждая строка – вызов функции на очередном элементе массива:

Как видно, результат предыдущего вызова передаётся в первый аргумент следующего.

Кстати, полный набор аргументов функции для включает в себя , то есть номер текущего вызова и весь массив , но здесь в них нет нужды.

Посмотрим, что будет, если не указать в вызове :

Результат – точно такой же! Это потому, что при отсутствии в качестве первого значения берётся первый элемент массива, а перебор стартует со второго.

Таблица вычислений будет такая же, за вычетом первой строки.

Метод arr.reduceRight работает аналогично, но идёт по массиву справа-налево.

JavaScript массивы, тип данных Array

Теперь подробнее рассмотрим объект массив.

Массив — упорядоченный набор данных.

Доступ к элементам массива осуществляется с помощью порядкового номера — индекса

Таким образом, массив — объект, представляющий собой проиндексированный набор элементов.
Обратите внимание на то, что в массиве могут храниться элементы любого типа.. Пример: Создать массив arr

Присвоить значение трем элементам созданного массива. С помощью диалогового окна вывести значение элемента массива с индексом 2. Вывести количество элементов массива.

Пример: Создать массив arr. Присвоить значение трем элементам созданного массива. С помощью диалогового окна вывести значение элемента массива с индексом 2. Вывести количество элементов массива.

Решение: 

1
2
3
4
5
6

let arr = new Array();
arr = "element1";
arr1 = "element2";
arr2 = "element3";
alert(arr2);
alert("Число элементов" + arr.length);

В javascript длина массива — свойство .

Итого

Массив – это особый тип объекта, предназначенный для работы с упорядоченным набором элементов.

• Объявление:

  Вызов создаёт массив с заданной длиной, но без элементов.

• Свойство отражает длину массива или, если точнее, его последний цифровой индекс плюс один. Длина корректируется автоматически методами массива.

  

  

  

  

  

  

  

• Если мы уменьшаем вручную, массив укорачивается.

Мы можем использовать массив как двустороннюю очередь, используя следующие операции:

• добавляет в конец массива.
• удаляет элемент в конце массива и возвращает его.
• удаляет элемент в начале массива и возвращает его.
• добавляет в начало массива.

Чтобы пройтись по элементам массива:

• – работает быстрее всего, совместим со старыми браузерами.
• – современный синтаксис только для значений элементов (к индексам нет доступа).
• – никогда не используйте для массивов!

Мы вернёмся к массивам и изучим другие методы добавления, удаления, выделения элементов и сортировки массивов в главе: Методы массивов.

Урок 21. Заполнение массива и вывод на экран

Урок из серии: «Язык программирования Паскаль»

Скачать исходные коды примеров После объявления массива с ним можно работать. Например, присваивать значения элементам массива и вообще обращаться с ними как с обычными переменными. Для обращения к конкретному элементу необходимо указать идентификатор (имя) массива и индекс элемента в квадратных скобках.

Например, запись Mas, A позволяет обратиться ко второму элементу массива MAS и десятому элементу массива A. При работе с двумерным массивом указывается два индекса, с n-мерным массивом — n индексов.

Например, запись Matr делает доступным для обработки значение элемента, находящегося в четвертой строке четвертого столбца массива M.

Индексированные элементы массива называются индексированными переменными. За границы массива выходить нельзя. То есть, если в массиве Mas пять элементов, то обращение к шестому или восьмому элементу приведет к ошибке.

Рассмотрим типичные операции, возникающие при работе с одномерными массивами.

Заполнение одномерного массива значениями

Заполнение и вывод массива можно осуществить только поэлементно, то есть можно сначала присвоить значение первому элементу, затем второму и так далее, то же самое и с выводом на экран — выводим первый, второй, третий и так до последнего.

Паскаль не имеет средств ввода-вывода элементов массива сразу, поэтому ввод и значений производится поэлементно. Значения элементу массива можно присвоить с помощью оператора присваивания, или ввести с клавиатуры с помощью операторов Read или Readln. Очень удобно перебирать все элементы массива в цикле типа for.

Способы заполнения одномерных массивов:

1. Ввод значений элементов массива с клавиатуры. В связи с тем, что использовался оператор Readln, каждое значение будет вводиться с новой строки.

2. Заполнение массива числами, сгенерированными случайным образом из интервала . Подключаем датчик случайных чисел — функцию random.

3. Заполнение массива по формуле. Каждому элементу массива присваивается значение, вычисленное по формуле. Если каждый элемент массива равен утроенному значению его порядкового номера (индекса), то процедура будет иметь вид:

4. Чтение чисел из файла. Нужно заранее создать текстовый файл, в который запишите несколько строк, в каждой из которых по 30 чисел.

Вывод значений элементов массива на экран

Вывод значений элементов массива на экран выполняется, как и ввод, поэлементно в цикле. Для вывода будем использовать операторы Write или Writeln. В качестве входных параметров будем передавать процедуре не только массив, но и количество элементов, которые надо вывести, начиная с первого (это понадобится нам, когда мы будем удалять и добавлять элементы в массиве).

Пример 1. Заполнить массив с клавиатуры и вывести его на экран.

В программе будет использоваться две процедуры: процедура Init1 (заполнение массива с клавиатуры) и процедура Print (вывод массива на экран).

Пример 2. Заполнить массив из текстового файла и вывести на экран. В текстовом файте несколько строк, в каждой строке по 30 чисел.

Вы научились заполнять одномерный массив и выводить его на экран.

На следующем уроке продолжим знакомиться с алгоритмами обработки одномерных массивов.

Источник