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

• Главная

• Инструкции

• JavaScript

• Методы поиска в массивах JavaScript

Поиск в массиве — довольно несложная задача для программиста. На ум сразу приходит перебор через цикл for или бинарный поиск в отсортированном массиве, для элементов которого определены операции «больше» и «меньше». Но, как и любой высокоуровневый язык программирования, JavaScript предлагает разработчику встроенные функции для решения различных задач. В этой статье мы рассмотрим четыре метода поиска в массивах JavaScript: find, includes, indexOf и filter.

indexOf

indexOf — это функция поиска элемента в массиве. Этот метод с помощью перебора ищет искомый объект и возвращает его индекс или «-1», если не находит подходящий.

Синтаксис

Функция имеет такой синтаксис:

Array.indexOf (search element, starting index)

где:

• Array — массив;
• search element — элемент, который мы ищем;
• starting index — индекс, с которого начинаем перебор. Необязательный аргумент, по умолчанию работа функции начинается с индекса “0”, т.е. метод проверяет весь Array. Если starting index больше или равен Array.length, то метод сразу возвращает “-1” и завершает работу. 

Если starting index отрицательный, то JS трактует это как смещение с конца  массива: при starting index = “-1” будет проверен только последний элемент, при “-2” последние два и т.д. 

Практика

Опробуем метод на практике. Запустим такой код и проверим результаты его работы:

let ExampleArray = [1,2,3,1,'5', null, false, NaN,3];
console.log("Позиция единицы", ExampleArray.indexOf(1) );
console.log("Позиция следующей единицы", ExampleArray.indexOf(1,2) );
console.log("Позиция тройки", ExampleArray.indexOf(3) );
console.log("Позиция тройки, если starting index отрицательный", ExampleArray.indexOf(3,-2) );
console.log("Позиция false", ExampleArray.indexOf(false) );
console.log("Позиция 5", ExampleArray.indexOf("5") ); 
console.log("Позиция NaN", ExampleArray.indexOf(NaN));

В результате работы этого кода мы получили такой вывод: 

Позиция единицы 0
Позиция следующей единицы 3
Позиция тройки 2
Позиция тройки, если starting index отрицательный 8
Позиция false 6
Позиция 5 -1
Позиция NaN -1

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

Для сравнения искомого и очередного объекта применяется строгое сравнение (===). При использовании строгого сравнения для разных типов данных, но с одинаковым значение, например 5, ‘5’ и “5” JavaScript даёт отрицательный результат, поэтому IndexOf не нашел 5. 

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

includes

includes не совсем проводит поиск заданного элемента в массиве, а проверяет, есть ли он там вообще. Работает он примерно также как и indexOf. В конце работы includes возвращает «True», если нашел искомый объект, и «False», если нет. Также includes правильно обрабатывает NaN

Синтаксис

includes имеет следующий синтаксис:

Array.includes (search element, starting index)

где: 

• Array — массив;
• search element — элемент, который мы ищем;
• starting index — индекс, с которого начинаем перебор. Необязательный аргумент, по умолчанию работа функции начинается с индекса “0”, т.е. метод проверяет весь Array. Если starting index больше или равен Array.length, то метод сразу возвращает «False» и завершает работу.  

Если starting index отрицательный, то JS трактует это как смещение с конца массива: при starting index = “-1” будет проверен только последний элемент, при “-2” последние два и т.д.  

Практика

Немного изменим код из предыдущего примера и запустим его:

let Example = [1,2,3,1,'5', null, false,NaN, 3];
console.log("Наличие единицы", Example.includes(1) );
console.log("Наличие следующей единицы", Example.includes(1,2) );
console.log("Наличие тройки", Example.includes(3) );
console.log("Наличие тройки, если starting index отрицательный", Example.includes(3,-1) );
console.log("Наличие false", Example.includes(false) );
console.log("Наличие 5", Example.includes(5) ); 
console.log("Наличие NaN", Example.includes(NaN));

Вывод:

Наличие единицы true
Наличие следующей единицы true
Наличие тройки true
Наличие тройки, если starting index отрицательный true
Наличие false true
Наличие 5 false
Наличие NaN true

Для includes отсутствует альтернативная функция, которая проводит поиск по массиву js справа налево, которая, в общем-то, и не очень актуальна.

find

Предположим, что нам нужно найти в массиве некий объект. Но мы хотим найти его не по значению, а по его свойству. Например, поиск числа в массиве со значением между 15 и 20. Как и прежде, мы можем воспользоваться перебором с помощью for, но это не слишком удобно. Для поиска с определенным условием в JavaScript существует метод find.

Синтаксис

