ES5和ES6总结--未完待续

ES5

1、总结

严格模式，限制一些用法 use strict

为什么使用严格模式：

• 消除代码运行的不安全之处，保证代码的安全运营；
• 消除JavaScript语法法一些不合理，不严谨之处，减少一些怪异行为；
• 提高编译器效率，增加运行速度；
• 为未来新版本的JavaScript做好铺垫

"use strict";
   x = 3.14;   //报错 不允许使用未声明的变量或对象
  "use strict"; var x = 3.14; delete x;   //报错 不允许删除变量或对象。
  "use strict"; function x(p1, p2) {}; 
    delete x;  //报错 不允许删除函数。
  "use strict"; function x(p1, p1) {};   // 报错 不允许变量重名
  "use strict"; var x = 010; // 报错 不允许使用八进制
//   "use strict"; var x = \010; // 报错 不允许使用转义字符
  "use strict"; var obj = {}; Object.defineProperty(obj, "x", {value:0, writable:false});
 obj.x = 3.14; // 报错 不允许对只读属性赋值
  "use strict"; var obj = {get x() {return 0} };
 obj.x = 3.14;            // 报错 不允许对一个使用getter方法读取的属性进行赋值
  "use strict"; delete Object.prototype; // 报错 不允许删除一个不允许删除的属性
  "use strict"; var eval = 3.14;         // 报错 变量名不能使用 "eval" 字符串:
  "use strict"; var arguments = 3.14;         // 报错 变量名不能使用 "arguments"  字符串:
  "use strict"; with (Math){x = cos(2)}; // 报错 不允许使用with
  "use strict"; eval ("var x = 2");
 alert (x);               // 报错 由于一些安全原因，在作用域 eval() 创建的变量不能被调用：
 
 function f(){  return !this;// 禁止this关键字指向全局对象
 } 
 // 返回false，因为"this"指向全局对象，"!this"就是false
 
 function f(){ 
  "use strict";  return !this;
 } 
 // 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。

ES5新增数组的使用方法

forEach

forEach(callback);循环，遍历数组 callback为回调函数

var arr = [2,3,4,5,6,7,8];
        arr.forEach(function(value,index,arr){
            console.log(value,index,arr);
            //函数中的三个参数分别代表，该项的值，该项下标，数组本身
        })
/*输出的结果
2 0 [2,3,4,5,6,7,8];
3 1 [2,3,4,5,6,7,8];
4 2 [2,3,4,5,6,7,8];
5 3 [2,3,4,5,6,7,8];
6 4 [2,3,4,5,6,7,8];
7 5 [2,3,4,5,6,7,8];
8 6 [2,3,4,5,6,7,8];
*/

map

map(callback)的作用为映射，也就是把原数组映射到一个新的数组内

var arr = [1,2,3,4];
    var arrayOfSquares = arr.map(function( item ){
        return item*item;
    })
    console.log( arrayOfSquares )//[1,4,9,16]

indexOf

indexOf(searchElement,start)用法：用于返回某个数组或者字符串中规定字符或者字符串的位置；

var arr = ["a","b","c","d","e"];
        arr.indexOf("a");        //0
        //返回当前查询字符所在的位置的下标，如果查询不到，返回-1，start表示从第几位开始查询。

lastIndexOf

用法和indexOf的用法一样，从数组的末端开始找

arr.lastIndexOf(searchElement,Formindex);
从数组的末端开始找，Formindex默认为arr.length-1,依次递减

filter

过滤。刷选，filter过滤到数组不需要的元素，返回过滤后的的新数组，用法同map方法相似

filter的回调函数返回boolean为true的值

var arr = [2,3,4,5,6];
            var newArr = arr.filter(function(value,index,arr){
                return value > 3;
            })
            console.log( newArr );  //得到一个经过筛选的数组

some

只需满足一个条件

some()方法用于检测数组中的元素是否满足指定条件（函数提供条件）。
some()方法会依次执行数组的每个元素：
如果有个元素满足条件，则表达式返回true，剩余的元素不会再执行检测。如果没有满足条件的元素，则返回false。

