javascript基础知识点

JavaScript编写的位置：

<1>- 将js代码编写到script标签中
    <script type="text/javascript">
            ...... (alert("hello");)
        </script>

<2>- 将js代码编写到外部的js文件中 , 然后使用script标签来引入外部文件,注意script一旦用于引入外部文件，则不能再编写js代码了，如果想写，则需要创建一个新的标签:
<script type="text/javascript" src="js文件的路径（js/script.js）">
</script>
            <script type="text/javascript">
              ...... (alert("我是内部的JS代码~~");)
            </script>

<3>- 可以将JS代码编写到标签指定的属性中
       - onclick 点击之后才会出现的情况
<button onclick="....{alert('点我干嘛');}">点我一下</button>    
    - 也可以将JS代码编写到超链接的href属性中
<a href="javascript:....{alert('让你点');}">点我一下</a>
     注意：（如外部有双引号" ",则内部的引号就要用单引号' '）        
- 以下这种超链接，点击以后不会有任何行为
    <a href="javascript:;">你也点我一下</a>

JS的三种语句输出：

        - 让浏览器弹出一个警告框
                alert("弹出的内容");
        - 在浏览器窗口中显示一个内容,向body中输入一个内容
                document.write("在浏览器窗口显示的内容");
        - 向控制台中输出一个内容
                console.log("在控制台显示的内容");

JS的注释

    - //单行注释
    - /*
       * 多行注释
      */
    - 在JS中严格区分大小写，每条语句用 ; 结尾

字面量和变量

• 字面量
  
  • 字面量就是一个值，字面量都是固定不变的。
    比如 1 2 3 4 5 “a” “b” “c”…,在JS中所有的字面量都是可以直接使用的,但是一般不会直接使用字面量，因为使用起来不方便
• 变量 关键字 var
  
  • 变量可以用来保存字面量，并且可以通过变量来使用字面量,变量中保存的字面量是可以改变的
  • 一般我们都是通过变量来保存一个字面量，然后使用，而不直接使用字面量
• 通过变量对字面量进行描述
  
  • 声明变量，在JS中使用 var关键字 来声明一个变量
    var 要声明的量; 使用 = 为变量赋值
  • 可以同时声明多个变量 var d , e , f ;
  • 可以声明和赋值同时进行 var g = 100;
  • 可以同时声明并赋值多个变量 var h = 1 , i = 2 , j = 3;
  • 常量 关键字 const
  • 当声明变量或是常量时，都不使用关键字时，在默认情况下，得到的都是变量。在实际开发中都要写上关键字。
  • 在声明“变量”时通常使用“全小写”；在声明“常量”时通常使用“全大写”。
  • 常量在第一次声明时就要赋值。常量被重新赋值时，就会报错。
    若重新声明，无论重新声明成变量还是常量还是会报错。总结得出常量必须在第一次声明时就赋值，并且不能重新声明或是赋值，会导致报错。
• 使用 var 语句重复声明变量是合法并且无害的，就是说变量可以多次的声明不会有影响。

标识符

• 在JS中所有自己命名的内容都是可以认为是一个标识符
  比如：变量名 函数名 属性
• 标识符需要遵循以下规范：
  
  1. 标识符中可以含有字母 数字 _ $，但是不能以数字开头
  2. 标识符不能是JS中的关键字和保留字
  3. JS中的标识符采用驼峰命名法
     - 首字母小写，每个单词的开头字母大写
     - 例子：helloWorld xxxYyyZzz
     - 在JS中标识符底层实际上是以Unicode编码保存的,所以理论上Unicode编码中的内容都可以作为标识符

数据类型

在JS中一共有6种数据类型：
String 字符串 Number 数值 Boolean 布尔值 Null 空值
Undefined 未定义 Object 对象
- 基本数据类型：String Number Boolean Null Undefined
- 引用数据类型：Object

字符串String

    - 在JS中，字符串都需要使用引号＂＂括起来，使用双引号或单引号都可以，没有任何区别
    - 引号不能嵌套    
    - 在JS中使用 \ 作为转义字符
