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

时间 2019-11-18

原文原文链接

js中的5中基本数据类型

js标识符

第一个字符必须为字母,下划线,或美圆符
其余字符能够是字母,下划线,美圆符,数字
js标识符区分大小写
标识符不能使关键字和保留字

关键字:express

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 this

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种操做符:一元操做符,位操做符,布尔操做符,乘性操做符,加性操做符,关系操做符,相等操做符,条件操做符,赋值操做符spa

/*
一元操做符：+, -, ++, --
+, -, ++, --能够做用于任何值
*/
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