SCSS（Sassy CSS）和Sass（Syntactically Awesome Style Sheets）都是CSS预处理器，它们扩展了CSS的功能，允许开发者使用变量、条件语句、循环、继承、混合等高级功能来编写样式表。虽然它们两者都是同一个项目的两种不同格式，但在语法和使用方式上有所区别。

**1. 语法差异**

- **Sass** 也被称为缩进语法（或Sass旧语法），因为它使用缩进而不是大括号和分号来界定代码块和属性。这使得它的格式更干净、类似于其他缩进式语言，如Python。

  **示例（Sass）:**
  ```sass
  $primary-color: #333

  body
    font: 100% $primary-color
    background-color: #fff
  ```

- **SCSS** 的语法与原始CSS非常接近，它使用大括号和分号。这意味着任何合法的CSS代码都是合法的SCSS代码。因此，它对于那些已经熟悉CSS的开发者来说更容易上手。

  **示例（SCSS）:**
  ```scss
  $primary-color: #333;

  body {
    font: 100% $primary-color;
    background-color: #fff;
  }
  ```

**2. 兼容性**

- **Sass** 语法从一开始就与CSS的兼容性较差，因为不能直接使用CSS文件。如果要将现有的CSS迁移到Sass，需要重写语法格式。

- **SCSS** 因为其语法兼容性好，可以轻松地把旧的CSS文件改名为 `.scss` 后缀，即可直接使用，并且可以逐步引入SCSS特性。

**3. 文件扩展名**

- **Sass** 文件通常有 `.sass` 扩展名。

- **SCSS** 文件通常有 `.scss` 扩展名。

**4. 社区和工具支持**

随着时间的推移，**SCSS** 由于其更接近传统CSS的语法，得到了更广泛的社区和工具支持。

**例子**

在我之前的一个项目中，我们需要迁移一个旧的CSS代码库到更现代的CSS预处理器。基于团队成员对传统CSS的熟悉度和工具链的支持，我们最终选择了SCSS。这样，我们可以很容易地将现有的CSS代码重命名为 `.scss` 扩展名，并且立即开始利用SCSS的高级特性，例如变量和混合，同时几乎不需要改变现有代码的结构。

总的来说，SCSS和Sass提供了相同的功能集，选择使用哪一个主要取决于开发者的偏好以及项目需求。在实践中，SCSS因为其更高的兼容性和易于上手，成为了更受欢迎的选择。

Sass 是一个具有语法改进的 CSS 预处理器。高级语法中的样式表经过程序处理后，变成常规的CSS样式表。然而，它们并**没有**扩展 CSS 标准本身。

CSS 变量受支持且可以使用，但不如预处理器变量。

