JavaScript 是一种基于脚本的编程语言，主要用于在 Web 页面上实现交互式的效果和动态的内容。JavaScript 是一种解释性语言，不需要编译就可以直接在浏览器中运行。

JavaScript 的主要特点包括：

轻量级：JavaScript 代码通常比较短小，可以快速加载和执行。

可移植性：JavaScript 可以在各种不同的浏览器和操作系统上运行。

面向对象编程：JavaScript 支持面向对象编程，包括对象、继承、封装等特性，可以用于构建复杂的软件系统。

客户端脚本语言：JavaScript 主要用于在 Web 页面上实现交互式的效果和动态的内容，可以与 HTML 和 CSS 一起使用。

异步编程：JavaScript 支持异步编程，可以利用回调函数、Promise、async/await 等方式实现异步操作，提高程序的性能和响应能力。

JavaScript 在 Web 开发中扮演着非常重要的角色，它可以用于实现各种交互式的效果和动态的内容，如表单验证、动画效果、AJAX 等。同时，JavaScript 也可以用于开发各种类型的应用程序，如桌面应用程序、移动应用程序等。

如果您想成为一名 Web 开发人员，JavaScript 是必不可少的编程语言之一，需要掌握 JavaScript 的基本语法和常用的开发框架和库，如 React、Angular、Vue 等。掌握 JavaScript 可以帮助您更加高效和灵活地实现 Web 开发中的各种功能和效果，为自己的职业发展和个人成长打下坚实的基础。

JavaScript

在JavaScript中，可以通过在函数定义的参数列表中给参数赋予初始值来设置默认参数值。如果在调用函数时没有提供相应的参数，那么该参数将使用默认值。这个特性在ES6（ECMAScript 2015）中被引入，使得设置默认参数变得简洁且易于理解。

以下是设置默认参数值的一个例子：

```javascript
function greet(name = 'Guest') {
  return `Hello, ${name}!`;
}

console.log(greet('Alice')); // 输出: Hello, Alice!
console.log(greet());         // 输出: Hello, Guest!
```

在这个例子中，我们定义了一个名为`greet`的函数，它接受一个参数`name`。通过使用`=`操作符，我们给`name`赋予了默认值`'Guest'`。当我们调用`greet`函数并传递一个参数时，如`greet('Alice')`，函数使用传递的值。然而，如果我们不提供任何参数，如`greet()`，函数则使用默认值`'Guest'`。

在ES6之前，我们需要在函数体中通过逻辑来检查参数是否被传递，如果没有，则手动设置默认值。下面是一个如何在旧版本的JavaScript中实现默认参数的例子：

```javascript
function greet(name) {
  name = (typeof name !== 'undefined') ? name : 'Guest';
  return `Hello, ${name}!`;
}

console.log(greet('Alice')); // 输出: Hello, Alice!
console.log(greet());         // 输出: Hello, Guest!
```

在这个旧版本的例子中，我们在函数体内部检查`name`参数是否被传递且不是`undefined`。如果是`undefined`，我们则给`name`赋予默认值`'Guest'`。这种方法在ES6之前是常见的做法，但代码比较繁琐且不够直观。随着ES6的默认参数特性的引入，代码变得更加清晰和简洁。

为 javascript 函数设置默认参数值

在HTML5中，`localStorage` 和 `sessionStorage` 可以用来在用户浏览器中存储键值对信息。这两者的主要区别在于数据的持久性和作用域：

- `localStorage` 中的数据会被长期存储，直到主动清除，即使浏览器关闭也依然保留。
- `sessionStorage` 中的数据只在当前的浏览器会话期间有效，关闭浏览器标签或窗口后数据将被清除。

但是，需要注意的是`localStorage`和`sessionStorage`只能直接存储字符串。如果希望存储对象，需要先将对象转化为JSON字符串格式。

下面是存储对象的步骤：

1. 首先，创建一个对象。
2. 使用`JSON.stringify()`方法将对象转换成一个JSON字符串。
3. 使用`localStorage.setItem()`或`sessionStorage.setItem()`方法来存储字符串。

下面是一个具体的例子：

```javascript
// 假设我们有一个要存储的对象
var user = {
  name: "张三",
  age: 30
};

// 将对象转换为JSON字符串
var userString = JSON.stringify(user);

// 存储到localStorage
localStorage.setItem('user', userString);

// 存储到sessionStorage
sessionStorage.setItem('user', userString);
```

在需要读取存储的对象时，可以按照以下步骤进行：

1. 使用`localStorage.getItem()`或`sessionStorage.getItem()`方法来获取存储的字符串。
2. 使用`JSON.parse()`方法将JSON字符串转换回对象。

以下是读取存储对象的例子：

```javascript
// 从localStorage中读取字符串
var storedUserString = localStorage.getItem('user');

// 将字符串转换回对象
var storedUser = JSON.parse(storedUserString);

// 现在storedUser就是之前存储的对象
console.log(storedUser.name); // 输出："张三"
```

同样的步骤也适用于`sessionStorage`。

总结一下，在使用HTML5的Web存储API来存储对象时，需要先将对象转换成字符串再存储，读取时再将字符串转换回对象。这样可以保证对象的结构和数据在存储过程中得以保持。

HTML5 如何在 localstorage 和 sessionstorage 中存储对象？

在JavaScript中，我们可以通过多种方式来动态合并两个对象的属性。其中最常用的方式是使用对象展开运算符（`...`）和`Object.assign`方法。下面分别举例说明这两种方法：

### 使用对象展开运算符（`...`）

对象展开运算符允许我们以一种简洁的语法将一个对象中的所有可枚丽数字属性复制到另一个新的对象当中。以下是一个例子：

```javascript
const object1 = { a: 1, b: 2 };
const object2 = { b: 3, c: 4 };

const mergedObject = { ...object1, ...object2 };
console.log(mergedObject); // 输出: { a: 1, b: 3, c: 4 }
```

在这个例子中，`object1` 和 `object2` 被合并成 `mergedObject`。由于两个对象中都有属性 `b`，`object2` 中的 `b` 的值会覆盖`object1`中`b`的值，因为它在展开操作中后面被指定。

### 使用`Object.assign`方法

`Object.assign` 方法用于将所有可枚举的自有属性从一个或多个源对象复制到目标对象，并返回修改后的目标对象。以下是一个例子：

```javascript
const object1 = { a: 1, b: 2 };
const object2 = { b: 3, c: 4 };

const mergedObject = Object.assign({}, object1, object2);
console.log(mergedObject); // 输出: { a: 1, b: 3, c: 4 }
```

在上面的例子中，我们首先创建了一个空对象 `{}` 作为目标对象，然后将 `object1` 和 `object2` 中的属性复制到这个新对象中。和对象展开运算符一样，如果有重复的属性，后面的源对象会覆盖前面的源对象的同名属性。

### 其他注意点

动态合并对象时，还应该注意以下几点：

1. 对象展开运算符和`Object.assign`都只会进行浅拷贝，这意味着如果对象属性是复杂类型（例如数组或另一个对象），合并后的对象将与源对象共享这个属性的引用。
2. 当我们需要进行深拷贝合并时，可能需要使用递归策略或者使用库如`lodash`的`_.merge`函数，以确保对象中嵌套的对象也被合并。
3. 如果合并的对象中包含相同的属性，那么后面的对象的属性值会覆盖前面对象的属性值。

根据应用场景选择合适的合并策略非常重要，并且在处理大型或复杂的对象时，也要考虑性能和内存的影响。

**ECMAScript 2018 标准方法**