　　  \"  -->  "　　　　  \'  -->  '　　　   \\  -->  \
　　\n  --> 换行　　　 \t  --> 制表符 \uxxxx --> Unicode编码

Number

• 在JS中所有的数字（包括整数和浮点数）都是Number类型
  　var a = 1; 　　//数字1
  　var b = “1”; 　//字符串1
  － typeof运算符
  
  • 通过typeof可以来检测一个变量的类型
    
    • 语法：typeof 变量
    • 使用typeof检查一个数值时，会返回number
      检查一个字符串时，会返回string
      　　　　console.log(typeof b);
• instanceof 检查变量是否是一个包装的类型
  -语法：
  变量 instanceof 包装类型（Number Boolean String）
  －JS中可以表示的数字的最大值
  Number.MAX_VALUE 可以表示数字的最大值
  1.7976931348623157e+308
  Number.MIN_VALUE 可以表示数字的最小值
  5e-324
  Infinity无穷，如果数字超过了可以表示的范围，则会返回Infinity
  NaN
  - Not a Number 非法的数字
• 注意 Infinity和NaN的类型都是Number
  
  • 八进制数字，以0开头
  • 十六进制数字，以0x开头
  • 二进制的数字，以0b开头，不是所有的浏览器都支持
• 在JS中在对数字做运算时，大部分的整数元素都可以得到一个精确的结果，但是做浮点数运算时，有可能得到一个不可预期的结果
  －注意：在JS中，涉及到钱的运算都不要做。

Boolean(布尔值)

    - 在JS中，可以通过布尔值来做一些逻辑判断
    - 布尔值只有两个 true(真的) 和 false(假的)
    - 使用typeof检查一个布尔值时，会返回boolean

null（空值）

    - 它专门用来表示一个为空的对象
    - Null类型的值只有一个 null,它存在，但不指向任何值
    - 使用typeof检查Null类型的值时会返回object
    - 在实际开发中，null用来释放资源。当设置一个变量之后不再使用时，就会使用 变量名=null 来释放资源。

undefined(未定义)

- 当声明一个变量但是没有为变量赋值会返回undefined
- 声明并赋值为undefined
- 获取使用了一个对象中没有的属性也会返回undefined
- 在函数中不明确指定return时也会返回undefined
- undefined类型的值只有一个 undefined
- 使用typeof检查一个undefined类型的值时，会返回undefined，它存在，但没有值

• null 和 undefined 都表示空，
  console.log(null == undefined) //true

类型的转换

指将其他的数据类型转换为String Number 或 Boolean

将其他数据类型转换为String

• 在实际开发中，常使用的是显示转化类型。
  
  • 显示类型转换
    
    1. 调用被转换类型的toString()方法
       谁谁的什么方法 –> 谁谁.什么()
       
       • 这种方式不适用于null和undefined，因为这两个类型的数据中没有toString()方法
       • 当number要转换为string使用该方法时，首先必须将number先定义之后再调用toString()。 变量名.toString()
         例如：var num=100;
         console.log(num.toString());
       • 布尔值可以直接调用toString()方法。
    2. 调用String()函数
       原理：调用String()函数，对于有toString()方法的值，它会调用值toString()来将其转换为字符串
       
       • 对于null值，它会直接转换为”null”
       • 对于undefined ，它会直接转换为”undefined”
         –调用a的toString()方法来将a转换为字符串
         a = a.toString();
         –调用String()函数来将a转换为字符串，需要将被转换为类型作为String函数的参数
         a = String(a);
         –数字类型的toString()中可以接收一个整数作为参数，这样将会使数字转换为指定的进制
         a = a.toString(16);

其他数据类型转换为Number

• 调用Number()函数
• 转换情况：
• 对于字符串
  
  • 如果字符串是一个合法的数字，则直接转换为对应的数字
  • 如果字符串是一个不合法的数字，则转换为NaN
  • 对于空串或纯空格的字符串，直接转换为0