array.some(function(currentValue,index,arr),thisValue)；
/*
  第1个是遍历的数组内容；第2个是对应的数组索引，第3个是数组本身 //thisValue可选。
  对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"
*/

every

需要所有元素满足条件

every()方法用于检测数组中的元素是否满足条件（函数提供条件）
every()方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到一个元素不满足，则整个表达式返回false，且剩余的元素不会再执行检测。
• 如果所有元素都满足条件，则返回true。

array.every(function(currentValue,index,arr), thisValue);
  //第1个是遍历的数组内容；第2个是对应的数组索引，第3个是数组本身 
  //thisValue可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
  //如果省略了 thisValue ，"this" 的值为 "undefined"

ES6

ES6新增let的变量声明，区别

• 变量名不能重复声明

var a = 10;
var a = 20
console.log( a ) //20

let a = 10;
let a = 20;
console.log( a )//Identifier 'a' has already been declared

• 变量声明不能提升

console.log( a )//10
var a = 10;
console.log( a ) //10

console.log( a )//not a defined
let a = 10;
console.log( a )  //10

-暂时性死区

function fn(){
        let a = 10 ;
        console.log( a )
  }
  fn()//10

function fn(){
        console.log( a );
        let a = 10 ;
  }
  fn()// a is not defined

• 块级作用域

if( true ){
    let a = 10;
    console.log( a )//10
}

console.log( a ) //not a defined

const 声明常量使用

onst声明的变量并不是变量的值不能改动，而是变量指向的内存地址不得改动，简单的数据类型（数字，字符串，布尔），值就保存在变量指向的那个内存地址，因此等同于常量，但是对于复合型的数据（对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于指向的数据结构就不能控制到了

const a  = 500;
   a = 100;
console.log( a )//Assignment to constant variable.

const obj = {
        name:'ymd',
        age: 18,
    }
    obj.name = 'gy';
    console.log( obj.name )//gy

字符串的Unicode表示\u+四位十六进制数
console.log( '\u0061' ) //输出a

字符串新增方法

• codePointAt()将字符串转成十进制的，然后可以通过toString()的方法转换成十六进制数，这里就不再进行展示

 var a = '杨'
 console.log(a.codePointAt( ))//26472

• String.fromCodePoint() 和String.fromCharCode()用法一样，但是有些区别的

先说说 String.fromCharCode()方法；这个方法无法正确识别 32位的 UTF-16字符（也就是上面>提到的四个字节的字符 Unicode编码 大于 0xFFFF）;
console.log(String.fromCharCode(0x20BB9 )) // [图片上传失败...(image-c1e00e-1539691199587)] 出现了一个奇怪的字符
原因是什么那？ 因为fromCharCode不识别四个字节的字符， 他会将第一位省略掉 ， 也就是将 0x20BB9 去掉开头 变成了0x0BB9;所以出现的结果不正确;但是ES6中的String.fromCodePoint()可以正确识别这样的编码;console.log(String.fromCodePoint(0x20BB9)) // 显示正确;

• repeat()重复功能

var str = 'ymd'
console.log( str.repeat( 5 ))//ymdymdymdymdymd

• startWith()、endWith()、includes()

var str = 'Hello World '

console.log( str.includes('ll'))//true    以参数开头
console.log( str.startsWith('Hello'))//true    以参数结尾
console.log( str.endsWith('W'))//false      包括参数;

• for of 一种新的遍历，没有具体的索引值时使用

var s = "abc";
for(let  b of s){
     console.log(b) // "a"  "b"  "c"
 }

ES6中存在一种新的字符串， 这种字符串是 以` ` (波浪线上的那个字符 > 反引号)括起来表示的；用 ${ } 扩住变量让拼接变得非常容易;

var obj = {
        name:'ymd',
        age: 19,
    }
    var str = `我的名字${obj.name}
                  是今天${obj.age}岁`;
    console.log( str )//

function fn() {
            return "Hello World"
        }
     console.log( `foo ${fn()} bar`  )  

https://www.imooc.com/article/251847