パラメータ

• string: 解析する文字列。文字列でない値は文字列に変換されます。
• radix: オプション。解析する際の基数（2〜36）を指定します。デフォルトでは、先頭が「0x」または「0X」の場合に16進数と解釈されます。指定されない場合や0が指定された場合は、10（10進数）として扱われます。

戻り値

指定された文字列から解析された整数を返します。文字列の先頭に有効な数値がない場合は NaN を返します。

基本的な使用法

以下のプログラムは、Number.parseInt() の基本的な使用法を示しています。

// 基本的な数値文字列の解析
console.log(Number.parseInt('42')); // 42
console.log(Number.parseInt('3.14')); // 3
console.log(Number.parseInt('-10.5')); // -10
console.log(Number.parseInt('0042')); // 42

// 先頭の空白は無視される
console.log(Number.parseInt('  42')); // 42

// 数値以外の文字で解析が停止
console.log(Number.parseInt('42abc')); // 42
console.log(Number.parseInt('42.5')); // 42

// 数値で始まらない文字列
console.log(Number.parseInt('abc')); // NaN
console.log(Number.parseInt('')); // NaN

このプログラムでは、Number.parseInt() が様々な文字列を整数に解析する例を示しています。先頭の空白は無視され、数値以外の文字が出現すると解析が停止します。数値で始まらない文字列に対しては NaN を返します。小数点以下は切り捨てられます。

基数（radix）の指定

以下のプログラムは、Number.parseInt() で様々な基数を指定する例を示しています。

// 様々な基数での解析
console.log(Number.parseInt('42', 10)); // 42 (10進数)
console.log(Number.parseInt('2A', 16)); // 42 (16進数)
console.log(Number.parseInt('101010', 2)); // 42 (2進数)
console.log(Number.parseInt('52', 8)); // 42 (8進数)

// 先頭の「0x」と基数の組み合わせ
console.log(Number.parseInt('0x2A')); // 42 (先頭の0xにより16進数と自動判断)
console.log(Number.parseInt('0x2A', 16)); // 42 (16進数として明示的に指定)
console.log(Number.parseInt('0x2A', 10)); // 0 (10進数として指定すると、'0'のみが解析される)

// 基数が不正な場合
console.log(Number.parseInt('42', 1)); // NaN (基数が1は無効)
console.log(Number.parseInt('42', 37)); // NaN (基数が37は無効)
console.log(Number.parseInt('42', 'abc')); // NaN (数値でない基数)

このプログラムでは、Number.parseInt() が様々な基数で文字列を解析する例を示しています。基数は2〜36の範囲で指定でき、指定されない場合は10（または先頭が「0x」の場合は16）が使用されます。

グローバルの parseInt() との比較

以下のプログラムは、Number.parseInt() とグローバルの parseInt() 関数の同等性を示しています。

// Number.parseInt() と グローバルの parseInt() の比較
const testStrings = [
  '42',
  '  -10',
  '3.14',
  '42abc',
  'abc',
  '0xFF', // 16進数表記
  '0b1010', // 2進数表記
  '0o52' // 8進数表記
];

console.log('Number.parseInt() === parseInt():', Number.parseInt === parseInt); // true

console.log('\n結果の比較:');
testStrings.forEach(str => {
  const numResult = Number.parseInt(str, 10);
  const globalResult = parseInt(str, 10);
  console.log(`${str}: ${numResult} === ${globalResult} (${numResult === globalResult})`);
});

このプログラムでは、Number.parseInt() とグローバルの parseInt() 関数が同じ関数オブジェクトを参照していること、および両者が様々な入力に対して同じ結果を返すことを示しています。

数値表記の解析

以下のプログラムは、Number.parseInt() で様々な数値表記を解析する例を示しています。

// 様々な数値表記の解析
console.log(Number.parseInt('42')); // 42 (10進数)
console.log(Number.parseInt('0x1A')); // 26 (16進数)
console.log(Number.parseInt('0b1010')); // 0 (先頭の'0'のみが解析される)
console.log(Number.parseInt('0b1010', 2)); // 0 (先頭の'0'のみが2進数として解析される)
console.log(Number.parseInt('1010', 2)); // 10 (2進数として正しく指定)
console.log(Number.parseInt('0o52')); // 0 (先頭の'0'のみが解析される)
console.log(Number.parseInt('0o52', 8)); // 0 (先頭の'0'のみが8進数として解析される)
console.log(Number.parseInt('52', 8)); // 42 (8進数として正しく指定)
console.log(Number.parseInt('Infinity')); // NaN

