js中的5中基本数据类型
js标识符
- 第一个字符必须为字母,下划线,或美元符
- 其他字符可以是字母,下划线,美元符,数字
- js标识符区分大小写
- 标识符不能使关键字和保留字
关键字:
break | do | instanceof | typeof |
case | else | new | var |
catch | finally | return | void |
continue | for | switch | while |
debugger | function | this | with |
default | if | throw | |
delete | in | try |
保留字:
abstract | enum | int | short |
boolean | export | interface | static |
byte | extends | long | super |
char | final | native | synchronized |
class | float | package | throws |
const | goto | private | transient |
debugger | implement | protected | volatile |
double | import | public |
js注释
//单行注释
/*
多行注释
*/
js模式
严格模式:使用 use strict
混杂模式:不加 use strict
js数据类型
js中有5中简单数据类型,也成为基本数据类型:Undefined, Null, Boolean, Number, String
/*
=======================================================
Undefined类型只有一个值:undefined,表示未定义这个量
为初始化的变量会自动赋予undefined值
*/
var message;
alert(typeof message); //undefined
alert(age); //出错,不执行这条语句
var message2;
alert(typeof message2); //undefined
alert(typeof age); //undefined
/*
Null类型也只有一个值:null
*/
alert(typeof null); //返回object,从逻辑角度来看,null值表示一个空对象指针
实际上是浏览器的bug一直延续至今
alert(undefined == null); //返回true,undefined派生自null值
/*
Boolean类型只有两个值:true和false。注意:TRUE,True,FALSE,False不是Boolean类型,而是标识符
可以对任何数据类型调用Boolean函数,总会返回一个Boolean值
数据类型 转换为true的值 转换为fasle的值
Boolean true false
String 任何非空字符串 ""(空字符串)
Number 任何非零数值(包括无穷大) 0和NaN
Object 任何对象 null
Undefined 不适用 undefined
*/
alert(Boolean(true)); //true
alert(Boolean(false)); //false
alert(Boolean("s")); //true
alert(Boolean("")); //false
alert(Boolean(2)); //true
alert(Boolean(Infinity)); //true
alert(Boolean(0)); //false
alert(Boolean(NaN)); //false
alert(Boolean(new Object()));//true
alert(Boolean(null)); //false
alert(Boolean(undefined)); //false
/*
Number类型
进行算数运算时,所有的八进制和十六进制会转化为十进制数值
*/
//十进制
alert(23); //23
alert(23.3); //23.3
alert(2.3e4); //23000
//若数字为0开头则视为八进制,注意:八进制在严格模式下无效
alert(070); //56
//十六进制的前两位为0x
alert(0x33); //51
alert(Number.MAX_VALUE);//1.7976931348623157e+308
alert(Number.MIN_VALUE);//5e-324
/*
若数值不在MIN_VALUE和Number.MAX_VALUE之间,
1.num < 0, 返回-Infinity
2.num > 0, 返回Infinity
*/
var num = Number.MAX_VALUE + 1;
alert(num); //Infinity
num = Number.MIN_VALUE - Number.MAX_VALUE;
alert(num); //-Infinity
/*
NaN:非数值,not a number。表示一个本来返回数值的操作数未返回数值的情况
1.任何涉及NaN的操作都会返回NaN
2.NaN和任何值都不相等
*/
alert(NaN - 10); //NaN
alert(NaN == NaN); //false
/*
isNaN()接受一个参数x,若x不是数值则返回true,反之返回false
isNaN()接受参数x时会尝试将x转化为数值
*/
alert(isNaN(NaN)); //true
alert(isNaN(10)); //false
alert(isNaN("10")); //false "10"可以转化为数值10
alert(isNaN("blue")); //true "blue"不可以转化为数值
alert(isNaN(false)); //false true可转为1,fasle可转为0
/*
数值转换:Number(), parseInt()和parseFloat()
*/
//1.如果是Boolean值,则true返回1,false返回0
alert(Number(true)); //1
alert(Number(false)); //0
//2.如果是数值,则只是简单的传入和返回
alert(Number(23)); //23
//3.如果是null则返回0
alert(Number(null)); //0
//4.如果是undefined则返回NaN
alert(Number(undefined)); //NaN
//5.如果是NaN则返回NaN
alert(Number(NaN)); //NaN
//6.字符串
//6.1:若字符串中包含数字则将其转换为十进制数即可;忽略前导0
alert(Number("23")); //23
alert(Number("23.3")); //23.3
alert(Number("023")); //23
alert(Number("023.3")); //23.3
alert(Number("0xA")); //10
//6.2:若是空字符串,则转换为0
alert(Number("")); //0
//6.3:若字符串包含上述格式之外的字符则将其转换为NaN
alert(Number("23#")); //NaN
//7.若是对象,则调用valueOf()方法,按上述方法转换;若转换为NaN则调用toString()方法再次按上述方法转换
var a = new Object();
alert(Number(a)); //NaN
a = "23";
alert(Number(a)); //23
//parseInt在解析字符串时和Number有点区别
//1.忽略空格,若第一个字符为数字字符,则解析到非数字字符为止
alert(parseInt(" 123 4blue")); //123,4前面的空格符是非数字字符
//2.空字符串返回NaN,无法识别字符串也返回NaN
alert(parseInt("")); //NaN
alert(parseInt("AF")); //NaN
//3.能解析各种格式整数
alert(parseInt("0xA")); //10
alert(parseInt("70")); //70
alert(parseInt("070")); //56,ECMAScript3认为是56,ECMAScript5认为是70
alert(parseInt("0xf")); //15
//4.解析浮点数时,正数向下取整,负数向上取整
alert(parseInt(22.9)); //22
alert(parseInt(-22.9)); //-22
//可以给parseInt传递第二个参数,指定转换的进制
alert(parseInt("A", 16)); //10
alert(parseInt(110, 2)); //6
alert(parseInt(110, 8)); //72
alert(parseInt(110, 10)); //110
alert(parseInt(110, 16)); //272
/*
parseFloat()与parseInt类似;不过parseFloat()只解析十进制;若parseFloat()解析的是整数(也可没有小数点,或者小数点后全为0),
则返回整数
*/
alert(parseFloat("0xA")); //10
alert(parseFloat("2.000")); //2
alert(parseFloat(2.000)); //2
/*
String类型
EMCAScript中的字符串是不可变的,字符串一旦创建它们的值就不能改变。
要改变某个变量保存的字符串,首先要销毁原来的字符串,然后再用一个包含新值得字符串填充该变量
*/
var lang = "Java";
lang = lang + "Script"; //先创建一个字符串用"JavaScipt填充",再销毁原来的Java和Script字符串
//Boolean,Number,String,Object类型都有toString()方法,但是null和undefined没有
var t = true;
alert(t.toString());//true
var num = 16;
alert(num.toString()); //16
alert(num.toString(2)); //10000
alert(num.toString(8)); //20
alert(num.toString(10)); //16
alert(num.toString(16)); //10
num = 10;
alert(num.toString(16)); //a
var str = "23";
alert(str.toString()); //23
var a = new Object("2#"); //2#
alert(a.toString());
/*
String()方法:如果值有toString()方法,则调用该方法;如果值是null则返回null;如果值是undefined则返回undefined
*/
var value1 = 10;
var value2 = true;
var value3 = null;
var value4;
alert(String(value1)); //10
alert(String(value2)); //true
alert(String(value3)); //null
alert(String(value4)); //undefined
/*
Obejct类型
Object的每个实例都有下列属性和方法
constructor:保存着用于创建当前对象的函数
hasOwnProperty(propertyName):用于检查给定的属性当前对象实例中(不是实例的原型)是否存在
isPrototypeOf(object):用于检查传入的对象是否是当前对象的原型
proPertyIsEnumerable(propertyName):用于检查给定的属性是否能使用for-in语句来枚举
toLocaleString():返回对象的字符串表示
toString():返回对象的字符串表示
valueOf():返回对象的字符串,数值或布尔值表示
*/
var o = new Object(); //创建对象
var o = {
"age" : 13
}
//给对象添加属性
o.name = "libra";
o.money = "100";
//访问属性
alert(o.age); //13
alert(o.name); //libra
alert(o["name"]); //100
//检测类型
var str = "Nicholas";
var bool = true;
var int = 22;
var undi;
var nul = null;
var ob = new Object();
var arr = new Array();
//typeof常用来检测基本类型值,也可用来检测引用类型值
alert(typeof str); //string
alert(typeof bool); //boolean
alert(typeof int); //number
alert(typeof undi); //undifined
alert(typeof nul); //null
alert(typeof ob); //object
alert(typeof arr); //object
/*
instanceof 常用来检测引用类型值
*/
//注意:所有引用类型值为Object实例,所以始终会返回true,但是基本类型不是对象,则返回false;
alert(ob instanceof Object); //true
alert(str instanceof Object); //false
alert(arr instanceof Object); //true
alert(arr instanceof Array); //true
js操作符
js有9种操作符:一元操作符,位操作符,布尔操作符,乘性操作符,加性操作符,关系操作符,相等操作符,条件操作符,赋值操作符
/*
一元操作符:+, -, ++, --
+, -, ++, --可以作用于任何值
*/
var age = 10;
alert(age++); //10,下一个age是11
alert(++age); //执行++后为12
alert(age--); //12,下一个age是11
alert(age); //11
alert(--age); //执行--后为10
alert(age + 10); //20
alert(age - 10); //0
//连接符
alert("我有" + age + "岁了!"); //我有10岁了!
/*
位操作符:~, &, |, ^, <<, >>, >>>
若对非数值应用位操作符,会先使用Number()函数将该值转换为一个数值(自动完成),然后再应用位操作。
*/
//按位非~:操作数的负数减一
alert(~1); //-2
alert(~"1"); //-2
//按位与&:对应的二进制数进行逻辑与操作,返回1或0
alert(25 & 3); //1
//按位与|:对应的二进制数进行逻辑或操作,返回1或0
alert(25 | 35); //59
//按位与^:对应的二进制数进行逻辑异或操作,返回1或0
alert(25^3); //26
//左移:二进制数左移n位,空位用0填充;a << n = a * 2^n;
alert(2 << 3); //16
//有符号右移:二进制数右移n位,空位用符号位填充
alert(25 >> 3); //3
//无符号右移对于正数,和有符号右移一样
alert(64 >>> 5); //2
//无符号右移对于负数,二进制数右移n位,空位用0填充
alert(-64 >>> 5); //134217726
/*
布尔操作符:!, &&, ||
&&, || 为短操作,即若是第一个操作数能决定结果则不会对第二个操作数求值
可以应用于任何类型的操作数,返回布尔值true或false或操作数
*/
//1.若操作数是一个对象则返回false
alert(!new Object(2)); //false
//2.若操作数是空字符串则返回true
alert(!""); //true
//3.若操作数是任何非空字符串则返回false
alert(!"@#4"); //false
//4.若操作数是数值0则返回true
alert(!0); //true
//5.若操作数是任何非零数值(包括无穷)则返回false
alert(!12); //false
alert(!Infinity); //false
//6.若操作数是null,NaN,undefined则返回true
alert(!null); //true
alert(!NaN); //true
alert(!undefined); //true
//对于逻辑与操作,若第一个操作数为false则结果为false
//1.若第一个操作数为对象则返回第二个操作数
alert(new Object("23") && "34");//34
//2.若第二个操作数为对象,则当第一个操作数为true时返回该对象
alert(true && new Object(2)); //2
alert(false && new Object(2)); //false
//3.//若两个操作数都为对象则返回第二个操作数
alert(new Object("23") && new Object(2)); //2
//4.若有一个操作数是null则返回null
alert(null && 2); //null
alert(2 && null); //null
//5.若有一个操作数是NaN则返回NaN
alert(NaN && 2); //NaN
alert(2 && NaN); //NaN
//6.若有一个操作数是undefined则返回undefined
alert(undefined && 2); //undefined
alert(2 && undefined); //undefined
//7.任何数值(包括Infinity)为true
alert(0 && 3);
//对于逻辑或操作,若第一个操作数为true则结果为true
//1.若第一个操作数是对象则返回该对象
alert(new Object(2) || false); //2
//2.若第二个操作数是对象,则当第一个操作数为false时返回该对象
alert(false || new Object(2)); //2
//3.若两个操作数是对象,则返回第一个操作数
alert(new Object(33) || new Object(3));//33
//4.若两个操作数是null, NaN, Undefined,当操作数一样时则返回它们本身,不一样是返回第二个操作数
alert(null || null); //null
alert(NaN || NaN); //NaN
alert(undefined || undefined); //undefined
alert(NaN || undefined); //undefined
/*
乘性操作符:*, /, %
*/
//乘法:*
//1.若操作数都是数值则返回数值,若数值范围超过了ECMAScript的表示范围则返回Infinity和-Infinity
alert(2 * 3.3); //6.6
alert(2 * Number.MAX_VALUE);//Infinity
//2.任何NaN的操作返回NaN
alert(2 * NaN); //NaN
//3.Infinity * 0 返回NaN
alert(Infinity * 0); //NaN
//4.Infinity乘以非零数值则返回Infinity或者-Infinity
alert(Infinity * 2); //Infinity
alert(Infinity * -2); //-Infinity
alert(Infinity * Infinity); //Infinity
alert(Infinity * -Infinity); //-Infinity
//5.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 * "2"); //4
alert(2 * "2#"); //NaN, 应为"2#"用Number()转换后为NaN
//除法:/
//1.若操作数都是数值则返回数值,若数值范围超过了ECMAScript的表示范围则返回Infinity和-Infinity
alert(2 / 2); //1
alert(2 / Number.MIN_VALUE);//Infinity
//2.任何NaN操作都返回NaN
alert(2 / NaN); //NaN
//3.Infinity / Infinity返回NaN
alert(Infinity / Infinity); //NaN
//4. 0 / 0 返回NaN
alert(0 / 0); //NaN
//5.非零有限数被零除则返回Infinity或-Infinity
alert(0 / 23); //0
alert(23 / 0); //Infinity
//6.Infinity被任何非零数值除,则返回Infinity或-Infinity
alert(Infinity / 4); //Infinity
alert(4 / Infinity); //0
//7.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 / "2"); //1
alert(2 / "2#"); //NaN, 应为"2#"用Number()转换后为NaN
//求模:%
//1.若操作数是数值则按常规计算
alert(5 % 12); //2
//2.被除数是无穷,除数是有限数值则返回NaN
alert(Infinity % 2); //NaN
alert(-Infinity % 2); //NaN
//3.若被除数是有限数值, 除数是无穷则返回被除数
alert(2 % Infinity); //2
//4.若被除数是有限数值,除数是零则返回NaN
alert(2 % 0); //NaN
//5.若被除数和除数都是Infinity则返回NaN
alert(Infinity % Infinity); //NaN
//6.若被除数是0则结果是0
alert(0 % 32); //0
//7.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 % "2"); //0
alert(2 % "2#"); //NaN, 应为"2#"用Number()转换后为NaN
/*
加性操作符:+, -
*/
//加法+
//1.任何NaN操作返回NaN
alert(1 + NaN); //NaN
//2.Infinity + Infinity = Infinitu;Infinity - Infinity = NaN;
alert(Infinity + Infinity); //Infinity
alert(Infinity + -Infinity); //NaN
alert(-Infinity + -Infinity); //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0; 0 - 0 = 0;
alert((+0) + (+0)); //+0, +(0 + 0)
alert((+0) + (-0)); //+0, +(0 - 0)
alert((-0) + (-0)); //-0, -(0 + 0)
//4.若操作数中有字符串,则+就是连接符,则调用toString(), 或String()方法将操作数变成字符串再进行拼接
alert("##" + 23); //"##23"
alert(null + "3"); //"null3"
//减法-
//1.任何NaN操作返回NaN
alert(1 - NaN); //NaN
//2.Infinity + Infinity = Infinitu;Infinity - Infinity = NaN;
alert(Infinity - Infinity); //NaN
alert(Infinity - -Infinity); //Infinity, Infinity + Infinity
alert(-Infinity - Infinity); //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0; 0 - 0 = 0;
alert((+0) - (+0)); //+0, +(0 - 0)
alert((+0) - (-0)); //+0, +(0 + 0)
alert((-0) - (-0)); //-0, -(0 - 0)
//4.若操作数中有字符串,则+就是连接符,则调用toString(), 或String()方等法将操作数变成字符串再进行拼接
alert("##" - 23); //NaN, "##"转换后为NaN
alert(null - "3"); //-3,
alert(3 - null); //3
alert(undefined - "3"); //NaN
alert(3 - undefined); //NaN
/*
关系操作符:>, <, <=, >= 返回true或false
*/
//若两个操作数是数值,则执行数值比较
alert(2 >= 3);//false
//如果两个操作数是字符串,则比较两个字符串对应的字符编码值
alert("a" > "3");//true
//若有操作数不是数值,则将其转换为字符串进行比较
alert(2 < "3");//true
//若操作数是对象则调用valueOf(),toString()等方法转换后进行比较
alert(new Object("2") >= 3);//false
//若操作数是布尔值则先将其转换为数值再执行比较
alert(true >= false);//true
/*
相等操作符:==, !=, ===, !==
==, !=:先转换再比较
===, !==:仅比较不转换
*/
alert(true == 1); //true
alert(false == 0); //true
alert(true == 2); //false
alert(false == -1); //false
alert("23" == "23"); //true
alert(new Object(2) == "2"); //true
alert(null == undefined); //true
alert(null == 0); //false
alert(undefined == 0); //false
alert(NaN != NaN); //true
alert("2" == 2); //true, 先将"2"转换为数值2在比较
alert("2" === 2); //false,直接进行比较
alert("2" !== 2); //true
/*
条件操作符: expression ? result1 : result2;
*/
var num = 1 > 2 ? 3 : 4;
alert(num); //4, 1 > 2 为假
num = 1 < 2 ? 3 : 4;
alert(num); //3, 1 < 2 为真
/*
赋值和计算
*/
var num1, num2;
num1 = num2 = 2;
alert(num1 *= num2);//4
num1 = num2 = 2;
alert(num1 /= num2);//1
num1 = num2 = 2;
alert(num1 %= num2);//0
num1 = num2 = 2;
alert(num1 += num2);//4
num1 = num2 = 2;
alert(num1 -= num2);//0
num1 = num2 = 2;
alert(num1 <<= num2);//8
num1 = num2 = 2;
alert(num1 >>= num2);//0
num1 = num2 = 2;
alert(num1 >>>=num2);//0