12 полезных советов и трюков с JavaScript массивами

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

1. Как удалить дубликаты из JavaScript массива?

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

const fruits = ["banana", "apple", "orange", "watermelon", "apple", "orange", "grape", "apple"];
 
// Первый способ
const uniqueFruits = Array.from(new Set(fruits));
console.log(uniqueFruits); // возвращает ["banana", "apple", "orange", "watermelon", "grape"]

// Второй способ
const uniqueFruits2 = […new Set(fruits)];
console.log(uniqueFruits2); // возвращает ["banana", "apple", "orange", "watermelon", "grape"]

Еще несколько способов удаления дубликатов из JavaScript массива описаны в статье "Как удалить повторяющиеся элементы массива в JavaScript?"

2. Как заменить определенное значение в JavaScript массиве?

Иногда при написании кода необходимо заменить определенное значение в массиве, и для этого есть хороший короткий метод, о котором вы, возможно, еще не знаете. Для этого мы можем использовать .splice(start, value to remove, valueToAdd) и передать туда все три параметра, указывающие, где мы хотим начать модификацию, сколько значений мы хотим изменить, и новые значения.

const fruits = ["banana", "apple", "orange", "watermelon", "apple", "orange", "grape", "apple"];

fruits.splice(0, 2, "potato", "tomato");
console.log(fruits); // возвращает ["potato", "tomato", "orange", "watermelon", "apple", "orange", "grape", "apple"]

3. Как трансформировать JavaScript массив не используя .map()?

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

const friends = [
    { name: "John", age: 22 },
    { name: "Peter", age: 23 },
    { name: "Mark", age: 24 },
    { name: "Maria", age: 22 },
    { name: "Monica", age: 21 },
    { name: "Martha", age: 19 },
]

const friendsNames = Array.from(friends, ({name}) => name);
console.log(friendsNames); // возвращает ["John", "Peter", "Mark", "Maria", "Monica", "Martha"]

4. Как очистите JavaScript массив?

Что делать если по каким-то причинам нужно очистить массив, но не хочется удалять элементы по одному? Это очень просто сделать одной строкой кода. Чтобы очистить массив, вам нужно установить длину массива равным 0, и все.

const fruits = ["banana", "apple", "orange", "watermelon", "apple", "orange", "grape", "apple"];

fruits.length = 0;
console.log(fruits); // возвращает []

5. Как в JavaScript преобразовать массив в объект?

Бывает, что у нас есть массив, но для какой-то цели нам нужен объект с этими данными, и самый быстрый способ преобразовать массив в объект — использовать известный оператор spread (...).

const fruits = ["banana", "apple", "orange", "watermelon"];
const fruitsObj = { ...fruits };

console.log(fruitsObj); // возвращает { 0: "banana", 1: "apple", 2: "orange", 3: "watermelon", 4: "apple", 5: "orange", 6: "grape", 7: "apple" }

6. Как заполнить данными массив в JavaScript?

Бывают ситуации, когда мы создаем массив, и мы хотели бы заполнить его какими-то данными, или нам нужен массив с одинаковыми значениями, и в этом случае можно использовать метод .fill().

const newArray = new Array(10).fill("1");

console.log(newArray); // возвращает ["1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]

7. Как объединить несколько массивов в JavaScript?

Знаете ли вы, как объединить массивы в один массив без использования метода .concat()? Существует простой способ объединить любое количество массивов в один одной строкой кода. Как вы, наверное, уже поняли, оператор spread (...) довольно полезен при работе с массивами и в данном случае он тоже применим.

const fruits = ["apple", "banana", "orange"];
const meat = ["beef", "fish"];
const vegetables = ["potato", "tomato", "cucumber"];
const food = [...fruits, ...meat, ...vegetables];

console.log(food); // ["apple", "banana", "orange", "beef", "fish", "potato", "tomato", "cucumber"]

8. Как удалить ложные значений из JavaScript массива?

