function 基础运用
sort排序，此处列子为a-b为升序，b-a为降序
let arr = [1,564,46,12,4,-455,];
console.log(arr.sort(function(a,b){
return b-a;
}))
同上，这是升序，-1和1替换一下则为降序
let arr = [1,654,13,41,3,4,5]
console.log(arr.sort(function(a,b){
if(a<b){
return -1;
}else if (a>b){
return 1 ;
}else{
return 0;
}
}))
infex 用法
let arr = ["h","e","l","l","o"];
console.log(arr.indexOf("l"))//此处是2；则为正数下标为2的位置；
console.log(arr.lastIndexOf("l"))//此处为3，为倒着找却正着数下标，在小标为3处；
console.log(arr.indexOf("z"))//找不到，则为-1；
let arr = ["1,","2","3"]
console.log(arr.indexOf(1));//此处为-1；是使用全等比较
// includes 用于查看数组是否包含某个元素，包含则返回true，否则返回false
let arr = ["1","2","3"]
console.log(arr.includes(2));//false
console.log(arr.includes("2"));//true
console.log(arr.includes(7));//false
// indexof去重
let str = [];
let arr = [1,2,6,1,2,3,1,5,2,3,1]
for(i=0;i<arr.length;i++){
if(str.indexOf(arr[i])==-1){
str.push(arr[i])
}
}console.log(str)
includes去重
let arr = [1,2,3,4,1,2,3,4,1,2,3]
let str = [];
for(i=0;i<arr.length;i++){
if(str.includes(arr[i])==false){
str.push(arr[i])
}
}
console.log(str);
集合
let s1 = new Set();
let s2 = new Set([1,2,3])
console.log(s1);
console.log(s2)
let s1 = new Set();
s1.add(1);
console.log(s1);
s1.add(2).add(3).add(4);
console.log(s1)
//也可直接传入数组
let s1 = new Set();
s1.add([1,2,3,4]);
console.log(s1)
// delete 删除某个元素，就算数组里面没有这个元素也不会报错
// 不可删除数组
let s1 = new Set([1,2,3]);
s1.delete(2);
console.log(s1);
s1.delete(4);
console.log(s1);
// clear一次性删除所有元素
let s1 = new Set([1,2,3,4])
s1.clear();
console.log(s1);
// for-of可以对集合进行遍历
let s = new Set([1,2,3,4,5,6]);
for(let i of s){
console.log(i);
}
//...元素，可以将集合转为数组
let s1 = new Set([1,2,3]);
console.log(s1);
let arr = [...s1];
console.log(arr);
//集合转数组去重
let arr = [1,2.,3,1,2,3,1,5,2,3,41,3,1];
let str = new Set(arr);
let s = [...str]
console.log(s)
//映射,先创建一个空的map对象，向里面添加元素用set，要从集合中获取信息用get
let a = new Map();
a.set("name","wangweijian");
a.set("age",21);
console.log(a)//Map { 'name' => 'wangweijian', 'age' => 21 }
console.log (a.get("name"))//wangweijian
// 在对象中，无法用对象作为对象属性的键名，但是在map映射中，却可以这样做，可以这么说
// 在map映射里面可以使用任意数据类型来作为键；
let a = new Map();
a.set({},"wangweijian");
a.set([1,2,3],21);
a.set([3554],21);
console.log(a);//Map { {} => 'wangweijian', [ 1, 2, 3 ] => 21, [ 3554 ] => 21 }
//映射转为数组
//map结构转为数组结构，比较快速的方法还是使用前面介绍过的扩展运算符...。
let arr = [["name","wangweijian"],["age",21]];
let w = new Map(arr);
console.log([...w.keys()]);//[ 'name', 'age' ]只显示键
console.log([...w.values()]);//[ 'wangweijian', 21 ]只显示值
console.log([...w.entries()]);//[ [ 'name', 'wangweijian' ], [ 'age', 21 ] ]显示键和值
console.log([...w])//[ [ 'name', 'wangweijian' ], [ 'age', 21 ] ]显示键和值
函数
function test(name){
console.log("Hello," + name);
}
test("wangweijian");//Hello,wangweijian
声明函数体
let test = function(name){
console.log("Hello,"+name);
}
test("wangweijian");//Hello,wangweijian
// arguments主要用途是用于保护传入到函数的实际参数
function text(x){
for(let i = 0;i<arguments.length;i++){
console.log(arguments[i])
}
}
text(1,2,3);
//1
//2
//3
// 伪数组对象，就是长得像数组的对象而已，但是并不是真的数组，我们可以证明这一点
function test (x){
arguments.push(100);//针对伪数组对象使用数组的方法
}
test(1,2,3)//TypeError: arguments.push is not a function
//它不是数组
//不定参数是在最后一个参数前面添加三个点，如果不是放在最后会直接报错，
// 如：function test(...a,b)，会将所有实参放入到一个数组里面，如：
function test(a,...b){
console.log(a);//1
console.log(b);//[2,3,4,5,6,7,8]
}
test(1,2,3,4,5,6,7,8)
//这里的不定参数就是一个真正的数组，可以使用数组的相关方法
function text(a,...b){
console.log(a);//1
console.log(b)//[ 2, 3, 4, 5, 6 ]
b.push(122);
console.log(b);//[ 2, 3, 4, 5, 6, 122 ]此处使用了数组的push加入了元素122
}
text(1,2,3,4,5,6)
// 默认参数ES6新增
function text(name="world"){
console.log("Hello,"+name);
}
text("wangweijian");//Hello,wangweijian
text()//Hello,world
//如果参数是一个数组，腰围这个数组设置默认值的话，写法稍微有些不同：如：
let fn = function([a=1,b=2]=[]){
console.log(a,b);
}
fn()//1 2
fn([3,4])//3 4
//包括后面我们要介绍的对象，也是可以设动默认值的，但是写法和上面类似
let fn = function({name="wangweijian",age=18}={}){
console.log(name,age);
}
fn();//wangweijian 18
fn({name:"song",age:20});//song 20
//length属性
let test = function(a,b,c){
console.log(arguments.length);//5实际参数的个数
console.log(arguments.callee.length);//3形式参数的个数
}
test(1,2,3,4,5)
Caller属性并不是arguments对象的，而是函数对象本身的属性，它显示了函数的调用者，如果函数是在全局执行环境中（浏览器）被调用，那么它的值为null，如果在另一个函数中被调用，它的值就是那个函数。
全局执行环境中被调用：
浏览器中：
<body>
<script>
let test = function(){
console.log(test.caller); }
test();//null
</script>
</body>
Node中
let test = function(){
console.log(test.caller);
}
test();//[Function]
被一个函数所调用：
let test = function(){
let test2 = function(){
console.log(test2.caller);
//[Function: test]
// ฎ因为这个函数的调用者是text函数
}
test2();
}
test();
Callee是arguments对象的一个属性，该属性是一个指针，指向拥有这个arguments对象的函数
let test = function(){
let test2 = function(){
let test3 = function(){
console.log(arguments.callee);
//[Function: test3]
}
Test3();
}
Text2();
}
Test();
callee的作用在于能够找到arguments对象所属的函数，不让函数的执行和函数名仅仅的关联在一起，我们来看下面这个例子
//计算阶乘的递归函数
let test = function(i){
if(i == 1){
return 1;
}else{
Return i * test(i-1);//这里就和函数名紧紧的关联了起来
}
}
console.log(test(3));
如果我们把上面的写法稍作修改，就可以看到上面写法的缺陷
//计算阶乘的递归函数
let test = function(i){
if(i == 1){
return 1;
}else{
return i * test(i-1);//这里就和函数名紧紧的关联起来
}
}
let test2 = test;//将阶乘函数赋值给text2
//改变test这个阶乘函数的函数体
test = function(){
console.log(" 我已经改变”};
}
console.log(test2(3));
//我已经改变了
//NaN
所以，这个时候就可以使用arguments对象的callee属性来降低这种关联
//计算阶乘的递归函数
let test = function(i){
if(i == 1){
return 1;
}else{
return i * arguments.callee(i-1)；//callee指向拥有arguments对象的函数
}
}
let test2 = test；//j将阶乘函数赋值给test2
//改变test这个阶乘函数的函数体
test = function(){
console.log(" 我已经改变了“);
}
console.log(test2(3))；//6
