プログラミング/リテラル

プログラミングにおいて、リテラルとは、プログラムのソースコード内に直接書かれた、不変の値のことを指します。リテラルの値は固定であり、実行時には変更できません。

リテラルと変数の違いは、変数が値を格納するための場所であるのに対して、リテラルは値自体を表しているという点です。変数の値はプログラムの実行中に変更することができますが、リテラルの値は常に同じであり、プログラムの実行中に変更することはできません。

また、リテラルは、様々なデータ型（整数型、浮動小数点型、文字列型、ブール型など）を表すことができます。データ型によって、リテラルの書き方が変わることがあるので、言語ごとに例を紹介します。

いくつかの言語でのリテラルの例

Python

# 整数のリテラル
x = 10
y = 0b1010 # 2進数リテラル
z = 0o12 # 8進数リテラル
p = 0xa # 16進数リテラル

# 浮動小数点数のリテラル
a = 3.14
b = 1.23e-5 # 指数表記のリテラル

# 文字列リテラル
s1 = "hello"
s2 = 'world'

# 真偽値のリテラル
flag1 = True
flag2 = False

# None型のリテラル
v = None

JavaScript

// 整数のリテラル
var x = 10;
var y = 0b1010; // 2進数リテラル
var z = 0o12; // 8進数リテラル
var p = 0xa; // 16進数リテラル

// 浮動小数点数のリテラル
var a = 3.14;
var b = 1.23e-5; // 指数表記のリテラル

// 文字列リテラル
var s1 = "hello";
var s2 = 'world';

// 真偽値のリテラル
var flag1 = true;
var flag2 = false;

// nullリテラル
var v = null;

C

// 整数のリテラル
int x = 10;
int y = 0b1010; // 2進数リテラル
int z = 012; // 8進数リテラル
int p = 0xa; // 16進数リテラル

// 浮動小数点数のリテラル
double a = 3.14;
double b = 1.23e-5; // 指数表記のリテラル

// 文字列リテラル
char s1[] = "hello";
char s2[] = "world";

// 真偽値のリテラル
int flag1 = 1;
int flag2 = 0;

// nullptrはC18では使用できないため、NULLを使用する
int *v = NULL;

C++

// 整数のリテラル
int x = 10;
int y = 0b1010; // 2進数リテラル
int z = 012; // 8進数リテラル
int p = 0xa; // 16進数リテラル

// 浮動小数点数のリテラル
double a = 3.14;
double b = 1.23e-5; // 指数表記のリテラル

// 文字列リテラル
std::string s1 = "hello";
std::string s2 = "world";

// 真偽値のリテラル
bool flag1 = true;
bool flag2 = false;

// nullptr
int* v = nullptr;

Java

// 整数のリテラル
int x = 10;
int y = 0b1010; // 2進数リテラル
int z = 012; // 8進数リテラル
int p = 0xa; // 16進数リテラル

// 浮動小数点数のリテラル
double a = 3.14;
double b = 1.23e-5; // 指数表記のリテラル

// 文字列リテラル
String s1 = "hello";
String s2 = "world";

// 真偽値のリテラル
boolean flag1 = true;
boolean flag2 = false;

// nullのリテラル
Object v = null;

Kotlin

// 整数のリテラル
val x = 10
val y = 0b1010 // 2進数リテラル
val z = 0o12 // 8進数リテラル（Kotlinではサポートしていません）
val p = 0xa // 16進数リテラル

// 浮動小数点数のリテラル
val a = 3.14
val b = 1.23e-5 // 指数表記のリテラル

// 文字列リテラル
val s1 = "hello"
val s2 = "world"

// 真偽値のリテラル
val flag1 = true
val flag2 = false

// nullのリテラル
val v: Any? = null

Rust

// 整数のリテラル
let x = 10;
let y = 0b1010; // 2進数リテラル
let z = 0o12; // 8進数リテラル
let p = 0xa; // 16進数リテラル

// 浮動小数点数のリテラル
let a = 3.14;
let b = 1.23e-5; // 指数表記のリテラル

// 文字列リテラル
let s1 = "hello";
let s2 = "world";

// 真偽値のリテラル
let flag1 = true;
let flag2 = false;

