0%

发表于 更新于
  • Math.floor()    //向下取整

发表于 更新于

首先判断两个数组是否相等时不能直接使用 == 

1
2
3
var array1 = []
var array2 = []
console.log(array1 == array2)    //输出false

对于对象来说，== 比较的是两个对象是否为同一个对象。数组属于对象类型，尽管数组元素是相同的，但这两个数组属于不同的对象，所以 == 比较为false.

四种比较方式

  1. 数组简单比较
    如果数组里的元素是标量，非 object 类型，可以使用 == 比较数组里的元素： 

    1
    2
    3
    scalarArrayEquals(array1,array2) {
      return array1.length==array2.length && array1.every(function(v,i) { return v === array2[i]})
    }

  2. 嵌套数组比较
    如果数组是多层嵌套，数组的基本元素也为标量。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    arrayEquals(array1, array2) {
        if(!(array1 || array1)) {
          return false
        }
        // 先比较长度 
        if (array1.length != array2.length)
            return false

        for (var i = 0, l=array1.length; i < l; i++) {
            // 检查是否为内嵌数组
            if (array1[i] instanceof Array && array2[i] instanceof Array) {
                // 递归比较数组
                if (!arrayEquals(array1[i],array2[i]))
                    return false   
            } else if (this[i] != array[i]) { //标量比较 
                return false
            }           
        }       
        return true
    }

  3. Lodash 或 Underscore 比较数组（推荐）
    如果数组的元素可能为 object，可以考虑使用 Lodash 或者 Underscore。它们已经实现了对象的深度比较，包括数组。
    使用 Lodash 或 Underscore 比较数组或对象很简单： 

    1
    2
    _.isEqual(array1, array2)   //相等返回true，否则返回false
    _.isEqual(object1, object2) //

  4. 转为字符串比较数组
    除了上面的比较方法外，还可以把数组转换为字符串后，比较字符串。 

    array1.toString() === array2.toString()

    或者 

    JSON.stringify(array1) === JSON.stringify(array2)

    但相对上面几种方式，转换为字符串后再比较的性能是比较差的。其中以 JSON 转换为字符串的性能最差。

发表于 更新于
1. 复制数组
1
arr.slice(0)
2. 数组长度
1
arr.length
3. 清空数组
1
arr.length = 0
4. 将“类似数组的对象”变成真正的数组
1
var arr = Array.protoytpe.slice.call(arrLike)
5. 在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度
1
2
3
var arr = [1, 2, 3]
arr.push(1)  // return 4 | [1, 2, 3, 4]
arr.push(1, 2)  // return 6 | [1, 2, 3, 4, 1, 2]
6. 删除数组的最后一个元素，并返回该元素
1
2
var arr = [1, 2, 3]
arr.pop()  // return 3
7. 判断是否为数组
1
2
3
4
5
// 1. instanceof 运算符
var arr = []
console.log(arr instanceof Array)  // return true
// 2. Array.isArray() 方法
console.log(Array.isArray(arr))  // return true
8. 在数组的开头添加一个或多个元素，并返回添加新元素后的数组长度
1
2
3
var arr = [1, 2, 3]
arr.unshift(1)  // return 4 | [1, 1, 2, 3]
arr.unshift(1, 2)  // return 6 | [1, 2, 1, 1, 2, 3]
9. 删除数组的第一个元素，并返回该元素
1
2
var arr = [1, 2, 3]
arr.shift()  // return 1
10. 翻转数组
1
2
var arr = [1, 2, 3]
arr.reverse()  // return [3, 2, 1]
11. 数组排序
1
2
3
4
5
6
7
8
9
10
// 1. 升序
var arr = [1, 3, 2, 6, 5]
// return [1, 2, 3, 5, 6]
arr.sort(function(a, b) {
    return a - b
})
//return [6, 5, 3, 2, 1]
arr.sort(function(a, b) {
    return b - a
})
12. 数组索引
1
2
3
4
5
6
7
var arr = [1, 2, 3, 2]
// 1. 查找数组中给定元素的第一个索引 如果存在返回索引号，否则返回 -1
arr.indexOf(2)  // return 1
// 2. 查找数组中给定元素的最后一个索引 如果存在返回索引号，否则返回 -1
arr.lastIndexOf(2)  // return 3
// indexOf lastIndexOf 可选参数 查找起始位置
arr.indexOf(2, 2)  // return 3
13. 数组去重
1
2
3
4
5
6
7
8
9
function unique(arr) {
    var newArr = []
    for(var i = 0; i < arr.length; i++) {
        if(newArr.indexOf(arr[i]) === -1) {
            newArr.push(arr[i])
        }
    }
    return newArr
}
14. 数组转换字符串
1
2
3
4
5
6
7
var arr = ['h', 'l', 'l']
// 1. toString() 方法
arr.toString()  // return 'h,l,l'
// 2. join() 方法
arr.join()  // return 'h,l,l'
arr.join('')  // return 'hll'
arr.join('|')  // return 'h|l|l'
15. 连接两个数组
1
2
var arr = [1, 2, 3, 4]
arr.concat(['hll'])  // reutrn [1, 2, 3, 4, 'hll']
16. 数组截取
1
2
3
var arr = ['h', 'l', 'l', 'c']
// slice(begin, end) 左开右闭 返回截取的新数组
arr.slice(0, 2)  // return ['h', 'l']
17. 数组删除
1
2
3
var arr = ['h', 'l', 'l', 'c']
// splice(从第几个开始, 要删除的个数) 返回被删除的元素 覆盖原数组
arr.splice(0, 2)  // return ['h', 'l']