Array.find(function(...){
//если элемент соответствует условиям (true), то функция возвращает его  и прекращает работу;
//если ничего не найдено, то возвращает undefined
})

• Array — массив;
• function(…) — функция, которая задает условия.

Практика

Как и в прошлых примерах, напишем небольшой код и опробуем метод:

let ExampleArray = ["Timeweb", 55555, "Cloud", "облачный провайдер", "буквы"];
console.log(ExampleArray.find(element => element.length == 5))

Вывод:

Cloud

В этом примере мы искали строки с длиной в 5 символов. Для числовых типов данных длина не определена, поэтому 55555 не подходит. find находит первый элемент и возвращает его, поэтому «буквы» также не попали в результат работы нашей функции. Для того, чтобы найти несколько элементов, соответствующих некоторому условию, нужно использовать метод filter.

Также не стоит забывать о методе findIndex. Он возвращает индекс подходящего элемента. Или -1, если его нет. В остальном он работает точно также, как и find.

filter

find ищет и возвращает первый попавшийся элемент, соответствующий условиям поиска. Для того, чтобы найти все такие элементы, необходимо использовать метод filter. Результат этой функции — массив (если ничего не найдено, то он будет пустым).

Синтаксис

Array.find(function(...){
//если элемент соответствует условиям (true), то добавляем его к конечному результату и продолжаем перебор;
})

• Array — массив;
• function(…) — функция, которая задает условия.

Практика

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

let ExampleArray = [
  [10, 15, 8],
  [11, 12, 6],
  [5, 20, 1],
  [10, 10, 2],
  [16,2, 4]
  ];
console.log(ExampleArray.filter(element=> element[0]*element[1]*element[2]>300))

 Вывод:

[ [ 10, 15, 8 ],
 [ 11, 12, 6 ] ]

В этом примере мы нашли прямоугольные параллелепипеды с объемом больше 300. В целом, метод filter в JS позволяет реализовывать всевозможные условия для поиска. 

Заключение

В этой статье узнали о методах поиска в JavaScript и научились ими пользоваться. Все перечисленные методы — универсальные инструменты для разработчиков. Но, как и любые универсальные инструменты, они не всегда являются самыми производительными. Так, например, бинарный поиск будет куда эффективнее, чем find и filter.

Вообщем то, что у меня получилось ниже логика скрипта должна быть такая:

