2019年の後半。いま、高速で生産性の高い開発言語はなに？！旬の言語 C++, C#, Javascript, Python で比較してみた！


# はじめに

みなさんこんにちは。[ハーツテクノロジー]の James です。この記事は業務の中で得られた知見から書かれています。

[ハーツテクノロジー]:https://www.hearts-tech.co.jp/


この記事の目的は、開発言語別の実行速度と、おおざっぱな行数（ステップ数）を把握するのが目的です。以下の４種類の言語で、同じアルゴリズムを実装し、その実行速度とコード行数を測ります。今回、調べたかった開発言語は以下の５つです。

 - C++ / Visual Studio 2019
 - C++ / MinGW(v8.1.0)
 - Javascript / node.js(v10.16.3)
 - C# / Visual Studio 2019
 - Python / Python(v3.7.5)



# C++, C#, Javascript, Python の実行速度の計測

計測に使うアルゴリズムには「[ライプニッツの公式]を使って円周率を求める」を選びました。短いコードですが、それなりにCPUを酷使するので目的は達成できると考えています。

[ライプニッツの公式]:https://ja.wikipedia.org/wiki/%E3%83%A9%E3%82%A4%E3%83%97%E3%83%8B%E3%83%83%E3%83%84%E3%81%AE%E5%85%AC%E5%BC%8F


結果的に、コードは３パターン作成し、計測しました。

- A, わたし(James)が書いた、小数点以下100桁で計算するコード
- B, 先輩の山崎さんがリファクタリングした、小数点以下20桁で計算するコード
- C, 同僚のOさんが書いたシンプルにdoubleのみで計算するコードをさらに山崎さんがリファクタリングしたコード

どれも、[ライプニッツの公式]を使って円周率を計算するコードです。


# パターンA わたし(James)が書いた、小数点以下100桁で計算するコード

## コードの解説

小数点以下100桁までを、1e8 回繰り返し計算します。

小数点以下100桁まで計算のため`pi`(π)と`val`(加減する値(1-1/3+1/5-1/7+1/9-⋯))を使います。小数点以下の桁数は設定できます。

- **例）1/3(pi も val と同じ大きさ100桁のint)**

|int val[]|[0]|[1]|[2]|[3]|[4]|…|[98]|[99]|[100]|
|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
|数|0|3|3|3|3|…|3|3|3|

1/3と同じ感じの無限小数をvalで保存して、一度は加算(+)一度は減算(-)と繰り返します。piとvalを加減算と同時に一番後から数の上げと下りを計算します。

- **int配列使うの理由**

double 型は小数点以下15桁の精度まで計算と表記ができますが、今回はもっと多い桁数を計算して表記したかったので int 配列を作成しました。


## コード

### A-1. **C++**(計算時間: VS2019-278.973秒, MinGW-165.098秒)

```cpp:Leibniz_J.cpp
#include <iostream>
#include <time.h>
#include <cstring>
using namespace std;

#define MAX 101 //小数点以下
int pi[MAX] = { 0 };
int val[MAX] = { 0 };

void val_def(int* q) //calculate val, ‘4/q’を小数点MAXまで計算
{
	int start = 4;
	for (int i = 0; i < MAX; i++) 
	{
		val[i] = start / *q;
		start = (start % *q) * 10;
	}
}
void cal() //calculate pi
{
	int p = -1, q = 1, num = 1;
	while (num <= 1e8) //pi = 4 * (1/1 - 1/3 + 1/5 -  ~ 1/(1e8*2-1))
	{
		val_def(&q);
		p *= -1;
		for (int i = MAX - 1; i >= 0; i--)
		{
			if (p == -1 && pi[i] < val[i])//pi[i]-val[i]時val[i]がpiより高い
			{
				pi[i - 1]--; //piの高桁からpi[i]+10
				pi[i] += 10;
				pi[i] += p * val[i];
			}
			else
				pi[i] += p * val[i];

			if (pi[i] >= 10)//(pi[i] >= 10)時に高桁に数を増加
			{
				pi[i - 1] += pi[i] / 10;
				pi[i] %= 10;
			}
		}
		q += 2;
		num++;
		memset(val, 0, MAX);
	}
}
void print_pi()
{
	printf("%d.", pi[0]);
	for (int i = 1; i < MAX; i++)
	{
		printf("%d", pi[i]);
		if (i % 10 == 0)
			printf("  ");
		if (i % 50 == 0)
			printf("\n  ");
	}
}

int main(void)
{
	double result = 0;

    printf("start\n");
    clock_t begin, end;
    begin = clock();
    cal();
    end = clock();
    print_pi(); //use if you want to see 0 ~ MAX PI value

    result += (double)(end - begin);
    printf("\n");
    printf(" %f sec(not include print time.)", result / CLOCKS_PER_SEC);
}
```



