Как найти значение переменной в массиве

Вам нужна быстрая проверка вхождения строки в набор? Тогда замените тип вашего эталона:

string[] эталон = new string[10] {"Example", "Еще", "Какие-то", "Строки"...}
//меняем на
HashSet<string> эталон = new HashSet<string>(){"Example", "Еще", "Какие-то", "Строки"...};

Теперь эталон.Contains("проверяемая строка") будет работать практически мгновенно и с постоянной скоростью, независимо от того есть ли искомое значение в наборе или нет (да исключения есть, но только для очень больших наборов при наличии коллизий в хэш-таблице).

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

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

---

Документация HashSet<T>

Вопросы:

·     Поиск
элемента массива с заданным значением.

·     Сортировка
элементов массива.

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

Задача: Написать
программу, которая определяет, есть ли в массиве из 100 случайных целых чисел,
на промежутке от 1 до 200, число, введённое пользователем.

Начнём написание
программы для решения задачи. Назовём нашу программу zadannoe_chislo.
Для работы программы нам потребуется массив из 100 элементов. Назовём его a.
Так как элементами массива будут целые числа на промежутке от 1 до 200, укажем
тип элементов массива byte.
Также нам понадобятся переменные для хранения номера текущего элемента – i
и для хранения числа, введённого пользователем – num.
Объявим принадлежащими к целочисленному типу byte.

Напишем логические
скобки. Тело программы будет начинаться с оператора writeln,
который будет выводить на экран сообщение о том, что это программа,
определяющая, есть ли в массиве случайных чисел число, введённое пользователем.
Теперь запишем цикл для заполнения массива случайными числами. Это будет цикл для
i, изменяющегося от 1 до 100. В нём
будет оператор присваивания i-тому
элементу массива a, суммы случайного
целого числа на промежутке от 0 до 199 и 1. После того как мы заполнили массив
случайными числами, напишем оператор write,
выводящий на экран запрос на ввод числа на промежутке от 1 до 200, а также
оператор readln для считывания
значения переменной num.

Для того чтобы
определить, есть ли введённое число в массиве a,
мы позже опишем логическую функцию, которую назовём poisk,
поэтому сейчас напишем условный оператор if,
условием которого будет значение функции poisk,
с введённым числом num
в качестве аргумента. После служебного слова then
в этом условном операторе, напишем оператор writeln,
выводящий на экран сообщение о том, что число num
есть в массиве. После слова else
также напишем оператор writeln,
который будет выводить на экран сообщение о том, что числа num нет в
массиве.

Для того чтобы
пользователь могу убедиться в том, что программа работает правильно, напишем
оператор write, выводящий
сообщение о том, что это массив, а также цикл с для i
для вывода элементов массива через пробел. На этом описание основной программы
завершено.

program zadannoe_chislo;

var

 a: array [1..100] of
byte;

 i, num: byte;

begin

 writeln (‘Программа, определяющая, есть ли в массиве случайных чисел число,
введённое пользователем.’);

 for i:=1 to 100
do

  a[i]:=random (200)+1;

 write (‘Введите число на промежутке [1;
200]>>> ‘);

 readln (num);

 if poisk (num)

 then write (‘Число ‘, num, ‘ есть в
массиве.’)

 else write (‘Числа ‘, num, ‘ нет в массиве.’);

end.

Заголовок,
переменные и операторный блок основной программы

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

Напишем для нашей
программы логическую функцию, определяющую, есть ли в массиве a
заданное число. Как мы помним, она должна называться poisk.
Эта функция должна иметь один аргумент целочисленного типа byte,
назовём его t. Также функция
должна возвращать значение логического типа boolean.
Для работы функции нам потребуется дополнительная переменная, которая будет
хранить номер текущего элемента массива. Назовём её i
и укажем принадлежащей к целочисленному типу byte.
В логических скобках опишем операторный блок функции. В его начале присвоим
переменной i начальное значение – 0.
Дальше напишем цикл с постусловием. Условием окончания работы цикла будет то,
что i-тый Элемент массива a
равен t или что достигнут конец
массива и i равно 100. Тело цикла
будет содержать единственный оператор, увеличивающий значение переменной i
на 1. После завершения работы цикла нам будет достаточно проверить равен ли i-тый
элемент массива a t
и присвоить значение истинности этого высказывания переменной функции poisk.
На этом описание функции закончено.

