JavaScript基本概念（二）

（表达式、语句、对象、数组、函数）
一、表达式    

1、对象和数组的初始化表达式

var arr = []  
var p = {};

2、函数定义表达式

表达式的值是这个新定义的函数。

var f = function(){}

3、调用表达式

f()  
a.sort()

二、语句

JavaScript解释器依照语句的编写顺序依次执行。

1、表示式语句

（1）复合语句

我们可以用花括号将多条语句括起来，这就是复合语句（语句块）。

（2）空语句

分号前面可以没有任何内容

2、声明语句 

var和function都是声明语句，它们声明或定义变量或函数。

function a(){}

3、条件语句

（1）if else

（2）switch

switch(expression) {
  case "":
  case "":
      statement;break;
  .....
}

注意：由于对每个case的匹配操作实际是“===”全等运算符比较，而不是“==”相等运算符比较，因此，表达式和case的匹配并不会做任何类型转换。比如字符串"10"不等于数值10.

（3）三元运算符 

(contidion) ? expr1 : expr2

（4）循环语句

while语句

在循环体内的代码被执行之前，就会对出口条件求值。

while(expression) {   
  statement  
}

do...while语句

在对条件表达式求值之前，循环体内的代码至少会被执行一次。

do {   
  statement  
} while(expression);

for语句

for(initialize ; test ; increment) {   
  statement  
}

initialize、test、increment三个表达式之间用分号隔开，分别负责初始化操作、循环条件判断和计数器变量的更新。

for...in语句

var o = { name: 'tg', age: 18};
for(var v in o) {
  console.log(v + ': ' + o[v]);
}

4、跳转语句

break语句是强制退出循环，然后执行循环后面的语句。
continue语句是终止本次循环的执行并开始下一次循环的执行。

5、标签语句

标签是由语句前的标识符和冒号组成。label语句定义的标签一般由break或continue语句引用。加标签的语句一般要与for等循环语句配合使用。

label : statement

6、其他语句

（1）return

函数体内出现，否则报错。当执行到return语句时，函数终止执行。

（2）throw语句

异常是指当发生了某种异常情况或错误时产生的一个信号。

（3）with语句

with语句用于临时扩展作用域链，也就是将代码的作用域设置到一个特定的对象中。

with(object){   
  statement  
}

将object添加到作用域链的头部，然后执行statement，最后把作用域链恢复到原生状态。

var o = {
    name: 'tg',
    age: 24
};
with(o){
    console.log('name：' + name);  // name：tg
    console.log('age：' + age);  // age：24
}

with里面的name相当于o.name。

（4）debugger语句

debugger语句用来产生一个断点（breakpoint），JavaScript代码的执行会停止在断点的位置。一般用来调试代码。

三、对象

1、对象

var o={
  name:'a'
}

键名：对象的所有键名都是字符串，所以加不加引号都可以。如果键名是数值，会被自动转为字符串。

如果键名不符合标识名的条件（比如第一个字符为数字，或者含有空格或运算符），也不是数字，则必须加上引号，否则会报错。

var o = {
  go: function(x){
    return x+1;
  }
};
o.go(2) // 3

如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用。

2、创建对象

• 对象直接量： var o={};
• 关键字new： var o=new Object();
• Object.create()函数： var o=Object.create(null)

3、读取属性

var o = {
  name : 'a'
}
o.name  // "a"
o['name']  //“a"

注意：数值键名不能使用点运算符（因为会被当成小数点），只能使用方括号运算符。

4、属性查询和设置

（1）for...in

