基础知识

JavaScript是一种专门为与网页交互而设计的脚本语言。
JavaScript 是一种非常松散的面向对象语言 ==> 弱类型语言
在script便签内书写JS代码， 一旦JS代码出现报错,后面的代码将不执行

JavaScript由三部分组成：

1）ECMAScript  由ECMA-262定义，提供核心语言功能 

      ECMAScript规定了以下组成部分：语法、类型、语句、关键字、保留字、操作符以及对象

2）DOM 文档对象模型  提供访问和操作网页内容的方法和接口   ==> 通常把方法和接口称为API，也就是查找一下文档，如 :W3School
							//方法  提供了一些东西让js与页面进行沟通交流

      DOM级别：DOM1 、DOM2、DOM3

3） BOM 浏览器对象模型  提供与浏览器交互的方法和接口

可选的分号：

ECMAScript中的语句以一个分号结尾;如果省略分号，则由解释器

确定语句的结尾。这是非严谨语言的特点。(不推荐省略分号)

标识符：指变量、函数、属性的名字，或者函数的参数。

标识符命名规则：

   1)第一个字符必须是一个字母、下划线(_)或一个美元符号($);  
   2)其他的字符可以是字母、下划线、美元符号或数字;
   3)不能把关键字、保留字用作标识符。
   4)ECMAScript标识符一般采用驼峰大小写命名格式。

	window.onload = function(){// 预加载 ==> 最后执行
		alert("hi");// 系统弹出框 ==> 一般不使用 (点击确定后面的代码才会继续执行)
		console.log( "hello" );// 控制台输出 报错信息的收集  
		document.write("hello world");// 将文本和标签内容输出到页面
	}
 

注释

	单行注释 //
	多行(块级)注释 /* */
    作用: 
	 1) 提高代码可读性
     2) 阻止代码的执行,解析时解析不到(过滤)

变量

