JavaScript--ES6（1）

ES6简介

简介

ES6， 全称 ECMAScript 6.0 ，是 JavaScript 的下一个版本标准，2015.06 发版。

ES6 主要是为了解决 ES5 的先天不足，比如 JavaScript 里并没有类的概念，但是目前浏览器的 JavaScript 是 ES5 版本，大多数高版本的浏览器也支持 ES6，不过只实现了 ES6 的部分特性和功能。

目前各大浏览器基本上都支持 ES6 的新特性，其中 Chrome 和 Firefox 浏览器对 ES6 新特性最友好，IE7~11 基本不支持 ES6。

1. IE浏览器内核：Trident内核，也是俗称的IE内核
2. Chrome浏览器内核：统称为Chromium内核或Chrome内核，以前是Webkit内核，现在是Blink内核
3. Firefox浏览器内核：Gecko内核，俗称Firefox内核
4. Safari浏览器内核：Webkit内核
5. Opera浏览器内核：最初是自己的Presto内核，后来是Webkit，现在是Blink内核

弹窗

alert弹窗

alert弹窗是JS中最常见的弹窗形式，它用于在页面中显示一段提示信息，用户需要点击确认按钮才能继续操作。

alert("这是一个alert弹窗！");

confirm弹窗

confirm弹窗用于在页面中显示一段提示信息，并且包括确认和取消两个按钮，用户根据需要可以选择不同的操作。

confirm("你确定要删除吗？")

最终结果会返回一个布尔值

prompt弹窗

prompt弹窗用于在页面中显示一个可编辑的文本框，用户可以在文本框中输入内容，然后选择确认或取消。

prompt("请输入您的名字")

定时器

setTimeout

一次性定时器：延迟多长时间做某件事情一次

//setTimeout(要执行的代码, 等待的毫秒数)
setTimeout("alert('对不起')", 3000 )

setInterval

setInterval() 方法可按照指定的周期（以毫秒计）来调用函数或计算表达式，直到 clearInterval() 被调用或窗口被关闭。

setInterval(function(){ console.log("Hello") }, 3000)

time和timeEnd

console.time()方法为计算器的起始方法

console.timeEnd() 方法是作为计算器的结束方法

该方法一般用于测试程序执行的时长

console.time();
for (i = 0; i < 10; i++) {
  console.log(i)
}
console.timeEnd()

let和const

let

• 基本用法：

  let a = 0;
  console.log(a);

• 代码块内有效：

{
    let a = 0;
    var b = 1;
    
}
console.log(b); // 1
console.log(a); // ReferenceError: a is not defined

• 不能重复声明

var a = 1;
var a = 2;
console.log(a);  // 2
​
let b = 3;
let b = 4;
console.log(b);  // Identifier 'b' has already been declared

在for循环使用let

for (var i = 0; i < 10; i++) {
  setTimeout(function(){
    console.log(i);
  })
}
// 输出十个 10

for (let j = 0; j < 10; j++) {
  setTimeout(function(){
    console.log(j);
  })
}
// 输出 0~9

变量 i 是用 var 声明的，在全局范围内有效，所以全局中只有一个变量 i, 每次循环时，setTimeout 定时器里面的 i 指的是全局变量 i ，而循环里的十个 setTimeout 是在循环结束后才执行，所以此时的 i 都是 10。

变量 j 是用 let 声明的，当前的 j 只在本轮循环中有效，每次循环的 j 其实都是一个新的变量，所以 setTimeout 定时器里面的 j 其实是不同的变量，即最后输出0~9。

• 不存在变量提升

console.log(a);  //undefined
var a = "banana";
​
console.log(b);  //ReferenceError: b is not defined
let b = "apple";

变量 a 用 var 声明存在变量提升，所以当脚本开始运行的时候，a 已经存在了，但是还没有赋值，所以会输出 undefined。

变量 b 用 let 声明不存在变量提升（即提前声明），在声明变量 b 之前，b 不存在，所以会报错。

const

const 声明一个只读变量，声明之后不允许改变。意味着，一旦声明必须初始化，否则会报错

