1.变量

变量名称命名规范：

1.首字母只能英文字母或_或$
2.不能使用关键字（var）或保留字符,如：var for if else break continue while let const function等等
3.驼峰命名：取有意义的名字，不要a,b,c,无意义

弹出框，输入框

提示框：alert（“hello”）
询问框：confirm(“是否删除？”);
输入框：prompt(“请输入性别”);
控制台打印输出：console.log(“你好”);
输出到页面：document.write(“

JavaScript”)

js引入方式：

  1. 1.行内js：代码可读性差<br />    2.内部js：应用于当前页面，其他页面无法使用<br />    3.外部js： 推荐使用该方式

2.数据类型：

简单（基本）数据类型

  • string，number，undefined，Boolean，null，

    typeof：

    用于获取数据类型，一般用于判断基本数据类型，返回数据类型的名称

    NaN ：

    代表一个数值，类型是number

复杂数据类型

  • 对象(Object)、数组(Array)、函数(Function)

    instanceof ：

    判断复杂数据类型，测试 左边的对象 是否是 右边类 中的一个实例，返回布尔值（true false）

    数据类型转换

    1.字符串转换为数字
    字符串（前提：纯数字的字符串，以数字开头的字符串）转换为数字
    parseInt() 从第一位开始 到 第一位的非数字字符结束，提取字符串开头位置的整数部分。
    parseFloat() 从第一位开始到第一位的非数字字符结束，提取字符串开头位置的整数部分+小数部分。
    隐式转换 （前提：纯数字的字符串） - / “2” 2 == 4
    var str1 = ‘123’;
    console.log(typeof str1); //string
    console.log(typeof parseInt(str1)); //number

    1.   var str2 = '123a'<br />        console.log(parseInt(str2)); //123
    3.   var str3 = '1a23';<br />        console.log(parseInt(str3)); //1
    5.   var str4 = '123.456'<br />        console.log(parseInt(str4));//123<br />        console.log(parseFloat(str4));//123.456
    7.   // Number() 将字符串(前提：纯数字)，布尔值转换为数字<br />        var str5 = '123456';<br />        console.log(typeof Number(str5));//number
    9.   var str6 = '123a';<br />        console.log(Number(str6)); //NaN  (not a number)
    11. **补充：isNaN() 方法，检测一个数值是否是NaN**<br />**       如果 某个数值是NaN，isNaN()方法返回的是true；否则返回false。**<br />        console.log(isNaN(Number(str6))); //true

    2.数字转换为字符串
    var num1 = 147;
    var res = num1.toString();
    console.log(typeof res); //string
    console.log(‘—————————————————-‘);

3.转换为布尔类型
console.log(Boolean(0)); //数字类型的值，只要不是0或NaN，转换为布尔类型之后都是true
console.log(Boolean(NaN)); //false
console.log(Boolean(‘’)); //字符串类型的值，只要不是空字符串，转换为布尔类型之后都是true
console.log(Boolean(undefined)); //false
console.log(Boolean(null));

  • 数字，字符串，布尔值互相转换，且出现 NaN，undefined，null，0 ，’ ‘，false都为假

    反引号

    模板字符串使用反引号代替普通字符串中的单引号、双引号
    模板字符串中有特定的语法 用${}作为占位符.

变量提升

先使用再声明不会报错

  1. // 先声明
  3.         // 再使用
  5.         var num1 = 10; //声明
  6.         var res = num1 + 1; //使用
  9.         // 由于js中存在变量提升的现象(仅仅是提升了变量的声明)
  10.         // 所以 我们可以 在声明之前去使用变量。
  11.         // 代码在编译和运行时不会报错。
  13.         console.log(num2 + 10);  //NaN
  14.         var num2 = 20;
  16.         // 相当于执行了以下代码：
  17.         // var num2;
  18.         // console.log(num2 + 10);
  19.         // num2 = 20;

严格模式 ：”use strict”

消除不合理
（不声明就使用会报错）
哪里用到就在哪声明，可以是某个函数中，也可以是整个script

ES6中的let 和 const

let

1.使用let声明变量，不存在变量提升的问题
2.let声明的变量能够形成块级作用域block

const

1.声明“常量”，常量是不能发生改变的量，
2.也能形成块级作用域

总结：var let const的区别

1.var存在变量提升，let和const都不具备
2.能否形成块级作用域，var不能，let和const都可以
3.值能否发生改变：const不能，var和let都可以

作用域 Scope

  1.     全局作用域 Global<br /> 脚本作用域script<br />脚本作用域只针对let  const声明的变量或常量<br />        局部作用域(函数作用域) Local<br /> 块级作用域bolck:<br />let,const声明的变量能够形成块级作用域，块级作用域中声明的常量或变量只能在块级作用域中使用
  3.     全局变量：在全局作用域中定义的变量，它在任何地方都可以使用<br />如果用**var声明**的变量，该变量会被绑定在window身上，作为window的属性<br />如果用**let**声明的变量或**const**常量，不会被绑定在window身上，不能使用window.XXX访问<br />        局部变量：在局部作用域中定义的变量或常量，它只能在局部作用域中使用
  1.        var x = 10;
  3.         function fun1() {
  4.             var y = 20;
  5.         }
  7.         fun1()
  9.         // console.log(y);  //报错： y is not define  (y变量没有定义)

作用域链：

简单说就是查找变量的规则(顺序)，访问变量时，先在当前作用域中查找，如果不存在则向上一级查找，直到全局作用域为止

  1. <script>
  2.         // 作用域链：简单说就是查找变量的规则(顺序)
  3.         // 访问变量时，先在当前作用域中查找，如果不存在则向上一级查找，直到全局作用域为止
  5.         var x = 10;
  7.         function fun1() {
  8.             var x = 1;
  9.             var y = 20;
  10.             return x + y;  //此时 x 指的是谁？
  11.         }
  12.         console.log(fun1());
  15.         // 练习
  16.         // 例1
  17.         var a = 1;
  18.         function fun2() {
  19.             console.log(a); //? undefined  变量提升
  20.             var a = 10;
  22.             // var a;
  23.             // console.log(a);
  24.             // a = 10;
  25.         }
  26.         fun2();
  28.         // 例2
  29.         var b = 5;
  30.         function fun3() {
  31.             var b = 15;
  32.             function fun4() {
  33.                 // var b = 25;
  34.                 console.log(b); // ?
  35.             }
  36.             fun4();
  37.         }
  38.         fun3();
  40.         // 例3
  41.         // var z = 10;
  42.         // function fn1() {
  43.         //     console.log("fn1:"+z); //?
  44.         // }
  45.         // function fn2() {
  46.         //     z = 100;
  47.         //     console.log("fn2:"+z); //?
  48.         //     fn1();
  49.         // }
  50.         // fn2();
  52.         // 变形
  53.         var z = 10;
  54.         function fn1() {
  55.             console.log("fn1:"+z); //? 10  全局作用域中的z
  56.         }
  57.         function fn2() {
  58.             var z = 100;
  59.             console.log("fn2:"+z); //? 100  局部作用域(fn2)中的z
  61.             fn1();
  62.         }
  63.         fn2();
  64.     </script>