var a=10;
function f(){
var message="hello,world";
return message;
}
function f(){
a=10;
return function g(){
var b=a+1;
return b;
}
}
var g=f();
g();//11var 声明有一些奇怪的作用域规则
The var declaration has some strange scoping rules
function f(shouldinitalize:boolean){
if(shouldinitalize){
var x=10;
}
return x;
}
f(true)//'10'
f(false)//undefined
多次声明同一个变量并不会报错
Repeated declarations of the same variable do not cause errors
function sumMatrix(matrix:number[][]){
var sum=0;
for(var i=0;i<matrix.length;i++){
var currentRow=matrix[i];
for(var i=0;i<currentRow.length;i++){
sum+=currentRow[i];
}
}
return sum;
}for(var i=0;i<10;i++){
setTimeout(function(){console.log(i);},100*i);
}
for(var i=0;i<10;i++){
(function(i){
setTimeout(function(){console.log(i);},100*i)
})(i);
}
function f(input:boolean){
let a=100;
if(input){
let b=a+1;
return b;
}
return b;
}catch语句声明的变量也具有同样的作用域规则
Variables declared by catch statements also have the same scoping rules
try{
throw "wowow"
}catch(e){
console.log("oh well")
}
console.log(e);重定义及屏蔽
Redefinition and Shielding
function f(x){
var x;
var x;
if(true){
var x;
}
}块级作用域需要在不用的块里声明
Block-level scopes need to be declared in unused blocks
function f(condition,x){
if(condition){
let x=100;
return x;
}
return x;
}
f(false,0);//return 0
f(true,0)//return 100在一个嵌套作用域里引一个新的名字称作屏蔽
Lead a new name in a nested scope called shielding
function sumMatrix(matrix:number[][]){
let sum=0;
for(let i=0;i<matrix.length;i++){
var currentRow=matrix[i];
for(let i=0;i<currentRow.length;i++){
sum+=currentRow[i];
}
}
return sum;
}块级作用域变量的获取
Obtaining Block-level Scope Variables
function theCityThatAlwaysSleeps(){
let getCity;
if(true){
let city="Seattle";
getCity=function(){
return city;
}
}
return getCity();
}
for(let i=0;i<10;i++){
setTimeout(function(){console.log(i);},100*i);
}const与let声明类似，他们被赋值后不能再改变，他们拥有与let相同作用域规则，凡事不能对他们重新赋值
Like let declarations, const cannot be changed after they are assigned. They have the same scoping
rules as let, and nothing can be reassigned to them.
const numLivesForCat=9;
const kitty={
name:"Aurora",
numLives:numLivesForCat,
}
//Error
kitty={
name:"Danielle",
numLives:numLivesForCat
}
//all okay
kitty.name="Rory";
kitty.name="Kitty";
kitty.name="Cat";
kitty.numLives--;最简单的解构莫过于数组的解构赋值
The simplest deconstruction is the deconstruction assignment of arrays
let input=[1,2];
let [first,second]=input;
console.log(first);
console.log(second);解构用于已经声明的变量就更好
It's better to deconstruct variables that have been declared
[first,second]=[second,first];作用域函数参数
Scope function parameters
function f([first,second]:[number,number]){
console.log(first);
console.log(second);
}
f(input);使用...语法创建一个剩余变量列表
Create a list of remaining variables using the... Grammar
let[first,...rest]=[1,2,3,4];
console.log(first);
console.log(rest);
//
let [first]=[1,2,3,4];
console.log(first);//1
let[,second,,fourth]=[1,2,3,4];对象解构
Object deconstruction
let o={
a:"foo",
b:12,
c:"bar"
}
let {a,b}=o;就像数组解构，可以用没有声明的赋值
Like array deconstruction, assignments without declarations can be used
({a,b}={a:"baz",b:101});属性命名
Attribute naming
let {a:newName1,b:newName2}=o;
let newName1=o.a;
let newName2=o.b;属性指示类型
Attribute Indicator Type
let{a,b}:{a:string,b:number}=0;默认值可以让你的属性为undefined时使用缺省值
Default values allow you to use default values when your attribute is undefined
function keepWholeObject(wholeObject:{a:string,b?:number}){
let {a,b=1001}=wholeObject;
}函数声明Function declaration
type C={a:string,b?:number}
function f({a,b}:C):void{
}首先你需要知道在默认值之前设置类型
First you need to know what type to set before the default value
function f({a,b}={a:"",b:0}):void{
//...
}
f()
你需要知道在解构属性上给予一个默认或可选的属性来替换主初始化列表
You need to know that the main initialization list is replaced by a default
or optional attribute on the deconstruction attribute.
function f({a,b=0}={a:""}):void{
}
f({a:"yes"})
f()
f({})