const arr = [1,3]

 ES6 明确规定，代码块内如果存在 let 或者 const，代码块会对这些命令声明的变量从块的开始就形成一个封闭作用域 ，故在声明之前使用let /const修饰的变量时会报错

注意

• let 和const 关键词声明的变量不具备变量提升（hoisting）特性

• let 和 const 声明只在最靠近的一个块中（花括号内）有效

• 当使用常量 const 声明时，请使用大写变量，如：CAPITAL_CASING

• const 在声明时必须被赋值

• 使用 const 声明复杂类型对象时要慎重

{
  const arr= [5,6];
  arr.push(7);
  console.log(arr); // [5,6,7]
  arr= 10; // TypeError
}

解构赋值

概述

• 解构赋值是对赋值运算符的扩展。

• 是一种针对数组或者对象进行模式匹配，然后对其中的变量进行赋值。

• 在代码书写上简洁且易读，语义更加清晰明了；也方便了复杂对象中数据字段获取。

解构模型

在解构中，有下面两部分参与：

• 解构的源，解构赋值表达式的右边部分。

• 解构的目标，解构赋值表达式的左边部分。

数组模型的结构

• 基本

let [a, b, c] = [1, 2, 3];
console.log(a, b, c); //1 2 3

• 可嵌套

let [a, [[b], c]] = [1, [[2], 3]];
console.log(a, b, c); //1 2 3

• 可忽略

let [a, , b] = [1, 2, 3];
console.log(a, b); //1 3

• 不完全解构

let [a = 1, b] = []; // a = 1, b = undefined

• 剩余运算符

let [a, ...b] = [1, 2, 3];
console.log(a, b); //a = 1, b = [2,3]

• 字符串

在数组的解构中，解构的目标若为可遍历对象，皆可进行解构赋值。可遍历对象即实现 Iterator 接口的数据。

let [a, b, c, d, e] = 'hello';
console.log(a, b, c, d, e); //h e l l o

• 解构默认值

let [a = 2] = []; // a = 2

当解构模式有匹配结果，且匹配结果是 undefined 时，会触发默认值作为返回结果。

let [a = 3, b = a] = [];     // a = 3, b = 3
let [a = 3, b = a] = [1];    // a = 1, b = 1
let [a = 3, b = a] = [1, 2]; // a = 1, b = 2

对象模型的结构

• 基本

let { foo, bar } = { bar: 'bbb' , foo: 'aaa'};
// foo = 'aaa'
// bar = 'bbb'
 
let { baz : foo } = { baz : 'ddd' };
// foo = 'ddd'

• 可嵌套可忽略

let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, { y }] } = obj;
// x = 'hello'
// y = 'world'
let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, {  }] } = obj;
// x = 'hello'

• 不完全解构

let obj = {p: [{y: 'world'}] };
let {p: [{ y }, x ] } = obj;
// x = undefined
// y = 'world'

• 剩余运算符

let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
// a = 10
// b = 20
// rest = {c: 30, d: 40}

• 解构默认值

let {a = 10, b = 5} = {a: 3};
// a = 3; b = 5;
let {a: aa = 10, b: bb = 5} = {a: 3};
// aa = 3; bb = 5;

内置对象的扩展

字符串

子串的识别

ES6 之前判断字符串是否包含子串，用 indexOf 方法，ES6 新增了子串的识别方法

• includes()：返回布尔值，判断是否找到参数字符串。

• startsWith()：返回布尔值，判断参数字符串是否在原字符串的头部。

• endsWith()：返回布尔值，判断参数字符串是否在原字符串的尾部。

以上三个方法都可以接受两个参数，需要搜索的字符串，和可选的搜索起始位置索引

let string = "apple,banana,orange";
string.includes("banana");     // true
string.startsWith("apple");    // true
string.endsWith("apple");      // false
string.startsWith("banana",6)  // true

注意：

• 这三个方法只返回布尔值，如果需要知道子串的位置，还是得用 indexOf 和 lastIndexOf 。

