TS STRUCTURE - Basic TS Types

let isAlive: boolean = false;

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

let name: string = "Cell";
name = 'cellinlab';

let sentence: string = `There is ${name}'s blog.`;

let list: number[] = [1, 2, 3];

let list2: Array<number> = [1, 2, 3];

let x: [string, number];

x = ['hello', 2022]; // OK
// x = [2022, 'hello']; // Error

console.log(x[0].substr(1)); // OK
// console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'

x[3] = 'cellinlab'; // OK, string type can be assigned to '(string | number)'

console.log(x[5].toString()); // OK, 'string' and 'number' both have the 'toString' method

// x[6] = true; // Error, 'boolean' cannot be assigned to '(string | number)'

console.log(`tupleType[0] = ${tupleType[0]}`);
console.log(`tupleType[1] = ${tupleType[1]}`);

[t1, t2] = tupleType;
console.log(`t1 = ${t1}`);
console.log(`t2 = ${t2}`);

let optionalTuple: [string, boolean?];

optionalTuple = ['hello', true];
console.log(`optionalTuple: ${optionalTuple}`); // optionalTuple: 'hello', true

optionalTuple = ['cell'];
console.log(`optionalTuple: ${optionalTuple}`); // optionalTuple: 'cell'

enum Color {Red, Green, Blue};

let c: Color = Color.Green;

enum Color {Red = 1, Green, Blue};

let c: Color = Color.Green;

enum Color {Red = 1, Green = 2, Blue = 4};

let c: Color = Color.Green;

enum Color {Red = 1, Green = 2, Blue = 4};

let colorName: string = Color[2];
console.log(`colorName: ${colorName}`); // colorName: Green

enum DoorState {Open, Closed, Ajar};

let openDoor: DoorState = DoorState.Open;
console.log(`openDoor: ${openDoor}`); // openDoor: 0

let closedDoor: DoorState = DoorState['Closed'];
console.log(`closedDoor: ${closedDoor}`); // closedDoor: 1

enum DoorStateString {
  Open = 'open',
  Closed = 'closed',
  Ajar = 'ajar'
};

let openDoorString: DoorStateString = DoorStateString.Open;
console.log(`openDoorString: ${openDoorString}`); // openDoorString: open

let notSure: any = 4;
notSure = 'maybe a string instead';
notSure = false; // okay, definitely a boolean

let list: any[] = [1, true, 'free'];
list[1] = 100;

function warnUser(): void {
  console.log('This is my warning message');
}

let unusable: void = undefined;

let n: number = null; // Primitive types can be null
n = undefined; // Primitive types can be undefined

let x = null; // same as x: any = null
let y = undefined; // same as y: any = undefined

// let e: Null; // Error
// let f: Undefined; // Error

let n: null = null;

// n = 1; // Error

let u: undefined = undefined;
// u = 'cellinlab'; // Error

function error(message: string): never {
  throw new Error(message);
}

// the output type of fail() is never
function fail() {
  return error('Something failed');
}

// no exit from this function
function infiniteLoop(): never {
  while (true) {
  }
}

let secretKey = Symbol();

let obj = {};

obj[secretKey] = 'secret value'; // Symbol as property
obj[Symbol.toStringTag] = 'test';

let someValue: any = 'this is a string';
let strLength: number = (<string>someValue).length;

let someValue: any = 'this is a string';
let strLength: number = (someValue as string).length;

let input = [1, 2];
let [first, second] = input;
console.log(`first: ${first}, second: ${second}`); // first: 1, second: 2

function f ([first, second]: [number, number]) {
  console.log(`first: ${first}, second: ${second}`);
}

let o = {
  a: 'foo',
  b: 12,
  c: 'bar'
};

let { a, b } = o;
console.log(`a: ${a}, b: ${b}`); // a: foo, b: 12

// You can also give different names to the properties.
let { a: newName1, b: newName2 } = o;
console.log(`newName1: ${newName1}, newName2: ${newName2}`); // newName1: foo, newName2: 12

function keepWholeObject(wholeObject: { a: string, b?: number }) {
  let { a, b = 1001 } = wholeObject;
}

type C = { a: string, b?: number };

function f({ a, b }: C): void {
  console.log(`a: ${a}, b: ${b}`);
}

// Specifying default values
function f2 ({ a, b } = { a: '', b: 0 }): void {
  console.log(`a: ${a}, b: ${b}`);
}
f2() // a: , b: 0