Сначала определим ложные значения. В JavaScript ложными значениями являются false, 0, "", null, NaN, undefined. Теперь мы можем узнать, как удалить такого рода значения из нашего массива. Для этого мы будем использовать метод .filter().

const mixedArr = [0, "blue", "", NaN, 9, true, undefined, "white", false];
const trueArr = mixedArr.filter(Boolean);

console.log(trueArr); // возвращает ["blue", 9, true, "white"]

9. Как получить случайное значение из JavaScript массива?

Иногда нам нужно выбрать значение из массива случайным образом. Простой, быстрый и короткий способ - получить случайный индекс в соответствии с длиной массива. Давайте посмотрим код:

const colors = ["blue", "white", "green", "navy", "pink", "purple", "orange", "yellow", "black", "brown"];

const randomColor = colors[(Math.floor(Math.random() * (colors.length)))]

10. Как реверсировать массив на JavaScript?

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

const colors = ["blue", "white", "green", "navy", "pink", "purple", "orange", "yellow", "black", "brown"];
const reversedColors = colors.reverse();

console.log(reversedColors); // возвращает ["brown", "black", "yellow", "orange", "purple", "pink", "navy", "green", "white", "blue"]

11. Как получить n-й с конца элемент массива в JavaScript?

В JavaScript есть интересный метод, позволяющий найти индекс последнего вхождения данного элемента. Например, если наш массив имеет повторяющиеся значения, мы можем найти позицию последнего его вхождения. Рассмотрим пример кода:

const nums = [1, 5, 2, 6, 3, 5, 2, 3, 6, 5, 2, 7];
const lastIndex = nums.lastIndexOf(5);

console.log(lastIndex); // возвращает 9

12. Как просуммировать все значения в JavaScript массиве?

Это еще одна популярная задача, которая очень часто возникает во время JavaScript собеседования. Здесь нет ничего сложного; ее можно решить с помощью метода .reduce одной строкой кода. Давайте проверим код:

const nums = [1, 5, 2, 6];
const sum = nums.reduce((x, y) => x + y);

console.log(sum); // возвращает 14

Итоги

В этой статье мы рассмотрели 12 трюков и советов, которые могут помочь вам при разработке и сделают ваш код коротким и чистым.

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

Зачем переходить с JavaScript на Rust?

JavaScript, де-факто язык Интернета, является динамичным, гибким и вездесущим. Это язык, который понимают браузеры, что делает его важным инструментом в арсенале веб-разработчика. Несмотря на это, JavaScript имеет свои ограничения, особенно когда речь идет о производительности и безопасности типов. Rust — системный язык программирования, который работает молниеносно, предотвращает ошибки сегментации и гарантирует безопасность потоков. Разработанный Mozilla, Rust неуклонно набирает обороты благодаря своей скорости, надежности, предлагая JavaScript разработчикам прочный мост к системному программированию.

Установка Rust

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

1. Посетите официальный сайт Rust: rustup.rs.
2. Следуйте инструкциям на веб-сайте, чтобы загрузить и установить rustup для вашей операционной системы.
3. После установки rustup откройте терминал или командную строку и выполните команду rustup update, чтобы убедиться, что у вас установлена последняя версия Rust. После установки rustup у вас будет доступ к трем важным командам: rustup, rustc и cargo. rustup позволяет вам управлять цепочкой инструментов компилятора Rust, rustc — это сам компилятор Rust (хотя вам редко придется использовать его напрямую), а cargo — это менеджер пакетов и система сборки Rust, похожая на npm в JavaScript.

Настройка проекта Rust

Теперь, когда у вас установлен Rust, давайте создадим новый проект Rust. Rust предоставляет мощный инструмент под названием cargo, который упрощает управление проектами и выстраивает процессы. Выполните следующие действия, чтобы создать новый проект Rust:

