Получение производительности с помощью того же кода?

Question

мне интересно, если

function pathJoin(uri,file){ 
    return url.format(
     url.parse(
      path.normalize(
       path.join(uri, file) 
      ).split(
       path.delimiter 
      ).join("/") 
     ) 
    ); 
} 

и

function pathJoin(uri,file){ 
    var joined_path = path.join(uri, file); 
    var normalized = path.normalize(joined_path); 
    var splitted = normalized.split(path.delimiter); 
    var joined = splitted.join("/"); 
    var parsed = url.parse(joined); 
    return url.format(parsed); 
} 

будет выполнять одинаково быстро. Нет ли штрафа за переключение из функции в функцию несколько раз?

Answer 1

Примечание: path.join уже возвращает нормализованный путь. Они имеют одинаковую производительность ... И не используйте jsperf для тестирования узлов узла.

КОД

var path = require ("path"); 
var url = require ("url"); 
var speedy = require ("speedy"); 

function pathJoin(uri,file){ 
    return url.format(
     url.parse(
      path.normalize(
       path.join(uri, file) 
      ).split(
       path.delimiter 
      ).join("/") 
     ) 
    ); 
} 

function pathJoin2(uri,file){ 
    var joined_path = path.join(uri, file); 
    var normalized = path.normalize(joined_path); 
    var splitted = normalized.split(path.delimiter); 
    var joined = splitted.join("/"); 
    var parsed = url.parse(joined); 
    return url.format(parsed); 
} 

speedy.timeout (20000); 
speedy.run ({ 
    "1": function(){ 
     pathJoin ("http://www.google.com", "file"); 
    }, 
    "2": function(){ 
     pathJoin2 ("http://www.google.com", "file"); 
    } 
}) 

РЕЗУЛЬТАТ

File: t.js 

Node v0.10.20 
V8 v3.14.5.9 
Speedy v0.0.8 

Benchmarks: 2 
Timeout: 20000ms (20s 0ms) 
Samples: 3 
Total time per benchmark: ~60000ms (1m 0s 0ms) 
Total time: ~120000ms (2m 0s 0ms) 

Higher is better (ops/sec) 

1 
    50,931 ± 0.1% 
2 
    51,029 ± 0.1% 

Elapsed time: 120063ms (2m 0s 63ms) 

Answer 2

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

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

function a(arg) { 
    return typeof arg === "string"; 
} 

function b(arg) { 
    var tmp = typeof arg; 
    return tmp === "string"; 
} 

Последняя будет фактически LookUp строку типа для переменной, а затем сравнить строку "string" - вместо того, чтобы проверить, если arg является строка это то, что код семантически делает. Проверьте, насколько радикально отличается сгенерированный код для функций: http://pastebin.com/h7PsV39p

Это также смешно, потому что люди оптимизируются с помощью «кеширования типа», в процессе чего они делают его намного медленнее, потому что V8 распознает только полные uncached выражения типа.