ts-变量声明

var a = 10;
function f() {
    var message = "Hello, world!";

    return message;
}

function f() {
    var a = 10;
    return function g() {
        var b = a + 1;
        return b;
    }
}

var g = f();
g(); // returns 11;

// ======================================

// 作用域规则
// 全局作用域
// 局部作用域

// 这些作用域规则可能会引发一些错误。 其中之一就是，多次声明同一个变量并不会报错：

for(var i=0; i<10;i++){
    function(i){
        setTimeout(function(){consile.log(i)},i*100);
    }(i)
}

for (let i = 0; i < 10 ; i++) {
    setTimeout(function() {console.log(i); }, 100 * i);
}


// 拥有块级作用域的变量的另一个特点是，它们不能在被声明之前读或写。 
// 虽然这些变量始终“存在”于它们的作用域里，但在直到声明它的代码之前的区域都属于时间死区。

// 块级作用域变量的获取

function theCityThatAlwaysSleeps() {
    let getCity;

    if (true) {
        let city = "Seattle";
        getCity = function() {
            return city;
        }
    }

    return getCity();
}

// const 与let相同的作用域规则，但是不能对它们重新赋值。
// 基本原则就是如果一个变量不需要对它写入，那么其它使用这些代码的人也不能够写入它们，并且要思考为什么会需要对这些变量重新赋值。 
// 使用const也可以让我们更容易的推测数据的流动。

// 解构
let input = [1, 2];
let [first, second] = input;
console.log(first); // outputs 1
console.log(second); // outputs 2

// 你可以使用...name语法创建一个剩余变量列表：
let [first, ...rest] = [1, 2, 3, 4];
console.log(first); // outputs 1
console.log(rest); // outputs [ 2, 3, 4 ]

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

console.log(o[‘a‘]);
console.log(o[‘b‘]);

// 数据类型指明

let {a, b}: {a: string, b: number} = o;

function f({a, b = 0} = {a: ""}): void {
    // ...
}
f({a: "yes"}) // ok, default b = 0
f() // ok, default to {a: ""}, which then defaults b = 0
f({}) // error, ‘a‘ is required if you supply an argument

// 要小心使用解构。 从前面的例子可以看出，就算是最简单的解构也会有很多问题