◆ 特に変わらない
◆ 条件演算子で一つの式がかなーり大きくなる場合はわずかに if 文のほうが早い

if と条件演算子ってどっちがパフォーマンスいいの?

なんとなくそう思ったので試してみました
もちろん JavaScript で です (ついでに Chrome だけです)

まずは 条件演算子の方
20回実行してかかった msec を配列で出力してます
計算に意味はありません
本当にテキトーです
絶対 true になる条件とかあるかもしれません
Array.from(Array(20), _ => {
var s = Date.now()

var h = false
for(var i=0;i<1000000;i++){
var j = i % 2 ? i/10 : i%10
var k = j + i > 10 ? true : false
var l = k ? j : i
var m = l < i ? i + i : i
var n = i % 100 === 0 ? i * i : i
var o = j & 1 === n & 1 ? 3 : 2
var p = o - l > 100
? k
? m + n
: j + k
: !k
? n % 2
: n % 3
h = p & 1 ? true : false
}

var e = Date.now()
return (e - s)
})

次にこれを if 文にしたもの
Array.from(Array(20), _ => {
var s = Date.now()

var h = false
for(var i=0;i<1000000;i++){
var j,k,l,m,n,o,p
if(i % 2){
j = i/10
}else{
j = i%10
}
if(j + i > 10){
k = true
}else{
k = false
}
if(k){
l = j
}else{
l = i
}
if(l < i){
m = i + i
}else{
m = i
}
if(i % 100 === 0){
n = i * i
}else{
n = i
}
if(j & 1 === n & 1){
o = 3
}else{
o = 2
}
if(o - l > 100){
if(k){
p = m + nk
}else{
p = j + k
}
}else{
if(!k){
p = n % 2
}else{
p = n % 3
}
}
if(p & 1){
h = true
}else{
h = false
}
}

var e = Date.now()
return (e - s)
})
// 条件演算子
[139, 126, 128, 128, 126, 127, 126, 127, 128, 126, 125, 127, 127, 128, 130, 128, 126, 126, 126, 127]

// if 文
[141, 126, 128, 126, 128, 126, 127, 126, 129, 127, 126, 125, 127, 127, 125, 125, 128, 127, 126, 126]

ほぼ一緒です

式と文なので違うのかなと思いましたが大差ないようでした
ただコードを見比べると if 文は長いし 同じ変数への代入が 2 箇所に別れていてあんまり好きじゃないです

速度に違いがないなら 基本はやっぱり 条件演算子かな




最後の方のネストしてるのを見てかなーりネストさせたらどうなるの?っと思ったので次はネストが深いものです

[条件演算子]
Array.from(Array(20), _ => {
var s = Date.now()

var t = 0
for(var i=0;i<10000000;i++){
t += i % 2
? i % 3
? i % 4
? i % 5
? i % 6
? 1100
: 1200
: i % 6
? 1300
: 1400
: i % 5
? i % 6
? 1500
: 1600
: i % 6
? 1700
: 1800
: i % 4
? i % 5
? i % 6
? 2100
: 2200
: i % 6
? 2300
: 2400
: i % 5
? i % 6
? 2500
: 2600
: i % 6
? 2700
: 2800
: i % 3
? i % 4
? i % 5
? i % 6
? 3100
: 3200
: i % 6
? 3300
: 3400
: i % 5
? i % 6
? 3500
: 3600
: i % 6
? 3700
: 3800
: i % 4
? i % 5
? i % 6
? 4100
: 4200
: i % 6
? 4300
: 4400
: i % 5
? i % 6
? 4500
: 4600
: i % 6
? 4700
: 4800
}

var e = Date.now()

return e - s
})

[if 文]
Array.from(Array(20), _ => {
var s = Date.now()

var t = 0
for(var i=0;i<10000000;i++){
if(i % 2){
if(i % 3){
if(i % 4){
if(i % 5){
if(i % 6){
t += 1100
}else{
t += 1200
}
}else{
if(i % 6){
t += 1300
}else{
t += 1400
}
}
}else{
if(i % 5){
if(i % 6){
t += 1500
}else{
t += 1600
}
}else{
if(i % 6){
t += 1700
}else{
t += 1800
}
}
}
}else{
if(i % 4){
if(i % 5){
if(i % 6){
t += 2100
}else{
t += 2200
}
}else{
if(i % 6){
t += 2300
}else{
t += 2400
}
}
}else{
if(i % 5){
if(i % 6){
t += 2500
}else{
t += 2600
}
}else{
if(i % 6){
t += 2700
}else{
t += 2800
}
}
}
}
}else{
if(i % 3){
if(i % 4){
if(i % 5){
if(i % 6){
t += 3100
}else{
t += 3200
}
}else{
if(i % 6){
t += 3300
}else{
t += 3400
}
}
}else{
if(i % 5){
if(i % 6){
t += 3500
}else{
t += 3600
}
}else{
if(i % 6){
t += 3700
}else{
t += 3800
}
}
}
}else{
if(i % 4){
if(i % 5){
if(i % 6){
t += 4100
}else{
t += 4200
}
}else{
if(i % 6){
t += 4300
}else{
t += 4400
}
}
}else{
if(i % 5){
if(i % 6){
t += 4500
}else{
t += 4600
}
}else{
if(i % 6){
t += 4700
}else{
t += 4800
}
}
}
}
}
}

var e = Date.now()

return e - s
})

どっちも見やすいとは言えない複雑さになりました
条件演算子が ? と : じゃなくて もっと見やすい記号やキーワードなら見やすかったかも

さて結果ですが
// 条件演算子
[85, 74, 73, 73, 73, 73, 73, 75, 73, 74, 73, 74, 74, 75, 74, 72, 75, 73, 73, 75]

// if 文
[78, 68, 68, 67, 67, 67, 67, 68, 67, 66, 66, 67, 67, 67, 67, 68, 67, 66, 67, 67]

わずかですが if 文のほうが早いです

条件演算子は式なので評価しなくていいところも含めて読み取らないといけなくて if 文は文だから使わなかったところは見なくていいから 短い文数個だけで済んだから ということでしょうか

あまりネストしすぎるなら if 文のほうがいいかも
って思いましたが ここまでネストしてるのを 1000 万回実行して 10msec も差がないなら無視していいともいえます


ところでどれも 2 回目以降が早くなっていて 1 回目(配列の 1 番目)だけちょっと遅いですよね
2回目は最適化済みだから安定してるみたいです

こういうのがあるのでブラウザでの速度計測って難しいですよね
もちろんあるコト自体はいいことなんですけどね