for(var i=0; i<100; i++){
  }

for(auto &&obj: objects) {
    obj.update();
}

void Object::update() {
    if(this->shouldUpdate()) {
        // updateの内容
    }
}
for(auto &&obj: objects) {
    obj.update();
}

void Object::update() {
    // updateの内容
}
for(auto &&obj: objects) {
    if(obj.shouldUpdate()) {
        obj.update();
    }
}

inline bool Object::shouldUpdate() {
    return is_awake;
}

std::vector<Object*> objects;
for(auto &&obj: objects) {
    obj->update();
}

std::vector<Object> objects;
for(auto &&obj: objects) {
    obj.update();
}

ObjectArray awakeObjects, sleepObjects;

void update() {
    for(auto &&obj: awakeObjects) {
        obj.update();
    }
}
void sleep(Object &obj) {
    awakeObjects.remove(obj);
    sleepObjects.add(obj);
}
void awake(Object &obj) {
    awakeObjects.add(obj);
    sleepObjects.remove(obj);
}

std::vector<Object> objects;
for(int i = 0; i < objects.size(); i++) {
    objects[i].update();
}

for(std::size_t i = 0; i < objects.size(); ++i) {}
for(auto it = std::begin(objects); it != std::end(objects); ++it) {}

for(std::size_t i = 0, end = objects.size(); i < end ++i) {}
for(auto it = std::begin(objects), end = std::end(objects); it != end; ++it) {}

for(int y = 0; y < image.getHeight(); ++y) {
    for(int x = 0; x < image.getWidth(); ++x) {
    }
}

int w = image.getWidth();
int h = image.getHeight();
for(int y = 0; y < h; ++y) {
    for(int x = 0; x < w; ++x) {
    }
}

for(std::size_t i = 0, end = objects.size(); i < num; i += 4) {
    objects[i].update();
    objects[i+1].update();
    objects[i+2].update();
    objects[i+3].update();
}

static std::size_t counter = 0;
const std::size_t skip_length = 4;
for(std::size_t i = counter%skip_length, end = objects.size(); i < end; i += skip_length) {
    object[i].update();
}
++counter;

<?php
$i = 0;
while($i < 10){
    echo $i;
    $i ++;
}
// => 0123456789

<?php
$i = 0;
do{
    echo $i;
    $i++;
}while($i < 10);
// => 0123456789

<?php
$i = 0;
while($i < 10){
    echo $i;
    $i ++;
}
// => （表示されない）

<?php
$i = 100;
do{
    echo $i;
    $i++;
}while($i < 10);
// => 100

include<iostream>
using namespace std;

typedef long long LL;

//ここからメイン
int main(void) {
    LL i, j, k, n, m;

    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            for (k = 0; k < 4; k++) {
                for (n = 0; n < 4; n++) {
                    for (m = 0; m < 4; m++) {
                        cout << i << j << k << n << m << endl;
                    }
                }
            }
        }
    }

    return 0;
}

#include<iostream>
#include<vector>
#include<string>

using namespace std;

typedef long long LL;
typedef vector<LL> VLL;


//n進数を管理するクラス
class N_Number {
public:
    N_Number(LL n, LL keta) {
        this->N_Shinsuu = n;

        VLL temp(keta, 0);
        this->numbers = temp;

    }

    //数を足す
    void plus(LL a) {
        this->numbers[0] += a;
        LL size = this->numbers.size();
        for (LL i = 0; i < size; i++) {
            if (i + 1 < size) {
                this->numbers[i + 1] += this->numbers[i] / this->N_Shinsuu;
            }
            this->numbers[i] %= this->N_Shinsuu;
        }
    }

    //全ての桁が同じ数字になっていればその数字を返す。それ以外の場合は -1 を返す
    LL check() {
        LL a = this->numbers[0];

        for (LL i = 0; i < this->numbers.size(); i++) {
            if (this->numbers[i] != a)return -1;
        }

        return a;
    }

    LL getNumber(LL keta) {
        return this->numbers[keta];
    }

    LL getKeta() {
        return this->numbers.size();
    }

    LL getShinsuu() {
        return this->N_Shinsuu;
    }

    void setNumber(LL keta, LL number) {
        if (0 <= number && number < this->getShinsuu()) {
            if (0 <= keta && keta < this->getKeta()) {
                this->numbers[keta] = number;
                return;
            }
        }

        cout << "er" << endl;
    }

