数として読む — 入力が整数かを確かめる

<?php
// 受け取った文字列が整数なら2倍にして出す。整数でなければ、そう伝える
$s = $argv[1];
// is_numeric は前の空白・「+」・小数も数とみなすので、先に「-? と半角数字だけ」かを確かめる
if (!preg_match('/\A-?[0-9]+\z/', $s)) {
    echo "整数ではありません\n";
    exit;
}

// PHP の整数に入らない数は (int) で別の数に変わるので、先に桁数で「大きすぎる」かを決める（10の18乗は19桁）
$digits = ltrim(ltrim($s, '-'), '0');
if (strlen($digits) > 19 || (strlen($digits) === 19 && $digits !== '1000000000000000000')) {
    echo "大きすぎます\n";
    exit;
}

$n = (int) $s;
echo $n . " の2倍は " . ($n * 2) . "\n";

# 受け取った文字列が整数なら2倍にして出す。整数でなければ、そう伝える
import re
import sys

s = sys.argv[1]
# int() は前後の空白・全角の数字・「+」・「_」も受け付けるので、先に「-? と半角数字だけ」かを確かめる
if not re.fullmatch(r"-?[0-9]+", s):
    print("整数ではありません")
    sys.exit()

n = int(s)  # Python の整数には上限が無いので、20桁でもそのまま比べられる
if abs(n) > 10**18:
    print("大きすぎます")
else:
    print(f"{n} の2倍は {n * 2}")

// 受け取った文字列が整数なら2倍にして出す。整数でなければ、そう伝える
package main

import (
	"fmt"
	"os"
	"regexp"
	"strconv"
	"strings"
)

func main() {
	s := os.Args[1]
	// strconv.Atoi は「+5」も受け付けるので、先に「-? と半角数字だけ」かを確かめる
	if !regexp.MustCompile(`^-?[0-9]+$`).MatchString(s) {
		fmt.Println("整数ではありません")
		return
	}

	// int64 に入らない数は直すとエラーになるので、先に桁数で「大きすぎる」かを決める（10の18乗は19桁）
	digits := strings.TrimLeft(strings.TrimPrefix(s, "-"), "0")
	if len(digits) > 19 || (len(digits) == 19 && digits != "1000000000000000000") {
		fmt.Println("大きすぎます")
		return
	}

	n, _ := strconv.ParseInt(s, 10, 64) // ここまで来れば必ず int64 に入る
	fmt.Printf("%d の2倍は %d\n", n, n*2)
}

// 受け取った文字列が整数なら2倍にして出す。整数でなければ、そう伝える
const s = process.argv[2];
// Number() は空の文字列を 0 に、" 12" や "0x1A" も数にするので、先に「-? と半角数字だけ」かを確かめる
if (!/^-?[0-9]+$/.test(s)) {
  console.log("整数ではありません");
  process.exit();
}

// 普通の数（Number）は 2の53乗 を超えると1の位がずれるので、大きい整数を正しく持てる BigInt を使う
const n = BigInt(s);
const limit = 10n ** 18n;
if (n > limit || n < -limit) {
  console.log("大きすぎます");
} else {
  console.log(`${n} の2倍は ${n * 2n}`);
}

// 受け取った文字列が整数なら2倍にして出す。整数でなければ「整数ではありません」と出す
import java.math.BigInteger;

public class ParseInt {
    public static void main(String[] args) {
        String s = args[0];
        // Long.parseLong は「+5」や全角の「１２」も受け付けるので、先に「-? と半角の数字だけ」かを確かめる
        if (!s.matches("-?[0-9]+")) {
            System.out.println("整数ではありません");
            return;
        }
        // long に入りきらない桁数でも比べられるように、大きさに上限のない BigInteger で直す
        BigInteger n = new BigInteger(s);
        if (n.abs().compareTo(BigInteger.TEN.pow(18)) > 0) {
            System.out.println("大きすぎます");
            return;
        }
        System.out.println(n + " の2倍は " + n.multiply(BigInteger.TWO));
    }
}

