标签：调用   前端学习   结束   ret   hit   对象   注意   length   全局   

前端学习——JavaScript运算

在这一节之前，应该做到的是对上一节的数据类型的相关方法都敲一遍，加深印象

这部分的知识的特点就是碎而且杂，所以一定要多练~练习起来，才能够进步飞快

那这一部分我们将对JavaScript中的运算，流程控制，函数等进行一个简单的理解

运算符

算数运算符

+ - * / % ++ --

比较运算符

> >= < <= != == === !==

注意：

1 == “1”  // true
1 === "1"  // false

1. 1 == “1” // true 因为在比较的时候，浏览器会把数值1转换成字符串1去比较
2. 1 === "1" // false 因为1和“1”比较的不仅仅是值的相等，还比较它们的数据类型

逻辑运算符

&& || !

如果要测试多个条件，而不需要编写嵌套if … else语句，逻辑运算符可以帮助您。当在条件下使用时，前两个执行以下操作：

• && — 逻辑与; 使得并列两个或者更多的表达式成为可能，只有当这些表达式每一个都返回true时，整个表达式才会返回true
• || — 逻辑或; 当两个或者更多表达式当中的任何一个返回 true 则整个表达式将会返回 true
• ! — 逻辑非; 对一个布尔值取反, 非true返回false,非false返回true.

赋值运算符

= += -= *= /=

流程控制

if-else

var a = 10;
if (a > 5){
  console.log("yes");
}else {
  console.log("no");
}

1. 关键字 if，并且后面跟随括号
2. 要测试的条件，放到括号里（通常是“这个值大于另一个值吗”或者“这个值存在吗”）。这个条件会利用比较运算符我们会在最后的模块中讨论）进行比较，并且返回true或者false
3. 一组花括号，在里面我们有一些代码——可以是任何我们喜欢的代码，并且只会在条件语句返回true的时候运行
4. 关键字else
5. 另一组花括号，在里面我们有一些代码——可以是任何我们喜欢的代码，并且当条件语句返回值不是true的话，它才会运行

这段代码真的非常易懂——它说“如果（if）条件（condition）返回true，运行代码A，否则（else）运行代码B”

注意：你不一定需要else和第二个花括号

if-else if-else

var a = 10;
if (a > 5){
  console.log("a > 5");
}else if (a < 5) {
  console.log("a < 5");
}else {
  console.log("a = 5");
}

switch

var day = new Date().getDay();
switch (day) {
  case 0:
  console.log("Sunday");
  break;
  case 1:
  console.log("Monday");
  break;
default:
  console.log("...")
}

switch中的case子句通常都会加break语句，否则程序会继续执行后续case中的语句。

1. 关键字 switch, 后跟一组括号
2. 括号内的表达式或值
3. 关键字 case, 后跟一个选项的表达式/值，后面跟一个冒号
4. 如果选择与表达式匹配，则运行一些代码
5. 一个 break 语句, 分号结尾. 如果先前的选择与表达式/值匹配，则浏览器在此停止执行代码块，并执行switch语句之后的代码
6. 你可以添加任意的 case 选项
7. 关键字 default, 后面跟随和 case 完全相同的代码模式 (选项 3–5), except that default之后不需要再有选项, 并且您不需要 break 语句, 因为之后没有任何运行代码. 如果之前没有选项匹配，则运行default选项

for

for循环，通过初始化条件、结束条件和递增条件来循环执行语句块

for (var i=0;i<10;i++) {
  console.log(i);
}

for循环最常用的地方是利用索引来遍历数组

而且for循环的3个条件都是可以省略的，如果没有退出循环的判断条件

就必须使用break语句退出循环，否则就是死循环：

var x = 0;
for (;;) { // 将无限循环下去
    if (x > 100) {
        break; // 通过if判断来退出循环
    }
    x ++;
}

continue语句中断循环中的迭代,如果出现了指定的条件,然后继续循环中的下一个迭代

var x;
for(var i = 0; i <= 10; i++){
    if(i == 3) continue;
     x = x + "这个数字是" + i 
}

while

var i = 0;
while (i < 10) {
  console.log(i);
  i++;
}

三元运算

var a = 1;
var b = 2;
var c = a > b ? a : b

函数

