javascript

严格检查模式

加入‘use strict’，必须写在第一行
此时i标红，需添加var 或者let
建议使用let（局部变量） 更清爽

数据类型

字符串类型

1. 转义字符 ： \
\ ’ ==>输出单引号

2. 多行字符串：``

3. 模板字符串：

4. 字符串长度：
str.length
5. 字符串：

5. 字符串的一些属性：
substring使用过多，须记住

数组类型

Array可以包含任意数组类型

var arr  =  [1,2,3,4,5,6]

1.长度
通过length改变数组长度

arr.length

注意：假如给arr.length赋值，数组大小就会发生变化，赋值过小，多余数组内容会丢失
多余的会用空值表示

2.indexOf 通过元素获得下标索引
3.slice（） 截取Array的一部分，返回一个新数组
类似于String中的substring
4. push pop

push（）：压入到尾部
pop（）：弹出尾部的一个元素

5. unshift（），shift（）头部
   与第6条一致

unshift：压入到头部
shift：弹出头部的一个元素

6.排序 sort()
7.元素反转 reverse()
8.concat()

concat() 并没有修改数组，只是会返回一个新的数组

9.连接符 join
打印拼接数组，使用特定的字符串连接

10.多维数组

数组：存储数据（如何存，如何取）

对象

若干个键值对

var 对象名 = {
	属性名： 属性值，
	属性名： 属性值，
	属性名： 属性值
}

var person = {
	name: "pink",
	age:"5",
	email:"522582@qq.com",
	score: 0
}

js中的对象，{…}表示一个对象，键值对描述属性xxxx： xxxx，
JavaScript中的所有键都是字符串，值是任意对象！

1.对象赋值

person.age
"5"
person.age = 8
8
person
{name: "pink", age: 8, email: "522582@qq.com", score: 0}

2.使用一个不存在的对象属性，不会报错！undefined

person.hhh
undefined

3.动态的删减属性，通过delete删除对象属性

4.动态的添加，直接给新的属性添加值

5.判断属性值是否在这个对象中 xxx in xxx

JavaScript中的所有键都是字符串，值是任意对象！
用引号包裹键

6.判断一个属性是否是这个对象自身拥有的 hasOwnProperty（）

7.forEach循环

map和set

ES6中新特性
map

set
无需不重复的集合

var set = new Set([1,2,3,666,666,666]);
undefined
set
Set(4) {1, 2, 3, 666}
set.add(5)     //添加
Set(5) {1, 2, 3, 666, 5}
set.delete(2)    //删除
true
set
Set(4) {1, 3, 666, 5}
set.has(5)   //是否包含某个元素
true
set.has(2)
false

iterator

遍历数组

//通过for of（具体值） /for in （输出下标）
var arr = [3,4,5]
undefined
for(var x of arr){
    console.log(x);
}

遍历map

    var map = new Map([["tom",100],["jack",199],["hh",80]]);
    for(let x of map){
        console.log(x);
    }

遍历set

    var set = new Set([1,2,3,4,5]);
    for(let x of set){
        console.log(x);
    }

函数

定义函数

定义方式一

function  abs(x){
    if(x>=0){
        return x;
    }
    else{
        return -x;
    }
}

一旦执行到return 代表函数结束

定义方式二

var abs = function(x){
    if(x>=0){
        return x;
    }
    else{
        return -x;
    }
}

function(x){…}这是一个匿名函数，但可以把结果赋值给abs，通过abs可以调用函数

调用函数

abs(10) //10

参数问题：JavaScript可以穿任意一个参数，也可以不传递参数
假如不存在参数，如何规避？

var abs = function(x){
//手动抛出异常判断如果类型不是数字则抛出异常
    if(typeof x!=='number'){
        throw 'Not a Number';
    }
    if(x>=0){
        return x;
    }
    else{
        return -x;
    }
}

arguments

arguments是一个js免费赠送的关键字，代表传递进来的所有参数，是一个数组

var abs = function(x){
    console.log('x==>' + x);
for(var i = 0;i <arguments.length;i++){
console.log(arguments[i]);
}
    if(x>=0){
        return x;
    }
    else{
        return -x;
    }
}

问题：arguments包含所有的参数，我们有时候想使用多余的参数来进行附加操作。需要排除已有的参数~
解决：

rest
ES6引入的新特性，获取除了已经定义的参数之外的所有参数~

var abs = function(a,b,...rest){
    console.log('a==>' + a);
    console.log('b==>' + b);
    console.log(rest);
}

注意事项：rest参数只能写在最后面，必须用…rest来标识

变量的作用域

在JavaScript中，var定义变量实际是有作用域的。
假设在函数体中声明，则在函数体外不可以使用~

内部函数可以访问外部函数的成员，反之不行

function qj() {
    var x = 1;

    function qj2(){
        var y = x + 1;
    }
    var z = y + 1 ;  // Uncaught ReferenceError: z is not defined
}

假设，内部函数变量和外部函数的变量，重名

function qj() {
    var x = 1;
    function qj2(){
        var y=x + 1;
        console.log(y);
    }
    console.log(x);
    qj2()
}
qj();

假设在JavaScript中 函数查找变量从自身函数开始~ 由“内”向“外”查找，假如外部存在这个同名的函数变量，则内部函数会屏蔽外部函数的变量

提升变量的作用域

function qj() {
    var x = 'x';
    console.log('x' + y);
    var y = 'y';
    }
qj();

相当于

function qj() {
    var y;
    var x = 'x';
    console.log('x' + y);
     y = 'y';
    }
qj();

即 说明：js执行引擎，自动提升了y的声明，但不会提升变量y的赋值；
这个是在JavaScript建立之初就存在的特性。
养成规范，把所有变量定义在最前面

全局函数

    var x = 1;
function qj() {
    console.log('x = ' + x);
    }
qj();
console.log(x);

全局对象 window

    var x = 1;
alert(x);
alert(window.x);//默认所有的全局变量都会自动绑定在window对象下
window.alert(x);

alert()这个函数本身也是一个window变量~
由于我们所有的全局变量都会绑定到我们的window上，如果不同的js文件使用了相同的变量冲突，如何能够减少冲突？

var kuangApp = {};
kuangApp.name = 'kuangshen';
kuangApp.add = function(a,b) {
return a + b;
}

把自己的代码全部放入自己定义的唯一空间名字中，降低全局命名冲突的问题~

局部作用域 let

ES6 let 关键字，解决局部作用域冲突问题~

function aaa(){
    for(let i = 0;i < 100; i++){
        console.log(i)
    }
    console.log(i+1)
}

常量 const

const PI = '3.14';
console.log(PI);
PI ='123';
console.log(PI);

方法

定义方法
方法就是把函数放在对象的里面，对象里有属性和方法

    var zhangSan={
        name:'zhangsan',
        birth: 2000,

        //方法
        age: function(){
            var now = new Date().getFullYear();
            return now-this.birth;
        }
    }
//属性
zhangSan.name
//方法  一定要带（）
zhangSan.age()

this.代表什么？

    function getAge() {
        var now = new Date().getFullYear();
            return now-this.birth;
    }
    var zhangSan={
        name:'zhangsan',
        birth: 2000,
        age: getAge     //此时不加括号

    }
    zhangSan.age() //成功
    //getAge() NaN     window中没有

this是无法指向的，是默认指向调用它的那个对象；

apply

在js中可以控制this指向！

getAge。apply(zhangSan,[]);//this.指向了zhangSan，参数为空

标准对象