1、JS来源

  • 借鉴了C语言的基本语法
  • 借鉴了Java语言的数据类型和内存管理
  • 借鉴了Scheme语言，将函数提升到第一等公民的地位
  • 借鉴了Self 语言，使用基于原型的继承机制

    1.1、js的特点

  1. 解释执行
  2. 纯文本
  3. 基于对象

  4. 弱类型(变量没有指定任何的数据类型但是可以通过值判断数据类型 , 数据类型可以随时发生改变)

    PS:js注意

  5. js区分大小写

  6. 字符 ‘’ “”(都可以) 一般使用双引号

2、JavaScript 核心由三部分组成

  • BOM：操作浏览器部件(专门操纵浏览器窗口,弹窗等….) 浏览器厂商自行决定的标准,没有标准

  • DOM：操作文本流(文档对象模型) w3c制定的标准

15-31.png

  • ECMAScript：JS的语法规则（这才是核心）es5 es6 typescript

    3、javascript的运行环境

    1.1 node.js

    1.2、行内式：（把JS直接写在标签里）

  • a标签：写在href属性里

    1. <a href="javascript: codecode;">here</a>

  • 非a标签：写在行为属性里 ```javascript

    非a标签

onclick—点击事件

  1. 事件: 元素可以根据鼠标或者键盘的不同的操作响应不同的交互行为, 事件就是特殊的属性
  2. ```javascript
  3. <!DOCTYPE html>
  4. <html lang="en">
  5. <head>
  6.     <meta charset="UTF-8">
  7.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  8.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  9.     <title>Document</title>
  10. </head>
  11. <body>
  12.     <a href="javascript: alert('hello javascirpt');">a标签</a>
  13.     <div onclick="alert('hello world')">非a标签</div>
  14. </body>
  15. </html>

1.3、内嵌式：把代码书写在一个script标签对内(这种不需要任何行为会自动执行JS代码)

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>Document</title>
  8. </head>
  9. <body>
  10.     <script>
  11.         alert("hello word");
  12.     </script>
  13. </body>
  14. </html>

1.4、外链式：把代码书写在一一个.js 文件内，如：在同目录下新建一个JS文件，写入alert(“hello word”); 之后再HTML中引用：

PS注：行内式能不用就不用；内嵌式学习的使用；推荐外链式

3、变量：值可以变化的量,

  1. // 单行注释
  2. /* 多行注释
  3. var a = 100;
  4. */
  5. var a = 100;
  6. a = 200; 
  7. var---声明一个变量的意思  a--变量名   = 赋值   100值
  9. 把100这个值赋值给a这个变量
  11. //只声明了一个变量c,但是没有赋值
  12. var c;-----变量声明
  14. 声明多个变量:
  15. var a = 10,
  16.     b = 20,
  17.     ...
  18.         c;

js变量名的命名规范:

变量命名规则和规范：
规则：
1.变量名必须以英文字母 , , $开头
2..变量名可以包括 英文字母 , , $开头
3不可以用系统的关键字 ,保留字 , 作为变量名
规范：
1.变量名必须有意义
2.遵守驼峰命名法
3.建议不要用$作为变量名

从内存的角度分析什么是变量?
什么是变量: 内存中专门存储数据的空间
如果一个变量只声明没有赋值,那么它的值默认为undefind(未定义)
一个 var 一个空间 :
声明变量：var 一条语句中可以声明多个变量( var a , b , c = 30; 输出都是等于30;——但是不推荐使用)
当创建一个变量时会在内存中的栈区开辟一个新的空间
如何使用变量 : 使用变量名相当于使用变量的值
57.png

常量: 值是固定不变, 值一旦定义了就不能修改

  1. 语法:const a = 3.1415926
  2. const---声明一个常量的意思  a 给定义常量一个名字  = 赋值  3.1415926--值
  4. 把3.1415926这个值赋值给a这个常量
  6. 什么时候使用常量?
  7.   不要这个值被任意修改


