前端学习（大一下）第十二周

js

数组

var arr = [1,2,3,45,5,"abc",undefined];

console.log(arr[0]);                        //打印第0位
console.log(arr.length);                    //打印数组的长度

结构体

var arr = {
    属性名1 : "字符串"，                    //注意用“，”分隔
    属性名2 : 数字,
    属性名3 : underfined,
    属性名4 : false,
}

console.log(arr.属性名);

编程形式的区别

1. 面向过程：机械的想法，逻辑化思维，按步骤进行(c语言)

2. 面向对象（java c++）

js即面向过程也面向对象

注：也可以用脚本语言与非脚本语言进行分类

typeof()

用于区别不同的数据类型
用console.log(typeof(变量名));则直接打印变量的数据类型

注：typeof函数中var a = {}; var a= []; var = null;的返回值是object
也可以用typeof 变量名表示typeof函数

类型转换

显式类型转换

1. Number(变量)； 转化为数字变量
   eg：var num = Number(‘123’); //把123转换为数字123，并返回num
   var demo = “123”; //另一种形式
   var num = Number(demo);

注：布尔值true转为数字为1，false为0；null为0，undefined不能转化，变为为NaN，字母也不能转化，变为NaN

2. parseInt(变量);

   1. parseInt(变量);转化为数字的整形变量（去掉小数点后的数字）
      注：可以转换字符串，但布尔值true和false以及其他则转化为NaN
   2. parseInt(变量，数字);以数字为基底转换为10进制
      注：：“数字”被称为radix，取值范围为2-36；且其运行方式为从数字位开始取值，取到非数字位（小数点，字母等）截止
      eg：var demo = “10”;
      var num = parseInt(demo,16);
      console.log(typeof(num) + " : " + num) //输出值为Number:16

3. parseFloat(变量); 转化数字为浮点数
   注：当其出现非数字位时，只取非数字位前的数字（小数点除外）

4. String(变量); 转化为字符串（任意值）

5. Boolean(变量); 转化为布尔值（true和false）
   注：undefined、null、NaN、""（空串）、0、false 转化的布尔值为false，其余变量均为true

6. toString();

   1. 变量名.toString();
      eg：var demo = “123”;
      var num = demo.toString();
      注：undefined与null不能用该函数转化，但可以用String函数解决
   2. 变量名.toString(数字);以10为基底转化为数字目标进制
      eg：var demo = “10”;
      var num = demo.toString(8);
      console.log(typeof(num) + " : " + num) //输出值为Number:16

隐式类型转换

1. isNaN(变量); //判断变量是不是NaN，返回布尔值
   注：把变量用Number();函数进行转换，将转化结果与NaN进行比较

2. “++”，“–”，“+”，“-” （最后两个是一元正负运算符）
   注：

   1. 把变量用Number();函数进行转换再进行计算；
   2. “+”两侧有一个是字符串，则会把非字符串部分链接到字符串部分上

3. “*”，“/”，“%”
   注：把两侧用Number();进行转换，并对转换结果进行计算

4. “&&”，“||”
   注：把两侧变量用Boolean();进行转换,并对转换结果进行运算，但返回的值却是变量的值

5. “>=”，“<=”
   注：有数字则用Number();函数转化后进行比较 ；字符串则是用ASCII进行比较，且可以连续比较
   eg：2 > 1 > 3(返回值为false)；3 > 2 > 1（返回值为true）

6. “”，“！=”
   注：undefined == null 他们两个不等于其他值
   “=”，“!==”是不发生类型转换的绝对不等于

注：NaN != NaN ; NaN !== NaN

未定义的变量如果出现在函数中，只有typeof();函数有返回值不报错，且这种情况下返回值为undefined

变量.toFixed(数字);
其用法为，将变量的小数点后“数字”位作为标准，余下部分四舍五入

var num = 123.45678;                        
var demo = num.toFixed(3);                               
var demo == 123.457;

函数 （高内聚 弱偶合）

函数的定义

函数的声明

function 函数名(){
    函数内容;
}
函数名();                           //调用函数

函数表达式

1. 命名函数表达式

