JS基础笔记

<script>
    var a = 10;
    var b = 20;
    var c = a;
    a = b;
    b = c;
    console.log(a);
    console.log(b);

    console.log(isNaN(NaN));
    console.log("abc" + 10);

    var i = true;
    var j = false;
    console.log(i + j);

数据类型： number string boolean undefined null

//typeof 判断数据类型
    console.log(typeof(j));

//    var num = 11;
//    console.log(isNaN(num));

// toString数据转换为字符串string类型  常用*
    var num = 12;
    var str = num.toString();
    console.log(str);
// String转换为字符串String类型  强制转换
// 隐式转换
    var a = 1;
    console.log(a + '');
// Number数据转换为number类型： 保留小数， 有非数字结果为NaN;
// parseInt数据转换为number类型： 取整，  如遇到非数字，就返回NaN;  常用*
// parseFloat和parseInt 一样，但保留小数;

//    var i = prompt('输入第一个数');
//    var j = prompt('输入第二个数');
//    var x = parseFloat(i) + parseFloat(j);
//    alert(x);

// Boolean数据转换为bool   除了0 NaN ''空字符串 false null undefined为false, 其余都为true.
    console.log(Boolean('123'));

// ++前置  先自增后运算  先自增后赋值 先自加 后返回原值；；

//后置++  先赋值后自增 先返回原值后自加；
//    var a = 10;
//    var b = a++;
//    console.log(a);  // 11
//    console.log(b);   // 10
//    console.log(a + b); //21
//
//    var i = 10;
//    i++;
//    var j = i++ + 2;
//    console.log(j);   //13

// 单等 = 是赋值， 双等 == 是判断， 三等 === 是全等。

// 逻辑运算符 :先与&&后或||。
//  与：&&  真真为真， 其余都为假  一false都false**;
//  或：||  假假为假， 其余都为真  一true都true**;
//  非：！  取反
    console.log(false && false);
//运算优先级：1.（）
//           2.一元运算符 ++  --  ！
//           3.算数运算符 先* / % 后 + -
//           4.关系运算符 > >= < <=
//           5.相等运算符 ==  !== ===  !==
//           6.逻辑运算符 先&&   后 ||
//           7.赋值运算符

//三元运算符表达式：a >= b ? a : b;
    var a = 1;
    var b = 2;
    var c = a > b ? a : b;
    console.log(c);

// 控制语句流 ：
// if语句：
//  if else
//  if  else if  else
//    var a = prompt('请输入分数？')
//    if( a >= 90 ){
//        alert("A");
//    }
//    else if( a >= 80 ){
//        alert("B");
//    }
//    else if( a >= 70 ){
//        alert("C");
//    }
//    else if( a >= 60 ){
//        alert("D");
//    }
//    else if( a < 60 && a > 0 ){
//        alert("E");
//    }
//    else{
//        alert("what are you doing?");
//    }

// switch语句
// switch 是比较的全等===；

// Sources 调试：  Watch添加监视，
// 设置断点
// 刷新 命中断点h 是比较的全等===；

// for循环：
// 双for循环：
//        for( var i = 0; i < 3; i++){  //外层循环 循环一次  控制的是趟数
//            for( var j = 0; j < 3; j++){  //内层循环 循环全部  控制次数
//                document.write('*')
//            }
//            document.write('<br/>')
//        }

   // while循环：
// do while 不管条件成不成立 都会执行一次。

// continue： 继续  终止本次循环 ，进入到下一次循环。
// break: 终止循环

// 数组 *** :存储多个值， 把一组数据存到一起，并且提供方便的访问方式，
//           数组可以使用一个变量名 ，就可以存储多个值。
//           数组里可以是任何数据类型。
//           多个值用，隔开。
// 创建数组方法：var arr1 = new Array();通过构造函数创建函数 写一个数值代表数组长度  了解,
//             **使用数组字面量创建数组: var arr2 = []; ***
// 通过索引获取里面的数据 ， 索引从0开始；
    var arr = ['春','夏','秋','冬'];
    var str = arr[0];
    var s = '|';
    for( var i = 1; i < arr.length; i++){
        str += s + arr[i];
    }
    console.log(str);
