第二周知识点要点总结JavaScript

my kernel of JavaScript

小点

var

弱类型语言，这是全局变量的定义形式，可以赋值为各种传统数据类型，对象，甚至函数（函数部分会具体展示）

var tag="poilzero";
var datas=new Array();

let

这是局部变量的定义形式，在同一作用域可访问，其他同上

if(true){
	let under="myself";
}

//以下代码会报错，显示无定义under
//因为在if语句结束under就被释放了
console.log(under);

typeof

var gpa = 4.3
var name = 'poilzero'
console.log(typeof gpa)//输出 number
console.log(typeof name)//输出 string
//typeof gpa的结果是string是个字符串
//因此再一次typeof的结果是一个字符串
console.log(typeof typeof gpa)//输出string

数组

列表

数组在JavaScript中是以对象+特殊定义（比如[index]调用成员）形成的，因此也可以通过对象的方式创建

//三者等价
var a = [115,515,123];
var b = new Array(115,515,123);
var c = [];c=[115,515,123]//后一句会将[]初始化为列表

console.log(a);
for(let i in a){
    console.log(a[i]);
}
/*
	会打印如下：
	[115, 515, 123]
        0: 115
        1: 515
        2: 123
        length: 3
        __proto__: Array(0)
     115
     515
     123
*/

列表的一些常见函数（对成员属性部分无效，仅对列表部分有效）：

• 对数组头操作
  • .shift() 删除最前一个元素
  • .unshift(元素) 在最前插入一个元素
• 对数组尾操作
  • .pop() 删除最后一个元素
  • .push(元素) 在最后插入一个元素
• 反转
  • .reverse() 反转元素先后顺序

类字典

类字典的实现功能其实是因为，数组本质上是一个对象，而JavaScript中对象的属性是可以作为键值对来定义的。

var scores = [];
scores["poilzero"] = 98;//会将[]初始化为字典
scores["anonym"] = 100;
scores["jack"] = 60;
scores['gpa'] = [];
scores['gpa']["poilzero"] = 4.5;
scores['gpa']["anonym"] = 5.0;
scores['gpa']["jack"] = 1.0;

console.log(scores);
for(let i in scores){
    console.log(scores[i]);
}
/*
	会打印如下：
	[poilzero: 98, anonym: 100, jack: 60]
        anonym: 100
        gpa: [poilzero: 4.5, anonym: 5, jack: 1]
        jack: 60
        poilzero: 98
        length: 0
        __proto__: Array(0)
	98
	100
	60
*/

对象（泛字典）

泛字典

可以兼容字典的写法

// 把对象当字典写
var marks = {
    "poilzero": 98,
	anonym: 100,
	"jack": 60,
    gpa:{//嵌套
        "poilzero": 4.5,
        anonym: 5.0,
        "jack": 1.0
	}
};

console.log(marks);
for(let i in marks){
    console.log(marks[i]);
}
/*
	会打印如下：
	{poilzero: 98, anonym: 100, jack: 60}
        anonym: 100
        gpa: {poilzero: 4.5, anonym: 5, jack: 1}
        jack: 60
        poilzero: 98
        __proto__: Object
	98
	100
	60
*/

独有的成员方法

其实严格来说不是独有的，因为列表或字典都可以把某一位的值赋值给一个函数，以此来调用对应函数，这是弱类型语言的特性。

但对象的成员方法严格来说是通用的定义方式。

//Object是空类名 Array是数组类名
//new的过程就是将类实例化成对象的过程
var boyfriend=new Object();
boyfriend = {
    //在外面 var name = "anonym";
    name: "anonym",
    'age': 18,
    //嵌套和自己同类型
    contact:{
		qq: "100000",
         phone: "12345678910",
    	sayhello: function(){
        	console.log("hello")
    	}
	},
    sayhello: function(){
        console.log("hello")
    }
}
//初始化后添加成员
boyfriend.lengthOfHair = "9cm";
console.log(boyfriend.lengthOfHair);//输出9cm
boyfriend.sayhello();//输出hello

函数

定义

function sumUp(a,b){
    return a+b;
}
var sum = sumUp(2,5);
console.log(sum);//输出7

立即执行函数

//立即执行函数
;(function sumUp(a,b){
    console.log(a+b)
})(1,2)
//控制台输出3

n参数传入

函数()无需写内容，n个传入的参数会依次自动保存到局部数组变量argument中

function sumAll(){
    let sum=0;
    for(let i in argument){
        sum+=argument[i];
    }
    return sum;
}
var sum = sumAll(5,6,1,2,0,3);
console.log(sum);//输出16

可变函数

基于原理：函数也可以作为变量被赋值

function makeAdder(basis){
    return function add(value){
        return basis+value;
    }
}

var addFive=makeAdder(5);

var ans=addFive(6);
console.log(ans);//输出11