数组扁平化
将多维数组转化为单层数组
ES语法
- flat(参数)
- 想让几层数组扁平化就填几,也可以写Infinity,全部扁平化
var arr = [1,[5,9,[5,6,1]],1,5,[4,8,9,[4,5,6,[4,[5]]]],5]
console.log(arr);
// ES6语法 falt(参数) 参数需要扁平化几层就填几,可以写Infinity
var arr1 = arr.flat(Infinity);
console.log(arr1);
数组先转字符串再转数组
// 数组先转字符串再转数组
var arr2 = arr.toString().split(",").map(function(r){
return Number(r)
});
console.log(arr2);
数组转JSON字符串,保留原数据格式
// 数组转换成json字符串,再替换掉[]
var arr3 = JSON.stringify(arr).replace(/(\[|\])/g,"").split(",").map(function(r){
return Number(r)
});
console.log(arr3);
封装函数,利用some循环查找是否包含数组
// 封装一个函数利用some检测是否有数组
function getArr (arr){
while(arr.some(function(r){
return Array.isArray(r)
})){
arr=[].concat(...arr);
console.log(arr);
}
return arr;
}
var arr4 = getArr(arr);
console.log(arr4);
字符串
模板字符串
用 `` 包起来,可以解析变量、方法,变量或者方法要用${}包起来
// 模板字符串 ``
var obj = {
name:"彭忠杰",
age:18,
idendity:"马跃磊儿子",
}
var str = `我叫${obj.name}我是${obj.idendity}`;
console.log(str);
function intro () {
return "我叫彭忠杰,我有一个好爸爸"
}
var str2 = `这是我的自我介绍:${intro()}`;
console.log(str2);
字符串的方法
- startswith(string) 查看参数字符串是否在原字符串的开头,返回true/false
- endswith(string) 查看参数字符串是否在原字符串的末尾,返回true/false
- repeat(n) 字符串重复n次
// startsWith 表示参数数字是否在原字符串的开头
var str3 = "hello world!";
console.log(str3.startsWith("he")); // true
console.log(str3.startsWith("e")); // false
// endswidth 表示参数数字是否在原字符串的末尾
console.log(str3.endsWith("!")); // true
console.log(str3.endsWith("h")); // false
console.log("最是人间留不住".repeat(2));
let、const
let 声明变量,块级作用域,变量不提升
特点:
- 防止变量泄露
- 不存在变量提升处理语法问题
- 暂时性死区
- 不能重复声明
暂时性死区是指,一个变量在用let或者const声明变量之前赋值,就会报错,那么在let和const声明前面的区域,就是这个变量的死区
const 声明常量,值不可以修改,块级作用域,声明函数,内容地址不能修改,必须赋值。
var 函数作用域,变量提升,值可以修改,可以重复声明,可以不赋值
let 块级作用域,变量不提升,值可以修改,同一块级下不可重复声明,可以不赋值
const 块级作用域,变量不提升,值不可以修改,同一块级下不可重复声明,必须赋值
let arr = [8, 7, 6, 5]
// let
// for (let i = 0; i < arr.length; i++) {
// console.log(i);
// }
// console.log(i); // i is not defined
// for(var i = 0 ; i < arr.length ; i ++){
// console.log(i);
// }
// console.log(i); // 4
// 暂时性死区
// for (let i = 0; i < 4; i++) {
// setTimeout(() => {
// console.log(i); // 0 1 2 3
// });
// }
// for (var i = 0; i < 4; i++) {
// setTimeout(() => {
// console.log(i); // 4 4 4 4
// });
// }
// const 常量
const chang= 123;
// chang = 456 ; // 报错
console.log(chang);
解构赋值
ES6允许从对象/数组,按照对应的位置进行赋值
let [a,b] = [2,3]; // => let a=2,b=3;
console.log(a,b);
let[c,d,e] = [5,6]// 如果数据不过,就是undefined
console.log(c,d,e); // 5 6 undefined
还可以剩余参数,剩余参数要写在后面
// 剩余参数 ...
let [f,...g] = [1,2,3,5,4]; // ...g就是接收多余的参数
console.log(f,g); // 1 [2, 3, 5, 4]
function fn(e){
console.log(e);
}
fn(1,2,3); // 只输出1
function fn2(...e){
console.log(e);
}
fn2(1,2,3); // [1, 2, 3]
对于对象,则根据key值返回对应的value值
// 对于对象,对应值为key返回的value
let obj = {
name:"彭忠杰",
age:18,
height:200
}
let{age,height,name} = obj;
console.log(age,height,name);
另外可用于交换值
// 交换值
let i = 1 , j = 2 ;
console.log(i,j); // 1 2
[i,j] = [j,i]
console.log(i,j);
闭包函数
- 闭包就是让外部能够获取函数内部的变量
- 作用
- 读取函数内部的变量,使这些变量保存在内存中,不会在外部函数执行完以后就销毁 - 闭包的缺点:
- 内存消耗大,IE中会导致内存泄漏,父级函数的变量尽量不要修改
另外注意:
js的作用域是静态的,函数的作用域是定义函数时的作用域,而不是调用函数时的作用域
function fn3(){
let a=10;
return (function(){
return a
})()
}
var aa = fn3();
console.log(aa); // 10
var a = 8 ;
function getA(){
console.log(a);
}
getA(); // 8 这时函数的作用域是全局的
function fn () {
var a = 9 ;
return getA()
}
fn(); // 8 因为getA的作用域是全局的,读取不了fn内部的变量