• 这三个方法如果传入了正则表达式而不是字符串，会抛出错误。而 indexOf 和 lastIndexOf 这两个方法，它们会将正则表达式转换为字符串并搜索它。

字符串重复

repeat()：返回新的字符串，表示将字符串重复指定次数返回。

console.log("Hello ".repeat(2));  // "Hello Hello "

如果参数是小数，向下取整

console.log("Hello,".repeat(3.2));  // "Hello,Hello,Hello,"

如果参数是 0 至 -1 之间的小数，会进行取整运算，0 至 -1 之间的小数取整得到 -0 ，等同于 repeat 零次

console.log("Hello,".repeat(-0.5));  // "" 

如果参数是 NaN，等同于 repeat 零次

console.log("Hello,".repeat(NaN));  // "" 

如果参数是负数或者 Infinity ，会报错:

console.log("Hello,".repeat(-1));  
// RangeError: Invalid count value
​
console.log("Hello,".repeat(Infinity));  
// RangeError: Invalid count value

如果传入的参数是字符串，则会先将字符串转化为数字

console.log("Hello,".repeat("hh")); // ""
console.log("Hello,".repeat("2"));  // "Hello,Hello,"

字符串补全

• padStart：返回新的字符串，表示用参数字符串从头部补全原字符串。

• padEnd：返回新的字符串，表示用参数字符串从尾部补全原字符串。

以上两个方法接受两个参数，第一个参数是指定生成的字符串的最小长度，第二个参数是用来补全的字符串。如果没有指定第二个参数，默认用空格填充。

console.log("5".padStart(2,"0"));  // "05"
console.log("5".padEnd(2,"o"));    // "2o"
console.log("h".padStart(3));      // "  h"

如果指定的长度小于或等于原字符串的长度，则返回原字符串:

console.log("hello".padStart(5,"-"));  // "hello"

如果原字符串加上补全字符串长度大于指定长度，则截去超出位数的补全字符串:

console.log("hello".padEnd(10,",world!"));  // "hello,worl"

常用于补全位数：

console.log("250".padStart(5,"0"));  // "00250"

模板字符串

