<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>第四章.html</title>
</head>
<body>
<script type="text/javascript">
var undefined = "sd"; //undefined是全局变量，和null不同，他不是一个关键字
var o = undefined + "5";
console.log(o);//undefined5
var _sz01 = [[1, 2, 3], [4, 5, 6]];//表达式是可以嵌套的
var _sz02 = [1, , , , 5]; //其中三个元素是 undefined
console.log(_sz02[3]); //undefined
var _dx = { //对象直接量也可以嵌套
a: {x: 1, y: 2},
b: {x: 1, y: 2}
};
console.log(_dx.a.x + _dx.b.y); //3
var _o = {x: 1, y: {z: 3}};
var _a = [o, 4, [5, 6]];
console.log(_o.x);
console.log(_o.y.z);
console.log(_o["x"]);
console.log(_a[1]);
console.log(_a[2]["1"]);
console.log(_a[0].x);
var _obj = new Object();
console.log(_obj instanceof Object); //instanceof 测试对象类 true
console.log("a" in _dx); //in 测试属性是否存在 true
console.log(~100); //-101 按位求反
//parseInt( String , 传参的位数 ) //2-16进制 转化成 10进制
console.log(parseInt("fa", 16));//250
console.log(1 + true); // 2 在 + 运算符中，会先把非字符串和数字的类型转化成数字，如果数字不成立则转化成字符串
console.log(false + true); // 1 false=0 true=1
console.log(1 + {}); // 1[object Object] {}对象不是数字 则转换成字符串 [object Object]
console.log(1 + undefined); // NaN
console.log(1 - {}); // NaN
console.log(1 - "123asd"); // NaN
console.log(1 - "101"); // -100
//一元运算符 + - ++ -- 会将操作数转换成数字
var _
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>第四章.html</title>
</head>
<body>
<script type="text/javascript">
var undefined = "sd"; //undefined是全局变量，和null不同，他不是一个关键字
var o = undefined + "5";
console.log(o);//undefined5
var _sz01 = [[1, 2, 3], [4, 5, 6]];//表达式是可以嵌套的
var _sz02 = [1, , , , 5]; //其中三个元素是 undefined
console.log(_sz02[3]); //undefined
var _dx = { //对象直接量也可以嵌套
a: {x: 1, y: 2},
b: {x: 1, y: 2}
};
console.log(_dx.a.x + _dx.b.y); //3
var _o = {x: 1, y: {z: 3}};
var _a = [o, 4, [5, 6]];
console.log(_o.x);
console.log(_o.y.z);
console.log(_o["x"]);
console.log(_a[1]);
console.log(_a[2]["1"]);
console.log(_a[0].x);
var _obj = new Object();
console.log(_obj instanceof Object); //instanceof 测试对象类 true
console.log("a" in _dx); //in 测试属性是否存在 true
console.log(~100); //-101 按位求反
//parseInt( String , 传参的位数 ) //2-16进制 转化成 10进制
console.log(parseInt("fa", 16));//250
console.log(1 + true); // 2 在 + 运算符中，会先把非字符串和数字的类型转化成数字，如果数字不成立则转化成字符串
console.log(false + true); // 1 false=0 true=1
console.log(1 + {}); // 1[object Object] {}对象不是数字 则转换成字符串 [object Object]
console.log(1 + undefined); // NaN
console.log(1 - {}); // NaN
console.log(1 - "123asd"); // NaN
console.log(1 - "101"); // -100
//一元运算符 + - ++ -- 会将操作数转换成数字
var _$1 = 1, _$2 = ++_$1;
var _$3 = 1, _$4 = _$3++;
console.log(_$1 + "|" + _$2); // 2
console.log(_$3 + "|" + _$4); // 2 1
//位运算符
// & 只有两个操作数中相对应的位都是1，结果中的这一位才是1.
console.log(parseInt("1010", 2) + "&" + parseInt("1110", 2)); //
console.log(10 & 14); // 10:1010 & 14:1110 = 1010 =10
console.log(parseInt("1010", 2)); //10
// | 如果其中一个操作数为1，那么结果就是1
console.log(parseInt("1010", 2) + "|" + parseInt("1110", 2)); //
console.log(10 | 14); // 10:1010 & 14:1110 = 1110 =14
console.log(parseInt("1110", 2)); //10
// ^ 都为1时 则结果过为1 都为0时，则结果为0 其中一个数为1时候 则结果为0
console.log(parseInt("1010", 2) + "^" + parseInt("1110", 2)); //
console.log(10 ^ 14); // 10:1010 & 14:1110 = 0100 =4
console.log(parseInt("0100", 2)); //4
// << 左移运算符
console.log(7 << 2); //28 7*(2*2) 2的2次方
console.log(7 << 3); //56 7*(2*2*2) 2的3次方
// << 右移运算符
console.log(100 >> 2); //25 100/(2*2) 2的2次方 //忽略余数
console.log(100 >> 4); //6 100/(2*2*2*2) 2的4次方 //忽略余数
// != == ... !== === 相等 严格相等
console.log("333" == 333); //true;
console.log("333" != 333); //false;
console.log("333" === 333); //false;
console.log("333" !== 333); //true;
var __ = {x: 1};
if (__ && __.x) { //true 只要是真值就可以判断为真
console.log("123");
}
function _(num) {
console.log(num);
}
var p = null;
if (p == null) {
_("1");
}
//写法不同 意思一样 同上
(p == null) && _("2");
// || OR运算符 两个为真值则返回真值，其中一个为假值 则返回假值
if (true || true) {
console.log("||");
}
var max_w, pre = {max_w};
//如果max_w定义了，则直接用它，否则在pre对象中查找max_w，如果没有定义它，则使用一个写死的常量。
var max = max_w || pre.max_w || 500;
console.log(max);
var p = true, q = false; //对于p和q取任意值，这两个等式都永远成立;
console.log(!(p && q) === !p || !q); //true;
console.log(!(p || q) === !p && !q); //true;
//eval函数 可计算某个字符串，并执行其中的的 JavaScript 代码。
var ss = eval("alert('123')"); //弹出123
console.log(ss); //undefined
var geval = eval; //获取 全局eval函数
var x = "x", y = "y"; //定义2个全局变量
function f() {
var x = "f()"; //定义局部变量
eval("x+= 'f()';"); //直接 eval 更改局部变量的值
return x; //fh
}
function b() {
var y = "b()"; //定义局部变量
geval("y+= 'b()';"); //直接 geval 更改全局变量的值
return y; //fh
}
console.log(f(), x); // f()f() x
console.log(b(), y); // b() yb()
//条件运算符 ? :
var x = 0 - 2 * 3 - 56;
console.log(x >= 0 ? x : -x); //运用条件运算符 求 绝对值 返回的是 ：左右两边的值
//合理运用运算符可以减少代码量
var gree = "hello" + (null ? true : false);
//等同于
gree="hello";
if(null){
gree+=true;
}else{
gree+=false;
}
//typeof运算符
var _t=typeof null; //typeof 可以是函数也可以是运算符
console.log(_t); //object
console.log(typeof(NaN)); //number
//delete运算符 //主要用于删除对象的属性
//可以是函数也可以是运算符
_t={x:1,y:2};
delete _t.x; //删除的_t的x属性 返回true;
delete _t.z; //删除的_t不存在z属性 返回true;
delete _t; //返回false 不能删除通过var声明的变量
var s=delete(_t.g); //true;
console.log(s);//true
this.z=1; //
console.log(this.z);//1
console.log(delete z);//true; 可以执行，在严格模式下会抛出异常，这是用 this.z代替
console.log(this.z);//undefined; //已经删除了
//void运算符跳过 可有可无 一般运用在 a连接中 javascript:void(0);
//逗号运算符 可以是任何操作数，由左向右计算。
var o=2,o=o*8,o=o-6;
console.log(o);//10
//for循环里面最常用
//2015年9月20日 15:49:38 第四章完..
</script>
</body>
</html>
= 1, _ = ++_
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>第四章.html</title>
</head>
<body>
<script type="text/javascript">
var undefined = "sd"; //undefined是全局变量，和null不同，他不是一个关键字
var o = undefined + "5";
console.log(o);//undefined5
var _sz01 = [[1, 2, 3], [4, 5, 6]];//表达式是可以嵌套的
var _sz02 = [1, , , , 5]; //其中三个元素是 undefined
console.log(_sz02[3]); //undefined
var _dx = { //对象直接量也可以嵌套
a: {x: 1, y: 2},
b: {x: 1, y: 2}
};
console.log(_dx.a.x + _dx.b.y); //3
var _o = {x: 1, y: {z: 3}};
var _a = [o, 4, [5, 6]];
console.log(_o.x);
console.log(_o.y.z);
console.log(_o["x"]);
console.log(_a[1]);
console.log(_a[2]["1"]);
console.log(_a[0].x);
var _obj = new Object();
console.log(_obj instanceof Object); //instanceof 测试对象类 true
console.log("a" in _dx); //in 测试属性是否存在 true
console.log(~100); //-101 按位求反
//parseInt( String , 传参的位数 ) //2-16进制 转化成 10进制
console.log(parseInt("fa", 16));//250
console.log(1 + true); // 2 在 + 运算符中，会先把非字符串和数字的类型转化成数字，如果数字不成立则转化成字符串
console.log(false + true); // 1 false=0 true=1
console.log(1 + {}); // 1[object Object] {}对象不是数字 则转换成字符串 [object Object]
console.log(1 + undefined); // NaN
console.log(1 - {}); // NaN
console.log(1 - "123asd"); // NaN
console.log(1 - "101"); // -100
//一元运算符 + - ++ -- 会将操作数转换成数字
var _$1 = 1, _$2 = ++_$1;
var _$3 = 1, _$4 = _$3++;
console.log(_$1 + "|" + _$2); // 2
console.log(_$3 + "|" + _$4); // 2 1
//位运算符
// & 只有两个操作数中相对应的位都是1，结果中的这一位才是1.
console.log(parseInt("1010", 2) + "&" + parseInt("1110", 2)); //
console.log(10 & 14); // 10:1010 & 14:1110 = 1010 =10
console.log(parseInt("1010", 2)); //10
// | 如果其中一个操作数为1，那么结果就是1
console.log(parseInt("1010", 2) + "|" + parseInt("1110", 2)); //
console.log(10 | 14); // 10:1010 & 14:1110 = 1110 =14
console.log(parseInt("1110", 2)); //10
// ^ 都为1时 则结果过为1 都为0时，则结果为0 其中一个数为1时候 则结果为0
console.log(parseInt("1010", 2) + "^" + parseInt("1110", 2)); //
console.log(10 ^ 14); // 10:1010 & 14:1110 = 0100 =4
console.log(parseInt("0100", 2)); //4
// << 左移运算符
console.log(7 << 2); //28 7*(2*2) 2的2次方
console.log(7 << 3); //56 7*(2*2*2) 2的3次方
// << 右移运算符
console.log(100 >> 2); //25 100/(2*2) 2的2次方 //忽略余数
console.log(100 >> 4); //6 100/(2*2*2*2) 2的4次方 //忽略余数
// != == ... !== === 相等 严格相等
console.log("333" == 333); //true;
console.log("333" != 333); //false;
console.log("333" === 333); //false;
console.log("333" !== 333); //true;
var __ = {x: 1};
if (__ && __.x) { //true 只要是真值就可以判断为真
console.log("123");
}
function _(num) {
console.log(num);
}
var p = null;
if (p == null) {
_("1");
}
//写法不同 意思一样 同上
(p == null) && _("2");
// || OR运算符 两个为真值则返回真值，其中一个为假值 则返回假值
if (true || true) {
console.log("||");
}
var max_w, pre = {max_w};
//如果max_w定义了，则直接用它，否则在pre对象中查找max_w，如果没有定义它，则使用一个写死的常量。
var max = max_w || pre.max_w || 500;
console.log(max);
var p = true, q = false; //对于p和q取任意值，这两个等式都永远成立;
console.log(!(p && q) === !p || !q); //true;
console.log(!(p || q) === !p && !q); //true;
//eval函数 可计算某个字符串，并执行其中的的 JavaScript 代码。
var ss = eval("alert('123')"); //弹出123
console.log(ss); //undefined
var geval = eval; //获取 全局eval函数
var x = "x", y = "y"; //定义2个全局变量
function f() {
var x = "f()"; //定义局部变量
eval("x+= 'f()';"); //直接 eval 更改局部变量的值
return x; //fh
}
function b() {
var y = "b()"; //定义局部变量
geval("y+= 'b()';"); //直接 geval 更改全局变量的值
return y; //fh
}
console.log(f(), x); // f()f() x
console.log(b(), y); // b() yb()
//条件运算符 ? :
var x = 0 - 2 * 3 - 56;
console.log(x >= 0 ? x : -x); //运用条件运算符 求 绝对值 返回的是 ：左右两边的值
//合理运用运算符可以减少代码量
var gree = "hello" + (null ? true : false);
//等同于
gree="hello";
if(null){
gree+=true;
}else{
gree+=false;
}
//typeof运算符
var _t=typeof null; //typeof 可以是函数也可以是运算符
console.log(_t); //object
console.log(typeof(NaN)); //number
//delete运算符 //主要用于删除对象的属性
//可以是函数也可以是运算符
_t={x:1,y:2};
delete _t.x; //删除的_t的x属性 返回true;
delete _t.z; //删除的_t不存在z属性 返回true;
delete _t; //返回false 不能删除通过var声明的变量
var s=delete(_t.g); //true;
console.log(s);//true
this.z=1; //
console.log(this.z);//1
console.log(delete z);//true; 可以执行，在严格模式下会抛出异常，这是用 this.z代替
console.log(this.z);//undefined; //已经删除了
//void运算符跳过 可有可无 一般运用在 a连接中 javascript:void(0);
//逗号运算符 可以是任何操作数，由左向右计算。
var o=2,o=o*8,o=o-6;
console.log(o);//10
//for循环里面最常用
//2015年9月20日 15:49:38 第四章完..
</script>
</body>
</html>
;
var _ = 1, _ = _++;
console.log(_
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>第四章.html</title>
</head>
<body>
<script type="text/javascript">
var undefined = "sd"; //undefined是全局变量，和null不同，他不是一个关键字
var o = undefined + "5";
console.log(o);//undefined5
var _sz01 = [[1, 2, 3], [4, 5, 6]];//表达式是可以嵌套的
var _sz02 = [1, , , , 5]; //其中三个元素是 undefined
console.log(_sz02[3]); //undefined
var _dx = { //对象直接量也可以嵌套
a: {x: 1, y: 2},
b: {x: 1, y: 2}
};
console.log(_dx.a.x + _dx.b.y); //3
var _o = {x: 1, y: {z: 3}};
var _a = [o, 4, [5, 6]];
console.log(_o.x);
console.log(_o.y.z);
console.log(_o["x"]);
console.log(_a[1]);
console.log(_a[2]["1"]);
console.log(_a[0].x);
var _obj = new Object();
console.log(_obj instanceof Object); //instanceof 测试对象类 true
console.log("a" in _dx); //in 测试属性是否存在 true
console.log(~100); //-101 按位求反
//parseInt( String , 传参的位数 ) //2-16进制 转化成 10进制
console.log(parseInt("fa", 16));//250
console.log(1 + true); // 2 在 + 运算符中，会先把非字符串和数字的类型转化成数字，如果数字不成立则转化成字符串
console.log(false + true); // 1 false=0 true=1
console.log(1 + {}); // 1[object Object] {}对象不是数字 则转换成字符串 [object Object]
console.log(1 + undefined); // NaN
console.log(1 - {}); // NaN
console.log(1 - "123asd"); // NaN
console.log(1 - "101"); // -100
//一元运算符 + - ++ -- 会将操作数转换成数字
var _$1 = 1, _$2 = ++_$1;
var _$3 = 1, _$4 = _$3++;
console.log(_$1 + "|" + _$2); // 2
console.log(_$3 + "|" + _$4); // 2 1
//位运算符
// & 只有两个操作数中相对应的位都是1，结果中的这一位才是1.
console.log(parseInt("1010", 2) + "&" + parseInt("1110", 2)); //
console.log(10 & 14); // 10:1010 & 14:1110 = 1010 =10
console.log(parseInt("1010", 2)); //10
// | 如果其中一个操作数为1，那么结果就是1
console.log(parseInt("1010", 2) + "|" + parseInt("1110", 2)); //
console.log(10 | 14); // 10:1010 & 14:1110 = 1110 =14
console.log(parseInt("1110", 2)); //10
// ^ 都为1时 则结果过为1 都为0时，则结果为0 其中一个数为1时候 则结果为0
console.log(parseInt("1010", 2) + "^" + parseInt("1110", 2)); //
console.log(10 ^ 14); // 10:1010 & 14:1110 = 0100 =4
console.log(parseInt("0100", 2)); //4
// << 左移运算符
console.log(7 << 2); //28 7*(2*2) 2的2次方
console.log(7 << 3); //56 7*(2*2*2) 2的3次方
// << 右移运算符
console.log(100 >> 2); //25 100/(2*2) 2的2次方 //忽略余数
console.log(100 >> 4); //6 100/(2*2*2*2) 2的4次方 //忽略余数
// != == ... !== === 相等 严格相等
console.log("333" == 333); //true;
console.log("333" != 333); //false;
console.log("333" === 333); //false;
console.log("333" !== 333); //true;
var __ = {x: 1};
if (__ && __.x) { //true 只要是真值就可以判断为真
console.log("123");
}
function _(num) {
console.log(num);
}
var p = null;
if (p == null) {
_("1");
}
//写法不同 意思一样 同上
(p == null) && _("2");
// || OR运算符 两个为真值则返回真值，其中一个为假值 则返回假值
if (true || true) {
console.log("||");
}
var max_w, pre = {max_w};
//如果max_w定义了，则直接用它，否则在pre对象中查找max_w，如果没有定义它，则使用一个写死的常量。
var max = max_w || pre.max_w || 500;
console.log(max);
var p = true, q = false; //对于p和q取任意值，这两个等式都永远成立;
console.log(!(p && q) === !p || !q); //true;
console.log(!(p || q) === !p && !q); //true;
//eval函数 可计算某个字符串，并执行其中的的 JavaScript 代码。
var ss = eval("alert('123')"); //弹出123
console.log(ss); //undefined
var geval = eval; //获取 全局eval函数
var x = "x", y = "y"; //定义2个全局变量
function f() {
var x = "f()"; //定义局部变量
eval("x+= 'f()';"); //直接 eval 更改局部变量的值
return x; //fh
}
function b() {
var y = "b()"; //定义局部变量
geval("y+= 'b()';"); //直接 geval 更改全局变量的值
return y; //fh
}
console.log(f(), x); // f()f() x
console.log(b(), y); // b() yb()
//条件运算符 ? :
var x = 0 - 2 * 3 - 56;
console.log(x >= 0 ? x : -x); //运用条件运算符 求 绝对值 返回的是 ：左右两边的值
//合理运用运算符可以减少代码量
var gree = "hello" + (null ? true : false);
//等同于
gree="hello";
if(null){
gree+=true;
}else{
gree+=false;
}
//typeof运算符
var _t=typeof null; //typeof 可以是函数也可以是运算符
console.log(_t); //object
console.log(typeof(NaN)); //number
//delete运算符 //主要用于删除对象的属性
//可以是函数也可以是运算符
_t={x:1,y:2};
delete _t.x; //删除的_t的x属性 返回true;
delete _t.z; //删除的_t不存在z属性 返回true;
delete _t; //返回false 不能删除通过var声明的变量
var s=delete(_t.g); //true;
console.log(s);//true
this.z=1; //
console.log(this.z);//1
console.log(delete z);//true; 可以执行，在严格模式下会抛出异常，这是用 this.z代替
console.log(this.z);//undefined; //已经删除了
//void运算符跳过 可有可无 一般运用在 a连接中 javascript:void(0);
//逗号运算符 可以是任何操作数，由左向右计算。
var o=2,o=o*8,o=o-6;
console.log(o);//10
//for循环里面最常用
//2015年9月20日 15:49:38 第四章完..
</script>
</body>
</html>
+ "|" + _); // 2
console.log(_ + "|" + _); // 2 1
//位运算符
// & 只有两个操作数中相对应的位都是1，结果中的这一位才是1.
console.log(parseInt("1010", 2) + "&" + parseInt("1110", 2)); //
console.log(10 & 14); // 10:1010 & 14:1110 = 1010 =10
console.log(parseInt("1010", 2)); //10
// | 如果其中一个操作数为1，那么结果就是1
console.log(parseInt("1010", 2) + "|" + parseInt("1110", 2)); //
console.log(10 | 14); // 10:1010 & 14:1110 = 1110 =14
console.log(parseInt("1110", 2)); //10
// ^ 都为1时 则结果过为1 都为0时，则结果为0 其中一个数为1时候 则结果为0
console.log(parseInt("1010", 2) + "^" + parseInt("1110", 2)); //
console.log(10 ^ 14); // 10:1010 & 14:1110 = 0100 =4
console.log(parseInt("0100", 2)); //4
// << 左移运算符
console.log(7 << 2); //28 7*(2*2) 2的2次方
console.log(7 << 3); //56 7*(2*2*2) 2的3次方
// << 右移运算符
console.log(100 >> 2); //25 100/(2*2) 2的2次方 //忽略余数
console.log(100 >> 4); //6 100/(2*2*2*2) 2的4次方 //忽略余数
// != == ... !== === 相等 严格相等
console.log("333" == 333); //true;
console.log("333" != 333); //false;
console.log("333" === 333); //false;
console.log("333" !== 333); //true;
var __ = {x: 1};
if (__ && __.x) { //true 只要是真值就可以判断为真
console.log("123");
}
function _(num) {
console.log(num);
}
var p = null;
if (p == null) {
_("1");
}
//写法不同 意思一样 同上
(p == null) && _("2");
// || OR运算符 两个为真值则返回真值，其中一个为假值 则返回假值
if (true || true) {
console.log("||");
}
var max_w, pre = {max_w};
//如果max_w定义了，则直接用它，否则在pre对象中查找max_w，如果没有定义它，则使用一个写死的常量。
var max = max_w || pre.max_w || 500;
console.log(max);
var p = true, q = false; //对于p和q取任意值，这两个等式都永远成立;
console.log(!(p && q) === !p || !q); //true;
console.log(!(p || q) === !p && !q); //true;
//eval函数 可计算某个字符串，并执行其中的的 JavaScript 代码。
var ss = eval("alert('123')"); //弹出123
console.log(ss); //undefined
var geval = eval; //获取 全局eval函数
var x = "x", y = "y"; //定义2个全局变量
function f() {
var x = "f()"; //定义局部变量
eval("x+= 'f()';"); //直接 eval 更改局部变量的值
return x; //fh
}
function b() {
var y = "b()"; //定义局部变量
geval("y+= 'b()';"); //直接 geval 更改全局变量的值
return y; //fh
}
console.log(f(), x); // f()f() x
console.log(b(), y); // b() yb()
//条件运算符 ? :
var x = 0 - 2 * 3 - 56;
console.log(x >= 0 ? x : -x); //运用条件运算符 求 绝对值 返回的是 ：左右两边的值
//合理运用运算符可以减少代码量
var gree = "hello" + (null ? true : false);
//等同于
gree="hello";
if(null){
gree+=true;
}else{
gree+=false;
}
//typeof运算符
var _t=typeof null; //typeof 可以是函数也可以是运算符
console.log(_t); //object
console.log(typeof(NaN)); //number
//delete运算符 //主要用于删除对象的属性
//可以是函数也可以是运算符
_t={x:1,y:2};
delete _t.x; //删除的_t的x属性 返回true;
delete _t.z; //删除的_t不存在z属性 返回true;
delete _t; //返回false 不能删除通过var声明的变量
var s=delete(_t.g); //true;
console.log(s);//true
this.z=1; //
console.log(this.z);//1
console.log(delete z);//true; 可以执行，在严格模式下会抛出异常，这是用 this.z代替
console.log(this.z);//undefined; //已经删除了
//void运算符跳过 可有可无 一般运用在 a连接中 javascript:void(0);
//逗号运算符 可以是任何操作数，由左向右计算。
var o=2,o=o*8,o=o-6;
console.log(o);//10
//for循环里面最常用
//2015年9月20日 15:49:38 第四章完..
</script>
</body>
</html><!DOCTYPE html>
<html lang="en">
<head>
<me
阅读背景：
Javascript学习笔记【第四章】
来源：互联网
分享到：
