JavaScript基础学习

一、简介   JavaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的语言,内置支持类型。它的解释器被称为JavaScript引擎,为浏览器的一部分,广泛用于客户端的脚本语言,最早是...

一、简介

  JavaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的语言,内置支持类型。它的解释器被称为JavaScript引擎,为浏览器的一部分,广泛用于客户端的脚本语言,最早是在HTML(标准通用标记语言下的一个应用)网页上使用,用来给HTML网页增加动态功能。

二、历史

  ·1992年Nombas开发出C-minus-minus(C--)的嵌入式脚本语言(最初绑定在CEnvi软件中),后将其改名为ScriptEase(客户端执行的语言)。

  ·Netscape(网景)接收Nombas的理念,(Brendan Eich)在其Netscape Navigator 2.0产品开发出一套livescript的脚本语言,Sun和Netscape共同完成,后改名叫JavaScript。

  ·微软随后模仿在IE3.0的产品中搭载了一个JavaScript的克隆版叫Jscript。

  ·为了统一三家,ECMA(欧洲计算机制造协会)定义了ECMA-262规范,国际标准化组织及国际电工委员会(ISO/IEC)也采纳ECMAScript作为标准(ISO/IEC-16262)。从此,Web浏览器就开始努力(虽然有着不同程序的成功和失败)将ECMAScript作为JavaScript实现的基础。ECMAScript是规范。

三、ECMAScript

  尽管ECMAScript是一个重要的标准,但它并不是JavaScript唯一的部分,当然,也不是唯一被标准化的部分。实际上,一个完整的JavaScript实现是由以下3个不同部分组成的:

  ·核心(EMCAScript)

  ·文档对象模型(DOM)Document object model(整合js, css, html)

  ·浏览器对象模型(BOM)Broswer object model(整合js和浏览器)

  JavaScript在开发中绝大多数情况是基于对象的,也是面向对象的。

  简单地说,ECMAScript描述了以下内容:

  ·语法

  ·类型

  ·语句

  ·关键字

  ·保留字

  ·运算符

  ·对象(封装  继承  多态)基于对象的语言,使用对象

四、JavaScript基础

  1.变量

  变量是用于存储信息的“容器”。

var x=5;
var y=6;
var z=x+y;

  就像代数那样

  x=5

  y=6

  z=x+y

  在代数中,我们使用字母(比如x)来保存值(比如5)。

  通过上面的表达式z=x+y,我们能够计算出z的值为11。

  在JavaScript中,这些字母被称为变量。

  与代数一样,JavaScript变量可用于存放值(比如x=5)和表达式(比如z=x+y)。

  变量可以使用短名称(比如x和y),也可以使用描述性更好的名称(比如age, sum, totalvolume)。

  ·变量必须以字母开头

  ·变量也能以$和_符号开头(不推荐)

  ·变量名称对大小写敏感

  2.基础规范

  ·每行结束可以不加分号,没有分号时会以换行符作为每行的结束。

a=1;b=2;
a=1 b=2;//------错误

//不推荐
a=1
b=2

//推荐
a=1;
b=2;