1. Откройте терминал или командную строку и перейдите в каталог, в котором вы хотите создать проект.
2. Выполните команду cargo new my_project_name, заменив my_project_name нужным именем для вашего проекта.
3. cargo создаст новый каталог с указанным именем проекта, содержащий необходимые файлы и папки для базовой структуры проекта Rust. Внутри каталога проекта вы найдете файл Cargo.toml, который служит конфигурационным файлом проекта, аналогично package.json в JavaScript. Он определяет метаданные проекта, зависимости и другие параметры. Кроме того, вы найдете каталог src, который содержит файлы исходного кода для вашего проекта.

Написание первой программы на Rust

Давайте напишем простую программу «Hello, World!» на Rust, чтобы почувствовать синтаксис языка. Откройте файл src/main.rs в каталоге проекта и замените его содержимое следующим кодом:

fn main() {
    println!("Hello, World!");
}

В Rust функция main является точкой входа для выполнения программы, аналогичная функции main в JavaScript. Макрос println! используется для печати сообщения "Hello, World!" на консоли. Rust использует макросы для генерации кода, что позволяет создавать мощные и гибкие синтаксические расширения. Чтобы запустить программу, откройте терминал или командную строку, перейдите в каталог проекта и выполните команду cargo run. Cargo скомпилирует ваш код и выполнит полученный двоичный файл. Вы должны увидеть сообщение «Hello, World!», напечатанное в консоли. Поздравляю! Вы написали и запустили свою первую программу на Rust. Теперь давайте углубимся в некоторые ключевые понятия и синтаксис в Rust.

Переменные и типы данных в Rust

В Rust переменные по умолчанию неизменяемы (иммутабельны), что означает, что их значения не могут быть изменены после назначения. Однако вы можете использовать ключевое слово mut (mutable, мутабельные) для создания изменяемых переменных. Давайте посмотрим на несколько примеров:

fn main() {
    let name = "Alice"; // Иммутабельная переменная
    let mut age = 30; // Мутабельная переменная
    age += 1; // Инкремент переменной на 1
    println!("Name: {}", name);
    println!("Age: {}", age);
}

В этом примере name — это неизменяемая переменная, содержащая строку, а age — это изменяемая переменная, содержащая целое число. Мы можем изменить значение age с помощью оператора +=. Макрос println! снова используется для отображения значений переменных. Rust предоставляет несколько встроенных примитивных типов данных, включая целые числа, числа с плавающей запятой, логические значения, символы и строки. Ниже приведен обзор некоторых распространенных типов данных:

• Целочисленные типы: i8, i16, i32, i64, u8, u16, u32, u64
• Типы чисел с плавающей запятой: f32, f64
• Логический тип: bool
• Символьный тип: char
• Строковый тип: String (изменяемая строка с динамическим размером) и фрагменты строки (&str)

Rust использует вывод типов для переменных на основе их начальных значений. Тем не менее, вы можете явно указать тип, используя let variable: Type = value;. Например:

fn main() {
    let x: i32 = 42;
    let pi: f64 = 3.14;
    let is_true: bool = true;
    let message: &str = "Hello, Rust!";
}

Поток управления

Как и JavaScript, Rust предоставляет различные операторы потока управления, включая выражения if, циклы for и while и выражения match. Давайте рассмотрим каждый из них.

Выражения if

В Rust операторы if — это выражения, которые вычисляют условие и выполняют блок кода на основе результата. Вот пример:

fn main() {
    let number = 5;
    if number % 2 == 0 {
        println!("The number is even");
    } else {
        println!("The number is odd");
    }
}

В этом примере мы проверяем, делится ли переменная number на 2. Если это так, мы печатаем, что число четное; В противном случае мы печатаем, что это нечетное.

Цикл loop

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

fn main() {
    let mut count = 0;
    loop {
        println!("Count: {}", count);
        count += 1;
        if count >= 5 {
            break;
        }
    }
}

В этом примере мы инициализируем count равным 0 и используем loop для многократного вывода ее значения. Цикл продолжается до тех пор, пока count не достигнет 5, после чего мы выходим из цикла с помощью оператора break.