var o = {
  name : 'a',
  age : 12
}
for(var i in o){
  console.log(o[i]
}
// "a"
// 12

（2）查看所有属性 

使用Object.keys方法，返回一个数组。

var o = {
  name : 'a',
  age : 12
}

Object.keys(o)  //['name','age']

（3）删除属性

delete运算符可以删除对象的属性。（只能删除自有属性，不能删除继承属性。）

var o={
  name : 'a'
}
delete o.name  //true
o.name  //undefined

（4）检测属性

hasOwnPreperty()方法

用于判断一个对象自身(不包括原型链)是否具有指定名称的属性。如果有，返回true，否则返回false。

in运算符

in运算符左侧是属性名（字符串），右侧是对象。如果对象的自有属性或继承属性中包含这个属性就返回true。

var o = {
  name : 'a'
}
'name' in o //true

5、序列化对象

对象序列化是指将对象的状态转换为字符串

内置函数JSON.stringify()和JSON.parse()用来序列化和还原JavaScript对象。

var o = {
  name : 'a',
  age : 12,
  intro : [false,null,'']
}
s= JSON.stringify(o)  // s {"name":"a","age":12,"intro":[false,null,""]}
p=JSON.parse(s)  // p是o的深拷贝

注意：JSON.stringify()只能序列化对象可枚举的自有属性。对于一个不能序列化的属性来说，在序列化后的输出字符串中会将这个属性省略掉。

6、构造函数

构造函数也可以传入参数：

function Car(color){
  this.color = color;
}
var c = new Car('red’);

7、原型

每一个JavaScript对象（null除外）都和另一个对象相关联，也可以说，继承另一个对象。另一个对象就是我们熟知的“原型”（prototype），每一个对象都从原型继承属性。所有对象的原型最终都可以上溯到Object.prototype

（1）instanceof运算符

指定对象是否为某个构造函数的实例

（2）Object.getPrototypeOf()

返回一个对象的原型

Object.getPrototypeOf(c) === Car.prototype  //true

（3）Object.create()

Object.create方法用于从原型对象生成新的实例对象，可以替代new命令。

（4）Object.getOwnPropertyNames()

Object.getOwnPropertyNames方法返回一个数组，成员是对象本身的所有属性的键名，不包含继承的属性键名。

（5）Object.prototype.hasOwnProperty()

对象实例的hasOwnProperty方法返回一个布尔值，用于判断某个属性定义在对象自身，还是定义在原型链上。

四、数组

1、数组定义

var  arr = [1,2,3];

var arr = [];
arr[0] =1;

数组元素可以是任意类型。（数字，字符串，对象，函数）

var arr = [1,'a',{name:'a'},function(){}];

2、创建数组

（1）var  arr = [1,2,3];

（2）new Array()

var a=new Array(); 
var a2=new Array(10);   //包含10个数组项但为undefined的数组
var a3=new Array(1,2,3,4); //包含4个数组项，并且分别有值

3、数组长度

.length 属性

将length属性设为0，会将数组清空。

如果人为设置length大于当前元素个数，则数组的成员数量会增加到这个值，新增的位置都是空位。

var arr = [1];
arr.length=3;
arr[1]  //undefined

4、数组读和写

（1）增加删除

push()方法在数组末尾添加一个或多个元素。

var arr = [1,2]
arr.push(3)  // [1,2,3]
arr.push('a','b') //[1,2,3,'a','b']
// shift()是删除数组的一个元素。 
arr.shift()   // [2,3,'a',’b']

5、稀疏数组

稀疏数组是指包含从0开始的不连续索引的数组。通常，数组的length属性值代表数组中元素的个数，但如果是稀疏数组，length属性值大于元素的个数。

6、多维数组

JavaScript不支持真正的多维数组，但可以用数组的数组来近似。也可以说，数组里放数组。

var arr = [[1],[2,3]];
arr[0][0]  // 1
arr[1][1]  //3

7、遍历数组

使用for循环、while循环、for..in或者forEach()方法来遍历数组

// for循环  
for(var i = 0; i < a.length; i++) {   
  console.log(a[i]);  
}

//while
var i = 0;  
while (i < a.length) {   
  console.log(a[i]);   
  i++;  
}

//for..in
for (var i in a) {    
  console.log(a[i]);    
}

//forEach
a.forEach(function(v){
  console.log(v);
})

8、类数组对象

有些对象被称为“类数组对象”。只要有length属性，就可以认为这个对象类似于数组。但是，对象的length属性不是动态值，不会随着成员的变化而变化。

var o = {
  0: 'a',
  1: 'b',
  length:2
}
o[0]  // "a"
o[1]  // "b"
o.length // 2

五、函数

函数使用function关键字来声明，后跟一组参数以及函数体，这些参数在函数体内像局部变量一样工作。

1、

function test(num){
  if(num > 2){
   return num;
  }else{
    return ;
  }
}

如果函数挂载在一个对象上，将作为对象的一个属性，就称它为对象的方法。

var o = {
  test: function(){}
}

test()就是对象o的方法。

2、函数定义：

（1）function命令

function name() {}

（2）函数表达式

function命令后面不带有函数名。如果加上函数名，该函数名只在函数体内部有效，在函数体外部无效。

var f = function(x){   
  console.log(x);  
}

（3）Function()

var f=new Function('x','y','return x+y');

Function()函数定义还可以通过Function()构造函数来定义

等价于

var f=function(x,y){
  return x+y;
}

注：如果同一个函数被多次定义（声明），后面的定义（声明）就会覆盖前面的定义（声明）

3、函数声明语句“被提前“

函数声明语句也会“被提前”到外部脚本或外部函数作用域的顶部，所以以这种方式声明的函数，可以被在它定义之前出现的代码所调用。

f()

function f(){}

注意：以表达式定义的函数并没有“被提前”，而是以变量的形式“被提前”。

f();                    //等同于var f;   f(); //调用时只是声明了，没有赋值，未定义
var f = function (){};  
// TypeError: f is not a function

4、嵌套函数

函数可以嵌套在其他函数中定义，这样它们就可以访问它们被定义时所处的作用域中的任何变量

function test(){
  var name = 'tg';
  function test2(){
    var age = 10;
    console.log(name);  // "tg"
  }
  console.log(age);  // Uncaught ReferenceError: age is not defined
}

5、函数的参数

当调用函数时，可以通过数字下标来访问传入函数的实参值，而不用非要通过名字来得到实参。

标识符arguments出现了，其指向实参对象的引用，实参对象是一个类数组对象

function go(x){   
  console.log(arguments[0]);   
  console.log(arguments[1]);  
}  
go(1,2);  
//1
//2

arguments有一个length属性，用以标识其所包含元素的个数。

我们可以借助Array类的原型对象的slice方法，将其转为真正的数组：

Array.prototype.slice.call(arguments, 0);
//更简洁的写法
[].slice.call(arguments, 0);

6、按值传参

参数传递引用类型的值时，会先把这个值在内存中的地址复制给一个局部变量，若局部变量变化，全局变量也会发生改变。

function test(obj){
  obj.name = 'tg';
}
var person = new Object();
test(person);
console.log(person.name);  // “tg"

但是，如果局部变量指向了一个新的堆内地址（在函数内new一个新的对象），再改变局部变量的属性时，不会影响全局变量。

7、函数属性、方法和构造函数

（1）name属性

name属性返回紧跟在function关键字之后的那个函数名。

function f(){}
f.name   //f

（2）length属性

函数的length属性是只读属性，代表函数形参的数量，也就是在函数定义时给出的形参个数。

（3）prototype属性

每一个函数都包含一个prototype属性，这个属性指向一个对象的引用，这个对象称做“原型对象”（prototype object）。

（4）apply

apply([thisObj[,argArray]]) 

定义：应用某一对象的一个方法，用另一个对象替换当前对象。

（5）eval命令

将字符串当作语句执行

eval('var a=1');
a  //1

注：转自  http://www.kancloud.cn/dennis/tgjavascript/241802