变量是松散类型的，所谓松散类型就是可以保存任何类型的数据
变量赋值的过程叫初始化
- 声明的同时进行赋值
- 先声明 再赋值
1. 变量的类型取决于值
2. 多个变量之间用,隔开
3. 同一变量后赋值会覆盖先赋值
4. var定义的变量叫显式声明， 省略var声明的变量叫隐式声明
5. 省略var操作符可以定义全局变量(不推荐
6. var定义的变量有变量声明提升的过程

数据类型

栈内存:5种基本数据类型的值保存在栈内存中
堆内存:对象类型的值保存在堆内存中

5种基本数据类型
			undefined ==> 未定义类型
			null ==> 空类型
			boolean ==> 布尔类型
			number ==> 数值类型
			string ==> 字符串类型
1种复杂数据类型
			object ==> 对象

	undefined ==> 未定义类型
		 1) 声明一个变量但未赋值,该变量默认保存的就是undefined
			var a;
			console.log( a );// undefined
			console.log( typeof a );// "undefined"
			
		 2) 如果没有声明变量使用(打印)其值,报错
			console.log( b );// 报错: b is not defined
	    	console.log( typeof b );//"undefined"
	        检测一个没有声明过得变量的类型,并不报错,值为"undefined"

				var a;
				console.log( a );//undefined
				console.log( typeof b );//"undefined"

				var a;
				console.log( b );// 报错 
				console.log( typeof a );// 不执行*/

	null ==> 空类型    空对象指针 
		var timer = null;
		console.log( timer );//null
		console.log( typeof timer );//"object"
		//实际上， undefined 值是派生自 null 值的，因此 ECMA-262规定对它们的相等性测试要返回 true 
		console.log( undefined == null );//true

    boolean ==> 布尔类型 
		// JS数据类型中使用的最多的一种
		// 表示真 与 假的 数据类型
		// true ==> 真
		// false ==> 假
		/*var flag = true;
		console.log( flag );//true
		console.log( typeof flag );//"boolean"*/

	number ==> 数值类型
		/*var num = 10;// 整型
		var num = 3.14;// 浮点型
		// 浮点数最多保存17位小数
		console.log( 0.1 + 0.2 );//0.30000000000000004==> 舍入问题
		console.log( 0.1 + 0.2 == 0.3 );//false
		console.log( 0.15 + 0.25 == 0.4 );//true*/

		 NaN :Not a Number ==> 非数值
		// 但是它是一种特殊的数值类型
		 用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。
		// console.log( "abc" - 2 );//NaN
		// NaN特点:
		 1) NaN不等于任何一个值,包括他本身 ==> 自我否定
		 2) 任何涉及与NaN进行操作,返回值都是NaN
		/*console.log( NaN == NaN );//false  自我否定
		console.log( NaN + 4 );//NaN
		var num = 10;
		console.log( typeof num );//"number"
		console.log( typeof NaN );// "number"*/
		
  isNaN(参数n)

	    判断参数n是否是"非数值"。如果是数值返回false,不是数值返回true;
		
	    说明：isNaN()在接收到一个值之后，会尝试将这个值转换为数值。

			alert(isNaN(NaN)); //true
			alert(isNaN(10)); //false(10是一个数值)
			alert(isNaN("10")); //false(可以被转换成数值10)
			alert(isNaN("hello")); //true(不能转换成数值)
			alert(isNaN(true)); //false(可以被转换成数值1)

	string ==> 字符串类型
		// 定义字符串 "" ''
		/*var str = "hello world";
		var str = 'hello world';
		console.log( str );
		console.log( typeof str );//"string"*/

		 字符串嵌套
		// var str = "name:"zhangsan"";
		/*var str = "name:'zhangsan'";// "''"  '""'
		var str = 'name:"zhangsan"';// "''"  '""'*/
		/*var str = "name:\"zhangsan\"";// 转义字符
		alert( str );*/
		
	数据类型包含一些特殊的字符字面量，也叫转义序列(字符)，用于表示非打印字符 
	        \n  换行
	        \t  制表
	        \b  空格
	        \r  回车
	        \f  换页

		// 字符串属性 ==> length ==> 返回字符串的长度(个数)
		/*var str = "hello world";
		console.log(str.length);// 11
		console.log( typeof str.length );//"number"

		// 字符串索引 ==> str[index]
		index下标范围 ==> [0,length-1]
		console.log( str[0] );//"h"
		console.log( str[10] );//"d"
		console.log( str[str.length-1] );//"d"*/

	 object ==> 对象
		var o = {// 对象字面量
			name:"zhangsan",
			age:23,
			run:function(){
				alert( this.name + "能跑" );
			}
		};
		/*console.log( o.name );//"zhangsan"
		console.log( o.age );//23
		o.run();*/
		console.log( o );
		console.log( typeof o );//"object"

		var o = new Object(); \\构造函数方法创建

typeof

	操作符 ==> 用于检测数据类型
	返回值 一定是 字符串类型
	// typeof 有两种用法:
			// 1) typeof 变量
			// 2) typeof( 变量 )
			数据类型                  		typeof结果
		undefined ==> 未定义类型				"undefined"
		boolean ==> 布尔类型					"boolean"
		number ==> 数值类型					"number"
		string ==> 字符串类型				"string"
		object 或 null 						"object"
		function ==> 						"function"

	少了个null  多了个function	
	console.log( typeof fn );//"function"
	console.log( typeof typeof 5 );//"string"
	console.log( typeof typeof 5 + 6 );//"string6"
	console.log( typeof typeof (5 + 6) );//"string" 
	console.log( typeof  Number);//"function"

数据类型的转换

各种数据类型转   字符串
		 1) 变量.toString()
			// null 和 undefined 是没有toString()这个方法
					  如：	var timer = null;
							console.log( timer );//null
							console.log( timer.toString() );//报错
		2) String( 变量 ) ==> 强转函数
					console.log( String( null ) );//"null"
		3) + 字符串拼接的功能
					console.log( "" + undefined );//"undefined"*/

