А кто-то вел речь о десятичных? Даже детишки знают, что для целых чисел деление можно заменить логическим сдвигом, четность проверять по младшему разряду, по естественным причинам. Десятичное представление иное.

поясни почему интересное и правильное с твоей точки зрения

const doubleEveryEven = arr => arr.map(n => 0 === n % 2 ? n + n : n);

здесь нет лишнего умножения
Error,
приветсвую, если аватарка таже
laimas,
абсолютно правильно написал для целых чисел

Vlasenko Fedor,
приветствую Вас! Да, это я. Что касается моего решения, то мне захотелось избежать применения любых условных операторов. Хотя это, конечно, не должно быть целью.

Понятие чётности вводится обычно именно для целых чисел (для рациональных нет смысла рассматривать вопросы делимости). Поэтому предлагаю считать, что все элементы массива — целые числа. Значит, любое решение, применимое к целым числам, можно считать правильным.

Поосторожнее надо быть детишкам.
console.log(2**30<<1)

:stop: Но, но, это также как и с десятичными, не всегда будет гут, но с другой стороны мы же иногда и округляем, а значит допускаем. А деление, это сдвиг вправо, а не влево ;)

a<<b
умножение числа a на 2 в степени b

console.log(2**30&1)

Раз использовался Array, а не конкретный типизированный массив для целых чисел; а также тип Number, то странно предполагать, что речь идёт не о десятичных числах. Совершенно спокойно можно написать дробное число и оно будет неверно обработано. Может для тебя ОК писать код, который делает неожиданные вещи и продолжает выполняться, но я предпочёл бы использовать правильный тип или выкидывать исключение при нарушении требовании (диапазон целых чисел и проверка на целочисленность)

Использование правильного типа оберегает от проблем...

function doubleEveryEven (a) {
    return a.map(n => n * (2n - (n & 1n)));
}
console.log(doubleEveryEven([11n, 0n, 9n, 3n, 10n, 4n]));

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

Если же хотите использовать тип Number и работать именно с целыми числами и использовать оператор &, то следует провести проверки.

Хотя оператор & работает с 32-битными числами, он подходит для задачи, поскольку нас интересует только последний бит.

function doubleEveryEven (a) {
    return a.map(n => {
        if(!Number.isSafeInteger(n))
            throw new RangeError(`The provided number ${n} is not a safe integer to operate with.`);

        if((n & 1) == 0) {
            const doubleN = 2 * n;

            if(!Number.isSafeInteger(doubleN))
                throw new RangeError(`The calculated number ${doubleN} is not a safe integer to operate with.`);

            return doubleN;
        } else {
            return n;
        }
    });
}
console.log(doubleEveryEven([11, 0, 9, 3, 10, 4]));

Почему удвоенное число типа Number тоже проверяется на безопасность? Поскольку безопасное число, умноженное на 2, может оказаться не безопасным...

alert(8456834563856384 * 2 === 16913669127712767);

А на самом деле так...

alert(8456834563856384n * 2n === 16913669127712767n);

Что же касается умножения при помощи побитового сдвига, то нужно учитывать, что работает с 32-битными числами от -(2 ** 31) до 2 ** 31 - 1.

function doubleEveryEven (a) {
    return a.map(n => {
        if(Number.isSafeInteger(n) && ((n > 2 ** 31 - 1) || (n < -(2 ** 31))))
            throw new RangeError(`The provided number ${n} is not a safe 32-bit integer to operate with.`);

        if((n & 1) == 0) {
            if((n > 2 ** 30 - 1) || (n < -(2 ** 30)))
                throw new RangeError(`A double of number has got to be a safe 32-bit integer to operate with.`);

            return n << 1;
        } else {
            return n;
        }
    });
}
console.log(doubleEveryEven([11, 0, 9, 3, 10, 4]));

Не упомянуты проверки, соответственно не для всех целых чисел правильные результаты.

Если именно для типа Number и кол-во значащих цифр не имеет значения, но тут оказалось всё хуже — пишем тип Number, думаем о BigInt.

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

Однако же не написано.

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

Твой метод хорош, просто нужно было уточнить, что он правильно работает только с типом BigInt, а с типом Number требуются дополнительные проверки!

Это не мой метод, а если руководствоваться постулатом "Раз использовался Array, а не конкретный типизированный массив для целых чисел; а также тип Number, то странно предполагать, что речь идёт не о десятичных числах.", то надо смотреть ширше, ибо массив может содержать и другое. Почему тогда не добавить еще и о проверке типа перед нами, например, в стрингах он или нет, и можно ли его вообще умножать.

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

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