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

JavaScript 的主要特点包括：

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

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

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

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

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

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

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

JavaScript

在网页中调用JavaScript函数，主要有几种常用方法可以在页面加载时执行。以下是一些常见的实现方式：

### 1. 使用`<body>`标签的`onload`属性

可以在HTML的`<body>`标签中使用`onload`属性来调用函数。当整个页面加载完成后，包括所有的框架、图像和外部文件，指定的JavaScript函数将会被执行。

**示例代码：**
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body onload="initFunction()">
    <h1>页面加载完成！</h1>
    <script>
        function initFunction() {
            alert("页面已完全加载！");
        }
    </script>
</body>
</html>
```

### 2. 使用JavaScript的`window.onload`

通过在JavaScript中使用`window.onload`事件也可以实现在页面加载完成后执行函数。这种方式的优势在于不需要修改HTML结构，直接在JavaScript中处理。

**示例代码：**
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
    <h1>页面加载完成！</h1>
    <script>
        window.onload = function() {
            alert("页面已完全加载！");
        };
    </script>
</body>
</html>
```

### 3. 使用DOM的`DOMContentLoaded`事件

如果你只需要在DOM结构解析完成后就执行函数，而不需要等待像图片、样式表等外部资源的加载，可以使用`DOMContentLoaded`事件。

**示例代码：**
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
    <h1>DOM已加载完成！</h1>
    <script>
        document.addEventListener("DOMContentLoaded", function() {
            alert("DOM 已完全加载和解析，但外部资源可能还没有加载完。");
        });
    </script>
</body>
</html>
```

### 4. 使用现代框架的生命周期方法

如果你使用的是现代JavaScript框架（如React, Vue, Angular等），它们通常提供了生命周期方法或钩子来处理类似的需求。

**React 示例：**
```jsx
import React, { useEffect } from 'react';

function App() {
    useEffect(() => {
        console.log('组件已挂载，并且DOM已完成渲染。');
    }, []);

    return <h1>React 应用加载完成！</h1>;
}

export default App;
```

这些方法可以根据具体的使用场景和需求选择。例如，如果页面依赖于外部资源完全加载，那么使用`onload`更合适；如果只需要DOM结构加载完成，`DOMContentLoaded`更为高效。

How do I call a JavaScript function on page load?

在JavaScript中合并两个对象的属性有几种方法，主要取决于具体的需求和所使用的JavaScript版本。这里我将介绍两种常见的方法：使用`Object.assign()`方法和使用展开运算符（spread operator）。

### 方法1：使用 `Object.assign()`

`Object.assign()` 方法可以将所有可枚举的自有属性从一个或多个源对象复制到目标对象，并且返回修改后的目标对象。这个方法是在ES6中引入的，适用于大部分现代浏览器。

**例子：**
```javascript
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };

const mergedObj = Object.assign({}, obj1, obj2);

console.log(mergedObj); // 输出：{ a: 1, b: 3, c: 4 }
```
在这个例子中，`obj1` 和 `obj2` 被合并到一个新的空对象中。如果两个对象有相同的属性（例如属性 `b`），则后面的对象（`obj2`）中的值会覆盖前面的对象（`obj1`）中的值。

### 方法2：使用展开运算符（Spread Operator）

展开运算符（...）允许一个表达式在某处展开（即展开数组或对象的属性）。在ES6中同样引入，这种方法在编写代码时更为直观和简洁。

**例子：**
```javascript
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };

const mergedObj = { ...obj1, ...obj2 };

console.log(mergedObj); // 输出：{ a: 1, b: 3, c: 4 }
```
这里使用展开运算符将 `obj1` 和 `obj2` 的属性展开并包含在一个新的对象字面量里。同样，`obj2` 中的属性 `b` 的值覆盖了 `obj1` 中的值。

### 总结

这两种方法都是合并对象时常用的技术。选择哪一种取决于个人偏好以及代码上下文的需要。`Object.assign()` 方法是一个标准函数，可提供更多控制，如可用于克隆对象或合并多个对象。展开运算符则提供了一种更简洁的方法来实现相同的结果，尤其在只需要合并两个对象时非常方便。在实际开发中，可以根据具体情况选择使用哪种方法。

How can I merge properties of two JavaScript objects?

要在jQuery中检查是否存在具有特定ID的`div`元素，您可以使用`$('#elementId')`选择器，这里的`elementId`是您想要查找的`div`的ID。如果该元素存在，`$(selector).length`将返回一个大于0的值。下面是一个具体示例：

```javascript
// 假设我们要查找ID为'myDiv'的div元素
$(document).ready(function() {
    if ($('#myDiv').length > 0) {
        console.log('存在ID为"myDiv"的div元素。');
    } else {
        console.log('不存在ID为"myDiv"的div元素。');
    }
});
```

在这个例子中，当文档加载完成后，我们使用`$(document).ready()`来确保DOM完全加载。然后我们通过`$('#myDiv')`选择器找到ID为`myDiv`的`div`元素，通过`.length`属性检测元素的数量。如果该属性大于0，表示页面上存在这个元素，我们就在控制台输出存在的信息，否则输出不存在的信息。

这种方法简单且高效，可以应用在需要动态检查页面元素存在与否的场景中。

How to find if div with specific id exists in jQuery?

在jQuery中，如果您想获取`this`选择器的子项，可以使用`.children()`方法。这个方法允许您选择当前元素的所有直接子元素。这里有一个具体的例子来说明如何使用这个方法：

假设您的HTML结构如下：

```html
<div id="parent">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div>
    <p>Paragraph</p>
</div>
```

您可以使用以下jQuery代码来获取id为`parent`的元素的直接子元素，并进行遍历：

```javascript
$('#parent').click(function() {
    $(this).children().each(function() {
        console.log($(this).text()); // 打印每一个子元素的文本
    });
});
```

在这个例子中，当id为`parent`的元素被点击时，它的所有直接子元素（两个`div`和一个`p`标签）的文本内容将被输出到控制台。

此外，如果您只想选择特定类型的子元素，比如只选择`div`标签的子元素，可以在`.children()`方法中指定选择器：

```javascript
$('#parent').click(function() {
    $(this).children('div').each(function() {
        console.log($(this).text()); // 只打印div子元素的文本
    });
});
```

这样，当id为`parent`的元素被点击时，只有两个`div`元素的文本内容会被输出，`p`标签的文本内容则不会被处理。

这是使用jQuery处理DOM元素子项的基本方法，灵活运用可以处理各种与DOM相关的动态交互需求。

How to get the children of the $( this ) selector?

在JavaScript中，要删除字符串中的所有换行符，常用的方法是使用`replace()`函数结合正则表达式。换行符可能包括`\r`（回车符，Carriage Return，CR）和`\n`（换行符，Line Feed，LF），不同的操作系统可能使用不同的换行符，例如Windows通常使用`\r\n`来表示一个新行，而UNIX/Linux使用`\n`，Mac OS旧版本使用`\r`。为了确保能处理所有环境下的换行符，可以使用一个包含`\r`和`\n`的正则表达式。

以下是如何实现的示例代码：

```javascript
function removeNewLines(str) {
    // 使用正则表达式匹配所有的换行符
    return str.replace(/[\r\n]+/gm, "");
}

// 示例字符串
var exampleString = "这是第一行\r\n这是第二行\n这是第三行\r这是第四行";

// 执行函数
var cleanedString = removeNewLines(exampleString);