各种数据类型转   数值
		// 1) Number( 变量 ) ==> 强转函数
			console.log( Number( "123" ) );// 123
			console.log( Number( "123a" ) );// NaN
			console.log( Number( true ) );// 1
			console.log( Number( false ) );// 0
			console.log( Number( null ) );// 0
			console.log( Number( undefined ) );// NaN  
			console.log( Number( "abc" ) );// NaN  
			console.log( Number( "true" ) );// NaN  
			// 转换数值为0的有: null false "" " " "0" []
			
				// JS专门提供了将字符串转数值的两个方法
		// 2) parseInt() ==> 取整
			console.log( parseInt("123abc") );//123
			console.log( parseInt("12.3abc") );//12
			console.log( parseInt( "a12.3" ) );//NaN
			console.log( parseInt( "1010",2 ) );//10
			console.log( parseInt( 3.14 ) );//3
			console.log( parseInt( 3.94 ) );//3
		// 3) parseFloat() ==> 取浮点数
			console.log( parseFloat("3.14.15abc") );//3.14
			console.log( parseFloat("314abc") );//314
			console.log( parseFloat("a3.14bc") );//NaN

各种数据类型转   布尔值
	// Boolean( 变量 )  ==> 强转函数
			转布尔值为false有: false  ""  0  NaN  null  undefined 
 		 	console.log( Boolean( [] ) );//true
		    console.log( Boolean( {} ) );//true 

运算符

// 1) 加性运算符
		// + 加法
			console.log( 4 + true );//5 ==> 4 + Number(true) ==> 5
			console.log( "4" + true );// "4true"
		// - 减法
			console.log( "4" - true );// 3
			// "4" - true ==> Number("4") - Number(true) ==> 3
			console.log( "3" - null );// 3
			console.log( true - undefined );// NaN ==> 1 - NaN
	// 2) 一元加减操作符
		// +
			console.log( +"4" );//4  Number("4")
			console.log( +true );//1
		// -
			console.log( -"4" );//-4 -Number("4")
			console.log( -true );// -1

		console.log( +"4" + 4 + "4" );//"84" ==> 4 + 4 + "4" ==> 8 + "4"

	// 3) 乘性运算符
		// * 乘法
			console.log( "4" * true );// 4
			console.log( "4" * null );// 0
			console.log( "4" * undefined );// NaN
			console.log( "abc" * true );//NaN
		// / 除法
			console.log( "6" / "2" );// 3
			console.log( true / false );// Infinity
		// % 取余
			console.log( 3 % 4 );// 3   前面数值小
			console.log( 4 % 2 );// 0
			console.log( 4 % 3 );// 1
			console.log( 99 % 100 );// 99
			console.log( 101 % 100 );// 1
	// 4) 递增递减运算符
		// 后置型  
			// 先赋值 再自增自减
			//i++  
			//i--
			/*var i = 10;
			var sum = i++;//10
			console.log( i );// 11
			console.log( sum );// 10

			var i = 10;
			var sum = i--;
			console.log( i );// 9
			console.log( sum );// 10*/


		// 前置型
			// 先自增自减 再赋值
			// ++i
			// --i
			/*var i = 10;
			var sum = ++i;
			console.log( i );//11
			console.log( sum );// 11

			var i = 10;
			var sum = --i;
			console.log( i );// 9
			console.log( sum );// 9*/

			var i = 4;
			var sum = i++ + ++i + i-- + --i + i;
			//  sum =  4  +  6  +  6  +  4  + 4;
			//   i  =  5	 6	   5	 4
			console.log( i );// 4   
			console.log( sum );// 24 

	// 5) 相等运算符
		// 相等比较 ==> 仅仅比较数值,不比较类型
			// ==  相等
				/*console.log( 5 == "5" );//true
				console.log( undefined == null );// true
				console.log( 1 == true );//true
				console.log( "" == "0" );//false    相同类型就不隐式转换了
				console.log( false == "" );//true*/
				
				// null 只能与null 和 undefined 比较返回true 其他全为false
				console.log( null == 0 );// false

			// !=	不等
				console.log( 5 != "5" );//false
				console.log( NaN != NaN );//true

		// 全等比较 ==> 不仅比较类型 还有比较值
			// === 全等 
				console.log( 5 == "5" );// true
				console.log( 5 === "5" );// false
				console.log( 5 === 5 );//true

			// !== 不全等
				console.log( 5 != "5" );//false
				console.log( 5 !== "5" );//true
	// 6) 比较运算符
		// >  >=  <  <=
		console.log( 4 > 2 );//true
		console.log( 4 > 4 );//false
		console.log( 4 >= 4 );//true
		console.log( 12 > "2" );// true
		console.log( "12" > "2" );// false ==> 都是字符串比较ASCII值    0  48   A  65   a  97
		console.log( "21" > "2" );//true
		
		console.log( 5 > "abc" );// false  5 > NaN
		console.log( 5 < "abc" );// false 5 < NaN
		console.log( 5 == NaN );// false

	// 7) 逗号运算符
		// 一般用于声明多个变量
		/*var a = 1, b = 2 , c = 3;

		var a = (1,2,3,4,5);// a = 1 a = 2 a = 3 a = 5
		console.log( a );//5
		
		、、在赋值
		var a;
		a = 1,2,3,4,5;
			  无效语句
		console.log( a );// 1

		、、在声明变量，数字不能作为变量名
		var a = 1,2,3,4,5;
		console.log( a );// 报错*/