このプログラムでは、Number.parseInt() が様々な数値表記をどのように解析するかを示しています。16進数の前置「0x」は自動的に認識されますが、2進数（0b）や8進数（0o）の前置は認識されないため、これらの基数を明示的に指定する必要があります。"Infinity" は数値として有効ではないため NaN が返されます。

ユーザー入力の解析

以下のプログラムは、ユーザー入力から整数を解析する例を示しています。

// フォーム入力から整数を解析するクラス
class IntegerInputProcessor {
  constructor(minValue = null, maxValue = null) {
    this.minValue = minValue;
    this.maxValue = maxValue;
  }
  
  // 入力を整数に解析
  parseUserInput(input, radix = 10) {
    // 入力の検証
    if (input === null || input === undefined || input === '') {
      return { valid: false, value: 0, error: '入力が空です' };
    }
    
    // 数値に変換
    const parsedValue = Number.parseInt(input, radix);
    
    // NaN チェック
    if (Number.isNaN(parsedValue)) {
      return { valid: false, value: 0, error: '有効な整数ではありません' };
    }
    
    // 範囲のチェック
    if (this.minValue !== null && parsedValue < this.minValue) {
      return { 
        valid: false, 
        value: this.minValue, 
        error: `値は最小値 ${this.minValue} 以上である必要があります` 
      };
    }
    
    if (this.maxValue !== null && parsedValue > this.maxValue) {
      return { 
        valid: false, 
        value: this.maxValue, 
        error: `値は最大値 ${this.maxValue} 以下である必要があります` 
      };
    }
    
    return {
      valid: true,
      value: parsedValue,
      formatted: this.formatNumber(parsedValue)
    };
  }
  
  // 数値を読みやすい形式にフォーマット
  formatNumber(num) {
    return num.toLocaleString();
  }
}

// 使用例
const processor = new IntegerInputProcessor(1, 100);

// 有効な入力
console.log(processor.parseUserInput('42'));
// { valid: true, value: 42, formatted: '42' }

console.log(processor.parseUserInput('100'));
// { valid: true, value: 100, formatted: '100' }

// 無効な入力
console.log(processor.parseUserInput('abc'));
// { valid: false, value: 0, error: '有効な整数ではありません' }

console.log(processor.parseUserInput('0'));
// { valid: false, value: 1, error: '値は最小値 1 以上である必要があります' }

console.log(processor.parseUserInput('200'));
// { valid: false, value: 100, error: '値は最大値 100 以下である必要があります' }

console.log(processor.parseUserInput(''));
// { valid: false, value: 0, error: '入力が空です' }

このプログラムでは、ユーザー入力から整数を解析し、指定された範囲内かどうかを確認するクラスの例を示しています。Number.parseInt() を使用して入力文字列を整数に変換し、Number.isNaN() で結果が有効かどうかを確認しています。

色コードの解析

以下のプログラムは、16進数の色コードを解析する例を示しています。

// 16進数の色コードを解析するクラス
class ColorParser {
  // 16進数の色コードを RGB 値に変換
  static hexToRGB(hexColor) {
    // 先頭の '#' を削除
    let hex = hexColor.replace(/^#/, '');
    
    // 短縮形式の場合（#RGB）を標準形式（#RRGGBB）に変換
    if (hex.length === 3) {
      hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
    }
    
    // 16進数からRGB成分を抽出
    const r = Number.parseInt(hex.substring(0, 2), 16);
    const g = Number.parseInt(hex.substring(2, 4), 16);
    const b = Number.parseInt(hex.substring(4, 6), 16);
    
    // 無効な値をチェック
    if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
      return { valid: false, error: '無効な色コードです' };
    }
    
    return {
      valid: true,
      r,
      g,
      b,
      rgb: `rgb(${r}, ${g}, ${b})`,
      hex: `#${hex.toUpperCase()}`
    };
  }
  