avaScript中的函数和Python中的非常类似，只是定义方式有点区别

// 普通函数定义
function f1() {
  console.log("Hello world!");
}

// 带参数的函数
function f2(a, b) {
  console.log(arguments);  // 内置的arguments对象
  console.log(arguments.length);
  console.log(a, b);
}

// 带返回值的函数
function sum(a, b){
  return a + b;
}
sum(1, 2);  // 调用函数

// 匿名函数方式
var sum = function(a, b){
  return a + b;
}
sum(1, 2);

// 立即执行函数
(function(a, b){
  return a + b;
})(1, 2);

ES6中允许使用“箭头”（=>）定义函数。

var f = v => v;
// 等同于
var f = function(v){
  return v;
}

如果箭头函数不需要参数或需要多个参数，就是用圆括号代表参数部分：

var f = () => 5;
// 等同于
var f = function(){return 5};

var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2){
  return num1 + num2;
}

函数中的arguments参数

function add(a,b){
  console.log(a+b);
  console.log(arguments.length)
}

add(1,2)

输出：

3
2

注意：

函数只能返回一个值，如果要返回多个值，只能将其放在数组或对象中返回

函数的全局变量和局部变量

局部变量：

在JavaScript函数内部声明的变量（使用 var）是局部变量，所以只能在函数内部访问它（该变量的作用域是函数内部）。只要函数运行完毕，本地变量就会被删除

全局变量：

在函数外声明的变量是全局变量，网页上的所有脚本和函数都能访问它

变量生存周期：

JavaScript变量的生命期从它们被声明的时间开始

局部变量会在函数运行以后被删除

全局变量会在页面关闭后被删除

作用域

首先在函数内部查找变量，找不到则到外层函数查找，逐步找到最外层

var city = "BeiJing";
function f() {
  var city = "ShangHai";
  function inner(){
    var city = "ShenZhen";
    console.log(city);
  }
  inner();
}

f();  //输出结果是？

var city = "BeiJing";
function Bar() {
  console.log(city);
}
function f() {
  var city = "ShangHai";
  return Bar;
}
var ret = f();
ret();  // 打印结果是？

var city = "BeiJing";
function f(){
    var city = "ShangHai";
    function inner(){
        console.log(city);
    }
    return inner;
}
var ret = f();
ret();

JavaScript中在调用函数的那一瞬间，会先进行词法分析

词法分析的过程：

当函数调用的前一瞬间，会先形成一个激活对象：Avtive Object（AO），并会分析以下3个方面：

1:函数参数，如果有，则将此参数赋值给AO，且值为undefined

? 如果没有，则不做任何操作

2:函数局部变量，如果AO上有同名的值，则不做任何操作

? 如果没有，则将此变量赋值给AO，并且值为undefined

3:函数声明，如果AO上有，则会将AO上的对象覆盖，如果没有，则不做任何操作

函数内部无论是使用参数还是使用局部变量都到AO上找

var age = 18;
function foo(){
  console.log(age);
  var age = 22;
  console.log(age);
}
foo();  // 问：执行foo()之后的结果是？

var age = 18;
function foo(){
  console.log(age);
  var age = 22;
  console.log(age);
  function age(){
    console.log("呵呵");
  }
  console.log(age);
}
foo();  // 执行后的结果是？

词法分析过程：
1、分析参数，有一个参数，形成一个 AO.age=undefine;
2、分析变量声明，有一个 var age, 发现 AO 上面已经有一个 AO.age，因此不做任何处理
3、分析函数声明，有一个 function age(){...} 声明， 则把原有的 age 覆盖成 AO.age=function(){...};

最终，AO上的属性只有一个age，并且值为一个函数声明

执行过程：
注意：执行过程中所有的值都是从AO对象上去寻找

1、执行第一个 console.log(age) 时，此时的 AO.age 是一个函数，所以第一个输出的一个函数
2、这句 var age=22; 是对 AO.age 的属性赋值， 此时AO.age=22 ，所以在第二个输出的是 2
3、同理第三个输出的还是22, 因为中间再没有改变age值的语句了

前端学习（十六）：JavaScript运算

标签：调用   前端学习   结束   ret   hit   对象   注意   length   全局   

原文地址：https://www.cnblogs.com/jevious/p/11548552.html