{
 a=1;
 b=2;
    //推荐加tab
    a=1;
    b=2;
}

  ·注释:支持多行注释(/* 注释内容 */)和单行注释(//注释内容)

  ·使用{}来封装代码块

  3.常量和标识符

  常量:直接在程序中出现的数据值

  标识符:

    a.由不以数字开头的字母、数字、下划线(_)、美元符号($)组成

    b.常用于表示函数、变量等的名称

    c.例如:_abc, $abc, abc, abc123是标识符,而1abc不是

    d.JavaScript语言中代表特定含义的词称为保留字,不允许程序再定义为标识符

  ECMA v3标准保留的JavaScript的关键字

break

case

catch

continue

default

delete

do

else

false

finally

for

function

if

in

instanceof

new

null

return

switch

this

throw

true

try

typeof

var

void

while

with

 

 

  4.数据类型

  值类型(基本类型):字符串(String)、数字(Number)、布尔(Boolean)、空(Null)、未定义(Undefined)、Symbol。

  引用数据类型:对象(Object)、数组(Array)、函数(Function)。

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

  JavaScript拥有动态类型

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

var x;               // x 为 undefined
var x = 5;           // 现在 x 为数字
var x = "MaYi";      // 现在 x 为字符串

  JavaScript字符串

  字符串是存储字符(比如“MaYi”)的变量。

  字符串可以是引号中的任意文本。可以使用单引号或双引号:

var carname="Volvo XC60";
var carname='Volvo XC60';

  可以在字符串中使用引号,只要不匹配包围字符串的引号即可:

var answer="It's alright";
var answer="He is called 'Johnny'";
var answer='He is called "Johnny"';

  JavaScript数字

  JavaScript只有一种数字类型。数字可以带小数点,也可以不带:

var x1=34.00;      //使用小数点来写
var x2=34;         //不使用小数点来写

  极大或极小的数字可以通过科学(指数)计数法来书写:

var y=123e5;      // 12300000
var z=123e-5;     // 0.00123

  JavaScript布尔

  布尔(逻辑)只能有两个值:true或false。

var x=true;
var y=false;

  布尔常用在条件测试中。

  JavaScript数组

  下面的代码创建名为cars的数组:

var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";

  或者

var cars=new Array("Saab","Volvo","BMW");

  或者

var cars=["Saab","Volvo","BMW"];

  数组下标是基于零的,所以第一个是[0],第二个是[1],以此类推。

  JavaScript对象

  对象由花括号分隔。在括号内部,对象的属性以名称和值对的形式(name: value)来定义。属性由逗号分隔:

var person={firstname:"John", lastname:"Doe", id:5566};

  上面例子中的对象(person)有三个属性:firstname、lastnamet和id。

  空格和折行无关紧要。声明可横跨多行:

var person={
firstname : "John",
lastname  : "Doe",
id        :  5566
};

  对象属性有两种寻址方式:

name=person.lastname;
name=person["lastname"];

  Undefined类型

  Undefined类型只有一个值,即undefined。当声明的变量未初始化时,该变量的默认值是undefined。当函数无明确返回值时,返回的也是值“undefined”。

  Null类型

  Null类型也只有一个值,即null。值undefined实际上是从值null派生来的,因此ECMAScript把它们定义为相等的。

  尽管这两个值相等,但它们的含义不同。undefined是声明了变量但未对其初始化时赋予该变量的值,null则用于表示尚未存在的对象。如果函数要返回的是对象,那么找不到该对象时,返回的通常是null。

  可以通过将变量的值设置为null来清空变量。

cars=null;
person=null;

  声明变量类型

  声明变量时,可以使用关键词“new”来声明其类型:

var carname=new String;
var x=      new Number;
var y=      new Boolean;
var cars=   new Array;
var person= new Object;

  数据类型转换

JavaScript属于松散类型的程序语言
变量在声明的时候并不需要指定数据类型
变量只有在赋值的时候才会确定数据类型
表达式中包含不同类型数据则在计算过程中会强制进行类别转换
数字+字符串:数字转换为字符串
数字+布尔值:true转换为1,false转换为0
字符串+布尔值:布尔值转换为字符串“true”或“false”

  强制类型转换函数

函数parseInt:强制转换成整数
例如:
parseInt(“6.12”)    6
parseInt(“12a”)    12
parseInt(“1a2”)    1
函数parseFloat:强制转换成浮点数
parseFloat(“6.12”)    6.12
函数eval:将字符串强制转换为表达式并返回结果
eval(“1+1”)    2
eval(“1<2”)    true

  类型查询函数(typeof)

  ECMAScript提供了typeof运算符来判断一个值是否在某种类型的范围内。可以用这种运算符判断一个值是否表示一种原始类型:如果它是原始类型,还可以判断它表示哪种原始类型。

函数typeof:查询数值当前类型(string / number / boolean / object)
例如typeof(“test”+3)    “string”
例如typeof(null)        “object”
例如typeof(true+1)     “number”
例如typeof(true-false)    “number”

五、ECMAScript运算符

  1.ECMAScript算数运算符

加(+)、减(-)、乘(*)、除(/)、求余(%+除了可以表示加法运算外还可以用于字符串的连接。例如:”abc”+”def”    “abcdef”
-除了可以表示减号外还可以表示负号。例如:x=-y

  递增(++)、递减(--)

假如x=2,那么x++表达式执行后的值为3,x--表达式执行后的值为1
i++相当于i=i+1,i--相当于i=i-1
递增和递减运算符可以放在变量前也可以放在变量后:--i
var i=1;
console.log(i++);
console.log(++i);
console.log(i--);
console.log(--i);

  一元加减法:

var a=1;
var b=1;
a=-a;  //a=-1;

var c=”10”;
alert(typeof(c));  //string
c=+c;  //类型转换
alert(typeof(c));  //number

var d=”mayi”;
d=+d;
alert(d);  //NaN:属于Number类型的一个特殊值,当遇到将字符串转成数字无效时,就会得到一个NaN数据
alert(typeof(d));  //number

var n=NaN;
alert(n>3);  //false
alert(n<3);  //false
alert(n==3);  //false
alert(n==NaN);  //false

alert(n!=NaN);  //true。NaN参与的所有的运算都是false,除了!=

  2.ECMAScript逻辑运算符

等于(==)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)、小于等于(<=)
与(&&)、或(||)、非(!)
1&&1    1
1&&0    0
0&&1    0
0&&0    0
1||1    1
1||0    1
0||1    1
0||0    0
!0    1
!1    0

  逻辑AND运算符(&&)

  逻辑AND运算的运算数可以是任何类型的,不止是布尔值。

  如果某个运算数不是原始的布尔类型,逻辑AND运算并不一定返回布尔值:

  ·如果某个运算数是null,返回null。

  ·如果某个运算数是NaN,返回NaN。

  ·如果某个运算数是undefined,返回undefined。

  逻辑OR运算符(||)

  与逻辑AND运算符相似,如果某个运算数不是布尔值,逻辑OR运算并不一定返回布尔值,逻辑OR运算并不一定返回布尔值。

  3.ECMAScript赋值运算符

赋值 =
JavaScript中“=”代表赋值,两个等号“==”表示判断是否相等
例如,x=1表示给x赋值为1
if(x==1){...}  程序表示当x与1相等时
配合其他运算符形成的简化表达式
例如i+=1相当于i=i+1,x&=y相当于x=x&y

  实例:

var b1 = 2 == "2";
var b2 = 2 === "2";
var b3 = 4 != "4";
var b4 = 4 !== "4";

var a = 2;
var b = 4;
var c1 = a < b | --b > --a;
var c2 = a < b || --b > --a;
var c3 = a < b && --b > --a;
var c4 = a < b & --b > --a;

console.log(b1);  //true
console.log(b2);  //false
console.log(b3);  //false
console.log(b4);  //true
console.log(c1);  //1
console.log(c2);  //true
console.log(c3);  //true
console.log(c4);  //1

  4.ECMAScript等性运算符

  执行类型转换的规则如下:

  ·如果一个运算数是布尔值,在检查相等性之前,把它转换成数字值。false转换成0,true为1。

  ·如果一个运算数是字符串,另一个是数字,在检查相等性之前,会尝试把数字转换成字符串。

  ·如果一个运算数是对象,另一个是字符串,在检查相等性之前,会尝试把对象转换成字符串。

  ·如果一个运算数是对象,另一个是数字,在检查相等性之前,会尝试把对象转换成数字。

  在比较时,该运算符还遵守下列规则:

  ·值null和undefined相等。

  ·在检查相等性时,不能把null和undefined转换成其他值。

  ·如果某个运算数是NaN,等号将返回false,非等号将返回true。

  ·如果两个运算数都是对象,那么比较的是它们的引用值。如果两个运算数指向同一对象,那么等号返回true,否则两个运算数不等。

表达式

null == undefined

true

“NaN” == NaN

false

5 == NaN

false

NaN == NaN

false

NaN != NaN

true

false == 0

true

true == 1

true

true == 2

false

undefined == 0

false

null == 0

false

“5” == 5

true

 

  5.ECMAScript关系运算符

var bResult = "Blue" < "alpha";
alert(bResult);  //输出 true

  在上面的例子中,字符串“Blue”小于“alpha”,因为字母B的字符码是66,字母a的字符码是97。

  比较数字和字符串

  另一种棘手的状况发生在比较两个字符串形式的数字时,比如:

var bResult = "25" < "3";
alert(bResult);  //输出 true

  上面这段代码比较的是字符串“25”和“3”。两个运算数都是字符串,所以比较的是它们的字符码(“2”的字符码是50,“3”的字符码是51)。

  不过,如果把某个运算数改为数字:

var bResult = "25" < 3;
alert(bResult);  //输出 false

  这里,字符串“25”将被转换成数字25,然后与数字3进行比较,结果不出所料。

总结:

  比较运算符两侧如果一个是数字类型,一个是其他类型,会将其类型转换成数字类型。

  比较运算符两侧如果都是字符串类型,比较的是最高位的asc码,如果最高位相等,继续取第二位比较。

  6.Boolean运算符

var temp=new Object();// false;[];0; null; undefined;object(new Object();)

if(temp){
    console.log("true")
}else {
    console.log("false")
}

  7.全等号和非全等号

  等号和非等号的同类运算符是全等号和非全等号。这两个运算符所做的与等号和非等号相同,只是它们在检查相等性前,不执行类型转换。

六、控制语句

  1.if控制语句

if-esle  基本格式:
if(表达式){
语句1;
......
}else{
语句2;
......
};
功能说明:
如果表达式的值为true,则执行语句1,否则执行语句2

  例子:

var x= (new Date()).getDay();
//获取今天的星期值,0为星期天
var y;

if((x==6) || (x==0)) {
y="周末";
}else{
y="工作日";
}

alert(y);

  if可以单独使用:

if语句嵌套格式:
if(表达式1){
    语句1;
}else if(表达式2){
    语句2;
}else if(表达式3){
    语句3;
}else{
    语句4;
}

  例子:

var x= (new Date()).getDay();
//获取今天的星期值,0为星期天
var y;
if(x==1){
    y="星期一";
}else if(x==2){
    y="星期二";
}else if(x==3){
    y="星期三";
}else if(x==4){
    y="星期四";
}else if(x==5){
    y="星期五";
}else if(x==6){
    y="星期六";
}else{
    y="星期日"
}

alert(y);

  2.switch选择控制语句

switch基本格式:
switch(表达式){
case 值1:语句1;break;
case 值2:语句2;break;
case 值3:语句3;break;
default:语句4;
}

  例子:

var x= (new Date()).getDay();
//获取今天的星期值,0为星期天
var y;

switch (x){
    case 1:y="星期一";break;
    case 2:y="星期二";break;
    case 3:y="星期三";break;
    case 4:y="星期四";break;
    case 5:y="星期五";break;
    case 6:y="星期六";break;
    default:y="星期日";
}

alert(y);

  switch比else if结构更加简洁清晰,使程序可读性更强,效率更高。

首先要看一个问题,if语句适用范围比较广,只要是boolean表达式都可以用if判断;而switch只能对基本类型进行数值比较。两者的可比性就仅限在两个基本比较的范围内。
说到基本类型的数值比较,那当然要有两个数。然后重点来了——
if语句每一句都是独立的,看下面的语句:
if(a==1){
    ......
}else if(a==2){
    ......
}
这样a要被讲稿寄存器两次,1和2分别被读入寄存器一次。于是你是否发现其实a读两次是有点多余的,在你全部比较完之前只需要一次读入寄存器就行了,其余都是额外开销。但是if语句必须每次都把里面的两个数从内存拿出来读到寄存器,它不知道你其实比较的是同一个a。
于是switch case就出来了,把上面的改成switch case版本:
switch(a){
case 0:......;break;
case 1:......;break;
}
总结:
1.switch用来根据一个整型值进行多路分支,并且编译器可以对多路分支进行优化。
2.switch-case只将表达式计算一次,然后将表达式的值与每个case的值比较,进而选择执行哪一个case的语句块。
3.if...else的判断条件范围较广,每条语句基本上独立的,每次判断时条件都要加载一次。
所以在多路分支时用switch比if...else if...else结构要效率高。

  3.for循环控制语句

for循环基本格式:
for(初始化;条件;增量){
语句1;
......
}
功能说明:
实现条件循环,当条件成立时,执行语句1,否则跳出循环休。

  例子:

for(var i=1;i<=6;i++){
    document.write("<H"+i+">hello</H"+i+">");
}

var arr=[1, "hello", true];
for(var j in arr){
    console.log(j);
    console.log(arr[j]);
}

  注意:for j in不推荐使用

  4.while循环控制语句

while循环基本格式:
while(条件){
语句1;
......
}
功能说明:
功能和for类似,当条件成立循环执行语句花括号{}内的语句,否则跳出循环。

var i=1;
while (i<=6){
    document.write("<H"+i+">hello</H"+i+">");
    i++;
}

  5.异常处理

try{
    ......  //这段代码从上往下运行,其中任何一个语句抛出异常该代码块就结束运行
}catch (e){
......  //如果try代码块中抛出了异常,catch代码块中的代码就会被执行。
......  //e是一个局部变量,用来指向Error对象或者其他抛出的对象
}finally{
    ......  //无论try中代码是否有异常抛出(甚至是try代码块中有return语句),finally代码块中始终会被执行。
}

  注:主动抛出异常throw Error(“xxx”)

七、ECMA对象

  从传统意义上来说,ECMAScript并不真正具有类。事实上,除了说明不存在类,在ECMA-262中根本没有出现“类”这个词。ECMAScript定义了“对象定义”,逻辑上等价于其他程序设计语言中的类。

  var o=new Object();

  1.对象的概念与分类:

  ·由ECMAScript定义的本地对象,独立于宿主环境的ECMAScript实现提供的对象(native object)。

  ·ECMAScript实现提供的、独立于宿主环境的所有对象,在ECMAScript程序开始执行时出现。这意味着开发者不必明确实例化内置对象,它已被实例化了。ECMA-262只定义了两个内置对象,即Global和Math(它们也是本地对象,根据定义,每个内置对象都是本地对象)(built-in object)。

  ·所有非本地对象都是宿主对象(host object),即由ECMAScript实现的宿主环境提供的对象。所有BOM和DOM对象都是宿主对象。

  object对象:ECMAScript中的所有对象都由这个对象继承而来;Object对象中的所有属性和方法都会出现在其他对象中。

ToString() : 返回对象的原始字符串表示。
ValueOf() : 返回最适合该对象的原始值。对于许多对象,该方法返回的值都与ToString()的返回值相同。

  11种内置对象

包括:

  Array, String, Date, Math, Boolean, Number Function, Global, Error, RegExp, Object

简介:

  在JavaScript中除了null和undefined以外其他的数据类型都被定义成了对象,也可以用创建对象的方法定义变量,String、Math、Array、Date、RegExp都是JavaScript中重要的内置对象,在JavaScript程序大多数功能都是通过对象实现的。

<script language="javascript">
var aa=Number.MAX_VALUE;
//利用数字对象获取可表示最大数
var bb=new String("hello JavaScript");
//创建字符串对象
var cc=new Date();
//创建日期对象
var dd=new Array("星期一", "星期二", "星期三", "星期四");
//数组对象
</script>

  内置对象的分类

类型

内置对象

介绍

数据对象

Number

数字对象

String

字符串对象

Boolean

布尔值对象

组合对象

Array

数组对象

Math

数学对象

Date

日期对象

高级对象

Object

自定义对象

Error

错误对象

Function

函数对象

RegExp

正则表达式对象

Global

全局对象

  2.String对象

  自动创建字符串对象:

var str1="hello world";
alert(str1.length);
alert(str1.substr(1, 5));

  调用字符串的对象属性或方法时自动创建对象,用完就丢弃

  手工创建字符串对象

var str1=new String("hello world");
alert(str1.length);
alert(str1.substr(1, 3));

  采用new创建字符串对象str1,全局有效

  String对象的属性

  获取字符串长度:length

String对象的方法

类别

方法

说明

格式编排方法

fontcolor("color")

返回字体颜色字义字符串,color参数可以为red、blue、green等

fontsize("size")

返回字体大小定义字符串,size从小到大可以定义为1到7

link("url")

返回超链接定义字符串,url为网络超链接

大小写转换

toLowerCase()

返回小写字符串

toUpperCase()

返回大写字符串

获取指定字符

charAt(index)

返回指定位置字符

charCodeAt(index)

返回指定位置字符Unicode编码

查询字符串

indexOf(findstr, index)

返回正向的索引位置

lastIndexOf(findstr)

返回反向的索引位置

match(regexp)

返回匹配的字符串

search(regexp)

返回找到字符串的首字符索引

截取子字符串

substr(start, length)

返回从索引位置start开始长为length的子字符串

substring(start, end)

返回start开始end结束的子字符串

slice(start, end)

同substring,但允许使用负数表示从后计算位置

替换子字符串

replace(findstr, tostr)

返回替换findstr为tostr之后的字符串

分割字符串

split(bystr)

返回由bystr分割成的字符串数组

连接字符串

concat(string)

返回与string连接后的字符串

  String对象的方法(1)——格式编排方法

书写格式:
String对象提供了一组针对HTML格式的方法,如x.anchor()返回锚定义字符串<a>x</a>
x.bold()返回粗体表示字符串<b>x</b>,x.sup()返回上标格式字符串<sup>x</sup>
var x="mayi"; var y="x.italics():"+x.italics(); document.write(y.fontsize(10)); //<font size="10">x.italics():<i>mayi</i></font>

  String对象的方法(2)——大小写转换

var str1="AbcdEfgh";
var str2=str1.toLowerCase();
var str3=str1.toUpperCase();
alert(str2);  //结果为"abcdefh"
alert(str3);  //结果为"ABCDEFH"

  String对象的方法(3)——获取指定字符

书写格式:
x.charAt(index)
x.charCodeAt(index)
使用注解:
x代表字符串对象
index代表字符位置
index从0开始编号
charAt返回index位置的字符
charCodeAt返回index位置的Unicode编码

var str1="welcome to the world of Python! 蚂蚁";
var str2=str1.charAt(28);  //结果为""
var str3=str1.charCodeAt(30);  //结果为34434

  String对象的方法(4)——查询字符串

书写格式:
x.indexOf(findstr, index)
x.lastIndexOf(findstr)
var str1="Welcome to the world of Python! ";
var str2=str1.indexOf("l");
var str3=str1.lastIndexOf("l");
alert(str2);  //结果为2
alert(str3);  //结果为18

书写格式:
x.match(regexp)
x.search(regexp)
使用注解:
x代表字符串对象
regexp代表正则表达式或字符串
match返回匹配字符串的数组,如果没有匹配则返回null
search返回匹配字符串的首字符位置索引

var str1="welcome to the world of Python! ";
var str2=str1.match("world");
var str3=str1.search("world");
alert(str2[0]);  //结果为"world"
alert(str3);  //结果为15

  String对象的方法(5)——子字符串处理

  截取子字符串

书写格式:
x.substr(start, length)
x.substring(start, end)
使用注解:
x代表字符串对象
start表示开始位置
length表示截取长度
end是结束位置加1
第一个字符位置为0

var str1="abcdefgh";
var str2=str1.substr(2, 4);
var str3=str1.substring(2, 4);
alert(str2);  //结果为"cdef"
alert(str3);  //结果为"cd"

x.slice(start, end)
var str1="abcdefgh";
var str2=str1.slice(2, 4);
var str3=str1.slice(4);
var str4=str1.slice(2, -1);
var str5=str1.slice(-3, -1);
alert(str2);  //结果为"cd"
alert(str3);  //结果为"efgh"
alert(str4);  //结果为"cdefg"
alert(str5);  //结果为"fg"

  替换子字符串

x.replace(findstr, tostr)

var str1="abcdefgh";
var str2=str1.replace("cd", "aaa");
alert(str2);  //结果为"abaaaefgh"

  分割字符串

var str1="一,二,三,四,五,六,日";
var strArray=str1.split(",");
alert(strArray[1]);  //结果为""

  连接字符串

书写格式:
y=x.concat(addstr)
使用注解:
x代表字符串对象
addstr为添加字符串
返回x+addstr字符串

var str1="abcd";
var str2=str1.concat("efgh");
alert(str2);  //结果为"abcdefgh"

  3.Array对象

  创建数组对象

Array对象用于在单个的变量中存储多个值。
语法:
创建方式1:
var a=[1, 2, 3];
创建方式2:
new Array();  //创建数组时允许指定元素个数也可以不指定元素个数。
new Array(size);  //如果1个参数且为数字,即代表size
初始化数组对象:
var cnweek=new Array(7);
cnweek[0]= "星期日";
cnweek[1]= "星期一";
......
cnweek[6]= "星期六";
new Array(element0, element1, ..., elementn)  //也可以直接在建立对象时初始化数组元素,元素类型允许不同
var test=new Array(100, "a", true)

  创建二维数组

var cnweek=new Array(7);
for(var i=0;i<=6;i++){
    cnweek[i]=new Array(2);
}
cnweek[0][0]= "星期日";
cnweek[0][1]= "Sunday";
cnweek[1][0]= "星期一";
cnweek[1][1]= "Monday";
......
cnweek[6][0]= "星期六";
cnweek[6][1]= "Saturday";

  Array对象的属性

  获取数组元素的个数:length

var cnweek=new Array(7);
cnweek[0]= "星期日";
cnweek[1]= "星期一";
cnweek[2]= "星期二";
cnweek[3]= "星期三";
cnweek[4]= "星期四";
cnweek[5]= "星期五";
cnweek[6]= "星期六";
for(var i=0;i<cnweek.length;i++){
    document.write(cnweek[i]+ " | ");
}

  Array对象的方法

类别

方法

说明

获取子数组

slice(start, end)

通过数组元素起始和结束索引号获取子数组

splice(start, deleteCount, value, ...)

通过数组元素起始和结束索引号获取子数组

进出栈操作

push(value, ...)

数组末端入栈操作

pop()

  • 发表于 2019-07-09 10:20
  • 阅读 ( 150 )
  • 分类:网络文章

条评论

请先 登录 后评论
不写代码的码农
小编

篇文章

作家榜 »

  1. 小编 文章
返回顶部
部分文章转自于网络,若有侵权请联系我们删除