function poisk (t: byte): boolean;

var

 i: byte;

begin

 i:=0;

 repeat

  i:=i+1;

 until (a[i]=t) or (i = 100);

 poisk:=a[i]=t;

end;

Функция poisk

Запустим программу на
выполнение. Введём число 75.
Программа вывела сообщение о том, что такое число есть в массиве. Просмотрев
элементы массива, мы можем убедиться, что такое число действительно в нём есть.

Снова запустим программу
и введём число 120. Программа вывела сообщение о том, что такого числа нет в
массиве. Программа работает правильно. Задача решена.

Рассмотрим функцию poisk.
Очевидно, что в лучшем случае при её выполнении будет выполнена 1 проверка, а в
худшем – 100. Это не очень много, но предположим, что у нас есть программа,
которая будет выполнять поиск тысячи или даже миллионы раз. Тогда для этого
может потребоваться много времени, но поиск в массиве можно организовать проще,
если элементы массива расположены в соответствии с некоторыми правилами,
например, по возрастанию или по убыванию своих значений.

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

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

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

Итак, что же нужно
сделать чтобы отсортировать массив по возрастанию методом пузырька… Вначале предположим,
что элементы массива уже расположены по возрастанию. Дальше будем
последовательно проверять пары элементов массива. Если найдём пару, в которой
элементы расположены не по возрастанию, то мы опровергнем начальное
предположение о том, что элементы уже расположены по возрастанию. Мы поменяем
местами элементы массива в паре, и продолжим проверять его дальше. После того,
как мы проверили все пары элементов массива мы должны проверить, осталось ли
наше начальное предположение о том, что элементы массива расположены по
возрастанию не опровергнутым. Если предположение было опровергнуто – мы начнём
выполнять алгоритм сначала, в противном случае – алгоритм завершит свою работу.
Когда после завершения работы алгоритма начальное положение останется не опровергнуто
алгоритм завершит свою работу.

Для написанной нами
программы для поиска элементов массива напишем процедуру сортировки элементов
массива a но не убыванию. Назовём
её sort. Для работы
процедуры нам нужна переменная для хранения, номера текущего элемента массива –
i и переменная для хранения одного из
элементов массива, когда мы будем менять их местами – k,
а также логическая переменная – p.
Напишем программный блок процедуры. В нём будет цикл с постусловием, в качестве
условия завершения работы которого будет значение логической переменной p.
Тело цикла будет начинаться с того что мы предположим, что элементы массива уже
расположены по возрастанию. Для этого переменной p
мы присвоим значение true.
Дальше будет следовать цикл с параметром i,
изменяющимся от 1 до 99. Это будет цикл для проверки пар элементов массива. В
нём будет условный оператор, который проверяет расположены ли элементы массива
с индексами i и i
+ 1
не по неубыванию. То есть что a[i]
> a[i
+ 1].
Если это условие выполняется, мы должны поменять эти два элемента массива
местами. Для этого после слова then
в логических скобках запишем четыре оператора присваивания: переменной p
– значения false, так как мы
опровергли начальное предположение, переменной k
– значения a[i],
a[i]
– значение a[i
+ 1],
a[i
+ 1]
– значение переменной k.
Таким образом, мы опровергли начальное предположение и поменяли местами
элементы массива с индексами i
и i + 1.
На этом описание процедуры завершено.

procedure sort ();

var

 p: boolean;

 i, k: byte;

begin

 repeat

  p:=true;

  for i:=1 to 99