    void setAllNumbers(LL number) {
        LL size = this->getKeta(), i;
        for (i = 0; i < size; i++) {
            this->setNumber(i, number);
        }
    }

private:
    VLL numbers;
    LL N_Shinsuu;
};

//ここからメイン
int main(void) {
    N_Number i(4, 5);

    while (true)
    {
        string s;
        for (LL j = i.getKeta() - 1; j >= 0; j--) {
            s += to_string(i.getNumber(j));
        }

        cout << s << endl;

        if (i.check() == i.getShinsuu() - 1)break;
        i.plus(1);
    }

    return 0;
}

#include<iostream>
#include<vector>
#include<string>

using namespace std;

typedef long long LL;
typedef vector<LL> VLL;

//再帰で繰り返しを行う
void ForCout(LL n, LL keta, VLL numbers) {
    if (numbers.size() == keta) {
        string s;
        for (LL i = 0; i < numbers.size(); i++) {
            s += to_string(numbers[i]);
        }
        cout << s << endl;
        return;
    }

    for (LL i = 0; i < n; i++) {
        VLL temp = numbers;
        temp.push_back(i);
        ForCout(n, keta, temp);
    }
}

//ここからメイン
int main(void) {

    VLL numbers;
    ForCout(4, 5, numbers);

    return 0;
}

<ul class="array_test">
  <li>item1</li>
  <li>item2</li>
  <li>item3</li>
  <li>item4</li>
  <li>item5</li>
</ul>

$('ul.array_test li').each(function(index, element){
  console.log(index + ':' + $(element).html());
});

0:item1
1:item2
2:item3
3:item4
4:item5

$('ul.array_test li').each(function(index, element){
  if(index == 3){
    return true;
  }
  console.log(index + ':' + $(element).html());
});

0:item1
1:item2
2:item3
4:item5

$('ul.array_test li').each(function(index, element){
  if(index == 3){
    return false;
  }
  console.log(index + ':' + $(element).html());
});

0:item1
1:item2
2:item3

String testData = new String[1000000];
for(Int32 i = 0, len = testData.Length; i < len; i++ )
{
    testData[i] = i.ToString();
}

System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Reset();
sw.Start();

/* ループ処理 */

sw.Stop();
/* ElapsedMilliseconds メンバから経過したミリ秒を取得 */
Int64 res = sw.ElapsedMilliseconds;

/* i < testData.Length の部分に注目 */
for (Int32 i = 0; i < testData.Length; i++)
{
    System.Console.WriteLine(testData[i]);
}

/* len = testData.Length の部分に注目 */
for (Int32 i = 0, len = testData.Length; i < len; i++)
{
    System.Console.WriteLine(testData[i]);
}

/* 後述するデクリメントとの差異を厳密にするため、キャッシュ方式を採用 */
for (Int32 i = 0, len = testData.Length; i < len; i++)
{
    System.Console.WriteLine(testData[i]);
}

/* 後述するデクリメントとの差異を厳密にするため、キャッシュ方式を採用 */
for (Int32 i = 0, len = testData.Length; i < len; --i)
{
    System.Console.WriteLine(testData[i]);
}

/* キャッシュしているようなものなので、
上記インクリメントもキャッシュ方式を採用しています */
for (Int32 i = testData.Length - 1; i >= 0; i--)
{
    System.Console.WriteLine(testData[i]);
}

/* キャッシュしているようなものなので、
上記インクリメントもキャッシュ方式を採用しています */
for (Int32 i = testData.Length - 1; i >= 0; --i)
{
    System.Console.WriteLine(testData[i]);
}

#パッケージリストの更新
apt-get update

#パッケージの更新
apt-get upgrade

#パッケージの再設定
dpkg --configure -a

#cinnamon-control-center-dataのインストール
apt-get install cinnamon-control-center-data

#gdm3のバージョン確認
gdm3 --version

#gdm3のインストール
apt-get --reinstall install gdm3

#gnomeのインストール
apt-get --reinstall install gnome

#gnome-shellのインストール
apt-get --reinstall install gnome-shell

#gdm3の再設定
dpkg-reconfigure gdm3

#再起動
reboot

System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Reset();
sw.Start();

/* ループ処理 */

sw.Stop();
/* ElapsedMilliseconds メンバから経過したミリ秒を取得 */
long res = sw.ElapsedMilliseconds;

/* C#コード */
using System;
public class C {
    private static void PostInc()
    {
        for(int i = 0; i < 1000000000; i++)
        {
        }
    }