console.log(cleanedString);
```

在这个例子中，`removeNewLines`函数接收一个字符串，然后使用`replace()`方法和正则表达式`/[\r\n]+/gm`来查找所有的换行符（`\r`或`\n`）。这个正则表达式中：
- `[\r\n]` 是一个字符集，匹配所有`\r`和`\n`字符。
- `+` 表示匹配一个或多个前面的表达式，这样可以连续的换行符一起被替换掉。
- `g` 标志代表全局搜索，即查找整个字符串中的所有匹配项。
- `m` 标志代表多行搜索，这在处理多行字符串时是有用的。

输出结果将是将所有行合并成一行的字符串："这是第一行这是第二行这是第三行这是第四行"。通过这种方法可以确保字符串中不包含任何换行符，适用于需要将输出保持在单行的场景，如日志记录、数据传输等。

How to remove all line breaks from a string

在JavaScript中，获取一个对象中所有键（key）组成的数组可以使用 `Object.keys()` 方法。这个方法会返回一个包含给定对象自身可枚举属性名称的数组，不考虑原型链中的属性。

### 示例：

假设我们有一个对象如下：

```javascript
const person = {
    name: '张三',
    age: 30,
    job: '软件工程师'
};
```

如果我们想获取这个对象所有的键，我们可以这样做：

```javascript
const keys = Object.keys(person);
console.log(keys); // 输出: ["name", "age", "job"]
```

在这个例子中，`Object.keys(person)` 返回了一个数组 `["name", "age", "job"]`，这个数组包含了对象 `person` 的所有键。

### 使用场景：

这种方法非常实用在需要遍历对象的键时，比如我们需要检查一个对象是否包含某个特定的键，或者我们需要根据键来组织数据等场合。例如，如果我们要验证对象是否含有特定的属性，可以结合使用 `Object.keys()` 和 `includes()` 方法：

```javascript
if (Object.keys(person).includes('age')) {
    console.log('年龄是：' + person.age);
} else {
    console.log('没有提供年龄信息');
}
```

这段代码检查对象 `person` 是否包含 `'age'` 键，如果包含则输出年龄，否则提示没有提供年龄信息。

### 注意事项：

- `Object.keys()` 只包括对象自身的可枚举属性，不包括继承的属性。
- 如果对象的属性名不是字符串，比如是 Symbol 类型的键，这些键不会被 `Object.keys()` 返回。在这种情况下，可以使用 `Object.getOwnPropertyNames()` 或 `Reflect.ownKeys()` 来获取所有键，包括非字符串键和不可枚举的键。


Get array of object's keys

要在JavaScript中获取数组的最后一项，我们可以使用数组的`length`属性来定位最后一个元素。这里有一个简单的例子：

假设我们有一个数组`arr`:

```javascript
let arr = [10, 20, 30, 40, 50];
```

要获取这个数组的最后一项，我们可以使用以下代码:

```javascript
let lastItem = arr[arr.length - 1];
console.log(lastItem); // 输出: 50
```

在这个例子中，`arr.length`返回数组的长度，即5。因为数组的索引是从0开始的，所以最后一个元素的索引是`arr.length - 1`，也就是4。通过这种方式，我们可以有效地获取数组的最后一项。

此外，如果我们希望这个操作更加动态和通用，我们可以将其封装成一个函数：

```javascript
function getLastItem(array) {
    if (array.length === 0) {
        return undefined; // 如果数组是空的，返回undefined
    }
    return array[array.length - 1];
}

console.log(getLastItem(arr)); // 输出: 50
console.log(getLastItem([])); // 输出: undefined
```

这个函数首先检查数组是否为空，如果为空则返回`undefined`，否则返回数组的最后一项。这可以让我们的代码更健壮，更能适应不同的输入情况。

Get the last item in an array

在Web开发中，防止事件冒泡是一个常见的需求。事件冒泡指的是当一个事件在DOM树中的一个元素上触发时，这个事件会向上层元素传播。在您的问题中，您提到了如何防止在点击子锚点时触发父级的onclick事件。这可以通过多种方式实现，以下是一些方法：

### 方法1: 使用JavaScript中的 `event.stopPropagation()`

`event.stopPropagation()` 方法可以阻止事件进一步传播到父元素。您可以在子元素的事件处理函数中调用这个方法来防止父元素的事件被触发。

#### 示例代码：

```html
<div onclick="alert('父元素被点击!')">
    <a href="#" onclick="handleClick(event)">点击我</a>
</div>

<script>
function handleClick(event) {
    event.stopPropagation();
    alert('子元素被点击!');
}
</script>
```

在这个例子中，当点击锚点时，只会触发 `handleClick` 函数，并显示"子元素被点击!"的警告框。由于调用了 `event.stopPropagation()`，所以不会触发父元素的onclick事件，即不会显示"父元素被点击!"的警告框。

### 方法2: 检查事件的 `target` 属性

在父元素的事件处理器中，您可以检查事件的 `target` 属性，以确定事件是否是在子元素上触发的。如果是，您可以选择不执行任何操作。

#### 示例代码：

```html
<div onclick="handleParentClick(event)">
    <a href="#" onclick="handleClick(event)">点击我</a>
</div>

<script>
function handleParentClick(event) {
    if (event.target.tagName === 'A') {
        // 如果事件是在锚点上触发的，不做任何处理
        return;
    }
    alert('父元素被点击!');
}

function handleClick(event) {
    alert('子元素被点击!');
}
</script>
```

在这个例子中，`handleParentClick` 函数会检查事件目标。如果事件是在锚点上触发的（即`event.target.tagName === 'A'`），函数会直接返回，不会显示"父元素被点击!"的警告框。当然，子元素的事件处理器仍然会正常执行。

以上两种方法都是有效的解决方案，具体使用哪一种取决于您的具体需求和上下文。在实际开发中，`event.stopPropagation()` 更为直接和常用。

How do I prevent a parent's onclick event from firing when a child anchor is clicked?

在JavaScript中，将UTC日期时间转换为本地日期时间可以通过多种方式实现。以下是一些常用的方法：

### 1. 使用`Date`对象

JavaScript的`Date`对象在被创建时就自动考虑了本地时间。当你从一个UTC时间字符串（如ISO 8601格式）创建一个`Date`对象时，它将基于运行代码的系统的时区自动转化为本地时间。

```javascript
// 假设我们有一个UTC时间
var utcDateString = "2022-06-01T12:00:00Z";

// 创建一个Date对象
var date = new Date(utcDateString);

// 输出本地时间
console.log(date.toString()); // 输出的时间会是本地时间
```

### 2. 使用`toLocaleString()`方法

`Date`对象提供了`toLocaleString()`方法，该方法可以根据本地的语言和时区设置来格式化日期时间。

```javascript
var utcDateString = "2022-06-01T12:00:00Z";
var date = new Date(utcDateString);

// 输出本地化的日期时间字符串
console.log(date.toLocaleString());
```

### 3. 使用第三方库

有时，为了更简便或支持更复杂的日期时间处理，使用第三方库可能是一个好选择。例如，`moment.js`是一个广泛使用的日期时间处理库。

```javascript
// 使用Moment.js（需先安装moment库）
var moment = require('moment');

// 创建一个UTC日期时间
var utcDate = moment.utc("2022-06-01T12:00:00");

// 转换为本地时间
var localDate = utcDate.local();