![c++ 1e8.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/8caca40d-15bd-0a06-ff2c-5574b4906f80.png)





### A-2. **C#**(計算時間: 458.992秒)

```c#:Leibniz_J.cs
using System;

namespace leibniz
{
    class func
    {
        static int MAX = 101; //小数点以下 100まで
        int[] pi = new int[MAX];
        int[] val = new int[MAX];
        public void val_def(int q)
        {
            int start = 4;
            for (int i = 0; i < MAX; i++)
            {
                val[i] = start / q;
                start = (start % q) * 10;
            }
        }
        public void cal()
        {
            int p = -1, q = 1, num = 1;
            while (num <= 1e8) //pi = 4 * (1/1 - 1/3 + 1/5 -  ~ 1/(1e8*2-1))
            {
                val_def(q);
                p *= -1;
                for (int i = MAX - 1; i >= 0; i--)
                {
                    if (p == -1 && pi[i] < val[i])
                    {
                        pi[i - 1]--;
                        pi[i] += 10;
                        pi[i] += p * val[i];
                    }
                    else
                        pi[i] += p * val[i];

                    if (pi[i] >= 10)
                    {
                        pi[i - 1] += pi[i] / 10;
                        pi[i] %= 10;
                    }
                }
                q += 2;
                num++;
                Array.Clear(val, 0, MAX);
            }
        }
        
        public void print()
        {
            Console.Write(pi[0] + ".");
            for (int i = 1; i < MAX; i++)
            {
                Console.Write(pi[i]);
                if (i % 10 == 0)
                    Console.Write("  ");
                if (i % 50 == 0)
                    Console.Write("\n  ");
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            double result = 0;
            DateTime begin, end;

            begin = DateTime.Now;
            func _func = new func();
            _func.cal();
            end = DateTime.Now;
            result += end.Subtract(begin).TotalSeconds;
            _func.print(); //use if you want to see 0 ~ MAX PI value
            Console.WriteLine("\n " + end.Subtract(begin).TotalSeconds + " sec");
        }
    }
}
```