// 受け取った文字列が整数なら2倍にして出す。整数でなければ「整数ではありません」と出す
using System.Globalization;
using System.Numerics;
using System.Text.RegularExpressions;

string s = args[0];
// long.TryParse は前後の空白や「+5」も受け付けるので、先に「-? と半角の数字だけ」かを確かめる
// （$ は最後の改行の前にも合うので、文字列の終わりは \z と書く）
if (!Regex.IsMatch(s, @"\A-?[0-9]+\z"))
{
    Console.WriteLine("整数ではありません");
    return;
}
// long に入りきらない桁数でも比べられるように、大きさに上限のない BigInteger で直す
BigInteger n = BigInteger.Parse(s, CultureInfo.InvariantCulture);
if (BigInteger.Abs(n) > BigInteger.Pow(10, 18))
{
    Console.WriteLine("大きすぎます");
    return;
}
Console.WriteLine($"{n} の2倍は {n * 2}");

// 受け取った文字列が整数なら2倍にして出す。整数でなければ「整数ではありません」と出す
fn main() {
    let args: Vec<String> = std::env::args().collect();
    let s = &args[1];
    // parse は「+5」も受け付けるので、先に「-? と半角の数字だけ」かを確かめる
    let digits = s.strip_prefix('-').unwrap_or(s);
    if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_digit()) {
        println!("整数ではありません");
        return;
    }
    // i64 に入りきらない桁数でも比べられるように、先頭の0を取った桁数で比べる（同じ桁数なら文字列の比較で大小がわかる）
    let digits = digits.trim_start_matches('0');
    if digits.len() > 19 || (digits.len() == 19 && digits > "1000000000000000000") {
        println!("大きすぎます");
        return;
    }
    let n: i64 = s.parse().unwrap();
    println!("{} の2倍は {}", n, n * 2);
}

# 受け取った文字列が整数なら2倍にして出す。整数でなければ、そう伝える
s = ARGV[0]
# Integer() は前後の空白・「+」・「_」・「0x」も受け付けるので、先に「-? と半角数字だけ」かを確かめる
unless s.match?(/\A-?[0-9]+\z/)
  puts "整数ではありません"
  exit
end

# Integer("010") は 8進数として 8 になるので、10進数と指定する。Ruby の整数には上限が無い
n = Integer(s, 10)
if n.abs > 10**18
  puts "大きすぎます"
else
  puts "#{n} の2倍は #{n * 2}"
end

// 受け取った文字列が整数なら2倍にして出す。整数でなければ「整数ではありません」と出す
import java.math.BigInteger

fun main(args: Array<String>) {
    val s = args[0]
    // toLongOrNull は「+5」や全角の「１２」も受け付けるので、先に「-? と半角の数字だけ」かを確かめる
    if (!Regex("-?[0-9]+").matches(s)) {
        println("整数ではありません")
        return
    }
    // Long に入りきらない桁数でも比べられるように、大きさに上限のない BigInteger で直す
    val n = BigInteger(s)
    if (n.abs() > BigInteger.TEN.pow(18)) {
        println("大きすぎます")
        return
    }
    println("$n の2倍は ${n * BigInteger.TWO}")
}

// 受け取った文字列が整数なら2倍にして出す。整数でなければ「整数ではありません」と出す
let s = CommandLine.arguments[1]
// Int() は「+5」も受け付けるので、先に「-? と半角の数字だけ」かを確かめる
let digits = s.hasPrefix("-") ? String(s.dropFirst()) : s
if digits.isEmpty || !digits.allSatisfy({ $0.isASCII && $0.isNumber }) {
    print("整数ではありません")
} else {
    // Int に入りきらない桁数でも比べられるように、先頭の0を取った桁数で比べる（同じ桁数なら文字列の比較で大小がわかる）
    let trimmed = String(digits.drop(while: { $0 == "0" }))
    if trimmed.count > 19 || (trimmed.count == 19 && trimmed > "1000000000000000000") {
        print("大きすぎます")
    } else {
        let n = Int(s)!
        print("\(n) の2倍は \(n * 2)")
    }
}