console.log(localDate.format()); // 输出本地时间的字符串表示
```

### 示例应用场景

假设你正在开发一个国际化的日程管理应用，用户遍布全球。存储在数据库中的所有日程时间都是UTC格式。当用户查看日程时，你需要将这些时间转换为用户各自的本地时间。使用上述方法之一，你可以轻松实现这一功能，确保用户看到的是正确的本地时间，而不是UTC时间。

通过这些方法，JavaScript可以方便地处理UTC到本地时间的转换，满足大多数日常开发需求。

Convert UTC date time to local date time

在JavaScript中，四舍五入一个数字可以使用 `Math.round()` 函数。这个函数会接受一个数字作为参数，并返回最接近的整数。如果参数是正数，它就会四舍五入；如果参数是负数，它会进行五舍六入。

### 示例：

假设我们有以下几个数字，我们需要对它们进行四舍五入：

```javascript
let num1 = 3.14;
let num2 = -4.6;
let num3 = 2.5;
```

我们可以使用 `Math.round()` 来四舍五入这些数字：

```javascript
let roundedNum1 = Math.round(num1);  // 结果为 3
let roundedNum2 = Math.round(num2);  // 结果为 -5
let roundedNum3 = Math.round(num2);  // 结果为 3
```

在这个例子中，`num1` 四舍五入结果是 3，因为3.14更接近3。`num2` 的四舍五入结果是 -5，虽然-4.6距离-4和-5的距离都是0.6，但是根据五舍六入的规则，向下取整为-5。`num3` 的结果是3，因为2.5正好在2和3的中间，根据四舍五入的规则，它会被舍入到较大的整数即3。

### 更多信息：

如果需要四舍五入到小数点后特定的位数，可以使用 `toFixed()` 方法，该方法允许指定小数位数，但返回的是字符串格式的数字。如果需要返回数字格式，则可以再用 `parseFloat()` 或者 `Number()` 将字符串转换为数字。

例如，四舍五入到小数点后两位：

```javascript
let num4 = 3.14159;
let roundedNum4 = parseFloat(num4.toFixed(2)); // 结果为 3.14
```

这里 `toFixed(2)` 将数字四舍五入到小数点后两位，并返回字符串 "3.14"，之后使用 `parseFloat()` 将字符串转换回数字形式。

以上方法都是处理四舍五入的基本方式，在实际的开发中可以根据具体需求选择使用。

How can I round down a number in Javascript?

在 Web 开发中，DOM（文档对象模型）是 HTML 和 XML 文档的编程接口，它定义了访问和操作文档的方法和接口。在 DOM 中，`parentNode` 和 `parentElement` 都是用来访问一个节点的父节点的属性，但它们之间存在一些细微的差别：

1. **定义上的差异**：
   - `parentNode` 是一个更广泛的概念，它可以是任何类型的节点的父节点，包括元素节点、文本节点、注释节点等。
   - `parentElement` 专门用于指向元素节点的父节点。如果父节点不是元素节点（比如是文本节点或注释节点），则 `parentElement` 的值为 `null`。

2. **使用场景**：
   - 当你确定需要获取的父节点是元素节点时，使用 `parentElement` 更为合适。
   - 如果你的操作涉及到可能不是元素的其他类型的节点，或者你需要编写更通用的处理逻辑，使用 `parentNode` 更安全。

### 示例解释：

假设我们有如下的 HTML 结构：

```html
<div id="parent">
  Hello, <span id="child">World!</span>
</div>
```

在这个例子中，`span` 元素是 `div` 元素的子元素。如果我们使用 JavaScript 来获取 `span` 的父节点：

```javascript
var childElement = document.getElementById('child');

// 使用 parentNode
console.log(childElement.parentNode);  // 输出: <div id="parent">...</div>

// 使用 parentElement
console.log(childElement.parentElement);  // 输出: <div id="parent">...</div>
```

在这种情况下，`parentNode` 和 `parentElement` 都会返回 `div` 元素，因为 `div` 是 `span` 的直接父元素，并且它是一个元素节点。

但如果考虑一个文本节点的情况：

```javascript
var textNode = childElement.firstChild;

// 使用 parentNode
console.log(textNode.parentNode);  // 输出: <span id="child">...</span>

// 使用 parentElement
console.log(textNode.parentElement);  // 输出: null
```

在这个例子中，文本节点 "World!" 的 `parentNode` 是包含它的 `span` 元素，但它的 `parentElement` 是 `null`，因为文本节点没有元素类型的父节点。

总的来说，理解这两个属性的差异有助于更准确地访问和操作 DOM，这对于前端开发是非常重要的技能。

Difference between DOM parentNode and parentElement

当浏览器窗口或选项卡关闭时，若需要删除localStorage中的项目，可以通过监听浏览器的 `unload` 或 `beforeunload` 事件来实现。这两个事件会在浏览器窗口或选项卡即将关闭时被触发。

以下是一个JavaScript示例代码，展示了如何在窗口关闭时删除localStorage中名为 `userSession` 的项目：

```javascript
window.addEventListener('beforeunload', function(event) {
    // 删除localStorage中的'userSession'项
    localStorage.removeItem('userSession');
    // 如果需要可以在这里进行其他清理工作
});
```

### 示例说明：
在这个例子中，我们向 `window` 对象添加了一个事件监听器，该监听器监听 `beforeunload` 事件。当用户尝试关闭浏览器窗口或选项卡时，这个事件会被触发，然后执行回调函数中的代码。在这个回调函数中，我们使用 `localStorage.removeItem('userSession')` 删除名为 `userSession` 的localStorage项。

### 使用场景示例：
假设您正在开发一个需要用户登录的网站，并且使用localStorage来存储用户的会话信息。为了提高安全性，您希望当用户关闭浏览器窗口时自动清除这些会话信息。通过上述方法，您可以确保每次用户关闭窗口时，其会话信息都会被安全地从localStorage中删除。

这种方法特别适用于管理需要在会话结束时清除的敏感信息，从而帮助增强应用程序的安全性。

浏览器的 `localStorage` 是一种持久的存储方式，通常不会因为浏览器窗口或选项卡关闭而自动删除。如果需要在窗口或选项卡关闭时删除特定的 `localStorage` 项目，可以通过监听 `beforeunload` 或 `unload` 事件来实现。

这里有一个具体的例子：

```javascript
window.addEventListener('beforeunload', function(event) {
    // 在窗口关闭前执行的代码
    localStorage.removeItem('yourLocalStorageKey');  // 替换 'yourLocalStorageKey' 为你想要删除的项的键名
});
```

在这段代码中，当用户准备关闭浏览器窗口或选项卡时，`beforeunload` 事件会被触发，然后执行回调函数中的代码，从 `localStorage` 中删除指定的项。 

值得注意的是，使用 `beforeunload` 事件可以提示用户是否真的要离开页面（例如，在用户填写表单但未提交时给予警告）。如果你只是简单地需要在关闭时清除数据，而不需要任何提示，也可以使用 `unload` 事件，这样就不会干扰用户的关闭流程。

```javascript
window.addEventListener('unload', function(event) {
    localStorage.removeItem('yourLocalStorageKey');
});
```

这两种方法都可以有效地在浏览器窗口或选项卡关闭时处理 `localStorage` 的清理工作。根据具体需求选择合适的事件监听类型。

How to delete a localStorage item when the browser window/tab is closed?

在JavaScript中，获取URL的查询字符串（query string）值是一个常见的需求，尤其是在Web开发中。以下是几种流行和实用的方法来获取查询字符串值：

### 1. 使用原生 JavaScript - `URLSearchParams`

`URLSearchParams` 是一个内建的浏览器API，它提供了一种简便的方式来获取URL的查询参数。假设URL是这样的：`https://example.com/?product=shirt&color=blue`。

