引用类型是一种数据结构，它被称为类，但是这种称呼并不妥当，不具备传统的面向对象语言所支持的类和接口等基本结构。
Array.isArray()最终确定某个值到底是不是数组。
var color = [‘red‘,‘blue‘,‘green‘]; console.log(color.toString());//red,blue,green console.log(color.valueOf());//[ ‘red‘, ‘blue‘, ‘green‘ ] console.log(color.toLocaleString());//red,blue,green
数组:栈方法
var colors = new Array();
var count = colors.push("red","greend");
console.log(count);//2
count = colors.push("blcak");
console.log(count);//3
var item = colors.pop();
console.log(item);//black
数组中的最大值
var arr = [0,1,2,3,4,8,5,1,4,1,1,111,111]; var max = Math.max(0,1,2,3,4,8,5,1,4,1,1,111,111); var min = Math.min(0,1,2,3,4,8,5,1,4,1,1,111,111); console.log(max); console.log(min);
var value = [0,2,11,8,55,13]; var max = Math.max.apply(Math,value); console.log(max);//55
数组拼接
var a = [1,2]; var b = [3,4]; console.log(a.concat(b));//[ 1, 2, 3, 4 ]
数组indexOf，找不到的话返回-1
var numbers = [1,12,3,4,5,8,6,8]; console.log(numbers.indexOf(8)); console.log(numbers.lastIndexOf(8)); console.log(numbers.lastIndexOf(9));
迭代方法
var numbers = [1,2,3,4,5,6,7,6,5,4,3,2,1];
var every = numbers.every(function(item,index,array){
return (item > 2)
})
console.log(every);//false
var some = numbers.some(function(item,index,array){
/*console.log(item);
console.log(index);
console.log(array);*/
return (item > 2)
})
console.log(some);//true
var filterR = numbers.filter(function(item,index,arr){
return (item > 2)
})
console.log(filterR);//[ 3, 4, 5, 6, 7, 6, 5, 4, 3 ]
var mapR = numbers.map(function(item,index,arr){
return (item*2 )
})
console.log(mapR);//[ 2, 4, 6, 8, 10, 12, 14, 12, 10, 8, 6, 4, 2 ]
var forEachR = numbers.forEach(function(item,index,arr){
})
console.log(forEachR);//undefined
归并方法
var values = [0,1,2,3,4,5,6];
var sum = values.reduce(function(a,b,c,d){
return a+b
})
console.log(sum);//21
数组排序
var values = [0,5,10,7,8,2,3];
console.log(values.reverse());
/*function compare(a,b){//因为直接用sort会直接用字符串 也可以调换顺序改变升序降序
if (a<b) {
return -1
}else if (a>b){
return 1;
}else{
return 0
}
}*/
function compare(a,b){
return a-b
}
console.log(values.sort(compare));
slice
var colors = ["red","blue","green","black","arr"]; var colors2 = colors.slice(1); var colors3 = colors.slice(1,4); console.log(colors2); console.log(colors3);
spilce
var colors = [‘red‘,‘green‘,‘blue‘,‘blcak‘,‘arr‘]; var removed = colors.splice(0,1); console.log(colors);//[ ‘green‘, ‘blue‘, ‘blcak‘, ‘arr‘ ] console.log(removed);//[ ‘red‘ ] // 2 removed = colors.splice(1,0,‘yellow‘,‘orange‘); console.log(colors);//[ ‘green‘, ‘yellow‘, ‘orange‘, ‘blue‘, ‘blcak‘, ‘arr‘ ] console.log(removed);//[ ] // 3 removed = colors.splice(1,1,"red","purple"); console.log(colors);//[ ‘green‘, ‘red‘, ‘purple‘, ‘orange‘, ‘blue‘, ‘blcak‘, ‘arr‘ ] console.log(removed);//[ ‘yellow‘ ]
字符串操作方法 http://www.cnblogs.com/littledu/archive/2011/04/18/2019475.html 区别
var str = "hello word";
console.log(str.charAt(1));//e
console.log(str.charCodeAt(1));//字符编码101
console.log(str.concat("nihao"));//hello wordnihao
console.log(str.slice(3));//lo word没有指定第二个参数就到结束
console.log(str.slice(3,7));//lo w 到第七个字符
//lo wordstart 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
//end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
console.log(str.substring(3,7));//lo w substring()总是以较小的参数作为start，较大的作为end，而不会在意参数的位置
console.log(str.substring(3))//lo word
//slice可以对数组操作，substring不行。。
console.log(str.substr(3,7));//lo word三开始7指定返回字符
console.log(str.indexOf("o"));//返回位置，没有就返回-1 4
console.log(str.lastIndexOf("o"));//返回位置，没有就返回-1 7;
var str2 = " hell o word ";
console.log(str2.trim());//删除最前面和最后面的空格
console.log(String.fromCharCode(104,101,108,108,111));
Date日期操作
var someDate = new Date(Date.parse("2011/11/11"));
console.log(someDate);//2011-11-10T16:00:00.000Z
var oldTime = (new Date("2011-11-11")).getTime(); //得到毫秒数
var newTime = new Date(oldTime); //就得到普通的时间了
console.log(oldTime);//1321013410000
console.log(newTime);//2011-11-11T12:10:10.000Z
var start = Date.now(); dosomething(); var stop = Date.now(); result = strat - stop
函数内部属性 arguments和this
function outer(){//更松散的耦合
inner();
}
function inner(){
console.log(inner.caller);//[Function: outer]//指向caller
}
outer()
arguments.callee.caller
function outer(){//更松散的耦合
inner();
}
function inner(){
console.log(arguments.callee.caller);//[Function: outer]
}
outer()
函数的属性和方法
每个函数都包含两个属性:length和prototype，length表示函数希望接受的命名参数的个数
prototype:
无法枚举，所以无法使用for-in；
每个函数包含两个非继承而来的方法：apply()和call();
apply()方法接受两个参数:一个是运行函数的作用域，另一个是参数数组，第二个可以是array实例
function sum(num1,num2){
return num1+num2
}
function callSum1(num1,num2){
return sum.apply(this,arguments)
}
function callSum2(num1,num2){
return sum.apply(this,[num1,num2])
};
console.log(callSum1(10,10));//20
console.log(callSum2(10,10));//20
call()方法与apply()方法的作用相同，它们的区别仅次于接受参数的方式不同，对于call()方法而言，第一个参数是this值没有变化，变化的是其余参数都直接传给函数，换句话说，在使用call方法时，传递给函数的参数必须逐个列举出来
function sum(num1,num2){
return num1+num2
}
function callSum1(num1,num2){
return sum.call(this,num1,num2)
}
console.log(callSum1(10,10));//20
如果打算直接传入arguments对象，或者函数中先接收到的也是一个数组，那么使用apply()方法更方便，否则选择call()方法更合适。（在不给函数传递参数的情况下，使用哪个都无所谓）
传递参数并非call(),apply()真正用武之地，它们真正强大的地方是能够扩充函数赖以生存的作用域。
window.color = "red";
var o = {color:"blue"};
function sayColor(){
console.log(this.color);
}
sayColor()//red;
sayColor.call(this)//red
sayColor.call(window)//red
sayColor.call(o)//bule
使用call()(或者apply())方法来扩充作用域最大的好处是对象不需要与方法有任何的耦合关系
ES5中还有bind()方法
window.color ="red";
var o = {color:"buld"};
function sayColor(){
console.log(this.color);
}
var objSayColor = sayColor.bind(o);
objSayColor()//blue
引用类型与基本包装类型的主要区别就是对象的生存期。
Number类型
var num = 10; console.log(num.toString());//10 console.log(num.toString(2));//1010 console.log(num.toString(8)); console.log(num.toString(10)); console.log(num.toString(16)); console.log(num.toFixed(3));// 小数点位数10.000 console.log(num.toExponential(10));//1.0000000000e+1 console.log(num.toPrecision(3));//精密的
eval()方法 ：
在eval("var msg=‘hello‘");
alert(msg)//"hello world"
在eval()中创建的任何变量和函数都不会被提升，在严格模式下，访问不到eval()中创建的任何变量和函数，因此前面两个例子都会导致错误
时间： 2024-10-30 02:05:54