do

   if a[i]>a[i+1]

   then begin

    p:=false;

    k:=a[i];

    a[i]:=a[i+1];

    a[i+1]:=k;

   end;

 until p;

end;

Процедура сортировки
элементов массива по неубыванию методом пузырька

В программном блоке
основной программы перед запросом на ввод числа запишем вызов процедуры sort.
Запустим программу на выполнение. Зададим число 28.
Программа вывела сообщение о том, что это число есть в массиве. Просмотрев
элементы массива, мы можем убедиться в том, что они действительно отсортированы
по невозрастанию.

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

Теперь рассмотрим, как мы
можем организовать поиск элемента с заданным значением в массиве,
отсортированном по неубыванию. Очевидно, что элементы с наименьшим и наибольшим
значениями располагаются по краям. Для поиска элемента с заданным значением
можно использовать метод деления отрезка пополам (метод двоичной
дихотомии). Если элементы массива расположены по возрастанию, то мы можем проверить
его средний элемент. Так мы можем точно сказать где нужно искать элемент с
искомым значением. Если средний элемент массива будет меньше искомого, то
искомый элемент нужно искать после среднего, а в противном случае от первого до
среднего. Таким образом мы сократим область поиска сразу в два раза. Точно
также мы найдём средний элемент на новом промежутке поиска, сравним его с
искомым и так далее. Так будет продолжаться до тех пор, пока начальный или
конечный элемент промежутка поиска не будет равен искомому или пока промежуток
поиска не станет равен одному элементу.

В написанной нами
программе изменим функцию poisk.
В ней нам понадобится дополнительные переменные для хранения номеров первого и
последнего элемента массива на промежутке поиска, назовём их соответственно f
и l, объявим их
целочисленного типа byte.
Запишем логические скобки. Операторный блок процедуры будет начинаться с того,
что мы присвоим переменным f
и l их начальные значения,
то есть соответственно 1 и 100. Дальше мы запишем цикл с постусловием. Условием
завершения его работы будет, то что один из элементов массива с индексами f
и l равен искомому элементу t
или что промежуток поиска сузился до одного элемента, то есть f
= l.
В теле цикла будет условный оператор, который будет проверять меньше ли средний
элемент массива, с индексом равным (f
+ l) div
2,
искомого t. Если это условие
выполняется, то мы должны сократить промежуток поиска элемента. Поэтому после слова
then присвоим переменной f
значение (f
+ l) div
2 + 1. В противном случае – сократим промежуток поиска в
другом направлении и присвоим переменной l
значение (f
+ l) div
2.
После завершения работы цикла проверим, равен ли один из элементов с индексами f
и l искомому t.
И присвоим значение истинности этого высказывания переменной функции – poisk.

function poisk (t: byte): boolean;

var

 f, l: byte;

begin

 f:=1;

 l:=100;

 repeat

  if a[(f+l) div 2]<t

  then f:=(f+l) div 2
+ 1

  else l:=(f+l)
div 2;

 until (a[f]=t) or (a[l]=t)
or (f=l);

 poisk:=(a[f]=t) or (a[l]=t);

end;

Функция поиска элемента с
заданным значением методом деления отрезка пополам

Запустим программу на
выполнение. Введём число 45. Программа вывела сообщение о том, что такого числа
нет в массиве.

Снова запустим программу
и введём число 190. Программа вывела сообщение о том, что это число есть в
массиве.

Программа работает
правильно задача решена.

Данная тема основывается на теме: Массивы. Одномерные массивы. Инициализация массива

---

Содержание

• 1. Нахождение сумм и произведений элементов массива. Примеры
• 2. Нахождение максимального (минимального) элемента массива. Примеры
• 3. Сортировка массива методом вставки
• 4. Поиск элемента в массиве. Примеры
• Связанные темы

---

Поиск на других ресурсах:

1. Нахождение сумм и произведений элементов массива. Примеры