• 对于布尔值
  
  • true 转换为 1 false 转换为 0
• 调用Number（）函数将null 转换的值为 0
• 调用Number（）函数将undefined 转换的值为 NaN

parseInt()和parseFloat()

• 这两个函数专门用来将字符串转换为数字
• parseInt()
  
  • 可以将字符串转换为一个整数
  • 该函数会自左向右来解析一个字符串，它会将字符串中所有的有效的整数转换为Number
• parseFloat()
  
  • 可以将一个字符串转换为一个小数
    和parseInt()用法一样，不同的是它会截取字符串中有效的小数位
    将其他的数据类型转换为布尔值

使用Boolean()函数

• 转换情况：
  
  • 对于数字
    
    • 除了0 和 NaN是false，其余的都是true
  • 对于字符串
    
    • 除了空串，其余的都是true
• 对于null 和 undefined 都是false
• 对象默认情况下都转换为true

运算符（操作符）

- 通过运算符可以对一个或多个值进行各种运算或操作
    - 比如：typeof就是一个运算符,它的作用是检查一个值的类型
- 算数运算符
    +
        - 可以对符号两侧的值进行加法运算
    -
        - 可以对符号两侧的值进行减法运算
    *
        - 可以对符号两侧的值进行乘法运算
    /
        - 可以对符号两侧的值进行除法运算
    %
        - 可以对符号两侧的值进行取模运算（取余数）

- 对于非数字类型的值进行算数运算时，解析器会先将其转换为Number然后再运算

利用该特点：我们可以为一个“任意的数据类型”通过 -0 *1 /1 来将其转换为数字,它的原理和Number()函数一样.

字符串的加法

• 如果对两个字符串进行加法运算，则会对字符串进行拼串操作
• 任何值和字符串做加法，都会将其转换为字符串，然后再做拼串操作，利用这个特点，可以为一个值 +一个空串 的形式来将其转换为字符串，
  它的原理和String()函数一样，但是更加简单
  a=a + “” a是任意一个值，加上一个空串，可将a变为字符串然后在进行拼串。
  - 任何值和NaN 做运算其结果都是NaN

一元运算符 +a -a

一元运算符是只需要一个操作数的运算符
- 一元的+，就相当于正号， 一元的 + 不会对数值产生任何影响 
- 一元的-，就相当于负号，  一元的 - 会对数字符号位取反          *  - 如果对一个非Number类型的值做运算，则会先将其转换为Number，然后再运算，利用该特点，我们可以通过一元的 + 来将一个 “任意的数据类型”转换为Number，它的原理也是使用的Number()函数，但是更加简单

• 自增
  
  • 自增指在原来值的基础上自增1
  • 使用 ++ 来做自增运算，++ 分为前++(++a)和后++(a++)，无论是a++ 还是 ++a 调用后都会立即使原变量增加1，不同的是a++的值和++a的值不同
  • a++的值是变量自增前的值（原值）
  • ++a的值是变量自增后的值（新值）
• 自减
  
  • 自减指在原来值的基础上自减1，使用 – 来做自减运算，– 分为前–(–a) 和 后–(a–)，无论是a– 还是 –a 调用后变量都会立即减1，不同的是a– 和 –a的值不同
• a–的值是变量自减前的值（原值）
• –a的值是变量自减后的值（新值）

逻辑运算符

• 逻辑非（！）
• ！！值，将值转化为布尔类型的值
  
  • !可以对符号右侧的值进行非运算，它会对一个布尔值进行取反操作，true变false，false变true
    
    • 如果对一个非布尔值进行非运算，则会将其转换为布尔值然后再取反
    • 可以利用这个特点来将一个任意的数据类型转换为布尔值，可以通过为一个值取两次反，来将其转换为Boolean。原理和Boolean()函数一样，但是更加简单 *