    private static void PreInc()
    {
        for(int i = 0; i < 1000000000; ++i)
        {
        }
    }

    private static void SubInc()
    {
        for(int i = 0; i < 1000000000; i+=1)
        {
        }
    }
}

/* 中間言語（CIL） */
.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit C
    extends [mscorlib]System.Object
{
    // Methods
    .method private hidebysig static 
        void PostInc () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 17 (0x11)
        .maxstack 2
        .locals init (
            [0] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: stloc.0
        // sequence point: hidden
        IL_0002: br.s IL_0008
        // loop start (head: IL_0008)
            IL_0004: ldloc.0
            IL_0005: ldc.i4.1
            IL_0006: add
            IL_0007: stloc.0

            IL_0008: ldloc.0
            IL_0009: ldc.i4 1000000000
            IL_000e: blt.s IL_0004
        // end loop

        IL_0010: ret
    } // end of method C::PostInc

    .method private hidebysig static 
        void PreInc () cil managed 
    {
        // Method begins at RVA 0x2070
        // Code size 17 (0x11)
        .maxstack 2
        .locals init (
            [0] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: stloc.0
        // sequence point: hidden
        IL_0002: br.s IL_0008
        // loop start (head: IL_0008)
            IL_0004: ldloc.0
            IL_0005: ldc.i4.1
            IL_0006: add
            IL_0007: stloc.0

            IL_0008: ldloc.0
            IL_0009: ldc.i4 1000000000
            IL_000e: blt.s IL_0004
        // end loop

        IL_0010: ret
    } // end of method C::PreInc

    .method private hidebysig static 
        void SubInc () cil managed 
    {
        // Method begins at RVA 0x2090
        // Code size 17 (0x11)
        .maxstack 2
        .locals init (
            [0] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: stloc.0
        // sequence point: hidden
        IL_0002: br.s IL_0008
        // loop start (head: IL_0008)
            IL_0004: ldloc.0
            IL_0005: ldc.i4.1
            IL_0006: add
            IL_0007: stloc.0

            IL_0008: ldloc.0
            IL_0009: ldc.i4 1000000000
            IL_000e: blt.s IL_0004
        // end loop

        IL_0010: ret
    } // end of method C::SubInc

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x20ad
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: ret
    } // end of method C::.ctor

} // end of class C

/* JITによるコンパイル後 */
C..ctor()
    L0000: ret

C.PostInc()
    L0000: push ebp
    L0001: mov ebp, esp
    L0003: xor eax, eax
    L0005: inc eax
    L0006: cmp eax, 0x3b9aca00
    L000b: jl L0005
    L000d: pop ebp
    L000e: ret

C.PreInc()
    L0000: push ebp
    L0001: mov ebp, esp
    L0003: xor eax, eax
    L0005: inc eax
    L0006: cmp eax, 0x3b9aca00
    L000b: jl L0005
    L000d: pop ebp
    L000e: ret

C.SubInc()
    L0000: push ebp
    L0001: mov ebp, esp
    L0003: xor eax, eax
    L0005: inc eax
    L0006: cmp eax, 0x3b9aca00
    L000b: jl L0005
    L000d: pop ebp
    L000e: ret

using System;
using System.Diagnostics;

namespace C
{
    class Program
    {
        static void Main (string[] args)
        {
            long sum;
            long[] result = new long[6];
            Stopwatch sw = new Stopwatch();
            /* 10回分の平均速度を求める */
            for (int loop = 0 ; loop < 10 ; loop++)
            {
                /* i++ */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 0 ; i < 1000000000 ; i++)
                {
                    sum += i;
                }
                sw.Stop();
                result[0] += sw.ElapsedMilliseconds;

                /* ++i */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 0 ; i < 1000000000 ; ++i)
                {
                    sum += i;
                }
                sw.Stop();
                result[1] += sw.ElapsedMilliseconds;

                /* i += 1 */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 0 ; i < 1000000000 ; i += 1)
                {
                    sum += i;
                }
                sw.Stop();
                result[2] += sw.ElapsedMilliseconds;

                /* i-- */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 999999999 ; i >= 0 ; i--)
                {
                    sum += i;
                }
                sw.Stop();
                result[3] += sw.ElapsedMilliseconds;

                /* --i */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 999999999 ; i >= 0 ; --i)
                {
                    sum += i;
                }
                sw.Stop();
                result[4] += sw.ElapsedMilliseconds;

                /* i -= 1 */
                sum = 0;
                sw.Reset();
                sw.Start();
                for (int i = 999999999 ; i >= 0 ; i -= 1)
                {
                    sum += i;
                }
                sw.Stop();
                result[5] += sw.ElapsedMilliseconds;
            }
            Console.WriteLine("i++：" + result[0] / 10);
            Console.WriteLine("++i：" + result[1] / 10);
            Console.WriteLine("i+=1：" + result[2] / 10);
            Console.WriteLine("i--：" + result[3] / 10);
            Console.WriteLine("--i：" + result[4] / 10);
            Console.WriteLine("i-=1：" + result[5] / 10);
            Console.ReadKey();
        }
    }
}