Цикл while

Ключевое слово while позволяет создать цикл, который выполняется до тех пор, пока выполняется определенное условие. Вот пример:

fn main() {
    let mut count = 0;
    while count < 5 {
        println!("Count: {}", count);
        count += 1;
    }
}

В этом примере цикл продолжается до тех пор, пока count меньше 5. Мы увеличиваем count на 1 в каждой итерации и выводим его значение.

Выражения match

Выражение match Rust похоже на оператор switch JavaScript, но с более мощными возможностями сопоставления шаблонов (pattern matching). Он позволяет сопоставлять значение с набором шаблонов и выполнять код на основе совпадающего шаблона. Давайте посмотрим на пример:

fn main() {
    let number = 2;
    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"),
    }
}

В этом примере мы сопоставляем значение переменной number с различными шаблонами. Если значение равно 1, печатаем "One". Если это 2, мы печатаем "Two". Если это 3, мы печатаем "Three". Если ни один из шаблонов не совпадает, представленный символом подчеркивания _, мы печатаем "Other". Выражения match могут быть более сложными, что позволяет сопоставлять шаблоны с перечислениями, диапазонами и даже захватывать переменные. Это мощная конструкция, которая может обрабатывать широкий спектр сценариев.

Выражения

Еще одним важным аспектом Rust является его природа, основанная на выражениях (expression-based), которая отличается от подхода JavaScript, основанного на утверждениях (statement-based). В Rust почти все является выражением, включая блоки кода. Это позволяет создавать мощные и лаконичные шаблоны. Для примера сравним простой пример потока управления в JavaScript и Rust:

let x = {
    let y = 1 + 1;
    y * y
};
if x == 4 {
    println!("Hello, world!");
}

В этом примере Rust мы определяем блок кода с помощью фигурных скобок {}. Последнее выражение внутри блока (y * y) становится значением всего блока, которое затем присваивается переменной x.

Функции и модули

Функции в Rust определяются с помощью ключевого слова fn, аналогично JavaScript. Давайте посмотрим на пример:

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

В этом примере мы определяем функцию greet, которая принимает строковый фрагмент (&str) в качестве параметра и выводит приветственное сообщение. Затем мы дважды вызываем функцию greet в main функции с разными именами. Rust также поддерживает определение модулей, которые помогают организовать и структурировать ваш код. Модули позволяют группировать связанные функции, типы и другие элементы вместе. Ниже приведен пример определения модуля:

mod math {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }
}

fn main() {
    let result = math::add(5, 3);
    println!("Result: {}", result);
}

В этом примере мы определяем math модуль, который содержит две функции: add и subtract. Эти функции выполняют основные арифметические действия. Ключевое слово pub указывает, что функции являются общедоступными и к ним можно получить доступ из-за пределов модуля. В main функции вызываем функцию add из модуля math, передавая аргументы 5 и 3. Результат сохраняется в переменной result, которую затем выводим на консоль. Модули позволяют упорядочить код в логические блоки, упрощая управление и обслуживание более крупных проектов. Вы можете вкладывать модули в другие модули, чтобы создать иерархическую структуру.

Обработка ошибок

Обработка ошибок в Rust является значительным улучшением по сравнению с JavaScript. В то время как JavaScript выбрасывает и ловит ошибки, Rust использует механизм под названием «Result» для обработки ошибок, который представляет собой либо успешное значение (Ok), либо ошибку (Err). Это похоже на использование блоков try/catch в JavaScript.