对于 SCSS 和 Sass 之间的区别，[Sass 文档页面](https://sass-lang.com/documentation/syntax)上的这段文字应该回答这个问题：

> SCSS 语法使用文件扩展名`.scss`.除了一些小例外，它是 CSS 的超集，这意味着基本上**所有有效的 CSS 也是有效的 SCSS**。由于它与 CSS 相似，因此它是最容易习惯且最受欢迎的语法。

> 缩进语法是 Sass 的原始语法，因此它使用文件扩展名`.sass`.由于这个扩展名，它有时简称为“Sass”。缩进语法支持与 SCSS 相同的所有功能，但它使用缩进而不是花括号和分号来描述文档的格式。

然而，**所有这一切都只能与 Sass 预编译器一起使用，**它最终会创建 CSS。它不是 CSS 标准本身的扩展。

我是帮助创建 Sass 的开发人员之一。

区别在于语法。在文字外观之下，它们是相同的。这就是 sass 和 scss 文件可以互相导入的原因。实际上，Sass 有四种语法解析器：scss、sass、CSS 和 less。所有这些都将不同的语法转换为[抽象语法树](http://en.wikipedia.org/wiki/Abstract_syntax_tree)，并通过 sass-convert 工具进一步处理为 CSS 输出，甚至转换为其他格式之一。

使用您最喜欢的语法，两者都得到完全支持，如果您改变主意，您可以稍后在它们之间进行更改。

Sass`.sass`文件在视觉上与文件不同`.scss`，例如

### Example.sass - sass 是较旧的语法

    $color: red
    
    =my-border($color)
      border: 1px solid $color
    
    body
      background: $color
      +my-border(green)
    

### Example.scss - sassy css 是 Sass 3 的新语法

    $color: red;
    
    @mixin my-border($color) {
      border: 1px solid $color;
    }
    
    body {
      background: $color;
      @include my-border(green);
    }
    

`.css`只需将扩展名从更改为 ，任何有效的 CSS 文档都可以转换为 Sassy CSS (SCSS) `.scss`。

_Sass_（_语法很棒的样式表_）有两种语法：

*   较新的：_SCSS_ ( _Sassy CSS_ )
*   以及一种较旧的、原始的： indent 语法，它是原始的_Sass_，也称为_Sass_。

_因此它们都是Sass_预处理器的一部分，具有两种不同的可能语法。

_SCSS_和原始_Sass_之间最重要的区别：

**_社会保障体系_**：

*   _语法与CSS_类似（以至于每个常规的有效_CSS3_也是有效的_SCSS_，但另一个方向的关系显然不会发生）
    
*   使用大括号`{}`
    
*   使用分号`;`
    
*   赋值符号是`:`
    
*   要创建一个_mixin_，它使用`@mixin`指令
    
*   要使用_mixin，_请在其前面加上`@include`指令
    
*   文件的扩展名为_.scss_。
    

**原始_萨斯_**：

*   _语法与Ruby_类似
*   没有大括号
*   没有严格的缩进
*   没有分号
*   赋值符号是`=`代替`:`
*   要创建一个 mixin，它使用`=`符号
*   要使用_mixin，_请在其前面加上`+`符号
*   文件的扩展名为_.sass_。

有些人更喜欢_Sass_，即原始语法，而另一些人则更喜欢_SCSS_。不管怎样，但值得注意的是，[_Sass 的_缩进语法尚未被弃用，也永远不会被弃用](https://web.archive.org/web/20121108051331/http://thesassway.com/news/sass-is-here-to-stay)（网络存档）。

**使用_sass-convert_**进行转换：

    # Convert Sass to SCSS
    $ sass-convert style.sass style.scss
    
    # Convert SCSS to Sass
    $ sass-convert style.scss style.sass
    

[Sass 和 SCSS 文档](https://sass-lang.com/documentation)

它的语法是不同的，这是主要的优点（或缺点，取决于你的观点）。

我会尽量不重复其他人所说的内容，你可以轻松地用谷歌搜索，但相反，我想根据我使用两者的经验（有时甚至在同一个项目中）说一些事情。

**SASS专业版**

*   更干净 - 如果您来自 Python、Ruby（您甚至可以使用类似符号的语法编写 props）甚至 CoffeeScript 世界，那么这对您来说会非常自然 - 编写 mixins、函数以及通常任何可重用的东西都“更容易`.sass`” ' 比`.scss`（主观）更可读。

**SASS 缺点**

*   空白敏感（主观），我不介意在其他语言中它，但在 CSS 中它只是困扰我（问题：复制、制表符与空格之战等）。
*   没有内联规则（这对我来说是破坏性的），你不能`body color: red`像在 .scss 中那样做`body {color: red}`
*   导入其他供应商的东西，复制普通的 CSS 片段 - 并非不可能，但一段时间后会很无聊。解决方案是在项目中包含`.scss`文件（与文件一起）或将它们转换为.`.sass``.sass`

除此之外 - 他们做同样的工作。

现在，我喜欢做的是编写 mixin 和变量，`.sass`以及在可能的情况下实际编译为 CSS 的代码`.scss`（即 Visual studio 不支持，`.sass`但每当我处理 Rails 项目时，我通常将其中两个结合起来，而不是在一个文件 ofc 中）。

最近，我正在考虑给**Stylus**一个机会（作为一个全职 CSS 预处理器），因为它允许您在一个文件中组合两种语法（以及一些其他功能）。对于团队来说这可能不是一个好的方向，但是当你独自维护它时 - 没关系。当语法有问题时，手写笔实际上是最灵活的。

最后 mixin 进行`.scss`vs`.sass`语法比较：

    // SCSS
    @mixin cover {
      $color: red;
      @for $i from 1 through 5 {
        &.bg-cover#{$i} { background-color: adjust-hue($color, 15deg * $i) }
      }
    }
    .wrapper { @include cover }
    
    
    // SASS
    =cover
      $color: red
      @for $i from 1 through 5
        &.bg-cover#{$i}
          background-color: adjust-hue($color, 15deg * $i)
    .wrapper
      +cover

What 's the difference between SCSS and Sass?

在JavaScript中，从数组中删除重复值可以通过几种不同的方法实现。以下是一些常见的方法，每种方法都有其自身的优势。

### 1. 使用`Set`对象
`Set`是ES6中引入的一个新的数据结构，它允许你存储唯一值（重复的元素会被忽略）。我们可以利用这个特性来删除数组中的重复值。

```javascript
const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]
```

使用`Set`对象是最简洁的方法，代码易于理解，且性能良好。

### 2. 使用`filter`方法
`Array.prototype.filter`方法可以用来遍历数组并返回一个新数组，包含所有通过测试函数的元素。我们可以利用这个方法来筛选出第一次出现的元素，从而达到去重的效果。

```javascript
const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = array.filter((item, index, arr) => arr.indexOf(item) === index);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]
```

这种方法不需要任何外部库或特定的语言特性，因此适用于老版本的JavaScript环境。

### 3. 使用`reduce`方法
`Array.prototype.reduce`方法对数组中的每个元素执行一个由您提供的“reducer”函数，将其结果汇总为单个返回值。我们可以用它来构建一个不包含重复值的数组。

```javascript
const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = array.reduce((acc, current) => {
  if (acc.indexOf(current) === -1) {
    acc.push(current);
  }
  return acc;
}, []);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]
```

这种方法给了我们更多的控制力，但它的效率可能不如使用`Set`对象。

### 4. 使用`forEach`方法和辅助对象
我们也可以使用`forEach`遍历数组，并使用一个辅助对象（或者`Map`）来记录已经出现过的值。

```javascript
const array = [1, 2, 2, 3, 4, 4, 5];
let uniqueObject = {};
const uniqueArray = [];

array.forEach((item) => {
  if (!uniqueObject[item]) {
    uniqueArray.push(item);
    uniqueObject[item] = true;
  }
});
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]
```

这种方法的效率也比较高，但是代码稍微复杂一些，并且需要额外的空间来存储辅助对象。

---

每种方法都有其适用场景，选择哪一种取决于具体需求、代码的可读性以及对旧版JavaScript的支持需求。例如，如果你正在编写一个需要在老版本浏览器上运行的应用程序，你可能需要避免使用`Set`和`filter`，而是选择`for`循环或其他ES5兼容的方法。如果你的环境支持ES6，那么使用`Set`可能是最简单和最直观的方式。

长话短说
----

使用[Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)构造函数和[展开语法](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax)：

    uniq = [...new Set(array)];
    

_（请注意 var`uniq`将是一个数组... `new Set()`将其转换为集合，但 \[...\] 再次将其转换回数组）_

* * *

“聪明”但天真的方式
----------

    uniqueArray = a.filter(function(item, pos) {
        return a.indexOf(item) == pos;
    })
    

基本上，我们迭代数组，并针对每个元素检查该元素在数组中的第一个位置是否等于当前位置。显然，对于重复元素来说，这两个位置是不同的。

使用过滤器回调的第三个（“这个数组”）参数，我们可以避免数组变量的闭包：

    uniqueArray = a.filter(function(item, pos, self) {
        return self.indexOf(item) == pos;
    })
    

尽管简洁，但该算法对于大型数组（二次时间）并不是特别有效。

哈希表来救援
------

    function uniq(a) {
        var seen = {};
        return a.filter(function(item) {
            return seen.hasOwnProperty(item) ? false : (seen[item] = true);
        });
    }
    

通常是这样做的。这个想法是将每个元素放入哈希表中，然后立即检查它是否存在。这给了我们线性时间，但至少有两个缺点：

*   由于哈希键只能是 JavaScript 中的字符串或符号，因此此代码不区分数字和“数字字符串”。也就是说，`uniq([1,"1"])`只会返回`[1]`
*   出于同样的原因，所有对象都将被视为相等：`uniq([{foo:1},{foo:2}])`将返回 just `[{foo:1}]`。

也就是说，如果您的数组仅包含基元并且您不关心类型（例如它始终是数字），则此解决方案是最佳的。

来自两个世界的最好的
----------

通用解决方案结合了这两种方法：它对基元使用哈希查找，对对象使用线性搜索。

    function uniq(a) {
        var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];
    
        return a.filter(function(item) {
            var type = typeof item;
            if(type in prims)
                return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
            else
                return objs.indexOf(item) >= 0 ? false : objs.push(item);
        });
    }
    

排序|独特的
------

另一种选择是先对数组进行排序，然后删除与前一个元素相等的每个元素：

    function uniq(a) {
        return a.sort().filter(function(item, pos, ary) {
            return !pos || item != ary[pos - 1];
        });
    }
    

同样，这不适用于对象（因为所有对象都相等`sort`）。此外，我们默默地更改原始数组作为副作用 - 不好！但是，如果您的输入已经排序，那么这就是要走的路（只需`sort`从上面删除）。

独特之处在于...
---------

有时，需要基于除相等之外的某些标准来唯一化列表，例如，过滤掉不同但共享某些属性的对象。这可以通过传递回调来优雅地完成。此“key”回调应用于每个元素，并且具有相同“key”的元素将被删除。由于`key`预计返回一个原语，因此哈希表在这里可以正常工作：

    function uniqBy(a, key) {
        var seen = {};
        return a.filter(function(item) {
            var k = key(item);
            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
        })
    }
    

一个特别有用的方法`key()`是`JSON.stringify`删除物理上不同但“看起来”相同的对象：

    a = [[1,2,3], [4,5,6], [1,2,3]]
    b = uniqBy(a, JSON.stringify)
    console.log(b) // [[1,2,3], [4,5,6]]
    

如果`key`不是原始的，则必须诉诸线性搜索：

    function uniqBy(a, key) {
        var index = [];
        return a.filter(function (item) {
            var k = key(item);
            return index.indexOf(k) >= 0 ? false : index.push(k);
        });
    }
    

在 ES6 中你可以使用`Set`：

    function uniqBy(a, key) {
        let seen = new Set();
        return a.filter(item => {
            let k = key(item);
            return seen.has(k) ? false : seen.add(k);
        });
    }
    

或`Map`：

    function uniqBy(a, key) {
        return [
            ...new Map(
                a.map(x => [key(x), x])
            ).values()
        ]
    }
    

它们都可以使用非原始键。

第一个还是最后一个？
----------

当通过键删除对象时，您可能希望保留第一个“相等”对象或最后一个对象。

使用`Set`上面的变体保留第一个，使用`Map`保留最后一个：

    function uniqByKeepFirst(a, key) {
        let seen = new Set();
        return a.filter(item => {
            let k = key(item);
            return seen.has(k) ? false : seen.add(k);
        });
    }
    
    
    function uniqByKeepLast(a, key) {
        return [
            ...new Map(
                a.map(x => [key(x), x])
            ).values()
        ]
    }
    
    //
    
    data = [
        {a:1, u:1},
        {a:2, u:2},
        {a:3, u:3},
        {a:4, u:1},
        {a:5, u:2},
        {a:6, u:3},
    ];
    
    console.log(uniqByKeepFirst(data, it => it.u))
    console.log(uniqByKeepLast(data, it => it.u))

运行代码片段Hide results

展开片段

图书馆
---

[underscore](http://underscorejs.org/#uniq)和[Lo-Dash](https://lodash.com/docs#uniq)都提供了`uniq`方法。他们的算法基本上类似于上面的第一个片段，归结为：

    var result = [];
    a.forEach(function(item) {
         if(result.indexOf(item) < 0) {
             result.push(item);
         }
    });
    

这是二次的，但还有一些额外的好处，例如包装 native `indexOf`、通过键进行统一的能力（`iteratee`用他们的说法）以及对已排序数组的优化。

如果你正在使用 jQuery 并且不能忍受没有一美元的任何东西，它会像这样：

      $.uniqArray = function(a) {
            return $.grep(a, function(item, pos) {
                return $.inArray(item, a) === pos;
            });
      }
    

这又是第一个片段的变体。

表现
--

JavaScript 中函数调用的开销很大，因此上述解决方案虽然简洁，但效率并不是特别高。为了获得最佳性能，请替换`filter`为循环并摆脱其他函数调用：

    function uniq_fast(a) {
        var seen = {};
        var out = [];
        var len = a.length;
        var j = 0;
        for(var i = 0; i < len; i++) {
             var item = a[i];
             if(seen[item] !== 1) {
                   seen[item] = 1;
                   out[j++] = item;
             }
        }
        return out;
    }
    

这段丑陋的代码与上面的代码片段 #3 的作用相同，但速度快了一个数量级（截至 2017 年，速度只有两倍 - JS 核心人员做得很好！）

显示代码片段

    function uniq(a) {
        var seen = {};
        return a.filter(function(item) {
            return seen.hasOwnProperty(item) ? false : (seen[item] = true);
        });
    }
    
    function uniq_fast(a) {
        var seen = {};
        var out = [];
        var len = a.length;
        var j = 0;
        for(var i = 0; i < len; i++) {
             var item = a[i];
             if(seen[item] !== 1) {
                   seen[item] = 1;
                   out[j++] = item;
             }
        }
        return out;
    }
    
    /////
    
    var r = [0,1,2,3,4,5,6,7,8,9],
        a = [],
        LEN = 1000,
        LOOPS = 1000;
    
    while(LEN--)
        a = a.concat(r);
    
    var d = new Date();
    for(var i = 0; i < LOOPS; i++)
        uniq(a);
    document.write('<br>uniq, ms/loop: ' + (new Date() - d)/LOOPS)
    
    var d = new Date();
    for(var i = 0; i < LOOPS; i++)
        uniq_fast(a);
    document.write('<br>uniq_fast, ms/loop: ' + (new Date() - d)/LOOPS)

Run code snippetHide results

Expand snippet

ES6
---

ES6 提供了[Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)对象，这使得事情变得更加容易：

    function uniq(a) {
       return Array.from(new Set(a));
    }
    

或者

    let uniq = a => [...new Set(a)];
    

请注意，与 python 不同，ES6 集合按插入顺序迭代，因此此代码保留原始数组的顺序。

但是，如果您需要一个具有唯一元素的数组，为什么不从一开始就使用集合呢？

发电机
---

`uniq`可以在相同的基础上构建“惰性”、基于生成器的版本：

*   从参数中获取下一个值
*   如果已经看过，请跳过
*   否则，产生它并将其添加到已经看到的值集中

    function* uniqIter(a) {
        let seen = new Set();
    
        for (let x of a) {
            if (!seen.has(x)) {
                seen.add(x);
                yield x;
            }
        }
    }
    
    // example:
    
    function* randomsBelow(limit) {
        while (1)
            yield Math.floor(Math.random() * limit);
    }
    
    // note that randomsBelow is endless
    
    count = 20;
    limit = 30;
    
    for (let r of uniqIter(randomsBelow(limit))) {
        console.log(r);
        if (--count === 0)
            break
    }
    
    // exercise for the reader: what happens if we set `limit` less than `count` and why

运行代码片段Hide results

展开片段

使用 jQuery 又快又脏：

    var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
    var uniqueNames = [];
    $.each(names, function(i, el){
        if($.inArray(el, uniqueNames) === -1) uniqueNames.push(el);
    });

厌倦了看到所有使用 for 循环或 jQuery 的糟糕例子。如今，Javascript 拥有完美的工具：排序、映射和归约。

Uniq 在保持现有顺序的同时减少
-----------------

    var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
    
    var uniq = names.reduce(function(a,b){
        if (a.indexOf(b) < 0 ) a.push(b);
        return a;
      },[]);
    
    console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
    
    // one liner
    return names.reduce(function(a,b){if(a.indexOf(b)<0)a.push(b);return a;},[]);
    

更快的 uniq 排序
-----------

可能还有更快的方法，但这个方法相当不错。

    var uniq = names.slice() // slice makes copy of array before sorting it
      .sort(function(a,b){
        return a > b;
      })
      .reduce(function(a,b){
        if (a.slice(-1)[0] !== b) a.push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
        return a;
      },[]); // this empty array becomes the starting value for a
    
    // one liner
    return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.push(b);return a;},[]);
    

2015年更新：ES6版本：
--------------

在 ES6 中，您有 Sets 和 Spread，这使得删除所有重复项变得非常容易且高效：

    var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
    

根据出现次数排序：
---------

有人询问如何根据唯一名称的数量对结果进行排序：

    var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']
    
    var uniq = names
      .map((name) => {
        return {count: 1, name: name}
      })
      .reduce((a, b) => {
        a[b.name] = (a[b.name] || 0) + b.count
        return a
      }, {})
    
    var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])
    
    console.log(sorted)

**Vanilla JS：使用像集合这样的对象删除重复项**

您始终可以尝试将其放入对象中，然后迭代其键：

    function remove_duplicates(arr) {
        var obj = {};
        var ret_arr = [];
        for (var i = 0; i < arr.length; i++) {
            obj[arr[i]] = true;
        }
        for (var key in obj) {
            ret_arr.push(key);
        }
        return ret_arr;
    }
    

**Vanilla JS：通过跟踪已经看到的值来删除重复项（订单安全）**

或者，对于顺序安全版本，使用一个对象来存储所有以前看到的值，并在添加到数组之前检查它的值。

    function remove_duplicates_safe(arr) {
        var seen = {};
        var ret_arr = [];
        for (var i = 0; i < arr.length; i++) {
            if (!(arr[i] in seen)) {
                ret_arr.push(arr[i]);
                seen[arr[i]] = true;
            }
        }
        return ret_arr;
    
    }
    

**ECMAScript 6：使用新的 Set 数据结构（顺序安全）**

ECMAScript 6 添加了新的`Set`数据结构，它允许您存储任何类型的值。 `Set.values`按插入顺序返回元素。

    function remove_duplicates_es6(arr) {
        let s = new Set(arr);
        let it = s.values();
        return Array.from(it);
    }
    

