Basic Types

C

// ------------------------------------
// Integer
// ------------------------------------

#include <stdint.h> // Since C99
/*
To help with cross-platform portability, C99 defined a
set of fixed-width integers (in the stdint.h header)
that are guaranteed to have the same size on any architecture.
*/

int8_t variable_name_Signed = 10;		// Range: -128 to 127
uint8_t variable_name_Unsigned = 10;	// Range: 0 to 255
int16_t variable_name_Signed = 10;		// Range: -32,768 to 32,767
uint16_t variable_name_Unsigned = 10;	// Range: 0 to 65,535
int32_t variable_name_Signed = 10;		// Range: -2,147,483,648 to 2,147,483,647
uint32_t variable_name_Unsigned = 10;	// Range: 0 to 4,294,967,295
int64_t variable_name_Signed = 10;		// Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
uint64_t variable_name_Unsigned = 10;	// Range: 0 to 18,446,744,073,709,551,615

// Const Declaration
const int16_t MY_CONSTANT = 30;

// Alternative (Classic)
int variable_name = 10; // Signed by default
unsigned int variable_name = 10;
short int variable_name = 10;
short variable_name = 10;
long int variable_name = 10;
long variable_name = 10;
long long int variable_name = 10;
long long variable_name = 10;

// ------------------------------------
// Float & Double
// ------------------------------------

float variable_name = 10.5;
float variable_name = 10.5f;
float variable_name = 10.5F;

double variable_name = 10.5;

// Const Declaration
const float MY_CONSTANT = 12.2;
const float MY_CONSTANT = 12.2f;

const double MY_CONSTANT = 12.2;

// ------------------------------------
// Character
// ------------------------------------

char variable_name = 'a'; // Single Quotes for characters
char variable_name = '\n';

// Const Declaration
const char MY_CONSTANT = '\n';

// ------------------------------------
// Boolean
// ------------------------------------
#include <stdbool.h> // Since C99

bool variable = true; // true expands to 1
bool variable = false; // false expands to 0


// Old Way #1
#define TRUE 1
#define FALSE 0

// Main structure omitted
int variable = TRUE;
int variable = FALSE;

// Old Way #2
typedef enum {FALSE, TRUE} boolean;

// Main structure omitted
boolean variable = TRUE;
boolean variable = FALSE;

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

More Info:

• https://en.wikipedia.org/wiki/C_data_types
• https://pubs.opengroup.org/onlinepubs/009695399/basedefs/stdint.h.html

C++

// Differents mode of initialization

// Copy
std::int32_t variable_name = 5;

// Direct
std::int32_t variable_name( 5 );

// Uniform Initialization (since C++11)
// Also known as Brace Initialization or List Initialization
std::int32_t variable_name{ 5 };

// ------------------------------------
// Integer
// ------------------------------------

#include <cstdint> // Since C++11

std::int8_t variable_name_Signed = 10;		// Range: -128 to 127
std::uint8_t variable_name_Unsigned = 10;	// Range: 0 to 255
std::int16_t variable_name_Signed = 10;		// Range: -32,768 to 32,767
std::uint16_t variable_name_Unsigned = 10;	// Range: 0 to 65,535
std::int32_t variable_name_Signed {10};		// Range: -2,147,483,648 to 2,147,483,647
std::uint32_t variable_name_Unsigned {10};	// Range: 0 to 4,294,967,295
std::int64_t variable_name_Signed {10};		// Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
std::uint64_t variable_name_Unsigned {10};	// Range: 0 to 18,446,744,073,709,551,615

// Const Declaration
/*
Any variable that should not be modifiable after initialization
and whose initializer is not known at compile-time should be
declared as const.
*/
const std::int16_t MY_CONSTANT {30};
std::int16_t const MY_CONSTANT {30};

/*
Any variable that should not be modifiable after initialization
and whose initializer is known at compile-time should be
declared as constexpr.
*/
constexpr std::int16_t MY_CONSTANT {30}; // C++11


// Alternative (Classic)
int variable_name = 10; // Signed by default
unsigned int variable_name = 10;
short int variable_name = 10;
short variable_name = 10;
long int variable_name = 10;
long variable_name = 10;
long long int variable_name = 10;
long long variable_name = 10;

// ------------------------------------
// Float & Double
// ------------------------------------
float variable_name {10.5};
float variable_name {10.5f};
float variable_name {10.5F};
double variable_name {10.5};

// Const Declaration
/*
Any variable that should not be modifiable after initialization
and whose initializer is not known at compile-time should be
declared as const.
*/
const double MY_CONSTANT = {12.2};
double const MY_CONSTANT = {12.2};