1.1、输出方式：

  1. // 在浏览器弹窗中显示
  2. alert("hello alert");
  4. // 在控制台中打印
  5. console.log("hello log");
  7. // 在页面中打印
  8. document.write("hello document");
  10. prompt("提示信息")  ---结论:prompt()输出的结果是字符串的类型

1.2、数据类型

现实生活中为什么要有数据类型?
因为在现实的生活中所有的数据类型根据用途不同, 分为不同不同的数据类型;

字符串（String）、数字(Number)、布尔(Boolean)、数组(Array)、对象(Object)、空（Null）、未定义（Undefined）。

JavaScript数据类型：

值类型—原始值(基本类型 存储在栈中)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol (es6 node.js)。

引用数据类型 存储在堆中：对象(Object)、数组(Array)、函数(Function) 日期(date) 正则表达式 Error math。

PS注：Symbol 是 ES6 引入了一种新的原始数据类型，表示独一无二的值。

基本数据类型和引用数据类型的区别是什么?

  1. 基本数据类型一般存储在栈中 , 引用数据类型存储在堆中,

(你口袋里面的钱存储在的口袋里面, 属于基本数据类型)
(手机存储的号码是指向某个人 (引用的意思) 数据引用数据类型)
通过一个地址 , 找到实际的数据 , 这个实际的数据存储在堆中 , 只要存储在堆中都属于引用数据类型;

JavaScript 拥有动态类型：
JavaScript 拥有动态类型。这意味着相同的变量可用作不同的类型：

  1. var x;               // x 为 undefined
  2. var x = 5;           // 现在 x 为数字
  3. var x = "John";      // 现在 x 为字符串

*值类型(基本类型)：

var a = “123”

console.log(typeof(a)); // string 使用运算符typeof来检查一个变量的类型

1.2.1、JavaScript 字符串（String）

字符串是存储字符（比如 “Bill Gates”）的变量。
字符串的变量内容一旦创建不可以改变 , 如果改变 ,只能创建一个新的字符串 ,抛弃旧的字符串.
字符串可以是引号中的任意文本。您可以使用单引号或双引号：

  1. var carname="Volvo XC60";
  2. var carname='Volvo XC60';
  4. 通过new这个关键字创建字符串的对象
  5. var str = new String();
  8. 您可以在字符串中使用引号，只要不匹配包围字符串的引号即可：
  9. var answer="It's alright";
  10. var answer="He is called 'Johnny'";
  11. var answer='He is called "Johnny"';

字符串常用方法:

arr.lenght属性: 返回字符串的值的个数;
.charAt(index) ; 获取指定位置的下标;
var num = str.charCodeAt(index) 获取指定位置的字符的Unicode编号;
.indexOf(“字符”) ,指的是字符所在的位置,如果没找到则返回 -1;
.indexOf(“字符” , 从哪个下标位置开始查找) lastIndexOf (“字符” , 从哪个下标位置开始查找) ; 最后开始找

split(“ “);字符串转化为数组 需要赋给新的值, 字符串创建了就不能改变了
.join(“”);将数组转化为字符串
53b.png

1.2.2、JavaScript 数字(Number)

JavaScript 是一种数字类型 (整数 , 浮点数)。数字可以带小数点，也可以不带：

  1. var x1=34.00;      //使用小数点来写
  2. var x2=34;         //不使用小数点来写
  4. 极大或极小的数字可以通过科学（指数）计数法来书写：
  5. var y=123e5;      // 12300000
  6. var z=123e-5;     // 0.00123

数字常用方法

531.png

1.2.3、JavaScript 布尔(Boolean)

布尔（逻辑）只能有两个值：true 或 false。

  1. var x=true;  ---逻辑上表示真
  2. var y=false;  ---逻辑上表示假

1.2.4、JavaScript 未定义(Undefined) 和 空（Null）

未定义(Undefined) : 表示一个变量只声明 , 没有赋值 ,它的默认值就是 undefined;——用typeof 检查返回值是undefined

