JavaScript学习(一) -- 与C#语法重大区别

1. 数据类型

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

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

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

2. JavaScript 变量重新声明

如果重新声明 JavaScript 变量，该变量的值不会丢失：在以下两条语句执行后，变量 carname 的值依然是 "Volvo"：

var carname = "Volvo";
var carname;

3.JavaScript 对象 

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

var cars = ["Saab","Volvo","BMW"];   //定义数组

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

var person =     //表示一个对象（对象是属性和方法的容器）
{
  firstname : "John",
  lastname  : "Doe",
  id        :  5566,
  friends   :  ["Bob","Salay","Li"]    //数组
  fullName  : function()   //方法
  {
       return this.firstName + " " + this.lastName;
  }
};

4.Undefined 和 Null 

• null 是一个只有一个值的特殊类型。表示一个空对象引用。可以通过将变量的值设置为 null 来清空变量。
• undefined 是一个没有设置值的变量。typeof 一个没有值的变量会返回 undefined。

var cars;   //不赋值时为 Undefined
var person = null;

typeof undefined             // undefined
typeof null                  // object
null === undefined           // false
null == undefined            // true

null 和 undefined 的值相等，但类型不等

5.JavaScript 全局变量

如果变量在函数内没有声明（没有使用 var 关键字），该变量为全局变量。

以下实例中 carName 在函数内，但是为全局变量。

// 此处可调用 carName 变量
 
function myFunction() 
{
    carName = "Volvo";
    // 此处可调用 carName 变量
}

6.对象和原始值 

var x = "John";   //原始值
var y = new String("John");
typeof x // 返回 String
typeof y // 返回 Object

不要创建 String 对象。它会拖慢执行速度，并可能产生其他副作用

var x = "John";             
var y = new String("John");
(x === y) // 结果为 false，因为 x 是字符串，y 是对象

=== 为绝对相等，即数据类型与值都必须相等。

7.For/In 循环 

function myFunction()
{
	var x;
	var txt="";
	var person = {fname:"Bill",lname:"Gates",age:56}; 
	for (x in person)   //C# foreach in 不能这样写
	{
		txt += person[x];   //txt结果为 BillGates56
        txt += x;           //txt结果为 fnamelnameage
	}
}

8.JavaScript 标签 

continue 语句（带有或不带标签引用）只能用在循环中。

break 语句（不带标签引用），只能用在循环或 switch 中。

cars=["BMW","Volvo","Saab","Ford"];
var txt="";	
list:
{
  txt+=cars[0];
  txt+=cars[1];
  break list;
  txt+=cars[2];
}
//txt结果为 BMWVolvo

9.严格模式(use strict) 

 严格模式通过在脚本或函数的头部添加 "use strict"; 表达式来声明。

10.return 语句 

JavaScript 默认是在代码的最后一行自动结束。

function myFunction(a) 
{
    var
    power = 10; 
    return a * power;
}

function myFunction(a)    //返回  undefined
{
    var
    power = 10; 
    return
    a * power;
}

在 JavaScript 中，分号是可选的 。由于 return 是一个完整的语句，所以 JavaScript 将关闭 return 语句。

11.函数和方法 

<script>

function myFunction()    //这是函数
{
  return this;
}


var person = 
{
  firstName: "John",
  lastName : "Doe",
  id     : 5566,
  fullName : function()    //这是方法
  {
    return this.firstName + " " + this.lastName;
  }
};

</script>

12.this指向

1. 在对象方法中， this 指向调用它所在方法的对象。
2.  单独使用 this，它指向全局(Global)对象。
3.  函数使用中，this 指向函数的所属者。
4.  严格模式下函数是没有绑定到 this 上，这时候 this 是 undefined。
5.  在 HTML 事件句柄中，this 指向了接收事件的 HTML 元素。
6.  apply 和 call 允许切换函数执行的上下文环境（context），即 this 绑定的对象，可以将 this 引用到任何对象。

13.显式函数绑定  （apply 和 call）

在 JavaScript 中函数也是对象，对象则有方法，apply 和 call 就是函数对象的方法。这两个方法异常强大，他们允许切换函数执行的上下文环境（context），即 this 绑定的对象。

在下面实例中，当我们使用 person2 作为参数来调用 person1.fullName 方法时, this 将指向 person2, 即便它是 person1 的方法：

script>
var person1 = 
{
  fullName: function() 
  {
    return this.firstName + " " + this.lastName;
  }
}
var person2 = 
{
  firstName:"John",
  lastName: "Doe",
}
var x = person1.fullName.call(person2);   //返回  John Doe
</script>

14.关键字：let 和 const 

（1）let 声明的变量只在 let 命令所在的代码块内有效。

使用 var 关键字声明的变量不具备块级作用域的特性，它在 {} 外依然能被访问到。

{ 
    var x = 2; 
}
// 这里可以使用 x 变量

在 ES6 之前，是没有块级作用域的概念的。

ES6 可以使用 let 关键字来实现块级作用域。

let 声明的变量只在 let 命令所在的代码块 {} 内有效，在 {} 之外不能访问。

{ 
    let x = 2;
}
// 这里不能使用 x 变量

（2）const 用于声明一个或多个常量，声明时必须进行初始化，且初始化后值不可再修改：

const 和 let 的异同： 

相同点：

• 二者都是块级作用域
• 都不能和它所在作用域内的其他变量或函数拥有相同的名称

不同点：

• const声明的常量必须初始化，而let声明的变量不用
• const 定义常量的值不能通过再赋值修改，也不能再次声明。而 let 定义的变量值可以修改。