发表于 | 分类于
  1. instanceof 判断
1
2
var ary = [1,23,4];
console.log(ary instanceof Array)//true;

  1. 原型链方法

    1
    2
    3
    var ary = [1,23,4];
    console.log(ary.__proto__.constructor==Array);//true
    console.log(ary.constructor==Array)//true 这两段代码是一样的

  2. 通用的方法

    1
    2
    3
    4
    5
    var ary = [1,23,4];
    function isArray(o){
    return Object.prototype.toString.call(o)=='[object Array]';
    }
    console.log(isArray(ary));

发表于 | 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var cloneObj = function(obj){
    var str, newobj = obj.constructor === Array ? [] : {};
    if(typeof obj !== 'object'){
        return;
    } else if(window.JSON){
        str = JSON.stringify(obj), //系列化对象
        newobj = JSON.parse(str); //还原
    } else {
        for(var i in obj){
            newobj[i] = typeof obj[i] === 'object' ? 
            cloneObj(obj[i]) : obj[i]; 
        }
    }
    return newobj;
};

作者：青笠
链接：https://www.zhihu.com/question/23031215/answer/31944721
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

发表于 | 分类于

link

1. js正则表达式(.+)和(.+?)的区别

?疑问号让.+的搜索模式从贪婪模式变成惰性模式。

1
2
3
4
5
var str = 'aaa<div style="font-color:red;">123456</div>bbb'

<.+?>会匹配<div style="font-color:red;">

<.+>会匹配<div style="font-color:red;">123456</div>

要在浏览器测试结果的话，输入:

1
2
3
4
5
var str = 'aaa<div style="font-color:red;">123456</div>bbb'

str.match(/<.+?>/);

str.match(/<.+>/);

2. js的正则表达式的正则前瞻(?=)和非捕获性分组(?:)有什么区别?

(?=)会作为匹配校验，但不会出现在匹配结果字符串里面

(?:)会作为匹配校验，并出现在匹配结果字符里面，它跟(…)不同的地方在于，不作为子匹配返回。

1
2
3
4
var data = 'windows 98 is ok';
data.match(/windows (?=\d+)/);  // ["windows "]
data.match(/windows (?:\d+)/);  // ["windows 98"]
data.match(/windows (\d+)/);    // ["windows 98", "98"]

正则表达式中?=和?:和?!的理解

1
2
3
4
5
6
7
8
前瞻：
exp1(?=exp2) 查找exp2前面的exp1
后顾：
(?<=exp2)exp1 查找exp2后面的exp1
负前瞻：
exp1(?!exp2) 查找后面不是exp2的exp1
负后顾：
(?<!=exp2)exp1 查找前面不是exp2的exp1

链接

发表于 | 分类于

1.叠加

reduce方法有两个参数，第一个参数是一个callback，用于针对数组项的操作；第二个参数则是传入的初始值，这个初始值用于单个数组项的操作。需要注意的是，reduce方法返回值并不是数组，而是形如初始值的经过叠加处理后的操作。

1
2
3
4
5
6
7
8
9
var items = [10, 120, 1000];

// our reducer function
var reducer = function add(sumSoFar, item) { return sumSoFar + item; };

// do the job
var total = items.reduce(reducer, 0);

console.log(total); // 1130
1
2
3
4
5
6
7
8
9
10
11
12
var items = [10, 120, 1000];

// our reducer function
var reducer = function add(sumSoFar, item) {
  sumSoFar.sum = sumSoFar.sum + item;
  return sumSoFar; //注意要return 
};

// do the job
var total = items.reduce(reducer, {sum: 0});

console.log(total); // {sum:1130}

2.转化对象

1
2
3
4
5
6
7
8
9
10
11
12
const calendarTypeOptions = [
  { key: 'CN', display_name: 'China' },
  { key: 'US', display_name: 'USA' },
  { key: 'JP', display_name: 'Japan' },
  { key: 'EU', display_name: 'Eurozone' }
]

// arr to obj ,such as { CN : "China", US : "USA" }
const calendarTypeKeyValue = calendarTypeOptions.reduce((acc, cur) => {
  acc[cur.key] = cur.display_name
  return acc
}, {})

发表于 | 分类于

CSDN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<script>  
    function Person(){  
//      return 123;                         //值类型  
//      return "abcdef";                    //值类型  
//      return ["a","b"];                   //引用类型  
//      return {a:2};                       //引用类型  
         return function(){ console.log(1)};   //引用类型  
 }  
     Person.prototype.sayHello =  
           function() {  
             console.log('hello world');  
     };  
     console.log(new Person());  
  
//new Person()分别返回以下:  
//        1. Person{}  
//        2. Person{}  
//        3. ["a","b"];  
//        4. Object {a:2}  
//        5. function(){ console.log(1)};  
</script>

可以看出：在JavaScript构造函数中：如果return值类型，那么对构造函数没有影响，实例化对象返回空对象；如果return引用类型（数组，函数，对象），那么实例化对象就会返回该引用类型；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Super(a){  
    this.a=a;  
    return 123;  
}  
Super.prototype.sayHello=function(){  
     console.log("Hello")  
}  
function Super1(a){  
     this.a=a;  
     return {a:2};  
}  
Super1.prototype.sayHello=function(){  
     console.log("Hello")  
}  
console.log(new Super(1));      //返回Super{a:1},有原型方法sayHello  
console.log(new Super1(2));     //返回Object{a:2},没有原型方法sayHello