建议花一天时间过一遍js的基础语法，然后再去学习js web api，并且本篇文章，我只写了我认为有区别于其他语言的地方。

输入输出

	说明	归属
alert(msg)	浏览器弹出警示框	浏览器
console.log	浏览器控制台打印输出信息（开发者看）	浏览器
prompt(info)	浏览器弹出输入框，用户可以输入	浏览器

变量

声明变量

var age;

使用变量

age=20;

输出变量

alert(age)

案例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>js</title>
    <!-- <script src="h.js"></script> -->
    <script>
        var n=prompt("输入昵称");
        alert(n+' 您好！');
    </script>
</head>
<body>
</body>
</html>

结果演示

数据类型

js的变量数据类型是只有在程序运行过程中，根据等号右边的值才能确定的。

js拥有动态类型，意味着相同、

的变量可用作不同的类型：

var x = 6;  //x为数字型
var x = 'b' //x为字符串型

判断非数字

console.log(isNaN(10));

字符串型

转义符

字符串长度

str.length

字符串拼接

和python一样，只要是字符串拼接，不管是和什么类型拼接，最后都是字符串类型。

检测数据类型

typeof age

数据类型转换

转换为字符串

转换为数字型

parseInt是取整，并且在后面有单位的数值上会去掉单位取其整数值

转换为布尔型

代表空、否定的值会被转换为false，如”、0、NaN、null、undefined
其余值都会被转换为true

运算符

== 是否相等（遇到字符串类型，会把它先转换为数字型再进行比较）
=== 全等（要求两侧的值和数据类型完全一致才返回true）

短路运算（逻辑中断）

原理：当有多个表达式（值）的时候，左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值了

逻辑与

语法：表达式1 && 表达式2
如果第一个表达式的值为真，则返回表达式2
如果第一个表达式的值为假，则返回表达式1

逻辑或

语法：表达式1 || 表达式2
如果表达式1结果为真，则返回的是表达式1
如果表达式1结果为假，则返回表达式2。

例题

条件：能被4整除且不能整除100的或者能够被400整除的就是闰年

翻译成代码：

if(year % 4 == 0 && year %100 != 0 || year % 400 == 0){}

赋值运算符

js的赋值运算符和C语言一样。

流程控制

选择

和C语言一样

if(){
}else if(){
}else if(){
}else{
}

if(a>b) ? c : d

switch(表达式){
     case value1: 语句；
             break;
     case value2:语句;
             break;
     default:语句;
}

循环

和C语言一样

数组

创建数组

var arr = new Array(); //第一种方法，创建一个空的数组，后续有内容会自动添加，即扩容
var arr = [];  //第二种方法，创建一个空的数组
var arr=['小白',12,true,28.9'];

数组扩容

arr.length=5; //把数组的长度修改为了5
var arr = new Array(); //第一种方法，创建一个空的数组，后续有内容会自动添加，即扩容

添加删除数组元素

arr.push(4,'a') //在末尾添加一个或多个数组元素
arr.unshift(4,'a') //在前面添加一个或多个数组元素，返回的结果是新数组的长度
arr.pop()//可以删除最后一个元素，一次只能删除一个，不写参数
arr.shift()//删除第一个元素

数组冒泡排序

<script>
        var arr=[13,4,77,1,7];
        arr.sort(function(a,b){
            return b - a; //降序的顺序排列
        })
        console.log(arr);
</script>

数组转为字符串

arr.toString(); //1,2,3
arr.join('-'); //1-2-3

这个案例小技巧要理解：

var arr = [2,0,1,10,33,44,87];
var newarr=[];
for(var i =0; i <arr.length; i++){
    if(arr[i]>=10){
        newarr[newarr.length]=arr[i];
    }
}

函数

语法

<script>
        function name1(n1){
            console.log(n1);
        }
        name1('渣渣龙');
</script>

函数数组

<script>
        function name1(arr){
            console.log(arr[2]);
        }
        name1([3,4,2,7,7]);
</script>

arguments的使用

适用于不知道传了多少个实参的情况，arguments对象存储了传递的所有实参，它是当前函数的一个内置对象，里面储存了所有传递过来的实参。

它的展示形式是一个伪数组，特点：

具有length属性
按索引方式存储数据
不具有数组的push、pop等方法

<script>
        function name1(){
            console.log(arguments[1]);
        }
        name1(2,7,7);
</script>

作用域（es5)