  // RGB 値を 16進数の色コードに変換
  static rgbToHex(r, g, b) {
    // 範囲の検証
    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
      return { valid: false, error: 'RGB値は0から255の範囲である必要があります' };
    }
    
    // 16進数に変換して2桁に整形
    const hexR = r.toString(16).padStart(2, '0');
    const hexG = g.toString(16).padStart(2, '0');
    const hexB = b.toString(16).padStart(2, '0');
    
    const hex = `#${hexR}${hexG}${hexB}`.toUpperCase();
    
    return {
      valid: true,
      r,
      g,
      b,
      rgb: `rgb(${r}, ${g}, ${b})`,
      hex
    };
  }
}

// 使用例
console.log(ColorParser.hexToRGB('#FF5733'));
// { valid: true, r: 255, g: 87, b: 51, rgb: 'rgb(255, 87, 51)', hex: '#FF5733' }

console.log(ColorParser.hexToRGB('#F53'));
// { valid: true, r: 255, g: 85, b: 51, rgb: 'rgb(255, 85, 51)', hex: '#FF5533' }

console.log(ColorParser.hexToRGB('#XYZ'));
// { valid: false, error: '無効な色コードです' }

console.log(ColorParser.rgbToHex(255, 87, 51));
// { valid: true, r: 255, g: 87, b: 51, rgb: 'rgb(255, 87, 51)', hex: '#FF5733' }

console.log(ColorParser.rgbToHex(300, 0, 0));
// { valid: false, error: 'RGB値は0から255の範囲である必要があります' }

このプログラムでは、16進数の色コードをRGB値に変換する例を示しています。Number.parseInt() を使用して、16進数文字列を整数に変換しています。

IP アドレスの解析

以下のプログラムは、IPアドレスを解析する例を示しています。

// IP アドレスを解析するクラス
class IPAddressParser {
  // IPv4 アドレスを解析
  static parseIPv4(ipString) {
    // IPv4 形式の検証
    const ipPattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
    const match = ipString.match(ipPattern);
    
    if (!match) {
      return { valid: false, error: '無効なIPv4形式です' };
    }
    
    // オクテットを取得して検証
    const octets = [];
    for (let i = 1; i <= 4; i++) {
      const octet = Number.parseInt(match[i], 10);
      
      if (octet < 0 || octet > 255) {
        return { valid: false, error: 'オクテットは0から255の範囲である必要があります' };
      }
      
      octets.push(octet);
    }
    
    // 数値表現（32ビット）を計算
    const numericValue = (octets[0] << 24) | (octets[1] << 16) | (octets[2] << 8) | octets[3];
    
    return {
      valid: true,
      octets,
      numericValue,
      ipString: octets.join('.')
    };
  }
  
  // 数値表現から IPv4 アドレスに変換
  static numericToIPv4(numericIP) {
    if (numericIP < 0 || numericIP > 0xFFFFFFFF) {
      return { valid: false, error: '無効なIP数値です' };
    }
    
    const octets = [
      (numericIP >> 24) & 0xFF,
      (numericIP >> 16) & 0xFF,
      (numericIP >> 8) & 0xFF,
      numericIP & 0xFF
    ];
    
    return {
      valid: true,
      octets,
      numericValue: numericIP,
      ipString: octets.join('.')
    };
  }
}

// 使用例
console.log(IPAddressParser.parseIPv4('192.168.1.1'));
// { valid: true, octets: [192, 168, 1, 1], numericValue: 3232235777, ipString: '192.168.1.1' }

console.log(IPAddressParser.parseIPv4('255.255.255.255'));
// { valid: true, octets: [255, 255, 255, 255], numericValue: 4294967295, ipString: '255.255.255.255' }

console.log(IPAddressParser.parseIPv4('300.168.1.1'));
// { valid: false, error: 'オクテットは0から255の範囲である必要があります' }

console.log(IPAddressParser.parseIPv4('192.168.1'));
// { valid: false, error: '無効なIPv4形式です' }

console.log(IPAddressParser.numericToIPv4(3232235777));
// { valid: true, octets: [192, 168, 1, 1], numericValue: 3232235777, ipString: '192.168.1.1' }

このプログラムでは、IPv4アドレスを解析し、数値表現と変換する例を示しています。Number.parseInt() を使用して、文字列からIPアドレスのオクテットを整数に変換しています。