/* C#コード */
using System;
class C
{
    static void UseProperty (int[] dataArray)
    {
        long sum = 0;
        for (int i = 0 ; i < dataArray.Length ; i++)
        {
            sum += dataArray[i];
        }
    }

    static void UseCache (int[] dataArray)
    {
        long sum = 0;
        for (int i = 0, len = dataArray.Length ; i < len ; i++)
        {
            sum += dataArray[i];
        }
    }

    static void UseLiteral (int[] dataArray)
    {
        long sum = 0;
        for (int i = 0 ; i < 100000000 ; i++)
        {
            sum += dataArray[i];
        }
    }
}

/* 中間言語（CIL） */
.class private auto ansi '<Module>'
{
} // end of class <Module>

.class private auto ansi beforefieldinit C
    extends [mscorlib]System.Object
{
    // Methods
    .method private hidebysig static 
        void UseProperty (
            int32[] dataArray
        ) cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 25 (0x19)
        .maxstack 3
        .locals init (
            [0] int64,
            [1] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: conv.i8
        IL_0002: stloc.0
        IL_0003: ldc.i4.0
        IL_0004: stloc.1
        // sequence point: hidden
        IL_0005: br.s IL_0012
        // loop start (head: IL_0012)
            IL_0007: ldloc.0
            IL_0008: ldarg.0
            IL_0009: ldloc.1
            IL_000a: ldelem.i4
            IL_000b: conv.i8
            IL_000c: add
            IL_000d: stloc.0
            IL_000e: ldloc.1
            IL_000f: ldc.i4.1
            IL_0010: add
            IL_0011: stloc.1

            IL_0012: ldloc.1
            IL_0013: ldarg.0
            IL_0014: ldlen
            IL_0015: conv.i4
            IL_0016: blt.s IL_0007
        // end loop

        IL_0018: ret
    } // end of method C::UseProperty

    .method private hidebysig static 
        void UseCache (
            int32[] dataArray
        ) cil managed 
    {
        // Method begins at RVA 0x2078
        // Code size 27 (0x1b)
        .maxstack 3
        .locals init (
            [0] int64,
            [1] int32,
            [2] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: conv.i8
        IL_0002: stloc.0
        IL_0003: ldc.i4.0
        IL_0004: stloc.1
        IL_0005: ldarg.0
        IL_0006: ldlen
        IL_0007: conv.i4
        IL_0008: stloc.2
        // sequence point: hidden
        IL_0009: br.s IL_0016
        // loop start (head: IL_0016)
            IL_000b: ldloc.0
            IL_000c: ldarg.0
            IL_000d: ldloc.1
            IL_000e: ldelem.i4
            IL_000f: conv.i8
            IL_0010: add
            IL_0011: stloc.0
            IL_0012: ldloc.1
            IL_0013: ldc.i4.1
            IL_0014: add
            IL_0015: stloc.1

            IL_0016: ldloc.1
            IL_0017: ldloc.2
            IL_0018: blt.s IL_000b
        // end loop

        IL_001a: ret
    } // end of method C::UseCache

    .method private hidebysig static 
        void UseLiteral (
            int32[] dataArray
        ) cil managed 
    {
        // Method begins at RVA 0x20a0
        // Code size 27 (0x1b)
        .maxstack 3
        .locals init (
            [0] int64,
            [1] int32
        )

        IL_0000: ldc.i4.0
        IL_0001: conv.i8
        IL_0002: stloc.0
        IL_0003: ldc.i4.0
        IL_0004: stloc.1
        // sequence point: hidden
        IL_0005: br.s IL_0012
        // loop start (head: IL_0012)
            IL_0007: ldloc.0
            IL_0008: ldarg.0
            IL_0009: ldloc.1
            IL_000a: ldelem.i4
            IL_000b: conv.i8
            IL_000c: add
            IL_000d: stloc.0
            IL_000e: ldloc.1
            IL_000f: ldc.i4.1
            IL_0010: add
            IL_0011: stloc.1

            IL_0012: ldloc.1
            IL_0013: ldc.i4 100000000
            IL_0018: blt.s IL_0007
        // end loop

        IL_001a: ret
    } // end of method C::UseLiteral

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x20c7
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: ret
    } // end of method C::.ctor

} // end of class C