模板字符串相当于加强版的字符串，用反引号 `,除了作为普通字符串，还可以用来定义多行字符串，还可以在字符串中加入变量和表达式。

//普通字符串
let string = `Hello'\n'world`;
console.log(string); 
​
//多行字符串
let string1 =  `Hey,
can you stop angry now?`;
console.log(string1);
​
//变量名写在 ${} 中，${} 中可以放入 JavaScript 表达式。
let name = "Mike";
let age = 27;
let info = `My Name is ${name},I am ${age+1} years old next year.`
console.log(info);
​
//字符串中调用函数
function f(){
  return "have fun!";
}
let string2= `Game start,${f()}`;
console.log(string2);  // Game start,have fun!

注意：模板字符串中的换行和空格都是会被保留的。

数值

数值的表示

• 二进制表示法新写法: 前缀 0b 或 0B 。

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

• 八进制表示法新写法: 前缀 0o 或 0O 。

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

方法

• Number.isFinite()：用于检查一个数值是否为有限的（ finite ），即不是 Infinity

console.log( Number.isFinite(1));   // true
console.log( Number.isFinite(0.1)); // true
 
// NaN 不是有限的
console.log( Number.isFinite(NaN)); // false
 
console.log( Number.isFinite(Infinity));  // false
console.log( Number.isFinite(-Infinity)); // false
 
// Number.isFinate 没有隐式的 Number() 类型转换，所有非数值都返回 false
console.log( Number.isFinite('foo')); // false
console.log( Number.isFinite('15'));  // false
console.log( Number.isFinite(true));  // false
Number.isNaN()

 Number.isNaN同理，用于检查一个数值是否为NaN

用于检查一个值是否为 NaN 。
console.log(Number.isNaN(NaN));      // true
console.log(Number.isNaN('true'/0)); // true
 
// 在全局的 isNaN() 中，以下皆返回 true，因为在判断前会将非数值向数值转换
// 而 Number.isNaN() 不存在隐式的 Number() 类型转换，非 NaN 全部返回 false
Number.isNaN("NaN");      // false
Number.isNaN(undefined);  // false
Number.isNaN({});         // false
Number.isNaN("true");     // false

• Number.parseInt()：从全局移植到 Number 对象的方法，逐步减少全局方法，用于全局变量的模块化。方法的行为没有发生改变。

// 不指定进制时默认为 10 进制
Number.parseInt('12.34'); // 12
 
// 指定进制
Number.parseInt('0011',2); // 3
 
// 与全局的 parseInt() 函数是同一个函数
Number.parseInt === parseInt; // true

 第二个参数范围2-36整数 Number.parseFloat()用于把一个字符串解析成浮点数

Number.parseFloat('123.45')    // 123.45
Number.parseFloat('123.45abc') // 123.45
 
// 无法被解析成浮点数，则返回 NaN
Number.parseFloat('abc') // NaN
 
// 与全局的 parseFloat() 方法是同一个方法
Number.parseFloat === parseFloat // true

 Number.isInteger() 用于判断给定的参数是否为整数。

Number.isInteger(value)
Number.isInteger(0); // true
// JavaScript 内部，整数和浮点数采用的是同样的储存方法,因此 1 与 1.0 被视为相同的值
Number.isInteger(1);   // true
Number.isInteger(1.0); // true
 
Number.isInteger(1.1);     // false
Number.isInteger(Math.PI); // false
 
// NaN 和正负 Infinity 不是整数
Number.isInteger(NaN);       // false
Number.isInteger(Infinity);  // false
Number.isInteger(-Infinity); // false
 
Number.isInteger("10");  // false
Number.isInteger(true);  // false
Number.isInteger(false); // false
Number.isInteger([1]);   // false
 
// 数值的精度超过 53 个二进制位时，由于第 54 位及后面的位被丢弃，会产生误判
Number.isInteger(1.0000000000000001) // true
 
// 一个数值的绝对值小于 Number.MIN_VALUE（5E-324），即小于 JavaScript 能够分辨
// 的最小值，会被自动转为 0，也会产生误判
Number.isInteger(5E-324); // false
Number.isInteger(5E-325); // true
Number.isSafeInteger()
用于判断数值是否在安全范围内。
Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false
Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Math对象的扩展

ES6 在 Math 对象上新增了 17 个数学相关的静态方法，这些方法只能在 Math 中调用。

• Math.cbrt()：用于计算一个数的立方根。

Math.cbrt(1);  // 1
Math.cbrt(0);  // 0
Math.cbrt(-1); // -1
// 会对非数值进行转换
Math.cbrt('1'); // 1
 
// 非数值且无法转换为数值时返回 NaN
Math.cbrt('hhh'); // NaN

• Math.imul()：两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。

// 大多数情况下，结果与 a * b 相同 
Math.imul(1, 2);   // 2

• Math.hypot()：用于计算所有参数的平方和的平方根。勾股定理

Math.hypot(3, 4); // 5

对象

对象字面量

• 属性的简洁表示法：ES6允许对象的属性直接写变量，这时候属性名是变量名，属性值是变量值。

const age = 12;
const name = "Amy";
const person = {age, name};
console.log(person); //{age: 12, name: "Amy"}

• 方法也可以简写：

const person = {
  sayHi(){
    console.log("Hi");
  }
}
person.sayHi();  //"Hi"

• 属性名表达式：ES6允许用表达式作为属性名，但是一定要将表达式放在方括号内。

const obj = {
 ["he"+"llo"](){
   return "Hi";
  }
}
obj.hello();  //"Hi"

注意点：属性的简洁表示法和属性名表达式不能同时使用，否则会报错。

const hello = "Hello";
const obj = {
 [hello]
};
console.log(obj);  //SyntaxError: Unexpected token }
 
const hello = "Hello";
const obj = {
 [hello+"2"]:"world"
};
console.log(obj); //{Hello2: "world"}

对象的扩展运算符

拓展运算符（...）用于取出参数对象所有可遍历属性然后拷贝到当前对象。

• 基本用法

let person = {name: "Amy", age: 15};
let someone = { ...person };
console.log(someone);  //{name: "Amy", age: 15}

• 可用于合并两个对象

let age = {age: 15};
let name = {name: "Amy"};
let person = {...age, ...name};
console.log(person);  //{age: 15, name: "Amy"}

对象的新方法

Object.is(value1, value2)：用来比较两个值是否严格相等，与（===）基本类似。

Object.is("q","q");      // true
Object.is(1,1);          // true
Object.is([1],[1]);      // false
Object.is({q:1},{q:1});  // false

与===的区别

//一是+0不等于-0
Object.is(+0,-0);  //false
+0 === -0  //true
​
//二是NaN等于本身
Object.is(NaN,NaN); //true
NaN === NaN  //false

数组

数组创建

• Array.of()：将参数中所有值作为元素形成数组。

console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4]
 
// 参数值可为不同类型
console.log(Array.of(1, '2', true)); // [1, '2', true]
 
// 参数为空时返回空数组
console.log(Array.of()); // []

• Array.from()：将类数组对象或可迭代对象转化为数组。

// 参数为数组,返回与原数组一样的数组
console.log(Array.from([1, 2])); // [1, 2]
 
// 参数含空位
console.log(Array.from([1, , 3])); // [1, undefined, 3]

• 类数组对象：一个类数组对象必须含有 length 属性，且元素属性名必须是数值或者可转换为数值的字符。

let arr = Array.from({
  0: '1',
  1: '2',
  2: 3,
  length: 3
});
console.log(); // ['1', '2', 3]
 
// 没有 length 属性,则返回空数组
let array = Array.from({
  0: '1',
  1: '2',
  2: 3,
});
console.log(array); // []
 
// 元素属性名不为数值且无法转换为数值，返回长度为 length 元素值为 undefined 的数组  
let array1 = Array.from({
  a: 1,
  b: 2,
  length: 2
});
console.log(array1); // [undefined, undefined]

扩展的方法

• 查找：

  • find()：查找数组中符合条件的元素,若有多个符合条件的元素，则返回第一个元素。

  let arr = Array.of(1, 2, 3, 4);
  console.log(arr.find(item => item > 2)); // 3
   
  // 数组空位处理为 undefined
  console.log([, 1].find(n => true)); // undefined

  • findIndex()：查找数组中符合条件的元素索引，若有多个符合条件的元素，则返回第一个元素索引。

  let arr = Array.of(1, 2, 1, 3);
  // 参数1：回调函数
  // 参数2(可选)：指定回调函数中的 this 值
  console.log(arr.findIndex(item => item = 1)); // 0
   
  // 数组空位处理为 undefined
  console.log([, 1].findIndex(n => true)); //0

• 填充：

  • fill()：将一定范围索引的数组元素内容填充为单个指定的值。

  let arr = Array.of(1, 2, 3, 4);
  // 参数1：用来填充的值
  // 参数2：被填充的起始索引
  // 参数3(可选)：被填充的结束索引，默认为数组末尾
  console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]

• 遍历：

  • entrys()：遍历键值对。

  for(let [key, value] of ['a', 'b'].entries()){
      console.log(key, value);
  }
  // 0 "a"
  // 1 "b"
   
  // 不使用 for... of 循环
  let entries = ['a', 'b'].entries();
  console.log(entries.next().value); // [0, "a"]
  console.log(entries.next().value); // [1, "b"]
   
  // 数组含空位
  console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]

  • keys()：遍历键名。

  for(let key of ['a', 'b'].keys()){
      console.log(key);
  }
  // 0
  // 1
   
  // 数组含空位
  console.log([...[,'a'].keys()]); // [0, 1]

  • values()：遍历键值

  for(let value of ['a', 'b'].values()){
      console.log(value);
  }
  // "a"
  // "b"
   
  // 数组含空位
  console.log([...[,'a'].values()]); // [undefined, "a"]

• 包含：

  • includes()：数组是否包含指定值。注意：与 Set 和 Map 的 has 方法区分；Set 的 has 方法用于查找值；Map 的 has 方法用于查找键名。

  // 参数1：包含的指定值
  [1, 2, 3].includes(1);    // true
   
  // 参数2：可选，搜索的起始索引，默认为0
  [1, 2, 3].includes(1, 2); // false
   
  // NaN 的包含判断
  [1, NaN, 3].includes(NaN); // true

• 嵌套数组转一维数组：

  • flat()

  console.log([1 ,[2, 3]].flat()); // [1, 2, 3]
   
  // 指定转换的嵌套层数
  console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]]
   
  // 不管潜逃多少层
  console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5]
   
  // 自动跳过空位
  console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]

扩展运算符（...）

• 复制数组：

let arr = [1, 2],
    arr1 = [...arr];
console.log(arr1); // [1, 2]
 
// 数组含空位
let arr2 = [1, , 3],
    arr3 = [...arr2];
console.log(arr3); [1, undefined, 3]

• 合并数组：

console.log([...[1, 2],...[3, 4]]); // [1, 2, 3, 4]

Object的扩展

Symbol

ES6 引入了一种新的原始数据类型 Symbol ，表示独一无二的值

let sy = Symbol(10)
let sy2 = Symbol(10)
console.log(sy==sy2)
console.log(typeof Symbol)

Symbol 作为对象属性名时不能用.运算符，要用方括号。因为.运算符后面是字符串，所以取到的是字符串 sy 属性，而不是 Symbol 值 sy 属性。

let syObject = {};
syObject[sy] = "kk";
 
syObject[sy];  // "kk"
syObject.sy;   // undefined

Map和Set

Map

Map 对象保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。

和 Objects 的区别

• 一个 Object 的键只能是字符串或者 Symbols，但一个 Map 的键可以是任意值。
• Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。
• Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。
• Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突

    var m1 = new Map()
    m1.set("age", 20)
    m1.set("name", "karen")
    console.log(m1.size)
    console.log(m1.get("name"))
    console.log(m1.get("age"))

    var m1 = new Map([["name", "karen"], ["age", 20]])
    console.log(m1)

Set

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用

Set 中的特殊值

Set 对象存储的值总是唯一的，所以需要判断两个值是否恒等。有几个特殊值需要特殊对待：

• +0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复；
• undefined 与 undefined 是恒等的，所以不重复；
• NaN 与 NaN 是不恒等的，但是在 Set 中只能存一个，不重复

let mySet = new Set();
mySet.add(1); // Set(1) {1}
mySet.add(5); // Set(2) {1, 5}
mySet.add(5); // Set(2) {1, 5} 这里体现了值的唯一性
mySet.add("text"); 
// Set(3) {1, 5, "text"} 这里体现了类型的多样性
var o = {a: 1, b: 2}; 
mySet.add(o);
mySet.add({a: 1, b: 2}); 
// Set(5) {1, 5, "some text", {…}, {…}} 
// 这里体现了对象之间引用不同不恒等，即使值相同，Set 也能存储

 数组去重

    var arr = [10, 20, 30, 40, 10]
    var s1 = new Set(arr)
    var arr2 = Array.from(s1)
    console.log(s1, arr2)

深拷贝

//方法1. 最简单的方式,缺陷是原型链没有拷贝 函数和null不会拷贝
var copy1 = function (obj) {
    return JSON.parse(JSON.stringify(obj));
}
var a = {a:function(){console.log('hello world')},b:{c:1},c:[1,2,3],d:"wanger",e:new Date(),f:null,g:undefined}
var b = copy1(a)

//方法2.利用自调用
var copy1 = function (obj) { 
    if(obj === null) return null 
    if(typeof obj !== 'object') return obj;
    if(obj.constructor===Date) return new Date(obj); 
    if(obj.constructor === RegExp) return new RegExp(obj);
    var newObj = new obj.constructor ();  //保持继承链
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {   //不遍历其原型链上的属性
            var val = obj[key];
            newObj[key] = typeof val === 'object' ? arguments.callee(val) : val; 
            // 使用arguments.callee解除与函数名的耦合
        }
    }  
    return newObj;  
};