严格模式

“use strict”
【注】在你需要进行严格模式的作用域，去声明”use strict”，声明以后，这个作用域下，所有的内容都是严格模式。

  1.         使用严格模式以后，代码的特点：
  2.             1、全局变量声明时，必须加var
  3.             2、this无法指向全局对象；
  4.             3、函数内重名属性
  5.             4、arguments对象不允许被动态改变，永远只存储实参
  6.             5、新增保留字：implements, interface, let, package, private, protected, public, static, yield。
  8.         严格模式的目的：
  9.         1. 消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;
  10.         2. 消除代码运行的一些不安全之处，保证代码运行的安全；
  11.         3. 提高编译器效率，增加运行速度；
  12.         4. 为未来新版本的Javascript做好铺垫。
  13.         【注】"严格模式"体现了Javascript更合理、更安全、更严谨的发展方向，包括IE 10在内的主流浏览器，都已经支持它。

数组的新语法

  • Array.isArray 判定当前的数据是否是数组

    1.           如果是 true<br />                否则   false
    1. console.log(Array.isArray([1, 2, 3]));//true
    2.           console.log([1, 2, 3]);
    4.           var person = {
    5.               // name: "钢铁侠"
    6.               0: 1,
    7.               1: 2,
    8.               2: 3,
    9.               length: 3
    10.           }
    11.           console.log(Array.isArray(person));  //false

  • 数组的遍历 Array.forEach()

    1. var arr = [10, 20, 30, 40, 50];
    2.           arr.forEach(function(item, index, array){
    3.               //item 是当前遍历到的元素
    4.               //index是当前遍历到的元素的下标
    5.               //array数组本身
    7.               console.log(item, index, array);
    8.           })

  • Array.map()

    1.           功能：映射<br />                映射关系：写在函数的return部分。<br />                返回值：生成一个映射关系生成的新数组
    1. 让上述数组中每一个元素，增加30%
    2.           var newArr = arr.map(function(item, index, array){
    3.               return item * 1.3;
    4.           })
    6.           console.log(newArr);
    7.           console.log(arr);

  • Array.filter()

    1.           功能：过滤<br />                过滤条件：return后面的表达式
    1. var newArr = arr.filter(function(item, index, array){
    2.               return item > 30;
    3.           })
    5.           console.log(newArr);
    6.           console.log(arr);

  • Array.every()

    1.           功能：判断数组中的每一个元素，是否都符合条件<br />                返回值：如果是，返回true， 否则false<br />                判断条件：return后面的表达式<br />                【注】短路操作
    1. var res = arr.every(function(item, index, array){
    2.               console.log(item, index, array);
    3.               return item < 300;
    4.           })
    6.           console.log(res);
    7.           console.log(arr);

  • Array.some()

    1.          功能：判断数组中的有一个元素，是否符合条件<br />                返回值：如果是，返回true， 否则false<br />                判断条件：return后面的表达式<br />                【注】短路操作
    1. var res = arr.some(function(item, index, array){
    2.              console.log(item, index, array);
    3.              return item > 300;
    4.          })
    6.          console.log(res);
    7.          console.log(arr);

  • Array.indexOf()

    1.           格式：数组.indexOf(item, start);<br />                【注】start不传入，默认从0开始查找。<br />                功能：在数组中查找item，从start开始第一次出现的下标。<br />                返回值：如果能查找的到，返回查找到的下标，否则，返回-1

    ```javascript var arr = [10, 20, 30, 40, 50, 40, 30, 20, 10];

    1.       var index = arr.indexOf(200, 2);
    2.       console.log(index);
  2. - 格式：Array.lastIndexOf(item, end);
  4.                 功能：在数组中，查找item最后一次出现的位置，这个位置<= end。<br />                返回值：如果能查找的到，返回查找到的下标，否则，返回-1
  5. ```javascript
  6. var arr = [10, 20, 30, 40, 50, 40, 30, 20, 10];
  7.             var index = arr.lastIndexOf(20, 0);
  8.             console.log(index);

  • Array.reduce()

    1.       //归并

    ```javascript

    1.       var arr = [10, 20, 30, 40, 50];
  1.     var res = arr.reduce(function(prev, next, index, array){
  2.         //prev 第一次是下标0的元素，第二次开始是上一次return的值
  3.         //next 第一次是下标1的元素，每一次取出后面一个元素
  4.         //index 当前next元素的下标
  5.         console.log(prev, next, index);
  6.         return prev + next;
  7.     })
  9.     console.log(res);
  13.     var sum = arr.reduceRight(function(total, value, index) {
  14.         console.log(total, value, index);
  15.         return total + value;
  16.     });
  17.     console.log(sum);
  1. <a name="ohZfu"></a>
  2. ## 新增字符串的语法
  4. - 字符串的声明
  6.                字符串：任何带单引号或者双引号，都叫做字符串。<br />                【注】既是基本数据类型，又是复合数据类型。
  7. ```javascript
  8. //1、可以通过new运算符创建
  9.             var str1 = new String(true);
  10.             console.log(typeof str1); //object
  11.             console.log(str1);
  13.             // //2、可以省略new创建
  14.             var str2 = String(100);
  15.             console.log(typeof str2); //string
  17.             //3、通过常量赋值
  18.             var str3 = "world";
  19.             console.log(typeof str3); //string
  20.             console.log(str3[2]);
  21.             str3[2] = "x";
  22.             console.log(str3);

  • 如果想要访问字符串中某一个字符

    1.           str[下标];<br />                访问字符串的字符个数<br />                str.length 
    3.           【注】字符串是只读的，只能读取，不能被修改，如果非要修改，那么销毁原字符串，生成新字符串。

    方法

  • 格式：字符串.trim();

    1.           功能：清除字符串首尾的空格
    1. var str = "  he l  lo   ";
    2. console.log("|" + str + "|");
    3. console.log("|" + str.trim() + "|");

  • charAt(3) //获取下标为3的字符

    1.           charCodeAt(3)     //获取下标为3的字符的编码(ASCII)<br />                【注】上述两个方法使用字符串对象调用
    3.           fromCharCode(94)  //编码转换成字符<br />                该方法是 String 的静态方法，所以用String调用， <br />                格式：String.fromCharCode(参数1, 参数2...);<br />                返回值：传入所有的ASCII码值，对应的字符拼接成的字符串。

    ```javascript var str = “hello”;

    1.       console.log(str.charAt(1));
    2.       console.log(str[1]);
    4.       console.log(str.charCodeAt(1)); //101
  1.         var str = String.fromCharCode(97, 98, 99, 100);
  2.         console.log(str);
  2. - concat()
  4.                 用途是用于拼接字符串。
  6.                 用的很少，+号也是拼接符。
  7. ```javascript
  8. console.log("hello".concat(100, "world", true));//concat拼接
  10.             console.log("hello" + 100 + "world" + true)//+好拼接

  • <1>indexOf(“abc”, start); 查找字符串第一次出现的位置，可以传两个参数

    1.              格式：supStr.indexOf(subStr, start);<br />                    返回值：查找到，返回下标，查找不到，返回-1
  1.             <2>lastIndexOf("abc”);      查找字符串最后一次出现的位置  如果没有找到  返回-1<br />                    格式：supStr.lastIndexOf(subStr, end);<br />                    返回值：查找到，返回下标，查找不到，返回-1<br />               <br />                <3>search()  正则匹配(返回出现的位置)<br />                    【注】只能找第一个符合条件的。<br />                简单介绍：<br />                    "abc"<br />                    /abc/ig   修饰符 <br />                    i  忽略大小写<br />                    g  全局匹配
  1. var supStr = "Abcabcabc";
  2.             var subStr = "abc";
  3.              console.log(supStr.indexOf(subStr, 7));
  5.              console.log(supStr.lastIndexOf(subStr, 2));
  7.             console.log(supStr.search(/abc/i));

  • replace(); 替换字符串

    1.          格式：supStr.replace(oldStr/正则, newStr);<br />                功能：用newStr将oldStr替换调，返回新字符串。<br />                返回值：替换完成的新字符串。
    3.          "hello"<br />                /hello/ig<br />                i 忽略大小写<br />                g 全局匹配
    1. var str = "how are aRe are you";
    2.         var newStr = str.replace("are", "old are");
    4.         var newStr = str.replace(/are/gi, "old are");
    5.         console.log(str);
    6.         console.log(newStr);

  • substring

    1.           格式：字符串.substring(start, end);<br />                功能：提取[start, end)对应字符，生成新字符串。<br />                返回值：生成的新字符串。
    3.           substr<br />                格式：字符串.substr(start,length);<br />                功能：在start这个位置开始，提取length个字符，生成新的字符串<br />                返回值：新的字符串。
    5.           //数组的方法，可以在字符串中用<br />                slice(start, end);
    1. var str = "helloworld";
    2.           console.log(str.substring(2, 6));
    3.           console.log(str.substr(2, 4));
    4.           console.log(str[1]);
    6.           console.log(str.slice(2, 6));

  • toLowerCase()方法用于把字符串转换成小写

    1.               toUpperCase()方法用于把字符串转换成大写
    1. var str = "helloWORLD";
    2.           console.log(str.toLowerCase());
    3.           console.log(str.toUpperCase());

  • split 

    1.          格式：字符串.split(分割符, length);<br />                参数： 第一个参数，传入分隔符以后，用于分割原字符串<br />                      第二个参数，分割完毕的字符串，放在数组中返回，控制数组长度(一般不传)<br />                返回值：数组
  1.             特殊情况：<br />                    1、如果有相邻的分隔符，会分割出空字符串。<br />                    2、如果分割符是空字符串，那么会将每一个字符，单独分割到数组中。
  1. var str = "how  are you";
  2.             // var arr = str.split(" ");
  3.             // console.log(arr);
  5.             var arr = str.split("");
  6.             console.log(arr);
  8.             var str = new String("hello");
  9.             console.log(str);

声明提升

顺序结构：代码自上而下顺序执行。

  1.             实际代码运行之前，先会进行预编译-声明提升。<br />                预编译：先将程序要用的内存资源，准备好。
  3.             声明提升：将变量的声明，形参的声明，函数的声明，放在当前作用域的最前面执行。
  1. var a = 10;
  2.             function show(){
  4.                 console.log(a);
  5.                 function a(){
  7.                 }
  8.                 a = 100;
  9.                 console.log(a);
  10.             }
  12.             console.log(a); //10
  13.             show(a); //a = a输出结果是f（a）和100
  14.             console.log(a); //10
  15.             console.log(a);//10
  16.             function a(){
  18.             } 输出结果是空