/*
Any variable that should not be modifiable after initialization
and whose initializer is known at compile-time should be
declared as constexpr.
*/
constexpr float MY_CONSTANT = {12.2}; // C++11

// ------------------------------------
// Character
// ------------------------------------
char variable_name {'a'}; // Single Quotes for characters
char variable_name = '\n';

// Const Declaration
/*
Any variable that should not be modifiable after initialization
and whose initializer is not known at compile-time should be declared as const.
*/
const char MY_CONSTANT = '\n';
char const MY_CONSTANT = '\n';

/*
Any variable that should not be modifiable after initialization
and whose initializer is known at compile-time should be declared as constexpr.
*/
constexpr char MY_CONSTANT = '\n'; // C++11

// ------------------------------------
// Boolean
// ------------------------------------
bool variable = true;
bool variable = false;

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

More Info:

• https://www.learncpp.com/cpp-tutorial/variable-assignment-and-initialization/
• https://en.cppreference.com/w/cpp/types/integer
• https://www.learncpp.com/cpp-tutorial/fixed-width-integers-and-size-t/
• http://www.cplusplus.com/reference/cstdint/
• https://www.learncpp.com/cpp-tutorial/const-constexpr-and-symbolic-constants/

C#

// ------------------------------------
// Integer
// ------------------------------------
byte variableName = 10;		// Range: 0 to 255
sbyte variableName = 10;	// Range: -128 to 127
short variableName = 10;	// Range: -32,768 to 32,767
ushort variableName = 10;	// Range: 0 to 65,535
int variableName = 10;		// Range: -2,147,483,648 to 2,147,483,647
uint variableName = 10U;	// Range: 0 to 4,294,967,295
long variableName = 10L;
ulong variableName = 10UL;

// Const Declaration
const int MY_CONSTANT = 10;
readonly int myReadonlyValue = 10;

// ------------------------------------
// Float & Double
// ------------------------------------
float variableName = 10.5f;
double variableName = 10.5;
decimal variableName = 10.5m;

// Const Declaration
const double MY_CONSTANT = 10.5;

// ------------------------------------
// Character
// ------------------------------------
char variableName = 'a';
char variableName = '\n';

// ------------------------------------
// Boolean
// ------------------------------------
bool variableName = true;
bool variableName = false;

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

Java

// ------------------------------------
// Integer
// ------------------------------------
byte variableName = 10;		// Range: -128 to 127
short variableName = 10;	// Range: -32,768 to 32,767
int variableName = 10;		// Range: -2,147,483,648 to 2,147,483,647
long variableName = 10L;

// Const Declaration
final int MY_CONSTANT = 10;

// ------------------------------------
// Float & Double
// ------------------------------------
float variableName = 10.5f;
double variableName = 10.5;

// Const Declaration
final double MY_CONSTANT = 10.5;

// ------------------------------------
// Character
// ------------------------------------
char variableName = 'a';
char variableName = '\n';

// ------------------------------------
// Boolean
// ------------------------------------
boolean variableName = true;
boolean variableName = false;

// ------------------------------------
// Type Inference
// ------------------------------------
// Since Java 10, local variables can use "var".
var inferredInteger = 10;

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

Rust

// ------------------------------------
// Integer
// ------------------------------------
let variable_name: i8 = 10;
let variable_name: u8 = 10;
let variable_name: i16 = 10;
let variable_name: u16 = 10;
let variable_name: i32 = 10;
let variable_name: u32 = 10;
let variable_name: i64 = 10;
let variable_name: u64 = 10;
let variable_name: isize = 10;
let variable_name: usize = 10;

// Const Declaration
const MY_CONSTANT: i32 = 10;

// ------------------------------------
// Float
// ------------------------------------
let variable_name: f32 = 10.5;
let variable_name: f64 = 10.5;

// ------------------------------------
// Character
// ------------------------------------
let variable_name: char = 'a';
let variable_name: char = '\n';

// ------------------------------------
// Boolean
// ------------------------------------
let variable_name: bool = true;
let variable_name: bool = false;

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

Go

// ------------------------------------
// Integer
// ------------------------------------
var variableName int8 = 10
var variableName uint8 = 10
var variableName int16 = 10
var variableName uint16 = 10
var variableName int32 = 10
var variableName uint32 = 10
var variableName int64 = 10
var variableName uint64 = 10
var variableName int = 10
var variableName uint = 10

// Const Declaration
const MY_CONSTANT int = 10

// ------------------------------------
// Float
// ------------------------------------
var variableName float32 = 10.5
var variableName float64 = 10.5