// nullのリテラル(Rustにはnullのリテラルがなく、代わりにOption型を使用します)
let v: Option<i32> = None;

Go

package main

import "fmt"

func main() {
	// 整数のリテラル
	x := 10
	y := 0b1010 // 2進数リテラル
	z := 012 // 8進数リテラル
	p := 0xa // 16進数リテラル

	// 浮動小数点数のリテラル
	a := 3.14
	b := 1.23e-5 // 指数表記のリテラル

	// 文字列リテラル
	s1 := "hello"
	s2 := "world"

	// 真偽値のリテラル
	flag1 := true
	flag2 := false

	// nilのリテラル(Goにはnullがなく、代わりにnilを使用します)
	var v *int = nil

	fmt.Println(x, y, z, p, a, b, s1, s2, flag1, flag2, v)
}

Scale

// 整数のリテラル
val x = 10
val y = 0b1010 // 2進数リテラル
val z = 0o12 // 8進数リテラル
val p = 0xa // 16進数リテラル

// 浮動小数点数のリテラル
val a = 3.14
val b = 1.23e-5 // 指数表記のリテラル

// 文字列リテラル
val s1 = "hello"
val s2 = 'world' // シングルクォーテーションでもOK

// 真偽値のリテラル
val flag1 = true
val flag2 = false

// シンボルのリテラル
val sym1 = 'foo
val sym2 = 'bar

Ruby

# 整数のリテラル
x = 10
y = 0b1010 # 2進数リテラル
z = 012 # 8進数リテラル
p = 0xa # 16進数リテラル

# 浮動小数点数のリテラル
a = 3.14
b = 1.23e-5 # 指数表記のリテラル

# 文字列リテラル
s1 = "hello"
s2 = 'world'

# 真偽値のリテラル
flag1 = true
flag2 = false

# シンボルのリテラル
sym1 = :foo
sym2 = :bar

Perl

# 整数のリテラル
$x = 10;
$y = 0b1010; # 2進数リテラル
$z = 012; # 8進数リテラル
$p = 0xa; # 16進数リテラル

# 浮動小数点数のリテラル
$a = 3.14;
$b = 1.23e-5; # 指数表記のリテラル

# 文字列リテラル
$s1 = "hello";
$s2 = 'world';

# 真偽値のリテラル
$flag1 = 1; # true
$flag2 = 0; # false

Fortran 90/95/2003

INTEGER :: x = 10, y = 0B1010, z = 0O12, p = 16#A#
REAL :: a = 3.14, b = 1.23e-5
LOGICAL :: flag1 = .TRUE., flag2 = .FALSE.
CHARACTER(LEN=5) :: s1 = "hello", s2 = 'world'

これらの例では、整数リテラルは、二進数表記の0B、八進数表記の0O、16進数表記の16#を使って表現されます。浮動小数点数を表すためには、指数表記のeを使うことができます。文字列リテラルは、"、もしくは、'で囲みます。文字数は、Fortran 90/95/2003 で追加された LEN 属性を使用して指定されます。真偽値は、.TRUE.および.FALSE.を使用して表現されます。

COBOL

IDENTIFICATION DIVISION.
PROGRAM-ID. EXAMPLE-PROGRAM.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 MY-INTEGER PIC 9(2) VALUE 10.
01 MY-STRING PIC X(10) VALUE "hello".
01 MY-BOOLEAN PIC X VALUE 'T'.
01 MY-FLOAT PIC S9(3)V9(2) VALUE -3.14.

PROCEDURE DIVISION.
MAIN-PROCEDURE.
    DISPLAY "My integer: " MY-INTEGER
    DISPLAY "My string: " MY-STRING
    DISPLAY "My boolean: " MY-BOOLEAN
    DISPLAY "My float: " MY-FLOAT
    STOP RUN.

COBOL においては、整数リテラルには PIC 9、小数点以下の桁数には V を使用します。文字列リテラルは、PIC Xを使用して指定されます。真偽値は、'T'および'F'を使用して表現されます。

PL/I