**用法示例：**

    a = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
    
    b = remove_duplicates(a);
    // b:
    // ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]
    
    c = remove_duplicates_safe(a);
    // c:
    // ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]
    
    d = remove_duplicates_es6(a);
    // d:
    // ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]

`.filter`使用数组和函数的单行版本`.indexOf`：

    arr = arr.filter(function (value, index, array) { 
      return array.indexOf(value) === index;
    });
    

### ES6方法

    arr = arr.filter((value, index, array) => 
      array.indexOf(value) === index
    )

在JavaScript中，可以使用多种方法从数组中删除重复的值。

1. **使用 Set**
   Set 是一种允许你存储任何类型唯一值的集合。因此，你可以利用 Set 来轻松去重。

   ```javascript
   const array = [1, 2, 2, 3, 4, 4, 5];
   const uniqueArray = [...new Set(array)];
   console.log(uniqueArray); // [1, 2, 3, 4, 5]
   ```

2. **使用 filter()**
   `filter()` 方法可以用来创建一个新数组，这个新数组由通过所提供函数测试的所有元素组成。这里我们可以检查当前元素的索引是否是它首次出现的索引。

   ```javascript
   const array = [1, 2, 2, 3, 4, 4, 5];
   const uniqueArray = array.filter((item, index, arr) => arr.indexOf(item) === index);
   console.log(uniqueArray); // [1, 2, 3, 4, 5]
   ```

3. **使用 reduce()**
   `reduce()` 方法对数组中的每个元素执行一个由你提供的“reducer”回调函数，将其结果汇总为单个返回值。你可以使用它来构建一个不包含重复项的新数组。

   ```javascript
   const array = [1, 2, 2, 3, 4, 4, 5];
   const uniqueArray = array.reduce((accumulator, current) => {
     if (accumulator.indexOf(current) === -1) {
       accumulator.push(current);
     }
     return accumulator;
   }, []);
   console.log(uniqueArray); // [1, 2, 3, 4, 5]
   ```

4. **使用 forEach() 和 includes()**
   你可以遍历数组并使用 `includes()` 方法检查结果数组中是否已经包含了当前项。

   ```javascript
   const array = [1, 2, 2, 3, 4, 4, 5];
   const uniqueArray = [];
   array.forEach(item => {
     if (!uniqueArray.includes(item)) {
       uniqueArray.push(item);
     }
   });
   console.log(uniqueArray); // [1, 2, 3, 4, 5]
   ```

以上是一些常见的方法来去除数组中的重复项。你可以根据实际情况选择最适合你的方法。通常情况下，使用 `Set` 是最简单快捷的方式。

How to remove duplicate values from js array

禁用文本选择突出显示通常指的是防止用户能够通过鼠标或其他输入设备选择页面上的文本。这样做有时是为了改善用户界面的体验或防止用户轻易复制网站内容。这可以通过多种方式实现，而最常见的方法是使用CSS或JavaScript。

### 通过CSS禁止文本选择：

可以使用CSS的 `user-select` 属性来控制哪些元素上的文本可以被用户选择。例如，要在整个网页上禁止文本选择，您可以在网页的样式表中添加以下CSS规则：

```css
/* 禁止页面上的所有文本选择 */
body {
  -webkit-user-select: none; /* Safari */
  -moz-user-select: none;    /* Firefox */
  -ms-user-select: none;     /* Internet Explorer/Edge */
  user-select: none;         /* 标准语法 */
}
```

如果只想针对特定元素禁止选择文本，您可以将选择器从 `body` 更改为您想要的特定类、ID或元素。

### 通过JavaScript禁止文本选择：

虽然CSS方法简单易用，但如果您需要更多控制，例如在用户进行特定操作后禁止文本选择，可以使用JavaScript。以下是如何执行此操作的一个例子：

```javascript
// 禁止文本选择的函数
function disableTextSelection() {
  document.onselectstart = function() { return false; };     // 针对IE
  document.onmousedown = function() { return false; };       // 针对其他浏览器
}

// 启用文本选择的函数
function enableTextSelection() {
  document.onselectstart = function() { return true; };      // 针对IE
  document.onmousedown = function() { return true; };        // 针对其他浏览器
}

// 当文档加载完成时禁用文本选择
document.addEventListener('DOMContentLoaded', function() {
  disableTextSelection();
});

// 如果需要在某些动作后重新启用文本选择，可以调用 enableTextSelection() 函数
```

通过以上方法，可以在需要的时候禁止或允许文本选择。但请注意，禁用文本选择可能会影响用户体验，并且并不能完全防止内容被复制（例如，用户可能通过查看网页源码来复制文本），应谨慎使用。

**2017 年 1 月更新：**