• 逻辑与(&&) 找错的，返回到是原值
  - &&可以对符号两侧的值进行与运算,如果符号两侧都是true，则返回true，否则返回false，若两个都是false，则输出第二个的原值。

  • JS中的与是短路的与，一旦第一个值为false，则不再看第二个值
    
    • 逻辑或(||) 找对的，返回的是原值
    • ||可以对符号两侧的值进行或运算,如果两端都是false则返回false，否则返回true
    • JS中的或是短路的或，一旦第一个值是true，则不再看第二值

• 对于非布尔值的 与 和 或，它会先将其转换为布尔值，然后做运算,最终返回原值

  • 非布尔值 与 运算(就是找flase)
    
    • 如果第一个值为false，则返回第一个值;如果第一个值为true，则返回第二个值
  • 非布尔值 或 运算(就是找true)
    
    • 如果第一个值为true，则返回第一个值;如果第一个值为false，则返回第二个值
      赋值运算：
• 通过赋值运算符可以将一个值赋值给一个变量 = 就是一个赋值运算符，他可以将符号右侧的值赋值给符号左侧的变量
  += -= *= /= %=
  例如：a+=5 等价于 a=a+5 a*=5 等价于 a=a*5
  关系运算符
• 通过关系运算符可以来比较两个值之间的关系（大小 等于）
  
  • > 判断符号左侧的值是否大于右侧的值,
    如果关系成立，则返回true。否则返回false
    
    • >= 判断符号左侧的值是否大于或等于右侧的值
      如果关系成立，则返回true。否则返回false
    • < 判断一个值是否小于另一个
    • <= 判断一个值是否小于或等于另一个
      
      • 当对 非Number类型 的值做关系运算时，它会先将其转换为Number然后在运算
      • NaN和任何值比较结果都是false
• 特殊情况：
  - 当关系运算符的两端都是字符串时,解析器不会将其转换为Number然后比较，而是比较的字符串的Unicode编码
  
  • 比较Unicode编码时是逐位进行比较，第一位和第一位比，第二个位比，所以利用该特点可以对英文按照字母顺序排序
    
    • 注意，当比较两端的值都是字符串时，也可用 +“字符串”的形式将其转化为Number类型值，则两边就会用数值来作比较了。
      相等运算符 ==
    • 通过 == 可以来判断两个值是否相等，如果相等则返回true，否则返回false
    • 如果符号两侧的值的类型不同，则相等运算会做自动的类型转换，来将其转换为相同的类型，然后在比较.
    • 一般情况下都是转换为Number然后再比较，但是不确定
      由于undefined衍生自null，所以这两个值做相等比较时，会返回true
      全等运算符 ===
    • ===可以用来判断两个值是否全等，它和相等的用法一样，不同的是全等不会做自动的类型转换。如果两个值的类型不同，直接返回false
• NaN不与任何值相等，包括它自己
• 判断a是否是NaN，不能通过相等运算来判断一个变量是否是NaN

• 在JS中为我们提供了一个isNaN()函数：
  专门用来检查一个值是否是NaN，如果是则返回true，否则返回false
  例如：isNaN(a);
  !=

  • 不等运算，可以用来检查两个变量是否不相等， 如果不相等则返回true，否则返回false
  • 不等运算会做自动的类型转换，如果两个值转换后相等，也会返回false

  !==

  • 不全等，可以用来检查两个变量是否不全等,如果不全等则返回true，否则返回false
  • 它和不等运算类似，不同的是它不会做自动的类型转换,如果两个值的类型不同，则直接返回true

三元运算符（三目运算符）

• 三元运算符需要三个操作数: ?:
• 语法：
  条件表达式?表达式1:表达式2
• 执行流程：
  条件运算符在执行时，会先对条件表达式进行求值判断,如果判断结果为true，则执行表达式1，并返回执行结果;如果判断结果为false，则执行表达式2，并返回执行结果。
  运算符的优先级由高到低是：（） ++，– ！ 算数运算符 && ||

条件判断语句（if语句）