```javascript
// 假设 URL 是 https://example.com/?product=shirt&color=blue
const queryString = window.location.search;

// 使用 URLSearchParams
const params = new URLSearchParams(queryString);

const product = params.get('product'); // 返回 'shirt'
const color = params.get('color'); // 返回 'blue'
```

这种方法简单直接，且由现代浏览器原生支持。

### 2. 使用JavaScript手动解析

如果不想使用`URLSearchParams`或需要更多控制解析过程，也可以手动解析查询字符串：

```javascript
function getQueryStringValue(key) {
    const queryString = window.location.search.substring(1); // 获取查询字符串，去掉'?'
    const queries = queryString.split("&"); // 分割成数组

    for (let i = 0; i < queries.length; i++) {
        const pair = queries[i].split('='); // 分割键和值
        if (decodeURIComponent(pair[0]) === key) {
            return decodeURIComponent(pair[1] || ""); // 如果找到对应的键，则返回解码后的值
        }
    }
    return null; // 如果没有找到键，返回null
}

// 示例
const product = getQueryStringValue('product'); // 返回 'shirt'
const color = getQueryStringValue('color'); // 返回 'blue'
```

### 3. 使用第三方库

对于一些复杂的URL解析需求，或者为了代码的简洁性，可以使用第三方库如`query-string`。

```javascript
// 首先需要安装 query-string 库
// npm install query-string

import queryString from 'query-string';

const parsed = queryString.parse(window.location.search);
const product = parsed.product; // 返回 'shirt'
const color = parsed.color; // 返回 'blue'
```

这种方法适用于复杂的查询字符串解析，或者当项目已经引入了这种库的情况。

### 结论

根据项目需求和浏览器兼容性选择合适的方法。`URLSearchParams` 提供了一个简单且现代的API来处理查询字符串，而手动解析给予了更多的控制权。第三方库则是在处理更复杂的情况或求简洁代码时的优选。

