前端基础（二十六）：引用类型相关-CFANZ编程社区

参数与局部变量
instanceof
with 延长作用域链
toString toLocaleString
push() 返回数组长度
indexOf() 要求被查找的元素与目标元素是完全相等的（===）
every some filter
reduce reduceRight
arguments.callee arguments.callee.caller
`new 类型()` 与 `类型本身` 区别
trim 去除字符串前后空格
localeCompare
冒泡排序法按字母排序

参数与局部变量

function setName(obj){
    obj.name = 'Lee';
    obj = {}
    obj.name = 'ABC';
}
let person = {}
setName(person);
console.log(person); // {name: "Lee"}

因为函数中 obj={} 等价于 obj=new Object()，相当于重新new了一个对象，所以不会被做为参数进行传值，obj这时在这里是一个局部变量

instanceof

用于检测构造函数的 prototype 属性是否出现在某个实例对象(Number/Object/Array···)的原型链上

// 均返回 true
class FunC{}
        
console.log(new Number() instanceof Number);

console.log(new String() instanceof String);

console.log(new Boolean() instanceof Boolean);

console.log({} instanceof Object);
console.log(new Object() instanceof Object);
console.log(Object instanceof Object);
console.log(Object() instanceof Object);

console.log(new Array() instanceof Array);
console.log(Array() instanceof Array);

console.log(new Function() instanceof Function);
console.log(Function() instanceof Function);

console.log(new FunC() instanceof FunC);

with 延长作用域链

function buildUrl(){
    var qs = '?name=Lee';
    with(location){
        var url = href + qs
    }
    return url;
}

console.log(buildUrl());    // http://127.0.0.1:5500/?name=Lee

toString toLocaleString

var p1 = {
    toString: function () {
        return 'p1A'
    },
    toLocaleString: function () {
        return 'p1B'
    },
    func: function () {
        return 'p1C'
    }
}
var p2 = {
    toString: function () {
        return 'p2A'
    },
    toLocaleString: function () {
        return 'p2B'
    },
    func: function () {
        return 'p2C'
    }
}
var arr = [p1, p2]
console.log(arr);
console.log(arr.toString()); // p1A,p2A
console.log(arr.toLocaleString()); // p1B,p2B
// console.log(arr.func()); // error Uncaught TypeError: arr.func is not a function

push() 返回数组长度

let arr = ['0'];
let count = arr.push('1', '2')
console.log(count); // 3
console.log(arr);   // ["0", "1", "2"]
count = arr.push('3')
console.log(count); // 4

indexOf() 要求被查找的元素与目标元素是完全相等的（===）

let obj = {name: 'Lee'}
let arr1 = ['1', {name: 'Lee'}]
let arr2 = ['1', obj]

console.log(arr1.indexOf(obj)); // -1
console.log(arr2.indexOf(obj)); // 1
console.log(arr1.indexOf({name: 'Lee'})); // -1
console.log(arr2.indexOf({name: 'Lee'})); // -1

console.log(obj === arr1[1])    // false
console.log(obj === arr2[1])    // true

every some filter

every

数组中的每个元素均执行给定函数进行判断，如果每项都符合函数中的规则则返回true，存在一项或多项不满足条件的则返回false

some

数组中的每个元素均执行给定函数进行判断，只要存在一项满足条件的则返回true，否则返回false

filter

数组中的每个元素均执行给定函数进行判断，返回满足条件的项，组成全新的数组

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

let isTwo = arr.every(item => item > 2)
console.log(isTwo);     // false

let isZero = arr.every(item => item > 0)
console.log(isZero);    // true

let isThree = arr.some(item => item > 3)
console.log(isThree);   // true

let isEleven = arr.some(item => item > 11)
console.log(isEleven);  // false

let newArr = arr.filter(item => item > 5)
console.log(newArr);    // [6, 7, 8, 9, 10]

reduce reduceRight

传值（开始从第二个元素开始）

前一个值当前值索引数组对象

arr.reverse().reduce 与arr.reduceRight 是存在区别的

var arr = [1, 2, 3, 4, 5]
var arr1 = arr.reduce((prev, cur, index, array) => {
    // 1 2 1 (5) [1, 2, 3, 4, 5]
    // 2 3 2 (5) [1, 2, 3, 4, 5]
    // 3 4 3 (5) [1, 2, 3, 4, 5]
    // 4 5 4 (5) [1, 2, 3, 4, 5]
    console.log(prev, cur, index, array);
    return cur
})
console.log(arr1); // 5

var arr = [1, 2, 3, 4, 5]
var arr2 = arr.reverse().reduce((prev, cur, index, array) => {
    // 5 4 1 (5) [5, 4, 3, 2, 1]
    // 4 3 2 (5) [5, 4, 3, 2, 1]
    // 3 2 3 (5) [5, 4, 3, 2, 1]
    // 2 1 4 (5) [5, 4, 3, 2, 1]
    console.log(prev, cur, index, array);
    return cur
})
console.log(arr2); // 1

var arr = [1, 2, 3, 4, 5]
var arr2 = arr.reduceRight((prev, cur, index, array) => {
    // 5 4 3 (5) [1, 2, 3, 4, 5]
    // 4 3 2 (5) [1, 2, 3, 4, 5]
    // 3 2 1 (5) [1, 2, 3, 4, 5]
    // 2 1 0 (5) [1, 2, 3, 4, 5]
    console.log(prev, cur, index, array);
    return cur
})
console.log(arr2); // 1

arguments.callee arguments.callee.caller

function func(){
    console.log(arguments.callee);          // func
    console.log(arguments.callee.caller);   // aaa
    console.log(func.caller);               // aaa
}
(function aaa(){
    func();
}())

`new 类型()` 与 `类型本身` 区别

let a = new Number(123)
console.log(a);         // Number {123}
let b = 123;
console.log(a === b);   // false

trim 去除字符串前后空格

let str = '     Hello Lee   '
let newStr = str.trim();
console.log(newStr);    // Hello Lee
console.log(str);       //      Hello Lee   

let newStrL = str.trimLeft();
console.log(newStrL);
console.log(str); 

let newStrR = str.trimRight();
console.log(newStrR);
console.log(str);

localeCompare

let s1 = 'Prosper';
let s2 = 'Lee';
console.log(s1.localeCompare(s2));  // 1
console.log(s2.localeCompare(s1));  // -1
console.log(s2.localeCompare(s2));  // 0

冒泡排序法按字母排序

var arr = ['Prosper', 'Lee', 'La', 'Lucy', 'Tom', 'Zero', 'Apple', 'Sun']

for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j].localeCompare(arr[j + 1]) === 1) {
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

console.log(arr); // ["Apple", "La", "Lee", "Lucy", "Prosper", "Sun", "Tom", "Zero"]