var 变量名 = function 函数名() {
    函数内容;
}
变量名();                           //调用函数，当前情况下函数名失去作用

2. 匿名函数表达式 ---- 函数表达式

var 变量名 = function () {
    函数内容;
}
变量名();

函数的括号里可以直接输入变量名（多个变量名间用“,”隔开），在调用函数时直接在括号里对应变量的位置上输入在调用该函数时，该该变量需要的值
eg：

function sum(a,b){                  //a、b为形参
    document .write(a + b);
}
sum(1,2);                           //1、2为实参；打印3

函数的组成

函数名称

函数名也是一个变量，只不过不需要var来定义，和变量命名方式相同，执行函数，执行的是函数内容，打印函数名则出现“function 函数名(){函数内容;}”
命名时用小驼峰原则（第一个单词首字母小写，后面的单词首字母大写）

参数

1. 实参会在函数中形成一个名为arguments的数列，数列的内容是实参的值，就算形参的数量小于实参，也会把所有实参都储存在arguments里

2. 系统内也可以对形参进行赋值，arguments数列默认出现在第一行，也可在后面对其再进行赋值；在函数中最后对形参值定义的表达式决定了形参的值
   注：如果实参数量小于形参，则arguments在缺少实参的位置将失去意义，不再与形参对应

eg:

function sum(a,b){ 
    document .write(a);             //输出值为1
    a = 2;
    document .write(a);             //输出值为2
    arguments[0] = 3;
    document .write(a);             //输出值为3
}
sum(1,2);



function sum(a,b){ 
    document .write(b);             //输出值为undefined
    b = 2;
    document .write(b);             //输出值为2
    document .write(arguments[1]);  //输出值为undefined
    arguments[1] = 3;
    document .write(b);             //输出值为3
}
sum(1);

返回值

return; 用于结束函数，如果不写，默认出现在函数的最后

return 后接数字或变量，会把该值赋予等于函数的变量
eg：

function sum(a,b){ 
    document .write(a);
    document .write(b);
    return (a + b) ;
}
var num = sum(1,2);
sum(1,2);                           //打印1和2
document .write(num);               //打印3

初始作用域

作用域定义：变量（变量作用域又称上下文）和函数生效（能被访问）的区域

全局、局部变量

函数里面可以调用函数外面的变量，函数外面不能调用里面的变量
（注：两个函数相互嵌套，里面的函数也可以调用外面函数，以及外面函数外面的变量；两个平行关系的函数不能相互调用变量）

作用于的访问顺序

递归，预编译

递归

通过函数中调用函数本身，并设置结束递归的条件，从而使得其从最后一次自我调用往上逐层计算

eg（计算n的阶乘）：

var n = parseInt(window.prompt('input'));
function mul(n){
    if(n == 1 || n == 0){
        return 1;
    }
    return n * mul(n-1);
}

代码简单但运算复杂度高

预编译

通篇扫描不执行用于确定是否有代码书写错误后进行预编译

eg：

var a = 123;
console.log(a);                     //输出值为undefined，并不报错

console.log(a);                     //报错

1. 函数声明整体提升

2. 变量 声明提升

3. imply global 暗示全局变量：即任何变量，如果变量未经声明就赋值，此变量就为全局对象所有
   eg：

a = 123;
var a = b = 123;

2. 一切声明的全局变量，全是window的属性（window就是全局）
   eg：

var a = 123;                        //定义本行时，等同于定义下一行
window.a = 123;
window{                             //与上一行等价
    a : 123;
}

预编译四步：（

function fn(a){
    var b = function () {};
    var c = 1;
    function d() {};
}

fn(1);
```）

1. 创建AO对象（Activation Object即执行期上下文）

AO{

}

2. 找形参变量和变量声明，将变量和形参名作为AO属性名，值为undefined

AO{
a : undefined,
b : undefined,
c : undefined,
}

3. 将实参值和形参统一

AO{
a : 1,
b : undefined,
c : undefined,
}

4. 在函数体里找函数声明，值赋予函数体

AO{
a : 1,
b : undefined,
c : undefined,
d : function d() {},
}

后面的步骤会对前面的步骤进行覆盖