您将使用[对象传播](https://github.com/tc39/proposal-object-rest-spread)：

    let merged = {...obj1, ...obj2};
    

`merged``obj1`现在是和的并集`obj2`。中的属性`obj2`将覆盖 中的属性`obj1`。

    /** There's no limit to the number of objects you can merge.
     *  Later properties overwrite earlier properties with the same name. */
    const allRules = {...obj1, ...obj2, ...obj3};
    

这里还有此语法的[MDN 文档](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax)。如果您使用 babel，则需要[@babel/plugin-proposal-object-rest-spread](https://babeljs.io/docs/en/babel-plugin-proposal-object-rest-spread)插件才能正常工作（该插件包含在[ES2018](https://github.com/tc39/proposals/blob/main/finished-proposals.md)`@babel/preset-env`中）。[](https://github.com/tc39/proposals/blob/main/finished-proposals.md)

**ECMAScript 2015 (ES6) 标准方法**

    /* For the case in question, you would do: */
    Object.assign(obj1, obj2);
    
    /** There's no limit to the number of objects you can merge.
     *  All objects get merged into the first object. 
     *  Only the object in the first argument is mutated and returned.
     *  Later properties overwrite earlier properties with the same name. */
    const allRules = Object.assign({}, obj1, obj2, obj3, etc);
    

（请参阅[MDN JavaScript 参考](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Browser_compatibility)）

* * *

**ES5 及更早版本的方法**

    for (var attrname in obj2) { obj1[attrname] = obj2[attrname]; }
    

请注意，`obj2`如果`obj1`您仍想使用未修改的`obj1`.

如果你使用的框架在你的原型上到处乱七八糟，那么你必须使用像 之类的检查`hasOwnProperty`，但该代码适用于 99% 的情况。

示例函数：

    /**
     * Overwrites obj1's values with obj2's and adds obj2's if non existent in obj1
     * @param obj1
     * @param obj2
     * @returns obj3 a new object based on obj1 and obj2
     */
    function merge_options(obj1,obj2){
        var obj3 = {};
        for (var attrname in obj1) { obj3[attrname] = obj1[attrname]; }
        for (var attrname in obj2) { obj3[attrname] = obj2[attrname]; }
        return obj3;
    }
    

* * *

另外：-[检查此程序](https://jsfiddle.net/fmcajhsv/)以查看 Object.assign 和 spread 语法对象文字之间的差异

jQuery 也有一个实用程序： http: [//api.jquery.com/jQuery.extend/](http://api.jquery.com/jQuery.extend/)。

摘自 jQuery 文档：

    // Merge options object into settings object
    var settings = { validate: false, limit: 5, name: "foo" };
    var options  = { validate: true, name: "bar" };
    jQuery.extend(settings, options);
    
    // Now the content of settings object is the following:
    // { validate: true, limit: 5, name: "bar" }
    

上面的代码将改变名为**的现有对象**_`settings`_。

* * *

如果您想创建一个**新对象**而不修改任何一个参数，请使用以下命令：

    var defaults = { validate: false, limit: 5, name: "foo" };
    var options = { validate: true, name: "bar" };
    
    /* Merge defaults and options, without modifying defaults */
    var settings = $.extend({}, defaults, options);
    
    // The content of settings variable is now the following:
    // {validate: true, limit: 5, name: "bar"}
    // The 'defaults' and 'options' variables remained the same.

Harmony [ECMAScript 2015 (ES6)](http://www.ecma-international.org/ecma-262/6.0/#sec-object.assign)指定了[**`Object.assign`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)哪个将执行此操作。

    Object.assign(obj1, obj2);
    

当前的浏览器支持[越来越好](http://kangax.github.io/compat-table/es6/#test-Object_static_methods_Object.assign)，但如果您正在为不支持的浏览器进行开发，则可以使用[polyfill](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill)。

我在谷歌上搜索了合并对象属性的代码，最终找到了这里。然而，由于没有任何递归合并的代码，我自己编写了它。 （也许 jQuery 扩展是递归的？）无论如何，希望其他人也会发现它很有用。

（现在代码没有使用`Object.prototype`：）

代码
--

    /*
    * Recursively merge properties of two objects 
    */
    function MergeRecursive(obj1, obj2) {
    
      for (var p in obj2) {
        try {
          // Property in destination object set; update its value.
          if ( obj2[p].constructor==Object ) {
            obj1[p] = MergeRecursive(obj1[p], obj2[p]);
    
          } else {
            obj1[p] = obj2[p];
    
          }
    
        } catch(e) {
          // Property in destination object not set; create it and set its value.
          obj1[p] = obj2[p];
    
        }
      }
    
      return obj1;
    }
    

一个例子
----

    o1 = {  a : 1,
            b : 2,
            c : {
              ca : 1,
              cb : 2,
              cc : {
                cca : 100,
                ccb : 200 } } };
    
    o2 = {  a : 10,
            c : {
              ca : 10,
              cb : 20, 
              cc : {
                cca : 101,
                ccb : 202 } } };
    
    o3 = MergeRecursive(o1, o2);
    

**生成对象 o3 像**

    o3 = {  a : 10,
            b : 2,
            c : {
              ca : 10,
              cb : 20,
              cc : { 
                cca : 101,
                ccb : 202 } } };

请注意，[`underscore.js`](http://underscorejs.org/)'s [`extend`\-method](http://underscorejs.org/#extend)在一行中执行此操作：

    _.extend({name : 'moe'}, {age : 50});
    => {name : 'moe', age : 50}

JS 如何动态合并两个对象的属性？

在 JavaScript 中，创建多行字符串可以通过以下几种方式实现：

### 1. 使用传统的转义符 `\n`

在 ES5 及之前的版本中，创建多行字符串通常需要使用换行符 `\n` 来实现换行效果。例如：

```javascript
var multiLineString = "这是第一行。\n" +
                      "这是第二行。\n" +
                      "这是第三行。";
console.log(multiLineString);
```

### 2. 使用数组和 `join` 方法

还可以通过将每一行字符串作为数组的元素，然后使用 `join` 方法将它们连接成一个多行字符串。例如：

```javascript
var multiLineString = [
  "这是第一行。",
  "这是第二行。",
  "这是第三行。"
].join('\n');
console.log(multiLineString);
```

### 3. 使用 ES6 的模板字符串（模板字面量）

在 ES6（ECMAScript 2015）中引入了模板字符串，可用于创建多行字符串。模板字符串使用反引号 (\`) 而不是单引号或双引号，可以直接在字符串中进行换行。例如：

```javascript
var multiLineString = `这是第一行。
这是第二行。
这是第三行。`;
console.log(multiLineString);
```

模板字符串还可以用于插入变量或表达式，这使得构建动态的多行字符串变得十分方便。举例来说，如果我们想在多行字符串中插入变量，可以这样做：

```javascript
var name = "张三";
var multiLineString = `你好，${name}。
欢迎来到JavaScript世界。
这是一个多行字符串的例子。`;
console.log(multiLineString);
```

在实际开发中，我通常会根据具体情况选择使用哪种方法。在 ES6 及更新版本的 JavaScript 中，我会优先选择模板字符串，因为它的语法简洁，易于阅读和编写多行文本内容。

### 更新：

ECMAScript 6 (ES6) 引入了一种新的文字类型，即[**模板文字**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings)。它们有很多功能，变量插值等，但对于这个问题最重要的是，它们可以是多行的。

模板文字由_反引号_分隔：

    var html = `
      <div>
        <span>Some HTML here</span>
      </div>
    `;
    

（注意：我不提倡在字符串中使用 HTML）

[浏览器支持还可以](https://kangax.github.io/compat-table/es6/#test-template_literals)，但是您可以使用[转译器](https://babeljs.io/)来提高兼容性。

* * *

### ES5 原始答案：

Javascript 没有此处文档语法。但是，您可以转义文字换行符，它很接近：

    "foo \
    bar"

ES6 更新：
-------

正如第一个答案提到的，使用 ES6/Babel，您现在只需使用反引号即可创建多行字符串：

    const htmlString = `Say hello to 
    multi-line
    strings!`;
    

插值变量是一项流行的新功能，带有反引号分隔字符串：

    const htmlString = `${user.name} liked your post about strings`;
    

这只是转换为串联：

    user.name + ' liked your post about strings'
    

ES5 原始答案：
---------

> [Google 的 JavaScript 样式指南](https://google.github.io/styleguide/javascriptguide.xml?showone=Multiline_string_literals#Multiline_string_literals)建议使用字符串连接而不是转义换行符：
> 
> **不要这样做：**
> 
>     var myString = 'A rather long string of English text, an error message \
>                     actually that just keeps going and going -- an error \
>                     message to make the Energizer bunny blush (right through \
>                     those Schwarzenegger shades)! Where was I? Oh yes, \
>                     you\'ve got an error and all the extraneous whitespace is \
>                     just gravy.  Have a nice day.';
>     
> 
> 每行开头的空格在编译时无法安全地去除；斜杠后面的空格会导致棘手的错误；虽然大多数脚本引擎都支持这一点，但它不是 ECMAScript 的一部分。
> 
> **使用字符串连接代替：**
> 
>     var myString = 'A rather long string of English text, an error message ' +
>                    'actually that just keeps going and going -- an error ' +
>                    'message to make the Energizer bunny blush (right through ' +
>                    'those Schwarzenegger shades)! Where was I? Oh yes, ' +
>                    'you\'ve got an error and all the extraneous whitespace is ' +
>                    'just gravy.  Have a nice day.';
>

该模式`text = <<"HERE" This Is A Multiline String HERE`在 js 中不可用（我记得在我美好的 Perl 岁月里经常使用它）。

为了对复杂或长的多行字符串进行监督，我有时使用数组模式：

    var myString = 
       ['<div id="someId">',
        'some content<br />',
        '<a href="#someRef">someRefTxt</a>',
        '</div>'
       ].join('\n');
    

或者已经显示的匿名模式（转义换行符），这可能是代码中的一个丑陋的块：

        var myString = 
           '<div id="someId"> \
    some content<br /> \
    <a href="#someRef">someRefTxt</a> \
    </div>';
    

这是另一个奇怪但有效的“技巧” **1**：

    var myString = (function () {/*
       <div id="someId">
         some content<br />
         <a href="#someRef">someRefTxt</a>
        </div>        
    */}).toString().match(/[^]*\/\*([^]*)\*\/\}$/)[1];
    

_外部编辑：[jsfiddle](http://jsfiddle.net/orwellophile/hna15vLw/2/)_

**ES20xx支持使用**[模板字符串](http://www.2ality.com/2011/09/quasi-literals.html)跨越多行字符串：

    let str = `This is a text
        with multiple lines.
        Escapes are interpreted,
        \n is a newline.`;
    let str = String.raw`This is a text
        with multiple lines.
        Escapes are not interpreted,
        \n is not a newline.`;
    

**1**注意：缩小/混淆代码后这将丢失

您_可以_在纯 JavaScript 中使用多行字符串。

该方法基于函数的序列化，其被[定义为依赖于实现的](http://es5.github.io/#x15.3.4.2)。它确实可以在大多数浏览器中工作（见下文），但不能保证它将来仍然可以工作，所以不要依赖它。

使用以下函数：

    function hereDoc(f) {
      return f.toString().
          replace(/^[^\/]+\/\*!?/, '').
          replace(/\*\/[^\/]+$/, '');
    }
    

你可以在这里拥有这样的文档：

    var tennysonQuote = hereDoc(function() {/*!
      Theirs not to make reply,
      Theirs not to reason why,
      Theirs but to do and die
    */});
    

该方法已在以下浏览器中成功测试（未提及=未测试）：

*   浏览器 4 - 10
*   Opera 9.50 - 12（9- 中没有）
*   Safari 4 - 6（不在 3- 中）
*   铬1 - 45
*   Firefox 17 - 21（[16- 没有](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString#Notes)）
*   雷康克 0.7.0 - 0.8.0
*   _Konqueror 4.7.4 不支持_

不过，要小心你的缩小器。它往往会删除评论。对于[YUI 压缩器](http://www.julienlecomte.net/yuicompressor/README)`/*!`，以（就像我使用的那样）开头的注释将被保留。

我认为_真正的_解决方案是使用[CoffeeScript](http://coffeescript.org/#strings)。

ES6 更新：您可以使用反引号，而不是创建带有注释的函数并在注释上运行 toString。正则表达式需要更新为仅删除空格。您还可以使用字符串原型方法来执行此操作：

    let foo = `
      bar loves cake
      baz loves beer
      beer loves people
    `.removeIndentation()
    

有人应该写这个 .removeIndentation 字符串方法...;)

你可以这样做...

    var string = 'This is\n' +
    'a multiline\n' + 
    'string';

JS 如何创建多行字符串？

在JavaScript中，您可以使用`JSON.stringify()`方法来转换JSON对象为其字符串形式，这个方法还可以让我们以非常易读的格式打印JSON数据。`JSON.stringify()`接受三个参数：要序列化的对象，一个可选的替换函数，以及一个可选的数字或字符串来控制缩进。

以下是一个例子，展示了如何使用`JSON.stringify()`方法来以漂亮的格式打印JSON对象：

```javascript
// 假设我们有如下的JSON对象
const myObject = {
  name: "John",
  age: 30,
  cars: ["Ford", "BMW", "Fiat"]
};

// 第三个参数控制缩进，数字2表示每一层缩进两个空格
const prettyJson = JSON.stringify(myObject, null, 2);

console.log(prettyJson);
```

输出将会是：

```
{
  "name": "John",
  "age": 30,
  "cars": [
    "Ford",
    "BMW",
    "Fiat"
  ]
}
```

在这个例子中，我们没有使用替换函数（`JSON.stringify()`的第二个参数），但是它也可以用来过滤或者转换对象中的值。如果你想要自定义某些属性的显示或者排除对象中的一些属性不被打印，可以提供这个函数。

例如，如果我们只想打印`cars`数组中的第二个元素，我们可以这样做：

```javascript
function replacer(key, value) {
  // 如果键是'cars'，只返回数组的第二个元素
  if(key === "cars") {
    return [value[1]];
  }
  return value;
}

// 使用自定义替换函数和缩进
const prettyJson = JSON.stringify(myObject, replacer, 2);

console.log(prettyJson);
```

输出将会是：

```
{
  "name": "John",
  "age": 30,
  "cars": [
    "BMW"
  ]
}
```

这个替换函数只会让`cars`数组中的"BWM"被打印出来。这种方法在处理大型对象或者需要从输出中过滤掉敏感信息时非常有用。

**[漂亮打印是在`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)**.第三个参数启用漂亮的打印并设置要使用的间距：

    var str = JSON.stringify(obj, null, 2); // spacing level = 2
    

如果您需要语法突出显示，您可以使用一些正则表达式魔法，如下所示：

    function syntaxHighlight(json) {
        if (typeof json != 'string') {
             json = JSON.stringify(json, undefined, 2);
        }
        json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
        return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
            var cls = 'number';
            if (/^"/.test(match)) {
                if (/:$/.test(match)) {
                    cls = 'key';
                } else {
                    cls = 'string';
                }
            } else if (/true|false/.test(match)) {
                cls = 'boolean';
            } else if (/null/.test(match)) {
                cls = 'null';
            }
            return '<span class="' + cls + '">' + match + '</span>';
        });
    }
    

请参阅此处的实际操作：[jsfiddle](http://jsfiddle.net/KJQ9K/554/)

**或者下面提供的完整片段：**

显示代码片段

    function output(inp) {
        document.body.appendChild(document.createElement('pre')).innerHTML = inp;
    }
    
    function syntaxHighlight(json) {
        json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
        return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
            var cls = 'number';
            if (/^"/.test(match)) {
                if (/:$/.test(match)) {
                    cls = 'key';
                } else {
                    cls = 'string';
                }
            } else if (/true|false/.test(match)) {
                cls = 'boolean';
            } else if (/null/.test(match)) {
                cls = 'null';
            }
            return '<span class="' + cls + '">' + match + '</span>';
        });
    }
    
    var obj = {a:1, 'b':'foo', c:[false,'false',null, 'null', {d:{e:1.3e5,f:'1.3e5'}}]};
    var str = JSON.stringify(obj, undefined, 4);
    
    output(str);
    output(syntaxHighlight(str));

    pre {outline: 1px solid #ccc; padding: 5px; margin: 5px; }
    .string { color: green; }
    .number { color: darkorange; }
    .boolean { color: blue; }
    .null { color: magenta; }
    .key { color: red; }

Run code snippetHide results

Expand snippet

如果您有一个想要漂亮打印的**对象**，用户 Pumbaa80 的回答非常好。如果您从想要漂亮打印的有效 JSON**字符串**开始，则需要首先将其转换为对象：

    var jsonString = '{"some":"json"}';
    var jsonPretty = JSON.stringify(JSON.parse(jsonString),null,2);  
    

这会从字符串构建一个 JSON 对象，然后使用 JSON stringify 的漂亮打印将其转换回字符串。

更好的方法。

[在 Javascript 中美化 JSON 数组](https://stackoverflow.com/questions/11359291/prettify-json-array-in-javascript)

    JSON.stringify(jsonobj,null,'\t')

我想你正在寻找这样的东西：

    JSON.stringify(obj, null, '\t');
    

这会使用制表符进行缩进，“漂亮地打印”您的 JSON 字符串。

如果您更喜欢使用空格而不是制表符，您也可以使用数字来表示您想要的空格数：

    JSON.stringify(obj, null, 2);

JS 如何漂亮地打印 JSON

在JavaScript中，可以使用多种方法来检查对象中是否存在某个值。这里我将介绍几种常见的办法：

### 使用 `for...in` 循环

这种方法通过遍历对象的所有属性来检查是否有属性的值等于我们要找的值。

```javascript
function hasValue(obj, value) {
  for (let key in obj) {
    if (obj.hasOwnProperty(key) && obj[key] === value) {
      return true;
    }
  }
  return false;
}

// 例子
const person = {
  name: 'Alice',
  age: 25
};

console.log(hasValue(person, 25)); // 输出 true
console.log(hasValue(person, 'Bob')); // 输出 false
```

### 使用 `Object.values()` 和 `Array.prototype.includes()`

`Object.values()` 方法返回一个数组，包含给定对象自身的所有可枚举属性值。结合数组的 `includes()` 方法，可以很容易地检查这个值数组中是否包含特定的值。

```javascript
function hasValue(obj, value) {
  return Object.values(obj).includes(value);
}

// 例子
const person = {
  name: 'Alice',
  age: 25
};

console.log(hasValue(person, 25)); // 输出 true
console.log(hasValue(person, 'Bob')); // 输出 false
```

### 使用 `Object.entries()` 和 `Array.prototype.some()`

`Object.entries()` 方法返回一个给定对象自身可枚举属性的键值对数组。使用数组的 `some()` 方法可以检查数组中至少有一个元素满足提供的函数。

```javascript
function hasValue(obj, value) {
  return Object.entries(obj).some(([key, val]) => val === value);
}

// 例子
const person = {
  name: 'Alice',
  age: 25
};

console.log(hasValue(person, 25)); // 输出 true
console.log(hasValue(person, 'Bob')); // 输出 false
```

### 使用 `JSON.stringify()`

这个方法相对简单粗暴，它将对象转换成字符串，然后检查该字符串中是否包含特定的值。但是请注意，这种方法并不总是可靠的，因为它也可能匹配到对象的键或者结构中的字符串，并且对于对象内嵌套的对象或数组来说，可能无法正确匹配。

```javascript
function hasValue(obj, value) {
  return JSON.stringify(obj).includes(value);
}

// 例子
const person = {
  name: 'Alice',
  age: 25
};

console.log(hasValue(person, 25)); // 输出 true (注意：25被转换成了字符串)
console.log(hasValue(person, 'Bob')); // 输出 false
```

在实际使用中，应根据具体的场景和需求选择最合适的方法。例如，如果你知道值是不会重复的或者是唯一的，那么使用 `Object.values()` 结合 `includes()` 方法可能是最简洁明了的选择。而如果你需要处理更复杂的数据结构，可能需要采用更为复杂的方法，如递归检查嵌套对象。

检查未定义性并不是测试键是否存在的准确方法。如果键存在但值实际上是怎么办`undefined`？

    var obj = { key: undefined };
    console.log(obj["key"] !== undefined); // false, but the key exists!

运行代码片段Hide results

展开片段

您应该使用`in`运算符：

    var obj = { key: undefined };
    console.log("key" in obj); // true, regardless of the actual value

运行代码片段Hide results

展开片段

如果你想检查某个键是否不存在，请记住使用括号：

    var obj = { not_key: undefined };
    console.log(!("key" in obj)); // true if "key" doesn't exist in object
    console.log(!"key" in obj);   // Do not do this! It is equivalent to "false in obj"

运行代码片段Hide results

展开片段

或者，如果您想特别测试对象实例的属性（而不是继承的属性），请使用`hasOwnProperty`：

    var obj = { key: undefined };
    console.log(obj.hasOwnProperty("key")); // true

运行代码片段Hide results

展开片段

`in`有关和`hasOwnProperty`key方法之间的性能比较`undefined`，请参阅[此**基准测试**](https://jsben.ch/WqlIl)：

[![基准测试结果](https://i.stack.imgur.com/PEuZT.png)](https://i.stack.imgur.com/PEuZT.png)

快速回答
====

> 如何检查 JavaScript 对象或数组中是否存在特定键？如果密钥不存在并且我尝试访问它，它会返回 false 吗？或者抛出错误？

使用（关联）数组样式或对象样式直接访问缺失的属性将返回_未定义的_常量。

_操作符_和_hasOwnProperty_方法缓慢而可靠
-----------------------------

正如人们已经在这里提到的，您可以拥有一个具有与“未定义”常量关联的属性的对象。

     var bizzareObj = {valid_key:  undefined};
    

在这种情况下，您必须使用_hasOwnProperty_或_in_运算符来知道密钥是否确实存在。但是，_但是要以什么价格呢？_

所以，我告诉你...

_in_运算符和_hasOwnProperty_是在 Javascript 中使用属性描述符机制的“方法”（类似于 Java 语言中的 Java 反射）。

[http://www.ecma-international.org/ecma-262/5.1/#sec-8.10](http://www.ecma-international.org/ecma-262/5.1/#sec-8.10)

> 属性描述符类型用于解释命名属性的操作和具体化。属性描述符类型的值是由命名字段组成的记录，其中每个字段的名称是属性名称，其值是 8.6.1 中指定的相应属性值。此外，任何字段都可以存在或不存在。

另一方面，调用对象方法或键将使用 Javascript \[\[Get\]\] 机制。这要快得多！

基准
--

[https://jsben.ch/HaHQt](https://jsben.ch/HaHQt)

![比较 JS 中的按键访问](https://i.stack.imgur.com/GjzNU.png)。

#### 使用_in_运算符

    var result = "Impression" in array;
    

结果是

    12,931,832 ±0.21% ops/sec      92% slower 
    

#### 使用 hasOwnProperty

    var result = array.hasOwnProperty("Impression")
    

结果是

    16,021,758 ±0.45% ops/sec     91% slower
    

#### 直接访问元素（括号样式）

    var result = array["Impression"] === undefined
    

结果是

    168,270,439 ±0.13 ops/sec     0.02% slower 
    

#### 直接访问元素（对象样式）

    var result = array.Impression  === undefined;
    

结果是

    168,303,172 ±0.20%     fastest
    

编辑：为属性分配值的原因是什么`undefined`？
---------------------------

这个问题让我很困惑。在 Javascript 中，至少有两个对不存在对象的引用，以避免出现这样的问题：`null`和`undefined`。

`null`是表示故意不存在任何对象值的原始值，或者简单地说，是**确认**缺乏值。另一方面，`undefined`是一个未知值（未定义）。如果存在稍后将使用_适当_值的属性，请考虑使用`null`引用，而不是`undefined`因为在最初时刻**确认**该属性缺乏价值。

比较：

    var a = {1: null}; 
    console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
    console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].
    

建议
--

避免使用具有值的对象`undefined`。尽可能直接检查并用于`null`初始化属性值。否则，请使用慢速`in`运算符或`hasOwnProperty()`方法。

编辑：12/04/2018 - 不再相关
--------------------

正如人们所评论的，现代版本的 Javascript 引擎（Firefox 除外）已经改变了访问属性的方法。对于这种特殊情况，当前的实现比以前的实现慢，但访问密钥和对象之间的差异可以忽略不计。

它会回来的`undefined`。

    var aa = {hello: "world"};
    alert( aa["hello"] );      // popup box with "world"
    alert( aa["goodbye"] );    // popup box with "undefined"

运行代码片段Hide results

展开片段

`undefined`是一个特殊的常数值。所以你可以说，例如

    // note the three equal signs so that null won't be equal to undefined
    if( aa["goodbye"] === undefined ) {
        // do something
    }
    

这可能是检查丢失钥匙的最佳方法。然而，正如下面的评论所指出的，理论上您可能希望实际值为`undefined`。我从来没有需要这样做，也想不出我想要这样做的原因，但为了完整起见，您可以使用运算`in`符

    // this works even if you have {"goodbye": undefined}
    if( "goodbye" in aa ) {
        // do something
    }

1.  **检查对象的属性，包括继承的属性**

可以使用`in`运算符来确定，如果指定的属性位于指定对象或其原​​型链中，则返回 true，否则返回 false

    const person = { name: 'dan' };
    
    console.log('name' in person); // true
    console.log('age' in person); // false

运行代码片段Hide results

展开片段

2.  **检查对象实例的属性（不包括继承的属性）**

\*2021 - 使用新方法\*\*\*_`Object.hasOwn()`作为替代`Object.hasOwnProperty()`_

`Object.hasOwn()`旨在替代 Safari，`Object.hasOwnProperty()`并且是一种可供使用的新方法（但尚未得到 safari 等所有浏览器的完全支持，但很快就会得到支持）

`Object.hasOwn()`是一个静态方法，如果指定对象将指定属性作为其自己的属性，则返回 true。如果该属性是继承的或不存在，则该方法返回 false。

    const person = { name: 'dan' };
    
    console.log(Object.hasOwn(person, 'name'));// true
    console.log(Object.hasOwn(person, 'age'));// false
    
    const person2 = Object.create({gender: 'male'});
    
    console.log(Object.hasOwn(person2, 'gender'));// false

运行代码片段Hide results

展开片段

**使用它而不是 Object.prototype.hasOwnProperty 的动机是什么？** - 建议使用此方法而不是 ，`Object.hasOwnProperty()`因为它也适用于通过使用创建的对象`Object.create(null)`以及覆盖继承`hasOwnProperty()`方法的对象。尽管可以通过调用`Object.prototype.hasOwnProperty()`外部对象来解决此类问题，`Object.hasOwn()`但克服这些问题是首选（请参见下面的示例）

    let person = {
      hasOwnProperty: function() {
        return false;
      },
      age: 35
    };
    
    if (Object.hasOwn(person, 'age')) {
      console.log(person.age); // true - the remplementation of hasOwnProperty() did not affect the Object
    }

运行代码片段Hide results

展开片段

    let person = Object.create(null);
    person.age = 35;
    if (Object.hasOwn(person, 'age')) {
      console.log(person.age); // true - works regardless of how the object was created
    }

运行代码片段Hide results

展开片段

更多信息`Object.hasOwn`可以在这里找到：[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Object/hasOwn](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)

浏览器兼容性`Object.hasOwn`\- [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Object/hasOwn#browser\_compatibility](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn#browser_compatibility)

"key" in obj
    

可能只测试与数组键非常不同的对象属性值

如何检查 javascript 对象中是否存在某个 key 值？

在JavaScript中格式化日期通常可以通过以下几种方法来实现：

### 1. 使用 Date 对象的内置方法
JavaScript中的`Date`对象带有几个方法可以用来获取日期和时间的不同部分（例如年、月、日、时、分、秒），然后你可以将这些部分拼接成任何你需要的格式。

```javascript
const date = new Date();

const year = date.getFullYear();
const month = (date.getMonth() + 1).toString().padStart(2, '0');
const day = date.getDate().toString().padStart(2, '0');

const formattedDate = `${year}-${month}-${day}`;
console.log(formattedDate); // 输出格式如: "2023-03-10"
```

### 2. 使用第三方库
很多开发者为了简便会选择使用像 Moment.js 或 date-fns 这样的第三方库来处理日期和时间。这些库提供了简单的API来格式化日期。

#### 使用 Moment.js
```javascript
const moment = require('moment');

const formattedDate = moment().format('YYYY-MM-DD');
console.log(formattedDate); // 输出格式如: "2023-03-10"
```

#### 使用 date-fns
```javascript
const { format } = require('date-fns');

const formattedDate = format(new Date(), 'yyyy-MM-dd');
console.log(formattedDate); // 输出格式如: "2023-03-10"
```

### 3. 使用国际化API `Intl.DateTimeFormat`
ES6引入了一个国际化API `Intl`，它有一个`DateTimeFormat`对象可以用来格式化日期。

```javascript
const date = new Date();
const formatter = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
});
const formattedDate = formatter.format(date);
console.log(formattedDate); // 输出格式如: "03/10/2023"
```

上面的例子演示了如何使用`Intl.DateTimeFormat`来按照美式格式（月/日/年）来格式化日期。这个API的优势在于它支持本地化，你可以很容易地按照不同地区的习惯来格式化日期。

### 示例
假设我们要格式化一个日期，要求输出格式为`dd/MM/yyyy HH:mm:ss`，我们可以这样做：

```javascript
const date = new Date();

const day = date.getDate().toString().padStart(2, '0');
const month = (date.getMonth() + 1).toString().padStart(2, '0');
const year = date.getFullYear();
const hours = date.getHours().toString().padStart(2, '0');
const minutes = date.getMinutes().toString().padStart(2, '0');
const seconds = date.getSeconds().toString().padStart(2, '0');

const formattedDate = `${day}/${month}/${year} ${hours}:${minutes}:${seconds}`;
console.log(formattedDate); // 输出格式如: "10/03/2023 14:20:30"
```

在选择哪种方法时，你要根据具体需要（例如是否需要本地化，是否希望引入额外的库等）来决定。对于简单的需求，内置的`Date`方法可能就足够了。而对于更复杂或特定格式的需求，则可能需要使用第三方库或`Intl`对象来简化代码。

如果您需要对格式的控制比当前接受的答案稍微少一些，[`Date#toLocaleDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString)则可用于创建标准的特定于区域设置的渲染。和参数让应用程序指定应使用其格式约定的语言，并允许对呈现进行一些自定义`locale`。`options`

#### 选项关键示例：

1.  **day：**  
    表示当天的情况。  
    可能的值为“数字”、“2 位数字”。
2.  **weekday：**  
    工作日的表示。  
    可能的值为“窄”、“短”、“长”。
3.  **年：**  
    年份的表示。  
    可能的值为“数字”、“2 位数字”。
4.  **Month：**  
    月份的表示。  
    可能的值为“数字”、“2 位数字”、“窄”、“短”、“长”。
5.  **hour：**  
    小时的表​​示。  
    可能的值为“数字”、“2 位数字”。
6.  **分钟：** 分钟的表示。  
    可能的值为“数字”、“2 位数字”。
7.  **第二：**  
    第二个的表示。  
    可能的值为“数字”、“2 位数字”。
8.  **hour12：**  
    时间格式的表示。  
    接受布尔值 true 或 false

所有这些键都是可选的。您可以根据您的要求更改选项值的数量，这也将反映每个日期时间术语的存在。

注意：如果您只想配置内容选项，但仍使用当前区域设置，则传递`null`第一个参数将导致错误。`undefined`代替使用。

#### 对于不同的语言：

1.  **“en-US”：**美式英语
2.  **“en-GB”：**英式英语
3.  **“hi-IN”：**印地语
4.  **“ja-JP”：**日语

您可以使用更多语言选项。

#### 例如

    var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
    var today  = new Date();
    
    console.log(today.toLocaleDateString("en-US")); // 9/17/2016
    console.log(today.toLocaleDateString("en-US", options)); // Saturday, September 17, 2016
    console.log(today.toLocaleDateString("hi-IN", options)); // शनिवार, 17 सितंबर 2016

运行代码片段Hide results

展开片段

您也可以使用该`toLocaleString()`方法来达到相同的目的。唯一的区别是这个函数提供了当你不传递任何选项时的时间。

    // Example
    9/17/2016, 1:21:34 PM
    

#### 参考：

*   [`toLocaleString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString)
    
*   [`toLocaleDateString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString)

[`DateTimeFormat`](//developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat)对于自定义分隔的日期格式，您必须从对象（它是 [ECMAScript 国际化 API](//developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl)的一部分）中提取日期（或时间）组件，然后使用所需的分隔符手动创建一个字符串。

为此，您可以使用[`DateTimeFormat#formatToParts`](//developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts).您可以解构数组，但这并不理想，因为数组输出取决于区域设置：

    { // example 1
       let formatter = new Intl.DateTimeFormat('en');
       let example = formatter.formatToParts();
       console.log(example);
    }
    { // example 2
       let formatter = new Intl.DateTimeFormat('hi');
       let example = formatter.formatToParts();
       console.log(example);
    }

运行代码片段Hide results

展开片段

更好的方法是将格式数组映射到结果字符串：

    function join(date, options, separator) {
       function format(option) {
          let formatter = new Intl.DateTimeFormat('en', option);
          return formatter.format(date);
       }
       return options.map(format).join(separator);
    }
    
    let options = [{day: 'numeric'}, {month: 'short'}, {year: 'numeric'}];
    let joined = join(new Date, options, '-');
    console.log(joined);

运行代码片段Hide results

展开片段

`DateTimeFormat`您还可以使用 提取出一对一 的部分，但请注意，使用此方法时，截至 2020 年 3 月， ECMAScript 实现中在分钟和秒上出现前导零时[`DateTimeFormat#format`](//developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/format)存在[一个错误](//stackoverflow.com/questions/60544534#60545316)（此错误可以通过上面的方法规避）。

    let date = new Date(2010, 7, 5);
    let year = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(date);
    let month = new Intl.DateTimeFormat('en', { month: 'short' }).format(date);
    let day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date);
    console.log(`${day}-${month}-${year}`);

运行代码片段Hide results

展开片段

当使用日期和时间时，通常值得使用库（例如[luxon](//moment.github.io/luxon)、[date-fns](https://date-fns.org/)、[moment.js不建议用于新项目](https://momentjs.com/docs/#/-project-status/recommendations/)），因为该领域存在许多隐藏的复杂性。

[请注意， IE10](//caniuse.com#search=datetimeformat)不支持上述解决方案中使用的 ECMAScript 国际化 API （ 2020 年 2 月全球浏览器市场份额为[0.03%](//gs.statcounter.com/browser-version-market-share)）。

如果您需要使用纯 JavaScript 快速设置日期格式，请使用`getDate`、`getMonth + 1`、`getFullYear`和：`getHours``getMinutes`

    var d = new Date();
    
    var datestring = d.getDate()  + "-" + (d.getMonth()+1) + "-" + d.getFullYear() + " " +
    d.getHours() + ":" + d.getMinutes();
    
    // 16-5-2015 9:50
    

或者，如果您需要用零填充：

    var datestring = ("0" + d.getDate()).slice(-2) + "-" + ("0"+(d.getMonth()+1)).slice(-2) + "-" +
        d.getFullYear() + " " + ("0" + d.getHours()).slice(-2) + ":" + ("0" + d.getMinutes()).slice(-2);
    
    // 16-05-2015 09:50

使用[date.format 库](http://blog.stevenlevithan.com/archives/date-time-format)：

    var dateFormat = require('dateformat');
    var now = new Date();
    dateFormat(now, "dddd, mmmm dS, yyyy, h:MM:ss TT");
    

返回：

    Saturday, June 9th, 2007, 5:46:21 PM 
    

[npm 上的日期格式](https://www.npmjs.com/package/dateformat)

[http://jsfiddle.net/phZr7/1/](http://jsfiddle.net/phZr7/1/)

好吧，我想要的是将今天的日期转换为[MySQL](http://en.wikipedia.org/wiki/MySQL)友好的日期字符串`2012-06-23`，例如 ，并在我的一个查询中使用该字符串作为参数。我发现的简单解决方案是这样的：

    var today = new Date().toISOString().slice(0, 10);
    

请记住，上述解决方案没有**考虑**您的_时区_偏移。

您可以考虑使用此函数：

    function toJSONLocal (date) {
        var local = new Date(date);
        local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
        return local.toJSON().slice(0, 10);
    }
    

如果您在一天的开始/结束时执行此代码，这将为您提供正确的日期。

    var date = new Date();
    
    function toLocal(date) {
      var local = new Date(date);
      local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
      return local.toJSON();
    }
    
    function toJSONLocal(date) {
      var local = new Date(date);
      local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
      return local.toJSON().slice(0, 10);
    }
    
    // check out your devtools console
    console.log(date.toJSON());
    console.log(date.toISOString());
    console.log(toLocal(date));
    
    console.log(toJSONLocal(date));

运行代码片段Hide results

展开片段

*   [日期.toISOString](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
*   [日期转JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON)
*   [字符串切片](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)
*   [外部示例](http://jsfiddle.net/simo/sapuhzmm/)

JS 如何格式化日期

当我们在JavaScript中克隆对象时，我们的目的是创建一个新的对象，它具有与原始对象相同的属性和值，但是在内存中占据不同的位置。这意味着，当我们修改新对象时，原始对象不会受到影响，反之亦然。以下是几种常用的克隆JavaScript对象的方法：

### 浅克隆(Shallow Clone)

**Object.assign()**

```javascript
let original = { a: 1, b: 2 };
let clone = Object.assign({}, original);
```

这里的`Object.assign()`方法会将所有可枚举的自有属性从一个或多个源对象复制到目标对象（在这里是一个空对象），然后返回目标对象。

**Spread Operator (ES6)**

```javascript
let original = { a: 1, b: 2 };
let clone = { ...original };
```

扩展运算符`...`允许一个表达式在某处被扩展为多个参数（对于函数调用）或多个元素（对于数组字面量）或多个键值对（对于对象字面量）。

以上两种方法都是浅克隆，这意味着如果原始对象的属性值是一个对象，那么克隆对象的这个属性值仅仅是原始对象属性值的引用。如果修改了这个内部对象，原始对象和克隆对象都会受到影响。

### 深克隆(Deep Clone)

**JSON方法**

```javascript
let original = { a: 1, b: { c: 3 } };
let clone = JSON.parse(JSON.stringify(original));
```

这种方法非常简单，可以用来深克隆一个对象。但是它有一些限制，例如它不会克隆函数，会忽略undefined，也不能处理循环引用的对象。

**递归方式的深克隆**

```javascript
function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }

  if (obj instanceof Array) {
    let arrCopy = [];
    obj.forEach((v, i) => arrCopy[i] = deepClone(v));
    return arrCopy;
  }

  if (obj instanceof Object) {
    let copy = {};
    Object.getOwnPropertyNames(obj).forEach(prop => {
      copy[prop] = deepClone(obj[prop]);
    });
    return copy;
  }

  throw new Error('Unable to copy object!');
}

let original = { a: 1, b: { c: 3 } };
let clone = deepClone(original);
```

这个方法会递归地克隆对象，包括其属性值是对象的情况。这样我们得到的克隆对象是完全独立于原始对象的。

### 库方法

有些JavaScript库（如 Lodash）提供了深克隆的功能。例如，使用Lodash的`_.cloneDeep()`：

```javascript
let _ = require('lodash');
let original = { a: 1, b: { c: 3 } };
let clone = _.cloneDeep(original);
```

这种方式非常简便，不需要自己编写复杂的深克隆逻辑，并且能够处理更复杂的情况，比如循环引用、特殊的对象类型等。

总结起来，选择哪种克隆方式取决于你需要的克隆深度和对象的复杂性。对于简单的情况，浅克隆可能就足够了。当对象结构更复杂，或者需要完全独立副本时，深克隆则是更好的选择。在实际工作中，我们通常倾向于使用成熟的库方法来处理这些事情，以减少bug和提高开发效率。

### 2022年更新

有一个新的 JS 标准称为[结构化克隆](https://developer.mozilla.org/en-US/docs/Web/API/structuredClone)。它适用于许多浏览器（请参阅[我可以使用](https://caniuse.com/?search=structuredClone)）。

    const clone = structuredClone(object);
    

旧答案
---

要对 JavaScript 中的任何对象执行此操作都不会简单或直接。您将遇到错误地从对象原型中获取属性的问题，这些属性应该保留在原型中而不是复制到新实例中。例如，如果您要添加一个`clone`方法`Object.prototype`，正如一些答案所描述的那样，您将需要显式跳过该属性。但是，如果添加了`Object.prototype`您不知道的其他附加方法或其他中间原型怎么办？在这种情况下，您将复制不应该复制的属性，因此您需要使用该方法检测不可预见的非本地属性[`hasOwnProperty`](https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Object/hasOwnProperty "Mozilla JavaScript 参考：Object.hasOwnProperty")。

除了不可枚举的属性之外，当您尝试复制具有隐藏属性的对象时，您还会遇到更棘手的问题。例如，`prototype`是函数的隐藏属性。此外，对象的原型是通过 attribute 引用的`__proto__`，该属性也是隐藏的，并且不会被迭代源对象属性的 for/in 循环复制。我认为`__proto__`这可能是 Firefox 的 JavaScript 解释器特有的，在其他浏览器中可能有所不同，但你明白了。并非所有事情都是可枚举的。如果您知道隐藏属性的名称，则可以复制它，但我不知道有什么方法可以自动发现它。

寻求优雅解决方案的另一个障碍是正确设置原型继承的问题。如果源对象的原型是`Object`，那么只需创建一个新的通用对象`{}`即可，但是如果源的原型是 的后代`Object`，那么您将丢失使用`hasOwnProperty`过滤器跳过的该原型中的其他成员，或者存在于原型中，但一开始就不可枚举。一种解决方案可能是调用源对象的`constructor`属性来获取初始复制对象，然后复制属性，但您仍然不会获得不可枚举的属性。例如，[`Date`](https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Date "Mozilla JavaScript 参考：日期")对象将其数据存储为隐藏成员：

    function clone(obj) {
        if (null == obj || "object" != typeof obj) return obj;
        var copy = obj.constructor();
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = obj[attr];
        }
        return copy;
    }
    
    var d1 = new Date();
    
    /* Executes function after 5 seconds. */
    setTimeout(function(){
        var d2 = clone(d1);
        alert("d1 = " + d1.toString() + "\nd2 = " + d2.toString());
    }, 5000);
    

的日期字符串`d1`将比 的日期字符串晚 5 秒`d2`。使一个`Date`与另一个相同的方法是调用`setTime`方法，但这是特定于`Date`类的。我不认为这个问题有一个万无一失的通用解决方案，尽管我很乐意犯错！

当我必须实现一般深度复制时，我最终妥协了，假设我只需要复制普通的`Object`, `Array`, `Date`, `String`, `Number`, 或`Boolean`。最后 3 种类型是不可变的，因此我可以执行浅复制而不用担心它会发生变化。我进一步假设`Object`或中包含的任何元素`Array`也将是该列表中的 6 种简单类型之一。这可以通过如下代码来完成：

    function clone(obj) {
        var copy;
    
        // Handle the 3 simple types, and null or undefined
        if (null == obj || "object" != typeof obj) return obj;
    
        // Handle Date
        if (obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }
    
        // Handle Array
        if (obj instanceof Array) {
            copy = [];
            for (var i = 0, len = obj.length; i < len; i++) {
                copy[i] = clone(obj[i]);
            }
            return copy;
        }
    
        // Handle Object
        if (obj instanceof Object) {
            copy = {};
            for (var attr in obj) {
                if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr]);
            }
            return copy;
        }
    
        throw new Error("Unable to copy obj! Its type isn't supported.");
    }
    

只要对象和数组中的数据形成树结构，上述函数就足以适用于我提到的 6 种简单类型。也就是说，对对象中相同数据的引用不超过一次。例如：

    // This would be cloneable:
    var tree = {
        "left"  : { "left" : null, "right" : null, "data" : 3 },
        "right" : null,
        "data"  : 8
    };
    
    // This would kind-of work, but you would get 2 copies of the 
    // inner node instead of 2 references to the same copy
    var directedAcylicGraph = {
        "left"  : { "left" : null, "right" : null, "data" : 3 },
        "data"  : 8
    };
    directedAcyclicGraph["right"] = directedAcyclicGraph["left"];
    
    // Cloning this would cause a stack overflow due to infinite recursion:
    var cyclicGraph = {
        "left"  : { "left" : null, "right" : null, "data" : 3 },
        "data"  : 8
    };
    cyclicGraph["right"] = cyclicGraph;
    

它无法处理任何 JavaScript 对象，但它可能足以满足许多目的，只要您不认为它只适用于您扔给它的任何东西。

如果您不在`Date`对象中使用 s、functions、undefined、regExp 或 Infinity，则一个非常简单的行是`JSON.parse(JSON.stringify(object))`：

    const a = {
      string: 'string',
      number: 123,
      bool: false,
      nul: null,
      date: new Date(),  // stringified
      undef: undefined,  // lost
      inf: Infinity,  // forced to 'null'
    }
    console.log(a);
    console.log(typeof a.date);  // Date object
    const clone = JSON.parse(JSON.stringify(a));
    console.log(clone);
    console.log(typeof clone.date);  // result of .toISOString()

运行代码片段Hide results

展开片段

这适用于包含对象、数组、字符串、布尔值和数字的所有类型的对象。

另请参阅[这篇有关浏览器的结构化克隆算法的文章](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/The_structured_clone_algorithm)，该算法在向工作人员发布消息或从工作人员发布消息时使用。它还包含深度克隆功能。

在 ECMAScript 6 中，有一个[Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)方法，它将所有可枚举自身属性的值从一个对象复制到另一个对象。例如：

    var x = {myProp: "value"};
    var y = Object.assign({}, x); 
    

但请注意，**这是浅复制**\- 嵌套对象仍被复制为引用。

使用 jQuery，您可以使用[扩展进行](http://api.jquery.com/jQuery.extend)**浅复制**：[](http://api.jquery.com/jQuery.extend)

    var copiedObject = jQuery.extend({}, originalObject)
    

的后续更改`copiedObject`不会影响`originalObject`，反之亦然。

或者进行**深层复制**：

    var copiedObject = jQuery.extend(true, {}, originalObject)

根据[MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Deep_Clone)：

*   如果您想要浅复制，请使用`Object.assign({}, a)`
*   对于“深度”复制，请使用`JSON.parse(JSON.stringify(a))`

不需要外部库，但您需要[先检查浏览器兼容性](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Browser_compatibility)。

JS 如何正确克隆一个对象

在 JavaScript 中，如果要根据对象数组中对象的字符串属性进行排序，通常可以使用 `Array.prototype.sort()` 方法。这是一个自定义排序的方法，可以根据返回值来决定数组的顺序。

以下是按照对象的字符串属性对数组进行排序的具体步骤及例子：

1. 定义一个比较函数，该函数接受两个参数，即要比较的两个对象。
2. 在比较函数中，根据对象的字符串属性来比较它们的顺序。
3. 使用字符串的 `localeCompare` 方法来实现不区分大小写的排序，或者直接使用 `<` 和 `>` 操作符来实现区分大小写的排序。
4. 调用数组的 `sort` 方法，并将比较函数作为参数传递。

以下是一个例子，假设我们有一个学生对象数组，并且希望根据学生的姓名（name属性）来对数组进行排序。

```javascript
// 学生对象数组
let students = [
  { id: 1, name: "张三" },
  { id: 2, name: "李四" },
  { id: 3, name: "王五" }
];

// 比较函数
function compareByName(a, b) {
  // 使用 localeCompare 进行不区分大小写的字符串比较
  return a.name.localeCompare(b.name);
}

// 根据姓名排序
students.sort(compareByName);

// 输出排序后的数组
console.log(students);
```

如果要求区分大小写的排序：

```javascript
function compareByNameCaseSensitive(a, b) {
  if (a.name < b.name) {
    return -1;
  }
  if (a.name > b.name) {
    return 1;
  }
  return 0;
}

students.sort(compareByNameCaseSensitive);
```

以上代码将会根据学生姓名的字典顺序对 `students` 数组进行排序。如果需要其他方式的排序（例如倒序或者根据其他属性排序），只需要调整比较函数 `compareByName` 的逻辑即可。

编写自己的比较函数很容易：

    function compare( a, b ) {
      if ( a.last_nom < b.last_nom ){
        return -1;
      }
      if ( a.last_nom > b.last_nom ){
        return 1;
      }
      return 0;
    }
    
    objs.sort( compare );
    

或内联（[c/o Marco Demaio](https://stackoverflow.com/questions/1129216/sort-array-of-objects-by-string-property-value/16174180#comment2298229_1129270)）：

    objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0))
    

或者简化为数字（[c/o Andre Figueiredo](https://stackoverflow.com/questions/1129216/sort-array-of-objects-by-string-property-value/16174180#comment31549267_1129270)）：

    objs.sort((a,b) => a.last_nom - b.last_nom); // b - a for reverse sort

您还可以创建一个动态排序函数，根据您传递的值对对象进行排序：

    function dynamicSort(property) {
        var sortOrder = 1;
        if(property[0] === "-") {
            sortOrder = -1;
            property = property.substr(1);
        }
        return function (a,b) {
            /* next line works with strings and numbers, 
             * and you may want to customize it to your needs
             */
            var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
            return result * sortOrder;
        }
    }
    

所以你可以有一个像这样的对象数组：

    var People = [
        {Name: "Name", Surname: "Surname"},
        {Name:"AAA", Surname:"ZZZ"},
        {Name: "Name", Surname: "AAA"}
    ];
    

...当你这样做时它就会起作用：

    People.sort(dynamicSort("Name"));
    People.sort(dynamicSort("Surname"));
    People.sort(dynamicSort("-Surname"));
    

其实这已经回答了问题。写下面的部分是因为很多人联系我，抱怨[它不能使用多个参数](https://stackoverflow.com/questions/11379361)。

多个参数
----

您可以使用下面的函数生成具有多个排序参数的排序函数。

    function dynamicSortMultiple() {
        /*
         * save the arguments object as it will be overwritten
         * note that arguments object is an array-like object
         * consisting of the names of the properties to sort by
         */
        var props = arguments;
        return function (obj1, obj2) {
            var i = 0, result = 0, numberOfProperties = props.length;
            /* try getting a different result from 0 (equal)
             * as long as we have extra properties to compare
             */
            while(result === 0 && i < numberOfProperties) {
                result = dynamicSort(props[i])(obj1, obj2);
                i++;
            }
            return result;
        }
    }
    

这将使你能够做这样的事情：

    People.sort(dynamicSortMultiple("Name", "-Surname"));
    

### 子类化数组

对于我们当中能够使用 ES6 的幸运者来说，它允许扩展原生对象：

    class MyArray extends Array {
        sortBy(...args) {
            return this.sort(dynamicSortMultiple(...args));
        }
    }
    

这将实现这一点：

    MyArray.from(People).sortBy("Name", "-Surname");

在[ES6/ES2015](https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015)或更高版本中你可以这样做：

    objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));
    

ES6/ES2015 之前

    objs.sort(function(a, b) {
        return a.last_nom.localeCompare(b.last_nom)
    });

[下划线.js](http://underscorejs.org/#sortBy)

使用Underscore.js\]。它很小而且很棒...

> sortBy\_.sortBy(list, iterator, \[context\]) 返回列表的排序副本，按通过迭代器运行每个值的结果按升序排列。迭代器也可以是要排序的属性的字符串名称（例如长度）。

    var objs = [
      { first_nom: 'Lazslo',last_nom: 'Jamf' },
      { first_nom: 'Pig', last_nom: 'Bodine'  },
      { first_nom: 'Pirate', last_nom: 'Prentice' }
    ];
    
    var sortedObjs = _.sortBy(objs, 'first_nom');

我在 TypeORM 文档和源代码中都找不到 OR 运算符的任何概念。它完全支持吗？
我正在尝试使用存储库执行基本搜索。

```js
db.getRepository(MyModel).find({ name : "john", lastName: "doe" })
```

我知道这会生成 AND 运算，但我需要 OR 运算，因此 SQL 如下所示： 
`name='john' OR lastName='doe'`
我是否被迫使用查询生成器来完成这样的基本操作？

JS 如何按字符串属性值对对象数组进行排序

要使用JavaScript获取当前页面的URL，您可以使用 `window.location` 对象，它包含了与当前窗口的位置相关的信息。下面是获取当前URL的一些属性和方法：

1. `window.location.href` ：返回完整的URL字符串（即它包含协议、主机、端口号（如果有）、路径、查询字符串、锚点等）。

例如，假设当前URL是 `"https://www.example.com:80/path/index.html?search=test#section1"`，您可以这样获取完整的URL：

```javascript
var currentUrl = window.location.href;
console.log(currentUrl); // 输出："https://www.example.com:80/path/index.html?search=test#section1"
```

2. `window.location.hostname` ：返回web服务器的域名。

例如：

```javascript
var hostname = window.location.hostname;
console.log(hostname); // 输出："www.example.com"
```

3. `window.location.pathname`：返回URL的路径部分。

例如：

```javascript
var pathname = window.location.pathname;
console.log(pathname); // 输出："/path/index.html"
```

4. `window.location.protocol`：返回页面使用的协议，通常是http:或https:。

例如：

```javascript
var protocol = window.location.protocol;
console.log(protocol); // 输出："https:"
```

5. `window.location.port`：返回服务器端口号。

例如：

```javascript
var port = window.location.port;
console.log(port); // 输出："80"
```

6. `window.location.search`：返回URL的查询字符串部分，以"?"开头。

例如：

```javascript
var search = window.location.search;
console.log(search); // 输出："?search=test"
```

7. `window.location.hash`：返回URL的锚部分，以"#"开头。

例如：

```javascript
var hash = window.location.hash;
console.log(hash); // 输出："#section1"
```

8. `window.location.assign(url)`：加载新的文档。

9. `window.location.reload()`：重新加载当前页面。

10. `window.location.replace(url)`：用新的页面替换当前页面。

使用这些属性和方法，您可以根据需要获取和操作当前页面的URL。例如，如果您需要根据URL的查询字符串参数来执行某些操作，您可以提取 `window.location.search`，然后解析这些参数。

使用：

    window.location.href
    

正如评论中所指出的，下面的行可以工作，但在 Firefox 中存在错误。

    document.URL
    

请参阅**[DOMString 类型的 URL，readonly](https://web.archive.org/web/20170327080647/http://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-46183437)**。

**URL信息访问**

JavaScript 为您提供了许多方法来检索和更改显示在浏览器地址栏中的当前 URL。所有这些方法都使用[`Location`object](https://developer.mozilla.org/en-US/docs/Web/API/Location)，它是对象的属性`Window`。您可以`Location`通过以下方式读取当前对象[`window.location`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location)：

    var currentLocation = window.location;
    

**基本 URL 结构**

    <protocol>//<hostname>:<port>/<pathname><search><hash>
    

*   **协议：**指定用于访问 Internet 上的资源的协议名称。 （HTTP（不带 SSL）或 HTTPS（带 SSL））
    
*   **hostname：**主机名指定拥有该资源的主机。例如，`www.stackoverflow.com`。服务器使用主机名提供服务。
    
*   **端口：**用于识别 Internet 或其他网络消息到达服务器时要转发到的特定进程的端口号。
    
*   **路径名：**路径提供有关 Web 客户端想要访问的主机内特定资源的信息。例如，`/index.html`。
    
*   **搜索：**查询字符串跟随路径组件，并提供资源可用于某种目的的一串信息（例如，作为搜索参数或作为要处理的数据）。
    
*   **hash：** URL 的锚点部分，包括井号 (#)。
    

通过这些`Location`对象属性，您可以访问所有这些 URL 组件以及它们可以设置或返回的内容：

*   **href** - 整个 URL
*   **协议**\- URL 的协议
*   **host** - URL 的主机名和端口
*   **主机名**\- URL 的主机名
*   **port** - 服务器用于 URL 的端口号
*   **pathname** - URL 的路径名
*   **search** - URL 的查询部分
*   **hash** - URL 的锚点部分
*   [**起源**](https://developer.mozilla.org/en-US/docs/Web/API/Location/origin)——`window.location.protocol + '//' + window.location.host`

用于对与当前帧关联的[位置对象](https://developer.mozilla.org/En/DOM/Window.location#Location_object)`window.location`进行读写访问。如果您只想获取只读字符串形式的地址，您可以使用，它应该包含与 相同的值。[](https://developer.mozilla.org/En/DOM/Window.location#Location_object)`document.URL``window.location.href`

获取当前页面的URL：

    window.location.href

好的，使用纯 JavaScript 可以轻松获取当前页面的**完整 URL** 。例如，在此页面上尝试以下代码：

    window.location.href;
    // use it in the console of this page will return
    // http://stackoverflow.com/questions/1034621/get-current-url-in-web-browser"
    

该`window.location.href`属性返回当前页面的 URL。

    document.getElementById("root").innerHTML = "The full URL of this page is:<br>" + window.location.href;

    <!DOCTYPE html>
    <html>
    
    <body>
      <h2>JavaScript</h2>
      <h3>The window.location.href</h3>
      <p id="root"></p>
    </body>
    
    </html>

运行代码片段Hide results

展开片段

顺便提一下这些也不错：

*   如果您需要相对路径，只需使用`window.location.pathname`;
    
*   如果您想获取主机名，可以使用`window.location.hostname`;
    
*   如果您需要单独获取协议，请使用`window.location.protocol`
    
*   另外，如果您的页面有`hash`标签，您可以像这样获取它：`window.location.hash`。
    

所以`window.location.href`一次处理所有......基本上：

    window.location.protocol + '//' + window.location.hostname + window.location.pathname + window.location.hash === window.location.href;
        //true
    

`window`如果已经在窗口范围内，也不需要使用......

因此，在这种情况下，您可以使用：

    location.protocol
    
    location.hostname
    
    location.pathname
    
    location.hash
    
    location.href
    

[![使用 JavaScript 获取当前 URL](https://i.stack.imgur.com/NUGbD.png)](https://i.stack.imgur.com/NUGbD.png)

JS 如何获取当前 url

在JavaScript中，要将文本复制到剪贴板，你可以使用`navigator.clipboard.writeText()`方法。这是一个简单的现代浏览器API，用于向剪贴板写入文本。

以下是使用这个API的例子：

```javascript
// 要复制的文本
const textToCopy = "要复制的文本内容";

// 使用Clipboard API复制文本到剪贴板
navigator.clipboard.writeText(textToCopy).then(() => {
  console.log("文本已经成功复制到剪贴板！");
}).catch(err => {
  console.error("无法复制文本: ", err);
});
```

请注意，由于安全原因，现代浏览器通常要求`writeText`方法在由用户行为（如点击事件）触发的函数中调用。如果你尝试在非用户触发的事件中调用它（例如，在页面加载时），浏览器可能会阻止该操作。

此外，某些浏览器可能还需要页面通过HTTPS服务，而不是HTTP，才允许使用Clipboard API。

这是一个HTML按钮和JavaScript代码结合使用`navigator.clipboard.writeText()`方法的示例：

```html
<button id="copyButton">复制文本</button>
```

```javascript
document.getElementById('copyButton').addEventListener('click', function() {
  const textToCopy = "要复制的文本内容";
  
  navigator.clipboard.writeText(textToCopy).then(() => {
    console.log("文本已经成功复制到剪贴板！");
  }).catch(err => {
    console.error("无法复制文本: ", err);
  });
});
```

在这个例子中，当用户点击按钮时，`textToCopy`中的文本会被复制到剪贴板。

概述
==

复制到剪贴板的浏览器 API 主要有以下三种：

1.  [异步剪贴板 API](https://www.w3.org/TR/clipboard-apis/#async-clipboard-api) `[navigator.clipboard.writeText]`
    
    *   Chrome 66中提供以文本为中心的部分[（2018 年 3 月）](https://developers.google.com/web/updates/2018/03/clipboardapi)
    *   访问是异步的并使用[JavaScript Promises](https://developers.google.com/web/fundamentals/primers/promises)，可以编写这样的安全用户提示（如果显示）不会中断页面​​中的 JavaScript。
    *   文本可以直接从变量复制到剪贴板。
    *   仅在通过 HTTPS 提供服务的页面上受支持。
    *   在 Chrome 66 页面中，非活动选项卡可以在没有权限提示的情况下写入剪贴板。
2.  `document.execCommand('copy')`（_**[已弃用](https://developer.mozilla.org/docs/Web/API/Document/execCommand#browser_compatibility)**_）👎
    
    *   截至 2015 年 4 月，大多数浏览器都支持此功能（请参阅下面的浏览器支持）。
    *   访问是同步的，即停止页面中的 JavaScript 直至完成，包括显示任何安全提示以及用户与任何安全提示进行交互。
    *   文本从 DOM 读取并放置在剪贴板上。
    *   在 2015 年 4 月左右的测试过程中，只有 Internet Explorer 被注意到在写入剪贴板时显示权限提示。
3.  覆盖复制事件
    
    *   [请参阅有关覆盖复制事件的](https://w3c.github.io/clipboard-apis/#override-copy)剪贴板 API 文档。
    *   允许您修改任何复制事件中出现在剪贴板上的内容，可以包括纯文本以外的其他格式的数据。
    *   这里不涉及，因为它没有直接回答问题。

一般开发笔记
======

当您在控制台中测试代码时，不要指望与剪贴板相关的命令能够工作。通常，页面需要处于活动状态（异步剪贴板 API）或需要用户交互（例如用户单击）以允许 ( `document.execCommand('copy')`) 访问剪贴板，请参阅下文了解更多详细信息。

**重要信息**（2020/02/20 在此注明）
-------------------------

请注意，由于本文最初是[在跨源 IFRAME](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-permissions-in-cross-origin-iframes)和其他[IFRAME“沙盒”](https://blog.chromium.org/2010/05/security-in-depth-html5s-sandbox.html)中弃用权限，因此会阻止嵌入式演示“运行代码片段”按钮和“codepen.io 示例”在某些浏览器（包括 Chrome 和 Microsoft Edge）中工作）。

要开发创建您自己的网页，请通过 HTTPS 连接提供该页面以进行测试和开发。

这是一个测试/演示页面，演示了代码的工作原理： [https ://deanmarktaylor.github.io/clipboard-test/](https://deanmarktaylor.github.io/clipboard-test/)

异步+回退
=====

由于浏览器对新的异步剪贴板 API 的支持级别，您可能希望回退到该`document.execCommand('copy')`方法以获得良好的浏览器覆盖率。

这是一个简单的示例（可能无法嵌入本网站，请阅读上面的“重要”注释）：

    function fallbackCopyTextToClipboard(text) {
      var textArea = document.createElement("textarea");
      textArea.value = text;
      
      // Avoid scrolling to bottom
      textArea.style.top = "0";
      textArea.style.left = "0";
      textArea.style.position = "fixed";
    
      document.body.appendChild(textArea);
      textArea.focus();
      textArea.select();
    
      try {
        var successful = document.execCommand('copy');
        var msg = successful ? 'successful' : 'unsuccessful';
        console.log('Fallback: Copying text command was ' + msg);
      } catch (err) {
        console.error('Fallback: Oops, unable to copy', err);
      }
    
      document.body.removeChild(textArea);
    }
    function copyTextToClipboard(text) {
      if (!navigator.clipboard) {
        fallbackCopyTextToClipboard(text);
        return;
      }
      navigator.clipboard.writeText(text).then(function() {
        console.log('Async: Copying to clipboard was successful!');
      }, function(err) {
        console.error('Async: Could not copy text: ', err);
      });
    }
    
    var copyBobBtn = document.querySelector('.js-copy-bob-btn'),
      copyJaneBtn = document.querySelector('.js-copy-jane-btn');
    
    copyBobBtn.addEventListener('click', function(event) {
      copyTextToClipboard('Bob');
    });
    
    
    copyJaneBtn.addEventListener('click', function(event) {
      copyTextToClipboard('Jane');
    });

    <div style="display:inline-block; vertical-align:top;">
      <button class="js-copy-bob-btn">Set clipboard to BOB</button><br /><br />
      <button class="js-copy-jane-btn">Set clipboard to JANE</button>
    </div>
    <div style="display:inline-block;">
      <textarea class="js-test-textarea" cols="35" rows="4">Try pasting into here to see what you have on your clipboard:
    
      </textarea>
    </div>

运行代码片段Hide results

展开片段

（codepen.io 示例可能不起作用，请阅读上面的“重要”注释）请注意，此代码片段在 Stack Overflow 的嵌入式预览中运行不佳，您可以在这里尝试：[https ://codepen.io/DeanMarkTaylor/pen/RMRaJX?editors \=1011](https://codepen.io/DeanMarkTaylor/pen/RMRaJX?editors=1011)

异步剪贴板 API
=========

*   [MDN 参考](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API)
*   [Chrome 66 公告帖子（2018 年 3 月）](https://developers.google.com/web/updates/2018/03/clipboardapi)
*   参考[异步剪贴板 API](https://www.w3.org/TR/clipboard-apis/#async-clipboard-api)草稿文档

请注意，Chrome 66 中可以通过权限 API“请求权限”并测试对剪贴板的访问。

    var text = "Example text to appear on clipboard";
    navigator.clipboard.writeText(text).then(function() {
      console.log('Async: Copying to clipboard was successful!');
    }, function(err) {
      console.error('Async: Could not copy text: ', err);
    });
    

document.execCommand('复制')
==========================

本文的其余部分将讨论`document.execCommand('copy')`API 的细微差别和细节。

浏览器支持
-----

JavaScript[`document.execCommand('copy')`](https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand)支持已增加，请参阅以下链接了解浏览器更新： （_**[已弃用](https://developer.mozilla.org/docs/Web/API/Document/execCommand#browser_compatibility)**_）👎

*   Internet Explorer 10+（尽管[本文档](https://msdn.microsoft.com/en-us/library/ms537834(v=vs.85).aspx)表明 Internet Explorer 5.5+ 提供了一些支持）。
*   [Google Chrome 43+（~2015 年 4 月）](https://developers.google.com/web/updates/2015/04/cut-and-copy-commands?hl=en)
*   [Mozilla Firefox 41+（2015 年 9 月发货）](https://developer.mozilla.org/en-US/Firefox/Releases/41#Interfaces.2FAPIs.2FDOM)
*   [Opera 29+（基于 Chromium 42，~2015 年 4 月）](https://dev.opera.com/blog/opera-29/#cut-and-copy-commands)

简单的例子
-----

（可能无法嵌入本网站，请阅读上面的“重要”注释）

    var copyTextareaBtn = document.querySelector('.js-textareacopybtn');
    
    copyTextareaBtn.addEventListener('click', function(event) {
      var copyTextarea = document.querySelector('.js-copytextarea');
      copyTextarea.focus();
      copyTextarea.select();
    
      try {
        var successful = document.execCommand('copy');
        var msg = successful ? 'successful' : 'unsuccessful';
        console.log('Copying text command was ' + msg);
      } catch (err) {
        console.log('Oops, unable to copy');
      }
    });

    <p>
      <button class="js-textareacopybtn" style="vertical-align:top;">Copy Textarea</button>
      <textarea class="js-copytextarea">Hello I'm some text</textarea>
    </p>

运行代码片段Hide results

展开片段

复杂示例：复制到剪贴板而不显示输入
-----------------

如果屏幕上有可见的`textarea`或元素，上面的简单示例效果很好。`input`

在某些情况下，您可能希望将文本复制到剪贴板而不显示`input`/`textarea`元素。这是解决此问题的方法的一个示例（基本上是插入一个元素，复制到剪贴板，删除元素）：

使用 Google Chrome 44、Firefox 42.0a1 和 Internet Explorer 11.0.8600.17814 进行测试。

（可能无法嵌入本网站，请阅读上面的“重要”注释）

    function copyTextToClipboard(text) {
      var textArea = document.createElement("textarea");
    
      //
      // *** This styling is an extra step which is likely not required. ***
      //
      // Why is it here? To ensure:
      // 1. the element is able to have focus and selection.
      // 2. if the element was to flash render it has minimal visual impact.
      // 3. less flakyness with selection and copying which **might** occur if
      //    the textarea element is not visible.
      //
      // The likelihood is the element won't even render, not even a
      // flash, so some of these are just precautions. However in
      // Internet Explorer the element is visible whilst the popup
      // box asking the user for permission for the web page to
      // copy to the clipboard.
      //
    
      // Place in the top-left corner of screen regardless of scroll position.
      textArea.style.position = 'fixed';
      textArea.style.top = 0;
      textArea.style.left = 0;
    
      // Ensure it has a small width and height. Setting to 1px / 1em
      // doesn't work as this gives a negative w/h on some browsers.
      textArea.style.width = '2em';
      textArea.style.height = '2em';
    
      // We don't need padding, reducing the size if it does flash render.
      textArea.style.padding = 0;
    
      // Clean up any borders.
      textArea.style.border = 'none';
      textArea.style.outline = 'none';
      textArea.style.boxShadow = 'none';
    
      // Avoid flash of the white box if rendered for any reason.
      textArea.style.background = 'transparent';
    
    
      textArea.value = text;
    
      document.body.appendChild(textArea);
      textArea.focus();
      textArea.select();
    
      try {
        var successful = document.execCommand('copy');
        var msg = successful ? 'successful' : 'unsuccessful';
        console.log('Copying text command was ' + msg);
      } catch (err) {
        console.log('Oops, unable to copy');
      }
    
      document.body.removeChild(textArea);
    }
    
    
    var copyBobBtn = document.querySelector('.js-copy-bob-btn'),
      copyJaneBtn = document.querySelector('.js-copy-jane-btn');
    
    copyBobBtn.addEventListener('click', function(event) {
      copyTextToClipboard('Bob');
    });
    
    
    copyJaneBtn.addEventListener('click', function(event) {
      copyTextToClipboard('Jane');
    });

    <div style="display:inline-block; vertical-align:top;">
      <button class="js-copy-bob-btn">Set clipboard to BOB</button><br /><br />
      <button class="js-copy-jane-btn">Set clipboard to JANE</button>
    </div>
    <div style="display:inline-block;">
      <textarea class="js-test-textarea" cols="35" rows="4">Try pasting into here to see what you have on your clipboard:
    
      </textarea>
    </div>

运行代码片段Hide results

展开片段

补充笔记
----

### 仅当用户采取操作时才有效

所有`document.execCommand('copy')`调用都必须作为用户操作的直接结果发生，例如单击事件处理程序。这是一种防止用户剪贴板在意外情况下被弄乱的措施。

请参阅[此处的 Google 开发者帖子](https://developers.google.com/web/updates/2015/04/cut-and-copy-commands?hl=en)了解更多信息。

### 剪贴板API

请注意，完整的 Clipboard API 草案规范可以在这里找到： [https://w3c.github.io/clipboard-apis/](https://w3c.github.io/clipboard-apis/)

### 支持吗？

*   `document.queryCommandSupported('copy')``true`如果命令“浏览器支持”，则应返回。
*   如果现在调用将成功，则`document.queryCommandEnabled('copy')`返回。检查以确保该命令是从用户启动的线程调用的并且满足其他要求。`true``document.execCommand('copy')`

但是，作为浏览器兼容性问题的一个示例，2015 年 4 月到 10 月期间的 Google Chrome 仅`true`在`document.queryCommandSupported('copy')`从用户启动的线程调用该命令时返回。

请注意下面的兼容性详细信息。

### 浏览器兼容性详细信息

`document.execCommand('copy')`虽然对包装在`try`/块中的简单调用`catch`（由于用户单击而调用）将为您提供最大的兼容性，但使用以下内容有一些附带条件：

对`document.execCommand`, `document.queryCommandSupported`or 的任何调用都`document.queryCommandEnabled`应该包含在`try`/`catch`块中。

不同的浏览器实现和浏览器版本在调用而不是返回时会抛出不同类型的异常`false`。

不同的浏览器实现仍在不断变化，[剪贴板 API](https://w3c.github.io/clipboard-apis/)仍处于草案阶段，因此请记住进行测试。

自动复制到剪贴板可能很危险，因此大多数浏览器（Internet Explorer 除外）都使其变得非常困难。就我个人而言，我使用以下简单的技巧：

    function copyToClipboard(text) {
      window.prompt("Copy to clipboard: Ctrl+C, Enter", text);
    }
    

用户将看到提示框，其中已选择要复制的文本。现在按Ctrl+C和Enter（关闭框）就足够了——瞧！

现在剪贴板复制操作是_安全的_，因为用户手动执行此操作（但以非常简单的方式）。当然，它适用于所有浏览器。

    <button id="demo" onclick="copyToClipboard(document.getElementById('demo').innerHTML)">This is what I want to copy</button>
    
    <script>
      function copyToClipboard(text) {
        window.prompt("Copy to clipboard: Ctrl+C, Enter", text);
      }
    </script>

运行代码片段Hide results

展开片段

以下方法适用于 Chrome、Firefox、Internet Explorer 和 Edge 以及最新版本的 Safari（2016 年 10 月发布的版本 10 中添加了复制支持）。

*   创建一个文本区域并将其内容设置为要复制到剪贴板的文本。
*   将文本区域附加到 DOM。
*   选择文本区域中的文本。
*   调用 document.execCommand("copy")
*   从 dom 中删除 textarea。

注意：您将看不到文本区域，因为它是在 Javascript 代码的同一同步调用中添加和删除的。

如果您自己实施此操作，需要注意一些事项：

*   出于安全原因，这只能从事件处理程序（例如单击）中调用（就像打开窗口一样）。
*   首次更新剪贴板时，Internet Explorer 将显示权限对话框。
*   当文本区域聚焦时，Internet Explorer 和 Edge 将滚动。
*   execCommand() 在某些情况下可能会抛出异常。
*   除非您使用文本区域，否则换行符和制表符可能会被吞掉。 （大多数文章似乎都推荐使用div）
*   当显示 Internet Explorer 对话框时，文本区域将可见，您需要隐藏它，或者使用 Internet Explorer 特定的剪贴板数据 API。
*   在 Internet Explorer 中，系统管理员可以禁用剪贴板 API。

下面的函数应该尽可能干净地处理以下所有问题。如果您发现任何问题或有任何改进建议，请发表评论。

    // Copies a string to the clipboard. Must be called from within an
    // event handler such as click. May return false if it failed, but
    // this is not always possible. Browser support for Chrome 43+,
    // Firefox 42+, Safari 10+, Edge and Internet Explorer 10+.
    // Internet Explorer: The clipboard feature may be disabled by
    // an administrator. By default a prompt is shown the first
    // time the clipboard is used (per session).
    function copyToClipboard(text) {
        if (window.clipboardData && window.clipboardData.setData) {
            // Internet Explorer-specific code path to prevent textarea being shown while dialog is visible.
            return window.clipboardData.setData("Text", text);
    
        }
        else if (document.queryCommandSupported && document.queryCommandSupported("copy")) {
            var textarea = document.createElement("textarea");
            textarea.textContent = text;
            textarea.style.position = "fixed";  // Prevent scrolling to bottom of page in Microsoft Edge.
            document.body.appendChild(textarea);
            textarea.select();
            try {
                return document.execCommand("copy");  // Security exception may be thrown by some browsers.
            }
            catch (ex) {
                console.warn("Copy to clipboard failed.", ex);
                return prompt("Copy to clipboard: Ctrl+C, Enter", text);
            }
            finally {
                document.body.removeChild(textarea);
            }
        }
    }
    

[https://jsfiddle.net/fx6a6n6x/](https://jsfiddle.net/fx6a6n6x/)

这是我对此的看法......

    function copy(text) {
        var input = document.createElement('input');
        input.setAttribute('value', text);
        document.body.appendChild(input);
        input.select();
        var result = document.execCommand('copy');
        document.body.removeChild(input);
        return result;
     }
    

@korayem：请注意，使用 html`input`字段不会考虑换行符`\n`，并且会将任何文本展平为单行。

正如 @nikksan 在评论中提到的，使用`textarea`将解决问题如下：

    function copy(text) {
        var input = document.createElement('textarea');
        input.innerHTML = text;
        document.body.appendChild(input);
        input.select();
        var result = document.execCommand('copy');
        document.body.removeChild(input);
        return result;
    }

从网页读取和修改剪贴板会引起安全和隐私问题。但是，在 Internet Explorer 中，可以做到这一点。我找到了这个[示例片段](http://www.sajithmr.com/onclick-select-all-and-copy-to-clipboard-javascript/)：

        <script type="text/javascript">
            function select_all(obj) {
                var text_val=eval(obj);
                text_val.focus();
                text_val.select();
                r = text_val.createTextRange();
                if (!r.execCommand) return; // feature detection
                r.execCommand('copy');
            }
        </script>
        <input value="http://www.sajithmr.com"
         onclick="select_all(this)" name="url" type="text" />

运行代码片段Hide results

展开片段

JS 如何将内容复制到剪贴板

在JavaScript中，有几种方法可以检查数组是否包含特定的值。这里是几种常见的方法：

### 1. `includes` 方法
从ES6/ECMAScript 2015开始，`Array.prototype.includes` 方法被引入来检查数组是否包含特定的元素。这个方法返回一个布尔值。

```javascript
let fruits = ['apple', 'banana', 'mango', 'orange'];
let containsMango = fruits.includes('mango'); // 返回 true
let containsCherry = fruits.includes('cherry'); // 返回 false
```

### 2. `indexOf` 方法
在ES6之前，`indexOf` 方法被广泛用来检查数组中是否存在某个元素。如果数组包含指定的元素，`indexOf` 方法会返回该元素在数组中的索引（从0开始计数），否则返回-1。

```javascript
let fruits = ['apple', 'banana', 'mango', 'orange'];
let mangoIndex = fruits.indexOf('mango'); // 返回 2
let containsMango = mangoIndex !== -1; // 如果索引不是-1，则包含mango，返回 true
let cherryIndex = fruits.indexOf('cherry'); // 返回 -1
let containsCherry = cherryIndex !== -1; // 返回 false
```

### 3. `find` 或 `findIndex` 方法
`find` 方法用于查找数组中满足提供的测试函数的第一个元素的值。如果没有找到符合条件的元素，则返回`undefined`。
`findIndex` 方法与`find`方法类似，但它返回的是找到的元素的索引，如果没有找到则返回-1。

```javascript
let fruits = ['apple', 'banana', 'mango', 'orange'];
let containsMango = fruits.find(fruit => fruit === 'mango') !== undefined; // 返回 true
let containsCherry = fruits.findIndex(fruit => fruit === 'cherry') !== -1; // 返回 false
```

### 4. `some` 方法
`some` 方法会测试数组中是不是至少有1个元素通过了被提供的函数测试，返回一个布尔值。

```javascript
let fruits = ['apple', 'banana', 'mango', 'orange'];
let containsMango = fruits.some(fruit => fruit === 'mango'); // 返回 true
let containsCherry = fruits.some(fruit => fruit === 'cherry'); // 返回 false
```

这些都是检查数组是否包含某个值的有效方法，使用哪一种主要取决于你的具体需求以及你的JavaScript版本兼容性要求。通常，`includes`方法是最直接和易读的方式，但如果你需要支持旧版浏览器，可能会需要使用`indexOf`。而`find`、`findIndex`和`some`方法则提供了更多的灵活性，允许你使用函数来确定是否包含某个值。

现代浏览器有[`Array#includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes#browser_compatibility)，它正是_这样_做的，并且得到除 IE 之外的所有人的[广泛支持：](https://kangax.github.io/compat-table/es2016plus/#test-Array.prototype.includes)

    console.log(['joe', 'jane', 'mary'].includes('jane')); // true

运行代码片段Hide results

展开片段

您还可以使用[`Array#indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)，这不太直接，但不需要针对过时的浏览器进行填充。

    console.log(['joe', 'jane', 'mary'].indexOf('jane') >= 0); // true

运行代码片段Hide results

展开片段

* * *

许多框架也提供了类似的方法：

*   jQuery：[`$.inArray(value, array, [fromIndex])`](https://api.jquery.com/jquery.inarray/)
*   Underscore.js：（[`_.contains(array, value)`](https://underscorejs.org/#contains)也别名为`_.include`和`_.includes`）
*   道场工具包：[`dojo.indexOf(array, value, [fromIndex, findLast])`](https://dojotoolkit.org/reference-guide/1.10/dojo/indexOf.html)
*   原型：[`array.indexOf(value)`](http://api.prototypejs.org/language/Array/prototype/indexOf/)
*   穆工具：[`array.indexOf(value)`](https://mootools.net/core/docs/1.6.0/Types/Array#Array:indexOf)
*   麻糬套件：[`findValue(array, value)`](http://mochi.github.io/mochikit/doc/html/MochiKit/Base.html#fn-findvalue)
*   阿贾克斯女士：[`array.indexOf(value)`](https://web.archive.org/web/20140819232945/http://www.asp.net/ajaxlibrary/Reference.Array-indexOf-Function.ashx)
*   分机：[`Ext.Array.contains(array, value)`](https://docs.sencha.com/extjs/7.5.1/modern/Ext.Array.html#method-contains)
*   Lodash：[`_.includes(array, value, [from])`](https://lodash.com/docs#includes)（`_.contains`4.0.0 之前的版本）
*   拉姆达：[`R.includes(value, array)`](https://ramdajs.com/docs/#includes)

请注意，某些框架将其实现为函数，而其他框架则将该函数添加到数组原型中。

**2019 年更新：这个答案来自 2008 年（11 岁了！），与现代 JS 的使用无关。承诺的性能改进是基于当时浏览器中完成的基准测试。它可能与现代 JS 执行上下文无关。如果您需要简单的解决方案，请寻找其他答案。如果您需要最佳性能，请在相关执行环境中为自己进行基准测试。**

正如其他人所说，通过数组进行迭代可能是最好的方法，但已经[证明](https://web.archive.org/web/20170403221045/https://blogs.oracle.com/greimer/entry/best_way_to_code_a)递减`while`循环是 JavaScript 中最快的迭代方法。因此，您可能需要按如下方式重写代码：

    function contains(a, obj) {
        var i = a.length;
        while (i--) {
           if (a[i] === obj) {
               return true;
           }
        }
        return false;
    }
    

当然，你也可以扩展Array原型：

    Array.prototype.contains = function(obj) {
        var i = this.length;
        while (i--) {
            if (this[i] === obj) {
                return true;
            }
        }
        return false;
    }
    

现在您可以简单地使用以下内容：

    alert([1, 2, 3].contains(2)); // => true
    alert([1, 2, 3].contains('2')); // => false

最上面的答案假设原始类型，但如果你想知道一个数组是否包含具有某种特征的**对象**，[Array.prototype.some()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/some)是一个优雅的解决方案：

    const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]
    
    items.some(item => item.a === '3')  // returns true
    items.some(item => item.a === '4')  // returns false
    

它的好处是，一旦找到元素，迭代就会中止，从而避免不必要的迭代周期。

此外，它非常适合语句，`if`因为它返回一个布尔值：

    if (items.some(item => item.a === '3')) {
      // do something
    }
    

\* 正如 jamess 在评论中指出的那样，在 2018 年 9 月发表此答案时，`Array.prototype.some()`完全支持：[caniuse.com 支持表](http://kangax.github.io/compat-table/es5/#test-Array_methods_Array.prototype.some_a_href=_https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some_title=_MDN_documentation_img_src=_../mdn.png_alt=_MDN_(Mozilla_Development_Network)_logo_width=_15_height=_13_/_/a_nbsp;)

[`indexOf`](https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Array/indexOf)也许吧，但它是“ECMA-262 标准的 JavaScript 扩展；因此它可能不会出现在该标准的其他实现中。”

例子：

    [1, 2, 3].indexOf(1) => 0
    ["foo", "bar", "baz"].indexOf("bar") => 1
    [1, 2, 3].indexOf(4) => -1
    

AFAICS [Microsoft 没有_提供_某种替代方案](http://msdn.microsoft.com/en-us/library/k4h76zbx%5C%28VS.85%5C%29.aspx)`indexOf`，但如果您愿意，您可以在 Internet Explorer（以及其他不支持的浏览器）中向数组添加类似的功能，正如[Google 快速搜索显示的](http://google.com/search?q=indexof%20internet%20explorer)那样（例如，[这个](http://soledadpenades.com/2007/05/17/arrayindexof-in-internet-explorer/)）。

ECMAScript 7 引入了[`Array.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).

它可以这样使用：

    [1, 2, 3].includes(2); // true
    [1, 2, 3].includes(4); // false
    

它还接受可选的第二个参数`fromIndex`：

    [1, 2, 3].includes(3, 3); // false
    [1, 2, 3].includes(3, -1); // true
    

`indexOf`与使用[Strict Equality Comparison](https://262.ecma-international.org/12.0/#sec-strict-equality-comparison)不同，`includes`使用[SameValueZero](https://262.ecma-international.org/12.0/#sec-samevaluezero)相等算法进行比较。这意味着您可以检测数组是否包含`NaN`：

    [1, 2, NaN].includes(NaN); // true
    

与 不同的是`indexOf`，`includes`它不会跳过缺失的索引：

    new Array(5).includes(undefined); // true
    

它可以被[填充](https://github.com/zloirock/core-js#ecmascript-array)以使其在所有浏览器上运行。

在 JavaScript 中，你可以使用多种方法来检查数组是否包含特定的值。以下是一些常见的方法：

### 1. `includes` 方法

```javascript
let array = [1, 2, 3, 4, 5];
let value = 3;

if (array.includes(value)) {
  console.log('数组包含该值');
} else {
  console.log('数组不包含该值');
}
```
`includes` 方法会检查数组中是否存在指定的值，并返回一个布尔值（`true` 或 `false`）。

### 2. `indexOf` 方法

```javascript
let array = [1, 2, 3, 4, 5];
let value = 3;

if (array.indexOf(value) !== -1) {
  console.log('数组包含该值');
} else {
  console.log('数组不包含该值');
}
```
`indexOf` 方法会查找数组中指定值的第一个索引，并返回该索引。如果数组不包含该值，则返回 `-1`。

### 3. `find` 方法

```javascript
let array = [1, 2, 3, 4, 5];
let value = 3;

if (array.find(element => element === value) !== undefined) {
  console.log('数组包含该值');
} else {
  console.log('数组不包含该值');
}
```
`find` 方法会返回数组中满足提供的测试函数的第一个元素的值。如果没有找到满足条件的元素，则返回 `undefined`。

### 4. `some` 方法

```javascript
let array = [1, 2, 3, 4, 5];
let value = 3;

if (array.some(element => element === value)) {
  console.log('数组包含该值');
} else {
  console.log('数组不包含该值');
}
```
`some` 方法会测试数组中是否至少有一个元素通过了提供的函数测试。返回的是一个布尔值。

### 注意事项
- `includes` 方法不会对数组中的 NaN 值进行区分，即 `[NaN].includes(NaN)` 会返回 `true`。
- `includes` 和 `indexOf` 方法不会检查数组中的对象引用或嵌套数组是否相等，它们只能用于原始类型的比较。
- `find` 和 `some` 方法可以通过提供的回调函数来实现更复杂的检查，包括对象的深度比较。

在使用这些方法时，你应该根据你要进行的检查的性质以及目标浏览器是否支持这些方法来选择最合适的。例如，`includes` 方法在 ES2016 (ES7) 中被引入，不被一些旧的浏览器支持。

JavaScript 如何检查数组是否包含某个值？

在JavaScript中验证电子邮件地址通常涉及到检查该地址是否符合电子邮件地址的标准格式。这通常通过使用正则表达式（Regular Expressions）来完成，正则表达式是一种强大的模式匹配工具，可以用来检测字符串是否符合特定的格式。

以下是一个使用正则表达式来验证电子邮件地址的例子：

```javascript
function validateEmail(email) {
    var emailRegex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
    return emailRegex.test(email);
}

// 使用示例
var email = "example@example.com";
if (validateEmail(email)) {
    console.log(email + " 是一个有效的电子邮件地址。");
} else {
    console.log(email + " 不是一个有效的电子邮件地址。");
}
```

这里的正则表达式解释如下：

1. `^` ：表示匹配字符串的开始。
2. `[a-zA-Z0-9._-]`：表示可以包含小写字母a-z、大写字母A-Z、数字0-9以及点号、下划线和破折号。
3. `+`：表示前面的字符或子表达式至少出现一次。
4. `@`：字面量@字符，电子邮件地址的一部分。
5. `[a-zA-Z0-9.-]`：表示域名部分可以包含小写字母a-z、大写字母A-Z、数字0-9以及点号和破折号。
6. `\.`：转义后的点号，表示域名的部分。
7. `[a-zA-Z]{2,6}`：表示顶级域名（TLD），可以是两到六个字母长。
8. `$`：表示匹配字符串的结尾。

这个正则表达式仅是一个基础版本，用于匹配大部分电子邮件地址的格式。然而，电子邮件地址的规范（例如RFC 5322）要复杂得多，包含许多特殊的规则和例外，这意味着创建一个完全符合规范的正则表达式非常复杂并且会很长。因此，上述正则表达式在实际应用中可能会因为太过简化而排除一些有效的电子邮件地址，或者可能会接受一些不合规范的电子邮件地址。

此外，即使一个电子邮件地址的格式正确，也无法保证该电子邮件地址是存在的或者可以接收邮件。要验证电子邮件地址是否真正有效，您可能还需要发送一封确认邮件并要求用户点击其中的链接以验证他们的地址。

为了提高用户体验，现代web应用程序通常会在前端使用类似的正则表达式来做初步验证，然后再在后端进行进一步的检查，也可能包括发送确认邮件来验证电子邮件地址的真实性。

使用[正则表达式](http://en.wikipedia.org/wiki/Regular_expression)可能是在 JavaScript 中验证电子邮件地址的最佳方法。查看来自[Chromium](https://cs.chromium.org/chromium/src/third_party/blink/web_tests/fast/forms/resources/ValidityState-typeMismatch-email.js?q=ValidityState-typeMismatch-email.js&sq=package:chromium&dr)[的 JSFiddle 测试](http://jsfiddle.net/ghvj4gy9/embedded/result.js)。[](https://cs.chromium.org/chromium/src/third_party/blink/web_tests/fast/forms/resources/ValidityState-typeMismatch-email.js?q=ValidityState-typeMismatch-email.js&sq=package:chromium&dr)

```
const validateEmail = (email) => {
  return String(email)
    .toLowerCase()
    .match(
      /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    );
};
```

以下是接受 unicode 的正则表达式示例。

```
const re =
  /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
```

请记住，不应单独依赖 JavaScript 验证，因为 JavaScript 很容易被客户端禁用。此外，在服务器端进行验证也很重要。 

以下代码片段是在客户端验证电子邮件地址的 JavaScript 示例。

```
const validateEmail = (email) => {
  return email.match(
    /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
  );
};

const validate = () => {
  const $result = $('#result');
  const email = $('#email').val();
  $result.text('');

  if(validateEmail(email)){
    $result.text(email + ' is valid.');
    $result.css('color', 'green');
  } else{
    $result.text(email + ' is invalid.');
    $result.css('color', 'red');
  }
  return false;
}

$('#email').on('input', validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for="email">Enter email address</label>
<input id="email" type="email">

<p id="result"></p>
```


展开片段

I've slightly modified [Jaymon's answer](https://stackoverflow.com/a/48800/4832311) for people who want really simple validation in the form of:

    anystring@anystring.anystring
    

The regular expression:

    /^\S+@\S+\.\S+$/
    

To prevent matching multiple @ signs:

    /^[^\s@]+@[^\s@]+\.[^\s@]+$/
    

The above regexes match the whole string, remove the leading and `^` and trailing `$` if you want to match anywhere in the string. The example below matches _anywhere_ in the string.

If you do want to match the whole sring, you may want to `trim()` the string first.

Example JavaScript function:

    function validateEmail(email) {
      var re = /\S+@\S+\.\S+/;
      return re.test(email);
    }
        
    console.log(validateEmail('my email is anystring@anystring.any')); // true
        
    console.log(validateEmail('my email is anystring@anystring .any')); // false

Run code snippetHide results

Expand snippet

Just for completeness, [here you have another RFC 2822 compliant regex](http://www.regular-expressions.info/email.html)

> The official standard is known as [RFC 2822](https://www.rfc-editor.org/rfc/rfc2822#section-3.4.1). It describes the syntax that valid email addresses must adhere to. You can (**but you shouldn't** — [read on](http://www.regular-expressions.info/email.html)) implement it with this regular expression:
> 
> ``(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])``
> 
> (...) We get a more practical implementation of RFC 2822 if we omit the syntax using double quotes and square brackets. **It will still match 99.99% of all email addresses in actual use today.**
> 
> ``[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?``
> 
> A further change you could make is to allow any two-letter country code top level domain, and only specific generic top level domains. **This regex filters dummy email addresses like `asdf@adsf.adsf`**. You **will need to update it as new top-level domains are added**.
> 
> ``[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b``
> 
> So even when following official standards, there are still trade-offs to be made. _**Don't blindly copy regular expressions from online libraries or discussion forums. Always test them on your own data and with your own applications.**_

Emphasis mine

Wow, there are lots of complexity here. If all you want to do is just catch the most obvious syntax errors, I would do something like this:

    ^\S+@\S+$
    

It usually catches the most obvious errors that the user makes and assures that the form is mostly right, which is what JavaScript validation is all about.

EDIT: We can also check for '.' in the email using

    /^\S+@\S+\.\S+$/

There's something you have to understand the second you decide to use a regular expression to validate emails: [It's probably not a good idea](http://ex-parrot.com/~pdw/Mail-RFC822-Address.html). Once you have come to terms with that, there are many implementations out there that can get you halfway there, [this article sums them up nicely.](http://www.regular-expressions.info/email.html)

In short, however, the only way to be absolutely, positively sure that what the user entered is in fact an email is to actually send an email and see what happens. Other than that it's all just guesses.

JS 如何验证电子邮件地址

在JavaScript中，`let`和`var`都可用于声明变量，但它们之间存在几个关键的区别：

1. **作用域**：
   - `var`声明的变量拥有函数作用域，如果在函数之外声明，则为全局作用域。
   - `let`声明的变量拥有块级作用域（block scope），即只在其声明的块或子块中有效。

**例子**：
```javascript
function varTest() {
  if (true) {
    var x = 2;
  }
  console.log(x); // 输出2，因为x在整个函数中都是可见的
}

function letTest() {
  if (true) {
    let y = 2;
  }
  console.log(y); // 引发错误，y不可见，因为它只在if块中有效
}
```
   
2. **变量提升**：
   - `var`声明的变量会被提升至函数或全局作用域的顶部，但是在执行到声明语句之前，变量的值是`undefined`。
   - `let`声明的变量也存在提升，但不会被初始化。在代码执行到声明语句之前，它不可以被访问，这个区间称为“暂时性死区”（temporal dead zone）。

**例子**：
```javascript
console.log(a); // 输出undefined，因为var声明的变量被提升了
var a = 3;

console.log(b); // 引发ReferenceError错误，因为此时b还在暂时性死区
let b = 4;
```

3. **重复声明**：
   - 使用`var`声明变量时，可以在同一作用域中重复声明同一个变量而不会出错。
   - 使用`let`声明变量时，不允许在相同作用域内重复声明同一个变量。

**例子**：
```javascript
var c = 1;
var c = 2; // 有效，不会出错

let d = 1;
let d = 2; // 无效，会引发SyntaxError错误
```

4. **全局对象的属性**：
   - 在全局作用域中，用`var`声明变量会创建一个新的全局对象的属性。
   - 用`let`在全局作用域中声明变量不会在全局对象中添加属性。

**例子**：
```javascript
var e = 5; // 在浏览器中，window.e将会是5
let f = 5; // 在浏览器中，window.f将是undefined
```

总结来说，`let`提供了比`var`更严格的作用域控制，是ES6引入的，以解决`var`引起的一些作用域问题并提供更好的代码管理方式。在现代JavaScript编程中，一般推荐使用`let`（和`const`）来代替`var`。

范围规则
====

主要区别在于范围规则。由关键字声明的变量的作用域`var`为直接函数体（因此为函数作用域），而`let`变量的作用域为由 表示的直接_封闭_块`{ }`（因此为块作用域）。

    function run() {
      var foo = "Foo";
      let bar = "Bar";
    
      console.log(foo, bar); // Foo Bar
    
      {
        var moo = "Mooo"
        let baz = "Bazz";
        console.log(moo, baz); // Mooo Bazz
      }
    
      console.log(moo); // Mooo
      console.log(baz); // ReferenceError
    }
    
    run();

运行代码片段Hide results

展开片段

`let`语言中引入关键字的原因是函数作用域令人困惑，并且是 JavaScript 中错误的主要来源之一。

看一下[另一个 Stack Overflow 问题](https://stackoverflow.com/questions/750486/javascript-closure-inside-loops-simple-practical-example)中的示例：

    var funcs = [];
    // let's create 3 functions
    for (var i = 0; i < 3; i++) {
      // and store them in funcs
      funcs[i] = function() {
        // each should log its value.
        console.log("My value: " + i);
      };
    }
    for (var j = 0; j < 3; j++) {
      // and now let's run each one to see
      funcs[j]();
    }

运行代码片段Hide results

展开片段

`My value: 3``funcs[j]();`由于匿名函数绑定到同一变量，因此每次调用时都会输出到控制台。

人们必须创建立即调用的函数来从循环中捕获正确的值，但这也很麻烦。

吊装
==

使用关键字声明的变量`var`会[被提升并_初始化_](https://dev.to/godcrampy/the-secret-of-hoisting-in-javascript-egi)，这意味着即使在声明它们之前，它们也可以在其封闭范围内访问，但是它们的值是`undefined`在到达声明语句之前：

    function checkHoisting() {
      console.log(foo); // undefined
      var foo = "Foo";
      console.log(foo); // Foo
    }
    
    checkHoisting();

运行代码片段Hide results

展开片段

`let` variables are [hoisted but _not initialized_](https://stackoverflow.com/questions/31219420/are-variables-declared-with-let-or-const-hoisted) until their definition is evaluated. Accessing them before the initialization results in a `ReferenceError`. The variable is said to be in [the temporal dead zone](https://stackoverflow.com/questions/33198849/what-is-the-temporal-dead-zone) from the start of the block until the declaration statement is processed.

    function checkHoisting() {
      console.log(foo); // ReferenceError
      let foo = "Foo";
      console.log(foo); // Foo
    }
    
    checkHoisting();

Run code snippetHide results

Expand snippet

Creating global object property
===============================

At the top level, `let`, unlike `var`, does not create a property on the global object:

    var foo = "Foo"; // globally scoped
    let bar = "Bar"; // globally scoped but not part of the global object
    
    console.log(window.foo); // Foo
    console.log(window.bar); // undefined

Run code snippetHide results

Expand snippet

Redeclaration
=============

In strict mode, `var` will let you re-declare the same variable in the same scope while `let` raises a SyntaxError.

    'use strict';
    var foo = "foo1";
    var foo = "foo2"; // No problem, 'foo1' is replaced with 'foo2'.
    
    let bar = "bar1"; 
    let bar = "bar2"; // SyntaxError: Identifier 'bar' has already been declared

Run code snippetHide results

Expand snippet

`let` can also be used to avoid problems with closures. It binds fresh value rather than keeping an old reference as shown in examples below.

    for(var i=1; i<6; i++) {
      $("#div" + i).click(function () { console.log(i); });
    }

    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    <p>Clicking on each number will log to console:</p> 
    <div id="div1">1</div>
    <div id="div2">2</div>
    <div id="div3">3</div>
    <div id="div4">4</div>
    <div id="div5">5</div>

Run code snippetHide results

Expand snippet

Code above demonstrates a classic JavaScript closure problem. Reference to the `i` variable is being stored in the click handler closure, rather than the actual value of `i`.

Every single click handler will refer to the same object because there’s only one counter object which holds 6 so you get six on each click.

A general workaround is to wrap this in an anonymous function and pass `i` as an argument. Such issues can also be avoided now by using `let` instead `var` as shown in the code below.

(Tested in Chrome and Firefox 50)

    for(let i=1; i<6; i++) {
      $("#div" + i).click(function () { console.log(i); });
    }

    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    <p>Clicking on each number will log to console:</p> 
    <div id="div1">1</div>
    <div id="div2">2</div>
    <div id="div3">3</div>
    <div id="div4">4</div>
    <div id="div5">5</div>

Run code snippetHide results

Expand snippet

### What's the difference between `let` and `var`?

*   A variable defined using a `var` statement is known throughout [**the function**](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/function) it is defined in, from the start of the function. _(\*)_
*   A variable defined using a `let` statement is only known in [**the block**](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/block) it is defined in, from the moment it is defined onward. _(\*\*)_

To understand the difference, consider the following code:

    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, but undefined
    // l IS NOT known here
    
    function loop(arr) {
        // i IS known here, but undefined
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    
        for( var i = 0; i < arr.length; i++ ) {
            // i IS known here, and has a value
            // j IS NOT known here
            // k IS known here, but has a value only the second time loop is called
            // l IS NOT known here
        };
    
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    
        for( let j = 0; j < arr.length; j++ ) {
            // i IS known here, and has a value
            // j IS known here, and has a value
            // k IS known here, but has a value only the second time loop is called
            // l IS NOT known here
        };
    
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    }
    
    loop([1,2,3,4]);
    
    for( var k = 0; k < arr.length; k++ ) {
        // i IS NOT known here
        // j IS NOT known here
        // k IS known here, and has a value
        // l IS NOT known here
    };
    
    for( let l = 0; l < arr.length; l++ ) {
        // i IS NOT known here
        // j IS NOT known here
        // k IS known here, and has a value
        // l IS known here, and has a value
    };
    
    loop([1,2,3,4]);
    
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
    

Here, we can see that our variable `j` is only known in the first for loop, but not before and after. Yet, our variable `i` is known in the entire function.

Also, consider that block scoped variables are not known before they are declared because they are not hoisted. You're also not allowed to redeclare the same block scoped variable within the same block. This makes block scoped variables less error prone than globally or functionally scoped variables, which are hoisted and which do not produce any errors in case of multiple declarations.

* * *

### Is it safe to use `let` today?

Some people would argue that in the future we'll ONLY use let statements and that var statements will become obsolete. JavaScript guru [**Kyle Simpson**](https://twitter.com/getify) wrote [**a very elaborate article on why he believes that won't be the case**](https://davidwalsh.name/for-and-against-let).

Today, however, that is definitely not the case. In fact, we need actually to ask ourselves whether it's safe to use the `let` statement. The answer to that question depends on your environment:

*   If you're writing server-side JavaScript code ([**Node.js**](https://nodejs.org/en/)), you can safely use the `let` statement.
    
*   If you're writing client-side JavaScript code and use a browser based transpiler (like [**Traceur**](https://github.com/google/traceur-compiler) or [**babel-standalone**](https://github.com/babel/babel-standalone)), you can safely use the `let` statement, however your code is likely to be anything but optimal with respect to performance.
    
*   If you're writing client-side JavaScript code and use a Node based transpiler (like the [**traceur shell script**](https://github.com/google/traceur-compiler/wiki/Compiling-Offline) or [**Babel**](https://babeljs.io/)), you can safely use the `let` statement. And, because your browser will only know about the transpiled code, performance drawbacks should be limited.
    
*   If you're writing client-side JavaScript code and don't use a transpiler, you need to consider browser support.
    
    There are still some browsers that don't support `let` at all :
    

[![在此输入图像描述](https://i.stack.imgur.com/J9kEC.png)](https://i.stack.imgur.com/J9kEC.png)

* * *

### How to keep track of browser support

For an up-to-date overview of which browsers support the `let` statement at the time of your reading this answer, see [**this `Can I Use` page**](http://caniuse.com/#search=let).

* * *

_(\*) Globally and functionally scoped variables can be initialized and used before they are declared because JavaScript variables are [**hoisted**](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)._ This means that declarations are always moved to the top of the scope.

_(\*\*) Block scoped variables are not hoisted_

Here's an [explanation of the `let` keyword](https://developer.mozilla.org/en/New_in_JavaScript_1.7#Block_scope_with_let) with some examples.

> `let` works very much like `var`. The main difference is that the scope of a `var` variable is the entire enclosing function

[This table](http://en.wikipedia.org/wiki/JavaScript#Version_history) on Wikipedia shows which browsers support Javascript 1.7.

Note that only Mozilla and Chrome browsers support it. IE, Safari, and potentially others don't.

`let`
=====

Block scope
-----------

Variables declared using the `let` keyword are block-scoped, which means that they are available only in the [block](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/block) in which they were declared.

### At the top level (outside of a function)

At the top level, variables declared using `let` don't create properties on the global object.

    var globalVariable = 42;
    let blockScopedVariable = 43;
    
    console.log(globalVariable); // 42
    console.log(blockScopedVariable); // 43
    
    console.log(this.globalVariable); // 42
    console.log(this.blockScopedVariable); // undefined
    

### Inside a function

Inside a function (but outside of a block), `let` has the same scope as `var`.

    (() => {
      var functionScopedVariable = 42;
      let blockScopedVariable = 43;
    
      console.log(functionScopedVariable); // 42
      console.log(blockScopedVariable); // 43
    })();
    
    console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
    console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined
    

### Inside a block

Variables declared using `let` inside a block can't be accessed outside that block.

    {
      var globalVariable = 42;
      let blockScopedVariable = 43;
      console.log(globalVariable); // 42
      console.log(blockScopedVariable); // 43
    }
    
    console.log(globalVariable); // 42
    console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined
    

### Inside a loop

Variables declared with `let` in loops can be referenced only inside that loop.

    for (var i = 0; i < 3; i++) {
      var j = i * 2;
    }
    console.log(i); // 3
    console.log(j); // 4
    
    for (let k = 0; k < 3; k++) {
      let l = k * 2;
    }
    console.log(typeof k); // undefined
    console.log(typeof l); // undefined
    // Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.
    

### Loops with closures

If you use `let` instead of `var` in a loop, with each iteration you get a new variable. That means that you can safely use a closure inside a loop.

    // Logs 3 thrice, not what we meant.
    for (var i = 0; i < 3; i++) {
      setTimeout(() => console.log(i), 0);
    }
    
    // Logs 0, 1 and 2, as expected.
    for (let j = 0; j < 3; j++) {
      setTimeout(() => console.log(j), 0);
    }
    

Temporal dead zone
------------------

Because of [the temporal dead zone](https://stackoverflow.com/q/33198849/3853934), variables declared using `let` can't be accessed before they are declared. Attempting to do so throws an error.

    console.log(noTDZ); // undefined
    var noTDZ = 43;
    console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
    let hasTDZ = 42;
    

No re-declaring
---------------

You can't declare the same variable multiple times using `let`. You also can't declare a variable using `let` with the same identifier as another variable which was declared using `var`.

    var a;
    var a; // Works fine.
    
    let b;
    let b; // SyntaxError: Identifier 'b' has already been declared
    
    var c;
    let c; // SyntaxError: Identifier 'c' has already been declared
    

`const`
=======

`const` is quite similar to `let`—it's block-scoped and has TDZ. There are, however, two things which are different.

No re-assigning
---------------

Variable declared using `const` can't be re-assigned.

    const a = 42;
    a = 43; // TypeError: Assignment to constant variable.
    

Note that it doesn't mean that the value is immutable. Its properties still can be changed.

    const obj = {};
    obj.a = 42;
    console.log(obj.a); // 42
    

If you want to have an immutable object, you should use [`Object.freeze()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze).

    const obj = Object.freeze({a: 40});
    obj.a = 42;
    console.log(obj.a); // 40
    console.log(obj.b); // undefined
    

Initializer is required
-----------------------

You always must specify a value when declaring a variable using `const`.

    const a; // SyntaxError: Missing initializer in const declaration

The accepted answer is missing a point:

    {
      let a = 123;
    };
    
    console.log(a); // ReferenceError: a is not defined

In most basic terms,
--------------------

```
for (let i = 0; i < 5; i++) {
  // i accessible ✔️
}
// i not accessible ❌
```

---

```
for (var i = 0; i < 5; i++) {
  // i accessible ✔️
}
// i accessible ✔️
```

---

Here is an example of the difference between the two:  
![在此输入图像描述](https://i.stack.imgur.com/dqNYW.png)

As you can see, the `var j` variable still has a value outside the for loop scope (Block Scope), but the `let i` variable is undefined outside of the for loop scope.

    "use strict";
    console.log("var:");
    for (var j = 0; j < 2; j++) {
      console.log(j);
    }
    
    console.log(j);
    
    console.log("let:");
    for (let i = 0; i < 2; i++) {
      console.log(i);
    }
    
    console.log(i);

Run code snippetHide results

Expand snippet

The main difference is the **scope** difference, while **let** can be only available inside the **scope** it's declared, like in for loop, **var** can be accessed outside the loop for example. From the documentation in [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) (examples also from MDN):

> **let** allows you to declare variables that are limited in scope to the block, statement, or expression on which it is used. This is unlike the **var** keyword, which defines a variable globally, or locally to an entire function regardless of block scope.

> Variables declared by **let** have as their scope the block in which they are defined, as well as in any contained sub-blocks. In this way, **let** works very much like **var**. The main difference is that the scope of a **var** variable is the entire enclosing function:
> 
>     function varTest() {
>       var x = 1;
>       if (true) {
>         var x = 2;  // same variable!
>         console.log(x);  // 2
>       }
>       console.log(x);  // 2
>     }
>     
>     function letTest() {
>       let x = 1;
>       if (true) {
>         let x = 2;  // different variable
>         console.log(x);  // 2
>       }
>       console.log(x);  // 1
>     }`
>     
> 
> At the top level of programs and functions, **let**, unlike **var**, does not create a property on the global object. For example:
> 
>     var x = 'global';
>     let y = 'global';
>     console.log(this.x); // "global"
>     console.log(this.y); // undefined
>     

> When used inside a block, let limits the variable's scope to that block. Note the difference between **var** whose scope is inside the function where it is declared.
> 
>     var a = 1;
>     var b = 2;
>     
>     if (a === 1) {
>       var a = 11; // the scope is global
>       let b = 22; // the scope is inside the if-block
>     
>       console.log(a);  // 11
>       console.log(b);  // 22
>     } 
>     
>     console.log(a); // 11
>     console.log(b); // 2
>     

Also don't forget it's ECMA6 feature, so it's not fully supported yet, so it's better always transpiles it to ECMA5 using Babel etc... for more info about visit [babel website](https://babeljs.io)

There are some subtle differences — `let` scoping behaves more like variable scoping does in more or less any other languages.

e.g. It scopes to the enclosing block, They don't exist before they're declared, etc.

However it's worth noting that `let` is only a part of newer Javascript implementations and has varying degrees of [browser support](http://caniuse.com/#search=let).

*   **Variable Not Hoisting**
    
    `let` will **not hoist** to the entire scope of the block they appear in. By contrast, `var` could hoist as below.
    
        {
           console.log(cc); // undefined. Caused by hoisting
           var cc = 23;
        }
        
        {
           console.log(bb); // ReferenceError: bb is not defined
           let bb = 23;
        }
        
    
    Actually, Per @Bergi, [Both `var` and `let` are hoisted](https://stackoverflow.com/questions/31219420/are-variables-declared-with-let-or-const-not-hoisted-in-es6).
    
*   **Garbage Collection**
    
    Block scope of `let` is useful relates to closures and garbage collection to reclaim memory. Consider,
    
        function process(data) {
            //...
        }
        
        var hugeData = { .. };
        
        process(hugeData);
        
        var btn = document.getElementById("mybutton");
        btn.addEventListener( "click", function click(evt){
            //....
        });
        
    
    The `click` handler callback does not need the `hugeData` variable at all. Theoretically, after `process(..)` runs, the huge data structure `hugeData` could be garbage collected. However, it's possible that some JS engine will still have to keep this huge structure, since the `click` function has a closure over the entire scope.
    
    However, the block scope can make this huge data structure to garbage collected.
    
        function process(data) {
            //...
        }
        
        { // anything declared inside this block can be garbage collected
            let hugeData = { .. };
            process(hugeData);
        }
        
        var btn = document.getElementById("mybutton");
        btn.addEventListener( "click", function click(evt){
            //....
        });
        
    
*   **`let` loops**
    
    `let` in the loop can **re-binds it** to each iteration of the loop, making sure to re-assign it the value from the end of the previous loop iteration. Consider,
    
        // print '5' 5 times
        for (var i = 0; i < 5; ++i) {
            setTimeout(function () {
                console.log(i);
            }, 1000);  
        }
        
    
    However, replace `var` with `let`
    
        // print 1, 2, 3, 4, 5. now
        for (let i = 0; i < 5; ++i) {
            setTimeout(function () {
                console.log(i);
            }, 1000);  
        }
        
    
    Because `let` create a new lexical environment with those names for a) the initialiser expression b) each iteration (previosly to evaluating the increment expression), more details are [here](https://stackoverflow.com/a/30900289/3011380).

The difference is in the [scope](https://en.wikipedia.org/wiki/Variable_(computer_science)#Scope_and_extent) of the variables declared with each.

In practice, there are a number of useful consequences of the difference in scope:

1.  `let` variables are only visible in their _nearest enclosing_ block (`{ ... }`).
2.  `let` variables are only usable in lines of code that occur _after_ the variable is declared (even though [they are hoisted](/questions/33198849)!).
3.  `let` variables may not be redeclared by a subsequent `var` or `let`.
4.  Global `let` variables are not added to the global `window` object.
5.  `let` variables are _easy to use_ with closures (they do not cause [race conditions](https://en.wikipedia.org/wiki/Race_condition#Software)).

The restrictions imposed by `let` reduce the visibility of the variables and increase the likelihood that unexpected name collisions will be found early. This makes it easier to track and reason about variables, including their [reachability](https://en.wikipedia.org/wiki/Unreachable_memory)(helping with reclaiming unused memory).

Consequently, `let` variables are less likely to cause problems when used in large programs or when independently-developed frameworks are combined in new and unexpected ways.

`var` may still be useful if you are sure you want the single-binding effect when using a closure in a loop (#5) or for declaring externally-visible global variables in your code (#4). Use of `var` for exports may be supplanted if [`export`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export) migrates out of transpiler space and into the core language.

Examples
========

**1\. No use outside nearest enclosing block:** This block of code will throw a reference error because the second use of `x` occurs outside of the block where it is declared with `let`:

    {
        let x = 1;
    }
    console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".
    

In contrast, the same example with `var` works.

**2\. No use before declaration:**  
This block of code will throw a `ReferenceError` before the code can be run because `x` is used before it is declared:

    {
        x = x + 1;  // ReferenceError during parsing: "x is not defined".
        let x;
        console.log(`x is ${x}`);  // Never runs.
    }
    

In contrast, the same example with `var` parses and runs without throwing any exceptions.

**3\. No redeclaration:** The following code demonstrates that a variable declared with `let` may not be redeclared later:

    let x = 1;
    let x = 2;  // SyntaxError: Identifier 'x' has already been declared
    

**4\. Globals not attached to `window`:**

    var button = "I cause accidents because my name is too common.";
    let link = "Though my name is common, I am harder to access from other JS files.";
    console.log(link);  // OK
    console.log(window.link);  // undefined (GOOD!)
    console.log(window.button);  // OK
    

**5\. Easy use with closures:** Variables declared with `var` do not work well with closures inside loops. Here is a simple loop that outputs the sequence of values that the variable `i` has at different points in time:

    for (let i = 0; i < 5; i++) {
        console.log(`i is ${i}`), 125/*ms*/);
    }
    

Specifically, this outputs:

    i is 0
    i is 1
    i is 2
    i is 3
    i is 4
    

In JavaScript we often use variables at a significantly later time than when they are created. When we demonstrate this by delaying the output with a closure passed to `setTimeout`:

    for (let i = 0; i < 5; i++) {
        setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
    }
    

... the output remains unchanged as long as we stick with `let`. In contrast, if we had used `var i` instead:

    for (var i = 0; i < 5; i++) {
        setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
    }
    

... the loop unexpectedly outputs "i is 5" five times:

    i is 5
    i is 5
    i is 5
    i is 5
    i is 5

Here's an example to add on to what others have already written. Suppose you want to make an array of functions, `adderFunctions`, where each function takes a single Number argument and returns the sum of the argument and the function's index in the array. Trying to generate `adderFunctions` with a loop using the `var` keyword won't work the way someone might naïvely expect:

    // An array of adder functions.
    var adderFunctions = [];
    
    for (var i = 0; i < 1000; i++) {
      // We want the function at index i to add the index to its argument.
      adderFunctions[i] = function(x) {
        // What is i bound to here?
        return x + i;
      };
    }
    
    var add12 = adderFunctions[12];
    
    // Uh oh. The function is bound to i in the outer scope, which is currently 1000.
    console.log(add12(8) === 20); // => false
    console.log(add12(8) === 1008); // => true
    console.log(i); // => 1000
    
    // It gets worse.
    i = -8;
    console.log(add12(8) === 0); // => true
    

The process above doesn't generate the desired array of functions because `i`'s scope extends beyond the iteration of the `for` block in which each function was created. Instead, at the end of the loop, the `i` in each function's closure refers to `i`'s value at the end of the loop (1000) for every anonymous function in `adderFunctions`. This isn't what we wanted at all: we now have an array of 1000 different functions in memory with exactly the same behavior. And if we subsequently update the value of `i`, the mutation will affect all the `adderFunctions`.

However, we can try again using the `let` keyword:

    // Let's try this again.
    // NOTE: We're using another ES6 keyword, const, for values that won't
    // be reassigned. const and let have similar scoping behavior.
    const adderFunctions = [];
    
    for (let i = 0; i < 1000; i++) {
      // NOTE: We're using the newer arrow function syntax this time, but 
      // using the "function(x) { ..." syntax from the previous example 
      // here would not change the behavior shown.
      adderFunctions[i] = x => x + i;
    }
    
    const add12 = adderFunctions[12];
    
    // Yay! The behavior is as expected. 
    console.log(add12(8) === 20); // => true
    
    // i's scope doesn't extend outside the for loop.
    console.log(i); // => ReferenceError: i is not defined
    

This time, `i` is rebound on each iteration of the `for` loop. Each function now keeps the value of `i` at the time of the function's creation, and `adderFunctions` behaves as expected.

Now, image mixing the two behaviors and you'll probably see why it's not recommended to mix the newer `let` and `const` with the older `var` in the same script. Doing so can result is some spectacularly confusing code.

    const doubleAdderFunctions = [];
    
    for (var i = 0; i < 1000; i++) {
        const j = i;
        doubleAdderFunctions[i] = x => x + i + j;
    }
    
    const add18 = doubleAdderFunctions[9];
    const add24 = doubleAdderFunctions[12];
    
    // It's not fun debugging situations like this, especially when the
    // code is more complex than in this example.
    console.log(add18(24) === 42); // => false
    console.log(add24(18) === 42); // => false
    console.log(add18(24) === add24(18)); // => false
    console.log(add18(24) === 2018); // => false
    console.log(add24(18) === 2018); // => false
    console.log(add18(24) === 1033); // => true
    console.log(add24(18) === 1030); // => true
    

Don't let this happen to you. Use a linter.

> **NOTE:** This is a teaching example intended to demonstrate the `var`/`let` behavior in loops and with function closures that would also be easy to understand. This would be a terrible way to add numbers. But the general technique of capturing data in anonymous function closures might be encountered in the real world in other contexts. YMMV.

The explanation is taken from the article I wrote at [Medium](https://blog.devgenius.io/how-does-hoisting-in-javascript-works-80614300cb98):

> Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their scope by the parser which reads the source code into an intermediate representation before the actual code execution starts by the JavaScript interpreter. So, it actually doesn’t matter where variables or functions are declared, they will be moved to the top of their scope regardless of whether their scope is global or local. This means that
> 
>     console.log (hi);     
>     var hi = "say hi";
>     
> 
> is actually interpreted to
> 
>     var hi = undefined;
>     console.log (hi);
>     hi = "say hi";
>     
> 
> So, as we saw just now, `var` variables are being hoisted to the top of their scope and are being initialized with the value of undefined which means that we can actually assign their value before actually declaring them in the code like so:
> 
>     hi = “say hi”
>     console.log (hi); // say hi
>     var hi;
>     
> 
> Regarding function declarations, we can invoke them before actually declaring them like so:
> 
>     sayHi(); // Hi
>     
>     function sayHi() {
>        console.log('Hi');
>     };
>     
> 
> Function expressions, on the other hand, are not hoisted, so we’ll get the following error:
> 
>     sayHi(); //Output: "TypeError: sayHi is not a function
>     
>     var sayHi = function() {
>       console.log('Hi');
>     }; 
>     
> 
> ES6 introduced JavaScript developers the `let` and `const` keywords. While `let` and `const` are block-scoped and not function scoped as `var` it shouldn’t make a difference while discussing their hoisting behavior. We’ll start from the end, JavaScript hoists `let` and `const`.
> 
>     console.log(hi); // Output: Cannot access 'hi' before initialization 
>     let hi = 'Hi';
>     
> 
> As we can see above, `let` doesn’t allow us to use undeclared variables, hence the interpreter explicitly output a reference error indicating that the `hi` variable cannot be accessed before initialization. The same error will occur if we change the above `let` to `const`
> 
>     console.log(hi); // Output: Cannot access 'hi' before initialization
>     const hi = 'Hi';
>     
> 
> So, bottom line, the JavaScript parser searches for variable declarations and functions and hoists them to the top of their scope before code execution and assign values to them in the memory so in case the interpreter will encounter them while executing the code he will recognize them and will be able to execute the code with their assigned values. Variables declared with `let` or `const` remain uninitialized at the beginning of execution while that variables declared with `var` are being initialized with a value of `undefined`.
> 
> I added this visual illustration to better help understanding of how are the hoisted variables and function are being saved in the memory [![在此输入图像描述](https://i.stack.imgur.com/7aRxL.png)](https://i.stack.imgur.com/7aRxL.png)

Function VS block scope:
------------------------

The main difference between `var` and `let` is that variables declared with `var` are **function scoped**. Whereas functions declared with `let` are **block scoped**. For example:

    function testVar () {
      if(true) {
        var foo = 'foo';
      }
    
      console.log(foo);
    }
    
    testVar();  
    // logs 'foo'
    
    
    function testLet () {
      if(true) {
        let bar = 'bar';
      }
    
      console.log(bar);
    }
    
    testLet(); 
    // reference error
    // bar is scoped to the block of the if statement 
    

**variables with `var`:**

When the first function `testVar` gets called the variable foo, declared with `var`, is still accessible outside the `if` statement. This variable `foo` would be available **everywhere** within the scope of the `testVar` **function**.

**variables with `let`:**

When the second function `testLet` gets called the variable bar, declared with `let`, is only accessible inside the `if` statement. Because variables declared with `let` are **block scoped** (where a block is the code between curly brackets e.g `if{}` , `for{}`, `function{}`).

`let` variables don't get hoisted:
----------------------------------

Another difference between `var` and `let` is variables with declared with `let` **don't get hoisted**. An example is the best way to illustrate this behavior:

variables with `let` **don't** get hoisted:

    console.log(letVar);
    
    let letVar = 10;
    // referenceError, the variable doesn't get hoisted
    

variables with `var` **do** get hoisted:

    console.log(varVar);
    
    var varVar = 10;
    // logs undefined, the variable gets hoisted
    

Global `let` doesn't get attached to `window`:
----------------------------------------------

A variable declared with `let` in the global scope (which is code that is not in a function) doesn't get added as a property on the global `window` object. For example (this code is in global scope):

    var bar = 5;
    let foo  = 10;
    
    console.log(bar); // logs 5
    console.log(foo); // logs 10
    
    console.log(window.bar);  
    // logs 5, variable added to window object
    
    console.log(window.foo);
    // logs undefined, variable not added to window object
    

  

> **When should `let` be used over `var`?**

Use `let` over `var` whenever you can because it is simply scoped more specific. This reduces potential naming conflicts which can occur when dealing with a large number of variables. `var` can be used when you want a global variable explicitly to be on the `window` object (always consider carefully if this is really necessary).

It also appears that, at least in Visual Studio 2015, TypeScript 1.5, "var" allows multiple declarations of the same variable name in a block, and "let" doesn't.

This won't generate a compile error:

    var x = 1;
    var x = 2;
    

This will:

    let x = 1;
    let x = 2;

**When Using `let`**

The `let` keyword attaches the variable declaration to the scope of whatever block (commonly a `{ .. }` pair) it's contained in. In other words,`let` implicitly hijacks any block's scope for its variable declaration.

`let` variables cannot be accessed in the `window` object because they cannot be globally accessed.

    function a(){
        { // this is the Max Scope for let variable
            let x = 12;
        }
        console.log(x);
    }
    a(); // Uncaught ReferenceError: x is not defined
    

**When Using `var`**

`var` and variables in ES5 has scopes in functions meaning the variables are valid within the function and not outside the function itself.

`var` variables can be accessed in the `window` object because they cannot be globally accessed.

    function a(){ // this is the Max Scope for var variable
        { 
            var x = 12;
        }
        console.log(x);
    }
    a(); // 12
    

**If you want to know more continue reading below**

one of the most famous interview questions on scope also can suffice the exact use of `let` and `var` as below;

**When using `let`**

    for (let i = 0; i < 10 ; i++) {
        setTimeout(
            function a() {
                console.log(i); //print 0 to 9, that is literally AWW!!!
            }, 
            100 * i);
    }
    

This is because when using `let`, for every loop iteration the variable is scoped and has its own copy.

**When using `var`**

    for (var i = 0; i < 10 ; i++) {
        setTimeout(
            function a() {
                console.log(i); //print 10 times 10
            }, 
            100 * i);
    }
    

This is because when using `var`, for every loop iteration the variable is scoped and has shared copy.

I just came across one use case that I had to use `var` over `let` to introduce new variable. Here's a case:

I want to create a new variable with dynamic variable names.

    let variableName = 'a';
    eval("let " + variableName + '= 10;');
    console.log(a);   // this doesn't work
    

    var variableName = 'a';
    eval("var " + variableName + '= 10;');
    console.log(a);   // this works
    

The above code doesn't work because `eval` introduces a new block of code. The declaration using `var` will declare a variable outside of this block of code since `var` declares a variable in the function scope.

`let`, on the other hand, declares a variable in a block scope. So, `a` variable will only be visible in `eval` block.

Now I think there is better scoping of variables to a block of statements using `let`:

    function printnums()
    {
        // i is not accessible here
        for(let i = 0; i <10; i+=)
        {
           console.log(i);
        }
        // i is not accessible here
    
        // j is accessible here
        for(var j = 0; j <10; j++)
        {
           console.log(j);
        }
        // j is accessible here
    }
    

I think people will start using let here after so that they will have similar scoping in JavaScript like other languages, Java, C#, etc.

People with not a clear understanding about scoping in JavaScript used to make the mistake earlier.

Hoisting is not supported using `let`.

With this approach errors present in JavaScript are getting removed.

Refer to _[ES6 In Depth: let and const](https://hacks.mozilla.org/2015/07/es6-in-depth-let-and-const/)_ to understand it better.

JavaScript相关问题