空（Null）: Null类型只要一个值 —-null(空值)( 专门表示一个为空的对象 ) —-用typeof 检查 返回object (表示一个为空的对象);
什么是null : 替换栈中的地址 , 一个变量没有指向任何对象;
什么时候使用呢 ? 主动释放对象 ! 不能被找回了.
js的垃圾回收 : js的引擎自动销毁 ,不再被引用的对象;

基本数据类型的字节大小( 空格也会占字节 ):

number类型 : 整数它占 4 个字节 浮点数占 8 个字节
string类型 : 每个字符占 2 个字节;

*引用数据类型：

1.2.4、JavaScript 数组(Array)

连续存储多个数据的存储空间;
使用 : 相当于多个变量的集合;

为什么要有引用数据类型?
任何一个值 : 绝对不能代表一个东西 , 比如1个姓名 , 不肯代表你, 需要一大堆的数据去表示;

引用数据类型的特点 : 可以保存多个数据 , 而且数据的个数随时发生变化;

JavaScript中创建数组的方式

1.使用Array构造函数
var color=new Array();
new ——在堆中开辟了一个空间, (创建了一个对象)
Array : ecmascript 标准中的内置构造函数类型 (内置类型)

PS注意：括号里面参数可以有参数，若为一个数字，表示该数组的长度，如果为多个数字或者一个（多个）非数字表示的是传递数组中应该包含的值。
09-43-19.png

2.使用数组字面量
var color=[];

3.数组中两个不限制
不限制元素的数据类型;
不限制元素的个数(自动的实现扩容);