//一次取值：
    console.log(arr[0]);
    console.log(arr[1]);
    console.log(arr[2]);
    console.log(arr[3]);
//重新赋值：
    arr[0] = 'A';
    console.log(arr[0]);
//追加：
    arr[4] = '四季';
    console.log(arr[4]); //没有下标 追加；
// length 增加数组容量：
    arr.length = 5;
    console.log(arr);

    arr[arr.length] = '';

//遍历数组：
    console.log(arr.length);
    for( var i = 0; i < arr.length; i++){
        console.log(arr[i]);
    }

    var a = 0;
    var Arr = [5,6,7,8,9,10];
    for(var i =0; i < Arr.length; i++){
        a += Arr[i];
    }
    var p = a / Arr.length;
    console.log(a);
    console.log(p);

//选择数组中的最大最小值：<;
    var  arr1 = [12,58,32,1,50,64,85];
    var max = arr1[0];
    for(var i = 1; i < arr1.length; i++){
        if(max > arr1[i]){
            max = arr1[i];
        }
    }
    console.log(max);

// 把大于10的数放到新的数组中：
    var  arr3 = [12,58,32,1,50,64,85];
    var newArr = [];
    for(var i = 0; i < arr3.length; i++){
        if( arr3[i] > 10){
            newArr[newArr.length] = arr3[i];
        }
    }
    console.log(newArr);
//声明数组方式:
//    var arr = new Array(1,2,3,4,5);
//    var arr1 = [1];
//    console.log(arr1);
//    console.log(arr);

// 数组翻转：***
//1.
    var arr = ['A','B','C','D','E'];
    var newArr = [];
    for( var i = 0; i < arr.length; i++){
        newArr[i] = arr[arr.length - i - 1];
    }
    console.log(newArr);
//2.
    var arr = ['A','B','C','D','E'];
    var newArr = [];
    for( var i = arr.length - 1; i--;){
        newArr[newArr.length] = arr[i];
 加粗样式   }
    console.log(newArr);

//冒泡排序： 是一种算法，把一系列数据按照顺序排列（从小到大，从大到小）
//          外层 length - 1；
//          内层 length - i - 1；
    var arr = [5,9,43,1,8,12,50,123];
    for( var i = 0; i < arr.length - 1; i++){
        for(  var j = 0; j < arr.length - i - 1; j++){
            if(arr[j] > arr[j + 1]){
                var t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t;
            }
        }
    }
    console.log(arr);

    var arr1 = [1,2,3,4,5,6,7,8,9];
    var c = 0;
    for( var i = 0; i < arr1.length - 1; i++){
        var b = true;
        for( var j = 0; j < arr1.length - 1 - i; j++){
            if(arr1[j] > arr1[ j + 1]){
                b = false;
                var a = arr1[j];
                arr1[j] = arr1[j + 1];
                arr1[j + 1] = a;
            }
            c++;
        }
        if(b = true){
            break;
        }
    }
    console.log(arr1);
    console.log(c);

/         函数：
//         function 函数名(){函数体};

        // 匿名函数：1.当做自调用函数 2.当做函数表达式； 3 对象的方法；
        // 自调用：(function(){
        //         })();

        // 函数也是一种数据类型：function;
        // 函数可以作为参数传递： 把函数当做参数 传递进去的那个被传入的函数，称为回调函数，*****
      //                     当函数进行传递的时候，千万不要加小括号，because 加了小括号就是调用函数；
        //

        // return 当函数没有写return时，该函数返回undefined；
        // return 后面什么都没写， 该函数返回undefined；
        // return 后面是什么，那么该函数的返回值就是什么；

        // return 后面的代码将不再执行， 跟循环里的break一样；

        // arguments 用来确定用户输入了多少个实参
        // 用来存储用户传递过来的实参，不管多少都存储
        // 有arguments 就可以不用写形参；
        // arguments 按照一种伪数组形式存储；伪数组（有长度length 有索引号  没有数组的方法push、pop ）

