前提条件：SQL Server 2008 以降

IO負荷が高い例

Sub Test(ByVal dt As DataTable)
    Dim con As New SqlConnection("connection string")
    Dim cmd As New SqlCommand
    Dim sql As New StringBuilder
    con.Open()
    cmd.Connection = con
    cmd.Parameters.Clear()
 
    'データテーブルの行分だけループしている悪い例
    For i As Integer = 0 To dt.Rows.Count - 1
        sql.AppendLine("INSERT INTO dbo.T_TEST ")
        sql.AppendLine("( ")
        sql.AppendLine("  CODE ")
        sql.AppendLine(") VALUES ( ")
        sql.AppendLine("  @Code ")
        sql.AppendLine("); ")
 
        'パラメータの作成
        Dim param = New SqlParameter("@Code", SqlDbType.Int, ParameterDirection.Input)
        param.Value = dt.Rows(i).Item(0).ToString()
        'パラメータを渡します。
        cmd.Parameters.Add(param)
 
        'プロシージャの実行
        cmd.CommandType = CommandType.Text
        cmd.CommandText = sql.ToString()
        cmd.ExecuteNonQuery
    Next i
End Sub

まずは、悪例としてデータテーブルのレコードを 1 件ずつ INSERT していく方法。
上記の方法だと件数が少なければ問題が無いように感じるが、１万件を超えてくるとそのパフォーマンスの悪さが目立ってくる。
１万件のデータをループして INSERT すると１万回の IO 処理となり、オーバーヘッドが大きくなる。
しかし、次の方法で INSERT すると１回の IO 処理で済む為、更新するデータ量は変わらないがかなりのパフォーマンス改善が見込まれる。

DataTableをパラメータとして渡す

DataTable をパラメータとして渡す為には、SQL Server 側にユーザー定義テーブル型を作成しておく必要がある。

CREATE TYPE TestTableType AS TABLE
(
  TestCode int NOT NULL
)
GO

テーブルの定義と同様に括弧の中にフィールド定義を記述する。
テーブルで定義できるフィールドはTableTypeでも定義可能。

続いて、プログラム側の処理。

Sub Test(ByVal dt As DataTable)
    Dim con As New SqlConnection("connection string")
    Dim cmd As New SqlCommand
    Dim sql As New StringBuilder
    con.Open()
    cmd.Connection = con
    cmd.Parameters.Clear()
 
    sql.AppendLine("INSERT INTO dbo.T_TEST ")
    sql.AppendLine("      ( ")
    sql.AppendLine("        CODE ")
    sql.AppendLine("      ) ")
    sql.AppendLine(" SELECT TestCode ")
    sql.AppendLine("   FROM @TestTable ")
    sql.AppendLine("  WHERE TestCode = @Code ")
    sql.AppendLine("); ")
  
    'パラメータの作成
    Dim params(1) As SqlParameters
    params(0) = New SqlParameter("@Code", SqlDbType.Int, ParameterDirection.Input)
    params(0).Value = 1
    params(1) = New SqlParameter("@TestTable", SqlDbType.Structured, ParameterDirection.Input)  'TypeにSqlDbType.Structuredを渡します。
    params(1).TypeName = "TestTableType"  'テーブルタイプの名称を渡します。
    params(1).Value = dt    '編集したデータテーブルを渡します。
    'パラメータ配列を渡します。
    cmd.Parameters.AddRange(params)
    'プロシージャの実行
    cmd.CommandType = CommandType.StoredProcedure
    cmd.CommandText = sql.ToString()
    cmd.ExecuteNonQuery
End Sub

ユーザー定義テーブル型を使用することで DataTable をテーブルのように渡すことができる為、一括で SELECT して INSERT または UPDATE が可能となる。

<注意事項>

• DataTable のフィールドはユーザー定義テーブル型のフィールドと一致している必要がある。
• ユーザー定義テーブル型を渡す場合は、SqlDbType.Structured で渡す。

ユーザー定義テーブル型を作成しておく必要はあるが、こちらの方法であれば実行速度が圧倒的に速く、パフォーマンス改善が期待できる。
デメリットとしては、ループせずに一括で更新する為、プログレスバーなどで進捗を表示することができない。

.NETには、CSVファイルを読み取る際に便利なクラス(TextFieldParser)が「VB.NET」のライブラリに存在する。

このクラスを利用してCSVファイルをLINQで簡潔に扱えるようにする。

まず、CSVファイルへのコンテキストを生成する為のTextFieldクラスを作成する。

このクラスのContextメソッドでコンテキストを生成することでロジックを意識することなくCSVファイルの読み込みが可能になる。

Imports System.Text
Imports System.IO
Imports Microsoft.VisualBasic.FileIO

Public Class TextField
    ' 指定されたCSVファイルへのコンテキストを生成する
    Public Shared Function Context(path As String,
                                   Optional separator As String = ",",
                                   Optional myEncoding As Encoding = Nothing) As IEnumerable(Of String())

        Dim results As New List(Of String())

        Using stream As Stream = New FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)

            Using parser As New TextFieldParser(stream, If(myEncoding, Encoding.UTF8), True, False)

                parser.TextFieldType = FieldType.Delimited
                parser.Delimiters = New String() {separator}
                parser.HasFieldsEnclosedInQuotes = True
                parser.TrimWhiteSpace = True

                While parser.EndOfData = False
                    Dim fields As String() = parser.ReadFields()
                    results.Add(fields)
                End While
            End Using
        End Using

        Return results
    End Function

End Class

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using Microsoft.VisualBasic.FileIO;

