JScript学习心得

基本语法

• 对大小写敏感
• 标识符
• 关键字
  break do instanceof typeof case else new var catch finally return void continue for switch while debugger function this with default if throw delete in try
• 变量

 

 

操作符

• 一元操作符 ++ --
• 布尔操作符 && || ！（&&和||都属于 短路操作！）
• 除下列值为假外其余皆为真： false、null、undefined、''、0、NaN
• 算术运算符 + - * / %
• 关系操作符 <> <=>= == === != !==
• 条件（问号）操作符 ? : 例： var max = (num1 > num2) ? num1 : num2;
• 赋值操作符 = += -+ *= /= %=

语句

• if do-while while for for-in for-of break continue switch（注意为语句块加{}）
  例： 执行结果为：

 

函数

• 函数（ function）对任何语言来说都是一个核心的概念。通过函数可以封装任意多条语句，而且可以在任何地方、任何时候调用执行；例：

function sayHi(name, message) {
console.log('Hello ' + name + ',' + message);
} sayHi('Gridwang', '你好。');
ECMAScript 中的函数在定义时不必指定是否返回值。实际上，任何函数在任何时候都可以通过 return 语句后跟要返回的值来实现返回值 例： function sum(num1, num2) {
return num1 + num2;
} var result = sum(3, 2);
console.log(result);

对象

对象的定义方式有两种

• 方式一new var person = new Object();//生成空对象
  person.name = 'Mical';//设置对象的属性
  person.age = 20;
  person.job = 'Student';
  person.sayName = function(){ //设置对象的方法/函数，注意此处
  console.log(this.name);
  };
• 方式二字面量
  var person = {
  name: 'Lary Page',
  age: 47,
  job: 'Software Engineer',
  sayName: function(){ //注意此处
  console.log(this.name);
  } };
  console.log(person.job);
  person.sayName();
• Object 构造函数或对象字面量都可以用来创建单个对象，但是使用同一个接口创建很多对象，会产生大量的重复代码。为解决这个问题，人们开始使用工厂模式的一种变体。代码如下
  function createPerson(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
  console.log(this.name);
  };
  return o;
  } var person1 = createPerson('Steve Jobs',56 , 'Inventor');
  var person2 = createPerson('Linus Torvalds', 49, 'Software Engineer');

数组Array

• ECMAScript 中的数组与其他多数语言中的数组有着相当大的区别。虽然 ECMAScript 数组与其他语言中的数组都是数据的有序列表，但与其他语言不同的是，ECMAScript 数组的每一项 可以保存任何类型的数据（不建议！）。 也就是说，我们可以用数组的第一个位置来保存字符串，用第二位置来保存数值，用第三个位置来保存对象，以此类推。而且，ECMAScript 数组的大小是可以动态调整的。
  创建数组有以下两种方法，我们常用第二种。

       //方式一new
       var colors = new Array('red', 'blue', 'green');
       //方式二字面量
       var colors = ['red', 'blue', 'green'];
       // 创建一个包含 3 个字符串的数组
       console.log(colors[1]);
       colors[3] = 'brown';
       console.log(colors.length);
       var names = []; // 创建一个空数组
       var hyBird = [1, 2, 'haha', {firstName: 'Yong', lastName: 'Wang'}]; //不推荐！
        console.log(hyBird[3].firstName);

• 常用的数组方法如下：
• 方法一.元素联合
  var colors = ['red', 'green', 'blue'];
  console.log(colors.join(',')); //加入后的格式：red,green,blue
  console.log(colors.join('||'));加入后的格式： //red||green||blue
• 方法二：堆栈方法（ 栈是一种 LIFO（Last-In-First-Out，后进先出）的数据结构，也就是最新添加的项最早被移除。而栈中项的插入（叫做推入）和移除（叫做弹出），只发生在一个位置——栈的顶部。 ECMAScript 为数组专门提供了 push() 和 pop() 方法，以便实现类似栈的行为。）
  例：
  var colors = []; // 创建一个数组
  var count = colors.push('red', 'green'); // 末尾推入两项
  console.log(count); //2
  colors.push('black'); // 末尾推入另一项
  console.log(colors); //3
  var item = colors.pop(); // 末尾弹出最后一项
  console.log(item); //'black'
  console.log(colors); //2
• 方法三：队列方法（队列数据结构的访问规则是 FIFO（First-In-First-Out，先进先出）。队列在列表的末端添加项，从列表的前端移除项。 由于 push() 是向数组末端添加项的方法，因此要模拟队列只需一个从数组前端取得项的方法。实现这一操作的数组方法就是 shift() ，它能够移除数组中的第一个项并返回该项，同时将数组长度减1。） 例：
  var colors = new Array(); //创建一个数组
  colors.push('red', 'green'); //推入两项
  console.log(colors); //2
  count = colors.push('black'); //推入另一项
  console.log(colors); //3
  var item = colors.shift(); // 前端弹出第一项
  console.log(item); //'red'
  console.log(colors);
• 方法四：unshift() 方法。它能在数组前端添加任意个项并返回新数组的长度。例： var colors = new Array(); //创建一个数组
  var count = colors.unshift('red', 'green'); // 推入两项
  console.log(colors);
  count = colors.unshift('black'); // 推入另一项
  console.log(colors);
  var item = colors.pop(); // 取得最后一项
  console.log(item); //'green'
  console.log(colors);
• 方法五：反转数组项 例：
  var values = [1, 2, 3, 4, 5];
  values.reverse();
  console.log(values); //5,4,3,2,1
• 方法六：链接方法 例：
  var colors1 = ['red', 'green', 'blue'];
  var colors2 = ['yellow', 'black'];
  console.log(colors1.concat(colors2));
  console.log(colors2.concat(colors1));
  console.log(colors2.concat('brown'));
  console.log(color2)//注意：concat返回一个新数组，原数组没改变
• 方法七：分片方法 功能：
          删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。 例如， splice(0,2) 会删除数组中的前两项。
          插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、0（要删除的项数） 和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。例如， splice(2,0,'red','green') 会从当前数组的位置 2 开始插入字符串 'red' 和 'green' 。
          替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起 始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如， splice (2,1,'red','green') 会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串 'red' 和 'green' 。例： var colors = ['red', 'green', 'blue'];
  var removed = colors.splice(0,1); // 删除第一项
  console.log(colors); // green,blue
  console.log(removed); // red，返回的数组中只包含一项
  removed = colors.splice(1, 0, 'yellow', 'orange'); // 从位置 1 开始插入两项
  console.log(colors); // green,yellow,orange,blue
  console.log(removed); // 返回的是一个空数组
  removed = colors.splice(1, 1, 'red', 'purple'); // 插入两项，删除一项
  console.log(colors); // green,red,purple,orange,blue
  console.log(removed); // yellow，返回的数组中只包含一项

闭包

• 闭包是Closure，这是静态语言所不具有的一个新特性。但是闭包也不是什么复杂到不可理解的东西，简而言之，闭包就是： 函数的局部变量集合，只是这些局部变量在函数返回后会继续存在。 闭包就是就是函数的“堆栈”在函数返回后并不释放，我们也可以理解为这些函数堆栈并不在栈上分配而是在堆上分配 当在一个函数内定义另外一个函数就会产生闭包。如下代码： function greeting(name) {
  var text = 'Hello ' + name; // local variable // 每次调用时，产生闭包，并返回内部函数对象给调用者
  return function() { console.log(text); }//注意该函数无名称，称为匿名函数
  }
  var sayHello = greeting('Closure');//调用greeting()返回了什么？
  sayHello(); // 注意此处的使用方法。通过闭包访问到了局部变量text