Пример 1. Задан массив A, содержащий 100 целых чисел. Найти сумму элементов этого массива. Фрагмент кода, решающего эту задачу

// сумма элементов массива A из 100 целых чисел
int A[100];
int suma; // переменная, содержащая сумму
int i;    // дополнительная переменная

// ввод массива A
// ...

// Вычисление суммы
suma = 0; // обнулить сумму
for (i=0; i<100; i++)
    suma += A[i];

Перебор всех элементов массива выполняется в цикле for.

Переменная sum сохраняет результирующее значение суммы элементов массива. Переменная i есть счетчиком, определяющим индекс элемента массива A[i].

---

---

Пример 2. Задан массив B, содержащий 20 вещественных чисел. Найти сумму элементов массива, которые лежат на парных позициях. Считать, что позиции 0, 2, 4 и т.д. есть парными.

// сумма элементов массива B
// лежащих на парных позициях
float B[20];
float sum; // переменная, содержащая сумму
int i; // дополнительная переменная

// ввод массива
// ...

// Вычисление суммы
sum = 0; // обнулить сумму
for (i=0; i<20; i++)
    if ((i%2)==0)
        sum += B[i];

В этом примере выражение

(i%2)==0

определяет парную позицию (парный индекс) массива B. Если нужно взять нечетные позиции, то нужно написать

(i%2)==1

Пример 3. Задан массив, который содержит 50 целых чисел. Найти сумму положительных элементов массива.

// сумма положительных элементов массива
int A[50];
int sum; // переменная, содержащая сумму
int i; // дополнительная переменная

// ввод массива
// ...

// Вычисление суммы
sum = 0; // обнулить сумму
for (i=0; i<50; i++)
    if (A[i]>0)
        sum = sum + A[i];

Пример 4. Задан массив из 50 целых чисел. Найти произведение элементов массива, которые есть нечетными числами.

// произведение нечетных элементов массива
int A[50];
int d; // переменная, содержащая произведение
int i; // вспомогательная переменная

// ввод массива
// ...

// Вычисление произведения
d = 1; // начальная установка переменной d
for (i=0; i<50; i++)
    if ((A[i]%2)==1)
        d = d * A[i];

Чтобы определить, есть ли элемент массива A[i] нечетным, нужно проверить условие

(A[i]%2)==1

Если условие выполняется, то элемент массива есть нечетное число.

⇑

2. Нахождение максимального (минимального) элемента массива. Примеры

Пример 1. Задан массив из 30 вещественных чисел. Найти элемент (индекс), имеющий максимальное значение в массиве.

// поиск позиции (индекса), содержащего максимальное значение
float B[30];
float max; // переменная, содержащая максимум
int index; // позиция элемента, содержащего максимальное значение
int i; // дополнительная переменная

// ввод массива
// ...

// поиск максимума
// установить максимум как 1-й элемент массива
index = 0;
max = B[0]; 
for (i=1; i<30; i++)
    if (max<B[i]) 
    { 
        max = B[i]; // запомнить максимум
        index = i;  // запомнить позицию максимального элемента
    }

В вышеприведенном примере переменная max содержит максимальное значение. Переменная index содержит позицию элемента, который имеет максимальное значение. В начале переменной max присваивается значение первого элемента массива. Затем, начиная со второго элемента, происходит прохождение всего массива в цикле for. Одновременно проверяется условие

if (max<B[i])

Если условие выполняется (найден другой максимум), тогда новое значение максимума фиксируется в переменных max и index.

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

Пример 2. Задан массив содержащий 50 целых чисел. Найти позицию (позиции) элемента, который имеет минимальное значение. Если таких элементов несколько, сформировать дополнительный массив индексов.

// поиск позиций (индексов), содержащих минимальное значение
int A[50];
int min; // переменная, содержащая минимальное значение
int INDEXES[50]; // позиции элементов, содержащих минимальное значение
int n; // число одинаковых минимальных значений
int i; // дополнительная переменная


