本文实例讲述了JavaScript学习笔记之数组基本操作。分享给大家供大家参考，具体如下：
公司主营业务：网站设计、成都网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联公司推出碑林免费做网站回馈大家。
一、数组定义
1、定义
vara=[1,2,3]
vara=newArray(1,2,3);
2、长度
返回长度
script
vara=[1,2,3,4,5,6];
alert(a.length);
/script
设置长度
script
vara=[1,2,3,4,5,6];
a.length=2;
alert(a);
/script
二、数组连接
script
vara=[1,2,3];
varb=[4,5,6];
alert(a.concat(b));
alert(b.concat(a));
/script
三、数组排序
sort()函数
默认情况是把数组元素按字符串排序
例子
01
script
vararr=['float','width','alpha','zoom','left'];
arr.sort();
alert(arr);
/script
例子02
vararr=[12,8,99,19,112];
arr.sort();
alert(arr);
例子03
sort()函数的改进
vararr=[12,8,99,19,112];
arr.sort(function(n1,n2){
returnn1-n2;
});
alert(arr);
四、数组连接
1、两个数组间的连接：contact()
script
vara=[1,2,3];
varb=[4,5,6];
alert(a.concat(b));
alert(b.concat(a));
/script
2、数组元素间的连接：join()
script
vararr=[1,2,3,4];
alert(arr.join('--p'));
/script
五、数组元素添加、删除
1、数组尾部的添加、删除
尾部添加：push(value)
例子01
script
vara=[1,2,3];
a.push(4);
alert(a);
/script
尾部删除：pop()
例子02
script
vara=[1,2,3];
a.pop();
alert(a);
/script
2、数组头部的添加、删除
头部添加
unshift(value)
例子01
script
vararr=[1,2,3];
arr.unshift(0)
alert(arr);
/script
头部删除:shift()
例子02
script
vararr=[1,2,3];
arr.shift();
alert(arr);
/script
3、数组------splice()
删除数据
例子01
script
vararr=[1,2,3,4,5,6];
//splice(起点，长度)
arr.splice(2,3);
alert(arr);
/script
插入数据
例子02
script
vararr=[1,2,3,4,5,6];
//插入数据splice（起点，长度，元素）
arr.splice(2,0,'a','b','c');
alert(arr);
/script
替换数据
例子02
script
vararr=[1,2,3,4,5,6];
//替换数据
arr.splice(2,2,'a','b');
alert(arr);
/script
感兴趣的朋友可以使用在线HTML/CSS/JavaScript代码运行工具：测试上述代码运行结果。
更多关于JavaScript相关内容还可查看本站专题：《JavaScript数组操作技巧总结》、《JavaScript字符与字符串操作技巧总结》、《JavaScript遍历算法与技巧总结》、《JavaScript排序算法总结》、《JavaScript查找算法技巧总结》、《JavaScript数学运算用法总结》、《JavaScript数据结构与算法技巧总结》及《JavaScript错误与调试技巧总结》
希望本文所述对大家JavaScript程序设计有所帮助。
您可能感兴趣的文章:js数组与字符串的相互转换方法js删除数组元素、清空数组的简单方法(必看)js数组循环遍历数组内所有元素的方法JS
array
数组详解js数组去重的三种常用方法总结JavaScript从数组中删除指定值元素的方法JS数组的遍历方式for循环与for...in向JavaScript的数组中添加元素的方法小结JS删除数组里的某个元素方法javascript
数组的定义和数组的长度Js数组的操作push,pop,shift,unshift等方法详细介绍
不知道，大家对语言中变量的“声明”与“定义”是怎么理解的，
我的理解如下：
“声明”变量，只是仅仅声明，而“定义”变量，指声明了，并且赋值了。
例如:
复制代码
代码如下:
var
name;//只是声明
var
num
=
11;//声明，并且赋值，即定义了
var
password
=
"yangjiang";//声明，并且赋值，即定义了
下面是几点总结：
变量的作用域：全局的和局部的。（注意：如果尝试读取一个未声明的变量的值，javascript会生成一个错误）
第一点：在都使用var关键字修饰变量的情况下，如果给一个局部变量或函数的参数声明的名字与某个全局变量的名字相同，
那么就有效地隐藏了这个全局变量。
例如：
复制代码
代码如下:
var
scope1
=
"global";//var修饰
function
checksScope(){
var
scope1
=
"local";//var修饰
document.write(scope1);
}checksScope();//local
第二点：如果尝试给一个未用
var
关键字声明的变量，那么，隐式声明的变量总是被创建为全局变量，即使
该变量只在一个函数体内使用（只有该函数运行了，才会发生作用）,注意不支持函数嵌套的情形。
例如：
复制代码
代码如下:
scope2
=
"globalAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
function
checkScopeA(){
scope2
=
"localAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
document.write("br/"+scope2);
myscope
=
"myLocalAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
document.write(","+myscope);
}
checkScopeA();//localAAAAA，myLocalAAAAA
*A
document.write("br/"+scope2);//localAAAAA
*B
document.write("br/"+myscope);//myLocalAAAAA
*C
如果将上面的例子中的
*A处的代码注释掉，
例如：
复制代码
代码如下:
scope2
=
"globalAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
function
checkScopeA(){
scope2
=
"localAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
document.write("br/"+scope2);
myscope
=
"myLocalAAAAA";//没有使用var修饰(js会默认将其声明为全局变量)
document.write(","+myscope);
}
//checkScopeA();
*A
document.write("br/"+scope2);//globalAAAAA
*B
document.write("br/"+myscope);//发生错误
*C
因为函数checkScopeA没有执行，所以
*B处输出为globalAAAAA;
因为函数checkScopeA没有执行，所以变量myscope没有声明，如果尝试读取一个未声明的变量，会发生错误。
第三点：
在javascript中，函数的定义是可以嵌套的。由于
每个函数都有它自己的局部作用域，所以有可能出现几个局部作用域的嵌套层。
例如：
复制代码
代码如下:
var
scope3
=
"global
scope";
//定义了一个全局变量
function
checkScopeB(){
var
scope3
=
"local
scope";
//定义了一个局部变量，覆盖了全局变量scope3
function
nested(){
var
scope3
=
"nested
scope";
//在函数的函数的内部，定义了一个局部变量
document.write("br/"+scope3);
//nested
scope
}
nested();
}
checkScopeB();//nested
scope
第四点：
在javascript中，没有块级作用域，函数中声明的所有变量，无论是在哪里声明的，在整个函数中它们都是有声明的。
在javascript中，没有块级作用域，函数中定义的所有变量，无论是在哪里定义的，在整个函数中它们都是有定义的。
例如：
复制代码
代码如下:
function
test(o){//根据以上的说明：此函数中的i,j,k三个变量的作用域是相同的。
var
i
=
0;
//变量
i
在整个函数中都有定义
if(typeof
o
==
"object"){
var
j
=
;
//变量
j
在整个函数中都有定义，而不仅仅是在
if
语句块
for(var
k=0;k10;k++){//变量
k
在整个函数中都有定义，而不仅仅是在
if
语句块
document.write("br/k的值为："+k);
}
document.write("br/for循环外k的值："+k);//此时的
k
仍然被定义了，k=10
}
document.write("br/j的值:"+j);
//变量
j
被声明了，但可能没有被初始化
因为可能往函数中
传入的参数
不是对象
，if语句块不会执行
}
下面通过两种方式调用此函数：
方式一：传入对象
test({});//输出结果：上例中的注释
方式二：什么都不传
test();//输出结果：j的值：undefined
想不明白的是,在第二种方式中的输出结果,为什么会是
undefined。我当时猜的是：j的值：0
后来，这本书上面说：
由于局部变量在整个函数体内都是有声明（或定义）的，这就意味着在整个函数体中都隐藏了同名的全局
变量。虽然
局部变量在整个函数体内中都是有声明（或定义）的，但是在执行var语句之前，它是不会被初始化的。
这样的话，上面的方式二调用的输出结果，就比较好解释了，由于变量j在整个函数中都有定义，而又由于传入函数的参数为空，所以函数体中的if语句不会执行，从而使得j的值为undefined.（这是我参照上面书上说的那句话的理解）
下面的例子，更好的说明：
复制代码
代码如下:
var
sssss
=
"全局变量";
function
f(){
document.write("br/"+sssss);//输出：undefined
而不是输出"全局变量"
var
sssss
=
"局部变量";
document.write("br/"+sssss);//输出：局部变量
}
一、语法
delete后面的表达式必须给出一个属性的引用，比如
var
o
=
{a:1};
delete
o.a;
//此处o.a是对象o的属性a的引用
只有在with语句里才能使用单独的属性名
复制代码
代码如下:
with(o){
delete
a;
}
二、delete的返回值
delete是普通运算符，会返回true或false。规则为：当被delete的对象的属性存在并且不能被删除时
返回false，否则返回true。
这里的一个特点就是，对象属性不存在时也返回true，所以返回值并非完全等同于删除成功与否。
复制代码
代码如下:
var
o
=
{a:1};
delete
o.a;
//返回true
var
b
=
2;
delete
b;//返回false，ECMA规则约定:使用var和function声明的变量不可以被delete
三、哪些情况下不允许delete
上例提到的var和function声明的变量不可以被delete，但隐式声明可以被删除
复制代码
代码如下:
function
c(){return
12;}
delete
c;//返回false
d
=
function(){return
12;}
delete
d;//返回true
不能delete从原型链上继承的属性，但可以删除原型链上的属性
复制代码
代码如下:
function
Foo(){}
Foo.prototype.bar
=
42;
var
foo
=
new
Foo();
delete
foo.bar;
//
返回true,但并没有起作用
alert(foo.bar);
//
alerts
42,
属性是继承的
delete
Foo.prototype.bar;
//
在原型上删除属性bar
alert(foo.bar);
//
alerts
"undefined",
属性已经不存在，无法被继承
四、特例
复制代码
代码如下:
eval执行的代码中如有通过var和function声明的变量，可以被delete
eval("var
a=1");
delete
a;
alert(a);
//报未定义错误
如果声明是在eval执行代码中的闭包内进行的，则变量不能被delete
eval("(function(){var
a=1;delete
a;
return
a;})()");//1
五、delete
数组元素
从数组中delete其元素并不会影响数组的长度
复制代码
代码如下:
var
arr
=
['yuyin','suhuan','baby'];
delete
arr[0];
alert(arr.length);//alert
3
被delete的键值已经不属于数组，但却还是可以被访问，其值为undefined。
复制代码
代码如下:
var
arr
=
['yuyin','suhuan','baby'];
delete
arr[0];
in
arr;
//
false
alert(arr[0]);//undefined
arr[0]
===
undefined;//true
对比直接将键值赋值undefined
复制代码
代码如下:
var
arr
=
['yuyin','suhuan','baby'];
arr[0]
=
undefined;
in
arr;
//
true
alert(arr[0]);//undefined
arr[0]
===
undefined;//true
可以看出delete
操作只是将键值这个属性从数组中删除了，数组本身也是对象，这个情况好理解的。如果需要保留键值，可以用undefined赋值。
构造函数
new
Object（）
new
Object(value)
参数
value
可选的参数，声明了要转换成Number对象、Boolean对象或String对象的原始值(即数字、布尔值或字符串)。JavaScript
1.1之前的版本和ECMAScript
Vl不支持该对象。
返回值
如果没有给构造函数传递value参数，那么它将返回一个
新创建的Object实例。如果指定了原始的value参数，构造函数将创建并返回原始值的包装对象，即Number对象、Boolean对象或
String对象。当不使用new运算符，将Object()构造函数作为函数调用时，它的行为与使用new运算符时一样。
属性
constructor
对一个JavaScript函数的引用，该函数是对象的构造函数
方法
1.hasOwnProperty(
)
检查对象是否有局部定义的(非继承的)、具有特定名字的属性。
复制代码
代码如下:
script
type="text/javascript"
var
o
=
new
Object();
o.name="Tom";
alert(o.hasOwnProperty("name"));
//true
alert(o.hasOwnProperty("age"));
//false
/script
2.isPrototypeOf()
语法
object.isPrototypeOf(o)
参数
o
任意对象。
返回值
如果object是O的原型，则返回true。如果o不是对象，或者object不是o的原
型，则返回false。
描述
JavaScript对象继承了原型对象的属性。一个对象的原型是通过用于创建并初始化该对象的构造函数的prototype属性引用的。isPrototypeOf()方法提供了判断一个对象是否是另一个对象原型的方法。该方法可以用于确定对象的
类。
示例
复制代码
代码如下:
var
o
=
new
Object(
);
//
创建一个对象
Object.prototype.isPrototypeOf(o)
//
true:
o
是一个对象
Function.prototype.isPrototypeOf(o.toString);
//
true:
toString
是一个函数
Array.prototype.isPrototypeOf([1,2,3]);
//
true:
[1,2,3]
是一个数组
//下面是执行同样测试的另一种方法
(o.constructor
==
Object);
//
true:
o
was
created
with
Object(
)
constructor
(o.toString.constructor
==
Function);
//
true:
o.toString
is
a
function
/原型则对象本身于原型对象。下面的调用返回true
//说明函数继
Function.prototype和Object.prototyp属性.
Object.prototype.isPrototypeOf(Function.prototype);
3.ProertyIsEnumerable()
语法
object.propertyIsEnumerable(propname)
参数
propname
一个字符串，包含object原型的名字。
返回值
如果object具有名为propname的非继承属性，而且该属性是可枚举的(即用for/in循环可以枚举出它)，则返回true。
描述
用for/in语句可以遍历一个对象“可枚举”的属性。但并非—个对象的所有属性都是可枚举的，通过JavaScript代码添加到对象的属性是可枚举的，而内部对象的预定义属性(如方法)通常是不可枚举的。propertylsEnumerable()方法提供了区分可枚举属性和不可枚举属性的方法。但要注意，ECMAScript标准规定，propertyIsEnumerable()方法不检测原型链，这意味着它只适用于对象的局部属性，不能检测继承属性的可枚举性。
示例
复制代码
代码如下:
var
o
=
new
Object(
);
//
创建一个对象
o.x
=
3.14;
//
定义—个属性
o.propertyIsEnumerable("x");
//
true属性x是局部的、可枚举的
o.propertyIsEnumerable("y");
//false：o没有属性y
o.propertyIsEnumerable("toString");
//false：toStrlng属性是继承的
Object.prototype.propertyIsEnumerable("toString");
//
false:
枚举的
Bug
当标准限制propertylsEnumerable()方法只能检测非继承属性时，明显是错的。
Internet
Explorer
5.5按标准实现了该方法。Nestacpe
6.0实现的propertyIsEnumerable()方法考虑了原型链。虽然这种方法可取，但它与标准冲突，所以Netscape
6.1修改了它，以便与IE
5.5匹配。由于标准中有这个错误，因此该方法不是那么有用。
复制代码
代码如下:
script
var
obj
=
new
Object();
obj.title
=
'aaa';
obj.funb
=
function(a,
b)
{
alert(a+b);
}
alert(obj.title);
obj.funb(1,2);
/script
这里一种方法
******************************
复制代码
代码如下:
script
language="javascript"
function
object(value,a,b){
this.title
=
value;
this.funb
=
function(){
this.a
=
a;
this.b
=
b;
alert(a+b);
}
}
var
obj
=
new
object("aaa",1,2);
alert(obj.title);
obj.funb();
//这里为对象添加新的方法
object.prototype.name
=
"123456";
alert(obj.name);
/script
这是另一种方法