![c#1e8.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/3e493a86-4b73-c855-a281-def2f7c85e75.png)





### A-3. **JavaScript**(計算時間: 456.066秒)

```javascript:Leibniz_J.js
let MAX = 101; ////小数点以下 100まで
let pi = Array.apply(null,new Array(MAX)).map(Number.prototype.valueOf,0);
let val = Array.apply(null,new Array(MAX)).map(Number.prototype.valueOf,0);
let begin = new Date().getTime();
let result = 0;

function val_def(q){
    let start = 4;
    for (let i = 0; i < MAX; i++){
        val[i] = Math.floor(start / q);
        start = (start % q) * 10;
    }
}

function cal(){
    let p = -1, q = 1, num = 1;
    while (num <= 1e8) { //pi = 4 * (1/1 - 1/3 + 1/5 -  ~ 1/(1e8*2-1))
        val_def(q);
        p *= -1;
        for (let i = MAX - 1; i >= 0; i--){
            if (p == -1 && pi[i] < val[i]) {
                pi[i - 1]--;
                pi[i] += 10;
                pi[i] += p * val[i];
            }
            else
                pi[i] += p * val[i];

            if (pi[i] >= 10) {
                pi[i - 1] += parseInt(pi[i] / 10);
                pi[i] %= 10;
            }
        }  
        q += 2;
        num++;
        val = [];
    }
}

function print(){
    process.stdout.write(`${pi[0]}.`);
    for (let i = 1; i < MAX; i++){
        process.stdout.write(`${pi[i]}`);
        if (i % 10 == 0)
            process.stdout.write("   ");
        if (i % 50 == 0)
            process.stdout.write("\n  ");
    }
}

cal();
let end = new Date().getTime();
print(); //use if you want to see 0 ~ MAX PI value
result = (end-begin)/1000;

console.log(`\n${(end-begin)/1000} sec`);

```




![js 1e8.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/51ca866a-4c99-aad5-bc8d-ea7a7bf4c9c2.png)





### A-4. **Python**(計算時間: 1148.174秒)

```python:Leibniz_J.py
import time

MAX = 11 #遅いため小数点以下 10まで
pi = [0] * MAX
val = [0] * MAX

def cal():
    global pi
    global val
    p = -1
    q = 1
    num = 1
    while num <= 1e8:    #pi = 4 * (1/1 - 1/3 + 1/5 -  ~ 1/(1e8*2-1))
        val_def(q)
        val = list(reversed(val))
        p *= -1
        for index,i in enumerate(pi):
            if p == -1 and pi[index] < val[index]:
                pi[index + 1] -= 1
                pi[index] += 10
                pi[index] += p * val[index]
            else:
                pi[index] += p * val[index]

            if i >= 10:
                pi[index + 1] += pi[index] // 10
                pi[index] %= 10
        q += 2
        num += 1
        val = [0] * MAX
    pi = list(reversed(pi));

def val_def(q):
    global val
    start = 4
    for index,i in enumerate(val):
        val[index] = start // q
        start = (start % q)*10

def print_pi():
    global pi
    print("%d." % pi[0],end="")
    for index,i in enumerate(pi):
        if index == 0:
            continue
        print(i,end="");
        if (index % 10) == 0:
            print(" ",end="")
        if (index % 50) == 0:
            print("  ")
    print("")

if __name__ == '__main__':
    print("start")
    begin = time.time()
    cal()
    end = time.time()
    print_pi()
    print(end - begin," sec")
```



![python 1e8.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/523527bf-2833-757d-7f35-cc9728511c09.png)


# パターンB, 先輩の「山崎さん」がリファクタリングした、小数点以下20桁で計算するコード

## コードの解説

小数点以下20桁までを、分母が 1e9 になるまで繰り返し計算します。


## コード
### B-1. **C++**(計算時間: VS2019-216.595秒, MinGW-134.391秒)

```cpp:Leibniz_Y.cpp
#include <stdio.h>  // printf()
#include <time.h>   // clock()

#define MAX 21 //小数点以下 20桁
int pi[MAX] = { 0 };

void pi_add( long long  _q, int _a=1 )
{
    long long start = 4;        // _q は 1e9 まで来る想定なので long 32bit では足りない
    for ( int i=0; i<MAX; i++ )
    {
        pi[i] += (start / _q) * _a;
        start = (start % _q) * 10;
    }
}

int main()
{
    printf( "start\n" );
    auto begin = clock();    // 実行時間を計測

    for ( long long q=1; q<=1e9 ; ) // pi = 4/1 - 4/3 + 4/5 - 4/7 + ... 4/1e9
    {
        pi_add( q ); // 加算
        q += 2;

        pi_add( q, -1 );  // 減算
        q += 2;
    }

    // 計算のあと、各桁を 0 - 9 の範囲に調整する
    for ( int i=MAX-1; i>0; i-- )   // 0以下の値は、上の桁から拝借してくる
    {
        for ( ; pi[i] < 0 ; ) {
            pi[i-1] -= 1;
            pi[i]   += 10;
        }
    }
    for ( int i=MAX-1; i>0; i-- )   // 10以上の値は、上の桁に送る
    {
        if ( pi[i] >= 10 ) {
            pi[i-1] += pi[i] / 10 ;
            pi[i]   %= 10 ;
        }
    }

    // 表示
    printf( "%d.", pi[0]);
    for ( int i = 1; i < MAX; i++)
    {
        printf( "%d", pi[i] );
        if ( i % 10 == 0 ) printf( "  " );
    }
    printf( "\n" );

    printf( " %f sec.", (double)(clock() - begin) / CLOCKS_PER_SEC );    // 実行時間を表示

    return 0 ;
}
```

![1029 cpp o2.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/3bb6e816-d124-5c63-0348-c0ccd3b30720.png)



### B-2. **C#**(計算時間: 287.459秒)

```c#:Leibniz_Y.cs
using System;

namespace leibniz
{
   class Program
   {
       static int MAX = 21;
       static int[] pi = new int[MAX];

       static void pi_add(long _q, int _a = 1)
       {
           long start = 4;
           for (int i = 0; i < MAX; i++)
           {
               pi[i] += (int)(start / _q) * _a;
               start = (start % _q) * 10;
           }
       }

       static void Main(string[] args)
       {
           Console.WriteLine("start");
           DateTime begin = DateTime.Now;

           for (long q = 1; q <= 1e9;)// pi = 4/1 - 4/3 + 4/5 - 4/7 + ... 4/1e9
           {
               pi_add(q);
               q += 2;

               pi_add(q, -1);
               q += 2;
           }

           for (int i = MAX - 1; i > 0; i--)   // 0以下の値は、上の桁から拝借してくる
           {
               for (; pi[i] < 0;)
               {
                   pi[i - 1] -= 1;
                   pi[i] += 10;
               }
           }
           for (int i = MAX - 1; i > 0; i--)   // 10以上の値は、上の桁に送る
           {
               if (pi[i] >= 10)
               {
                   pi[i - 1] += pi[i] / 10;
                   pi[i] %= 10;
               }
           }

           Console.Write(pi[0] + ".");
           for (int i = 1; i < MAX; i++)
           {
               Console.Write(pi[i]);
               if (i % 10 == 0)
                   Console.Write("  ");
               if (i % 50 == 0)
                   Console.Write("\n  ");
           }
           Console.WriteLine("\n{0} sec.", DateTime.Now.Subtract(begin).TotalMilliseconds / 1000); //時間表示
       }
   }
}
```

![1028 c# 1e9.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/46d809bb-8429-4060-d562-6eaccbc7d3ac.png)


### B-3. **JavaScript**(計算時間: 123.56秒)

```javascript:Leibniz_Y.js
console.log( 'start' )
const begin = Date.now()    // 実行時間を計測

const MAX = 21 // 小数点以下 20桁
var pi = Array( MAX ).fill( 0 )

function pi_add( _q, _a=1 ) // 加算
{
    let start = 4
    for ( let i=0; i<MAX; i++ )
    {
        pi[i] += Math.floor( start / _q ) * _a
        start = ( start % _q ) * 10
    }
}

for ( let q=1; q<=1e9 ; ) // pi = 4/1 - 4/3 + 4/5 - 4/7 + ... 4/1e9
{
    pi_add( q ) // 加算
    q += 2

    pi_add( q, -1 )  // 減算
    q += 2
}

// 計算のあと、各桁を 0 - 9 の範囲に調整する
for ( let i=MAX-1; i>0; i-- )   // 0以下の値は、上の桁から拝借してくる
{
    for ( ; pi[i] < 0 ; )
    {
        pi[i-1] -= 1
        pi[i]   += 10
    }
}
for ( let i=MAX-1; i>0; i-- )   // 10以上の値は、上の桁に送る
{
    if ( pi[i] >= 10 ) {
        pi[i-1] += parseInt( pi[i] / 10 )
        pi[i]   %= 10
    }
}

// 表示
var r = `${pi[0]}.`
for ( let i=1; i<MAX; i++ )
{
    r += `${pi[i]}` + ( (i % 10 == 0) ? '  ' : '' )
}
console.log( r )

console.log( `${ ( Date.now() - begin ) / 1000 } sec.` )    // 実行時間を表示
```

![1028 js 1e9.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/d50b0fd6-47fa-ce81-a298-0cff5465359c.png)



### B-4. **Python**(計算時間: 3722.021秒)

```Python:Leibniz_Y.py
import time

print( "start" )
begin = time.time() # 実行時間を計測

MAX = 21 # 小数点以下 20桁
pi  = [0] * MAX

def pi_add( q, a=1 ):
    start = 4
    for i in range( 0, MAX ) :
        pi[i] += start // q * a
        start = (start % q) * 10

q = 1
while q <= 1e9:     # pi = 4/1 - 4/3 + 4/5 - 4/7 + ... 4/1e9
    pi_add( q )     # 加算
    q += 2
    pi_add( q, -1 ) # 減算
    q += 2

# 計算のあと、各桁を 0 - 9 の範囲に調整する
for i in range( MAX-1, 0, -1 ) :   # 0以下の値は、上の桁から拝借してくる
    while pi[i] < 0 :
        pi[i-1] -= 1
        pi[i]   += 10

for i in range( MAX-1, 0, -1 ) :  # 10以上の値は、上の桁に送る
    if pi[i] >= 10 :
        pi[i-1] += pi[i] // 10
        pi[i]   %= 10

# 表示
print( "%d." % pi[0], end="" )
for i in range( 1, MAX ) :
    print( pi[i], end="" )
    if ( i % 10 ) == 0 :
        print( "  ", end="" )
print( "" )

print( time.time() - begin, " sec." )    # 実行時間を表示
```

![1025 py 1e9.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/3aca9788-33f3-a3a5-4fd0-84099c3d9299.png)


# パターンC, 同僚の「Oさん」が書いたシンプルにdoubleのみで計算するコードをさらに山崎さんがリファクタリングしたコード

3回(小数点以下double(15)まで、1e9まで計算)
## コード
### C-1. **C++**(計算時間: VS2019-2.6秒, MinGW-0.608秒)

```cpp:Leibniz_O.cpp
#include <stdio.h>  // printf()
#include <time.h>   // clock()

int main()
{
    printf( "start\n" );
    auto begin = clock();    // 実行時間を計測

    double l = 0.0;

    for ( double n=1; n<1e9; ) // l = 1/1 - 1/3 + 1/5 - 1/7 + ... 1/1e9
    {
        l += 1.0 / n ;
        n += 2 ;
        l -= 1.0 / n ;
        n += 2 ;
    }

    printf( "%1.16f\n", l * 4 );

    printf( " %f sec.", (double)(clock() - begin) / CLOCKS_PER_SEC );    // 実行時間を表示

    return 0;
}
```

![1029 cpp o2 short.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/42eade7d-a496-7dcb-258b-609d54e96827.png)




### C-2. **C#**(計算時間: 1.847秒)

```c#:Leibniz_O.cs
using System;

namespace Leibniz
{
    class Program
    {
        public static void Main()
        {
            System.Console.WriteLine("start");
            System.DateTime begin = System.DateTime.Now; // 実行時間を計測
            double l = 0.0;

            for (double n = 1; n < 1e9;) // l = 1/1 - 1/3 + 1/5 - 1/7 + ... 1/1e9
            {
                l += 1.0 / n;
                n += 2;
                l -= 1.0 / n;
                n += 2;
            }

            System.Console.WriteLine(l * 4);
            System.Console.WriteLine("{0} sec", System.DateTime.Now.Subtract(begin).TotalMilliseconds / 1000);
        }
    }
}
```

![1028 cs short code.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/4129e14a-bee1-a1e2-93fc-8248d722fc13.png)


### C-3. **JavaScript**(計算時間: 0.756秒)

```javascript:Leibniz_O.js
console.log( 'start' )
const begin = Date.now()    // 実行時間を計測

var l = 0.0
for ( let n=1; n<1e9; )     // l = 1/1 - 1/3 + 1/5 - 1/7 + ... 1/1e9
{
    l += 1.0 / n
    n += 2
    l -= 1.0 / n
    n += 2
}

console.log( l * 4 )

console.log( `${ ( Date.now() - begin ) / 1000 } sec.` )    // 実行時間を表示
```

![1029 js short.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/ab9b03e7-a13f-04fd-8435-3452f875e2c5.png)



### C-4. **Python**(計算時間: 121.914秒)

```python:Leibniz_O.py
import time

print( "start" )
begin = time.time() # 実行時間を計測

l = 0.0
n = 1
while n<1e9 :       # l = 1/1 - 1/3 + 1/5 - 1/7 + ... 1/1e9
    l += 1.0 / n
    n += 2
    l -= 1.0 / n
    n += 2

print( l * 4 )

print( time.time() - begin, " sec." )    # 実行時間を表示

```

![1028 py short code.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/f28e9e39-e4bf-083c-dbb0-7acfcbd3cd32.png)

# 結果

## 実行環境

 - CPU : Intel Core i7-7500U 2.70GHZ
 - RAM : 8 GB
 - SSD : 250 GB
 - OS : Windows 10 Pro



## 実行速度(秒)

| code | VS2019/C++ | MinGW/C++ | node.js/Javascript| VS2019/C# |Python |
|:---:|---:|---:|---:|---:|---:|
| A | 278.973| 165.098 | 456.066| 458.992| 1148.174|
| B | 216.595| 134.391| 123.56 | 287.459| 3722.021|
| C | 2.6|   0.608|   0.756|   1.847|  121.914|

![graph1.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/3b322efa-c2ce-d209-3027-312b7c0151e7.png)



やはり C++ がよい成績を出しました。でも、2番目に Javascript が速いです。これは予想外。。。Python は3位のC#より3倍以上、最大で約100倍遅いです。


![graph2.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/1f7f9460-6a45-0eaf-6e14-03d97d65b436.png)


追加で、MinGW と Visual Studio の速度の違いも意味があると思います。どちらも「O2」最適化オプションで計測しました。

### コード量（行数）

コード量はコメント業も空白行も含む純粋な行数です。好みの書き方に左右されるので、あくまでも参考値です。

| code | C++ | Javascript| C# | Python |
|:---:|---:|---:|---:|---:|---:|
| A | 75 | 56 | 78 | 59 |
| B | 59 | 51 | 63 | 41 |
| C | 24 | 15 | 25 | 16 |


![graph-length.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/636be71c-ef5b-5fc5-ec02-906afef9e260.png)




コード量は C++, C# が長めで Python, Javascript 短めに思います。

３つとも Javascript と Python は長さ面で似ていましたが、速度面では反対の感じに結果がでました。


### 総評

この計測の前に g++(C++ compiler) で「-O2」オプションを使わずに計測しました。その計測のときにはJavascriptが速度面で1位でした。

でも最適化オプション「-O2」を使ったあとで結果が変わりました。

しかし速度だけでなくコード量を一緒に見れば Javascript が合理的な言語だと思いました。


# 追加テスト

ABC、３つの中で１つ（B,山崎さんのコード）だけ Javascriptが速い結果が出ました。それもなぜJavascriptが速いかが解決してないので簡単なテストをしました。
ループの速度が違うのでループを1回は1e5反復,2回は1e6反復して5回1e9までテストしました。(オプションで -O2使う)

### ループ速度

#### コード
- C++

```cpp:test.cpp

#include <iostream>
#include <time.h>

int main(void)
{
	int i = 0;
	double val = 1e5; //ループ 回数
	while (i < 5)
	{
        double a = 0;//これのtypeを変える
        int j = 0;
        double result = 0.0;
        while(j < 5)
        {
            a = 0;
            auto begin = clock();
            for (int q = 1; q <= val; q++)//これのtypeを変える
            {
                a++;
            }
            result += clock() - begin;
            j++;
        }
        printf("long long q ~ 10^%d, double a = %10.0f: %.3f sec \n", i + 5, a, (result / 5) / CLOCKS_PER_SEC);
        i++;
		val *= 10; //ループ 回数増加(i=0:1e5, i=1:1e6, i=2:1e7, i=3:1e8, i=4:1e9)
	}
    return 0;
}
```


|MinGW(double a)|MinGW(int a)|
|---|---|
|![double a-MinGW.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/9814f0cf-c6df-d6f1-19c8-ef9307ffa9f4.png)|![int a-MinGW.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/5af52829-cefa-b593-47f4-41f610078c90.png)


|VS2019(double a)|VS2019(int a)|
|---|---|
|![double a.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/7d492f5f-0f9e-db69-27dd-a6c827976ca4.png)|![int a.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/0b8321d5-2b7a-159f-bbc4-10596588d732.png)







- Javascript

```javascript:test.js

let i = 0
let val = 1e5 //ループ 回数
while (i < 5)
{
    let a = 0
    let j = 0
    let result = 0.0
    while (j < 5)
    {
        a = 0;
        let begin = Date.now()
        for (let q = 1; q <= val; q++)
        {
            a++
        }
        result += Date.now() - begin
        j++
    }

    console.log(`10^${i+5}: ${((result/5) / 1000).toFixed(3)} sec, a = ${a}`)
    i++
    val *= 10 //ループ 回数増加(i=0:1e5, i=1:1e6, i=2:1e7, i=3:1e8, i=4:1e9)
}
```

![javascript.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/9a1949b1-f52a-758f-5d82-168658289f7e.png)



#### 結果

10^9反復する場合だけ結果を整理します。(単位: 秒)

||int q|double q|long long q
|:---:|:---:|:---:|:---:|
|MinGW - int a|0.791|1.182|0.622
|MinGW - double a|1.166|1.192|1.188
|VS2019 - int a|4.188|1.374|4.332
|VS2019 - double a|4.855|1.365|5.582
|Javascript - type関係ない|1.019|-|-


![10^9.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/515827/0e1c4f41-6556-d165-f27d-329f076f06bb.png)



総合的にVS2019はループカウント(q)のデータタイプがdouble時には一番速かったけどそれも10^7からはJavascriptより遅くなりました。
でもMinGWはdoubleを使う時だけ(aかqかは関係ない)10^7からJavascriptより遅くなりましたが、doubleを使用しない時(aとq全体)にはJavascriptより全体の場合で速くなりました。
VS2019がループカウント(q)をdoubleで使う時だけMinGWと同じ実行時間が出ましたが、intとlong longを使う時にはVS2019がMinGWより3~4倍ぐらい遅くなりました。

# まとめ
まだ結果について明快な解答がありません。でも個人的にJavascriptが結構いい言語ということを知りました。

このあと Python がどこまで発展するかまだわからないが、今は速度が必要で、資金など資源が不足ぎみなら C++ より Javascript を使うのもいいと思いました。

みなさまのご意見もお聞かせください。よろしくお願いいたします。