/* JITによるコンパイル後 */
; Desktop CLR v4.7.3324.00 (clr.dll) on amd64.

C..ctor()
    L0000: ret

C.UseProperty(Int32[])
    L0000: xor eax, eax
    L0002: xor edx, edx
    L0004: mov r8d, [rcx+0x8]
    L0008: test r8d, r8d
    L000b: jle L0022
    L000d: movsxd r9, edx
    L0010: mov r9d, [rcx+r9*4+0x10]
    L0015: movsxd r9, r9d
    L0018: add rax, r9
    L001b: inc edx
    L001d: cmp r8d, edx
    L0020: jg L000d
    L0022: ret

C.UseCache(Int32[])
    L0000: xor eax, eax
    L0002: xor edx, edx
    L0004: mov r8d, [rcx+0x8]
    L0008: test r8d, r8d
    L000b: jle L0022
    L000d: movsxd r9, edx
    L0010: mov r9d, [rcx+r9*4+0x10]
    L0015: movsxd r9, r9d
    L0018: add rax, r9
    L001b: inc edx
    L001d: cmp edx, r8d
    L0020: jl L000d
    L0022: ret

C.UseLiteral(Int32[])
    L0000: sub rsp, 0x28
    L0004: xor eax, eax
    L0006: xor edx, edx
    L0008: test rcx, rcx
    L000b: jz L0030
    L000d: cmp dword [rcx+0x8], 0x5f5e100
    L0014: jl L0030
    L0016: movsxd r8, edx
    L0019: mov r8d, [rcx+r8*4+0x10]
    L001e: movsxd r8, r8d
    L0021: add rax, r8
    L0024: inc edx
    L0026: cmp edx, 0x5f5e100
    L002c: jl L0016
    L002e: jmp L004d
    L0030: cmp edx, [rcx+0x8]
    L0033: jae L0052
    L0035: movsxd r8, edx
    L0038: mov r8d, [rcx+r8*4+0x10]
    L003d: movsxd r8, r8d
    L0040: add rax, r8
    L0043: inc edx
    L0045: cmp edx, 0x5f5e100
    L004b: jl L0030
    L004d: add rsp, 0x28
    L0051: ret
    L0052: call 0x7ffdb9ec2660
    L0057: int3

using System;
using System.Diagnostics;

namespace C
{
    class Program
    {
        static void Main (string[] args)
        {
            /* ループ処理に使用する配列を作成する */
            int[] dataArray = new int[100000000];
            for (int i = 0 ; i < 100000000 ; i++)
            {
                dataArray[i] = i;
            }

            /* 10回分の平均速度を求める */
            long sum;
            long[] result = new long[3];
            Stopwatch sw = new Stopwatch();
            for (int loop = 0 ; loop < 10 ; loop++)
            {
                /* 配列のプロパティをそのまま使う */
                sw.Reset();
                sw.Start();
                UseProperty(dataArray);
                sw.Stop();
                result[0] += sw.ElapsedMilliseconds;

                /* 配列のプロパティを変数にキャッシュして使う */
                sw.Reset();
                sw.Start();
                UseCache(dataArray);
                sw.Stop();
                result[1] += sw.ElapsedMilliseconds;

                /* リテラルを使用する */
                sw.Reset();
                sw.Start();
                UseLiteral(dataArray);
                sw.Stop();
                result[2] += sw.ElapsedMilliseconds;
            }
            Console.WriteLine("プロパティ：" + result[0] / 10);
            Console.WriteLine("キャッシュ：" + result[1] / 10);
            Console.WriteLine("　リテラル：" + result[2] / 10);
            Console.ReadKey();
        }

                /* Lengthプロパティを用いたループ処理 */
        static void UseProperty (int[] dataArray)
        {
            long sum = 0;
            for (int i = 0 ; i < dataArray.Length ; i++)
            {
                sum += dataArray[i];
            }
        }