namespace CS_CSVtoLINQ
{
    public class TextField
    {
        // 指定されたCSVファイルへのコンテキストを生成する
        public static IEnumerable<string[]> Context(string path,
                                                    string separator = ",",
                                                    Encoding encoding = null)
        {
            using (Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (TextFieldParser parser = new TextFieldParser(stream, encoding ?? Encoding.UTF8, true, false))
                {
                    parser.TextFieldType = FieldType.Delimited;
                    parser.Delimiters = new[] { separator };
                    parser.HasFieldsEnclosedInQuotes = true;
                    parser.TrimWhiteSpace = true;
                    while (parser.EndOfData == false)
                    {
                        string[] fields = parser.ReadFields();
                        yield return fields;
                    }
                }
            }
        }
    }
}

次は、実際にTextFieldクラスを利用してコンテキストを生成し、CSVファイルへアクセスしてLINQにより入力した条件に一致するレコードデータを表示するコードを記述する。

尚、AsParallel()メソッドを呼び出すことで条件判定をマルチスレッド化できるので、データ量が多い場合は、並列化による高速化が期待できる。

Imports System.Text
Imports System.IO

Module Module1

    Sub Main()
        Do
            ' 検索条件に使用するIDの入力を求める
            Console.WriteLine("IDを入力")
            Dim input As String = Console.ReadLine()

            ' 入力された値から終了判定
            If input.ToUpper = "END" OrElse input.ToUpper = "EXIT" Then
                ' "END"、または"EXIT"が入力された場合は終了
                Exit Do
            End If

            ' 指定したCSVファイルへのコンテキストを生成
            Dim context As IEnumerable(Of String()) = TextField.Context("CSV\\SAMPLE001.csv", ",", Encoding.GetEncoding("Shift_JIS"))

            ' 取得したコンテキストを入力されたIDをキーに検索
            Dim results As IEnumerable(Of String) =
                From fields In context.AsParallel()
                Where fields(0).Equals(input)
                Select String.Format("{0}：{1}", fields(1), fields(2))

            ' 検索結果を出力
            For Each result As String In results
                Console.WriteLine(result)
            Next
            Console.WriteLine("---END---")
        Loop

    End Sub

End Module

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CS_CSVtoLINQ
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                // 検索条件に使用するIDの入力を求める
                Console.WriteLine("IDを入力");
                string input = Console.ReadLine();

                // 入力された値から終了判定
                if (input.ToUpper().Equals("END") || input.ToUpper().Equals("EXIT"))
                {
                    // "END"、または"EXIT"が入力された場合は終了
                    break;
                }

                // 指定したCSVファイルへのコンテキストを生成
                IEnumerable<string[]> context = TextField.Context("CSV\\SAMPLE001.csv", ",", Encoding.GetEncoding("Shift_JIS"));

                // 取得したコンテキストを入力されたIDをキーに検索
                IEnumerable<string> results = 
                    from fields in context.AsParallel()
                    where fields[0].Equals(input)
                    select String.Format("{0}：{1}", fields[1], fields[2]);

                // 検索結果を出力
                foreach (string result in results)
                {
                    Console.WriteLine(result);
                }
                Console.WriteLine("---END---");
            }
        }
    }
}

複数ファイルを跨いで検索する場合は以下のように記述することができる。

※全てのファイルレイアウトが同じ場合

Imports System.Text
Imports System.IO

Module Module1

    Sub Main()
        Do
            ' 検索条件に使用するIDの入力を求める
            Console.WriteLine("IDを入力")
            Dim input As String = Console.ReadLine()

            ' 入力された値から終了判定
            If input.ToUpper = "END" OrElse input.ToUpper = "EXIT" Then
                ' "END"、または"EXIT"が入力された場合は終了
                Exit Do
            End If

            ' 指定したCSVファイルへのコンテキストを生成して、入力されたIDをキーに検索
            Dim results As IEnumerable(Of String) =
                From path In Directory.GetFiles("CSV", "*.csv", SearchOption.AllDirectories).AsParallel()
                From fields In TextField.Context(path, ",", Encoding.GetEncoding("Shift_JIS"))
                Where fields(0).Equals(input)
                Select String.Format("{0}：{1}", fields(1), fields(2))

            ' 検索結果を出力
            For Each result As String In results
                Console.WriteLine(result)
            Next
            Console.WriteLine("---END---")
        Loop

    End Sub

End Module

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace CS_CSVtoLINQ
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                // 検索条件に使用するIDの入力を求める
                Console.WriteLine("IDを入力");
                string input = Console.ReadLine();

                // 入力された値から終了判定
                if (input.ToUpper().Equals("END") || input.ToUpper().Equals("EXIT"))
                {
                    // "END"、または"EXIT"が入力された場合は終了
                    break;
                }

                // 指定したCSVファイルへのコンテキストを生成して、入力されたIDをキーに検索
                IEnumerable<string> results = 
                    from path in Directory.GetFiles("CSV", "*.csv", SearchOption.AllDirectories).AsParallel()
                    from fields in TextField.Context(path, ",", Encoding.GetEncoding("Shift_JIS"))
                    where fields[0].Equals(input)
                    select String.Format("{0}：{1}", fields[1], fields[2]);

                // 検索結果を出力
                foreach (string result in results)
                {
                    Console.WriteLine(result);
                }
                Console.WriteLine("---END---");
            }
        }
    }
}

EnumWindowsを呼び出すと、コールバックメソッドが呼び出され、存在する個々のウィンドウのHWNDが渡される。

以下の例では、EnumWindows()でウィンドウを列挙し、コールバックメソッド内ではIsWindowVisible()を使って可視ウィンドウかどうかを調べている。