数组的长度

  1. var arr=[1,2,3[4,5];
  2. console.log(arr.length);  //4
  3. console.log(arr.[1])  //2

数组的方法有数组原型方法，也有从object对象继承来的方法

数组常用方法主要有以下这些：(api)

x.toString() x可以是任意类型 默认用 , 隔开 [“1”,”1”,”1”,”1”,”1”,] , —-分割符
arr.join(“分隔符”): 将数组转换为字符串，可以自定义分隔符。
slice(start,end+1); 截取数组中的下标从start开始，到end位置的元素，生成一个新的数组对象
splice():
删除 在任何的位置开始 , 删除 任意个元素 arr.splice (index从第几个开始删除, count删除几个)
插入 在任何的位置开始 , 插入 任意个元素 arr.splice (start从第几个开始插入, count删除几个不删写0 , 插入里面的值值一,值二,…)
替换 在任何的位置开始 , 替换 任意个元素 arr.splice (index从第几个开始删除, count删除几个, 替换删掉的值值一,值二,…)

3.png

练习题:
var bj=56;
var week=[‘“星期一”，‘星期二’，‘星期三’，‘星期四’，‘星期五’]
week=null;

二维数组

数组元素又是一个数组
创建二维数组，和普通数组一样的，只是将普通的数组，换成一个数组对象而已
如何访问二维数组中的任意元素：arr[父数组中的下标][子数组中的下标]

1.2.5、一个引用数据类型：时间(Date)，及常用方法

4118e.png
8e44b97.png

  1. // 创建一个时间对象，且是当前终端的时间
  2. var time = new Date();
  3. // 0表示1月，11表示12月
  4. var time = new Date(2021, 10, 15, 19, 45, 59);  // 2021年11月15号19时45分59秒
  6. // 获取年 月 日 时间
  7. var year = time.getFullYear();  // 2021
  8. var month = time.getMonth();    // 10
  9. var date = time.getDate();      // 15
  10. var hours = time.getHours();    // 19
  11. var minutes = time.getMinutes();  // 45
  12. var seconds = time.getSeconds();  // 59
  14. // 获取周几，0表示周日, 3表示周三
  15. var day = time.getDay();
  17. // 获取时间戳：当前时间与格林威治时间相差的毫秒数称时间戳
  18. // 1s = 1000ms
  19. var time = time.getTime()
  21. function getDiff(start, stop){
  22.     // 获取时间戳
  23.     var startTime = start.getTime();
  24.     var stopTime = stop.getTime();
  25.   hjijuiyhui
  26.     // 获取相差秒数
  27.     var seconds = Math.ceil((stopTime - startTime) / 1000);
  29.     // 获取时间
  30.     var day = Math.floor(seconds / (60*60*24));
  31.     var hours = Math.floor(seconds % (60*60*24) / (60*60));
  32.     var minutes = Math.floor(seconds % (60*60) / 60);
  33.     var seconds = sub % 60;
  35.     return {day: day, hours: hours, minutes: minutes, seconds: soconds};
  36. }

1.2.7、JavaScript 函数(方法)

概念: 专门执行一系列专门任务步骤的代码块

  1. (字面量定义函数的方法 , 它会自动提升到代码的顶部)
  3. 方式一、定义 : function  方法名字([参数列表]){
  4.         一系列专门任务的代码块
  5.     return;
  6. }
  7. 调用 : 方法名字(实际的参数)
  9. 关于return
  10. 第一种方式：只有return的时候，后面的语句就不会执行，退出功能
  11. 第二种方式：return+值，退出并且可以返回这个值给这个函数
  13. 参数:
  14.      function sum(a,b){---虚拟的参数(形参)
  15.              一系列专门任务的代码块          
  16.  }
  17. sum(7,8)----实际的参数
  19. 为什么要有参数？
  20. 更加的灵活
  21. 形参：方法内部的独有的变量，接收参数，在代码块里面去处理。

一,函数的递归调用

  1. 递归调用/嵌套调用：在函数内部调用自己（自己调用自己）

1.2.8、JavaScript 作用域

概念 : 1个变量的可用范围.
全局的变量
局部的变量

作用域：
全局变量的作用域：直接放到全局的作用域中的变量，只希望所有的作用域能够公有的变量就声明在全局的作用域中。
局部变量的作用域：声明在函数内部的变量或者方法的参数变量.

全局变量和局部变量的生命周期:
全局变量的生命周期，全局变量在打开网页的时候就创建了，关闭网页的时候就销毁了。
局部变量的生命周期，方法调用的时候创建，方法调用完就销毁了。

window对象：是整个网页的全局的作用域，在打开网页时候就已经自动创建好了。

  1. 一.  作用域链
  3.     先从自身出发 , 看看有没有变量 , 如果有就不会沿着作用域往上找,
  4.     如果没有,则沿着作用域往上找,直到找到
  6. 二. js中的值传递
  7. a.将一个变量的值赋值给另外一个变量，就是将变量中的值复制给一个新的变量。

问题: 需求：有三个变量，定义一个方法，求三个变量的最大值？

1.png

-15.png

Snipaste_2021-12-06_22-37-59.png

图片1.png
图片3.png

1.2.9、转换类型

NaN : 不是数字的数字( 就是内容不是数字 , 但是类型是数字)

JavaScript隐式转换:程序自动转换

如果只考虑+的情况下,
      1、 只要有字符串参与, 则都转换为字符串在做计算
        2、 如果没有字符串参与, 则都转换为数字在做计算(true--1   false--0)

JavaScript强制转换 : 通过js提供的内置的方法改变数据类型

——指将一个数据类型强制转换为其他的数据类型
——类型转换主要是指,将其他的数据类型,转换为 string Number Boolean

将其它类型转换为字符串(string)

1 、将其它类型转换为字符串(string)——调用tostring()方法 ,将a转换为字符串——-任何对象都有toString()方法

—-注意: null 和 undefined 这两个值没有toString()方法, 如果调用,会报错.

var a = 123;

//调用a的tostring()方法
//调用xxx前的yyy()方法,  就是xxx.yyy();
该方法不会影响到原变量,它会将转换的结果返回

正确写法: a = a.toString();
                console.log(typeof a); //string
                console.log(a);   // "123"

a=null;
a = a.toString();   //报错

a=undefined;
a = a.toString();   //报错

2、将其它类型转换为字符串(string)——调用string()函数, 将a转换为字符串

——调用string()函数 ,它会将null 直接转换为 “null” —字符串
——调用string()函数 ,它会将undefined 直接转换为 “undefined “ —字符串

var a = 123;

正确写法: a = String(a);
                console.log(typeof a); //string
                console.log(a);   // "123"


a=null;   //可以转
a = String(a);
    console.log(typeof a); //string
                console.log(a);   // "null"


a=undefined;   //可以转
a = String(a);
    console.log(typeof a); //string
                console.log(a);   // "undefined"

将其它类型转换为数字(Number)

1 、将其它类型转换为数字(Number)—-使用Number()函数 ,将a转换为数字

——字符串转Number 1、如果是纯数字字符串,则直接转换为数字
2、如果字符串中有非数字的内容,则转换为NaN
3、如果字符串是一个空串或者一个全是空格的字符,则转换为 0;
——-布尔转数字(true false)
true ——转成1
false——转成0
——-Null转数字 : 为 0
——undefined 转换为数字: NaN

var a = "123";

正确写法: a = Number(a);
                console.log(typeof a); //Number
                console.log(a);   // "123"




a=true;   //Boolean  true  转  数字  为1
a = Number(a);
    console.log(typeof a); //number
                console.log(a);   // "1"

a=false;   //Boolean  false  转  数字  为0
a = Number(a);
    console.log(typeof a); //number
                console.log(a);   // "0"





a=Null;   //Null  转  数字  为0
a = Number(a);
    console.log(typeof a); //number
                console.log(a);   // "0"




a=undefined;   //undefined  转  数字  为NaN
a = Number(a);
    console.log(typeof a); //Number
                console.log(a);   // "NaN"

2、将其它类型转换为数字(Number)—-专门用来对付字符串

parseInt() 把一个字符串转换为一个整数

—-parseInt() 可以将一个字符串中的有效的整数内容 (整数后面的就不会被取出来) 取出来然后转换为Number;
1、从第一个字符往后面读
2、如果碰到一个数字字符,开始读取,再次碰到不是数字的字符,则停止读取
3、开头碰到是空格, 可以继续往后读取
4、开头碰到非空格, 不是数字说明不能转 ——NaN

parseFloat() 把一个字符串转换为一个浮点数

—-parseFloat() 可以将一个字符串中的有效的小数数内容 取出来然后转换为Number;

如果对非String使用parseInt() 或 parseFloat() ,它会先将其转换为String然后再操作,

parseInt() 和 parseFloat()唯一的区别 : parseFloat() 认识小数点,但是它仅仅只认识第一个小数点

//parseInt() 将字符串里面有效的整数内容取 , 
var = "123.455px";
a =parseInt(a);
console.log(typeof a); //number
                console.log(a);   // "123"

//parseFloat() 将字符串里面有效的小数 , 
var = "123.455.758px";
a =parseInt(a);
console.log(typeof a); //number
                console.log(a);   // "123.456"

将其它类型转换为布尔(Boolean) ——使用Boolean()

1.3、运算符

算术运算符:
+    加法
-    减法     ***考虑减:任意类型相减,都会自动转换数字类型. 如果有参数("asaa"等) 参与,则不会转换为数字,返回NaN***
*    乘法
/    除法
%    取模（余数）
++    自增    x=++y(先加后取值)   x=y++(先取值后加)
--    自减

赋值运算符:
= 赋值
+=  
-=
*=
/=
%=

关系运算符:
==    等于     值来比较(自动类型转换)
===    绝对等于 (值和类型都要比较),不存在自动类型的转换
!=     不等于
!==     绝对不等于 (值和类型均不相等)
>     大于    (自动类型转换)    ****number类型和string类型作比较的时候  自动把 string类型转换 number类型****
<     小于    (自动类型转换)
>=     大于或等于
<=     小于或等于


逻辑运算符:
&&    and      与  并且 (只要有一个为假就全部为假,全部为真才为真)
||    or     为 false   或  要么  (只要有一个为真,则全部为真)
!    not       非   取反的意思



条件运算符(三元表达式)”

语法 : 表达式1?表达式2:表达式3

如果表达式1为true 就执行表达式2,
如果表达式1为false 就执行表达式3,
ps:表达式1结果必须是boolean(true  false)

多个条件：多选一
条件1？条件1的值：
条件2？条件2的值：
条件3？条件3的值：
。。。。。
默认值；


单目运算符 b++ !c

双目运算符 a+b  a>b


undefined   null  NaN  ""   0   false ==>false  (undefined = undefined)

-17-02.png

1.4、条件语句

判断if

  • if(逻辑表达式做判断){}
  • if(){} else{}
  • if(){} else if(){}

  • if(){} else if(){} else{}

    if (condition1){
  //当条件 1 为 true 时执行的代码
}
else if (condition2){
  //当条件 2 为 true 时执行的代码
}
else{
  //当条件 1 和 条件 2 都不为 true 时执行的代码
}

    分支switch

    多条分支语句,根据条件判断 , 选择执行 , 在条件比较多的时候用来代替if()else语句. ```javascript switch(value){ case 100:

      console.log('100');
  break;

    case 200:

      console.log('200');
  break;

    default:

      console.log('no');

    }

    break—-表示退出当前结构的意思

switch(表达式){ case 表达式1:(当表达式 ===表达式1的时候) 执行的代码块; break; case 表达式2:(当表达式 ===表达式1的时候) 执行的代码块; break; case 表达式3:(当表达式 ===表达式1的时候) 执行的代码块; break; default:默认表达式(如果以上条件都不满足.就执行这个) }

<a name="pO8nS"></a>
#### if...else语句,和swich..case
面试题:if..else 语句和switch..case语句的区别？<br />switch..case如果加了break，那就是和if..else语句一样的<br />如果不加break,那么所有的判断语句都会执行。
```javascript
一般情况下，当判断条件较多的情况下，
使用switch case语句的效率会高于使用if...else if语句。
switch...case与if...else if的根本区别在于:
switch...case会生成一个跳转表来指示实际的case分支的地址


循环：

程序反反复复的执行同一代码块,遇到条件不满足的时候就会停止循环

  • whick(){}
  • do{} while();
  • for(var i = 0; i < 3; i++){}

**continue , break , return 有啥区别 ?
continue;—-只能在循环里面使用—-跳出该阶段的循环,继续下一轮
break;——能在循环和switch里面使用 , 直接下面的不会执行了 , 直接退出的意思
return;—-只能包在方法里面的代码块一起使用 , 也有退出的意思 , 但是它可以返回值.

for 循环

var i;
for(i=0;i<10;i++){
    // 
}
var i;
for(i=0声明的循环变量;i<10 循环条件;i++ 叠加循环变量){
    // 循环体,内容
}

循环三要素:
1. 循环条件:循环继续执行的条件   i <10;
2. 循环体: 每次循环要做的事情   
3. 循环变量 : 循环条件做判断的变量   i = 0 ;
i++  --叠加的变量

for in 循环
遍历对象属性：

var x;
var txt="";
var person={fname:"Bill",lname:"Gates",age:56}; 

for (x in person){
    txt=txt + person[x];
}

do{} while()循环

var 循环变量
while (循环条件)
{
  循环体;
  叠加循环变量;
    //需要执行的代码
}


do{
    循环体;
  叠加循环变量;
    //需要执行的代码
}while (条件)

do{}while()  先执行一次循环体,在判断循环条件是否满足循环,  循环体至少可以执行一次

5-11.png

函数：function fn(){return;} 调用：fn();

随机数

Math 对象（引用类型）提供了一个生成随机数的函数
随机数:Math.random() 0<=r<1
任意的min—max （Math.random()*(max-min+1)+min）
向下取整；Math.floor()
向上取整:Math.ceil()

1.2.6、JavaScript 对象 Function 对象(内置的构造函数)

凡是存储在堆中的都是对象

如何使用引用数据类型的对象?
使用变量 , 等效于使用对象的地址 , 使用地址等效于使用对象本身;

创建function 的方式 :

  1. function 方法名 (){ } //字面量方式 字面量的方式, 方法可以得到提升,
  2. var 方法名 = function (){ } //声明变量的方式来定义函数
  3. var 方法名 = new function () { } //创建对象的形式来定义方法

匿名函数 :
就是定义方法的时候没有指定方法的名称的函数
2个用途 :
回调函数: 函数何时执行 ,程序员不需要控制 ,有所在的环境自动调用执行.

把一个函数,当做一个参数,传递给一个方法,

自调函数 : 匿名函数自己调用自己.
何时使用 : 但函数不需要重复使用的时候,就使用匿名函数自调.
(function () console.log(“add”)()}
(function () console.log(“add”)}()

JavaScript 对象 odject对象

image.png

数组：就是一组数据的集合
js中数组的特点：（有下标，从0开始；有长度，length）
①数组定义时无需指定数据类型；
②数组定义时可以无需指定数组长度；
③数组可以存储任何数据类型的数据；
④一般是相同的数据类型。

数组的创建方式：
①字面量定义：var arr = [值1,值2,值3]；（数组文本方法）
②构造函数创建：new Array（值1，值2，值3）； //当括号中没有值的时候，打印结果为[ ]（空数组）；
创建数组并指定长度（只有一个值的时候为起初的长度，可自己增加值来改变这个长度）：new Array（size）;
W3C中提出，出于简洁、可读性和执行速度的考虑，请使用第一种方法（数组文本方法）

var ary = new Array(4); ary[0] = 12; ary[1] = 13; ary[2] = 14; //加入值 数组名[下标] = 值 长度为4，只加入了三个值，则第四个值为undefined；

数组操作：
数组名.方法
1）push(5,4,3)—向数组末尾添加新的数组项，返回值新数组的长度，原数组改变
2）pop()—删除数组最后一项，没有参数，返回值删除项，原数组改变
3）unshift()—向数组开头位置添加，返回值是新数组的长度，原数组改变
4）shift()—删除数组第一项,没有参数，返回值删除项，原数组改变

（以下是扩展方法） ：
5）splice()—原数组改变
splice(n,m)—从索引(下标)n开始，删除m个，返回值以数组的形式返回删除项
splice(n)—从索引n开始删除到最后
splice(0)—原数组清空，返回一个和原来一样的新数组
splice(n,m,z)；从索引(下标)n开始，删除m个，把z添加到删除的位置
6）slice(n,m)—从索引n开始，查找到索引m处，不包含m，将查找到的以新数组返回，原数组不变
7）concat—数组的拼接,不改变数组，返回最终连接好的新数组；
8）数组转为字符串:不改变原数组
toString() join(‘符号’) （数组.join（）可以直接转数组）

清空数组的方式：
①arr.splice（0）；
②arr.length = 0；
③arr = [ ];

数组的遍历：
for , for…in
数组可以使用for循环遍历
也可以使用for…in遍历 一般使用for…in
for-in的特点：
没有循环条件
自动取出下标，
下标默认从 0 开始 ，最大下标 数组长度-1
下标的类型为string


当需要返回两个值时，可以用对象{ }或数组[ ]的形式返回；
只能用for…in遍历对象，for不能遍历对象；（因为对象的键是一个变量）在遍历时[ ]中不能加引号；

一些数组类型：
整数数组 ： [12,3,4,5,6]
字符串数组 ： [“orange”,”apple”,”pear”]
对象数组 ： [{sname:”jack”,age:19},{sname:”lily”,age:18}]
二维数组 ： [[1,3,4],[5,6,7],[1,2,5]] （一个数组的每一项都是一个数组）
_　　　　

_

数组和对象的区别

在 JavaScript 中，数组使用数字索引。
在 JavaScript 中，对象使用命名索引。
数组是特殊类型的对象，具有数字索引。

在数组中使用数字（下标）来访问其“元素”。
在对象使用名称（属性名称和方法名称）来访问其“成员”。