javascript 不让成为nan_javascript学习笔记

(常用指令,输出语句）
(js中严格区分大小写.)
(js中每一条语句必须用分号( ; ）结尾，英文分号.）

创建js

(需要创建一个js外部文件，会将js代码编写在外部JS文件中，通过script标签引入）
<script type="text/javascript" src="js/script.js">
<script>
</script>
(将js代码编写在内部文件中，通过script标签引入）
<script type="text/javascript">
</script>

输出语句

alert(" ");（控制浏览器弹出一个警告框）
document.write(" "); （让计算机在页面中输出一个内容）
console.log(" ");（向控制台输出一个内容）
console.time(“ ”）（定义一个计时器）
consloe.timeEnd(" ")(停止计时器)
prompt( " " )(可以弹出一个提示框，该提示框会带有一个文本框，用户可以在文本框中输入一段内容，该函数需要一个字符串作为参数，该字符串将会作为该文本框的提示文字) 

标识符

(标识符）
在js中，所有的可以有我们自主命名的都可以是标识符，
例如：变量名，函数名，属性名都可以属于标识符。
命名一个标识符时需要遵守的规则：
1;标识符中可以含有字母，数字，_  ，$。
2:但是标识符不能以数字开头。
3:标识符不能是es中的关键字或保留字。
4:规范的标识符一般都采用 驼峰命名法 ，首字母小写，随后每个单词的开头字母都是大写，其余都是小写。  示例：HelloWorld

字面量，变量

(字面量，变量）
字面量，都是一些不可改变的值，一般不直接使用字面量，而是通过变量去保存一个字面量。
在js中使用var关键词来声明一个变量，然后为变量赋值（字面量）
var a = 123;

数据类型

(数据类型）
(数据类型指的是字面量的类型）
(在js中有六种数据类型，其中1-5属于基础数据类型，6属于引用数据类型)
(基础数据类型都是单一的值，值和值之间没有任何的联系，创建的变量都是独立，不能成为一个整体，对象属于一种复合的数据类型，在对象中可以保存多个不同数据类型的属性）
(可以使用typeof来检查一个变量的类型，语法：typeof 变量）

string（字符串）
在js中字符串需要使用引号“”引起来，使用单引号或双引号都行，但不能混用，但可以用单引号来嵌套双引号。                                                              
想表示一些特殊符号时可以使用来进行转义:(" 表示“ ”）(' 表示‘ ’)(n 表示换行)(t 表示制表符)(表示 )

Number（数值）
在js中所有的数值都是Number类型，包括整数和浮点数(小数）
可以用Number表示的数字最大值，（Number.MAX_VALUE)
如果使用Number表示的数字超过了最大值，则会返回一个Infinity
Infinity 表示正无穷大    -Infinity  表示负无穷大
可以用Number表示的数字最小值，（Number.MIN_VALUE) 大于0的正数
NaN 是一个特殊的数字，表示Not A Number,使用typeof检查一个NaN也会返回一个NaN
如果使用js进行浮点运算，可能得到一个不精准的结果。

Boolean（布尔值）
布尔值只要两个   true(表示真)          false(表示假)
使用tpeof检查一个布尔值时，会返回boolean

Null（空值）
Null类型的值只有一个，就是null
null这个值专门用来变化一个空的对象
使用typeof检查一个null值时，会返回object

Undefined（未定义）
Undefined(未定义)类似的值只有一个，就是undefind
当声明一个变量，但是并不给变量赋值时，它的值就是undefind
使用typeof检查一个Undefined时也会返回undefind

对象

Object（对象）
1：内建对象
比如：Math   String   Number   Boolean   Functin   Object ……

2：宿主对象
由js的运行环境提供的对象，目前来讲主要指由浏览器提供的对象
比如 BOM  DOM

3：自定义对象
由开发人员自己创建的对象

1：创建对象
使用new调用的函数，是构造函数constructor
构造函数是专门用来创建对象的函数
使用typeof检查一个对象时，会返回object
在对象中保存的值称为属性
var obj = new Object（）；

2：向对象添加属性
语法： 对象.属性名 = 属性值；
obj.name = “猪八戒”；
向obj中添加一个gender属性
obj.gender = “男”；
向obj中添加一个age属性
obj.age = “18”；

3：读取对象的属性
语法： 对象.属性名
如果读取对象中没有的属性，不会报错而是会返回undefined
console.log（obj.gender）；
console.log（obj.hello）；

4：修改对象的属性值
语法：对象.属性名 = 新值
obj.name = “tom”；

5：删除对象的属性
语法：delete 对象.属性名
delete obj.name；
console.log（obj.age）；


属性名：
如果使用特殊的属性名，不能采用 .  的方式来操作
需要使用另一种方式：
语法：对象[“属性名”] = 属性值
读取时也需要采用这种方式
使用[ ]这种形式去操作属性，更加的灵活，在[ ]中可以直接传递一个变量

属性值：
js对象的属性值，可以是任意的数据类型

in 运算符
通过in 可以检查一个对象中是否含有指定的属性
如果有则返回true，没有则返回false
语法：“属性名”in 对象
console.log（“name”in obj）；

(枚举对象中的属性)
使用for。。。in 语句 对象中有几个属性，循环体就会执行几次
每次执行时，会将对象中的一个属性的名字赋值给变量
语法：
for（var n in obj ）{
console.log(“属性名：”+n)；
console.log("属性值：“+obj [n] ）;
}

(对象的字面量）
使用对象字面量，可以在创建对象时，直接指定对象的属性
语法{属性名：属性值，属性名：属性值 ……}；
示例：：
var obj = { 
name：“猪八戒”，
age：18，
gender：“男”
}；
属性名和属性值是一组一组的名值对结构，名和值之间使用：连接，多个名值对之间使用 ，（逗号）隔开，如果一个属性之后没有其他的属性了，就不需要写

栈内存与堆内存

(栈内存与堆内存）
js中的变量都是保存到栈内存中的，
基本数据类型的值直接在栈内存中存储
值和值直接是独立存在，修改一个变量不回影响其他的变量

对象是保存在堆内存中的，每创建一个新的对象，就在堆内存中开辟出一个新的空间
而变量保存的是对象的内存地址（对象的引用）如果两个变量保存的是同一个对象引用
当一个对象通过一个变量修改属性时，另一个也会受到影响

当比较两个基本数据类型的值时，就是在比较它们的值
而比较两个引用数据类型时，比较的是对象的内存地址
如果两个对象是一摸一样的，但是地址不同，它也会返回false

强制类型转换

(强制类型转换)

一：将数据类型转换为(字符串)
方式一：toString(  )
调用被转换数据类型的 toString(  ) 方法
该方法不会影响到原来的变量，它会将转换的结果返回
但是注意：null和undefined这两个值没有 toString(  ) 方法如果调用它们会报错
方法二：String(  )函数
调用 String (  )函数，并将被转换的数据作为参数传递给函数
使用 String (  )函数做强制类型转换时，
此方法 对于Number和Boolean实际上就是调用的 toString(  ) 方法
但是对于null和undefined，就不会调用 toString(  ) 方法
它会将null直接转换为 "null"(字符串）  也会将undefined直接转换为"nudefined"(字符串)


二：将数据类型转换为(数值)
调用Number( xx )函数 将括号中 xx 转换为Number类型
方式一：
(字符串) 转为 (数值)
1.如果是纯数字的字符串，则直接将其转换为数字
2.如果字符串中有非数字的内容，则转换为NaN
3.如果字符串是一个空串或者是一个全是空格的字符串，则转换为0

(布尔值) 转为 (数值)
true 转为 1          false 转为 0

null(空值)转为 数值 为 0

undefined (未定义) 转为 数值为 NaN


方式二：
这种方法专门用来对付字符串
1：调用parseInt(  )函数将括号中xx转换为Number
parseInt(  )可以将一个字符串中的有效的整数内容取出来，然后转换为Number
1：调用parseInt(xx)函数 将括号中xx转换为Number)类似，不同的是它可以获得有效的小数。


三：将数据类型转换为(布尔值)
使用Boolean( xx )函数将括号中xx转换为Boolean
1：(数值)转为(布尔值)
除了0和NaN,其余的都是true

2:(字符串)转换为(布尔值)
除了空串，其余的都是true

3:null和undefined都会转换为false     对象也会转换为true

运算符

(运算符)
运算符也叫操作符，通过运算符对一个或多个值进行运算，并获取运算结果
比如：typeof就是个运算符，可以用来获得一个值的类型，它会将该值的类型以字符串的形式返回

(算数运算符)
当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算
+（加法）
+  可以对两个值进行加法运算，并将结果返回，如果对两个字符串进行加法运算，则会做拼串，会将两个字符串拼接成一串，并返回
任何的值和字符串做加法运算，都会先转换为字符串，然后在拼串可以利用这一特定，来将一个任意的数据类型转换为String,只需要为任意的数据 类型加一个“”即可将其转换为String，这是一个隐式的类型转换，由浏览器自动完成，实际上它调用String( )函数

-（减法）*（乘法） /（除法）
-  任何值做 -   *  /  运算是都会自动转换为Number
我们可以利用这一特点做隐式的类型转换，

%（取模运算，取余数）

(一元运算符,只需要一个操作数）
+  正号   正数不会对数字产生任何影响
-   负号   负号可以对数字进行负号的取反
对于非Number类型的值，它会将先转换为Number,然后在运算，可以对一个其他的数据类型使用+，来将其转换为number，他的原理和Number(  ）函数一样

(自增和自减）
(++ 自增)
通过自增可以使变量在自身的基础上增加 1，对一个变量自增以后，原变量的词会立即自增 1
自增分为两种：后++（a++）和 前++（++a），无论是a++ 还是++a 都会立即使原变量的值自增 1，不同的是a++和++a的值不同
a++   的值是原变量的值（自增前的值）
++a   的值是新值（自增后的值）

(-  - 自减)
通过自减可以是变量在自身的基础上减 1
自减分成两种：后- -（a- -）和前- -（- -a），无论是a- - 还是 - -a 都会立即使原变量的值自减1，不同的是a- -和- -a的值不同
a- - 的值是原变量的值 （自减前的值）
- -a 的值是新值 （自减后的值）

(逻辑运算符）
js中为我们提供了三种逻辑运算符
(！非)
！可以用来对一个值进行非运算
所谓非运算就是指对一个布尔值进行取反操作，true变false，false变true，
要是进行两次取反！则会不发生变化
如果对非布尔值进行运算，则会将其转换为布尔值，然后在取反，利用这一特点，将任意数据类型转换为布尔值，将一个任意类型取两次反，来将其转换为布尔值

(&& 与)
&&可以对符合两边的值进行 与运算 并返回结果
运算规则
只有两个值都是true才会返回true
两个值中只要有一个值为false，都会返回false

(|| 或）
||或 可以对符号两侧的值进行 或运算 并返回结果
运算规则
只有两个值都是false才会返回false
两个值中只要有一个true，都会返回true

(&& 与运算)和(||或运算) 在非布尔值的情况运算)
对于非布尔值进行 与和或 的运算时，会先将其转换会布尔值，再进行运算，并且返回原值

(与运算)
如果第一个值为true，则必然返回第二个值
如果第一个值为false，则直接返回第一个值
如果两个值都为true，则返回后边的，谁在后边返回谁
如果两个值中有false，则返回靠前的false

(或运算)
如果第一个值为true，则必然返回第一个值
如果第一个值为false，则直接返回第二个值


(赋值运算符）
=  可以将符号右侧的值赋值给符号左侧的变量
+=   a+=5 等价于 a=a+5
-=    a-=5  等价于 a=a-5

(关系运算符）
通过关系运算符可以比较两个值直接的大小关系
如果关系成立它会返回true。如果关系不成立则会返回false，例如  2<1成立  1>2不成立


(非数值的比较情况）
对于非数值进行比较时，会将其转换为数字然后再比较
如果符号两侧的值都是字符串时，不会将其转换为数字进行比较，而会分别比较字符串中字符的Unicode编码（词典），比较字符编码时是从首字母开始一位一位向后进行比较，两位一样则比较下一位
注意：在比较两个字符串型的数字时，一定要转型，不然结果会出问题



(相等运算符)
使用==来做相等运算
相等运算符用来比较两个值是否相等，如果相等会返回true，否则返回false
当使用==来比较两个值时，如果类型不同，会自动将其转换为相同类型在进行比较，大部分情况会转换为数字

undefied衍生自null，这两个值做相等判断时，会返回true
NaN不和任何值相等，包括它本身
所以判断一个值是否为NaN，可以通过  isNaN( ）来判断，如果该值是NaN 则返回true，否则返回false

(不相等运算）
使用！= 来做不相等运算
用来判断两个值是否不相等，如果不相等会返回true，否则为false
不相等运算也会对变量进行自动的类型转换，如果转换后相等它也为false

(全等运算）
使用===来做全等运算，需要两个数据类型都相等
用来判断两个值是否全等，和相等运算相似，不同的是它不会自动对类型进行转换，
如果两个值的类型不同，直接返回false

(不全等运算）
使用 ！==来做不全等运算
用来判断两个值是否不全等，和不等运算相似，不同的是它不会自动对类型进行转换，
如果两个值的类型不同，直接返回ture


(条件运算符)
条件运算符也叫三元运算符
语法：
条件表达式？语句1：语句2；
a>b？alert（“语句a”）：alert（“语句b”）；
执行的流程：
条件运算符在执行时，首先对条件表达式进行求值，
如果该值为true，则执行语句1，并返回结果
如果该值为false，则执行语句2，并返回结果
如果条件的表达式的求值结果是一个非布尔值，会将其转换为布尔值然后再运算

(运算符的优先级）

数字运算和数学一样 先乘除 后加减

表格：

遇到优先级不清楚的，可以用括号（ ）来改变优先级

流程控制语句，条件判断语句

(流程控制语句）
通过流程控制语句可以控制程序来执行流程，使程序可以根据一定的条件来选择执行
语句的分类：
1：条件判断语句
2：条件分支语句
3：循环语句

(条件判断语句）
使用条件判断语句可以执行某个语句之前进行判断
如果条件成立才会执行语句，条件不成立则语句不执行

if语句

(if语句）
语法一：
if（条件表达式）{
语句……
}
if语句在执行时，会对条件表达式进行求值判断
如果条件表达式的值为true，则执行if后的语句
如果条件表达式的值为false，则不会执行if后的语句
if语句只能控制紧随其后的语句，如果希望if语句可以控制多条语句，可以将这些语句统一放在代码块中，if语句的代码不是必须的，但在开发中尽量写上

语法二：
if(条件表达式）{
语句……
}else{
语句……
}
当该语句在执行时，会先对if后的条件表达式进行求值判断
如果条件表达式的值为true，则执行if后的语句
如果条件表达式的值为false，则执行else后的语句

语法三：
if(条件表达式）{
alert("……");
}else if(……){
alert("……");
}else if(……){
alert("……");
}else {
alert("……")；
}
当该语句在执行时，会从上到下依次对条件表达式进行求值判断
如果条件表达式的值为true，则执行当前的语句
如果条件表达式的值为false，则继续向下判断
如果所有的条件都不满足，则执行最后一个else后的语句
该语句中，只会有一个代码块被执行，一旦代码块执行了，则直接结束语句

循环语句

(while循环）
循环语句：
通过循环语句可以反复的执行一段代码多次
语法：
while（条件表达式）{
语句……
}
while在执行时，先将条件表达式进行求值判断
如果值为true，则执行循环体，循环体执行完毕以后，继续对表达式进行判断
如果为true，则继续执行循环体，以此类推，如果为false，则终止循环

创建一个循环，需要三个步骤
1：创初始化一个变量
var i = 0；
2：在循环中设置一个条件表达式
while（ i <= 10）{
alert（i）；
}
3：定义一个更新表达式，每次更新循环初始化变量
document.write（i++ +"<br  />”）

(while 练习）
var money = 1000;
	var count = 0;
	while(money < 5000){
		money *= 1.05;
		count++
	}
	console.log("一共需要"+count+"年");

 
(do...while循环)
语法：
do{
语句……
}while（条件表达式）

执行流程：
do…while语句在执行时，会先执行循环体，
循环体执行完毕以后，在对while后的条件表达式进行判断，
如果结果为true，则继续执行循环体，执行完毕继续判断以此类推
如果结果为false，则终止循环
do ...while与while功能相似，不同的是while是先判断后执行，do…while是先执行后判断
do…while可以保证循环体至少执行一次，而while则不能

练习：
var a =100;
do{
}while(a<500)
console.log(a);


(for循环）
在for循环中，为我们提供了专门的位置用来放三个表达式，
1：初始化表达式
2：条件表达式
3：更新表达式

for循环的语法：
for(var a=1 ；a<=100; a++ )
console.log(a);
}
 

for循环的执行流程：
1：执行初始化表达式，初始化变量（初始化表达式只会执行一次）
2：执行条件表达式，判断是否循环，如果为true，则执行循环，如果为false，终止循环
3：执行更新表达式，更新表达式执行完毕，继续重复


(break）
break可以用来退出witch或循环语句 终止全部循环，只对最近的循环起作用
可以在break、后跟着一个label（outer），这样berak将会结束最近的循环

(continue）
continue可以用来终止当次循环，与break不同的是，默认只对最近的循环起作用

质数练习

(质数练习）

//预先打印2-100之间的数
for(var i = 2 ; i <=100 ; i++){
var flag = true;
for(var j=2 ; j<Math.sqrt（i） ; j++){
if( i%j == 0){
//如果进入判断则证明i不是质数，修改flag值为false
flag = false;
//一旦进入判断，则证明i不可能是质数了，此时循环再执行已经没有任何意义了
//使用break结束循环，来提升性能
break;
}
}
//判断是否为质数，是 则打印 i 的值
if(flag){
console.log( i );
}
}
var result = Math.sqrt（97）；

(Math.sqrt）
Math.sqrt（“”）可以用于开方，缩小取值范围

函数

(函数）
函数中可以封装一些功能（代码，在需要时可以执行这些功能（代码）
函数中可以保存代码，可以在需要的时候调用

语法：
	function 函数名([形参1，形参2……]){
	语句……
	}
示例：
function fun2( a,b )（形参）{
	console.log(a+b);
}
fun(1,2);(实参)
fun2(  );（可以随时调用fun2）

(立即执行函数）
函数定义完，立即被调用，这种函数叫做立即函数
立即执行函数只能执行一次
(function(a,b）{
console.log("a="+a);
console.log("b="+b);
} (1,2);


(this）
解析器在调用函数时每次都会向函数内部传递一个隐含的参数
这个隐含的参数就是this，this指向的是一个对象
这个对象我们称为函数执行的上下文对象
根据函数的调用方式不同，this会指向不同的对象：
1：函数的形式调用时，this永远都是window
2：以方法的形式调用时，this就是调用方法的那个对象



(形式参数）
可以在函数的（）中指定一个或多个形参
多个形参可以直接使用 ，（逗号）隔开，声明形参就相当于在函数内部声明了对应的变量，但不赋值

(实际参数）
在调用函数时，可以在（ ）中指定实参，实参将会赋值给函数中对应的形参
函数的实参可以是任意一个数据类型

(返回值）
可以使用return来设置函数的返回值，返回值可以是任意的数据类型，也可以是一个函数
语法：return 值
return后的值将会作为函数的执行结果返回，可以定义一个函数来接收该结果
变量result的值就是函数的执行结果，函数返回什么result的值就是什么
return后的语句都不会执行，如果函数中不写return，会返回undefined


(练习)
//定义一个函数，可以根据半径计算一个圆的面积，并返回计算结果
		function mianji(r){
			return 3.14*r*r;
 		}
 		result = mianji(5);
	console.log("result ="+result);


//创建一个函数，可以在控制台输出一个人的信息
function sayHello(o){
console.log("我是"+o.name+",今年我"+o.age+"岁了,我是一个"+o.gender+"人"+",我住在"+o.address);
}
sayHello({
	name:"dj",
	age:18,
	gender:"男",
	address:"赵家班"
});


// 实参可以是一个对象，也可以是一个函数
function fun(a){
console.log(",a="+a);
a(obj);
}
fun(sayHello);

作用域

(作用域)
作用域指一个变量的作用范围
js中作用域有两种：
1：全局作用域
直接编写在script便签中的js代码，都在全局作用域
全局作用域在页面打开时创建，在页面关闭时销毁
在全局作用域中有一个全局对象window，它代表的是浏览器的窗口，由浏览器创建，我们可以直接使用
在全局作用域中：
1：创建的变量都会作为window对象的属性保存
2：创建的函数都会作为window对象的方法保存

2：函数作用域
调用函数时创建函数作用域，函数执行完毕以后，函数作用域销毁
每调用一次函数就会创建一个新的函数作用域，它们之间是互相独立的
在函数作用域中可以访问到全局作用域的变量，在全局作用域中无法访问到函数作用域的变量
当在函数作用域操作一个变量时，它会先在自身作用域中寻找，如果有就直接使用
如果全局作用域中依然没有找到，则会报错
在函数中要访问全局变量可以使用window对象