use std::fs::File;
use std::io::Read;
fn read_file_contents(file_path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(file_path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file_contents("data.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(error) => eprintln!("Error: {}", error),
    }
}

В этом примере мы определяем функцию read_file_contents, которая считывает содержимое файла с указанием пути к нему. Функция возвращает тип Result, где успешным значением является String, содержащая содержимое файла, а тип ошибки — std::io::Error. Внутри функции мы используем оператор ? для распространения любых ошибок, возникающих во время операций с файлами. Если произойдет ошибка, функция немедленно вернет значение ошибки. В main функции мы обрабатываем Result с помощью выражения match. Result в Ok, мы распечатываем содержимое файла. Err, мы печатаем сообщение об ошибке. Используя тип Result и распространение ошибок, Rust обеспечивает обработку ошибок и делает их явными в коде. Это приводит к более надежным программам.

Управление памятью

Одной из выдающихся особенностей Rust является его система, которая обеспечивает безопасность памяти и устраняет распространенные проблемы, такие как исключения null указателей и гонки данных. У каждого значения в Rust есть один владелец. Когда владелец выходит за пределы области, значение очищается. Это избавляет от необходимости сборки мусора. Заимствование позволяет временно заимствовать ссылку на значение, не вступая в права собственности. Rust применяет строгие правила заимствования во время компиляции, чтобы предотвратить гонку данных и недопустимый доступ к памяти. Время жизни гарантирует, что заимствованные ссылки остаются действительными до тех пор, пока они используются. Они позволяют компилятору определять время жизни ссылок и предотвращают висячие ссылки. Вот простой пример, демонстрирующий владение и заимствование в Rust:

fn process_string(s: String) {
    println!("Processing: {}", s);
} // s остается за пределами и уничтожается

fn main() {
    let message = String::from("Hello, Rust!");
    process_string(message); // Владение `message` передается функции
    // println!("Message: {}", message); // Эта строка приводит к ошибке компиляции
}

В этом примере функция process_string становится владельцем String параметра s. Как только вызов функции завершен, s выходит за пределы области и удаляется. Если мы попытаемся использовать message после его передачи функции, это приведет к ошибке компиляции, потому что право собственности было передано. Чтобы позаимствовать ссылку на значение без передачи права собственности, мы можем использовать ссылки (&). Вот пример:

fn process_string(s: &str) {
    println!("Processing: {}", s);
}

fn main() {
    let message = String::from("Hello, Rust!");
    process_string(&message); // Позаимствовать ссылку на `message`
    println!("Message: {}", message); // `message` все еще доступен
}

В этом примере мы определяем функцию process_string для получения ссылки на строковый фрагмент (&str). Вместо того, чтобы передавать String напрямую, мы передаем ссылку на String с помощью оператора &. Это позволяет функции заимствовать значение, не становясь владельцем. Используя ссылки и систему владения, Rust обеспечивает безопасность памяти и устраняет многие распространенные ошибки программирования, связанные с управлением памятью.

Асинхронное программирование

Rust также поддерживает синтаксис async/await, но его работа по стандартизации все еще продолжается, и многие вещи еще не работают или могут привести к ошибкам. Но в настоящее время сообщество предоставляет мощное асинхронное решение, такое как tokio. Например, асинхронные привязки ввода-вывода встроены в Node.js, а в Rust — нет. Но мы можем использовать различные мощные асинхронные среды выполнения, например, использовать async-std для написания простого примера ниже:

use async_std::fs;
#[async_std::main]
async fn main() {
     match fs::read_to_string("./hello.txt").await {
         Ok(file) => println!("read {} chars", file.len()),
         Err(e) => eprintln!("{}", e),
     };
}

Rust «Futures» (аналог Promises) начинают выполняться только тогда, когда они вызываются с .await.

Параллелизм и многопоточность

Rust отлично поддерживает параллельное программирование и предоставляет безопасные абстракции для работы с потоками и общими данными. Модуль std::thread позволяет создавать потоки в Rust и управлять ими. Ниже приведен пример использования потоков для параллельного выполнения:

use std::thread;
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread: {}", i);
        }
    });
    for i in 1..=5 {
        println!("Main: {}", i);
    }
    handle.join().unwrap(); // Ожидаем пока thread закончит выполнение
}

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

Итоги

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