注意：条件语句只执行一次，当执行完之后就跳出语句判断，不会再执行其他的了。

        - 语法：
                if(条件表达式){
                            语句 ...
                        }

    - 执行流程：
    if语句在执行时，会先对条件表达式进行求值判断，如果判断结果为true，则执行if后的语句如果判断结果为false，则不执行  
     if只对紧随其后的那个语句起作用，如果希望if可以控制多个语句，可以在if后跟着一个代码块，代码块是可选的，但是为了代码的清晰，建议if后即使只有一条语句，也要使用代码块

if语法2
          - if(条件表达式)
{
                  语句...
        }
else
{
                 语句...
            }

    执行流程：
         if...else语句，在执行时先对if后的条件表达式进行求值判断，如果判断结果为true，则执行if后的语句，如果判断结果为false，则执行else后的语句

if语法3
        if(条件表达式){
                语句...
     *   }else if(条件表达式){
            语句...
         }else if(条件表达式){
                语句...
         }else{
            语句...
         }
执行流程：
    if...else if...else语句，

在执行时会自上向下依次对条件表达式进行求值判断，如果判断结果为true，则执行当前if后的语句，执行完毕语句结束，如果判断结果为false，则继续向下判断，直到有为true的为止
如果所有的条件表达式都是false，则执行else后的语句，if…else if…else语句只会执行一个代码块，一旦出现条件满足的代码块则直接执行，其他的将不再进行判断

• prompt() 标准输入框，将文本从键盘中输入，然后作为返回值返回给一个变量。返回的值是string类型的，在做数字比较的时候需要在其前面加上 + ，将其转换为number类型。
  var score;
  score=+prompt(“请从键盘中写入：”)
• 获取所有用户输入的内容都是string类型。