                /* Lengthプロパティをローカル変数にキャッシュしたループ処理 */
        static void UseCache (int[] dataArray)
        {
            long sum = 0;
            for (int i = 0, len = dataArray.Length ; i < len ; i++)
            {
                sum += dataArray[i];
            }
        }

        /* リテラルを用いたループ処理 */
        static void UseLiteral (int[] dataArray)
        {
            long sum = 0;
            for (int i = 0 ; i < 100000000 ; i++)
            {
                sum += dataArray[i];
            }
        }
    }
}

const idList = ["sample001@shop","sample002@shop","sample003@shop"];
class setOptions {
    constructor(id) {
        // API を request するためのオプションをセット（内容は割愛）
    }
}
for(let i = 0; i < idList.length; i++){ // 3 の処理
    request(new setOptions(idList[i])).then((response) => { // 1 の処理
        console.log(idList[i] + " : " + response); // 2 の処理
    }).catch((error) => { console.log(error) }); 
}

sample002@shop : サンプル次郎
sample001@shop : サンプル太郎
sample003@shop : サンプル四郎

request(new setOptions(idList[0])).then((response) => {
    console.log(idList[0] + " : " + response);
}).catch((error) => { console.log(error) }); 
request(new setOptions(idList[1])).then((response) => {
    console.log(idList[1] + " : " + response);
}).catch((error) => { console.log(error) }); 
request(new setOptions(idList[2])).then((response) => {
    console.log(idList[2] + " : " + response);
}).catch((error) => { console.log(error) }); 
}