// ------------------------------------
// Character / Rune
// ------------------------------------
var variableName rune = 'a'
var variableName byte = 'a'

// ------------------------------------
// Boolean
// ------------------------------------
var variableName bool = true
var variableName bool = false

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

Javascript

/* The let keyword was introduced to JavaScript in ES2015
and is now considered the standard because it’s safer than var.
Many common problems in JavaScript are alleviated by using let,
so you should use it instead of var whenever possible.
*/

// https://www.typescriptlang.org/docs/handbook/basic-types.html#a-note-about-let

// ------------------------------------
// Numerical
// ------------------------------------

// In Javascript, all numbers are floating point values.

let variableName = 10;
const variableName = 10;
const MY_CONSTANT = 10;
var variableName = 10; // Avoid "var"

let variableName = 10.2;
const variableName = 10.2;
const MY_CONSTANT = 10.2;

// A BigInt is created by appending n to the end of an integer
// or by calling the constructor.
let variableName = 10n;
/* The BigInt type is a numeric primitive in JavaScript
 that can represent integers with arbitrary precision.
 With BigInts, you can safely store and operate on large
 integers even beyond the safe integer limit for Numbers.
*/

// ------------------------------------
// Character
// ------------------------------------
let variableName = 'a';
let variableName = "a";
let variableName = "\n";
const variableName = "a";
const MY_CONSTANT = "a";

// ------------------------------------
// Boolean
// ------------------------------------
let variableName = true;
let variableName = false;

// You can also do some conversion
let variableName = Boolean(expression); // without the word "new"

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

More Info:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean

Typescript

/* The let keyword was introduced to JavaScript in ES2015
and is now considered the standard because it’s safer than var.
Many common problems in JavaScript are alleviated by using let,
so you should use it instead of var whenever possible.
*/

// https://www.typescriptlang.org/docs/handbook/basic-types.html#a-note-about-let

// ------------------------------------
// Numerical
// ------------------------------------

// In Javascript, all numbers are floating point values.

let variableName: number = 10;
let variableName: any = 10;
const variableName: number = 10;
const MY_CONSTANT: number = 10;

let variableName: number = 10.2;
let variableName: any = 10.2;
const variableName: number = 10.2;
const MY_CONSTANT: number = 10.2;

let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

/* The BigInt type is a numeric primitive in JavaScript
 that can represent integers with arbitrary precision.
 With BigInts, you can safely store and operate on large
 integers even beyond the safe integer limit for Numbers.
*/
let variableName: bigint = 10n;
let variableName: BigInt(10);

// ------------------------------------
// Character
// ------------------------------------
let variableName: string = 'a';
let variableName: string = "a";
let variableName: string = "\n";
const variableName: string = "a";
const MY_CONSTANT: string = "a";

// ------------------------------------
// Boolean
// ------------------------------------
let variableName: boolean = true;
let variableName: boolean = false;

// You can also do some conversion
let variableName = Boolean(expression); // without the word "new"

// ------------------------------------
// Strings
// ------------------------------------

// For Strings, check the dedicated section

More Info:

• https://www.typescriptlang.org/docs/handbook/basic-types.html#number
• https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-2.html#bigint

Python

# In Python if you declare a variable in a block scope (if statement, for statement, ...)
# the variable is hoisted to the outer function scope.

# ------------------------------------
# Integer
# ------------------------------------
variable_name = 10
MY_CONSTANT = 10

# Type Annotations (PEP 484 / Python 3.6+)
variable_name: int = 10
MY_CONSTANT: int = 10

# ------------------------------------
# Float & Double
# ------------------------------------
variable_name = 10.2
MY_CONSTANT = 10.2

# Type Annotations (PEP 484 / Python 3.6+)
variable_name: float = 10.2
MY_CONSTANT: float = 10.2

# ------------------------------------
# Character
# ------------------------------------
# You can use either single quotes or double
variable_name = "a"
MY_CONSTANT = 'a'

# Type Annotations (PEP 484 / Python 3.6+)
variable_name: str = 'a'
MY_CONSTANT: str = 'a'

# ------------------------------------
# Boolean
# ------------------------------------
variable = True # Must have an Upper Case first letter.
variable = False # Must have an Upper Case first letter.

# Type Annotations (PEP 484 / Python 3.6+)
variable: bool = True

# ------------------------------------
# Strings
# ------------------------------------

# For Strings, check the dedicated section

More Info:

• https://docs.python.org/3/library/typing.html
• https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html
• https://realpython.com/python-type-checking/