全局变量

定义：

在全局作用域script下的变量
如果在函数内部，没有声明却直接赋值的变量也属于全局变量（不建议）

var a=b=c=9;

上面的代码相当于下面，其中b和c是直接赋值，没有var声明，所以当全局变量看。

var 1 =9 ; b =9 ; c = 9;

预解析（面试）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>预解析</title>
    <script>
        f1();
            console.log(c);
            console.log(b);
            console.log(a);

            function f1() {
                var a = b = c = 9;
                console.log(a);
                console.log(b);
                console.log(c);
            }
        // 以下代码
        // function f1() {
        //     var a;
        //     a = b = c = 9;
        //     // 相当于 var  a  = 9; b = 9; c = 9; b 和 c 直接赋值 没有var 声明 当 全局变量看
        //     // 集体声明  var a = 9, b = 9, c = 9;
        //     console.log(a);
        //     console.log(b);
        //     console.log(c);
        // }
        // f1();
        // console.log(c);
        // console.log(b);
        // console.log(a);
    </script>
</head>
<body>
    
</body>
</html>

结果演示

对象

创建对象

第一种方法：

<script>
        // var n = {}; //创建一个空对象
        var n2 = {
            name2: '渣渣龙',
            age: 18,
            // 方法后面跟的是一个匿名函数
            say: function(){
                console.log('hi');
            }
        }
        // 调用对象
        console.log(n2.name2);
        // console.log(n2['name2']);
        // 调用对象方法
        ne.say();
</script>

第二种方法：

<script>
        var n = new Object();
        n.name1='渣渣龙'
        n.age=18;
        n.say=function(){
            console.log('hi');
        }
        // 调用
        n.name1;
</script

变量、属性、函数、方法的区别

变量单独声明并赋值，使用的时候直接写变量名，单独存在
属性在对象里面的不需要声明的，使用的时候必须是对象.属性
函数是单独声明，并且调用函数名()，单独存在
方法在对象里面，调用的时候是对象.方法()

构造函数

语法：

<script>
        function 构造函数名(){
            this.属性 = 值;
            this.方法 = function(){}
        }
        // 构造函数调用
        new 构造函数名();
</script>

<script>
        function peo(uname,age){
            this.name=uname;
            this.age=age;
            this.say=function(s){
            console.log(s);
            };
        }
        var use = new peo('渣渣龙',22);
        console.log(use.name)
        use.say('说话');
</script>

遍历对象

for(变量 in  对象){
}

<script>
        var peo={
            name:'渣渣龙',
            age:18
        }
        for(var k in peo){
            console.log(k); // k变量  输出的是属性名
            console.log(peo[k]); //输出的是属性值
        }
</script>

内置对象

非构造函数：

Math.max();等等。

随机数方法：random()等等

日期对象

日期对象是一个构造函数，必须使用new来调用创建日期对象

var data = new Date();
console.log(date);

格式化日期

毫秒数（时间戳）：

date.valueOf()
date.getTime()
var date1 = +new Date() 最常用

总秒数换算成标准时间：

d=parseInt(总秒数/60/60/24); 计算天数
h=parseInt(总秒数/60/60%24) 计算小时
m=parseInt(总秒数/60/%60); 计算分
s=parseInt(总秒数%60); 计算当前秒

倒计时：

function daojishi(time){
            var nowtime= +new Date(); //返回当前时间总的毫秒数
            var inputtime= +new Date(time); //返回的是用户输入时间总的毫秒数
            var jieguo = inputtime - nowtime; //time是剩余时间总的毫秒数
        }