js（3）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
              var str='asdjdfskjksjdkkf';
            var json={}
            for(var i=0;i<str.length;i++){
                if(!json[str.charAt(i)]){
                    json[str.charAt(i)]=1
                }else{
                    json[str.charAt(i)]++
                }
            }
            var iMax=0;
            var ildex='';
            for(var i in json){
                if(json[i]>iMax){
                    iMAx=json[i];
                    ilndex=i;
                }
            }
            console.log('出现次数最多的是:'+iIndex+'出现'+iMax+'次')

1
2
3
4
5
            
字符串反转，如将 '12345678' 变成 '87654321'
            var str='12345678'
            str=str.split('').reverse().join('')
            console.log(str);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
将数字 12345678 转化成 RMB形式 如： 12,345,678

/思路：先将数字转为字符， str= str + '' ;

//利用反转函数，每三位字符加一个 ','最后一位不加； re()是自定义的反转函数，最后再反转回去！

function re(str) {
    str += '';
    return str.split("").reverse().join("");
}

function toRMB(num) {
	var tmp='';
    for (var  i  =  1;  i  <=  re(num).length;  i++) {    
        tmp  +=  re(num)[i  -  1];    
        if (i  %  3  ==  0  &&  i  !=  re(num).length) {        
            tmp  +=  ',';    
        }
    }
    return re(tmp);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
去掉数组中重复的数字
var arr=[1,2,3,3,4,4,5,5,6,1,9,3,25,4];
Array.prototype.unique2 = function()
{
	var n = []; //一个新的临时数组
	for(var i = 0; i < this.length; i++) //遍历当前数组
	{
		//如果当前数组的第i已经保存进了临时数组，那么跳过，
		//否则把当前项push到临时数组里面
		if (n.indexOf(this[i]) == -1) n.push(this[i]);
	}
	return n;
}
var newArr2=arr.unique2(arr);
alert(newArr2); //输出1,2,3,4,5,6,9,25

1
2
3
4
5
6
7
8
9
10
11
阶乘函数
//原型方法
Number.prototype.N = function(){
    var re = 1;
    for(var i = 1; i <= this; i++){
        re *= i;
    }
    return re;
}
var num = 5;
alert(num.N());

1
2
3
4
window.location.search() 返回的是什么？

http://localhost:8080/xxx?ver=1.0&id=123
返回值：?ver=1.0&id=timlq 也就是问号后面的部分

1
2
window.location.reload() 作用？
刷新当前页面。

1
2
3
4
5
6
7
8
9
10
11
function f1(){
    var tmp = 1;
    this.x = 3;
    console.log(tmp);    //A
    console.log(this.x)；     //B
}
var obj = new f1(); //1
console.log(obj.x)     //2
console.log(f1());        //3

这道题让我重新认识了对象和函数，首先看代码（1），这里实例话化了 f1这个类。相当于执行了 f1函数。所以这个时候 A 会输出 1， 而 B 这个时候的 this 代表的是 实例化的当前对象 obj B 输出 3.。 代码（2）毋庸置疑会输出 3， 重点 代码（3）首先这里将不再是一个类，它只是一个函数。那么 A输出 1， B呢？这里的this 代表的其实就是window对象，那么this.x 就是一个全局变量 相当于在外部 的一个全局变量。所以 B 输出 3。最后代码由于f没有返回值那么一个函数如果没返回值的话，将会返回 underfined ，所以答案就是 ： 1， 3， 3， 1， 3， underfined 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
下面输出多少？
var o1 = new Object();
var o2 = o1;
o2.name = "CSSer";
console.log(o1.name);





如果不看答案，你回答真确了的话，那么说明你对javascript的数据类型了解的还是比较清楚了。js中有两种数据类型，
分别是：基本数据类型和引用数据类型（object Array）。
对于保存基本类型值的变量，变量是按值访问的，因为我们操作的是变量实际保存的值。
对于保存引用类型值的变量，变量是按引用访问的，我们操作的是变量值所引用（指向）的对象。答案就清楚了：  //CSSer;

1
2
3
4
5
6
7
8
9
10
11
12
function changeObjectProperty (o) {
    o.siteUrl = "http://www.csser.com/";
    o = new Object();
    o.siteUrl = "http://www.popcg.com/";
}
var CSSer = new Object();
changeObjectProperty(CSSer);
console.log(CSSer.siteUrl); // “http://www.csser.com/”

如果CSSer参数是按引用传递的，那么结果应该是"http://www.popcg.com/"，但实际结果却仍是"http://www.csser.com/"。事实是这样的：在函数内部修改了引用类型值的参数，该参数值的原始引用保持不变。我们可以把参数想象成局部变量，当参数被重写时，这个变量引用的就是一个局部变量，局部变量的生存期仅限于函数执行的过程中，函数执行完毕，局部变量即被销毁以释放内存。    
    （补充：内部环境可以通过作用域链访问所有的外部环境中的变量对象，但外部环境无法访问内部环境。每个环境都可以向上搜索作用域链，以查询变量和函数名，反之向下则不能。）

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
a输出多少？
var a = 6;
setTimeout(function () {    
    var a = 666;
    alert(a);      // 输出666，
}, 1000);
因为var a = 666;定义了局部变量a，并且赋值为666，根据变量作用域链，
全局变量处在作用域末端，优先访问了局部变量，从而覆盖了全局变量 




var a = 6;
setTimeout(function () {    
    alert(a);      // 输出undefined 
    var a = 666;
}, 1000);
因为var a = 666;定义了局部变量a，同样覆盖了全局变量，但是在alert(a);之前
a并未赋值，所以输出undefined。

var a = 6; 
setTimeout(function(){
    alert(a);
    var a = 66; 
}, 1000);
a = 666; 
alert(a); 
// 666, undefined;

记住： 异步处理，一切OK 声明提前 

1
2
3
4
5
6
7
8
function setN(obj){
    obj.name='屌丝';
    obj = new Object(); 
    obj.name = '腐女';
};
var per = new Object();
setN(per);
alert(per.name);  //屌丝 内部

1
2
3
4
5
精度问题: JS 精度不能精确到 0.1 所以  。。。。同时存在于值和差值中
var n = 0.3,m = 0.2, i = 0.2, j = 0.1;
alert((n - m) == (i - j)); //false
alert((n-m) == 0.1); //false
alert((i-j)==0.1); //true

1
2
3
4
5
6
加减运算

alert('5'+3); //53 string
alert('5'+'3'); //53 string
alert('5'-3); //2 number
alert('5'-'3'); //2 number

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
为什么不能定义1px左右的div容器？

IE6下这个问题是因为默认的行高造成的，解决的方法也有很多，例如：
overflow:hidden | zoom:0.08 | line-height:1px

结果是什么？

function foo(){
    foo.a = function(){alert(1)}; 
      this.a = function(){alert(2)};
    a = function(){alert(3)};
    var a = function(){alert(4)};
}; 
foo.prototype.a = function(){alert(5)};
foo.a = function(){alert(6)};
foo.a(); //6
var obj = new foo();
obj.a(); //2
foo.a(); //1

1
2
3
4
5
6
7
8
9
10
11
12
输出结果

var a = 5; 
function test(){
    a = 0; 
    alert(a); 
    alert(this.a); //没有定义 a这个属性
    var a; 
    alert(a)
}
test(); // 0, 5, 0
new test(); // 0, undefined, 0 //由于类它自身没有属性a， 所以是undefined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var bool = !!2; alert(bool)；//true;
双向非操作可以把字符串和数字转换为布尔值


匹配输入的字符：第一个必须是字母或下划线开头，长度5-20

var reg = /^[a-zA-Z_][a-zA-Z0-9_]{5,20}/,
            name1 = 'leipeng',
            name2 = '0leipeng',
            name3 = '你好leipeng',
            name4 = 'hi';
     
        alert(reg.test(name1));
        alert(reg.test(name2));
        alert(reg.test(name3));
        alert(reg.test(name4));

1
2
3
4
5
6
7
检测变量类型

function checkStr(str){
    return str =='string';
}

console.log(checkStr("aaa"));