// ввод массива
// ...

// 1. Поиск минимального значения
// установить минимальное значение в первом элементе массива
min = A[0];
for (i=1; i<50; i++)
    if (min>A[i])
        min = A[i]; // запомнить минимальное значение

// 2. Формирование массива
n = 0; // обнулить счетчик в массиве INDEXES
for (i=0; i<50; i++)
    if (min == A[i])
        {
            n++; // увеличить число элементов в INDEXES
            INDEXES[n-1] = i; // запомнить позицию
        }

listBox1->Items->Clear();

// 3. Вывод массива INDEXES в listBox1
for (i=0; i<n; i++)     
    listBox1->Items->Add(INDEXES[i].ToString());

В вышеприведенном листинге сначала ищется минимальное значение min.

На втором шаге формируется массив INDEXES, в котором число элементов записывается в переменную n. Происходит поиск минимального значения в массиве A с одновременным формированием массива INDEXES.

На третьем шаге приведен пример, как вывести массив INDEXES в элементе управления listBox1(ListBox).

⇑

3. Сортировка массива методом вставки

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

// сортировка массива методом вставки
int A[10];
int i, j; // дополнительные переменные - счетчики
int t; // дополнительная переменная

// ввод массива A
// ...

// сортировка
for (i=0; i<9; i++)
    for (j=i; j>=0; j--)
        if (A[j]<A[j+1])
        {
            // поменять местами A[j] и A[j+1]
            t = A[j];
            A[j] = A[j+1];
            A[j+1] = t;
        }

⇑

4.  Поиск элемента в массиве. Примеры

Пример 1. Определить, находится ли число k в массиве M состоящем из 50 целых чисел.

// определение наличия заданного числа в массиве чисел
int M[50];
int i;
int k; // искомое значение
bool f_is; // результат поиска, true - число k есть в массиве, иначе false

// ввод массива M
// ...
// ввод числа k
// ...

// поиск числа в массиве
f_is = false;
for (i=0; i<50; i++)
    if (k==M[i])
    {
        f_is = true; // число найдено
        break; // выход из цикла, дальнейший поиск не имеет смысла
    }

// вывод результата
if (f_is)
    label1->Text = "Число " + k.ToString() + " есть в массиве M.";
else
    label1->Text = "Числа " + k.ToString() + " нет в массиве M.";

Пример 2. Найти все позиции вхождения числа k в массиве M состоящим из 50 целых чисел.

// определение всех позиций заданного числа в массиве чисел
int M[50]; // массив чисел
int i; // вспомогательная переменная
int k; // искомое значение
int INDEXES[50]; // искомый массив позиций вхождения числа k
int n; // количество найденных позиций или количество элементов в массиве INDEXES

// ввод массива M
// ...
// ввод числа k
// ...

// поиск числа k в массиве M и одновременное формирование массива INDEXES
n = 0;
for (i=0; i<50; i++)
    if (k==M[i])
    {
        // число найдено
        n++;
        INDEXES[n-1] = i;
    }

// вывод результата в listBox1
listBox1->Items->Clear();

for (i=0; i<n; i++)
    listBox1->Items->Add(INDEXES[i].ToString());

⇑

---

Связанные темы

• Массивы. Часть 1. Определение массива в C++. Одномерные массивы. Инициализация массива
• Массивы. Часть 2. Двумерные массивы. Массивы строк. Многомерные массивы

⇑

---

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

Проверка наличия значения элемента в массиве может применяться при решении различных задач в программировании.

Мы можем получать различные массивы из нашей базы данных и проверять наличие того или иного значения в нем. Искомое значение может передаваться и от пользователя нашего скрипта, когда он, например, что-то ищет. По результатам такого поиска можно совершать определенные действия. Все зависит от конкретно поставленной задачи, однако, алгоритмы поиска значения в массиве будут одними и теми же.