// 作用域： 变量可以起作用的范围；在函数外部的叫全局变量，函数内部叫局部变量， 形参属于局部变量，
        // 作用域链：按链式往上一层找；

        // 预解析：1.变量提升：只提升声明，不提升赋值
        //        console.log(a); undefined;
        //        var a = 10;
        //        2.函数提升：会将整个函数体进行提升；
        // 如果变量名和函数冲突，优先执行 函数；

 // 对象：方法和属性组成的集合；
//      属性名和方法中间 用, 隔开；
//      方法后面跟函数；
//      使用对象 ：对象名.属性名，或者  对象名['属性名']；
//      使用方法：对象名.方法名() ,
//        创建对象方法：1.利用对象字面量创建对象{}；
//        var Wkk = {
//            name: '王可可',
//            age: 5,
//            color: 'red',
//            cry : '汪汪汪',
//            showFilm: '《后会无期》',
//            can: function () {
//                alert('wangwangwang')
//            }
//        }
//        console.log(Wkk);
//        console.log(Wkk.name);
//        console.log(Wkk.can());

//        2.利用 new Object 创建对象：
//        var stuObj = new Obect();
//        stuObj.name = 'james';
//        stuObj.age = 11;
//        stuObj.sex = true;
//        stuObj.sayHi = function(){
//            alert('大家好啊~');
//        }
//      构造函数：封装对象；
//      1. function 构造函数名（参数1....）{   构造函数名 首字母大写
//                  this.属性名 = 属性值；  this在对象方法中，指当前对象；
//                  this.方法名 = 函数}
//                调用构造函数： new 构造函数名（），自定义构造函数调用 ；
//         this
//        1. 函数在定义的时候this是不确定的，只有在调用的时候才可以确定
//        2. 一般函数直接执行，内部this指向全局window
//        3. 函数作为一个对象的方法，被该对象所调用，那么this指向的是该对象（谁调用指向谁）
//        是由构造函数创造的出来的实例对象；
//
//       new 关键字 ：*****
//        1.在构造函数中创建一个新的空对象；
//        2.让 this 指向这个空对象；
//        3.完成里面的代码  进行赋值；
//        4.帮我们自动返回这个对象。
//        for in 遍历：for( k in 对象){  console.log(对象[k]); }
//

        function Person(name,type,blood){
            this.name = name;
            this.type = type;
            this.blood = blood;
            this.attack = function(){
                console.log('攻击')
            }
        }
        var a = new Person('廉颇','力量型','100血');
        var b = new Person('后羿','射手型','100血');
        console.log(a);
        a.attack();
        console.log(b);
        //遍历 for in
        for(var k in a){
            console.log(a[k]);
        }
//        console.log(a instanceof Person); A instanceof B, A 是不是由B创造出来的实例（对象）；