DECLARE X FIXED BIN (8) INIT (10);
DECLARE Y FIXED BIN (8) INIT ('1010'B);
DECLARE Z FIXED BIN (8) INIT ('12'O);
DECLARE P FIXED BIN (8) INIT ('A'X);
DECLARE A FLOAT BINARY (8) INIT (3.14);
DECLARE B FLOAT BINARY (8) INIT (1.23E-5);
DECLARE S1 CHAR (5) INIT ('hello');
DECLARE S2 CHAR (5) INIT ("world");
DECLARE FLAG1 BIT INIT (1);
DECLARE FLAG2 BIT INIT (0);

PL/I では、整数リテラルは、二進数表記のB、八進数表記のO、16進数表記のXを使って表現されます。浮動小数点数を表すためには、指数表記のEを使用することができます。文字列リテラルは、シングルクォート '' 、もしくは、ダブルクォート "" で囲みます。真偽値は、BITデータ型を使用して表現されます。1が真、0が偽を表します。

APL

整数のリテラル
x ← 10
y ← 2 2⍴1 0 1 0  ⍝ 2進数リテラル
z ← 10           ⍝ 10進数リテラル
p ← 16⍴10        ⍝ 16進数リテラル

浮動小数点数のリテラル
a ← 3.14
b ← 1E¯5        ⍝ 指数表記のリテラル

文字列リテラル
s1 ← 'hello'
s2 ← 'world'

真偽値のリテラル
flag1 ← 1
flag2 ← 0

null ポインター
v ← ⍬           ⍝ null ポインターは空のリストで表現する

FORTH

FORTHでは、全ての値はスタックに積んで扱われます。リテラル値は、コロン : とセミコロン ; の間に単純なワードとして記述されます。具体例を以下に示します。

: x 10 ;
: y 0b1010 ;
: z 012 ;
: p 0xa ;
: a 3.14 ;
: b 1.23e-5 ;
: s1 ." hello" ;
: s2 ." world" ;
: flag1 true ;
: flag2 false ;
: v NULL ;

ここで、x、y、z、p、a、b、s1、s2、flag1、flag2、vはそれぞれスタック上にリテラル値を積みます。s1とs2の場合、文字列を積むために.を使っています。また、vの場合、NULLポインタを積むためにNULLを使っています。

PASCAL

PASCALでは、リテラル値は通常の変数に代入することによって使用されます。具体例を以下に示します。

var x: integer = 10;
var y: byte = %1010; // 2進数リテラル
var z: integer = 012; // 8進数リテラル
var p: integer = $a; // 16進数リテラル
var a: real = 3.14;
var b: real = 1.23e-5;
var s1: string = 'hello';
var s2: string = 'world';
var flag1: boolean = true;
var flag2: boolean = false;
var v: pointer = nil;

ここで、x、y、z、p、a、b、s1、s2、flag1、flag2、vは、それぞれリテラル値を代入された変数です。整数型変数に%を付けることで2進数、$を付けることで16進数、先頭が0であれば8進数のリテラルを表現できます。文字列はシングルクオートで囲みます。NULLポインタはnilで表現します。

まとめ

このように、リテラルとは、プログラムで使われる値のうち、変更されずに固定された値を表す表記法です。 異なるデータ型によってリテラルの表記法が異なりますが、変数とは性質が異なるため、区別しておく必要があります。

変わったリテラル表現をもったプログラミング言語

いくつかの変わったリテラル表現をもったプログラミング言語を紹介します：

1. APL：APLは、行列演算に特化しています。APLには多くの独自のリテラル表現があります。たとえば、4x4の単位行列を作成するには、以下のように入力します：⍳4 4=⍳4 4。
2. Perl：Perlは、正規表現や文字列処理を強化した汎用スクリプト言語です。Perlには、文字列リテラル内で変数を埋め込むための特殊な構文があります。たとえば、 $var を文字列に埋め込むことができます。
3. Haskell： Haskellは、静的型付けの関数型プログラミング言語です。Haskellには、算術演算子や比較演算子に対する特殊な文法があります。たとえば、2乗するために、x ^ 2という式を使用できます。
4. LISP：LISPは、リスト処理に特化しています。LISPには、カッコで囲まれたリスト表現があります。たとえば、(1 2 3)は3つの要素を持つリストです。また、LISPには、'を使用して引用されたリストを作成できます。たとえば、'(1 2 3)は、引用されたリストを表します。