console.log(eval("40+2"));  // 40+2 是一个表达式，可以执行，在控制台打印 42

// 试图将数据解释为代码
console.log(eval("Hello world!"));  // 引发 SyntaxError: Unexpected identifier 错误

function scriptAt(s: string): number {  // 参数类型为 string
    return s.indexOf("Script");
}

console.log(scriptAt("TypeScript"));
console.log(scriptAt(42));  // 由于参数类型不匹配，这行代码在编译时会报错

// Argument of type '42' is not assignable to parameter of type 'string'

function safeDivide(): number {
    const x: number = 42;  // 使用关键字 const 来声明不可变的常量

    if (x == 0) throw new Error("x should not be 0");

    x = x - 42;  // 因为 x 是不可变的，不能被重新复制，这行代码在编译时会报错

    return 42 / x;
}

// Cannot assign to 'x' because it is a constant.

class SafeDivisor {
    private divisor: number = 1;  // 使用 private 关键字来声明是私有变量

    setDivisor(value: number) {
        if (value == 0) throw new Error("Value should not be 0");

        this.divisor = value;
    }

    divide(x: number): number {
        return x / this.divisor;
    }
}

function exploit() {
    let sd = new SafeDivisor();

    sd.divisor = 0; // 因为 divisor 是私有变量，不能被外部使用，这行代码在编译时会报错
    sd.divide(42);
}

// 使用泛型类型，抽象类型，不必为每种类型都写一个函数
function first<T>(range: T[], p: (elem: T) => boolean)
    : T | undefined {
    for (let elem of range) {
        if (p (elem)) return elem;
    }
}

function findFirstNegativeNumber(numbers: number[])
    : number | undefined {
    return first(numbers, n => n < 0);
}

function findFirstOneCharacterString(strings: string[])
    : string | undefined {
    return first(strings, str => str.length == 1);
}

// 使用类型申明和泛型，可以清楚知道该函数的实参和返回数据类型
declare function first<T>(range: T[],
    p: (elem: T) => boolean): T | undefined;

// 动态类型，未使用 TypeScript 情况下的 JavaScript
function quacker(duck) {
    duck.quack();
}

quacker({ quack: function () { console.log("quack"); } });
quacker(42);  // 这行代码将在运行时报错：Uncaught TypeError: duck.quack is not a function

// 静态类型，使用 Typescript 声明一个 Duck 接口，并在函数参数中声明该类型
interface Duck {
    quack(): void;
}

function quacker(duck: Duck) {
    duck.quack();
}

quacker({ quack: function () { console.log("quack"); } });
quacker(42);  // 这行代码将在编译时报错：Argument of type ‘42’ is not assignable to parameter of type ‘Duck’.

// 弱类型，未指定变量类型，对于字符串和数字类型，在运算时会自动做隐式类型转换
const a = "hello world";
const b = 42;

console.log(a == b);  // false, 在 JavaScript 允许不同类型进行比较
console.log("42" == b);  // true, 在 JavaScript 中 == 运算符会隐式的将二边的值转化为相同类型
console.log("42" === b);  // false, === 运算符会对比是否不同类型

// 强类型，使用 Typescript 声明具体的类型
const a: string =c"hello world";
const b: number = 42;

console.log(a == b);  // 编译时报错：Typescript 不允许不同类型进行比较
console.log("42" == b);  // 编译时报错：Typescript 不允许不同类型进行比较
console.log("42" === b);  // 编译时报错：Typescript 不允许不同类型进行比较

function add(x: number, y: number) {  // 函数并没有指定返回值类型，但编译器可以自动推断出为 number 类型
    return x + y;
}

let sum = add(40, 2);  // sum 并没有显式的指定为 number 类型，但编译器可以自动推断出

// 在 TypeScript 中 nerver 可以代表空类型
function raiseError(message: string): never {  // 该函数只会抛出错误，不会有任何的返回值，因为抛错时程序已经终止
    console.error(`Error "${message}" raised`);
    throw new Error(message);
}

// 在 TypeScript 中 void 可以代表单元类型
function greet(): void {  // 该函数只会打印一段字符串，并不会返回任何有意义的值
    console.log("Hello world!");
}

greet();

function epsilonEqual(a: number, b: number): boolean {
    return Math.abs(a - b) <= Number.EPSILON;  // 检查二个数是否在最大圆整误差内
}

console.log(0.1 + 0.1 + 0.1 == 0.3);  // false，因为JS中处理浮点数的误差，0.1+0.1+0.1为0.30000000000000004
console.log(epsilonEqual(0.1 + 0.1 + 0.1, 0.3));  // true，因为0.3和0.30000000000000004在最大圆整误差内