また、個々の可視ウィンドウについて、GetWindowText()を使ってウィンドウのキャプションを、GetWindowThreadProcessId()とProcess.GetProcessByIdを使ってプロセス情報を取得・表示している。

Module Module1
    Public Class Sample
        ''' <summary>
        ''' ウィンドウを列挙します。
        ''' </summary>
        ''' <param name="lpEnumFunc">コールバック関数</param>
        ''' <param name="lParam">アプリケーション定義の値</param>
        ''' <returns></returns>
        ''' <remarks></remarks>
        <System.Runtime.InteropServices.DllImport("user32.dll")>
        Public Shared Function EnumWindows(ByVal lpEnumFunc As EnumWinProc, ByVal lParam As IntPtr) As Boolean
        End Function

        ''' <summary>
        ''' EnumWindowsから呼び出されるコールバック関数EnumWinProcのデリゲート
        ''' </summary>
        ''' <param name="hWnd">ウィンドウのハンドル</param>
        ''' <param name="lParam">アプリケーション定義の値</param>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Delegate Function EnumWinProc(ByVal hWnd As IntPtr, ByVal lParam As IntPtr) As Boolean

        ''' <summary>
        ''' ウィンドウハンドルからキャプションを取得します。
        ''' </summary>
        ''' <param name="hWnd">ウィンドウのハンドル</param>
        ''' <param name="lpString">キャプション</param>
        ''' <param name="nMaxCount">キャプションの最大桁数</param>
        ''' <returns></returns>
        ''' <remarks></remarks>
        <System.Runtime.InteropServices.DllImport("user32.dll", CharSet:=System.Runtime.InteropServices.CharSet.Auto)>
        Public Shared Function GetWindowText(ByVal hWnd As IntPtr, ByVal lpString As System.Text.StringBuilder, ByVal nMaxCount As Integer) As Integer
        End Function

        ''' <summary>
        ''' ウィンドウハンドルからプロセスＩＤを取得します。
        ''' </summary>
        ''' <param name="hWnd">ウィンドウのハンドル</param>
        ''' <param name="lpdwProcessId">プロセスＩＤ</param>
        ''' <returns></returns>
        ''' <remarks></remarks>
        <System.Runtime.InteropServices.DllImport("user32.dll")>
        Public Shared Function GetWindowThreadProcessId(ByVal hWnd As IntPtr, <System.Runtime.InteropServices.Out()> ByRef lpdwProcessId As Integer) As Integer
        End Function

        ''' <summary>
        ''' ウィンドウが可視かどうかを調べます。
        ''' </summary>
        ''' <param name="hWnd">ウィンドウのハンドル</param>
        ''' <returns></returns>
        ''' <remarks></remarks>
        <System.Runtime.InteropServices.DllImport("user32.dll")>
        Public Shared Function IsWindowVisible(ByVal hWnd As IntPtr) As Boolean
        End Function

    End Class

    Sub Main()

        ' ウィンドウの列挙を開始
        Sample.EnumWindows(AddressOf EnumerateWindow, IntPtr.Zero)

        Console.ReadLine()

    End Sub

    ' ウィンドウを列挙するためのコールバックメソッド
    Private Function EnumerateWindow(ByVal hWnd As IntPtr, ByVal lParam As IntPtr) As Boolean

        ' ウィンドウが可視かどうか調べる
        If Sample.IsWindowVisible(hWnd) Then
            ' キャプションとプロセスＩＤを表示
            PrintCaptionAndProcess(hWnd)
        End If

        ' ウィンドウの列挙を継続するにはTrueを返す必要がある
        Return True

    End Function

    ' ウィンドウのキャプションとプロセス名を表示する
    Private Sub PrintCaptionAndProcess(ByVal hWnd As IntPtr)

        ' ウィンドウハンドルからプロセスIDを取得
        Dim processId As Integer

        Sample.GetWindowThreadProcessId(hWnd, processId)

        ' プロセスIDからProcessクラスのインスタンスを取得
        Dim p As Process = Process.GetProcessById(processId)

        ' プロセス名を表示
        Console.Write("'{0}' ", p.ProcessName)

        ' ウィンドウのキャプションを取得・表示
        Dim caption As New System.Text.StringBuilder(&H1000)

        Sample.GetWindowText(hWnd, caption, caption.Capacity)

        Console.WriteLine("({0})", caption)

    End Sub

End Module

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;

namespace CS_EnumWindowsTest
{
    class Sample
    {
        /// <summary>
        /// ウィンドウを列挙します。
        /// </summary>
        /// <param name="lpEnumFunc">コールバック関数</param>
        /// <param name="lParam">アプリケーション定義の値</param>
        /// <returns></returns>
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern bool EnumWindows(EnumWinProc lpEnumFunc, IntPtr lParam);

        /// <summary>
        /// EnumWindowsから呼び出されるコールバック関数EnumWinProcのデリゲート
        /// </summary>
        /// <param name="hWnd">ウィンドウのハンドル</param>
        /// <param name="lParam">アプリケーション定義の値</param>
        /// <returns></returns>
        public delegate bool EnumWinProc(IntPtr hWnd, IntPtr lParam);

        /// <summary>
        /// ウィンドウハンドルからキャプションを取得します
        /// </summary>
        /// <param name="hWnd">ウィンドウのハンドル</param>
        /// <param name="lpString">キャプション</param>
        /// <param name="nMaxCount">キャプションの最大桁数</param>
        /// <returns></returns>
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

        /// <summary>
        /// ウィンドウハンドルからプロセスＩＤを取得します。
        /// </summary>
        /// <param name="hWnd">ウィンドウのハンドル</param>
        /// <param name="lpdwProcessId">プロセスＩＤ</param>
        /// <returns></returns>
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

        /// <summary>
        /// ウィンドウが可視かどうかを調べます。
        /// </summary>
        /// <param name="hWnd">ウィンドウのハンドル</param>
        /// <returns></returns>
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern bool IsWindowVisible(IntPtr hWnd);
    }

    class Program
    {
        static void Main(string[] args)
        {

            // ウィンドウの列挙を開始
            Sample.EnumWindows(EnumerateWindow, IntPtr.Zero);

            Console.ReadLine();

        }

        private static bool EnumerateWindow(IntPtr hWnd, IntPtr lParam)
        {
            // ウィンドウが可視かどうか調べる
            if (Sample.IsWindowVisible(hWnd))
            {
                // キャプションとプロセスＩＤを表示
                PrintCaptionAndProcess(hWnd);
            }

            // ウィンドウの列挙を継続するにはTrueを返す必要がある
            return true;
        }

        private static void PrintCaptionAndProcess(IntPtr hWnd)
        {
            // ウィンドウハンドルからプロセスIDを取得
            int processId;

            Sample.GetWindowThreadProcessId(hWnd, out processId);

            // プロセスIDからProcessクラスのインスタンスを取得
            Process p = Process.GetProcessById(processId);

            // プロセス名を表示
            Console.Write("'{0}' ", p.ProcessName);

            // ウィンドウのキャプションを取得・表示
            StringBuilder caption = new StringBuilder(0x1000);

            Sample.GetWindowText(hWnd, caption, caption.Capacity);

            Console.WriteLine("({0})", caption);

        }
    }
}

Environment.MachineName プロパティ

ローカル コンピュータの NetBIOS 名を取得する。

(NetBIOS名はすべて大文字で、小文字は大文字に自動変換される。)

＜必要条件＞

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)

＜構文＞

public static string MachineName { get; }

'宣言
Public Shared ReadOnly Property MachineName As String
'使用
Dim value As String
value = Environment.MachineName

＜解説＞

コンピュータの名前は、システムの起動時に、名前がレジストリから読み込まれた時点で確定される。

コンピュータがクラスタ内のノードである場合は、ノード名が返される。

＜例＞

実行しているコンピュータの名前を表示するコード例を次に示す。

using System;
class Sample 
{
  public static void Main() 
  {
    Console.WriteLine();
    Console.WriteLine("MachineName: {0}", Environment.MachineName);
  }
}

Imports System
Class Sample
   Public Shared Sub Main()
      Console.WriteLine()
      Console.WriteLine("MachineName: {0}", Environment.MachineName)
   End Sub 'Main
End Class 'Sample

My.Computer.Name プロパティ(VBのみ)

コンピュータ名を取得する。

戻り値にコンピュータの名前を格納した String を返す。

＜必要条件＞

名前空間: Microsoft.VisualBasic.Devices
クラス: Computer、ServerComputer
アセンブリ: Visual Basic ランタイム ライブラリ (Microsoft.VisualBasic.dll 内)

＜構文＞

'宣言
Public ReadOnly Property Name As String
'使用
Dim value As String = My.Computer.Name

＜解説＞

My.Computer.Name プロパティは、MachineName プロパティと同様の機能を提供する。

＜例＞

実行しているコンピュータの名前を表示するコード例を次に示す。

MsgBox("Computer name: " & My.Computer.Name)

即時関数の構文

基本的には、以下のような構文となる。（他にも記述方法がいくつかある）

(function () {
  //処理を記述
})();

また、以下のように引数を指定することもできる。

(function (param1, param2, ...) {
  //処理を記述
})('foo', 'bar', ...);

その他、通常の関数と同様に戻り値を持たせることも可能である。
※この場合、functionを丸括弧で括る必要はない。（理由は後述）

var result = function (param1, param2) {
  return param1 + param2;
}(3, 5);

functionを丸括弧で括る目的

即時関数はfunctionを丸括弧で括ることで実現されているがこの目的は、「関数を式として評価させる為」である。
JavaScriptにはfunction文とfunction式があり、以下のようにfunctionから始まる関数がfunction文、 式の中で関数を定義したもの（つまりfunction以外で始まるもの）がfunction式となる。

//function文
function func() {
}

//function式
var func = function () {
};

因みにfunction文とfunction式では挙動が異なり、function文の場合は実行された際に関数が常に先頭に定義される。その為、function文はコード上のどの位置に存在しても対象の関数を呼び出すことができる。しかし、function式は読込まれた位置で関数が定義される為、記述位置よりも前で実行することはできない。
また、function式であれば、関数呼び出しの演算子”()”をつけて関数定義と同時に関数呼び出しができる。
つまり、即時関数として関数を定義する上でfunctionを丸括弧で括る目的は、関数をfunction文ではなく、function式として扱う為ということになる。
戻り値を変数に代入する即時関数の場合、functionを丸括弧で括る必要がないのも既にfunction式として評価されている為である。
因みにfunction文に関数呼び出しの演算子”()”をつけるとSyntax Errorとなる。

function (){
  console.log("foo");
}();

これはfunction文が”}”で終わったとみなされ、以下のようなイメージで解釈される為である。

function (){
  console.log("foo");
}
(); // <-Syntax Error

“();”は、JavaScriptとして不正な構文となる為、ここでエラーが発生する。
繰り返しになってしまうが、この挙動を回避する為にfunction式の記述にする必要があり、その方法としてfunctionを丸括弧で括る（function以外で始まる）ということに繋がる。

即時関数を利用する目的

即時関数を利用する目的は、スコープを汚染せずに新たなスコープを作成することにある。
JavaScriptのスコープは、「グローバルスコープ」と「関数スコープ（ローカルスコープ）」のみであり、関数は任意にスコープを作る手段と成り得る。
関数スコープの中でvarを使って定義された変数は関数の中でローカルな変数になるので、関数の外側の変数を上書きしない。
再利用されることがない一連の処理の中で一時変数を使用する際、それらの変数をすべてグローバル変数とするとグローバルスコープに不要な変数が積み上がっていき、変数名のバッティング等の予期せぬトラブルが発生する可能性がある。
一連の処理を即時関数で包み一時的なスコープの中で実行することで、プログラムをスコープ上のサンドボックス内で実行することになり、スコープの外側への影響を防ぐことができる。
また、即時関数を利用することで関数そのものを格納する変数も必要がなくなる為、グローバルスコープを全く汚染せずに一時変数を関数スコープ内に包み込むことができる。
その他、一連の処理の結果が不変で結果のみが必要な場合、その結果を得るために何度も同じ処理を実行する必要がなくなるメリットもある。

即時関数の利用イメージ

＜初期化処理への利用＞
ページ読み込み時の初期化処理（一度限りの実行）に利用する。

以下の例は、”label_date”ラベルを用意してページ読み込みと同時に日時を表示している。
一時変数である”label”、”now”、そして処理そのものは初期化終了後には不要となるので、即時関数で包みグローバルスコープの汚染を回避できる。

document.addEventListener('DOMContentLoaded', function() {
  //初期化処理
  (function () {
      //ラベルオブジェクト取得
      var label = document.getElementById('label_date');
      //現在日時を取得
      var now = new Date();
      //ラベルに日時を設定
      label.textContent = now;
  }());
});

以下の例は、ユーザーエージェントの判定を行っている。
判定結果のみが必要であり、判定処理を即時関数とすることで、その結果を取得する為に何度も判定処理を行う必要がなくなる。

var device = function(u) {
  return {
    Tablet:
      (u.indexOf("windows") != -1 && u.indexOf("touch") != -1 && u.indexOf("tablet pc") == -1) 
      || u.indexOf("ipad") != -1
      || (u.indexOf("android") != -1 && u.indexOf("mobile") == -1)
      || (u.indexOf("firefox") != -1 && u.indexOf("tablet") != -1)
      || u.indexOf("kindle") != -1
      || u.indexOf("silk") != -1
      || u.indexOf("playbook") != -1,
    Mobile:
      (u.indexOf("windows") != -1 && u.indexOf("phone") != -1)
      || u.indexOf("iphone") != -1
      || u.indexOf("ipod") != -1
      || (u.indexOf("android") != -1 && u.indexOf("mobile") != -1)
      || (u.indexOf("firefox") != -1 && u.indexOf("mobile") != -1)
      || u.indexOf("blackberry") != -1
  };
}(window.navigator.userAgent.toLowerCase());

console.log(device);

＜プライベートプロパティ／メソッドの定義への利用＞
JavaScriptには、privateやprotected等のアクセス修飾子が無い為、オブジェクト内に定義されたプロパティ／メソッドは、全てパブリックなものとして扱われる。
しかし、即時関数とクロージャを利用することで、疑似的にプライベートなプロパティ／メソッドを実現することができる。

var counter = function() {
  //プライベートメンバ
  var count = 0;
  //countをクロージャで補足したincrementとshowを返す
  return {
    //加算メソッド
    increment: function() {
      count++;
    },
    //ログ出力メソッド
    show: function() {
      console.log(count);
    }
  };
}();
//メソッドの実行
counter.show(); //0が出力される
counter.increment();
counter.increment();
counter.show(); // 2が出力される
console.log(counter.count); // undefinedが出力される

即時関数のいろいろな記述方法

即時関数は、function式として認識させられる構文であれば記述することができる。
つまり、単項演算子から始まる関数を記述すればよい。
単項演算子には”+”、”-“、”!”、”void”、”typeof”等があり、これらも即時関数の記述に利用できる。

(function(){
  console.log("another parentheses");
}());

+function(){
  console.log("plus");
}();

-function(){
  console.log("minus");
}();

!function(){
  console.log("exclamation");
}();

void function(){
  console.log("void");
}();

typeof function(){
  console.log("typeof");
}();

上記は、全て動作する。
但し、丸括弧を利用した場合は戻り値に変化がないが、”+”、”-“の場合は戻り値がnumber型にキャストされ、”!”の場合は戻り値がbool型にキャストされ、”void”の場合は戻り値が常に”undefined”となる。
因みに”new”も単項演算子であるが、スコープ内でのthisの示すものが変わってくるので即時関数を記述する目的での使用は控えた方が良いかと思われる。

Object.createを利用する

// オブジェクト定義
var Dog = {
  name: "REON",
  method: function(){
    console.log( "My name is " + this.name);
  }
};
// 新しいオブジェクトを生成
var dog = Object.create(Dog);
// 新しいオブジェクトのメソッドの実行
dog.method();

上記のようにObject.createに元となるオブジェクトをプロトタイプとして渡すことで、新しいオブジェクトを生成することができる。
但し、そもそもコンストラクタ関数が無いのでコンストラクタ引数に初期値を与えることができない。

Object.createの第二引数

Object.createを利用する上でコンストラクタ引数に相当するものは、第二引数になる。

Object.create(proto [, propertiesObject ])

尚、Object.createの第二引数は以下のように形式が厳密に定義されている。

{
  "プロパティ名": {
    value        : "値",
    writable     : true,
    configurable : false,
    enumerable   : false,
    get          : function(){},
    set          : function(){},
  }
}

フィールド	既定値	内容
value	undefined	プロパティの値。データディスクリプタのみ。
writable	false	trueの場合、値を変更可能。データディスクリプタのみ。
configurable	false	trueの場合、ディスクリプタ変更や、オブジェクトからプロパティ削除が可能。
enumerable	false	trueの場合、対応するオブジェクトのプロパティ列挙に現れる。
get	undefined	Getter関数。アクセサディスクリプタのみ。
set	undefined	Setter関数。アクセサディスクリプタのみ。

上記の規定に従い、オブジェクト生成時に初期値を与えてみる。

// オブジェクト定義
var Dog = {
  name: "REON",
  method: function(){
    console.log( "My name is " + this.name);
  }
};
// 新しいオブジェクトを生成（第二引数で初期値の指定やメソッドの追加ができる）
var dog = Object.create(Dog, {
  name: {
    value: "SANTA"
  },
  bark: {
    value: function() {
      console.log(this.name + " is barking.");
    }
  }
});
// 新しいオブジェクトのメソッドの実行
dog.method();
dog.bark();

上記の例では、プロトタイプに定義したnameの値がオブジェクト生成時に指定した値に書き換わっている。
また、同時に新しいメソッド（bark）を追加している。
尚、nameプロパティを書き換え可能にするには、”{value: “SANTA”, writable: true}”のようにwritableフィールドにtrueを設定する必要がある。
同様にプロパティ列挙に表示したい場合やプロパティの削除を可能にしたい場合も、対応するフィールドの設定をtrueに変更する必要がある。

• 関数呼び出し（グローバルオブジェクト）のパターン
• メソッド呼び出し（所属オブジェクト）のパターン
• コンストラクタ呼び出し（インスタンス自身）のパターン
• apply/call呼び出し（強制変更）のパターン

関数呼び出し（グローバルオブジェクト）のパターン

// 関数定義
function func() {
    this.value= "foo";
    console.log(this);
    console.log(this.value);
}
// 関数呼び出し（thisはグローバルオブジェクトを指す）
func();

この場合、「this」は「グローバルオブジェクト」を指す。
つまり、「value」は「グローバル変数」になる。

メソッド呼び出し（所属オブジェクト）のパターン

// オブジェクト定義
var myObject = {
  value: "bar",
  method: function() {
    console.log(this);
    console.log(this.value);
  }
}
// メソッド呼び出し（thisは所属オブジェクトを指す）
myObject.method();

この場合、「this」はメソッド「method」が所属しているオブジェクトである「myObject」を指す。
因みに以下のようにメソッド呼び出しの中で関数呼び出しをした場合でも関数内の「this」はグローバルを指してしまう為、関数呼び出し時の「this.value」は「undefind」となる。

// オブジェクト定義
var myObject = {
    value: "bar",
    method: function() {
        console.log(this);
        console.log(this.value);
        // 関数定義
        function method() {
            console.log(this);
            console.log(this.value);
        }
        // 関数呼び出し
        method();
    }
};
// メソッド呼び出し
myObject.method();

尚、「this」を別の変数（下記の例では「self」）に格納しておくことで、この問題を解決することができる。

// オブジェクト定義
var myObject = {
    value: "bar",
    method: function() {
        // thisを別の変数に格納
        var self = this;
        console.log(this);
        console.log(self);
        console.log(self.value);
        // 関数定義
        function method() {
            console.log(this);
            console.log(self);
            console.log(self.value);
        }
        // 関数呼び出し
        method();
    }
};
// メソッド呼び出し
myObject.method();

コンストラクタ呼び出し（インスタンス自身）のパターン

// 関数定義（コンストラクタ呼び出しを期待）
function MyObject(value) {
    this.value = value;
    this.increment = function() {
        console.log(this);
        this.value++;
    };
}
// インスタンス生成
var myObject = new MyObject(0);
// インスタンス生成時の値（0）が出力される
console.log(myObject.value);
// インスタンスのメソッド呼出し
myObject.increment();
// インスタンスのメソッド実行後の値（1）が出力される
console.log(myObject.value);
// インスタンスのメソッド呼出し
myObject.increment();
// インスタンスのメソッド実行後の値（2）が出力される
console.log(myObject.value);

この場合、関数にnew演算子をつけてコンストラクタ呼び出しにてインスタンスを生成している為、「this」は生成されるインスタンス自身となる。
尚、new演算子をつけなかった場合、つまり関数呼び出しとなった場合は、「value」、「increment」共にグローバル変数として定義される。
※慣例として関数をコンストラクタ呼び出しで利用する場合、他の関数と区別しやすくする目的で関数名の先頭を大文字とする。

apply/call呼び出し（強制変更）のパターン

// オブジェクト定義
var myObject = {
  value: "foo",
  method: function() {
    console.log(this);
    console.log(this.value);
  }
};
var newObject = {
  value: "bar"
};
// メソッド呼び出し
myObject.method();
// thisの指すオブジェクトを差し替えてメソッド呼び出し
myObject.method.apply(newObject);
myObject.method.call(newObject);

この場合、「this」の指すオブジェクトを「newObject」に差し替えてメソッドが呼び出される為、「newObject」の「value」の値が出力される。
「apply/call」を利用すると「強制的にthisの差し替え」ができる。
「apply/call」の第一引数は、「this」に指定したいオブジェクトになる。
尚、「apply」と「call」の違いは、第二引数の指定の仕方になる。

// オブジェクト定義
var myObject = {
  method: function(value1, value2) {
    console.log(this);
    console.log(this.value + value1 + value2);
  }
};
var newObject = {
  value: "foo"
};
// オブジェクトを差し替えてメソッド呼び出し
myObject.method.apply(newObject, ["bar", "baz"]);
myObject.method.call(newObject, "bar", "baz");

出力結果は、「apply」と「call」共に同じになる。
「apply」は第二引数に配列をとり、配列の中身が引数として渡される。
「call」は、第二引数以降がそのままの形で渡される。

コンストラクタ関数とnew演算子のみで継承

まずは、シンプルに基底となるオブジェクト（コンストラクタ）を元に新しいオブジェクト（インスタンス）を生成する方法で継承をしてみる。
※途中に出てくる”arguments”オブジェクトは、関数呼び出しのタイミングで生成されて呼び出し元から与えられた引数の値を配列で保持している特別なオブジェクト

//基底オブジェクトを定義（プロトタイプ）
function Pet(name) {
  //--コンストラクタの処理を定義--
  //プロパティを設定
  this.name = name;
  this.age = 0;
  console.log("基底オブジェクトのコンストラクタ");
}
//基底オブジェクトのプロトタイプにメソッドを追加
Pet.prototype.countAge = function () {
  this.age += 1;
};

//新しいオブジェクト（Cat）を定義
function Cat(name) {
  //基底オブジェクトのコンストラクタ呼び出し
  Pet.apply(this, arguments);
  //自身のコンストラクタの処理を定義
  console.log("Catオブジェクトのコンストラクタ");
}
//基底オブジェクトを継承
Cat.prototype = new Pet();
//新しいオブジェクト（Cat）のプロトタイプにメソッドを定義
Cat.prototype.sleep = function () {
  console.log(this.name + " is sleeping.");
};

//Catオブジェクトを利用してインスタンス生成
console.log("-----Cat-----");
var cat = new Cat("santa");
cat.countAge();
cat.sleep();
console.log(cat.name + " is " + cat.age + " y.o.");

上記のコードで継承を行っている部分は、”Cat.prototype = new Pet();”にあたる。
うまく動作するように見えるが、実際に実行すると”—–Cat—–“の出力の前に”基底オブジェクトのコンストラクタ”が出力される。
これは、”Cat.prototype = new Pet();”のタイミングで基底オブジェクトのコンストラクタが実行されてしまう為である。
これを回避する為には、以下のように継承部分を変更する必要がある。

//基底オブジェクトを継承
var Func = function () {};
Func.prototype = Pet.prototype;
Cat.prototype = new Func();
Cat.prototype.constructor = Cat;

まず、ダミーのオブジェクト”Func”を定義する。
次に”Func”のプロトタイプに基底オブジェクトのプロトタイプを設定する。
さらに新しいオブジェクト”Cat”のプロトタイプに”Func”から生成したインスタンス（つまり基底オブジェクトのプロトタイプ）を設定する。
最後に新しいオブジェクト”Cat”のプロトタイプに自身のコンストラクタを設定する。
これで継承時に基底オブジェクトのコンストラクタが実行されることがなくなる。

Object.createを利用して継承

上記の継承をECMAScript5で定義されたObject.createを利用すると以下のように表すことができる。（新しいオブジェクト”Cat”のほかに別のオブジェクト”Dog”も追加している）

//基底オブジェクトを定義（プロトタイプ）
function Pet(name) {
  //--コンストラクタの処理を定義--
  //プロパティを設定
  this.name = name;
  this.age = 0;
  console.log("基底オブジェクトのコンストラクタ");
}
//基底オブジェクトのプロトタイプを拡張
Pet.prototype = Object.create(Object.prototype, {
  //プロパティの設定を拡張
  name: {
    writable: true
  },
  age: {
    writable: true
  },
  //自身のコンストラクタをセット
  constructor: {
    value: Pet,
    enumerable: false,
    writable: true,
    configurable: true
  },
  //メソッドを定義
  countAge: {
    value: function () {
      this.age += 1;
    }
  }
});

//新しいオブジェクト（Cat）を定義
function Cat(name) {
  //基底オブジェクトのコンストラクタ呼び出し
  Pet.apply(this, arguments);
  //自身のコンストラクタの処理を定義
  console.log("Catオブジェクトのコンストラクタ");
}
//基底オブジェクトのプロトタイプの継承と拡張
Cat.prototype = Object.create(Pet.prototype, {
  //自身のコンストラクタをセット
  constructor: {
    value: Cat,
    enumerable: false,
    writable: true,
    configurable: true
  },
  //メソッドを定義
  sleep: {
    value: function () {
      console.log(this.name + " is sleeping.");
    }
  }
});

//新しい別のオブジェクト（Dog）を定義
function Dog(name) {
  //基底オブジェクトのコンストラクタ呼び出し
  Pet.apply(this, arguments);
  //自身のコンストラクタの処理を定義
  console.log("Dogオブジェクトのコンストラクタ");
}
//基底オブジェクトのプロトタイプの継承と拡張
Dog.prototype = Object.create(Pet.prototype, {
  //自身のコンストラクタをセット
  constructor: {
    value: Dog,
    enumerable: false,
    writable: true,
    configurable: true
  },
  //メソッドを定義
  bark: {
    value: function () {
      console.log(this.name + " is barking.");
    }
  }
});
//Catオブジェクトを利用してインスタンス生成
console.log("-----Cat-----");
var cat = new Cat("santa");
cat.countAge();
cat.sleep();
console.log(cat.name + " is " + cat.age + " y.o.");
//Dogオブジェクトを利用してインスタンス生成
console.log("-----Dog-----");
var dog = new Dog("reon");
dog.countAge();
dog.bark();
console.log(dog.name + " is " + dog.age + " y.o.");

Object.createの第一引数に基底オブジェクトのプロトタイプを、第二引数に新しいオブジェクト自身のコンストラクタを指定して生成したオブジェクトを新しいオブジェクトのプロトタイプに設定している。（メソッドなどを追加する場合も第二引数に列挙する）
Object.createでオブジェクトを生成する際には、コンストラクタは実行されないので継承時に基底オブジェクトのコンストラクタが実行されることはない。

オブジェクトリテラルでクラスを定義

// オブジェクト定義
var myObject = {
    name: 'myObject',
    method: function() {
        console.log('Hello! ' + this.name);
    }
};
// メンバ変数の参照
console.log(myObject.name);
// メソッドの実行
myObject.method();

JavaScript での最も単純なクラスの定義は、オブジェクトリテラルを使用してオブジェクトを定義する形になる。
尚、あるオブジェクトを元に新しいオブジェクトを生成する場合は、ECMAScript5で規定された「Object.create」を利用して元のオブジェクトをプロトタイプとすることで実現できる。

// オブジェクト定義
var myObject = {
    name: 'myObject',
    method: function() {
        console.log('Hello! ' + this.name);
    }
};
// ECMAScript5規定のObject.createが未定義の場合、Object.createを定義する
if (typeof Object.create !== 'function') {
    Object.create = function(o) {
        var F = function() {};
        F.prototype = o;
        return new F();
    };
}
// 新しいオブジェクトを生成
var newObject = Object.create(myObject);
// 新しいオブジェクトのメンバ変数の値を変更
newObject.name = 'newObject';
// 新しいオブジェクトのメンバ変数の参照
console.log('---newObject---');
console.log(newObject.name);
// 新しいオブジェクトのメソッドの実行
newObject.method();
// 元のオブジェクトのメンバ変数の参照
console.log('---myObject---');
console.log(myObject.name);
// 元のオブジェクトのメソッドの実行
myObject.method();

コンストラクタでクラスを定義

// コンストラクタ定義（関数定義）
function MyClass() {
    //　newを使用してインスタンスを生成すると暗黙的にthisオブジェクトが生成される
    //var this = {};
    
    // メンバ変数定義
    this.name = 'no_name';
    // メソッド定義
    this.method = function() {
        console.log('Hello! ' + this.name);
    };
    
    //　newを使用してインスタンスを生成すると暗黙的にthisオブジェクトがreturnされる
    //return this;
}
// インスタンス生成
var newObject = new MyClass();
// メソッド実行
console.log(newObject.name);
newObject.method();

オブジェクトリテラルではなく、JavaやC#等のクラスベースでのオブジェクト指向のようにクラスを定義する場合は上記のようになる。
そもそもJavaScriptにクラスの概念が無い為、関数定義をnew演算子を使用して呼び出すことでコンストラクタとして働かせ、これをクラスと呼ぶ。
コンストラクタはインスタンスが生成された時に実行される関数のことであり、関数なので引数を与えることもできる。
尚、new演算子を使用しインスタンスを生成するとJavaScriptでは暗黙的に関数内で「this」という空オブジェクトの生成とそのオブジェクトのreturnの2行が追加される。
この為、thisキーワードを使用してメンバ変数を定義することができる。（this.XXX）
また、コンストラクタとしての関数内でthis以外のオブジェクトでreturnを使用するとthisが復帰されなくなってしまう為、コンストラクタとしての関数内ではreturnを使用しない。
その他、メンバ変数に無名関数として処理を代入すれば、インスタンスメソッドとして機能する。
但しこの場合、インスタンスが生成される度にインスタンスが定義され、メモリ領域を圧迫する。
この問題は、prototypeを利用することで解決できる。
※慣例として関数をコンストラクタ呼び出しで利用する場合、他の関数と区別しやすくする目的で関数名の先頭を大文字とする。

prototypeを使う

prototypeは、関数オブジェクトが定義されると自動的に生成されるメンバ変数である。
prototypeは、空オブジェクトへの参照を保持しており、インスタンス内に存在しないメンバ変数が参照された場合、prototypeを参照する。
つまり、prototypeのプロパティは関数オブジェクト自身の親への参照のようなものと捉えることができる。

// 中身が空のクラスを定義
function MyClass(){
}
// 定義したクラスのプロトタイプにプロパティを定義
MyClass.prototype.method = function() {
    console.log('Hello!');
};
// インスタンス生成
var newObject = new MyClass();
// メソッド実行
newObject.method();

上記の例は、中身が空のクラスを定義し、そのクラスのprototypeに対してmethodプロパティを定義することで、newObjectインスタンスからmethodプロパティを呼び出している。
prototypeは、MyClassクラスの親のようなものであり、prototypeにプロパティを定義することでMyClassのインスタンスであるnewObjectからもmethodを呼び出すことができる。
また、このようにprototypeにクラス共通のプロパティを定義をすることで、インスタンス生成の度にインスタンスメソッドが保持されることが無くなり、メモリ領域の圧迫を軽減できる。

改めてJavaScriptでのクラス定義の基本

基本的にJavaScriptでクラスを定義する際には、prototypeに汎用的な関数やクラス共通の変数を定義し、それ以外の変数はメンバ変数としてクラス内に定義することに規定すると理解しやすい。

サンプル

例えば、2桁に合わせる場合は、以下のようにする。

var num = 3;
console.log(('0' + num).slice(-2));

• “‘0’ + num”で元の値の左に”0″を付加する。（元の値が”3″であれば”03″となる）
• “slice(-2)”で右から2文字を切り出す。（”03″を右から2文字切り出すと”03″となる）

元の値が”12″の場合、”0″を付加して”012″となり右から2文字切り出して結果は、”12″となる。

3桁、4桁も同様に”’00’ + num.slice(-3)”や”‘000’ + num.slice(-4)”とすればよい。