request(new setOptions(idList[0]))
.then((response) => {
    console.log(idList[0] + " : " + response);
    return request(new setOptions(idList[1]));
.then((response) => {
    console.log(idList[1] + " : " + response);
    return request(new setOptions(idList[2]));
.then((response) => {
    console.log(idList[2] + " : " + response);
}).catch((error) => { console.log(error) }); 

const idList = ["sample001@shop","sample002@shop","sample003@shop"];
class setOptions {
    constructor(id) {
        // API を request するためのオプションをセット（内容は割愛）
    }
}
function loop(i){
    request(new setOptions(idList[i]))
    .then((response) => {
        console.log(idList[i] + " : " + response);
        i++;
        if(i < idList.length) loop(i); // ここでループする
    }).catch((error) => { errorArart(error) });    
}
loop(0);

sample001@shop : サンプル太郎
sample002@shop : サンプル次郎
sample003@shop : サンプル四郎

split(variables('test_var'), ',')

concat('f_', item())

num = [1,2,3,4]
sum = 0
num.each do |n|
  sum += n
end
print sum #=> 10

num = [1,2,3,4]
num.each_with_index do |i,n|
  p "#{i}:#{n}"
end
#出力は以下の通り
#0:1
#1:2
#2:3
#3:4

num = [1,2,3,4]
new_num = []
new_num = num.map do |n|
  n * 10
end
print new_num #=> [10,20,30,40]

num = [1,2,3,4]
new_num = num.select do |n|
  n.odd? #nが奇数のものをnew_numへ格納
end
print new_num  #=> [1,3]

num = [1,2,3,4]
new_num = num.select do |n|
  n.odd? #nが奇数でないものをnew_numへ格納
end
print new_num  #=> [2,4]

num = [1,2,3,4]
new_num = num.find do |n|
  n.odd?
end
print new_num #=> 3

num = [1,2,3,4]
sum = num.inject(0) do |result,n|
  result += n #初期値0に各要素をすべて足しこむ。初期値が異なれば結果も異なる。
end
print sum #=> 10

Scanner scan = new Scanner(System.in);
while(true){
  int num = scan.nextInt();
  switch(num){
    case // 入力してほしい数値:
      // 処理内容
      break;
    default:
      continue;
  }
  break;
}

$arr = [1, 2, 3];
foreach($arr as $val){
  echo $val; // 順に1, 2, 3
}

$arr = [3 => 1, 2 => 2, 1 => 3];
foreach ($arr as $key => $val) {
    echo $key, $val; // 31, 22, 13 順番が変わったりはしない
}

class Test{
    public $a = 1;
    protected $b = 2;
    private $c = 3;

    public function loop(){
        foreach($this as $val){
            echo $val;
        }
    }
}

$test = new Test();
foreach($test as $val){
    echo $val; // 1
}

$test->loop(); // 1,2,3

$array = range(0, 10);

foreach ($array as $k => $v) {
    unset($array[$k - 1]);
}

var_dump($array); // [10=>10]

$array = [1, 2, 3, 4, 5, 6];

// 偶数以外削除
foreach ($array as $k => $v) {
    if ($v % 2) {
        unset($array[$k]);
    }
}

var_dump($array); // [2, 4, 6]

$i = 1;
while ($i <= 10) {
    echo $i;
    $i++;
}

// 30回ループしたら脱出
$i = 0;
while ($i < 30) {
    echo $i;
    $i++;
}

// 30秒経ったら中断
while(true){
    sleep(1);

    if(time() - $_SERVER['REQUEST_TIME'] > 30){
        break;
    }
}

// 標準入力を出力
while( ($line = fgets(STDIN)) !== false){
    echo $line;
}

// 30回ループしたら脱出
for ($i = 0; $i < 30; $i++) {
    echo $i;
}

// forを使うほどではない
for(; true; ){
    sleep(1);

    if(time() - $_SERVER['REQUEST_TIME'] > 30){
        break;
    }
}

$array = [1, 2, 3];

for ($key = 0; $key < count($array); $key++) {
    echo $key, $array[$key]; // 01, 12, 23
}

$array = [0 => 1, 2 => 3]; // 死
$array = ['answer' => 42]; // 死

for(; time() - $_SERVER['REQUEST_TIME'] <= 30; sleep(1));

$i = 100;
do {
    echo $i++;
} while ($i < 30);

$sum = 0;
foreach($array as $val){
    $sum += $val;
}
echo $sum;

echo array_sum($array); // ↑と同じ

// 0～10000のうち、偶数だけを抽出して自乗し、結果が20を超えるものを足しあわせよ

// 関数型
echo array_sum(
    array_filter(
        array_map(
            function ($v) {
                return $v ** 2;
            },
            array_filter(range(0, 10000), function ($v) {
                return $v % 2 === 0;
            })
        ),
        function ($v) {
            return $v > 20;
        }
    )
);

// 普通に書く
for ($sum = $v = 0; $v <= 10000; ++$v) {
    if ($v % 2){ continue; }
    $v **= 2;
    if ($v <= 20){ continue; }
    $sum += $v;
}
echo $sum;

class Test implements Iterator
{
    public $dummy = '出てこない';
    private $data1 = [1, 2, 3];
    private $data2 = [4, 5, 6];
    private $current = 0;

    /**
     * @Override
     * 現在の値を返す
     * @return mixed 現在の値
     */
    public function current(){
        return $this->data1[$this->current] ?? $this->data2[$this->current - 3] ?? null;
    }

    /**
     * @Override
     * 現在のキーを返す
     * @return string|int 現在のキー
     */
    public function key(){
        return $this->current;
    }

    /**
     * @Override
     * ポインタを次に移動する
     */
    public function next(){
        $this->current++;
    }

    /**
     * @Override
     * ポインタを初期化する
     */
    public function rewind(){
        $this->current = 0;
    }

    /**
     * @Override
     * 現在のポインタが有効か
     * @return boolean 有効ならtrue
     */
    public function valid(){
        return isset($this->data1[$this->current]) ?: isset($this->data2[$this->current - 3]);
    }
}

$test = new Test();
foreach ($test as $key => $val) {
    echo $key, '=>', $val; // [0=>1, 1=>2, 2=>3, 3=>4, 4=>5, 5=>6]
}

class Test implements IteratorAggregate
{
    public $dummy = '出てこない';
    private $data1 = [1, 2, 3];
    private $data2 = [4, 5, 6];

    /**
     * @Override
     * イテレータを返す
     * @return Iterator
     */
    public function getIterator(){
        $iter = new AppendIterator();
        $iter->append(new ArrayIterator($this->data1));
        $iter->append(new ArrayIterator($this->data2));
        return $iter;
    }
}

$test = new Test();
foreach ($test as $key => $val) {
    echo $key, '=>', $val; // [0=>1, 1=>2, 2=>3, 0=>4, 1=>5, 2=>6]
}

function getPrimeNumber(){
    yield 2;
    yield 3;
    yield 5;
    yield 7;
    yield 11;
    yield 13;
    yield 17;
    return 19; // returnは出ない
}

$primes = getPrimeNumber();
foreach($primes as $prime){
    echo $prime; // 2, 3, 5, 7, 11, 13, 17
}

// フィボナッチ数を求めるジェネレータ
function getFibonacci(){
    $fa = 0;
    yield $fa;
    $fb = 1;
    yield $fb;

    while (true) {
        $fib = $fa + $fb;
        $fa = $fb;
        $fb = $fib;
        yield $fib;
    }
}

$count = 0;
foreach (getFibonacci() as $fibonacci) {
    echo $fibonacci . "\n";
    // 適当に切らないと無限ループする
    if ($count++ > 30) {
        break;
    }
}

$array = range(0, 5);
foreach ($array as &$val) {
    $val *= 2;
}
var_dump($array); // [2, 4, 6, 8, 10]

$val = 42;
var_dump($array); // [2, 4, 6, 8, 42] ←

do {
    if ($i < 5) {
        echo "i は十分大きくはありません。";
        break;
    }
    $i *= $factor;
    if ($i < $minimum_limit) {
        break;
    }
    echo "iはOKです。";

    /* 実際の処理 */

} while (0);

$array = range(0, 5);

while(true){
    echo key($array), current($array);
    if(next($array) === false){
        break;
    }
}

class Test{
    public $a = 1;
    protected $b = 2;
    private $c = 3;
}
$array = new Test();

while(true){
    var_dump(key($array), current($array) );
    if(next($array) === false){
        break;
    }
}

$fibonacci = getFibonacci();

while ($fibonacci->key() < 28) {
    $fibonacci->next();
    echo $fibonacci->current(); // 1, 1, 2, 3, 5, 8, …
}

function gen()
{
    yield 1;
    yield from [2, 3];
    yield from gen2();
}

function gen2()
{
    yield 4;
    yield 5;
}

$gen = gen();
foreach ($gen as $v) {
    echo $v; // 1, 2, 3, 4, 5
}

$arr = [3, 1, 2];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

var_dump($arr); // 1, 2, 3

#! /bin/bash

# 構造体
LOOP_LISTS=(
    ABCDEFG
    hijklmn
    1234567
    あいうえお
)

i=1
# 構造体の中身をループで一つづつ表示
for LOOP_LIST in ${LOOP_LISTS[@]}; do
    # 同一の処理(今回は表示)
    echo "${i}：${LOOP_LIST}"
    let i++
done

# 構造体の中身を指定で表示(１番目のデータは「0」になる)
echo "２番目指定：${LOOP_LISTS[1]}"

$ sh sample01.sh
1：ABCDEFG
2：hijklmn
3：1234567
4：あいうえお
２番目指定：hijklmn

signatureMY_MODULE=sigtypetvaltoString:t->stringend

typeelem=...(*何らかの要素 *)typet=elemlistfuntoStringdatas=foldr(fn(e,acc)=>(elemToStringe)^acc)""datas

   toString [A, B, C, D]
=> "A" ^ ("B" ^ ("C" ^ ("D" ^ "")))
=> "ABCD"

""
"D"
"D"
"C"
"CD"
"B"
"BCD"
"A"
"ABCD"

funtoStringdatas=letvalcharList=foldr(fn(e,acc)=>(elemToChare)::acc)nildatasinCharVector.fromListcharListend

   toString [A, B, C, D]
=> CharVector.fromList (#"A" :: #"B" :: #"C" :: "D" :: nil)
=> "ABCD"

#"D"
#"C"
#"B"
#"A"
[#"A", #"B", #"C", #"D"]

structureS:sigdatatypeelem=A|BtypetvaltoString:t->stringend=structdatatypeelem=A|Btypet=elemlistfunelemToStringA="A"|elemToStringB="B"funtoStringdatas=foldl(fn(e,acc)=>(elemToStringe)^acc)""datasendfunmain()=let(* n個のAを持つデータをプリントする *)valn=10000valinput:S.t=List.tabulate(n,fn_=>S.A)valformat=S.toStringinputinprintformatendval()=main()

structureS:sigdatatypeelem=A|BtypetvaltoString:t->stringend=structdatatypeelem=A|Btypet=elemlist(* char listにしてからCharVector.fromListでstringにする *)funelemToCharA=#"A"|elemToCharB=#"B"funtoStringdatas=letvalcharList=foldr(fn(e,acc)=>elemToChare::acc)nildatasinCharVector.fromListcharListendendfunmain()=let(* n個のAを持つデータをプリントする *)valn=10000valinput:S.t=List.tabulate(n,fn_=>S.A)valformat=S.toStringinputinprintformatendval_=main()