Сегодня мы их рассмотрим.

Проверка наличия значения в массиве. Функция in_array()

Функция in_array() позволит нам проверить наличие какого-либо значения в массиве.

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

Функция принимает 2 обязательных параметра: <Что ищем> и <Где ищем>.

Также она может принимать еще один необязательный параметр: <Тип данных>. Если этот третий необязательный параметр имеет значение true, тогда проверяется еще и тип данных. То есть ‘2’ и 2 будет не одно и то же. В первом случае – это строка, во втором – число. И тогда уже вся функция in_array() не вернет значение true.

Также нужно помнить, что функция осуществляет сравнение с учетом регистра символов.

Давайте рассмотрим работу этой функции на простом примере.
Нам нужен какой-нибудь массив. При помощи функции проверим наличие значения в массиве и выведем на экран определенное сообщение.

<?php
$Mass = array('www.hotmail.com','Marina',5,'website-create.ru');
if(in_array('Marina',$Mass)) echo 'Yes';
else echo 'No';
?>

Отработав функция выведет на экран сообщение «Yes», так как элемент «Marina» в нашем массиве присутствует.

Поменяйте первый параметр в функции на какой-либо несуществующий элемент, и Вы увидите сообщение «No».

Проверка наличия значения в массиве. Функция array_search()

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

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

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

<?php
$Mass1=array('mounth'=>'october','money'=>200,'name'=>'Mila');
$key = array_search('Mila',$Mass1);
if($key) echo $key;
?>

В данном случае мы увидим на экране «name», то есть ключ от искомого элемента со значением «Mila».

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

Поиск значения в многомерном массиве

А что делать, если мы работаем с многомерным массивом? Ведь его элементами будут другие массивы.

Здесь уже рассмотренные нами алгоритмы не сработают.

На самом деле все не так уж и сложно, просто нужно немного усложнить весь механизм и использовать цикл, например, foreach(), который прекрасно работает с массивами.

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

Все, что требуется сделать – это перебрать элементы первоначального массива в цикле foreach(). Каждый элемент этого массива будет разобран на ключ ($key) и значение ($value).

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

При нахождении мы выведем на экран сообщение о том, что такой элемент существует, а если нет, то выведем другое сообщение, что такого элемента нет.

Давайте посмотрим все это на примере кода:

<?php
$Mass2[0] = array('name'=>'anna','id'=>234);
$Mass2[1] = array('name'=>'anton','id'=>24);
$Mass2[2] = array('name'=>'ivan','id'=>007);
foreach($Mass2 as $key => $value)
{
$name .= in_array('ivan',$value);
}
if($name) echo 'OK! Element here!';
else echo 'No have element!'; 	
?>

Как Вы видите, вначале мы объявляем сам многомерный массив.

Далее в цикле foreach() проходимся по каждому из его элементов (внутренних массивов). В переменную $value на каждой итерации попадает каждый внутренний массив массива $Mass2.

А далее при помощи функции in_array() мы проверяем существование нужного нам значения элемента и заносим результат в переменную $name.

При этом здесь обязательно нужно писать не просто знак равенства, а «.=».

Делается это для того, чтобы переменная $name не перезаписывалась на каждой итерации, а дополнялась. Ведь если на первой итерации элемент будет найден и в переменную $name запишется значение «true», а на второй итерации (то есть во втором внутреннем массиве) искомого значения элемента нет, то значение переменной $name просто перезапишется, и в итоге мы просто не получим корректный результат.

Далее по результатам значения переменной $name мы выводим на экран соответствующее сообщение.

Как Вы поняли, итогом работы этого кода будет сообщение «OK! Element here!».

Попробуйте поменять искомый элемент на несуществующий и Вы увидите сообщение «No have element!».

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

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

А я жду Ваших комментариев.

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

Желаю Вам успешного программирования!

С Вами была Анна Котельникова!

До новых встреч!