目录
技术方面
二、js
1.js数据类型
1）值类型(基本类型)
2）引用数据类型（对象类型）
编辑
2.判断数据类型是否为数组类型
1）Array.isArray()
2）instanceof操作符
3） Object.prototype.toString.call()方法
3.NaN是什么数据类型，全称，有何特点
1）定义
2）例子
3）要点解析
4.js中，0.1+0.2为什么不等于0.3，如何实现等于
1）原因
2）解决方式
（1）使用Number.EPSILON进行比较
（2）放大倍数相加后再缩小还原
（3）外部库（decimal.js等）
5.typeof有什么局限，能识别全部数据吗
6..如何获取所有被选择的checkbox元素
编辑
7.点击dom节点执行某个函数
8.循环方法
1）for / for...in / for...of循环
2）while / do...while循环
3）Array.prototype.foreach()
9.怎么快速找到数组的某个值
1）只想知道某个值是否存在于数组中 -- includes
2）找到数组中的某个值，并知道该值在数组中的索引位置 -- indexOf()，find()，findIndex()
（1）indexOf()
（2）find()
（3）findIndex()
10.let,var,const区别
1）作用域
补充：变量提升
（1）为什么要变量提升
（2）变量提升具体表现
编辑
2）重复声明
3）重新赋值
11.null和undefined区别
1）定义
2）类型
12.操作数组有哪些原生方法
13.以下语句输出什么：
14.以下语句输出什么：
console.log()
补充：
真值与true：
15.以下语句输出什么：
16.获取当前时间，形式为“YYYY-MM-DD”
17.合并两个数组并删掉第二个元素
1）使用concat()合并数组，并使用splice()删除第二个元素
2）使用扩展运算符（...）和splice()
18.js写方法消除字符串中的重复内容，比如“aabbbbbcccd”，消除后为“abcd”
技术方面
二、js
1.js数据类型
1）值类型(基本类型)
- String：字符串
- Number：数字，包含整数和浮点数
- Boolean：布尔类型，true of false
- Null：表示空值或没有对象值
- Undefined：当变量声明但未赋值时，默认值为undefined
- Symbol：表示独一无二的值，通常用作对象的属性名
例子：
值类型定义例子：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>js数据类型</title>
<script>
let num = 42; // 整数
let floatNum = 3.14; // 浮点数
console.log(typeof num,typeof floatNum);// 输出:number number
let str = "Hello, world!";
console.log(typeof str);// 输出:string
let isDone = false;
let isReady = true;
console.log(typeof isDone,typeof isReady);// 输出:boolean boolean
let undefinedVar;
console.log(undefinedVar); // 输出: undefined
let emptyObj = null;
console.log(emptyObj); // 输出: null
let sym = Symbol("description");
console.log(sym); // 输出: Symbol(description)
</script>
</head>
123
</body>
</html>结果：
2）引用数据类型（对象类型）
- Object：对象。
- Array：数组，用于存储有序集合的数据。
- Function：函数，既可以作为值传递，也可以作为参数传递，还可以作为其他函数的返回值。
- RegExp：正则，用于定义字符串的搜索模式。
- Date：日期，用于处理日期和时间。
对象定义及使用例子：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>js数据类型</title>
<script>
// 定义一个对象
let student = {
name: "Marry",
gender: "female",
age: 20,
country:'China',
greet: function() {
return `Hello, my name is ${this.name}, I'm from ${this.country} originally.`;
}
};
// 使用点符号（.）或方括号（[]）访问属性
console.log(student.name); // 输出: Marry
console.log(student["name"]); // 输出: Marry
// 调用对象的方法
console.log(student.greet()); // 输出: Hello, my name is Marry, I'm from China originally.
// 修改对象的属性
student.age = 21;
console.log(student.age); // 输出: 21
// 添加新的属性
student.email = "marry@example.com";
console.log(student.email); // 输出: johndoe@example.com
// 遍历对象的属性
for (let key in student) {
console.log(`${key}: ${student[key]}`);
}
</script>
</head>
123
</body>
</html>结果：
2.判断数据类型是否为数组类型
1）Array.isArray()
直接检查对象是否为数组类型，且不会因数组所在的执行上下文不同而受到影响。
2）instanceof操作符
测试一个对象在其原型链中是否存在一个构造函数的prototype属性。对于数组，可以使用Array构造函数来测试。
3） Object.prototype.toString.call()方法
let arr = [1, 2, 3];
console.log(Array.isArray(arr)); // true
console.log(arr instanceof Array); // true
console.log(Object.prototype.toString.call(arr) === '[object Array]'); // true3.NaN是什么数据类型，全称，有何特点
1）定义
NaN(Not-a-Number)是一个特殊的数值，表示某些数学运算的结果不是数字。NaN的类型是Number，但它与任何值（包括它自身）的比较结果都是false。
2）例子
let result1 = 0 / 0;
let result2 = 's';
let result3=2 / 3;
let result4 = "";
console.log(isNaN(result1),isNaN(result2),isNaN(result3),isNaN(result4)); // 输出: true true false false
console.log(typeof result1,typeof result2,typeof result3); // 输出: number string number
console.log(result1 === NaN,result2 === NaN,result3 === NaN,NaN === NaN); // 输出: false false false false
console.log(Number.isNaN(result1),Number.isNaN(result2),Number.isNaN(result3)); // 输出: true false false结果：
3）要点解析
（1） isNaN会尝试将其参数转换为数字，然后检查转换后的值是否为NaN,而Number.isNaN则不会进行类型转换，直接检查其参数是否为NaN，是则返回true，不是返回false。
（2）isNaN对字符串's'（或任何其他非数字的字符串）作为数字进行操作时，JavaScript会尝试解析这个字符串以获取一个数字。但是，由于's'不包含任何可以解释为数字的有效字符序列（比如数字字符、小数点等），因此解析失败，JavaScript按照规则将其视为无法表示为一个有效的数字值，并返回NaN。
（3）可以解析为有效数字的情况有：数字字符串（如“123”，“23.35”，“-890”，“1.23e4”），前导空格或零（如“ 123”，“00123”），空字符串（“”在转换为数字时会得到0）
（4）NaN的类型是Number，但它与任何值（包括它自身）的比较结果都是false。(因为NaN是一个特殊的值，被设计为表示一个不确定或无效的数字结果，因此它不应该被视为等于任何其他值，包括它自己。这种设计有助于在编程中更容易地检测和处理无效或未定义的数值结果。)
4.js中，0.1+0.2为什么不等于0.3，如何实现等于
1）原因
在js（以及许多其他编程语言）中，浮点数通常使用IEEE 754标准来表示。这个标准定义了一种在计算机中存储浮点数的方法，它支持非常大和非常小的数，但有一个关键的限制：它不能精确表示所有的十进制小数。这是因为IEEE 754浮点数是以二进制形式存储的，而某些十进制小数在二进制下是无限循环的。
十进制小数0.1和0.2，它们在二进制下分别是无限循环小数：
- 0.1（十进制）在二进制中表示为0.00011001100110011...
- 0.2（十进制）在二进制中表示为0.0011001100110011...
转换过程(0.1转为二进制）：
- 开始：0.1（十进制）
- 乘以2：0.1*2=0.2，整数部分为0
- 取小数部分继续：0.2的小数部分再乘以2，0.2*2=0.4，整数部分为0
- 继续：0.4的小数部分乘以2，0.4*2=0.8，整数部分为0
- 继续：0.8的小数部分乘以2，0.8*2=1.6，整数部分为1，小数部分为0.6
- 继续（这里开始循环）：0.6的小数部分乘以2，0.6*2=1.2，整数部分为1，小数部分为0.2（与步骤2相同，循环）
因此，0.1的二进制近似表示为0.00011001100...（其中1100会无限重复）,0.2转换过程同理。
在js中执行0.1+0.2时，实际上是在对这两个数的二进制表示的有限近似值进行加法运算。
2）解决方式
（1）使用Number.EPSILON进行比较
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON
利用epsilon值作比较，计算0.1+0.2和0.3的差值的绝对值（Math.abs()），如果这个绝对值小于epsilon，则认为它们是相等的。
function numbersCloseEnoughToEqual(num1, num2) {
return Math.abs(num1 - num2) < Number.EPSILON;
}
console.log(numbersCloseEnoughToEqual(0.1 + 0.2, 0.3));
// 对于更一般的情况，可自行设定，使用更宽松的epsilon值
const epsilon = 1e-6;
console.log(Math.abs(0.1 + 0.2 - 0.3) < epsilon);（2）放大倍数相加后再缩小还原
将0.1+0.2的值和0.3的值同时放大10的precision次方（Math.pow()）后舍入为最接近的整数(Math.round())，比较两值是否相等。
function compareFloats(num1, num2, precision = 3) {
return Math.round(num1 * Math.pow(10, precision)) === Math.round(num2 * Math.pow(10, precision));
}
console.log(compareFloats(0.1 + 0.2, 0.3, 1)); （3）外部库（decimal.js等）
有些JavaScript库（如decimal.js、bignumber.js等）提供了高精度的十进制运算支持。这些库可以帮助进行精确的浮点数运算，避免舍入误差。
let a = new Decimal(0.1);
let b = new Decimal(0.2);
let sum = a.plus(b);
console.log(sum.toString() === '0.3'); // true5.typeof有什么局限，能识别全部数据吗
typeof运算符在js中用于确定一个值的数据类型，它可以区分基本数据类型，但是对于所有对象类型的数据（如数组、对象）都会返回object，且null也会返回object
例子：
let student = {
name: "Marry",
gender: "female",
age: 20,
country:'China',
greet: function() {
return `Hello, my name is ${this.name}, I'm from ${this.country} originally.`;
}
};
let arr = [1, 2, 3];
let func1 = function (){}
console.log(typeof student); // object
console.log(typeof arr); // object
console.log(typeof null); // object
console.log(typeof func1); // function
console.log(typeof undefined); // undefined
console.log(typeof NaN); // number结果：
6..如何获取所有被选择的checkbox元素
例子：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>js</title>
<script>
function getCheckedBoxes() {
// 获取页面上所有的checkbox元素
let checkboxes=document.querySelectorAll('input[type=checkbox]');
// 创建一个数组来存储所有被选中的checkbox的值
let selectedValues = [];
// 遍历每一个checkbox
checkboxes.forEach(function(checkbox) {
// 如果checkbox被选中，则将其值添加到selectedValues数组中
if (checkbox.checked) {
selectedValues.push(checkbox.value);
}
});
return selectedValues;
}
</script>
</head>
<div class="container">
<input type="checkbox" id="checkbox1" name="checkbox1" value="value1">选择1
<input type="checkbox" id="checkbox2" name="checkbox2" value="value2">选择2
<input type="checkbox" id="checkbox3" name="checkbox3" value="value3">选择3
</div>
</body>
</html>结果：
如果要在页面实时显示（js监听）：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>js</title>
<script>
function updateSelectedValues() {
// 获取页面上所有的checkbox元素
let checkboxes=document.querySelectorAll('input[type=checkbox]');
// 创建一个数组来存储所有被选中的checkbox的值
let selectedValues = [];
// 遍历每一个checkbox
checkboxes.forEach(function(checkbox) {
// 如果checkbox被选中，则将其值添加到selectedValues数组中
if (checkbox.checked) {
selectedValues.push(checkbox.value);
}
});
// 更新页面上显示已选中checkbox值的元素
document.getElementById('selectedValues').textContent = '当前选择了: ' + selectedValues.join(', ');
}
// 页面初始化显示
window.onload = function (){
updateSelectedValues();
// change事件监听器
document.querySelectorAll('input[type=checkbox]').forEach(function (checkbox){
checkbox.addEventListener('change',updateSelectedValues);
})
}
</script>
</head>
<div class="container">
<input type="checkbox" id="checkbox1" name="checkbox1" value="value1">选择1
<input type="checkbox" id="checkbox2" name="checkbox2" value="value2">选择2
<input type="checkbox" id="checkbox3" name="checkbox3" value="value3">选择3
<p>当前选择了<span id="selectedValues"></span></p>
</div>
</body>
</html>结果：
7.点击dom节点执行某个函数
在原生js中，可以用click事件监听器的方式绑定点击事件与执行函数：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>js</title>
</head>
<div class="container">
<button id="button" name="button">点击按钮</button>
</div>
<script>
let button = document.getElementById("button");
button.addEventListener('click',showAlert);
function showAlert(){
alert('按钮被点击');
}
</script>
</body>
</html>结果：
其他比如在vue中，可以用@click等绑定点击事件
8.循环方法
1）for / for...in / for...of循环
// for循环
for (let i = 0; i < 5; i++) {
console.log(i);
}
// for...in循环，用于遍历对象的所有可枚举属性
const obj = {a: 1, b: 2, c: 3};
for (let key in obj) {
console.log(key, obj[key]);
}
// for...of循环，直接遍历对象的值，而不是索引或键
const arr = [1, 2, 3];
for (let value of arr) {
console.log(value);
}
2）while / do...while循环
// while循环
let j = 0;
while (j < 5) {
console.log(j);
j++;
}
// do...while循环
let k = 0;
do {
console.log(k);
k++;
} while (k < 5);3）Array.prototype.foreach()
它不是一个循环语句，是一个数组方法，允许对数组的每个元素执行一次提供的函数。它不是一个真正的循环，因为它没有迭代控制（如break或continue），但它经常用于遍历数组。
// Array.prototype.foreach()循环
const array = [1, 2, 3];
array.forEach(function(value) {
console.log(value);
});9.怎么快速找到数组的某个值
1）只想知道某个值是否存在于数组中 -- includes
let arr = [1,2,3,4,5];
console.log(arr.includes(3)); // true
console.log(arr.includes(7)) // false2）找到数组中的某个值，并知道该值在数组中的索引位置 -- indexOf()，find()，findIndex()
（1）indexOf()
输入参数为要找的某个值，返回值为该值在数组中的下标（索引），如果数组中不存在该值则返回-1，如果值有重复则会返回第一个找到的元素的下标。
let array = [1,2,3,4,5,5];
let index1 = array.indexOf(4); // 查找值4的索引
console.log(index1); // 输出: 3
let index2 = array.indexOf(9); // 查找不存在的值9
console.log(index2); // 输出: -1
let index3 = array.indexOf(5); // 查找重复值5
console.log(index3); // 输出: 4（2）find()
find方法返回数组中满足条件的第一个元素的值。否则返回undefined。find返回的是元素本身。
let array = [5, 12, 8, 130, 44];
let value1 = array.find(element => element > 10); // 查找第一个大于10的元素
console.log(value1); // 输出: 12
let value3 = array.find(element => element === 3); // 查找不存在的值3
console.log(value3); // 输出: undefined（3）findIndex()
与find类似，但findIndex返回的是元素的索引。如果数组中没有任何元素满足查找条件，则返回-1。
let array = [5, 12, 8, 130, 44];
let index1 = array.findIndex(element => element > 10); // 查找第一个大于10的元素的索引
console.log(index1); // 输出: 1 , 找到的元素是12，对应下标是1
let index2 = array.findIndex(element => element === 3); // 查找不存在的值3的索引
console.log(index2); // 输出: -110.let,var,const区别
1）作用域
-
var：var声明的变量具有函数作用域或全局作用域，但不具有块级作用域。这意味着var变量可以在声明它的函数或全局作用域内的任何位置被访问，但不能在函数外部访问函数内部声明的var变量（除非该变量也被声明为全局变量）。然而，在if语句、for循环等控制结构内部声明的var变量，实际上会“泄漏”到包含这些控制结构的函数或全局作用域中。
-
let和 const：let 和const都引入了块级作用域的概念。这意味着它们声明的变量仅在声明它们的块（如{}包围的代码块）或包含它们的函数中可用。这使得变量在逻辑上更加封闭和可预测，有助于避免意外的变量覆盖和泄露。
var例子：
var具有函数作用域和全局作用域：
// a作为全局变量可以在aaa()中被访问到，执行aaa()函数后，a的值发生变化
var a=1;
function aaa(){
a=2;
}
console.log(a) // 1
aaa();
console.log(a) // 2// a作为函数中的局部变量可以在aaa()内部被访问到，执行aaa()函数后，a的值发生变化
function aaa(){
var a=2;
if(a===2){
a=3;
}
console.log(a) // 3
}
aaa();var不具有块级作用域（不能在函数外部访问函数内部声明的var变量）：
function aaa(){
var a=1;
a+=1;
}
aaa()
console.log(a);以上代码会报错：
补充：变量提升
{
var a=11;
}
console.log(a) // 11a并不在全局作用域中，因为它被声明在一个块级作用域{}内。但是，由于var的特性，这个变量a会被“提升”到包含它的函数（如果有的话）或全局作用域中，它在全局上下文中也是可访问的（非严格模式下执行）。然而，这种访问是通过“提升”到全局作用域（或包含函数的作用域）来实现的，而不是因为a本身就在全局作用域中声明。
（1）为什么要变量提升
变量提升简化变量和函数的使用，允许开发者在声明变量或函数之前就能使用它们。（let和const声明的变量不会被提升）
（2）变量提升具体表现
-
对于函数声明：函数声明会被提升到其作用域的开始，即可以在函数声明之前调用该函数。
-
对于变量声明：使用var声明的变量也会被提升到其作用域的开始，但重要的是要注意，只有声明会被提升，初始化（赋值）不会被提升。这意味着如果你在声明变量之前尝试访问它，你会得到一个undefined值，而不是错误。
例子：
console.log(a) // 变量初始化（赋值）不会提升，在初始化之前访问会返回undefined
var a=11
console.log(a) // 赋值后可以访问，输出：11
function foo() {
console.log(bar()); // 变量提升，函数可以在声明前被调用，输出: Hello, World!
function bar() {
return 'Hello, World!';
}
}
foo();结果：
注：
- 使用let和const声明的变量不会被提升。如果在声明之前访问，会报错。
- 在严格模式下，尝试访问未声明的变量（包括在var声明被提升但未初始化时访问）也会报错。
例子：
console.log(a) // let声明不会提升，在声明前访问会报错，const也是
let a=11报错：
2）重复声明
-
var：在同一个作用域内，使用var可以多次声明同一个变量，后面的声明会覆盖前面的声明。
-
let和 const：let和const都不允许在同一作用域内重复声明同一个变量，无论是否带有初始化表达式。
例子：
var重复声明：
var a=1
console.log(a)
var a=2;
console.log(a)
var a=3;
console.log(a)结果：
let和const则不允许重复声明：
例子：
let a=1;
console.log(a)
let a=2;
console.log(a)报错：
3）重新赋值
-
var和 let：使用var或let声明的变量都可以被重新赋值。即，你可以改变它们的值。
-
const：使用const声明的变量必须被赋予一个初始值，且这个值在后续不能被改变（常量）。
注：const的“不可变”是指变量所引用的内存地址不可变，如果变量引用的是一个对象或数组，则可以修改对象或数组内部的属性或元素，但不能将变量重新指向一个新的对象或数组。
例子：
let a=1;
console.log(a) // 1
a=2;
console.log(a) // 2const a=1;
console.log(a) // 1
a=2;
console.log(a) // 报错const修改常量报错：
const可以修改对象或数组内部的属性或元素：
const obj = {
a:1,
b:2
}
console.log(obj.a) // 1
obj.a=2;
console.log(obj.a) // 211.null和undefined区别
1）定义
- undefined：表示变量已经声明，但是还没有被赋值，是变量未定义时的默认值。
- null：表示空值或空引用，用于表示某个变量将来可能指向一个对象，但目前没有指向任何对象。null通常用于主动释放指向对象的引用，或者表示某个值或对象不存在。
2）类型
使用typeof进行类型检测时，undefined类型为“undefined”，null类型为“object”。
使用isNaN进行数字转化时，undefined转化为NaN，null会转化为数字0。
let a;
let b=null;
console.log(typeof a) // undefined
console.log(typeof undefined) // undefined
console.log(isNaN(a)) // true
console.log(typeof null) // object
console.log(typeof b) // object
console.log(isNaN(b)) // false12.操作数组有哪些原生方法
JS：33种原生JS数组方法（8种改变原数组方法，25种不涉及数组改变的方法）_js 改变原数组的方法-CSDN博客
13.以下语句输出什么：
var a;
alert(typeof(a));
alert(b);了解了前面的知识之后，这题就简单了：
弹窗输出：undefined
报错：b is not defined
14.以下语句输出什么：
var undefined;
console.log(undefined==null); // true
console.log(1==true); // true
console.log(2==true); // false
console.log(0==false); // true
console.log(0==''); // true
console.log(NaN==NaN); // false
console.log([]== false) // trueconsole.log()
==（非严格等于）操作符会进行类型转换
-
console.log(undefined == null); // true
undefined 和null在使用==进行比较时会被视为相等
-
console.log(1==true); // true
js中，当使用==比较时，数字1会被视为真值（truthy），而true本身就是真值。因此相等。
-
console.log(2==true); // false
这里2是真值，但true并不等同于数值2，所以它们不相等。
-
console.log(0==false); // true
在js中，0被视为假值（falsy），而false也是假值。当使用==进行比较时相等。
-
console.log(0==''); // true
空字符串''被视为假值，就像0一样。因此，当使用==进行比较时，被视为相等。
-
console.log(NaN == NaN); //false
NaN与任何值（包括它自己）使用==或===比较时都返回false。
-
console.log([] == false); // true
空数组[]被视为真值（truthy），但实际上，当它与false使用==进行比较时，空数组会被转换为数字0（因为空数组在数值上下文中被视为0），而0又被视为假值（falsy），但这里的关键是false也被视为假值，并且由于它们都处于假值，所以被视为相等。
如果题中全部改成严格意义相等===，则全部返回false,===操作符要求值和类型都必须相同:
var undefined;
console.log(undefined===null); // false
console.log(1===true); // false
console.log(2===true); // false
console.log(0===false); // false
console.log(0===''); // false
console.log(NaN===NaN); // false
console.log([]=== false) // false-
console.log(undefined === null); // false
这个返回false是因为undefined 和null虽然都表示“无”或“空”的概念，但它们类型不同。undefined 的类型是undefined ，而null的类型是object。
-
console.log(1 === true); // false
这个返回false因为1 是一个数字，而true是一个布尔值。使用===时不会进行类型转换，所以不相等。
-
console.log(2 === true); // false
同上，2是数字类型，而true是布尔类型，类型不同。
-
console.log(0 === false); // false
尽管在某些上下文中，0和false在逻辑上可能被视为等价，但它们的类型是不同的。0是数字类型，而false是布尔类型，不相等。
-
console.log(0 === ''); // false
类型不同。
-
console.log(NaN === NaN); //false
NaN 与任何值（包括它自己）使用===比较时都返回false。这是因为NaN 被设计为与任何值都不相等，包括它自己。
-
console.log([] === false); // false
同上，类型不同。
补充：
真值与true：
在js中，真值（truthy）和true是两个不同的概念，没有一个值严格等同于true（即使用===操作符比较时相等），除了true本身。
-
真值（Truthy）：在布尔上下文中，JavaScript会将某些值视为真（truthy），这些值在逻辑表达式中会被当作true。例如，非零数字、非空字符串、非空对象（包括数组）等都是真值。但是，这并不意味着这些真值在比较时等同于true。
-
true：这是一个布尔类型的字面量，表示严格的真。
- 使用===与true进行比较时，只有true本身才会被认为是相等的（true === true，结果为true，其余结果为false）。
15.以下语句输出什么：
function cart(){
console.log(a);
alert(a);
}
function foo(){
var a=100;
cart();
}
var a=200;
foo();运行结果：
原因：
定义全局变量a=200，执行函数foo()，在foo()中有局部变量a=100，然后执行cart()，在cart()中访问不到局部变量，所以输出为全局变量a，值为200。
16.获取当前时间，形式为“YYYY-MM-DD”
例子：
function getDateTime(){
const nowDate = new Date();
let year = nowDate.getFullYear(); // 获取年份
let month = (nowDate.getMonth() + 1).toString().padStart(2,'0'); // 月份从0开始，所以要+1，padStart确保两位数
let day = nowDate.getDay().toString().padStart(2,'0'); //获取日期
return `${year}-${month}-${day}` // 形如YYYY-MM-DD
}
console.log(getDateTime())结果：
17.合并两个数组并删掉第二个元素
1）使用concat()合并数组，并使用splice()删除第二个元素
let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
// 使用concat()合并数组
let mergedArray = array1.concat(array2);
// 删除合并后数组的第二个元素
mergedArray.splice(1,1); // 从索引1开始删除1个元素
console.log(mergedArray); // 输出: [1, 3, 4, 5, 6]2）使用扩展运算符（...）和splice()
let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
// 使用扩展运算符合并数组
let mergedArray = [...array1, ...array2];
// 删除合并后数组的第二个元素
mergedArray.splice(1, 1); // 从索引1开始删除1个元素
console.log(mergedArray); // 输出: [1, 3, 4, 5, 6]18.js写方法消除字符串中的重复内容，比如“aabbbbbcccd”，消除后为“abcd”
Javascript中字符串去重的方法总结_js字符串去重-CSDN博客
function removeDuplicates(str) {
let result = '';
for (let char of str) {
// 如果当前字符不在结果字符串中，则将其添加到结果字符串
if (!result.includes(char)) {
result += char;
}
}
return result;
}
// 示例
console.log(removeDuplicates("aabbbbbcccd")); // 输出 "abcd"function removeDuplicatesOptimized(str) {
let seen = new Set(); // 创建一个集合来存储已经看到的字符
let result = '';
for (let char of str) {
// 如果集合中没有这个字符，则添加到集合和结果字符串中
if (!seen.has(char)) {
seen.add(char);
result += char;
}
}
return result;
}
// 示例
console.log(removeDuplicatesOptimized("aabbbbbcccd")); // 输出 "abcd"