根据[Can I use 的说法](http://caniuse.com/#feat=user-select-none)，**Safari 的**`user-select`+足以在所有主要浏览器中实现所需的行为。**`-webkit-user-select`**

* * *

这些是所有可用的正确 CSS 变体：

    .noselect {
      -webkit-touch-callout: none; /* iOS Safari */
        -webkit-user-select: none; /* Safari */
         -khtml-user-select: none; /* Konqueror HTML */
           -moz-user-select: none; /* Old versions of Firefox */
            -ms-user-select: none; /* Internet Explorer/Edge */
                user-select: none; /* Non-prefixed version, currently
                                      supported by Chrome, Edge, Opera and Firefox */
    }

    <p>
      Selectable text.
    </p>
    <p class="noselect">
      Unselectable text.
    </p>

运行代码片段Hide results

展开片段

* * *

请注意，这`user-select`是在标准化过程中（目前在[W3C 工作草案](https://drafts.csswg.org/css-ui-4/#propdef-user-select)中）。它不能保证在所有地方都能工作，并且浏览器之间的实现可能存在差异。此外，浏览器将来可能会放弃对其的支持。

* * *

[更多信息可以在Mozilla 开发者网络文档](https://developer.mozilla.org/en-US/docs/Web/CSS/user-select)中找到。

该属性的值为`none`、`text`、`toggle`、`element`、`elements`和`all`。`inherit`

在大多数浏览器中，这可以使用 CSS 属性的专有变体来实现`user-select`，[最初在 CSS 3 中提出，然后被放弃，现在在](http://www.w3.org/TR/2000/WD-css3-userint-20000216#user-select)[CSS UI Level 4](https://drafts.csswg.org/css-ui-4/#content-selection)中提出：

    *.unselectable {
       -moz-user-select: none;
       -khtml-user-select: none;
       -webkit-user-select: none;
    
       /*
         Introduced in Internet Explorer 10.
         See http://ie.microsoft.com/testdrive/HTML5/msUserSelect/
       */
       -ms-user-select: none;
       user-select: none;
    }
    

对于 Internet Explorer < 10 和[Opera](http://en.wikipedia.org/wiki/Opera_%28web_browser%29) < 15，您将需要使用`unselectable`您希望不可选择的元素的属性。您可以使用 HTML 中的属性来设置它：

    <div id="foo" unselectable="on" class="unselectable">...</div>
    

遗憾的是，这个属性不是继承的，这意味着您必须在`<div>`.如果这是一个问题，您可以使用 JavaScript 为元素的后代递归地执行此操作：

    function makeUnselectable(node) {
        if (node.nodeType == 1) {
            node.setAttribute("unselectable", "on");
        }
        var child = node.firstChild;
        while (child) {
            makeUnselectable(child);
            child = child.nextSibling;
        }
    }
    
    makeUnselectable(document.getElementById("foo"));
    

* * *

**2014 年 4 月 30 日更新**：只要将新元素添加到树中，就需要重新运行此树遍历，但从 @Han 的评论看来，可以通过添加在目标上`mousedown`设置的事件处理程序来避免这种情况。`unselectable`事件。详情请参见[http://jsbin.com/yagekiji/1 。](http://jsbin.com/yagekiji/1)

* * *

这仍然没有涵盖所有可能性。虽然不可能在不可选择的元素中启动选择，但在某些浏览器（例如 Internet Explorer 和 Firefox）中，仍然不可能阻止在不可选择的元素之前开始和之后结束的选择，而不会使整个文档变得不可选择。

在 CSS 3 的[用户选择](http://www.w3.org/TR/1999/WD-css3-userint-19990916#user-select)属性可用之前，基于[Gecko](http://en.wikipedia.org/wiki/Gecko_%28layout_engine%29)的浏览器将支持`-moz-user-select`您已经找到的属性。[WebKit](https://en.wikipedia.org/wiki/WebKit)和基于 Blink 的浏览器支持该`-webkit-user-select`属性。

当然，不使用 Gecko 渲染引擎的浏览器不支持这一点。

没有符合“标准”的快速简便的方法来做到这一点；使用 JavaScript 是一种选择。

真正的问题是，为什么您希望用户无法突出显示以及复制和粘贴某些元素？我从来没有遇到过不想让用户突出显示我网站的某个部分的情况。我的几个朋友在花费大量时间阅读和编写代码后，会使用突出显示功能来记住他们在页面上的位置，或者提供一个标记，以便他们的眼睛知道下一步该看哪里。

我认为这是有用的唯一地方是，如果您有表单按钮，如果用户复制并粘贴网站，则不应复制和粘贴这些按钮。

Internet Explorer 的 JavaScript 解决方案是：

    onselectstart="return false;"

如果您想禁用除元素之外的所有内容的文本选择`<p>`，您可以在 CSS 中执行此操作（注意`-moz-none`允许在子元素中覆盖，这在其他浏览器中是允许的`none`）：

    * {
        -webkit-user-select: none;
        -khtml-user-select: none;
        -moz-user-select: -moz-none;
        -o-user-select: none;
        user-select: none;
    }
    
    p {
        -webkit-user-select: text;
        -khtml-user-select: text;
        -moz-user-select: text;
        -o-user-select: text;
        user-select: text;
    }

How to disable text selection highlighting

在JavaScript中，变量的作用域决定了在代码的哪些部分可以访问该变量。作用域可以是全局的或者局部的。

1. **全局作用域**：
   当一个变量在函数之外被声明时，它拥有全局作用域。这意味着它可以在代码的任何地方被访问和修改。全局变量在整个web页面的生命周期内都是可用的。

   例如：
   ```javascript
   var globalVar = "这是一个全局变量";

   function demoFunction() {
     console.log(globalVar); // 可以访问全局变量
   }

   demoFunction(); // 输出: 这是一个全局变量
   ```
   
   上面的 `globalVar` 就是一个全局变量，它可以在 `demoFunction` 函数内部被访问。

2. **局部作用域**：
   当一个变量在函数内部被声明时，它拥有局部作用域，也就是说它只能在该函数内部被访问和修改。局部变量对于函数外部的代码来说是隐藏的。

   例如：
   ```javascript
   function demoFunction() {
     var localVar = "这是一个局部变量";
     console.log(localVar); // 可以访问局部变量
   }

   demoFunction(); // 输出: 这是一个局部变量
   // console.log(localVar); // 错误：localVar 在这里是不可访问的
   ```
   
   `localVar` 只能在 `demoFunction` 函数内部被访问。

另外，JavaScript ES6 引入了两个新的关键字 `let` 和 `const` 来声明变量，它们提供了块级作用域（block scope）。

3. **块级作用域**：
   使用 `let` 和 `const` 声明的变量具有块级作用域。它们只能在包含它们的代码块（如一个for循环或者if语句）内部被访问。

   例如：
   ```javascript
   if (true) {
     let blockScopedVar = "这是一个块级作用域的变量";
     console.log(blockScopedVar); // 可以访问块级作用域的变量
   }

   // console.log(blockScopedVar); // 错误：blockScopedVar 在这里是不可访问的
   ```

在开发实际应用时，通常建议尽可能使用局部作用域或块级作用域来声明变量，以避免全局变量可能带来的命名冲突和难以追踪的bug。

总长DR
----

JavaScript 具有词法（也称为静态）作用域和闭包。这意味着您可以通过查看源代码来了解标识符的范围。

这四个范围是：

1.  全局 - 一切可见
2.  函数 - 在函数（及其子函数和块）内可见
3.  块 - 在块（及其子块）内可见
4.  模块 - 在模块内可见

除了全局和模块作用域的特殊情况之外，变量是使用`var`（函数作用域）、`let`（块作用域）和`const`（块作用域）声明的。大多数其他形式的标识符声明在严格模式下具有块作用域。

概述
--

范围是标识符有效的代码库区域。

词法环境是标识符名称和与其关联的值之间的映射。

作用域由词法环境的链接嵌套构成，嵌套中的每个级别对应于祖先执行上下文的词法环境。

这些链接的词汇环境形成了范围“链”。标识符解析是沿着这条链搜索匹配标识符的过程。

标识符解析仅发生在一个方向：向外。这样，外部词汇环境就无法“看到”内部词汇环境。

决定JavaScript 中[标识符](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-names-and-keywords)的[范围](https://en.wikipedia.org/wiki/Scope_(computer_science))有三个相关因素：[](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-names-and-keywords)

1.  标识符是如何声明的
2.  声明标识符的位置
3.  无论您处于[严格模式](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode)还是[非严格模式](https://developer.mozilla.org/en-US/docs/Glossary/Sloppy_mode)

声明标识符的一些方法：

1.  `var`，`let`和`const`
2.  功能参数
3.  catch 块参数
4.  函数声明
5.  命名函数表达式
6.  全局对象上隐式定义的属性（即`var`在非严格模式下丢失）
7.  `import`声明
8.  `eval`

可以声明一些位置标识符：

1.  全球背景
2.  函数体
3.  普通块
4.  控制结构的顶部（例如循环、if、while 等）
5.  控制结构体
6.  模块

声明样式
----

### 变量

使用声明的标识符具有`var` **函数作用域**，除非它们直接在全局上下文中声明，在这种情况下，它们将作为属性添加到全局对象上并具有全局作用域。它们在`eval`函数中的使用有单独的规则。

### 让和常量

使用`let`和声明的标识符`const` **具有块作用域**，除非直接在全局上下文中声明它们，在这种情况下它们具有全局作用域。

注：`let`、`const`、`var` [均为吊装](https://stackoverflow.com/a/31222689/38522)。这意味着它们定义的逻辑位置是其封闭范围（块或函数）的顶部。但是，在控制通过源代码中的声明点之前，无法读取或分配使用`let`and声明的变量。`const`过渡期被称为暂时死区。

    function f() {
        function g() {
            console.log(x)
        }
        let x = 1
        g()
    }
    f() // 1 because x is hoisted even though declared with `let`!

运行代码片段Hide results

展开片段

### 函数参数名称

函数参数名称的范围仅限于函数体。请注意，这有一点复杂。声明为默认参数的函数会关闭[参数列表](https://stackoverflow.com/questions/61208843/where-are-arguments-positioned-in-the-lexical-environment/)，而不是函数体。

### 函数声明

函数声明在严格模式下具有块作用域，在非严格模式下具有函数作用域。注意：非严格模式是一组复杂的紧急规则，基于不同浏览器的古怪历史实现。

### 命名函数表达式

命名函数表达式的范围仅限于其自身（例如，出于递归的目的）。

### 全局对象的隐式定义属性

在非严格模式下，全局对象上隐式定义的属性具有全局作用域，因为全局对象位于作用域链的顶部。在严格模式下，这些是不允许的。

### 评估

在`eval`字符串中，使用 using 声明的变量`var`将放置在当前范围内，或者，如果`eval`间接使用，则作为全局对象的属性。

例子
--

下面的代码将引发 ReferenceError，因为名称`x`、`y`、 和`z`在函数之外没有任何意义`f`。

    function f() {
        var x = 1
        let y = 1
        const z = 1
    }
    console.log(typeof x) // undefined (because var has function scope!)
    console.log(typeof y) // undefined (because the body of the function is a block)
    console.log(typeof z) // undefined (because the body of the function is a block)

运行代码片段Hide results

展开片段

`y`下面的代码将为and抛出一个 ReferenceError `z`，但对于 ，则不会`x`，因为 的可见性`x`不受块的约束。定义控制结构体（如`if`、`for`和`while`）的块的行为类似。

    {
        var x = 1
        let y = 1
        const z = 1
    }
    console.log(x) // 1
    console.log(typeof y) // undefined because `y` has block scope
    console.log(typeof z) // undefined because `z` has block scope

运行代码片段Hide results

展开片段

在下面，由于具有函数作用域，`x`因此在循环外部可见：`var`

    for(var x = 0; x < 5; ++x) {}
    console.log(x) // 5 (note this is outside the loop!)

运行代码片段Hide results

展开片段

...由于这种行为，您需要小心关闭使用`var`in 循环声明的变量。这里只声明了一个变量实例`x`，并且它在逻辑上位于循环之外。

下面的代码打印`5`, 五次，然后在循环外打印`5`第六次：`console.log`

    for(var x = 0; x < 5; ++x) {
        setTimeout(() => console.log(x)) // closes over the `x` which is logically positioned at the top of the enclosing scope, above the loop
    }
    console.log(x) // note: visible outside the loop

运行代码片段Hide results

展开片段

`undefined`由于`x`是块作用域，因此会打印以下内容。回调是一对一异步运行的。变量的新行为`let`意味着每个匿名函数都会对名为 的不同变量进行关闭`x`（与 不同`var`），因此会`0`打印整数`4`：

    for(let x = 0; x < 5; ++x) {
        setTimeout(() => console.log(x)) // `let` declarations are re-declared on a per-iteration basis, so the closures capture different variables
    }
    console.log(typeof x) // undefined

运行代码片段Hide results

展开片段

下面的代码不会抛出 a `ReferenceError`，因为 的可见性`x`不受块的约束；但是，它会打印，`undefined`因为变量尚未初始化（由于该`if`语句）。

    if(false) {
        var x = 1
    }
    console.log(x) // here, `x` has been declared, but not initialised

运行代码片段Hide results

展开片段

在循环顶部`for`使用声明的变量的`let`作用域为循环体：

    for(let x = 0; x < 10; ++x) {} 
    console.log(typeof x) // undefined, because `x` is block-scoped

运行代码片段Hide results

展开片段

以下代码将抛出 a `ReferenceError`，因为 的可见性`x`受到块的限制：

    if(false) {
        let x = 1
    }
    console.log(typeof x) // undefined, because `x` is block-scoped

运行代码片段Hide results

展开片段

使用`var`,`let`或声明的变量`const`都限定在模块范围内：

    // module1.js
    
    var x = 0
    export function f() {}
    
    //module2.js
    
    import f from 'module1.js'
    
    console.log(x) // throws ReferenceError
    

以下将在全局对象上声明一个属性，因为`var`在全局上下文中声明的变量将作为属性添加到全局对象中：

    var x = 1
    console.log(window.hasOwnProperty('x')) // true

运行代码片段Hide results

展开片段

`let`并且`const`在全局上下文中不向全局对象添加属性，但仍然具有全局作用域：

    let x = 1
    console.log(window.hasOwnProperty('x')) // false

运行代码片段Hide results

展开片段

函数参数可以认为是在函数体中声明：

    function f(x) {}
    console.log(typeof x) // undefined, because `x` is scoped to the function

运行代码片段Hide results

展开片段

Catch 块参数的作用域为 catch 块主体：

    try {} catch(e) {}
    console.log(typeof e) // undefined, because `e` is scoped to the catch block

运行代码片段Hide results

展开片段

命名函数表达式的作用域仅限于表达式本身：

    (function foo() { console.log(foo) })()
    console.log(typeof foo) // undefined, because `foo` is scoped to its own expression

运行代码片段Hide results

展开片段

在非严格模式下，全局对象上隐式定义的属性具有全局作用域。在严格模式下，您会收到错误。

    x = 1 // implicitly defined property on the global object (no "var"!)
    
    console.log(x) // 1
    console.log(window.hasOwnProperty('x')) // true

运行代码片段Hide results

展开片段

在非严格模式下，函数声明具有函数作用域。在严格模式下，它们具有块作用域。

    'use strict'
    {
        function foo() {}
    }
    console.log(typeof foo) // undefined, because `foo` is block-scoped

运行代码片段Hide results

展开片段

它是如何工作的
-------

范围定义为标识符有效的代码词汇区域[。](https://stackoverflow.com/a/1047479/38522)

在 JavaScript 中，每个函数对象都有一个隐藏引用，该引用是对其创建所在的[执行上下文](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-execution-contexts)（堆栈帧）的[词法环境](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-lexical-environments)`[[Environment]]`的引用。[](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-lexical-environments)[](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-execution-contexts)

当您调用函数时，`[[Call]]`会调用隐藏方法。此方法创建一个新的执行上下文，并在新的执行上下文和函数对象的词法环境之间建立链接。它通过将`[[Environment]]`函数对象上的值复制到新执行上下文的词法环境上的[外部引用字段中来实现此目的。](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-lexical-environments)

请注意，新的执行上下文和函数对象的词法环境之间的这种链接称为[闭包](https://stackoverflow.com/a/111114/38522)。

因此，在 JavaScript 中，作用域是通过外部引用以“链”形式链接在一起的词法环境来实现的。这个词法环境链称为作用域链，标识符解析是通过在[链中搜索](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-getidentifierreference)匹配的标识符来进行的。

了解[更多](https://github.com/getify/You-Dont-Know-JS/tree/2nd-ed/scope-closures)。

Javascript 使用作用域链来建立给定函数的作用域。通常有一个全局作用域，并且定义的每个函数都有其自己的嵌套作用域。在另一个函数中定义的任何函数都具有链接到外部函数的局部作用域。定义范围的始终是源代码中的位置。

作用域链中的元素基本上是一个带有指向其父作用域的指针的 Map。

解析变量时，JavaScript 从最内层范围开始向外搜索。

全局声明的变量具有全局作用域。函数内声明的变量的作用域为该函数，以及同名的影子全局变量。

（我确信真正的 JavaScript 程序员能够在其他答案中指出许多微妙之处。特别是我遇到了[这个页面](http://www.digital-web.com/articles/scope_in_javascript/)，了解`this`任何时候的确切含义。希望[这个更具介绍性的链接](http://bowles.byethost3.com/javascript/section6/lesson6.htm#part4)足以让您入门.)

老派 JavaScript
=============

传统上，JavaScript 实际上只有两种类型的作用域：

1.  **全局范围**：从应用程序启动时起，变量在整个应用程序中都是已知的_(\*)_
2.  **功能范围**：变量在其声明的[**函数**](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/function)内是已知的，从函数的开头开始_(\*)_

我不会详细说明这一点，因为已经有很多其他答案解释了其中的差异。

* * *

现代 JavaScript
=============

最新[**的 JavaScript 规范**](https://www.smashingmagazine.com/2015/10/es6-whats-new-next-version-javascript/)现在还允许第三个范围：

3.  **块作用域**：标识符[在其声明的作用域顶部](https://stackoverflow.com/a/31222689/38522)是“已知的” ，但在其声明行之后才能对其进行赋值或取消引用（读取）。这个过渡时期被称为“暂时死区”。

* * *

### 如何创建块作用域变量？

传统上，您可以像这样创建变量：

    var myVariable = "Some text";
    

块作用域变量是这样创建的：

    let myVariable = "Some text";
    

* * *

### 那么函数作用域和块作用域有什么区别呢？

要了解函数作用域和块作用域之间的区别，请考虑以下代码：

    // 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
    

在这里，我们可以看到我们的变量`j`仅在第一个 for 循环中已知，而不是之前和之后。然而，我们的变量`i`在整个函数中是已知的。

另外，请考虑块作用域变量在声明之前是未知的，因为它们没有被提升。您也不允许在同一块内重新声明同一块作用域变量。这使得块作用域变量比全局或函数作用域变量更不容易出错，全局或函数作用域变量被提升并且在多个声明的情况下不会产生任何错误。

* * *

### 现在使用块作用域变量安全吗？

今天使用是否安全取决于您的环境：

*   如果您正在编写服务器端 JavaScript 代码 ( [**Node.js**](https://nodejs.org/en/) )，则可以安全地使用该`let`语句。
    
*   如果您正在编写客户端 JavaScript 代码并使用基于浏览器的转译器（例如[**Traceur**](https://github.com/google/traceur-compiler)或[**babel-standalone**](https://github.com/babel/babel-standalone)），您可以安全地使用该`let`语句，但是您的代码在性能方面可能不是最佳的。
    
*   如果您正在编写客户端 JavaScript 代码并使用基于 Node 的转译器（如[**Traceur shell 脚本**](https://github.com/google/traceur-compiler/wiki/Compiling-Offline)或[**Babel**](https://babeljs.io/)），则可以安全地使用该`let`语句。而且由于您的浏览器只会了解转译的代码，因此性能缺陷应该是有限的。
    
*   如果您正在编写客户端 JavaScript 代码并且不使用转译器，则需要考虑浏览器支持。
    
    `let`以下是一些根本不支持的浏览器：
    
    *   **Internet Explorer 10**及以下版本
    *   **火狐浏览器 43**及以下版本
    *   **Safari 9**及以下版本
    *   **Android 浏览器 4**及以下版本
    *   **Opera 27**及以下版本
    *   **40丁目**以下
    *   任何版本的**Opera Mini**和**Blackberry 浏览器**

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

* * *

### 如何跟踪浏览器支持

`let`有关在您阅读此答案时哪些浏览器支持该声明的最新概述，请参阅[**此`Can I Use`页面**](http://caniuse.com/#search=let)。

* * *

_(\*) 全局和函数作用域的变量可以在声明之前初始化和使用，因为 JavaScript 变量是[**提升的**](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)。_这意味着声明总是位于范围的顶部。

这是一个例子：

    <script>
    
    var globalVariable = 7; //==window.globalVariable
    
    function aGlobal( param ) { //==window.aGlobal(); 
                                //param is only accessible in this function
      var scopedToFunction = {
        //can't be accessed outside of this function
    
        nested : 3 //accessible by: scopedToFunction.nested
      };
    
      anotherGlobal = {
        //global because there's no `var`
      }; 
    
    }
    
    </script>
    

您将需要研究闭包，以及如何使用它们来创建[私有成员](http://www.crockford.com/javascript/private.html)。

What is the scope of variables in javascript

在 JavaScript 中，要生成指定范围内的随机整数，你可以使用 `Math.random()` 函数来获得一个 [0, 1) 区间内的随机浮点数，然后通过适当的计算将其转换为你需要范围内的整数。

以下是一个如何生成介于 `min` 和 `max` 之间的随机整数（包括 `min` 和 `max`）的函数示例：

```javascript
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min); // 确保最小值是整数
  max = Math.floor(max); // 确保最大值是整数
  return Math.floor(Math.random() * (max - min + 1)) + min; // 向下取整以确保结果为整数
}
```

使用这个函数，你可以通过传入不同的 `min` 和 `max` 来得到一个在这个范围内的随机整数。例如：

```javascript
let randomNum = getRandomIntInclusive(1, 10); // 生成一个1到10之间的随机整数，包括1和10
console.log(randomNum);
```

这段代码会在控制台打印出一个介于 1 到 10 之间的随机整数。

[Mozilla 开发者网络](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)页面上有一些示例：

    /**
     * Returns a random number between min (inclusive) and max (exclusive)
     */
    function getRandomArbitrary(min, max) {
        return Math.random() * (max - min) + min;
    }
    
    /**
     * Returns a random integer between min (inclusive) and max (inclusive).
     * The value is no lower than min (or the next integer greater than min
     * if min isn't an integer) and no greater than max (or the next integer
     * lower than max if max isn't an integer).
     * Using Math.round() will give you a non-uniform distribution!
     */
    function getRandomInt(min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    

* * *

这是其背后的逻辑。这是一个简单的三条规则：

`Math.random()`返回`Number`介于 0（包含）和 1（不包含）之间的值。所以我们有一个这样的区间：

    [0 .................................... 1)
    

现在，我们想要一个`min`介于（包含）和`max`（不包含）之间的数字：

    [0 .................................... 1)
    [min .................................. max)
    

我们可以使用 来`Math.random`获取 \[min, max) 区间内的对应项。但是，首先我们应该通过`min`从第二个区间中减去一点来解决这个问题：

    [0 .................................... 1)
    [min - min ............................ max - min)
    

这给出：

    [0 .................................... 1)
    [0 .................................... max - min)
    

我们现在可以申请`Math.random`然后计算对应的。让我们选择一个随机数：

                    Math.random()
                        |
    [0 .................................... 1)
    [0 .................................... max - min)
                        |
                        x (what we need)
    

因此，为了找到`x`，我们会这样做：

    x = Math.random() * (max - min);
    

不要忘记加`min`回来，这样我们就得到了 \[min, max) 区间内的数字：

    x = Math.random() * (max - min) + min;
    

这是 MDN 的第一个功能。第二个返回介于`min`和之间的整数`max`（包含两者）。

现在要获取整数，您可以使用`round`,`ceil`或`floor`。

您可以使用`Math.round(Math.random() * (max - min)) + min`，但这会产生不均匀的分布。两者都有，`min`并且`max`只有大约一半的机会滚动：

    min...min+0.5...min+1...min+1.5   ...    max-0.5....max
    └───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
       min          min+1                          max
    

如果将`max`其排除在间隔之外，则滚动的机会甚至比 还要小`min`。

这样`Math.floor(Math.random() * (max - min +1)) + min`你就有了一个完美均匀的分布。

     min...  min+1...    ...      max-1... max....   (max+1 is excluded from interval)
    └───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
       min     min+1               max-1    max
    

您不能在该等式中使用`ceil()`and ，因为现在滚动的机会稍少，但您也可以滚动（不需要的）结果。`-1``max``min-1`

var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

[数学.随机()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)
=======================================================================================================

返回min（**包含**）和 max（**包含）之间的**[整数随机数](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#Getting_a_random_integer_between_two_values_inclusive)：

    function randomInteger(min, max) {
      return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    

或者min（**包含**）和 max（**不包含**）之间的[任何随机数：](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#Getting_a_random_number_between_two_values)

    function randomNumber(min, max) {
      return Math.random() * (max - min) + min;
    }
    

有用的示例（整数）：

    // 0 -> 10
    const rand1 = Math.floor(Math.random() * 11);
    
    // 1 -> 10
    const rand2 = Math.floor(Math.random() * 10) + 1;
    
    // 5 -> 20
    const rand3 = Math.floor(Math.random() * 16) + 5;
    
    // -10 -> (-2)
    const rand4 = Math.floor(Math.random() * 9) - 10;
    
    console.log(rand1);
    console.log(rand2);
    console.log(rand3);
    console.log(rand4);

运行代码片段Hide results

展开片段

\*\* 总是很高兴被提醒（Mozilla）：

> Math.random() 不提供加密安全随机数。请勿将它们用于与安全相关的任何事情。请改用 Web Crypto API，更准确地说是 window.crypto.getRandomValues() 方法。

使用：

    function getRandomizer(bottom, top) {
        return function() {
            return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
        }
    }
    

用法：

    var rollDie = getRandomizer( 1, 6 );
    
    var results = ""
    for ( var i = 0; i<1000; i++ ) {
        results += rollDie() + " ";    // Make a string filled with 1000 random numbers in the range 1-6.
    }
    

分解：

我们返回一个函数（借用函数式编程），当调用该函数时，将返回值`bottom`和之间的随机整数`top`（含）。我们说“包含”是因为我们希望将底部和顶部都包含在可返回的数字范围内。这样，`getRandomizer( 1, 6 )`将返回 1、2、3、4、5 或 6。

（“底部”是较小的数字，“顶部”是较大的数字）

    Math.random() * ( 1 + top - bottom )
    

`Math.random()``top`返回 0 和 1 之间的随机双精度值，如果我们将其乘以 1 加上和之间的差值，我们将得到和`bottom`之间的双精度值。`0``1+b-a`

    Math.floor( Math.random() * ( 1 + top - bottom ) )
    

`Math.floor`将数字向下舍入到最接近的整数。现在我们有了`0`和之间的所有整数`top-bottom`。 1 看起来令人困惑，但它必须存在，因为我们总是向下舍入，因此如果没有它，实际上永远不会达到最高数字。我们生成的随机小数需要在`0`to范围内，以便我们可以向下舍入并获得在to`(1+top-bottom)`范围内的整数：`0``top-bottom`

    Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
    

前面示例中的代码为我们提供了`0`和范围内的整数`top-bottom`，因此我们现在需要做的就是与该结果相加，以获得范围和范围内的`bottom`整数。 ：D`bottom``top`

* * *

注意：如果您首先传入非整数值或更大的数字，您将得到不良行为，但除非有人请求，否则我不会深入研究参数检查代码，因为它与原始问题的意图相去甚远。

所有这些解决方案都使用了太多的火力。你只需要调用一个函数：[Math.random();](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)

    Math.random() * max | 0;
    

这将返回 0（包含）和 max（不包含）之间的随机整数。

How to generating random whole numbers in javascrip

要将数字格式化为货币字符串，我们通常会遵循以下步骤：

1. **确定货币单位**：首先要决定使用哪种货币单位，比如美元（USD）、欧元（EUR）等，因为每种货币的格式可能有所不同。

2. **小数点精度**：货币通常需要保留两位小数，即分为单位。

3. **千分位分隔符**：大数额通常会使用逗号（在某些国家为点）作为千分位分隔符。

4. **货币符号**：根据货币的不同，可能会在前面或后面添加货币符号，比如'$'表示美元。

5. **负数的表示**：如果数额是负的，可以通过括号或者负号来表示。

举个例子，如果我们要将数字1234567.89格式化为美元字符串，我们会这样做：

- 确定货币单位：美元（$）
- 小数点精度：保留两位小数，即".89"
- 千分位分隔符：使用逗号将数字分隔为千分位，即"1,234,567.89"
- 货币符号：在数额前加上美元符号，即"$1,234,567.89"
- 负数的表示：如果是负数，写作"-$1,234,567.89"或"($1,234,567.89)"

在编程中，这可以通过各种方式实现，例如在JavaScript中，我们可以使用`Intl.NumberFormat`对象来格式化货币：

```javascript
const number = 1234567.89;
const formatter = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
});

const formatted = formatter.format(number); // "$1,234,567.89"
```

在Python中，我们可以使用内置的`locale`模块或者第三方库如`Babel`来实现相同的功能：

```python
import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')

number = 1234567.89
formatted = locale.currency(number, grouping=True)  # "$1,234,567.89"
```

这些方法都可以实现将数字格式化为货币字符串的目的，并且可以根据不同的地区设置进行定制。

[国际数字格式](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/NumberFormat)
===================================================================================================

JavaScript 有一个数字格式化程序（国际化 API 的一部分）。

    // Create our number formatter.
    const formatter = new Intl.NumberFormat('en-US', {
      style: 'currency',
      currency: 'USD',
    
      // These options are needed to round to whole numbers if that's what you want.
      //minimumFractionDigits: 0, // (this suffices for whole numbers, but will print 2500.10 as $2,500.1)
      //maximumFractionDigits: 0, // (causes 2500.99 to be printed as $2,501)
    });
    
    console.log(formatter.format(2500)); /* $2,500.00 */

运行代码片段Hide results

展开片段

使用系统区域`undefined`设置代替第一个参数（`'en-US'`在示例中）（如果代码在浏览器中运行，则为用户区域设置）。[区域设置代码的进一步解释](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation)。

这是[货币代码的列表](https://www.iban.com/currency-codes)。

Intl.NumberFormat 与 Number.prototype.toLocaleString
---------------------------------------------------

最后一点是将其与旧版本进行比较。`toLocaleString`。它们都提供本质上相同的功能。然而，toLocaleString 的旧版本（Intl 之前）[实际上并不支持语言环境](http://www.ecma-international.org/ecma-262/5.1/#sec-15.7.4.3)：它使用系统语言环境。因此，在调试旧浏览器时，请确保您使用的是正确的版本（[MDN 建议检查 是否存在`Intl`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString#Checking_for_support_for_locales_and_options_arguments)）。如果您不关心旧浏览器或只使用[shim](https://github.com/andyearnshaw/Intl.js)，则根本无需担心这一点。

_此外，对于单个_项目来说，两者的性能是相同的，但如果您有很多数字需要格式化，那么使用速度`Intl.NumberFormat`会快大约 70 倍。因此，通常最好`Intl.NumberFormat`在每次页面加载时仅使用和实例化一次。无论如何，这是等效的用法`toLocaleString`：

    console.log((2500).toLocaleString('en-US', {
      style: 'currency',
      currency: 'USD',
    })); /* $2,500.00 */

运行代码片段Hide results

展开片段

### 关于浏览器支持和 Node.js 的一些说明

*   如今，浏览器支持不再是问题，全球支持率超过 99%
*   如果您确实需要，有一个[垫片可以在化石浏览器（例如](https://github.com/andyearnshaw/Intl.js)[Internet Explorer 8](https://en.wikipedia.org/wiki/Internet_Explorer_8) ）上支持它
*   v13 之前的 Node.js 仅支持`en-US`开箱即用。一种解决方案是安装[full-icu](https://github.com/icu-project/full-icu-npm)，请参阅[此处](https://stackoverflow.com/a/39626602/1000608)了解更多信息
*   查看[CanIUse](https://caniuse.com/#feat=internationalization)了解更多信息

[Number.prototype.toFixed](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed)
---------------------------------------------------------------------------------------------------------------------------

该解决方案与每个主要浏览器兼容：

      const profits = 2489.8237;
    
      profits.toFixed(3) // Returns 2489.824 (rounds up)
      profits.toFixed(2) // Returns 2489.82
      profits.toFixed(7) // Returns 2489.8237000 (pads the decimals)
    

您所需要的只是添加货币符号（例如`"$" + profits.toFixed(2)`），您将获得美元金额。

自定义功能
-----

如果您需要在每个数字之间使用`,`，可以使用此功能：

    function formatMoney(number, decPlaces, decSep, thouSep) {
        decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,
        decSep = typeof decSep === "undefined" ? "." : decSep;
        thouSep = typeof thouSep === "undefined" ? "," : thouSep;
        var sign = number < 0 ? "-" : "";
        var i = String(parseInt(number = Math.abs(Number(number) || 0).toFixed(decPlaces)));
        var j = (j = i.length) > 3 ? j % 3 : 0;
    
        return sign +
            (j ? i.substr(0, j) + thouSep : "") +
            i.substr(j).replace(/(\decSep{3})(?=\decSep)/g, "$1" + thouSep) +
            (decPlaces ? decSep + Math.abs(number - i).toFixed(decPlaces).slice(2) : "");
    }
    
    document.getElementById("b").addEventListener("click", event => {
      document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
    });

    <label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
    <br />
    <button id="b">Get Output</button>
    <p id="x">(press button to get output)</p>

运行代码片段Hide results

展开片段

像这样使用它：

    (123456789.12345).formatMoney(2, ".", ",");
    

如果您总是要使用“.”和“，”，您可以将它们从方法调用中删除，该方法将为您默认它们。

    (123456789.12345).formatMoney(2);
    

如果您的文化有两个符号翻转（即欧洲人）并且您想使用默认值，只需在方法中粘贴以下两行`formatMoney`：

        d = d == undefined ? "," : d,
        t = t == undefined ? "." : t,
    

自定义函数（ES6）
----------

如果您可以使用现代 ECMAScript 语法（即通过 Babel），则可以使用这个更简单的函数：

    function formatMoney(amount, decimalCount = 2, decimal = ".", thousands = ",") {
      try {
        decimalCount = Math.abs(decimalCount);
        decimalCount = isNaN(decimalCount) ? 2 : decimalCount;
    
        const negativeSign = amount < 0 ? "-" : "";
    
        let i = parseInt(amount = Math.abs(Number(amount) || 0).toFixed(decimalCount)).toString();
        let j = (i.length > 3) ? i.length % 3 : 0;
    
        return negativeSign +
          (j ? i.substr(0, j) + thousands : '') +
          i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands) +
          (decimalCount ? decimal + Math.abs(amount - i).toFixed(decimalCount).slice(2) : "");
      } catch (e) {
        console.log(e)
      }
    };
    
    document.getElementById("b").addEventListener("click", event => {
      document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
    });

    <label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
    <br />
    <button id="b">Get Output</button>
    <p id="x">(press button to get output)</p>

运行代码片段Hide results

展开片段

简短而快速的解决方案（适用于任何地方！）
--------------------

    (12345.67).toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');  // 12,345.67
    

该解决方案背后的想法是用第一个匹配项和逗号替换匹配的部分，即`'$&,'`。匹配是使用[前瞻方法](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-lookahead)完成的。您可以将表达式理解为_“匹配一个数字，如果它后面跟着三个数字集（一个或多个）和一个点的序列”_。

**测试：**

    1        --> "1.00"
    12       --> "12.00"
    123      --> "123.00"
    1234     --> "1,234.00"
    12345    --> "12,345.00"
    123456   --> "123,456.00"
    1234567  --> "1,234,567.00"
    12345.67 --> "12,345.67"
    

**演示： http:** [//jsfiddle.net/hAfMM/9571/](http://jsfiddle.net/hAfMM/9571/)

* * *

扩展短解
----

您还可以扩展对象的原型[`Number`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Number)以添加对任意小数位数`[0 .. n]`和数字组大小的额外支持`[0 .. x]`：

    /**
     * Number.prototype.format(n, x)
     * 
     * @param integer n: length of decimal
     * @param integer x: length of sections
     */
    Number.prototype.format = function(n, x) {
        var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\.' : '$') + ')';
        return this.toFixed(Math.max(0, ~~n)).replace(new RegExp(re, 'g'), '$&,');
    };
    
    1234..format();           // "1,234"
    12345..format(2);         // "12,345.00"
    123456.7.format(3, 2);    // "12,34,56.700"
    123456.789.format(2, 4);  // "12,3456.79"
    

**演示/测试：** [http://jsfiddle.net/hAfMM/435/](http://jsfiddle.net/hAfMM/435/)

* * *

超长短解
----

在此[超级扩展版本](https://stackoverflow.com/questions/149055/how-can-i-format-numbers-as-money-in-javascript/14428340#comment34151293_14428340)中您可以设置不同的分隔符类型：

    /**
     * Number.prototype.format(n, x, s, c)
     * 
     * @param integer n: length of decimal
     * @param integer x: length of whole part
     * @param mixed   s: sections delimiter
     * @param mixed   c: decimal delimiter
     */
    Number.prototype.format = function(n, x, s, c) {
        var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\D' : '$') + ')',
            num = this.toFixed(Math.max(0, ~~n));
    
        return (c ? num.replace('.', c) : num).replace(new RegExp(re, 'g'), '$&' + (s || ','));
    };
    
    12345678.9.format(2, 3, '.', ',');  // "12.345.678,90"
    123456.789.format(4, 4, ' ', ':');  // "12 3456:7890"
    12345678.9.format(0, 3, '-');       // "12-345-679"
    

**演示/测试：** [http://jsfiddle.net/hAfMM/612/](http://jsfiddle.net/hAfMM/612/)

看一下 JavaScript [Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)对象，看看它是否可以帮助您。

*   `toLocaleString()`将使用特定于位置的千位分隔符格式化数字。
*   `toFixed()`将数字四舍五入到特定的小数位数。

要同时使用这些值，必须将其类型更改回数字，因为它们都输出字符串。

例子：

    Number((someNumber).toFixed(1)).toLocaleString()
    

**编辑**

可以直接使用 toLocaleString ，不需要重新转换为数字：

    someNumber.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2});
    

#### 多个号码

如果您需要经常类似地格式化数字，您可以创建一个特定的对象以供重用。就像德语（瑞士）：

    const money = new Intl.NumberFormat('de-CH',
      { style:'currency', currency: 'CHF' });
    const percent = new Intl.NumberFormat('de-CH',
      { style:'percent', maximumFractionDigits: 1, signDisplay: "always"});
    

可以用作：

    money.format(1234.50); // output CHF 1'234.50
    percent.format(0.083);  // output +8.3%
    

相当漂亮。

以下是[Patrick Desjardins（别名 Daok）的](https://stackoverflow.com/questions/149055/how-can-i-format-numbers-as-money-in-javascript/149099#149099)代码，添加了一些注释和一些细微的更改：

    /*
    decimal_sep: character used as decimal separator, it defaults to '.' when omitted
    thousands_sep: char used as thousands separator, it defaults to ',' when omitted
    */
    Number.prototype.toMoney = function(decimals, decimal_sep, thousands_sep)
    {
       var n = this,
       c = isNaN(decimals) ? 2 : Math.abs(decimals), // If decimal is zero we must take it. It means the user does not want to show any decimal
       d = decimal_sep || '.', // If no decimal separator is passed, we use the dot as default decimal separator (we MUST use a decimal separator)
    
       /*
       According to [https://stackoverflow.com/questions/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function]
       the fastest way to check for not defined parameter is to use typeof value === 'undefined'
       rather than doing value === undefined.
       */
       t = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep, // If you don't want to use a thousands separator you can pass empty string as thousands_sep value
    
       sign = (n < 0) ? '-' : '',
    
       // Extracting the absolute value of the integer part of the number and converting to string
       i = parseInt(n = Math.abs(n).toFixed(c)) + '',
    
       j = ((j = i.length) > 3) ? j % 3 : 0;
       return sign + (j ? i.substr(0, j) + t : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : '');
    }
    

这里有一些测试：

    // Some tests (do not forget parenthesis when using negative numbers and number with no decimals)
    alert(123456789.67392.toMoney() + '\n' + 123456789.67392.toMoney(3) + '\n' + 123456789.67392.toMoney(0) + '\n' + (123456).toMoney() + '\n' + (123456).toMoney(0) + '\n' + 89.67392.toMoney() + '\n' + (89).toMoney());
    
    // Some tests (do not forget parenthesis when using negative numbers and number with no decimals)
    alert((-123456789.67392).toMoney() + '\n' + (-123456789.67392).toMoney(-3));
    

较小的变化是：

1.  移动一点`Math.abs(decimals)`只有当不是时才能完成`NaN`。
    
2.  `decimal_sep`不能再是空字符串（某种小数点分隔符是必须_的_）
    
3.  我们[按照如何最好地确定参数是否未发送到 JavaScript 函数中的](https://stackoverflow.com/questions/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function)`typeof thousands_sep === 'undefined'`建议使用[](https://stackoverflow.com/questions/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function)
    
4.  `(+n || 0)`不需要，因为它`this`是一个`Number`对象
    

[JSFiddle](https://jsfiddle.net/9kvrndfu/)

How to format numbers as currency strings

在 JavaScript 中，可以通过多种方式来比较两个日期。以下是几种常见的方法：

### 1. 使用 `Date` 对象直接比较
JavaScript 的 `Date` 对象可以用来表示日期和时间。直接使用比较操作符（`<`, `>`, `<=`, `>=`）来比较两个日期对象是一种简单直接的方法：

```javascript
let date1 = new Date('2023-04-01');
let date2 = new Date('2023-04-02');

if (date1 < date2) {
  console.log('date1 is earlier than date2');
} else if (date1 > date2) {
  console.log('date1 is later than date2');
} else {
  console.log('date1 is the same as date2');
}
```

### 2. 使用 `getTime()` 方法
`Date` 对象的 `getTime()` 方法返回自1970年1月1日 00:00:00 UTC以来所经过的毫秒数。这可以用于精确比较两个日期：

```javascript
let date1 = new Date('2023-04-01');
let date2 = new Date('2023-04-02');

if (date1.getTime() < date2.getTime()) {
  console.log('date1 is earlier than date2');
} else if (date1.getTime() > date2.getTime()) {
  console.log('date1 is later than date2');
} else {
  console.log('date1 is the same as date2');
}
```

### 3. 对日期的各个组成部分分别比较
如果你想要比较日期的某个特定部分（例如，只比较年份），你可以使用 `Date` 对象提供的方法，如 `getFullYear()`, `getMonth()`, `getDate()` 等来获取相应部分的值然后进行比较：

```javascript
let date1 = new Date('2023-04-01');
let date2 = new Date('2023-04-02');

if (date1.getFullYear() < date2.getFullYear()) {
  console.log('date1 is in an earlier year than date2');
} else if (date1.getMonth() < date2.getMonth()) {
  // 注意：月份从0开始，0代表一月
  console.log('date1 is in an earlier month than date2');
} else if (date1.getDate() < date2.getDate()) {
  console.log('date1 is on an earlier day than date2');
} else {
  console.log('The specific parts compared are equal');
}
```

### 示例
假设你正在编写一个网站，要求用户输入他们的生日，然后你需要检查输入的日期是否是过去的日期。你可以如下实现这个功能：

```javascript
function isPastDate(inputDate) {
  let today = new Date();
  let birthDate = new Date(inputDate);

  // 将今天的时间部分清零
  today.setHours(0, 0, 0, 0);

  return birthDate < today;
}

// 假设用户输入了 "2000-05-20"
let userInput = '2000-05-20';

if (isPastDate(userInput)) {
  console.log('The entered date is in the past.');
} else {
  console.log('The entered date is not in the past.');
}
```

在这个例子中，`isPastDate` 函数用来检查用户输入的日期是否比当前日期早。如果是，函数将返回 `true`，表示这是一个过去的日期。在比较之前，我们通过设置时、分、秒和毫秒为0来确保只比较日期部分。

Date[对象](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)将执行您想要的操作 - 为每个日期构造一个日期，然后使用`>`、`<`或进行比较。`<=``>=`

`==`、`!=`、`===`和运算`!==`符要求您使用`date.getTime()`如下所示

    var d1 = new Date();
    var d2 = new Date(d1);
    var same = d1.getTime() === d2.getTime();
    var notSame = d1.getTime() !== d2.getTime();
    

需要明确的是，直接检查日期对象是否相等是行不通的

    var d1 = new Date();
    var d2 = new Date(d1);
    
    console.log(d1 == d2);   // prints false (wrong!) 
    console.log(d1 === d2);  // prints false (wrong!)
    console.log(d1 != d2);   // prints true  (wrong!)
    console.log(d1 !== d2);  // prints true  (wrong!)
    console.log(d1.getTime() === d2.getTime()); // prints true (correct)
    

不过，我建议您使用下拉菜单或某种类似的受限制的日期输入形式，而不是文本框，以免您发现自己陷入输入验证地狱。

* * *

对于好奇的人，[`date.getTime()`文档](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime)：

> 返回指定日期的数值，作为自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数。 （之前的时间返回负值。）

像往常一样比较`<`and ，但任何涉及or 的内容都应该使用前缀。就像这样：`>``==``===``+`

    const x = new Date('2013-05-23');
    const y = new Date('2013-05-23');
    
    // less than, greater than is fine:
    console.log('x < y', x < y); // false
    console.log('x > y', x > y); // false
    console.log('x <= y', x <= y); // true
    console.log('x >= y', x >= y); // true
    console.log('x === y', x === y); // false, oops!
    
    // anything involving '==' or '===' should use the '+' prefix
    // it will then compare the dates' millisecond values
    
    console.log('+x === +y', +x === +y); // true

运行代码片段Hide results

展开片段

在 javascript 中比较日期的最简单方法是首先将其转换为 Date 对象，然后比较这些日期对象。

下面你会发现一个具有三个功能的对象：

*   **日期.比较(a,b)**
    
    返回一个数字：
    
    *   \-1 如果 a < b
    *   0 如果 a = b
    *   1 如果 a > b
    *   NaN 如果 a 或 b 是非法日期
*   **日期.inRange** (d,开始,结束)
    
    返回布尔值或 NaN：
    
    *   如果_d_位于_开始_和_结束_之间（含），则为_true_
    *   如果_d_在_start_之前或_end之后，则__返回 false_。
    *   NaN 如果一个或多个日期非法。
*   **日期.转换**
    
    被其他函数用来将其输入转换为日期对象。输入可以是
    
    *   日期**对象**：输入按原样返回。
    *   数组：解释为\[年、月、日\] **。****注意**月份是 0-11。
    *   a **number**：解释为自 1970 年 1 月 1 日以来的毫秒数（时间戳）
    *   a **string**：支持多种不同的格式，例如“YYYY/MM/DD”、“MM/DD/YYYY”、“Jan 31 2009”等。
    *   an **object**：解释为具有年、月和日期属性的对象。 **注意**月份是 0-11。

。

    // Source: http://stackoverflow.com/questions/497790
    var dates = {
        convert:function(d) {
            // Converts the date in d to a date-object. The input can be:
            //   a date object: returned without modification
            //  an array      : Interpreted as [year,month,day]. NOTE: month is 0-11.
            //   a number     : Interpreted as number of milliseconds
            //                  since 1 Jan 1970 (a timestamp) 
            //   a string     : Any format supported by the javascript engine, like
            //                  "YYYY/MM/DD", "MM/DD/YYYY", "Jan 31 2009" etc.
            //  an object     : Interpreted as an object with year, month and date
            //                  attributes.  **NOTE** month is 0-11.
            return (
                d.constructor === Date ? d :
                d.constructor === Array ? new Date(d[0],d[1],d[2]) :
                d.constructor === Number ? new Date(d) :
                d.constructor === String ? new Date(d) :
                typeof d === "object" ? new Date(d.year,d.month,d.date) :
                NaN
            );
        },
        compare:function(a,b) {
            // Compare two dates (could be of any type supported by the convert
            // function above) and returns:
            //  -1 : if a < b
            //   0 : if a = b
            //   1 : if a > b
            // NaN : if a or b is an illegal date
            // NOTE: The code inside isFinite does an assignment (=).
            return (
                isFinite(a=this.convert(a).valueOf()) &&
                isFinite(b=this.convert(b).valueOf()) ?
                (a>b)-(a<b) :
                NaN
            );
        },
        inRange:function(d,start,end) {
            // Checks if date in d is between dates in start and end.
            // Returns a boolean or NaN:
            //    true  : if d is between start and end (inclusive)
            //    false : if d is before start or after end
            //    NaN   : if one or more of the dates is illegal.
            // NOTE: The code inside isFinite does an assignment (=).
           return (
                isFinite(d=this.convert(d).valueOf()) &&
                isFinite(start=this.convert(start).valueOf()) &&
                isFinite(end=this.convert(end).valueOf()) ?
                start <= d && d <= end :
                NaN
            );
        }
    }

关系运算符`<` `<=` `>` `>=`可用于比较 JavaScript 日期：

    var d1 = new Date(2013, 0, 1);
    var d2 = new Date(2013, 0, 2);
    d1 <  d2; // true
    d1 <= d2; // true
    d1 >  d2; // false
    d1 >= d2; // false
    

但是，相等运算符`==` `!=` `===` `!==`不能用于比较日期（的值），[因为](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)：

> *   无论是严格比较还是抽象比较，两个不同的对象永远不会相等。
> *   仅当操作数引用同一对象时，比较对象的表达式才为 true。

您可以使用以下任一方法比较日期值是否相等：

    var d1 = new Date(2013, 0, 1);
    var d2 = new Date(2013, 0, 1);
    /*
     * note: d1 == d2 returns false as described above
     */
    d1.getTime() == d2.getTime(); // true
    d1.valueOf() == d2.valueOf(); // true
    Number(d1)   == Number(d2);   // true
    +d1          == +d2;          // true
    

和[`Date.getTime()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime)均`Date.valueOf()`返回自 1970 年 1 月 1 日 00:00 UTC 以来的毫秒数。`Number`函数和一元运算符都在幕后`+`调用方法。`valueOf()`

到目前为止，最简单的方法是将一个日期与另一个日期相减并比较结果。

    var oDateOne = new Date();
    var oDateTwo = new Date();
    
    console.log(oDateOne - oDateTwo === 0);
    console.log(oDateOne - oDateTwo < 0);
    console.log(oDateOne - oDateTwo > 0);

运行代码片段Hide results

展开片段

How to compare two dates with 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的默认参数特性的引入，代码变得更加清晰和简洁。

Set a default parameter value for a javascript function

在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来存储对象时，需要先将对象转换成字符串再存储，读取时再将字符串转换回对象。这样可以保证对象的结构和数据在存储过程中得以保持。

How to store objects in 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}

How can i merge properties of two javascript objects dynamically

在 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';

How to creating multiline strings in javascript?

在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);

How to pretty print json using javascript

在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
    

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

How to checking if a key exists in a javascript object

在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/)

How do i format a date in javascript

当我们在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)。

How do i correctly clone a javascript object

在 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'`
我是否被迫使用查询生成器来完成这样的基本操作？

How to sort array of objects by string property value

要使用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)

How to get the current url with javascript

在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

展开片段

How do i copy to the clipboard in javascript

在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) 中被引入，不被一些旧的浏览器支持。

How do I check if an array includes a value in JavaScript?

在Web前端开发中，`<a>`元素的`href`属性用于定义超链接的目的地。`href`的值可以是多种类型，比如URL、书签或者是JavaScript伪协议。`"#"和"javascript:void(0)"都是在某些情况下用来创建一个点击不会导致页面跳转的链接的方法。

当你使用`"#"（锚点）`时，它会创建一个指向页面中相同ID的元素的书签链接。如果这个ID不存在，它将会导致页面滚动到顶部。如果只是单纯的`"#"，没有跟随具体的ID，那么点击链接通常会导致页面滚动到顶部，并且URL会更新（添加一个`#`在URL末尾）。

当你使用`"javascript:void(0)"`时，它会执行一个空的JavaScript语句，该语句不会有任何效果，并且页面不会有任何滚动或者URL的变化。这种方法通常用于那些想要附加JavaScript事件监听器以执行某些动作但不希望更改URL或者页面位置的场景。

### 使用场景对比：

- **使用"#"**：
    - 当你想创建一个真正的书签/锚点，例如页面内导航。
    - 如果你不介意URL变化（URL末尾会添加一个`#`）。
    - 如果你想通过CSS选择器或者JavaScript感知到URL的改变。

- **使用"javascript:void(0)"**：
    - 如果你不想要URL发生变化。
    - 当你想防止页面滚动到顶部。
    - 当你使用JavaScript来处理点击事件，并且不需要锚点导航的功能。

### 例子：

1. **使用"#"进行页面内导航**：

```html

<h2 id="section1">Section 1</h2>
...


<a href="#section1">Go to Section 1</a>
```

2. **使用"javascript:void(0)"附加事件监听器**：

```html
<a href="javascript:void(0)" onclick="doSomething();">Click me</a>

<script>
function doSomething() {
    // 执行一些动作，但不改变URL，也不会滚动页面
    alert('Action performed!');
}
</script>
```

### 最佳实践：

在现代Web开发中，推荐使用更加语义化的方法，避免使用`"javascript:void(0)"`，因为它将逻辑（JavaScript代码）与标记（HTML）混合在了一起。更好的做法是使用事件监听器来处理用户的点击事件：

```html
<a href="#" id="clickableElement">Click me</a>

<script>
document.getElementById('clickableElement').addEventListener('click', function(event) {
    event.preventDefault(); // 阻止默认行为，即不跳转
    doSomething();
});
</script>
```

这样的方式保持了HTML的清洁和JavaScript的可维护性，同时`event.preventDefault()`确保了即使使用了`"#"`，页面也不会滚动到顶部。这在提升用户体验和网站可维护性方面都是比较好的实践。

我用`javascript:void(0)`。

三个原因。鼓励`#`开发团队中使用不可避免地会导致一些人使用这样调用的函数的返回值：

    function doSomething() {
        //Some code
        return false;
    }
    

`return doSomething()`但后来他们忘记在 onclick 中使用而只是使用`doSomething()`.

避免的第二个原因是，如果被调用的函数抛出错误，`#`final将不会执行。`return false;`因此，开发人员还必须记住在被调用函数中适当处理任何错误。

第三个原因是存在`onclick`动态分配事件属性的情况。我更喜欢能够动态调用函数或分配它，而不必专门为一种或另一种附件方法编写函数代码。因此我的`onclick`（或任何东西）HTML 标记看起来像这样：

    onclick="someFunc.call(this)"
    

或者

    onclick="someFunc.apply(this, arguments)"
    

使用`javascript:void(0)`可以避免上述所有令人头痛的问题，而且我还没有发现任何缺点的例子。

因此，如果您是一个单独的开发人员，那么您显然可以做出自己的选择，但如果您作为一个团队工作，则必须声明：

使用`href="#"`，确保`onclick`始终包含`return false;`在末尾，任何被调用的函数都不会抛出错误，并且如果将函数动态附加到属性，`onclick`请确保它返回并且不抛出错误`false`。

或者

使用`href="javascript:void(0)"`

第二个显然更容易沟通。

两者都不。

如果您有一个有意义的实际 URL，请将其用作 HREF。如果有人在您的链接上单击鼠标中键以打开新选项卡或者禁用了 JavaScript，则 onclick 不会触发。

如果这是不可能的，那么您至少应该使用 JavaScript 和适当的单击事件处理程序将锚标记注入到文档中。

我意识到这并不总是可能的，但在我看来，在开发任何公共网站时都应该努力做到这一点。

查看_[Unobtrusive JavaScript](http://en.wikipedia.org/wiki/Unobtrusive_JavaScript)_和_[渐进式增强](http://en.wikipedia.org/wiki/Progressive_enhancement)_（均来自维基百科）。

做`<a href="#" onclick="myJsFunc();">Link</a>`或`<a href="javascript:void(0)" onclick="myJsFunc();">Link</a>`做任何其他包含某个`onclick`属性的事情 - 五年前还可以，但现在可能是一种不好的做法。原因如下：

1.  它促进了强制性 JavaScript 的实践——事实证明，这种做法难以维护且难以扩展。有关此内容的更多信息，请参阅_[Unobtrusive JavaScript](http://en.wikipedia.org/wiki/Unobtrusive_JavaScript)_。
    
2.  您花费时间编写极其冗长的代码 - 这对您的代码库几乎没有（如果有的话）好处。
    
3.  现在有更好、更简单、更可维护和可扩展的方法来实现所需的结果。
    

不引人注目的 JavaScript 方式
--------------------

就是根本没有`href`属性！任何好的 CSS 重置都会解决缺少的默认光标样式，因此这不是问题。然后使用优雅且不引人注目的最佳实践附加您的 JavaScript 功能 - 由于您的 JavaScript 逻辑保留在 JavaScript 中而不是标记中，因此更易于维护 - 当您开始开发需要将逻辑拆分为的大规模 JavaScript 应用程序时，这一点至关重要黑盒组件和模板。有关此内容的更多信息，请参阅_[大规模 JavaScript 应用程序架构](http://speakerdeck.com/u/addyosmani/p/large-scale-javascript-application-architecture)_

简单的代码示例
-------

    // Cancel click event
    $('.cancel-action').click(function(){
        alert('Cancel action occurs!');
    });
    
    // Hover shim for Internet Explorer 6 and Internet Explorer 7.
    $(document.body).on('hover','a',function(){
        $(this).toggleClass('hover');
    });

    a { cursor: pointer; color: blue; }
    a:hover,a.hover { text-decoration: underline; }

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
    <a class="cancel-action">Cancel this action</a>

运行代码片段Hide results

展开片段

黑盒_[Backbone.js](http://documentcloud.github.com/backbone/)_示例
--------------------------------------------------------------

有关可扩展、黑盒化的 Backbone.js 组件示例 -_[请参阅此处的工作 jsfiddle 示例](http://jsfiddle.net/balupton/sTzdD/)_。请注意我们如何利用不显眼的 JavaScript 实践，并在少量代码中拥有一个可以在页面上重复多次的组件，而不会产生副作用或不同组件实例之间发生冲突。惊人的！

笔记
--

*   省略元素`href`上的属性`a`将导致无法使用`tab`按键导航访问该元素。如果您希望通过键访问这些元素`tab`，您可以设置`tabindex`属性，或改用`button`元素。您可以轻松地设置按钮元素的样式，使其看起来像_[Tracker1 的回答](https://stackoverflow.com/a/8525002/130638)_中提到的普通链接。
    
*   省略元素`href`上的属性`a`将导致[Internet Explorer 6](http://en.wikipedia.org/wiki/Internet_Explorer_6)和[Internet Explorer 7](http://en.wikipedia.org/wiki/Internet_Explorer_7)不采用样式`a:hover`，这就是为什么我们添加了一个简单的 JavaScript shim 来完成此操作`a.hover`。这是完全可以的，就好像您没有 href 属性并且没有优雅的降级一样，那么您的链接将无法正常工作 - 并且您将有更大的问题需要担心。
    
*   如果您希望您的操作在禁用 JavaScript 的情况下仍然有效，那么可以使用一个`a`带有属性的元素`href`，该属性会转到某个 URL，该 URL 将手动执行该操作，而不是通过 Ajax 请求或其他任何方式。如果您这样做，那么您需要确保执行`event.preventDefault()`单击调用，以确保单击按钮时它不会跟随链接。此选项称为优雅降级。

`'#'`会将用户带回到页面顶部，所以我通常选择`void(0)`.

`javascript:;`也表现得像`javascript:void(0);`

老实说，我两者都不建议。我会使用一种程式化的方式`<button></button>`来表现这种行为。

    button.link {
      display: inline-block;
      position: relative;
      background-color: transparent;
      cursor: pointer;
      border: 0;
      padding: 0;
      color: #00f;
      text-decoration: underline;
      font: inherit;
    }

    <p>A button that looks like a <button type="button" class="link">link</button>.</p>

运行代码片段Hide results

展开片段

这样你就可以分配你的 onclick。我还建议通过脚本进行绑定，而不是使用`onclick`元素标签上的属性。唯一的问题是旧版 IE 中的伪 3D 文本效果无法禁用。

* * *

如果您_必须_使用 A 元素，请`javascript:void(0);`出于已经提到的原因使用。

*   如果您的 onclick 事件失败，将始终拦截。
*   不会发生错误的加载调用，或基于哈希更改触发其他事件
*   如果点击失败（onclick 抛出），井号标签可能会导致意外行为，请避免这种情况，除非它是适当的失败行为，并且您想要更改导航历史记录。

注意：您可以将 替换`0`为字符串，例如`javascript:void('Delete record 123')`，它可以作为额外的指示符，显示单击实际执行的操作。

所有问题