Какой из них быстрее и почему? Javascript

Question

Так что мой простой вопрос: который является лучшим решением (производительность и память мудрой) в этом случае:

A. мы обрабатываем переменную в новый и использовать его везде, нам нужно:

// imagine (a) is an incomming variable that 
    // we can't change or else we will break something 

    var a = "carrots"; 

    var b = a.substr(0,a.length-1); 
    // and then use b everywhere 

B. мы обрабатываем переменную на лету:

// imagine (a) is an incomming variable that 
    // we can't change or else we will break something 

    var a = "carrots"; 

    // and then use "a.substr(0,a.length-1);" everywhere 

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

Какой из вас выбрать и почему?

Answer 1

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

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

Кстати, концепция хранения и кеширования значений в ECMAscript очень часто используется и правильно (по разным причинам, таким как отказ от цепей областей и поиск прототипов).

Answer 2

Я согласен с jAndy.

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

Итак, в первом примере вы вызовете a.substr (0, a.length-1) и кешируете результат, который будет использоваться. В примере два это займет n раз, где n - количество раз, когда вы вызываете a.substr (0, a.length-1).

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

Кроме того, как следует из комментариев к ответу jAndy, это лучший код, поскольку вам не нужно повторять вызов a.substr (0, a.length-1), поскольку вы можете просто кэшировать его.

Answer 3

Согласен с jAndy. Я просто хотел добавить пример и, надеюсь, дать еще один пример.

Первый подход намного быстрее.

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

Подумайте об этом таким образом. Вы могли бы что-то сделать (это стоит того же количества, что и другой вариант, если сказать x) один раз, или сделать это x теоретически неограниченным временем. Вы смотрите на стоимость x против бесконечности.

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

Это имеет смысл?

Мы создаем наш var b и сохраняем его до тех пор, пока программа не будет закрыта (больше не требуется). Или мы можем создать переменную a.substring, но удалим ее, когда она больше не нужна. Технически в зависимости от того, как работает программа, у вас может быть меньше памяти, если вы сказали 100 из них в течение всего процесса. Однако используемая память незначительна, и сбор мусора не происходит достаточно часто (в обычных условиях), чтобы это действительно было правдой/релевантным.

Экономия памяти незначительна, а временная сложность сравнительно значительна.

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