一些代码
一些闭包代码:
<script>
function f() {
var a=[];
var i;
for(i=0;i<3;i++){
a[i]=(function (x) {
return function () {
return x;
}
})(i);
}
return a;
}
var test=f();
alert(test[0]());
alert(test[1]());
alert(test[2]());
</script>
结果:
0
1
2
这里换一种形式:
<script>
function f() {
function test(x) {
return function () {
return x;
}
}
var a=[];
var i;
for(i=0;i<3;i++){
a[i]=test(i);
}
return a;
}
var test=f();
alert(test[0]());
alert(test[1]());
alert(test[2]());
</script>
结果:
0
1
2
要注意的是:
对象扩展性的一些代码
<script>
var obj={};
//检测对象是否可以扩展
console.log(Object.isExtensible(obj));
var d=new Date();
console.log(Object.isExtensible(d));
obj.x=1;
console.log(obj.x);
//通过preventExtension()将对象变为不可扩展的
obj1=Object.preventExtensions(obj);
console.log(obj===obj1);//验证是否为原来的对象
console.log(Object.isExtensible(obj1));
obj1.y=2;
Object.defineProperty(obj1,'z',{value:1});//不能为一个不可扩展的对象赋值
</script>
结果:
对象封闭性的一些代码
<script>
var obj={
x:1,
y:2,
username:'king'
};
obj.age=12;
delete obj.x;
o=Object.seal(obj);//封闭对象obj
console.log(obj===o);
console.log(Object.isExtensible(o));
obj.y=55;
console.log(obj.y);
// Object.defineProperty(obj,'username',{
// get: function () {
// return 'this is test'//定义为访问器属性,但这是不行的
// }
// })
o.z=77;
console.log(o.z);
console.log(o.username);
delete o.username;
console.log(o.username);
// Object.defineProperties(obj,'username',{value:'queen'});
console.log(Object.isSealed(o))
console.log(o.username);
console.log(Object.getOwnPropertyDescriptor(obj,'username'));// obj username属性不可配置
</script>
结果:
冻结的一些代码
var obj={
prop:function () {
},
foo:'king'
};
obj.test='this is a test';
delete obj.prop;
var o=Object.freeze(obj);
console.log(obj===o);
console.log(Object.isFrozen(o));//检测是否冻结 冻结后任何操作都会失败
o.x=1;
console.log(o.x);
console.log(o.foo);
o.foo='queen';//修改失败
console.log(o.foo);
结果:
浅冻结
var obj1={
internal:{}
};
Object.freeze(obj1);
obj1.internal.x=1;
console.log(obj1.internal.x);//子对象依旧可以赋值 此为浅冻结
结果为1,所以要对子对象也进行冻结,这时候就需要个递归冻结
实现深度冻结的代码
var obj1={
internal:{}
};
Object.freeze(obj1);
obj1.internal.x=1;
console.log(obj1.internal.x);//子对象依旧可以赋值 此为浅冻结
function deepFreeze(obj) {
var prop,propKey;
Object.freeze(obj);
for(propKey in obj){
prop=obj[propKey];
if(!obj.hasOwnProperty(propKey)||!(typeof prop=='object')||Object.isFrozen(prop)){
continue;
}//如果它还有自己的属性 那么就是对象
deepFreeze(prop);//递归调用
}
}
var obj2={
internal:{}
};
deepFreeze(obj2);
obj2.internal.x=2;
console.log(obj2.internal.x);
深度冻结后obj2的子对象的值为undefined
需要注意:
- 默认对象是可扩展的,也就是非冻结的
- 一个不可扩展的对象同时也是一个冻结的对象
- 一个非空对象默认也是非冻结
- 一个不可扩展的对象,但是拥有一个可写但不可配置的属性,仍然是非冻结的
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script>
//默认对象是可扩展的,也就是非冻结的
console.log(Object.isFrozen({}));
//一个不可扩展的对象同时也是一个冻结的对象
var obj=Object.preventExtensions({});
console.log(Object.isFrozen(obj));
//一个非空对象默认也是非冻结
var obj1={x:1};
console.log(Object.isFrozen(obj1));
Object.preventExtensions(obj1);//不可扩展不意味着冻结
console.log(Object.isFrozen(obj1));
delete obj1.x;
console.log(Object.isFrozen(obj1));//但删除x后就变成冻结的了
//一个不可扩展的对象,但是拥有一个可写但不可配置的属性,仍然是非冻结的
var obj2={x:2};
Object.preventExtensions(obj2);
Object.defineProperty(obj2,'x',{writable:false});
console.log(Object.isFrozen(obj2));//此时依旧是非冻结的
//将x变为不可配置
Object.defineProperty(obj1,'x',{configurable:false});
console.log(Object.isFrozen(obj2));//此时变为一个冻结的对象了
</script>
</body>
</html>
结果:
- 如果一个不可扩展的对象,拥有一个不可配置但可写的属性,是非冻结的
- 如果一个不可扩展的对象拥有一个访问器属性,它也是非冻结的
//如果一个不可扩展的对象,拥有一个不可配置但可写的属性,是非冻结的
var obj3={x:1};
Object.preventExtensions(obj3);
Object.defineProperty(obj3,'x',{configurable:false});
console.log(Object.isFrozen(obj3));//此时非冻结
//将x变为不可写
Object.defineProperty(obj3,'x',{writable:false});
console.log(Object.isFrozen(obj3));//此时冻结
//如果一个不可扩展的对象拥有一个访问器属性,它也是非冻结的
var obj4={
get test(){
return 1;
}
};
Object.preventExtensions(obj4);
console.log(Object.isFrozen(obj4));//非冻结的
Object.defineProperty(obj4,'test',{configurable:false});
console.log(Object.isFrozen(obj4));//当变为不可配置后 该对象冻结
结果:
冻结后:
<script>
var obj5={x:1};
Object.freeze(obj5);
console.log(Object.isFrozen(obj5));
console.log(Object.isSealed(obj5));
console.log(Object.isExtensible(obj5));
</script>
结果:
一些Object对象代码
<script>
var arr=['a','b','c'];
console.log(Object.keys(arr));
var obj={
0:'d',
1:'e',
2:'f'
};
console.log(Object.keys(obj));
var obj1=Object.create({},{
getFoo:{
value:function () {
return this.foo;
}
}
});
obj1.foo=123;
console.log(Object.keys(obj1));
//如果想获取一个对象的所有属性,包括不可枚举的,Object.getOwnPropertyNames()
console.log(Object.getOwnPropertyNames(arr));
console.log(Object.getOwnPropertyNames(obj));
console.log(Object.getOwnPropertyNames(obj1));
</script>
<script>
var obj={get foo(){return 123;}};
console.log(Object.getOwnPropertyDescriptor(obj,'foo'));//得到obj对象 foo属性的描述;
obj={
name:'king',
age:12
};
console.log(Object.getOwnPropertyDescriptor(obj,'name'));
obj={};
Object.defineProperty(obj,'test',{
value:'this',
writable:false,
enumerable:false,
configurable:true
});
console.log(Object.getOwnPropertyDescriptor(obj,'test'));//按照我们定义的那样返回
var obj1={x:1};
var obj2=Object.create(obj1);
console.log(Object.getOwnPropertyDescriptor(obj2,'x'));
console.log(Object.getPrototypeOf(obj2)==obj1);
</script>
结果:
constructor
<script>
//constructor
var obj3=new Object;
console.log(obj3.constructor==Object);
var arr1=new Array;
console.log(obj3.constructor==Array);
var n=new Number(324);
console.log(n.constructor==Number);
function Test() {
}
var f=new Test();
console.log(f.constructor);
</script>
结果:
String对象的一些代码
<script>
var str='king';
var strObj= new String('king');
console.log(typeof strObj);
console.log(strObj[0]);
console.log(strObj.length);
console.log(strObj.valueOf());
console.log(strObj.toString());
console.log("mai"[0]);
console.log("heeeeee".length);
var str=String('1234');//这里使用的是函数
str=String(true);
str=String({x:1});
str=String(null);
console.log(str);
var str='king';
//charAt根据下表返回指定的字符
console.log(str.charAt(0));//取第几个字符
console.log(str.charAt(10));//若不存在返回空
//charCodeAt返回指定字符的ASCII码值
var str='abcdef';
console.log(str.charCodeAt(0));
console.log(str.charCodeAt(110));
console.log(str.charCodeAt(-10));
</script>
结果:
<script>
//fromCharCode()根据指定的ASCII放回对应的字符
console.log(String.fromCharCode(97));
console.log(String.fromCharCode(65,66,67));
//concat()连接字符串
var str='hello';
console.log(str.concat('world'));
console.log(str.concat('world','!'));
//字符串搜索相关
var str='this is a test';
console.log(str.indexOf('t'));//首次出现的位置
console.log(str.indexOf('is'));
console.log(str.indexOf('Is'));//区分大小写
console.log(str.indexOf('i'));//2
console.log(str.indexOf('i',3));//从第三个位置开始搜索 5
//通过indexOf可以统计一个字符在指定字符串中出现的次数
var str='sssdwefegrgdnkfdfdjig';
var count=0;
var pos=str.indexOf('s');
while(pos!=-1){
count++;
pos=str.indexOf('s',pos+1);
}
console.log(count);//3
//lastIndexOf():最后一次出现的位置
var str='this is a test';
console.log(str.lastIndexOf('is'));// 5
</script>
//比较两个字符串
console.log('a'.localeCompare('z'));//-1
console.log('z'.localeCompare('a'));//1
console.log('V'.localeCompare('A'));//1
console.log('a'.localeCompare('a'));//0
//字符串截至到正则表达式以前
function对象的一些代码
<script>
function Test() {}
console.log(Test.constructor);
function Test1(x,y,z) {
return x+y+z;
}
console.log(Test1.length);//返回参数个数
function A() {
return A.caller;//谁调用A函数就返回谁
}
function B() {
return A();
}
console.log(B());
console.log(A());//没有函数调用它 所以是null
function Test2() {
return arguments;//返回包含参数的数组
}
console.log(Test2(1,2,3,4,5,6,'a',7));
</script>
结果:
//callee属性,这个属性引用的是当前被调用的函数对象
function f() {
return arguments.callee;
}
console.log(f());
(
function (count) {
if(count<=3){
alert(count);
arguments.callee(++count);
}
}
)(0);//完成匿名函数的返回调用
结果:
依次弹出0,1,2,3
<script>
function f1(a,b,c) {
return a+b+c;
}
console.log(f1.toString());
console.log(f1.valueOf());
var obj={
name:'king',
say:function (somebody) {
return 'Hello '+somebody+' this '+this.name;
}
};
console.log(obj.say('queen'));
var obj1={
name:'maizi'
};
console.log(obj.say.call(obj1,'js')); //调用当前function对象,可同时改变函数内this指针引用
//函数参数一个个分别传入
var obj2={
calc:function (x,y,z) {
return x+y+z;
}
};
console.log(obj2.calc.call(null,1,2,3));
console.log(obj2.calc.apply({},[ 3,4,5]));//调用当前function对象,可同时改变函数内this指针引用
//函数参数以数组或者arguments方式传入
</script>
结果:
Math对象的一些代码
<script>
console.log(Math.E);
console.log(Math.PI);
console.log(Math.abs(-12));
console.log(Math.ceil(12.3));//取整
console.log(Math.floor(13.8));//去掉小数部分
console.log(Math.round(1234.5566,2));//四舍五入 保留2位小数
console.log(Math.pow(2,3));
console.log(Math.sqrt(4));
console.log(Math.random());
console.log(Math.max(1234,333333,222222));
console.log(Math.min(-233,222,1122,33));
</script>