• 1.Пользователь забивает в форму контакты (просто емайл контакты или контакты емайл:пароль или какая то другая вариация контактов. Скрипт разбивает это все на массивы и выявляет емаейлы и отделяет ненужное удаляя дубликаты. Сохраняет в файл все это дело.
• 2.Страница генерации позволяет сгенерировать базу из сохраненного файла по параметрам начального символа и конечного символа, а так же по домену и возможность скачать сгенерированный файл.
• 3.Страница позволяет отправить от указанного имени с темой и контентом письма всей базе сгенерированного файла.

Вот, что из этого получилось:

PS! не пинайте за быдло код лудше подправьте, что не так в нормальный код

class eMails extends mail
{

    protected $tmpFolder = "temp.txt";
    protected $genFolder = "generated.txt";

    function __construct($exec_time = 1600)
    {
        session_start();
        ini_set('max_execution_time', $exec_time); //300 seconds = 5 minutes
        header('Content-Type: text/html; charset=utf-8');
        ini_set('display_errors',1);
        error_reporting(E_ALL);
        setlocale(LC_CTYPE, 'us_US.UTF8');

        // Проверяем существуют папки для работы 

        if (!file_exists($this->tmpFolder)){
            $fh = fopen($newfile, 'w') or die("Невозможно ");
            fclose($fh);
        }

    }

    private function checkFiles($whatCheck=false){

        // Проверяем на существование и пустоту файл
        if (!file_exists($whatCheck) || '' == filesize($whatCheck)) {
            return false;
        } 
        return true;
    }

    private function getData($string=false,$getFromFile=false){

        if ($getFromFile)
            $string = file_get_contents($string);

        $array = array_filter(explode("n", $string));

        if (count($array) < 1) {
            echo "Массив пустой, нечего обрабатывать!";
            return false;
        } 

        return $array;
    }

    public function addNewMails(){

        $count_processed= 0;

        if ($_SERVER['REQUEST_METHOD'] == "POST") {

            /* Обрабатываем залитый файл и генерируем новый файл по определенному параметру */ 
            // Удаляем пустые массивы
            $_POST = array_filter($_POST);

            if ( !array_key_exists("data2load", $_POST) || empty($_POST['data2load'])) {
                die("<h3>Нет нужного параметра, выхожу...</h3>");
            }

            $_POST['data2load'] = htmlspecialchars($_POST['data2load']);

            // Создаем массив с емайлами
            //$tmp = explode("n", $_POST['data2load']);

            $tmp = $this->getData($_POST['data2load']);

            // Проверяем массив 
            if ($tmp != false) {

                /* Устанавливаем разделитель */
                $delimiter = !empty($_POST['delimiter']) ? $_POST['delimiter'] : false;

                // Записываем переменные в массив
                foreach ($tmp as $key => $value) {
                    // Автоматически определить как разделитель стоит или стоит он вообще или нет

                    $t = $delimiter != false ? strstr(str_replace(" ", " _ ", $value), $delimiter, true) : $value; 

                    if ( filter_var($t, FILTER_VALIDATE_EMAIL) ) {
                        file_put_contents($this->tmpFolder, $t."n", FILE_APPEND | LOCK_EX);    
                        $count_processed++;
                    } 
                }
                echo "<hr> Найдено емайлов: { $count_processed }";
            } else {
                echo "<p>Пустой массив данных!</p>";
                //var_dump($tmp);
            }


        } else {
            ?>
            <form action="?action=new" method="POST" enctype="multipart/form-data">
                <h3>Upload emails</h3>
                <p><textarea name="data2load" cols="45" rows="25" placeholder="Put here emails"></textarea></p>
                <p>
                <label>Разделитель который используется для емайла и пароля</label><br>
                <select name="delimiter">
                    <option value=":">:</option>
                    <option value=";">;</option>
                    <option value="_" selected>Пробел как разделитель</option>
                    <option>Разделителя нету</option>
                </select></p>
                <p>Удалить дубликаты<input type="checkbox" name="removeDublicates" /></p>
                <input type="submit" name="submit" value="Добавить емайлы" />
            </form>
            <?php 
        }
    }

    public function generateEmaildb(){

        if ($_SERVER['REQUEST_METHOD'] == "POST") {

            // Фильтры по умолчанию пустые 
            $begin = false;
            $end   = false;
            $domain= false;

            // имя для сохранения сгенерированной информации пустое
            $fileName = "";

            $recordedEmails = 0;

            if (!empty($_POST['filterBegin'])) {

                $fileName .= $_POST['filterBegin'];
                $begin = true;
            }
            if (!empty($_POST['filterEnd'])) {

                $fileName .= $_POST['filterEnd'];
                $end = true;
            }
            if (!empty($_POST['filterDomen'])) {

                $fileName .= $_POST['filterDomen'];
                $domain = true;
            }

            $fileName = !$fileName ? "generated_automaticaly.txt" : $fileName.".txt";

            $_SESSION['generated'] = $fileName;

            // Файл сохранять по параметрам заданым пользователями . всего 3 видами параметров.

            $tmp = $_SESSION['tmp'];

            if (!$this->checkFiles($tmp)) {
                echo "<p> Файл с базой емайлов отсутсвует</p>";
                return false;
            }

            $tmp = $this->getData($tmp,true);

            if (!$tmp)
                return false;

            foreach ($tmp as $key => $value) {

                $recordEmail = true;

                // Проверяем фильтры указанные пользователем, если хоть один указанный пользователем не сработал
                // то запись не записывается !!!
                if ($begin != false) {
                    if ($value{0} != mb_strtoupper($begin,'UTF-8') || $value{0} != mb_strtolower($begin,'UTF-8') ) {
                        $recordEmail = false;
                    }
                }
                if ($end != false) {

                    $m = strstr($value, "@", true);
                    if (substr($m, -1) != mb_strtoupper($end,'UTF-8') || substr($m, -1) != mb_strtolower($end,'UTF-8')) {
                        $recordEmail = false;
                    }

                }
                if ($domain != false) {
                    //"^[d|D]S*@[g|G]?[m|M][a|A][i|I][l|L].[r|R][u|U]$" // для preg_match
                    if (strstr($value, '@') != '@'.mb_strtolower($domain,'UTF-8')) {
                        $recordEmail = false;
                    }
                }

                // Записываем в файл отфильтрованное значение
                if ($recordEmail != false) {
                    file_put_contents($fileName, $value."n", FILE_APPEND | LOCK_EX);
                    $recordedEmails++;
                }
            }

            echo "<p>Записей { $recordedEmails } в файле { $fileName } </p>";
            echo "<p><form action='?download=getFile' method='POST' target='_blank'><input type='submit' name='downloadFile' value='Скачать файл' /></form></p>";

        } else {

            $tmp = $this->checkFiles($_SESSION['tmp'],true);
            if (!$tmp) {
                echo "<p>Сперва нужно создать базу с емайлами</a>";
            } else {
            ?>
                <form action="?action=gen" method="POST" >
                    <h3>Параметры для генерации базы емайлов</h3>
                    <label>Пустые поля игнорируются!</label>
                    <p><input type="text" name="filterBegin" placeholder="Первый символ емайла. Пр: A,*,a,_" /></p>
                    <p><input type="text" name="filterEnd" placeholder="Последний символ до значка @. Пр: A,*,a,_" /></p>
                    <p><input type="text" name="filterDomen" placeholder="Укажите домен для фильтрации" /></p>
                    <input type="submit" name="genFilterDB" value="Сгенерировать базу"> <br><span style="color: red">OR</span> <br>
                    <input type="submit" name="removeDublicate" value="Удалить дубликаты">
                </form>
                <?php 
            }
        }
    }

    public function sendEmailDestination(){

        // Проверяем файл на существование

        $tmp = $this->getData($_SESSION['generated']);

        if ($_SERVER['REQUEST_METHOD'] == "POST" && count($tmp) > 0) {

            if ( empty($_POST['from']) or empty($_POST['subject']) or empty($_POST['content'])) {
                echo "<p>Есть пустые поля! Не могу продолжать, выхожу из скрипта</p>";
                return false;
            }

            $sendFrom    = $_POST['from'];
            $sendSubject = $_POST['subject'];
            $sendContent = $_POST['content'];           

            $emailsended = 0;

            foreach ($tmp as $key => $value) {

                //mail::sendMail($value, $sendSubject, $sendContent, $sendFrom);
                $emailsended++;
            }

            echo "<p>Кол-во емайлов отправленно: { $emailsended }</p>";

        } else {

            if (!$tmp) {
                echo "<h3 style='color: green;'>Cперва нужно сгенерировать файл-базу емайлов!</h3>";
            } else {
                ?>
                <form>
                    <p><input type="text" name="from" placeholder="Автор: ваш емайл" /></p>
                    <p><input type="text" name="subject" placeholder="Тема сообщения" /></p>    
                    <p><textarea name="content" placeholder="Тело сообщения" cols="45" rows="25"></textarea></p>
                    <p><input type="submit" name="submit" value="Отослать письма сгенерированной базе!" /></p>  
                </form>
                <?php           
            }
        }

    }

    public function removeDublicate() { 

        $tmp = $_SESSION['temp'];

        $tmp = $this->getData($tmp,true);


        foreach ($tmp as $key => $value_result) {

        }
    }



    public function getFile($what2download=false) {

        $file = $_SESSION['generated'];

        if (isset($_GET['download']) && $file != false) {

            header('Content-Description: File Transfer');
            header('Content-Type: application/octet-stream');
            header('Content-Disposition: attachment; filename="'.basename($file).'"');
            header('Expires: 0');
            header('Cache-Control: must-revalidate');
            header('Pragma: public');
            header('Content-Length: ' . filesize($file));
            readfile($file);
        }
    }


}

Помогите мне исправить недочеты и быдло код

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

• поиск в несортированном массиве;

• поиск в сортированном массиве.

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

Поиск элемента в массиве на С

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

• линейный поиск в массиве на С;

• двоичный или бинарный поиск в массиве на С;

• интерполирующий поиск на С.

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

Линейный поиск элемента в массиве на С

Линейный поиск в массиве на С является самым простым алгоритмом, поэтому изучается первым. Суть его заключается в том, что необходимо будет «перебирать» все элементы массива на совпадение с заданными критериями или ключами. Самый простой не означает самый быстрый. Этот вид поиска очень затратный по времени, поэтому не рекомендуется к применению в массивах с большим количеством данных.

Пример функции линейного поиска:

int linSearch(int arr[], int requiredKey, int arrSize)

{

 for (int i = 0; i < arrSize; i++)

 {

 if (arr[i] == requiredKey)

 return i;

 }

 return -1;

}

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

Двоичный или бинарный поиск элемента в массиве на С

Бинарный поиск в массиве на С подходит для отсортированных массивов. Он также считается довольно простым, но при этом более эффективным, чем линейный алгоритм. Алгоритм его работы основывается на делении массива «пополам» и сверки среднего значения с заданным ключом. Например:

1. Допустим, у вас есть отсортированный массив с простыми числами от 1 до 10: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

2. Вам необходимо найти индекс значения числа «2». «2» будет ключом поиска, поэтому на первом этапе массив поделится «пополам». Так как индексирование элементов в массиве начинается с 0, у нас получается, что 0 + 9 / 2 = 4 (0,5 отбрасывается, и индекс округляется). Под индексом 4 у нас стоит число 5, это число сравнивается с нашим ключом. 5 не равно 2 и больше него. Если бы «среднее» значение массива совпало с ключом, тогда массив бы прекратил работу.

3. Так как 5 больше 2, поиск значения продолжится в части массива, содержащей числа от 1 до 5, а числа от 6 до 10 «отбрасываются в сторону». Вторым шагом алгоритма будет поиск среднего значения в «укороченном» массиве: 0 + 4 / 2 = 2. Под индексом 2 у нас расположено число 3. 3 сравнивается с ключом. Алгоритм определит, что 3 не равно 2 и больше него. Значит, будет третий шаг.

4. На третьем шаге еще часть массива после числа 3 «отбрасывается». Алгоритм ищет среднее значение в оставшихся индексах: 0 + 2 / 2 = 1. Под индексом 1 у нас располагается число 2, это число сравнивается с нашим ключом. Алгоритм определяет, что число 2 равно нашему ключу 2, выдает нам соответствующий индекс числа и заканчивает свою работу.

Вот как все, что мы описали выше, выглядит в скрипте:

#include <iostream>

using namespace std;

int SearchingAlgorithm (int arr[], int left, int right, int keys)

{

int middle = 0;

while (1)

{

middle = (left +right) / 2;

if (keys < arr[middle])

right = middle -1;

else if (keys > arr[])

left = middle + 1;

else

return middle;

if (left > right)

return -1;

}

}

int main()

{

  selocale (LC_ALL, “rus“);

  const int SIZE = 10;

  int array[SIZE] = {};

  int keys = 0;

  int index = 0;

  for (int i = 0; i < SIZE; i++)

  {

   array[i] = i +1;

  cout < < array[i] < <  “ | “;

  cout < < “nn Необходимо ввести числовое значение для поиска: “;

  cin > > keys;

  index = SearchingAlgorithm (array, 0, SIZE, keys);

  if (index >= 0)

  cout < < “Значение, которое вы указали, располагается с порядковым индексом: “ < < index < < “nn“;

  else

  cout < < “Введенное значение в массиве не обнаружено!nn“;

  return 0;

}

Если запустить программу, тогда получится следующий результат:

Необходимо ввести числовое значение для поиска: 2

Значение, которое вы указали, располагается с порядковым индексом: 1

Поиск в массиве С бинарным алгоритмом хорош тем, что он работает намного быстрее, чем линейный алгоритм. Представим, что вам необходимо осуществить поиск в массиве, содержащем 1000 элементов. Линейный поиск должен будет обойти все элементы, а бинарный — около 10. Такой результат возможен, потому что при каждом определении среднего значения часть массива, где точно нет искомого значения, просто отсеивается. Например, при первом шаге в массиве с 1000 элементов 500 отсеются, при втором — еще 250 и т. д.

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

Интерполирующий поиск элемента в массиве С

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

#include <iostream>

using namespace std;

int main ()

{

//Определяем массив со значениями, среди которых будет проходить поиск

int OwnArray [] {2, 3, 5, 7, 8, 90, 124, 232, 1001, 1236 };

int y = 0; //определяем текущую позицию массива

int c = 0; //определяем левую границу массива, откуда будет начинаться поиск

int d = 9; //определяем правую границу массива, докуда будет продолжаться поиск

int WeSearch = 124; //определяем элемент, который ищем

bool found;

//Запускаем интерполяционный поиск в массиве С

for (found = false; (OwnArray[c] < WeSearch) && (OwnArray[d] > WeSearch) && | found;)

y = c + ((WeSearch — OwnArray[c]) * (d — c)) / (OwnArray[d] — OwnArray[c]);

if (OwnArray[y] < WeSearch)

c = y +1;

else if (OwnArray[y] > WeSearch)

d = y -1;

else

found = true;

}

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

if (OwnArray[c] == We Search)

cout < < WeSearch < < “Элемент найден“ < < c < < endl;

else if (OwnArray[d] == WeSearch)

cout < < WeSearch < < “Элемент найден“ < < d < < endl;

else

cout < < “Извините, элемент не найден“ < < endl;

return 0;

}

Простыми словами: этот метод вычисляет область, где может быть расположен искомый элемент; если в этой области нет элемента, тогда границы области в массиве сдвигаются в ту или иную сторону. Этот метод чем-то похож на бинарный алгоритм, потому что в нем также «куски» массива постепенно отсеиваются, пока искомая область не будет сужена до 1 элемента. Если и в этом случае искомый элемент не будет найден, тогда его нет в массиве.

Заключение

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

• «Решето Эратосфена»;

• поиск с «барьером»;

• и другие алгоритмы.

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