条件分支语句(switch语句)

         语法：
    switch(条件表达式)
{
        case 表达式1 :语句...；break;
case 表达式2 :语句...；break;
case 表达式3 :语句...；break;
case 表达式4 :语句...；break;
default :语句...break;
    }
 ```
    - 执行流程：
    switch...case语句，在执行时会自上向下依次将case后的表达式和switch后的条件表达式进行全等比较，如果全等则从当前case处开始向下执行代码，如果不希望执行其他case后的语句，则可以在case后添加break。如果不全等则继续向下比较,直到遇到全等的为止，如果所有的case都不全等，则从default处开始执行语句 
    - if语句和switch语句本质上是一样的，
    if语句能做的事，switch语句也可以，同样switch语句能做的事 if语句也能做，这两个语句是可以互相代替的
    - switch结构看起来更加清楚，所以建议当条件比较多的时候可以选择switch，其他情况使用if  
###循环语句
        - 通过循环语句可以使一段代码反复的执行多次

    - while循环
            语法：
             while(条件表达式)
{
                语句...
             }

执行流程：
    while循环在执行时，会先对while后的条件表达式进行求值判断，如果判断结果为false，则直接退出循环；如果判断结果为true，则执行while后的循环体，循环体执行完毕以后，继续对条件表达式进行求值判断，如果为false，则退出循环；如果为true，则执行循环体，依次类推 

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

• 执行流程：
  do…while语句在执行时，先执行do后边的循环体，循环体执行完毕以后，再对while后的条件表达式进行求值判断,判断结果为false，则退出循环,判断结果为true，则继续执行循环体，依次类推
  - while和do…while大部分情况都是一样的
  不同点是，while是先判断后执行,而do…while是先执行后判断
  简单来说：do…while可以确保循环体至少执行一次
  
while(i<=10)
{
document.write(i++ + "<br />");用“<br />”来进行换行
}


for循环

• 语法：
  for(①初始化表达式;②条件表达式;④更新表达式){
  ③语句…
  }
  
  • for循环的执行流程
    ① for循环执行时，首先执行初始化表达式，来初始化一个变量
    ② 执行条件表达式，判断是否执行循环，如果为false，则终止循环，如果为true，则执行循环体③
    ④ 循环体执行完毕，执行更新表达式对初始化变量进行更新
    重复②
• 初始化表达式只会执行一次
  如果初始化都写在了外部，则for（）里面的就可以空着不写，只写分号就行。

For循环的例子：
- 在网页中打印9 * 9乘法表
* 1*1=1
* 1*2=2 2*2=4
* 1*3=3 2*3=6 3*3=9
* …..
* 9*9=81

        //创建一个外层循环控制乘法表的高度
        for(var i=1 ; i<=9 ; i++){

            //创建一个内存循环控制图形的宽度
            for(var j=1 ; j<i+1 ; j++){
                //宽j  * 高i
                document.write("<span>"+j + "*" + i + "=" + j*i +"</span>");
            }

            //打印换行
            document.write("<br />");
        }
<style type="text/css">

        span{
            display: inline-block;
            width: 100px;
        }

- 当变量定义在“语句”（if/switch/while/for语句）中，输出语句也可以找到它。

break和continue的区别：

• 在条件语句中：

  • break 不能用在if语句中，只能用在switch语句中。

    • break可以用来立即结束switch语句或者循环语句。
    • continue 不能用在if 和 switch 语句中。
    • 在循环语句中：
      相同点- 他们都可以使用在循环语句中，都是跳转语句。
    • 在他们两个关键字之后的代码都不会执行。
      不同点：
    • break会立即退出离他最近的循环。

    • continue可以用来结束本次循环 ，接着执行下一次循环。

    • 开启一个计时器

    • console.time() 可以用来开启一个计时器，它需要一个字符串作为参数，这个字符串将会成为为计时器的标识
    • console.timeEnd()可以用来关闭一个计时器，并输出结果， 它也需要一个字符串作为参数
      例如：console.time(“test”);
      console.timeEnd(“test”);

  Math.sqrt()可以求一个数的平方根（开方）

  For循环的例子：整理出质数
          for(var i=2 ; i<1000000 ; i++){
              //创建一个变量来记录i的状态，默认i是质数
              var flag = true;
              //创建一个循环，来获取1-i之间的数
              for(var j=2 ; j<=Math.sqrt(i) ; j++){
                  //看i能否被j整除
                  if(i % j == 0){
          //如果i能被j整除，说明i不是质数，则设置flag为false
                      flag = false;
  //一旦进入判断，则证明当前的i一定不是质数，内层不需要在执行了
                      break;
                  }
              }
              //判断i是否是质数
              if(flag){
                  //console.log(i);
              }
          }

引用类型

Date

• 在JS中所有时间相关的内容都是使用Date对象来表示
• 创建一个Date对象，如果我们直接创建一个新的Date对象，则该对象中会封装当前的时间
  var d = new Date(); //封装的是当前的时间
• 可以在构造函数中传递一个表示日期的字符串，来创建一个指定日期Date对象
  格式：月/日/年 时:分:秒
  例如：
  var d2 = new Date(“12/30/2001 13:40:50”);
  var d2 = new Date(“Feb 20 2001 13:40:50”);
  getDate() - 日期
• 返回当前Date对象是几号
  getDay() - 周几
• 返回当前Date对象是周几
• 返回 0 - 6之间的值，0 表示周日，1 表示周一
  getMonth() - 月份
• 返回当前Date对象的月份
• 返回0-11之间的值
  0 表示 1月份
  1 表示 2月份
  …
  11表示 12月份
  getFullYear() - 年
• 返回当前Date对象的年
  Date.now()
• 返回当前的时间戳
  getTime() - 时间戳
• 获取当前Date对象的时间戳
• 时间戳：
  从格林威治标准时间1970年1月1日0时0分0秒 到现在时间所经过的毫秒数
• 在计算机的底层所有的时间都是以时间戳的形式保存的
• 获取当前日期的时间戳
  var t2 = Date.now();

• 使用时间戳来测试程序执行的时间
  在程序开始前获取一个时间戳：
  var begin = Date.now();
  语句…

  在程序执行完成后获取一个时间戳:
  var end = Date.now();
  开始到结束的时间差：
  console.log(end - begin);

Math()

• Math不是一个构造函数不能直接创建对象，直接使用就可以。
  
  • 在Math对象中封装了数学运算相关的常量和方法，可以直接使用.像Math这种对象我们也称它是一个工具类
  • 常量： PI （π）
    
    • console.log(Math.PI);
      
      • Math.abs() - 可以求一个数的绝对值
        var a = Math.abs(-10);
      • Math.ceil() - 可以对一个数进行向上取整
      • Math.floor() - 可以对一个数进行向下取整
      • Math.round() - 可以对一个数进行四舍五入取整
      • Math.random() - 可以用来生成一个0~1之间的随机数，不会出现0和1
      • 生成一个 0-x间的随机数
        Math.round(Math.random()*x)
      • 生成一个x-y之间的随机数
        Math.round(Math.random()*(y-x) + x)
      • Math.max() - 可以获取多个值中的最大值
      • Math.min() - 可以获取多个值中的最小值
      • Math.pow(x,y) - 可以用来计算x的y次幂
        -Math.sqrt() - 可以对一个数进行开方运算

数组（Array）

• 数组也是一个对象，数组是专门用来存储数据的对象
  
  • 数组使用索引（index）来操作数据而不使用属性名
  • 索引指从0开始的整数
  • 由于存储方式的不同，数组的存储性能要超过对象的存储性能，所以在开发中，我们一般都是使用数组来存储数据
  • 创建一个数组对象:
  • 数组的字面量 【推荐】
    var 数组名 = [];
    
    • 创建对象方式
      var 数组名 = new Array();
  • 向数组中添加元素
    语法：数组对象[索引] = 元素;
    arr[0] = 123;
  • 通过数组字面量，可以在创建数组时就向数组中添加元素
    语法：var 数组名 = [元素1,元素2,…元素N]
  • 读取数组中的元素
    语法：数组对象[索引]
    如果读取数组中没有的元素，会返回undefined
  • 创建数组两种方式的区别：
    -创建一个数组，数组中只有一个元素10
    arr = [10];
    -创建一个长度为10的数组，数组没有元素
    arr2 = new Array(10);
  • length可以用来获取数组的长度
    
    • 对于连续的数组，length可以获取到数组中元素的个数
    • 对于非连续数组，length或获取到数组的最大索引+1，开发不用使用非连续的数组
    • length也可以用来修改数组的长度
    • 如果设置长度大于原长度，则在数组中会将多余的位置的空出， 如果设置长度小于原长度，则会将多余的部分删除
    • 在数组的最后一个位置添加一个元素
      数组[数组.length] = 元素，向数组的最后一个位置添加元素
    • 判断一个变量是否是数组的方法 Array.isArray(数组名)：
      console.log(Array.isArray(数组名));
      数组名 instanceof Array //true/false
  • 数组中可以放任意类型的元素:Number String Null Undefined Object函数 数组等类型。
    调用函数的形式：
    arr0;
  • 数组中也可以存放数组，
    如果一个数组中放的还是数组，则我们称这种数组为二维数组
    console.log(arr[1][0]);表示行和列
  • 遍历数组的方法有两种：
    
    • 使用for()循环语句遍历，可以控制遍历的长度
    • 使用 for in语句，遍历数组，只能将元素全都遍历出来

数组的方法

• push()
  
  • 可以向数组的末尾添加一个或多个元素，并返回新的长度，不改变原来数组的内容，只将长度改变。
    var result = arr.push(“唐僧”,”白骨精”,”蜘蛛精”);
• pop()
  
  • 可以删除并返回数组的最后一个元素 ，不改变原来数组的内容，结果返回的是最后删除的一个元素。
    result = arr.pop();
• unshift()
  - 向数组的开头添加一个或多个元素，改变原来数组的内容，并返回新的长度
• shift()
  - 删除数组最前边的元素，改变数组原来的内容，并返回被删除的元素。
• slice()
  
  • 可以从数组中截取出指定的元素
  • 该方法不会影响原数组，而是将截取到结果返回
    
    • 参数：
      1.开始位置的索引(包括开始位置)
      2.结束位置的索引(不包括结束位置)
  • 第二个参数可以省略不写,如果不写第二个参数，则会一直截取到最后
  • 参数可以是负数,如果是负数，则从后往前数
• splice(index,howmany,element…)
  
  • 删除元素，并向数组添加新元素，最终会返回被删除的元素。
  • 该方法会影响原数组
    
    • 参数：
      1.index - 删除开始位置的索引
      2.howmany - 删除的个数
      3.element - 可以传递多个参数，这些参数将会作为新元素插入到刚才删除的位置
• forEach()
  通过forEach()也可以对数组进行遍历
  
  • forEach()需要一个函数作为参数,像这种由我们定义，但是不由我们调用的函数，称为回调函数
  • forEach中的函数会被调用多次，数组中有几个元素函数就调用几次，每次调用都会将当前遍历到的元素以参数的形式传递进函数.
  • 回调函数中会传递进三个实参，它们分别是：
    1.当前遍历到的元素的值
    2.当前遍历到的元素的索引
    3.当前正在遍历的数组对象
    forEach()不支持IE8及以下的浏览器
    arr.forEach(function(value , index ,obj)
    {
    console.log(“index = “+index + ” , value = “+value);
    });
• concat()
  
  • 可以用来连接数组
  • 该方法不会影响原数组，而是创建一个新的数组并返回
• join()
  
  • 将数组转换为一个字符串
  • 默认情况下会将数组中的所有元素取出来，然后使用,连接成一个字符串
  • 在join()可以传递一个字符串作为参数，该字符串将会作为连接符使用，如果不传参数则默认使用逗号。
    result = arr.join(“@-@”);
• reverse()
  
  • 可以用来反转数组，前边的去后边，后边的去前边
  • 该方法会影响原数组
• sort()
  
  • 用来对数组进行排序，会影响原数组
  • 如果数组中都是字符串，则会按照字母顺序（Unicode编码顺序）对字符串进行排序，默认情况下sort()总是按照Unicode编码进行排序， 所以使用sort()对数字数组排序一定要注意，可能得到一个错误的结果
  • 也可以自定义sort()的排序规则，在sort()需要通过一个回调函数来指定排序规则，在回调函数中需要指定两个参数.

• 回调函数会被调用多次，每次调用都会将数组中的两个元素作为实参传递进回调函数，具体传递的那个元素不确定，但是可以确定的是a 一定在 b前面，解析器会根据回调函数的返回值，来决定两个元素位置。
  -如果返回值大于0，则两个元素交换位置
  -如果返回值等于0，则两个元素相等，不交换位置
  -如果返回值小于0，则两个元素不会交互位置

  *   arr.sort(function(a , b){
  

• 升序排列
  return a - b;

• 降序排列
  return b - a;
  });

• 数组排序的问题
  方法一：
  arr = [10,3,2,4,6,7,9,8,5];
  arr.sort(function(a , b){
  //升序排列（小的在前 大的在后）
  /*if(a > b){
  //交换位置
  return 1;
  }else if(a == b){
  //两个值相等
  return 0;
  }else{
  //不交换位置
  return -1;
  }*/

          //降序排列（大的在前 小的在后）
          /*if(a > b){
              //交换位置
              return -1;
          }else if(a == b){
              //两个值相等
              return 0;
          }else{
              //不交换位置
              return 1;
          }*/
  

  方法二：

          //升序排列
          //return a - b;
          //降序排列
          return b - a;
      });
      console.log(arr);
  

  • 稀疏数组
    
    • 表示创建的一个数组中，数组中包含的元素的个数，小于它的长度length，其中含有没有赋值的元素。 这样根据数据的长度进行循环，就一定会出现无效循环次数。这样就会导致程序执行无效代码，性能下降。解决的方法通常使用if判断语句。
      for(var i=0;i