【js实例】js中的5种基本数据类型和9种操作符

js中的5中基本数据类型

js标识符

1. 第一个字符必须为字母,下划线,或美元符
2. 其他字符可以是字母,下划线,美元符,数字
3. js标识符区分大小写
4. 标识符不能使关键字和保留字

关键字:

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);         //
alert(23.3);    //23.3
alert(2.3e4);    //

//若数字为0开头则视为八进制，注意：八进制在严格模式下无效
alert(070);        //

//十六进制的前两位为0x
alert(0x33);    //

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));    //
alert(Number(false));    //

//2.如果是数值，则只是简单的传入和返回
alert(Number(23));    //

//3.如果是null则返回0
alert(Number(null));    //

//4.如果是undefined则返回NaN
alert(Number(undefined));    //NaN

//5.如果是NaN则返回NaN
alert(Number(NaN));    //NaN

//6.字符串
//6.1：若字符串中包含数字则将其转换为十进制数即可；忽略前导0
alert(Number("23"));    //
alert(Number("23.3"));    //23.3
alert(Number("023"));    //
alert(Number("023.3"));    //23.3
alert(Number("0xA"));    //
//6.2：若是空字符串，则转换为0
alert(Number(""));        //
//6.3：若字符串包含上述格式之外的字符则将其转换为NaN
alert(Number("23#"));    //NaN

//7.若是对象，则调用valueOf()方法，按上述方法转换；若转换为NaN则调用toString()方法再次按上述方法转换
var a = new Object();
alert(Number(a));        //NaN
a = "23";
alert(Number(a));        //

//parseInt在解析字符串时和Number有点区别
//1.忽略空格，若第一个字符为数字字符，则解析到非数字字符为止
alert(parseInt("   123 4blue"));    //123，4前面的空格符是非数字字符
//2.空字符串返回NaN，无法识别字符串也返回NaN
alert(parseInt(""));            //NaN
alert(parseInt("AF"));            //NaN
//3.能解析各种格式整数
alert(parseInt("0xA"));            //
alert(parseInt("70"));            //
alert(parseInt("070"));            //56，ECMAScript3认为是56，ECMAScript5认为是70
alert(parseInt("0xf"));            //
//4.解析浮点数时，正数向下取整，负数向上取整
alert(parseInt(22.9));            //
alert(parseInt(-22.9));            //-22

//可以给parseInt传递第二个参数，指定转换的进制
alert(parseInt("A", 16));    //
alert(parseInt(110, 2));    //
alert(parseInt(110, 8));    //
alert(parseInt(110, 10));    //
alert(parseInt(110, 16));    //

/*
parseFloat()与parseInt类似；不过parseFloat()只解析十进制；若parseFloat()解析的是整数(也可没有小数点，或者小数点后全为0)，
则返回整数
*/
alert(parseFloat("0xA"));    //
alert(parseFloat("2.000"));    //
alert(parseFloat(2.000));    //

/*
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());        //
alert(num.toString(2));        //
alert(num.toString(8));        //
alert(num.toString(10));    //
alert(num.toString(16));    //
num = 10;
alert(num.toString(16));    //a

var str = "23";
alert(str.toString());        //

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));    //
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);        //
alert(o.name);        //libra
alert(o["name"]);    //

//检测类型
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);        //
alert(--age);    //执行--后为10
alert(age + 10);    //
alert(age - 10);    //

//连接符
alert("我有" + age + "岁了！");    //我有10岁了!

/*
位操作符：~, &, |, ^, <<, >>, >>>
若对非数值应用位操作符，会先使用Number()函数将该值转换为一个数值(自动完成),然后再应用位操作。
*/

//按位非~：操作数的负数减一
alert(~1);            //-2
alert(~"1");        //-2
//按位与&：对应的二进制数进行逻辑与操作，返回1或0
alert(25 & 3);        //
//按位与|：对应的二进制数进行逻辑或操作，返回1或0
alert(25 | 35);        //
//按位与^：对应的二进制数进行逻辑异或操作，返回1或0
alert(25^3);        //
//左移：二进制数左移n位，空位用0填充；a << n = a * 2^n;
alert(2 << 3);        //
//有符号右移：二进制数右移n位，空位用符号位填充
alert(25 >> 3);        //
//无符号右移对于正数，和有符号右移一样
alert(64 >>> 5);    //
//无符号右移对于负数，二进制数右移n位，空位用0填充
alert(-64 >>> 5);    //

/*
布尔操作符：！, &&, ||
&&, || 为短操作，即若是第一个操作数能决定结果则不会对第二个操作数求值
可以应用于任何类型的操作数，返回布尔值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");//
//2.若第二个操作数为对象，则当第一个操作数为true时返回该对象
alert(true && new Object(2));    //
alert(false && new Object(2));    //false
//3.//若两个操作数都为对象则返回第二个操作数
alert(new Object("23") && new Object(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.若第二个操作数是对象,则当第一个操作数为false时返回该对象
alert(false || new Object(2));    //
//3.若两个操作数是对象,则返回第一个操作数
alert(new Object(33) || new Object(3));//
//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");            //
alert(2 * "2#");        //NaN, 应为"2#"用Number()转换后为NaN

//除法：/
//1.若操作数都是数值则返回数值，若数值范围超过了ECMAScript的表示范围则返回Infinity和-Infinity
alert(2 / 2);            //
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);            //
alert(23 / 0);            //Infinity
//6.Infinity被任何非零数值除，则返回Infinity或-Infinity
alert(Infinity / 4);    //Infinity
alert(4 / Infinity);    //
//7.若有操作数不是数值，则后台调用Number()方法转换，在应用上述规则
alert(2 / "2");            //
alert(2 / "2#");        //NaN, 应为"2#"用Number()转换后为NaN

//求模：%
//1.若操作数是数值则按常规计算
alert(5 % 12);            //
//2.被除数是无穷,除数是有限数值则返回NaN
alert(Infinity % 2);    //NaN
alert(-Infinity % 2);    //NaN
//3.若被除数是有限数值, 除数是无穷则返回被除数
alert(2 % Infinity);    //
//4.若被除数是有限数值,除数是零则返回NaN
alert(2 % 0);            //NaN
//5.若被除数和除数都是Infinity则返回NaN
alert(Infinity % Infinity);    //NaN
//6.若被除数是0则结果是0
alert(0 % 32);            //
//7.若有操作数不是数值，则后台调用Number()方法转换，在应用上述规则
alert(2 % "2");            //
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);                //
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);//
num1 = num2 = 2;
alert(num1 /= num2);//1
num1 = num2 = 2;
alert(num1 %= num2);//
num1 = num2 = 2;
alert(num1 += num2);//
num1 = num2 = 2;
alert(num1 -= num2);//
num1 = num2 = 2;
alert(num1 <<= num2);//
num1 = num2 = 2;
alert(num1 >>= num2);//
num1 = num2 = 2;
alert(num1 >>>=num2);//