// 8) 条件运算符 ==> 三元运算符 ==> 三目运算符
		// 变量或语句 ? 变量或语句 : 变量或语句
		// 如果?前的语句为真，则执行?后的语句 
		// 如果?前的语句为假，则执行:后的语句
		/*var a = 14,
			b = 12;
		var maxNum = a > b ? a : b;
		console.log( maxNum );// 14

		// 三元运算符可以替代简单的if语句
		var a = 14,
			b = 12;
		if( a > b ){
			var maxNum = a;
		}else{
			var maxNum = b;
		}*/

	// 9) 赋值运算符
		// 简单赋值运算符  = 
			var a = 10;

		// 复合赋值运算符
			// +=  -=  *=  /=  %=  >>=  <<=  <<<=
			var a = 10;
			a += 5; // a = a + 5
			console.log( a );// 15

			var a = 10;
			a -= 5;// a = a - 5
			console.log( a );// 5

			var i = "4";
			i += i++ + ++i;
			// i +=  10 ==> i = i + 10 ==> i = "4" + 10 ==> "410"
			console.log( i );//"410"
			
逻辑运算符（布尔运算符）
逻辑运算符有3种： &&（与）、||（或）、 ! （非）
  * 优先级 ! > &&  > ||  
  * &&（与）：
	1)返回第一个为假的值。==》 找假
	2)都为真时返回最后一个为真的值。		
  * ||（或）：
	1)返回第一个为真的值。==》 找真
	2)都为假时返回最后一个为假的值。
  * ! （非）
    说明：
	1)、无论运算数是什么数据类型，逻辑非都会返回一个布尔值 ==》 非真即假 非假即真
	2)、同时使用两个逻辑非运算符时，第一个逻辑非运算会基于无论
	什么运算数返回一个布尔值，而第二个逻辑非则对该布尔值求反。 
	！！变量 ==》 Boolean(变量) 

输入弹出框 prompt()

	// prompt( 提示字符串1 , 提示字符串2 );
	// 点击确定,返回输入的内容 ==> 字符串
	// 点击取消或关闭, 返回 null 
	var score = prompt( "请输入您的成绩" , "成绩介于0-100之间" );
	console.log( score );//
	console.log( typeof score );