TypeScript: الأنواع الأساسية في TypeScript

let firstName: string = "Charlie";
let lastName: string = 'Wang';
let greeting: string = `Hello, ${firstName} ${lastName}`;

let age: number = 25;         // Integer
let price: number = 9.99;     // Decimals
let hex: number = 0xFF;       // Hexadecimal
let binary: number = 0b1010;  // Binary
let octal: number = 0o744;    // Octal

let isActive: boolean = true;
let hasPermission: boolean = false;

// Defining Different Types of Variables
let title: string = "TypeScript Getting Started";
let version: number = 5.3;
let isPublished: boolean = true;

console.log("Courses：" + title);
console.log("Version：" + version);
console.log("Published：" + isPublished);

Courses：TypeScript Getting Started
Version：5.3
Published：true

let notAssigned: undefined = undefined;
let emptyValue: null = null;

// strictNullChecks: false（Default Relaxed Mode）
let name: string = null;         // ✅ No errors，But at runtime name.toUpperCase() It will crash

// strictNullChecks: true（Strict Mode，Recommendations）
let name2: string = null;        // ❌ Error：You cannot null Assign to string
let name3: string | null = null; // ✅ Correct：An explicit declaration might be null

let id1: symbol = Symbol("id");
let id2: symbol = Symbol("id");

console.log(id1 === id2);  // false —— Even if the descriptions are the same，Each symbol They are all unique.

let uniqueKey: symbol = Symbol("secret");

let user = {
  name: "Diana",
  age: 20
};

// Use symbol as a property key，Does not conflict with other attributes
user[uniqueKey] = "Hide Data";

console.log(user.name);        // Normal Access
console.log(user[uniqueKey]);  // Visit symbol Key value

Diana
Hide Data

let big1: bigint = 100n;                        // Literal Notation
let big2: bigint = BigInt(9007199254740991);     // Function Syntax

// number Upper Limit for Secure Integers
let maxSafe: number = Number.MAX_SAFE_INTEGER;  // 9007199254740991
let overflow: number = 9007199254740992;        // Outside the safety range，Loss of Accuracy！

// bigint No loss of precision
let safe: bigint = 9007199254740992n;           // Precise representation

// number Accuracy is lost when the safe range is exceeded
let a: number = 9007199254740992;
let b: number = 9007199254740993;
console.log(a === b);  // true！Two different numbers are actually equal

// bigint Precise representation
let c: bigint = 9007199254740992n;
let d: bigint = 9007199254740993n;
console.log(c === d);  // false —— Distinguish Correctly

true
false

// ✅ Recommendations：Omit the type annotation when a variable has an initial value（Type inference is sufficient）
let name = "Charlie";
let age = 20;

// ✅ Recommendations：Explicitly Labeling Function Parameters and Return Values
function greet(name: string): string {
  return "Hello, " + name;
}

// ✅ Recommendations：Explicitly label when there is no initial value
let userId: number;
let isActive: boolean;

// ❌ Not recommended：Why include annotations when there are initial values?（Redundancy）
let name2: string = "Charlie";  // Superfluous——TypeScript It has already been deduced.