发表于 更新于
1. 复制数组
1
arr.slice(0)
2. 数组长度
1
arr.length
3. 清空数组
1
arr.length = 0
4. 将“类似数组的对象”变成真正的数组
1
var arr = Array.protoytpe.slice.call(arrLike)
5. 在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度
1
2
arr.push(1)  // return 1
arr.push('xx')  // return 2
6. 删除数组的最后一个元素，并返回该元素
1
2
var arr = [1, 2, 3]
arr.pop()  // return 3

发表于 更新于

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var stepCondition = function(current, end, step) {
    if (step > 0) {
        return current < end
        /* 下面两种是经常能看到的反例
            if(current < end) {
                return true
            } else {
                return false
            }
            return current < end ? true : false */
    } else {
        return current > end
    }
}

/*  start end step 都是数字
    要求支持负数 step
    使用 while 循环
    返回一个 array
    假设 start=1, end=5, step=1 返回数据如下
    [1, 2, 3, 4]
    假设 start=6, end=0, step=-1 返回数据如下
    [6, 5, 4, 3, 2, 1]  */
var range3 = function(start, end, step=1) {
    
    var l = []
    var i = start
    // 简单的办法是根据 step 写不同的条件
    // 我这里用了一个辅助函数
    while(stepCondition(i, end, step)) {
        l.push(i)
        i += step
    }
    return l
}

发表于 更新于
  1. 关闭已开启的 Lantern；
  2. 按 win + r 输入 cmd 进入命令提示符，然后输入 ipconfig 查看并记下当前网络地址；
  3. 在桌面找到 Lantern 图标，右键属性，在目标栏后先键入一个空格，然后加上参数 -addr=地址:8787 (把汉字处替换为你当前网络ip地址)；
  4. 重新打开 Lantern，允许通过防火墙；
  5. 手机连接该网络并手动设置代理，服务器为你当前网络地址，端口为 8787。

发表于 更新于

维基百科：双拼是汉语拼音输入法的一种编码方案。相对于全拼而言，使用双拼输入汉字时只需输入一个代表声母的字母，一个代表韵母的字母，就可以打出任意一个中文单字了。

上图是一张自然码双拼字码表。