Use [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams#Browser_compatibility) to get parameters from the query string.

For example:

    const urlParams = new URLSearchParams(window.location.search);
    const myParam = urlParams.get('myParam');
    

**Update: Jan-2022**

Using [`Proxy()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) is [faster](https://jsben.ch/MeP5G) than using [`Object.fromEntries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries) and better supported.

This approach comes with the caveat that you can no longer iterate over query parameters.

    const params = new Proxy(new URLSearchParams(window.location.search), {
      get: (searchParams, prop) => searchParams.get(prop),
    });
    // Get the value of "some_key" in eg "https://example.com/?some_key=some_value"
    let value = params.some_key; // "some_value"
    

**Update: June-2021**

For a specific case when you need all query params:

    const urlSearchParams = new URLSearchParams(window.location.search);
    const params = Object.fromEntries(urlSearchParams.entries());
    

**Update: Sep-2018**

You can use [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams#Browser_compatibility) which is simple and has [decent (but not complete) browser support](https://caniuse.com/urlsearchparams).

    const urlParams = new URLSearchParams(window.location.search);
    const myParam = urlParams.get('myParam');
    

**Original**

You don't need jQuery for that purpose. You can use just some pure JavaScript:

    function getParameterByName(name, url = window.location.href) {
        name = name.replace(/[\[\]]/g, '\\$&');
        var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
            results = regex.exec(url);
        if (!results) return null;
        if (!results[2]) return '';
        return decodeURIComponent(results[2].replace(/\+/g, ' '));
    }
    

**Usage:**

    // query string: ?foo=lorem&bar=&baz
    var foo = getParameterByName('foo'); // "lorem"
    var bar = getParameterByName('bar'); // "" (present with empty value)
    var baz = getParameterByName('baz'); // "" (present with no value)
    var qux = getParameterByName('qux'); // null (absent)
    

NOTE: If a parameter is present several times (`?foo=lorem&foo=ipsum`), you will get the first value (`lorem`). There is no standard about this and usages vary, see for example this question: [Authoritative position of duplicate HTTP GET query keys](https://stackoverflow.com/questions/1746507/authoritative-position-of-duplicate-http-get-query-keys).

NOTE: The function is case-sensitive. If you prefer case-insensitive parameter name, [add 'i' modifier to RegExp](https://stackoverflow.com/questions/3939715/case-insensitive-regex-in-javascript)

NOTE: If you're getting a no-useless-escape eslint error, you can replace `name = name.replace(/[\[\]]/g, '\\$&');` with `name = name.replace(/[[\]]/g, '\\$&')`.

* * *

This is an update based on the new [URLSearchParams specs](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) to achieve the same result more succinctly. See answer titled "[URLSearchParams](https://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript/901144#12151322)" below.

Some of the solutions posted here are inefficient. Repeating the regular expression search every time the script needs to access a parameter is completely unnecessary, one single function to split up the parameters into an associative-array style object is enough. If you're not working with the HTML 5 History API, this is only necessary once per page load. The other suggestions here also fail to decode the URL correctly.

    var urlParams;
    (window.onpopstate = function () {
        var match,
            pl     = /\+/g,  // Regex for replacing addition symbol with a space
            search = /([^&=]+)=?([^&]*)/g,
            decode = function (s) { return decodeURIComponent(s.replace(pl, " ")); },
            query  = window.location.search.substring(1);
      
        urlParams = {};
        while (match = search.exec(query))
           urlParams[decode(match[1])] = decode(match[2]);
    })();

Example querystring:

> `?i=main&mode=front&sid=de8d49b78a85a322c4155015fdce22c4&enc=+Hello%20&empty`

Result:

     urlParams = {
        enc: " Hello ",
        i: "main",
        mode: "front",
        sid: "de8d49b78a85a322c4155015fdce22c4",
        empty: ""
    }
    
    alert(urlParams["mode"]);
    // -> "front"
    
    alert("empty" in urlParams);
    // -> true
    

This could easily be improved upon to handle array-style query strings too. An example of this is [here](http://jsbin.com/adali3/2), but since array-style parameters aren't defined in [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986) I won't pollute this answer with the source code. [For those interested in a "polluted" version, look at campbeln's answer below](https://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript/23401756#23401756).

Also, as pointed out in the comments, `;` is a legal delimiter for `key=value` pairs. It would require a more complicated regex to handle `;` or `&`, which I think is unnecessary because it's rare that `;` is used and I would say even more unlikely that both would be used. If you need to support `;` instead of `&`, just swap them in the regex.

* * *

If you're using a server-side preprocessing language, you might want to use its native JSON functions to do the heavy lifting for you. For example, in PHP you can write:

    <script>var urlParams = <?php echo json_encode($_GET, JSON_HEX_TAG);?>;</script>

Much simpler!

#UPDATED

> A new capability would be to retrieve repeated params as following `myparam=1&myparam=2`. There is not a _specification_, however, most of the current approaches follow the generation of an array.

    myparam = ["1", "2"]
    

So, this is the approach to manage it:

    let urlParams = {};
    (window.onpopstate = function () {
        let match,
            pl = /\+/g,  // Regex for replacing addition symbol with a space
            search = /([^&=]+)=?([^&]*)/g,
            decode = function (s) {
                return decodeURIComponent(s.replace(pl, " "));
            },
            query = window.location.search.substring(1);
    
        while (match = search.exec(query)) {
            if (decode(match[1]) in urlParams) {
                if (!Array.isArray(urlParams[decode(match[1])])) {
                    urlParams[decode(match[1])] = [urlParams[decode(match[1])]];
                }
                urlParams[decode(match[1])].push(decode(match[2]));
            } else {
                urlParams[decode(match[1])] = decode(match[2]);
            }
        }
    })();

ES2015 (ES6)
============

    getQueryStringParams = query => {
        return query
            ? (/^[?#]/.test(query) ? query.slice(1) : query)
                .split('&')
                .reduce((params, param) => {
                        let [key, value] = param.split('=');
                        params[key] = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';
                        return params;
                    }, {}
                )
            : {}
    };
    

* * *

Without jQuery
--------------

    var qs = (function(a) {
        if (a == "") return {};
        var b = {};
        for (var i = 0; i < a.length; ++i)
        {
            var p=a[i].split('=', 2);
            if (p.length == 1)
                b[p[0]] = "";
            else
                b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
        }
        return b;
    })(window.location.search.substr(1).split('&'));
    

With an URL like `?topic=123&name=query+string`, the following will return:

    qs["topic"];    // 123
    qs["name"];     // query string
    qs["nothere"];  // undefined (object)
    

* * *

Google method
-------------

Tearing Google's code I found the method they use: `getUrlParameters`

    function (b) {
        var c = typeof b === "undefined";
        if (a !== h && c) return a;
        for (var d = {}, b = b || k[B][vb], e = b[p]("?"), f = b[p]("#"), b = (f === -1 ? b[Ya](e + 1) : [b[Ya](e + 1, f - e - 1), "&", b[Ya](f + 1)][K](""))[z]("&"), e = i.dd ? ia : unescape, f = 0, g = b[w]; f < g; ++f) {
            var l = b[f][p]("=");
            if (l !== -1) {
                var q = b[f][I](0, l),
                    l = b[f][I](l + 1),
                    l = l[Ca](/\+/g, " ");
                try {
                    d[q] = e(l)
                } catch (A) {}
            }
        }
        c && (a = d);
        return d
    }
    

It is obfuscated, but it is understandable. It does not work because some variables are undefined.

They start to look for parameters on the url from `?` and also from the hash `#`. Then for each parameter they split in the equal sign `b[f][p]("=")` (which looks like `indexOf`, they use the position of the char to get the key/value). Having it split they check whether the parameter has a value or not, if it has then they store the value of `d`, otherwise they just continue.

In the end the object `d` is returned, handling escaping and the `+` sign. This object is just like mine, it has the same behavior.

* * *

My method as a **jQuery plugin**

    (function($) {
        $.QueryString = (function(paramsArray) {
            let params = {};
    
            for (let i = 0; i < paramsArray.length; ++i)
            {
                let param = paramsArray[i]
                    .split('=', 2);
                
                if (param.length !== 2)
                    continue;
                
                params[param[0]] = decodeURIComponent(param[1].replace(/\+/g, " "));
            }
                
            return params;
        })(window.location.search.substr(1).split('&'))
    })(jQuery);
    

Usage

    //Get a param
    $.QueryString.param
    //-or-
    $.QueryString["param"]
    //This outputs something like...
    //"val"
    
    //Get all params as object
    $.QueryString
    //This outputs something like...
    //Object { param: "val", param2: "val" }
    
    //Set a param (only in the $.QueryString object, doesn't affect the browser's querystring)
    $.QueryString.param = "newvalue"
    //This doesn't output anything, it just updates the $.QueryString object
    
    //Convert object into string suitable for url a querystring (Requires jQuery)
    $.param($.QueryString)
    //This outputs something like...
    //"param=newvalue&param2=val"
    
    //Update the url/querystring in the browser's location bar with the $.QueryString object
    history.replaceState({}, '', "?" + $.param($.QueryString));
    //-or-
    history.pushState({}, '', "?" + $.param($.QueryString));
    

* * *

[Performance test (split method against regex method)](http://jsperf.com/querystring-with-javascript) ([jsPerf](http://jsperf.com/))
------------------------------------------------------------------------------------------------------------------------------------

Preparation code: methods declaration

### Split test code

    var qs = window.GetQueryString(query);
    
    var search = qs["q"];
    var value = qs["value"];
    var undef = qs["undefinedstring"];
    

### Regex test code

    var search = window.getParameterByName("q");
    var value = window.getParameterByName("value");
    var undef = window.getParameterByName("undefinedstring");
    

**Testing in Firefox 4.0 x86 on Windows Server 2008 R2 / 7 x64**

*   **Split method**: 144,780 ±2.17% fastest
*   **Regex method**: 13,891 ±0.85% | 90% slower

URLSearchParams
===============

Firefox 44+, Opera 36+, Edge 17+, Safari 10.3+ and Chrome 49+ support the [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) API:

*   [Chrome Announcement and details](https://developers.google.com/web/updates/2016/01/urlsearchparams)
*   [Opera Announcement and details](https://dev.opera.com/blog/opera-36/)
*   [Firefox Announcement and details](https://developer.mozilla.org/en-US/Firefox/Releases/44#Miscellaneous)

There is a google-suggested **[URLSearchParams polyfill](https://github.com/WebReflection/url-search-params)** for the stable versions of IE.

It is not standardized by [W3C](https://www.w3.org/TR/2014/WD-url-1-20141209/#interface-urlsearchparams), but it is a living standard by [WhatWG](https://url.spec.whatwg.org).

You can use it on `location`:

    const params = new URLSearchParams(location.search);
    

or

    const params = (new URL(location)).searchParams;
    

Or of course on any URL:

    const url = new URL('https://example.com?foo=1&bar=2');
    const params = new URLSearchParams(url.search);
    

You can get params also using a shorthand `.searchParams` property on the URL object, like this:

    const params = new URL('https://example.com?foo=1&bar=2').searchParams;
    params.get('foo'); // "1"
    params.get('bar'); // "2" 
    

You read/set parameters through the `get(KEY)`, `set(KEY, VALUE)`, `append(KEY, VALUE)` API. You can also iterate over all values `for (let p of params) {}`.

A [reference implementation](https://trac.webkit.org/browser/trunk/Source/WebCore/platform/URLParser.cpp) and a [sample page](https://googlechrome.github.io/samples/urlsearchparams/) are available for auditing and testing.

Improved version of [Artem Barger's answer](https://stackoverflow.com/questions/901115/get-querystring-values-with-jquery/901144#901144):

    function getParameterByName(name) {
        var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
        return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
    }
    

For more information on improvement see: [http://james.padolsey.com/javascript/bujs-1-getparameterbyname/](http://james.padolsey.com/javascript/bujs-1-getparameterbyname/)

在JavaScript中获取URL的查询字符串（query string）值可以通过不同的方法完成，以下是两种常用的方法：

### 1. 使用 `window.location.search` 属性

这是获取当前页面URL查询字符串的最直接方法。`window.location.search` 会返回URL中 `?`之后的字符串，包括 `?`本身。

#### 例子：

```javascript
// 假设当前URL是: http://example.com/?product=shirt&color=blue&size=medium

// 获取查询字符串
var queryString = window.location.search;
console.log(queryString); // 输出: ?product=shirt&color=blue&size=medium

// 去除开头的问号
var query = queryString.substring(1);
console.log(query); // 输出: product=shirt&color=blue&size=medium
```

### 2. 使用 `URLSearchParams` 对象

`URLSearchParams` 是一个实用的Web API，它提供了一系列的方法来操作URL中的查询字符串。我们可以结合 `window.location.search` 来使用它。

#### 例子：

```javascript
// 继续假设当前URL是: http://example.com/?product=shirt&color=blue&size=medium

// 创建URLSearchParams实例
var searchParams = new URLSearchParams(window.location.search);

// 获取特定的查询参数
var product = searchParams.get('product');
console.log(product); // 输出: shirt

var color = searchParams.get('color');
console.log(color); // 输出: blue

var size = searchParams.get('size');
console.log(size); // 输出: medium
```

### 处理不在当前页面的URL

如果需要解析的URL不是当前页面的URL，可以直接创建一个 `URL`对象，并传递该URL作为参数，然后再使用 `URLSearchParams`。

#### 例子：

```javascript
// 假设有另外一个URL
var someUrl = 'http://example.com/?product=shoes&color=red&size=large';

// 创建URL对象
var url = new URL(someUrl);

// 创建URLSearchParams实例
var searchParams = new URLSearchParams(url.search);

// 获取特定的查询参数
var product = searchParams.get('product');
console.log(product); // 输出: shoes

var color = searchParams.get('color');
console.log(color); // 输出: red

var size = searchParams.get('size');
console.log(size); // 输出: large
```

`URLSearchParams` 提供的方法还有很多，如 `set`, `delete`, `append` 等，可以非常方便地处理查询字符串。使用 `URLSearchParams` 是现代浏览器推荐的方式，因为它提供了直接和简洁的API来操作查询字符串。

以上就是在JavaScript中获取查询字符串的两种方法。

How can i get query string values in javascript

在Web开发中，JavaScript代码尝试执行跨源HTTP请求时，可能会遇到与访问控制（CORS）相关的问题。CORS是一种由许多浏览器实现的安全功能，用来防止恶意网站读取另一个网站的数据。当JavaScript尝试从另一个源（域名、协议或端口不同）加载资源时，浏览器会执行CORS检查，看看请求的资源是否通过了相应的访问控制检查。

问题中提到的“无访问控制的allow origin的 header”通常是指后端服务器在响应中包含了一个`Access-Control-Allow-Origin: *`的HTTP头。这个HTTP头的存在告诉浏览器允许来自任何源的访问请求，这样做可以增加资源的可访问性，但同时也降低了安全性，因为任何网站都可以读取这些数据。

### 例子

假设您有一个API部署在`https://api.example.com`上，该API提供了用户信息。如果后端配置为发送`Access-Control-Allow-Origin: *`头，那么任何网站都可以向这个API发起请求并读取数据。

**JavaScript代码示例：**

```javascript
fetch("https://api.example.com/user/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
```

在这个例子中，如果`api.example.com`的响应包括`Access-Control-Allow-Origin: *`头，那么即使是从任何其他源（例如从不同的域名`https://anotherdomain.com`）发出的请求，浏览器也会允许这个跨源请求成功，并且JavaScript能够处理返回的数据。

### 安全考虑

虽然使用`Access-Control-Allow-Origin: *`可以简化开发，使得任何人都可以从任何地方访问您的资源，但这通常不适用于包含敏感数据或需要身份验证的API。在这些情况下，最好限制访问源，只允许特定的域名或使用更加严格的CORS策略。

通常，为了增强安全性，推荐的做法是在服务器端配置一个明确的白名单，列出允许访问该资源的域名，而不是使用`*`，这样可以有效控制哪些网站可以请求您的资源。

总之，`Access-Control-Allow-Origin: *`头的使用可以使资源跨域访问变得更加容易，但应谨慎使用，特别是在处理需要保护的数据时。在实际应用中，应根据具体需求和安全策略来设置适当的CORS策略。

如果我理解正确的话，您正在对与您的页面所在的域不同的域执行[XMLHttpRequest](http://en.wikipedia.org/wiki/XMLHttpRequest) 。因此，浏览器会阻止它，因为出于安全原因，它通常允许同一来源的请求。当你想要进行跨域请求时，你需要做一些不同的事情。

当您使用 Postman 时，它们不受此政策的限制。引用自_[跨源 XMLHttpRequest](https://developer.chrome.com/docs/extensions/mv2/xhr/)_：

> 常规网页可以使用 XMLHttpRequest 对象从远程服务器发送和接收数据，但它们受到同源策略的限制。扩展并没有如此限制。只要扩展程序首先请求跨源权限，就可以与其源之外的远程服务器进行通信。

> **警告：**使用`Access-Control-Allow-Origin: *`可能会使您的 API/网站容易受到[跨站点请求伪造](https://en.wikipedia.org/wiki/Cross-site_request_forgery)(CSRF) 攻击。在使用此代码之前，请确保您[了解风险](https://stackoverflow.com/questions/43154170/is-it-safe-to-enable-cors-to-for-a-public-and-readonly-webservice)。

[如果您使用PHP ，](http://en.wikipedia.org/wiki/PHP)解决起来非常简单。只需在处理请求的 PHP 页面的开头添加以下脚本：

    <?php header('Access-Control-Allow-Origin: *'); ?>
    

如果您使用[Node-red，](https://en.wikipedia.org/wiki/Node-RED)则必须通过取消注释以下行来允许文件中的[CORS ：](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing)`node-red/settings.js`

    // The following property can be used to configure cross-origin resource sharing
    // in the HTTP nodes.
    // See https://github.com/troygoode/node-cors#configuration-options for
    // details on its contents. The following is a basic permissive set of options:
    httpNodeCors: {
      origin: "*",
      methods: "GET,PUT,POST,DELETE"
    },
    

如果您使用与问题相同的[Flask](http://flask.pocoo.org/) ；你必须先安装`flask-cors`

    pip install -U flask-cors
    

然后将 Flask _cors_包包含在您的应用程序中。

    from flask_cors import CORS
    

一个简单的应用程序将如下所示：

    from flask import Flask
    from flask_cors import CORS
    
    app = Flask(__name__)
    CORS(app)
    
    @app.route("/")
    def helloWorld():
      return "Hello, cross-origin-world!"
    

更多细节可以查看[Flask 文档](https://flask-cors.readthedocs.io/en/latest/)。

因为  
**$.ajax({type: "POST"** - 调用**OPTIONS**  
**$.post(** - 调用**POST**  

两者是不同的。[邮递员](https://stackoverflow.com/tags/postman/info)正确地调用“POST”，但当我们调用它时，它将是“OPTIONS”。

**对于 C# Web 服务 - [Web API](https://en.wikipedia.org/wiki/ASP.NET_MVC_Framework#Apache_License_2.0_release)**

请将以下代码添加到_web.config_文件中的 <system.webServer> 标记下。这将起作用：

    <httpProtocol>
        <customHeaders>
            <add name="Access-Control-Allow-Origin" value="*" />
        </customHeaders>
    </httpProtocol>
    

请确保您在 Ajax 调用中没有犯任何错误。

### jQuery

    $.ajax({
        url: 'http://mysite.microsoft.sample.xyz.com/api/mycall',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
        },
        type: "POST", /* or type:"GET" or type:"PUT" */
        dataType: "json",
        data: {
        },
        success: function (result) {
            console.log(result);
        },
        error: function () {
            console.log("error");
        }
    });
    

**注意：**如果您正在寻找**从第三方网站**下载内容，那么**这对您没有帮助**。您可以尝试以下代码，但不能尝试 JavaScript。

    System.Net.WebClient wc = new System.Net.WebClient();
    string str = wc.DownloadString("http://mysite.microsoft.sample.xyz.com/api/mycall");

深的
==

在下面的 API 调查中，我使用[http://example.com](http://example.com)而不是您问题中的 http://myApiUrl/login ，因为第一个有效。我假设您的页面位于[http://my-site.local:8088](http://my-site.local:8088)。

**注意**：API 和您的页面具有不同的域！

您看到不同结果的原因是 Postman：

*   设置标头`Host=example.com`（您的 API）
*   未设置标题`Origin`
*   Postman 实际上根本不使用你的网站 url（你只需在 Postman 中输入你的 API 地址） - 他只向 API 发送请求，所以他假设该网站与 API 具有相同的地址（浏览器不会假设这一点）

这类似于当站点和 API 具有相同域时浏览器发送请求的方式（浏览器也设置 header item `Referer=http://my-site.local:8088`，但我在 Postman 中没有看到它）。**当_未_`Origin`设置header时，通常服务器默认允许此类请求。**

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

这是 Postman 发送请求的标准方式。但是，当**您的站点和 API 具有不同的域**时，浏览器会以不同的方式发送请求，然后[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)就会发生，浏览器会自动：

*   设置标头`Host=example.com`（您的 API）
*   设置标题`Origin=http://my-site.local:8088`（您的网站）

（标头`Referer`的值与 相同`Origin`）。现在，在 Chrome 的_控制台和网络_选项卡中，您将看到：

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

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

当你有**`Host != Origin`**这个就是CORS，当服务器检测到这样的请求时，它通常会**默认阻止它**。

`Origin=null`当您从本地目录打开 HTML 内容时设置，并且它发送请求。同样的情况是当您在 中发送请求时`<iframe>`，如下面的代码片段所示（但这里`Host`根本没有设置标头） - 一般来说，在 HTML 规范提到不透明来源的任何地方，您都可以将其转换为`Origin=null`.您可以[在此处](https://stackoverflow.com/questions/42239643/when-do-browsers-send-the-origin-header-when-do-browsers-set-the-origin-to-null/42242802#42242802)找到有关此内容的更多信息。

    fetch('http://example.com/api', {method: 'POST'});

    Look on chrome-console > network tab

运行代码片段Hide results

展开片段

如果您不使用简单的 CORS 请求，通常浏览器还会在发送主请求之前自动发送 OPTIONS 请求 - 更多信息请参见[此处](https://stackoverflow.com/questions/10093053/access-control-request-headers-is-added-to-header-in-ajax-request-with-jquery/55584963#55584963)。下面的代码片段展示了这一点：

    fetch('http://example.com/api', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json'}
    });

    Look in chrome-console -> network tab to 'api' request.
    This is the OPTIONS request (the server does not allow sending a POST request)

运行代码片段Hide results

展开片段

您可以更改服务器的配置以允许 CORS 请求。

**下面是一个在 nginx（nginx.conf 文件）上**打开 CORS 的示例配置-`always/"$http_origin"`对 nginx 和Apache的设置要非常小心`"*"`\- 这将从任何域中解除对 CORS 的阻止（在生产中，而不是使用您的具体页面地址，而不是使用您的具体页面地址）应用程序编程接口）

显示代码片段

    location ~ ^/index\.php(/|$) {
       ...
        add_header 'Access-Control-Allow-Origin' "$http_origin" always;
        add_header 'Access-Control-Allow-Credentials' 'true' always;
        if ($request_method = OPTIONS) {
            add_header 'Access-Control-Allow-Origin' "$http_origin"; # DO NOT remove THIS LINES (doubled with outside 'if' above)
            add_header 'Access-Control-Allow-Credentials' 'true';
            add_header 'Access-Control-Max-Age' 1728000; # cache preflight value for 20 days
            add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
            add_header 'Access-Control-Allow-Headers' 'My-First-Header,My-Second-Header,Authorization,Content-Type,Accept,Origin';
            add_header 'Content-Length' 0;
            add_header 'Content-Type' 'text/plain charset=UTF-8';
            return 204;
        }
    }

Run code snippetHide results

Expand snippet

**以下是在 Apache 上**打开 CORS 的示例配置（.htaccess 文件）

显示代码片段

    # ------------------------------------------------------------------------------
    # | Cross-domain Ajax requests                                                 |
    # ------------------------------------------------------------------------------
    
    # Enable cross-origin Ajax requests.
    # http://code.google.com/p/html5security/wiki/CrossOriginRequestSecurity
    # http://enable-cors.org/
    
    # <IfModule mod_headers.c>
    #    Header set Access-Control-Allow-Origin "*"
    # </IfModule>
    
    # Header set Header set Access-Control-Allow-Origin "*"
    # Header always set Access-Control-Allow-Credentials "true"
    
    Access-Control-Allow-Origin "http://your-page.com:80"
    Header always set Access-Control-Allow-Methods "POST, GET, OPTIONS, DELETE, PUT"
    Header always set Access-Control-Allow-Headers "My-First-Header,My-Second-Header,Authorization, content-type, csrf-token"

Run code snippetHide results

Expand snippet

应用 CORS 限制是一项由服务器定义并由**浏览器**实现的安全功能。

> 浏览器查看服务器的 CORS 策略并遵守它。

然而，Postman工具并不关心服务器的CORS策略。

这就是为什么 CORS 错误出现在浏览器中，但没有出现在 Postman 中。

Why does my javascript code receive a no access control allow origin header

在 JavaScript 中，处理日期和时间是一个常见的任务，尤其是在企业应用程序中。当我们需要为给定的日期增加特定的月份时，我们可以通过以下步骤来实现：

1. **创建一个新的日期对象**：首先，我们需要有一个初始的日期对象。
2. **使用 `setMonth()` 和 `getMonth()` 方法**：通过这两个方法，我们可以获取当前月份并设置新的月份。

下面是一个简单的函数实现，它接受两个参数：一个日期和要增加的月份数：

```javascript
function addMonthsToDate(date, months) {
    var newDate = new Date(date);
    newDate.setMonth(newDate.getMonth() + months);
    return newDate;
}
```

### 使用示例

假设我们有一个日期 `2021-01-15`，我们想要增加 3 个月：

```javascript
let initialDate = new Date('2021-01-15');
let updatedDate = addMonthsToDate(initialDate, 3);
console.log(updatedDate);  // 输出：2021-04-15T00:00:00.000Z
```

### 注意事项

- **月份溢出**：JavaScript 的 `Date` 对象会自动处理日期的溢出。例如，如果您在 1 月 31 日上增加 1 个月，结果是 3 月 3 日，而不是 2 月 31 日，因为 2 月没有 31 日。
- **时区问题**：创建 `Date` 对象时，默认使用的是本地时区。如果您处理的是 UTC 日期或其他时区的日期，可能需要相应地调整这个函数。

通过这种方法，我们可以灵活地为任何日期增加任意月份，这对于计算未来或过去的日期非常有用。


JavaScript function to add X months to a date

在 JavaScript 中，`children` 和 `childNodes` 都是用来获取一个元素的子元素的属性，但主要区别在于它们各自包含的节点类型。

### 1. `childNodes`
`childNodes` 属性返回一个包含指定元素的所有子节点的节点列表（NodeList）。这里的“子节点”包括所有类型的节点，如元素节点、文本节点和注释节点。这意味着如果元素中包含了文本或注释，这些也会作为子节点被 `childNodes` 返回。

**示例**：
假设我们有如下HTML结构：
```html
<div id="example">
  Hello World!
  <p>Paragraph 1</p>
  <p>Paragraph 2</p>
</div>
```
使用 `childNodes` 获取子节点：
```javascript
var example = document.getElementById("example");
console.log(example.childNodes);
```
这将输出类似于以下的结果，包括文本节点和元素节点：
```
[
  #text "Hello World!",
  <p>Paragraph 1</p>,
  <p>Paragraph 2</p>
]
```

### 2. `children`
相比之下，`children` 属性只返回包含元素子节点的集合。它是一个HTMLCollection，仅包括元素类型的子节点，忽略文本节点、注释节点等其他类型的节点。

**示例**：
使用相同的HTML结构：
```html
<div id="example">
  Hello World!
  <p>Paragraph 1</p>
  <p>Paragraph 2</p>
</div>
```
使用 `children` 获取子元素：
```javascript
var example = document.getElementById("example");
console.log(example.children);
```
这将输出：
```
[
  <p>Paragraph 1</p>,
  <p>Paragraph 2</p>
]
```
这里不包括 "Hello World!" 文本节点，仅包括`<p>`元素节点。

### 总结
总的来说，`childNodes` 包含所有类型的子节点，而 `children` 仅包括子元素节点。根据需要处理的具体内容，选择合适的属性是很重要的。在处理DOM时，如果你只关心元素节点而不是文本或其他类型的节点，`children` 是更为合适的选择。

What is the difference between children and childNodes in JavaScript?

在 JavaScript 中，`@` 符号通常用于简化模块导入路径，这是通过配置 JavaScript 项目中的别名（alias）实现的。这种做法常见于使用 Webpack、TypeScript 或其他 JavaScript 构建工具的项目中。配置别名可以帮助开发者更快地访问项目中的特定文件或目录，避免使用较长或较复杂的相对路径。

### 示例

假设我们有一个较大的前端项目，项目结构如下：

```
- src
  - components
    - Button.js
    - NavBar.js
  - utils
    - helpers.js
  - App.js
```

在没有别名的情况下，如果你需要在 `App.js` 中导入 `Button.js` 和 `helpers.js`，你可能需要写出完整的相对路径：

```javascript
import Button from './components/Button';
import { someFunction } from './utils/helpers';
```

如果使用 `@` 符号来设置别名，你可以在构建配置中这样设置（以 Webpack 为例）：

```javascript
// webpack.config.js
module.exports = {
  resolve: {
    alias: {
      '@components': path.resolve(__dirname, 'src/components'),
      '@utils': path.resolve(__dirname, 'src/utils')
    }
  }
};
```

设置好别名后，你可以在项目中更简洁地引用模块：

```javascript
import Button from '@components/Button';
import { someFunction } from '@utils/helpers';
```

这样的配置使得代码更加整洁，并且当项目结构变更时，你只需要在配置文件中更新路径，而不需要修改每一个文件中的导入路径。这在大型项目中特别有用，可以大大提高开发效率和维护性。

What does the @ symbol do in javascript imports?

在JavaScript中，检查一个对象是否为DOM对象可以通过几种不同的方法来实现。具体方法取决于你想要检查的DOM对象的类型，比如是否是一个元素节点、文本节点或者其他。以下是一些常用的方法：

### 1. 使用 `instanceof` 检查

`instanceof` 操作符可以用来检查一个对象是否是特定构造函数的实例。对于DOM对象，我们可以使用如 `HTMLElement`, `Node` 等构造函数来进行检查。例如：

```javascript
function isDOMElement(obj) {
    return obj instanceof HTMLElement;
}

const element = document.createElement('div');
console.log(isDOMElement(element));  // 输出: true
```

### 2. 使用 `nodeType` 属性

每个DOM节点都有一个 `nodeType` 属性，它是一个数字，表示节点的类型。例如，元素节点的 `nodeType` 是 `1`。我们可以通过检查这个属性来判断一个对象是否是DOM节点：

```javascript
function isDOMNode(obj) {
    return obj && typeof obj === 'object' && 'nodeType' in obj;
}

const node = document.createTextNode("Hello");
console.log(isDOMNode(node));  // 输出: true
```

### 3. 使用 `nodeName` 或 `tagName` 属性

对于元素节点，`nodeName` 和 `tagName` 属性返回元素的标签名。我们可以检查这些属性是否存在来判断一个对象是否是DOM元素：

```javascript
function isDOMElement(obj) {
    return obj && typeof obj === 'object' && ('nodeName' in obj || 'tagName' in obj);
}

const element = document.createElement('p');
console.log(isDOMElement(element));  // 输出: true
```

### 应用场景示例

假设我们正在开发一个函数库，该库需要处理用户传入的对象，这些对象可能是DOM元素，也可能是普通的JavaScript对象。我们需要根据对象类型执行不同的操作，例如：

```javascript
function process(obj) {
    if (isDOMElement(obj)) {
        console.log("处理DOM元素");
        // 对DOM元素进行一些操作
    } else {
        console.log("处理普通对象");
        // 对普通对象进行一些操作
    }
}

const elem = document.createElement('span');
const obj = { name: 'John Doe' };

process(elem);  // 输出: 处理DOM元素
process(obj);   // 输出: 处理普通对象
```

这样，我们可以确保函数按照对象的类型正确地执行操作，同时也提高了代码的健壮性和可维护性。

How do you check if a JavaScript Object is a DOM Object?

在JavaScript中，要从字符串中删除所有非字母数字字符，我们可以使用正则表达式结合`replace`方法来实现。正则表达式提供了一种灵活的方式来匹配字符串中的特定模式，并通过`replace`方法将这些模式替换或删除。

### 示例代码：

```javascript
function removeNonAlphanumeric(str) {
    return str.replace(/[^a-z0-9]/gi, '');
}

// 示例使用
const originalString = "Hello, World! 123";
const cleanedString = removeNonAlphanumeric(originalString);

console.log(cleanedString);  // 输出: HelloWorld123
```

### 代码解释：

1. **函数定义**：
   - `removeNonAlphanumeric`是一个函数，接受一个字符串`str`作为参数。

2. **正则表达式**：
   - `/[^a-z0-9]/gi`是一个正则表达式，用于匹配所有非字母数字字符。
   - `[^a-z0-9]`意味着匹配除了小写字母(`a-z`)和数字(`0-9`)之外的所有字符。
   - `g`标志代表全局匹配，即匹配整个字符串中的所有实例。
   - `i`标志代表不区分大小写，这使得表达式也匹配大写字母(`A-Z`)。

3. **替换操作**：
   - 使用`replace`方法将所有匹配的非字母数字字符替换为空字符串(`''`)，这样就移除了这些字符。

### 应用场景：

这种方法可以用在多种场景下，例如清理用户输入、URL查询字符串参数，或者处理文本数据，以便后续的数据分析或存储。

通过上述方法，我们可以确保字符串只包含字母和数字，这在很多编程和应用场景中都非常有用。

Remove not alphanumeric characters from string

在 JavaScript 中，如果您想要返回一个不带斜杠（/）的字符串，您可以使用字符串的 `replace` 方法来实现这一点。这个方法可以用来搜索字符串中的特定字符或者模式，并将它们替换为您指定的新内容。

以下是一个简单的例子，展示如何移除字符串中的所有斜杠：

```javascript
function removeSlashes(inputString) {
  // 使用正则表达式 /\/+/g 匹配字符串中的所有斜杠，并将它们替换为空字符串
  return inputString.replace(/\/+/g, "");
}

// 示例
let stringWithSlashes = "https://www.example.com/";
let cleanedString = removeSlashes(stringWithSlashes);

console.log(cleanedString);  // 输出: https:www.example.com
```

在这个例子中，`/\/+/g` 是一个正则表达式，用于匹配一个或多个连续的斜杠字符。`g` 标志表示全局匹配，意味着会替换掉字符串中的所有斜杠。

这种方法非常有效，可以处理包含任意数量斜杠的字符串，并确保所有这些字符都被移除。

JavaScript相关问题