//        内置对象：js里面自带的一些对象，供我们开发者使用，这些对象提前内置准备好的属性和方法，可以直接使用。
        //        数学对象Math:
        //        Math.random();
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1) + min);
        }
        var a = getRandom(13, 31);
        console.log(a);
        console.log(Math.round(7.55656));// 四舍五入；

        //        Date对象: 实例化对象，
        var date = new Date(); //参数为空，则返回当前日期和时间，
        var date1 = new Date('2018-12-1');//返回输入的日期和时间
        //      获得毫秒数：
        //        1.valueOf();
        //        2.getTime();***
        //        3.var date = +new Date();
        //        4.console.log(Date.now()); h5方法 有兼容性问题。
        //        格式化日期：
        //                date.getFullYear(); 当前年份；
        //                date.getMonth(); 当前月 0 - 11
        //                date.getDate(); 当前日
        //                date.getDay(); 当前星期几  0 星期天  1星期一；
        //当前时间：
        function getDay() {
            var date = new Date();
            var arr = ['星期天', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']
            var y = date.getFullYear();
            var m = date.getMonth();
            var d = date.getDate();
            var x = date.getDay();
            var h = date.getHours();
            var f = date.getMinutes();
            var s = date.getSeconds();
            h = h < 10 ? '0' + h : h;
            f = f < 10 ? '0' + f : f;
            s = s < 10 ? '0' + s : s;
            return y + '年' + m + '月' + d + '日' + arr[x] + ' ' + h + ':' + f + ':' + s;

        }
        //        setInterval(getDay(), 1000);
        console.log(getDay());
        //倒计时：
        function getTime(start, end) {
            var t = end - start;
//            var d = Math.floor(t / 1000 / 60 / 60 / 24);
//            var h = Math.floor(t / 1000 / 60 / 60 % 24);
//            var m = Math.floor(t / 1000 / 60 % 60);
//            var s = Math.floor(t / 1000 % 60);
            return {
                d: Math.floor(t / 1000 / 60 / 60 / 24),
                h: Math.floor(t / 1000 / 60 / 60 % 24),
                m: Math.floor(t / 1000 / 60 % 60),
                s: Math.floor(t / 1000 % 60),
            };
        }
        var start = new Date();
        var end = new Date(2018, 11, 12);
        console.log(getTime(start, end));

        //      判断对象是否属于数组：
        //       1.instanceof  运算符； 判断是否是数组
        //       2.Array.isArray;
        //      数组中的方法：
        //      push() 追加 ： 向数组末尾追加元素，并返回添加后的数组长度，
        //      pop()  删除 ：从末尾删出元素，并返回被删除的元素，
        //      unshift() : 向数组最前面追加元素，并返回添加后的数组长度，
        //      shift() : 从最前面删除元素，并返回被删除的元素，
        //      reverse() ,翻转数组； 返回新数组
        //      sort(), 排序，  返回新数组
        //      concat(); 合并数组，称为一个新数组；
        //      splice（第几开始，删除个数），删除元素；
        //      slice(begin,end) 截取元素 ，返回截取的新数组；
        var arr = [1, 2, 3, 4, 5];
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            newArr.push(arr[i]);
            newArr.sort(function (a, b) {
                return b - a;
            });

//            newArr.unshift(arr[i]);
        }
        console.log(newArr);

      //      indexOf(); 查询数组元素在数组中的位置，从左往右查询；
        //      lastIndexOf(); 从右往左查询；
//        var arr = [1,0,25,0,1,0,1,3,5,8,3];
//        do{
//        var index = arr.indexOf(1,index + 1);
//        if( index != -1){
//            console.log(index);
//        }
//        }while ( index != -1)
//
     数组去重：
//        var arr = ['c','a','z','a','x','a','x','c','b'];
//        var newArr = [];
//        for( var i =0; i < arr.length; i++){
//        if(newArr.indexOf(arr[i]) === -1){
//            newArr.push(arr[i]);
//          }
//        }
//        console.log(newArr);

//      数组字符串拼接：
//        var arr = ['s','a','i','n','t'];
//        console.log(toString(arr));
//        console.log(arr.join(''));
//      复杂数据类型：复杂数据类型里面存储的是地址，同一地址直接调用地址。
//      基本包装类型：string是引用类型的一种，
//        indexOf();查询数组元素在数组中的位置，从左往右查询
//        charAt(index);根据索引号返回字符，
//        charCodeAt(index); 返回ASCII 码；
//        var str = 'adasdfgesrsfv';
//        for(var i = 0; i < str.length; i++){
//            console.log(str.charAt(i));
//        }
     substr(起始位置，长度); 截取字符串，
     replace(被替换的字符，替换的字符) ;
//        var str = 'obsessionsaint';

//        while(str.indexOf('s') != -1){
//            str = str.replace('s','b');
//        }
//        console.log(str);
     split 分割字符串 ，转换为数组；  //返回值是数组；

//        var str = 'saint-obsession';
//        var arr = str.split('-');
//        console.log(arr);
//      toUpperCase();转换为大写；**加粗样式**
//      toLowerCase();转换为小写；
//        把url'http://www.itheima.com/login?name=zs&age=18&pwd=123456'；
//        把？后面的数据转换为对象 {name:zs, age:18, pwd:123456}
//        var url = 'http://www.itheima.com/login?name=zs&age=18&pwd=123456';
//        function getUrl(url){
     var index = url.split('?')[1];  切割
//        var index = url.indexOf('?') + 1;
//        var last = url.substr(index);
//        var arr = last.split('&');
//        var o ={};
//        for( var i = 0; i < arr.length; i++){
//            var newArr = arr[i].split('=');
//            o[newArr[0]] = newArr[1];
//         }
//            return o;
//        }
//        console.log(getUrl(url));