JavaScript基础语法

        
            //1.弹出一个输入框，提示用户输入姓名;
            var uname = prompt('请输入您的姓名');
            
            //2.弹出一个对话框，输出用户刚才输入的姓名;
            alert(uname);
        
    

JS把数据类型分为两类:
• 简单数据类型（Number,String,Boolean,undefined,Null)
• 复杂数据类型（Object)

数字型 Number

1.八进制 0～7 我们程序里面数字前面加0 表示八进制

        
    var num = 010;
    console.log(num);//010 八进制 转换为 10进制 就是 8
        
    

2.十六进制 0～9 a~f #ffffff 数字的前面加 0x 表示十六进制

            
    var num = 0x9;
    console.log(num);//0x9 十六进制 转换为 10进制 就是 9

    var num1 = 0xa;
    console.log(num1);//0xa 十六进制 转换为 10进制 就是 10
            
    

3.数字型的最大值

            
    console.log(Number.MAX_VALUE);
            
    

4.数字型的最小值

            
    console.log(Number.MIN_VALUE);
            
    

5.isNaN()这个方法用来判断非数字，并且返回一个值，是数字返回false，反之true

            
    console.log(isNaN(12));//false
            
    

数据类型转换

**转换为字符串

• toString():

                  
                      var num = 1;
                      console.log(num.toString());
                  
              

• String()强制转换

                  
                      var num = 1;
                      console.log(String(num));
                  
              

• 加号拼接字符串（和字符串拼接的结果都是字符串）

                  
                      var num = 1;
                      console.log(num+'我是字符串');
                  
              

**转换为数字型（重点）

• parseInt(string)函数:

                      
                          //将string类型转成整数数值型
                          parseInt('78');
                      
                  

• parseFloat(string)函数:

                      
                          //将string类型转成浮点数数值型
                          parseFloat('78.21');
                      
                  

• Number()强制转换函数

                      
                          Number('12')
                      
                  

• js隐式转换（- * /）

                      
                          //利用算术运算隐式转换为数值型
                          ‘12’-0
                      
                  

**转换为布尔型

• Boolean()函数:

                          
                              //其他类型转成布尔值
                              Boolean('true')
                          
                      

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

JavaScript 中的对象分为3种：自定义对象，内置对象，浏览器对象

前面两种是 JS基础内容，属于ECMAScript；第三个浏览器对象属于我们JS独有的

内置对象就是指JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）

* Math 数学对象不是一个构造函数，所以我们不需要new 来调用，而是直接使用里面的属性和方法

        
            console.log(Math.PI);//一个属性 圆周率

            console.log(Math.max(1,99,8));//99
            console.log(Mact.max(1,99,'pink'));//NAN
            console.log(Math.max());//-Infinity

            console.log(Math.abs());//绝对值
            console.log(Math.abs(1));//1
            console.log(Math.abs(-1));//1
            console.log(Math.abs('-1'));//隐式转换 会把字符串型 -1 转换为数字型
            console.log(Math.abs('pink'));//NAN

            console.log(Math.floor());//向下取整
            console.log(Math.floor(1.1));//1
            console.log(Math.floor(1.9));//1

            console.log(Math.ceil());//向上取整
            console.log(Math.ceil(1.1));//2
            console.log(Math.ceil(1.9));//2

            console.log(Math.round());//四舍五入版 就近取整 注意 -3 5 结果是-3
            console.log(Math.round(1.1));//1
            console.log(Math.round(1.5));//2
            console.log(Math.round(1.9));//2
            console.log(Math.round(-1.1));//-1
            console.log(Math.round(-1.5));//-1

        
    

案例：利用对象封装自己的数学对象 里面有PI 最大值和最小值

        
           var myMath = {
               PI:3.141592653,
               max:function(){
                   var max = arguments[0];
                   for(var i = 1;i<arguments.length;i++){
                       if(arguments[i]>max){
                          max=arguments[i];
                       }
                   }
                   return max;
               },
               min:function(){
                   var min = arguments[0];
                   for(var i = 1;i<arguments.length;i++){
                    if(arguments[i]< min){
                        min=arguments[i];
                     }
                   }
                   return min;
               }
           }
           console.log(myMath.PI);//3.141592653
           console.log(myMath.max(1,5,99));//99
           console.log(myMath.min(1,5,99));//1
        
    

* random()随机数方法返回一个随机的小数[0,1)能取到0，不能取到1，这个方法里面不跟参数

案例：得到两个数之间的随机整数，并且包含这2个整数

        
            //Math.floor(Math.random()*(max-min+1))+min;
            function getRandom(min,max){
                return Math.floor(Math.random()*(max-min+1))+min;
            }
            console.log(getRandom(1,10));
        
    

案例：随机点名

        
            function getRandom(min,max){
                return Math.floor(Math.random()*(max-min+1))+min;
            }
            var arr  = ['张三','卡利斯','lil','tantang','mumu'];
            console.log(arr[getRandom(0, arr.length-1)]);
        
    

案例：猜数字游戏

        
           //随机生成一个1-10之间的数字，并让用户输入一个数字
           //1.如果大于该数字，就提示，数字大了，继续猜
           //2.如果小于该数字，就提示数字小了，继续猜
           //3.如果等于该数字，就提示猜对了，结束程序


        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }

        var random = getRandom(1, 10);
        var cc = 0
        while (cc<3) {
            cc++;
            var num = prompt('你来猜？输入1-10之间的一个数字');      
            if (num > random) {
                alert('你猜大了');
            } else if (num <random) {
                alert('你猜小了');

            } else if(cc===3){
                alert('不好意思，3次你都猜错了哦');
            } else {
                alert('你好帅哦，猜对了');
                break;//退出整个循环结束程序
            }
        }

        
    

* Date() 日期对象是一个构造函数 必须使用new 来调用创建我们的日期对象

        
            //Date() 日期对象 是一个构造函数 必须使用new 来调用创建我们的日期对象
             var arr = new Array();//创建一个数组对象
             var obj = new Object();//创建了一个对象实例
            
            //1.使用Date
            var date = new Date();//没有参数，返回当前系统的日期

            //2.参数常用写法 数字型 2019，10，01 或者是 字符串类型 ‘2019-10-1 8:9:0’
            var date = new Date(2019，11，21);//返回的是12月，不是11月
            var date = new Date('2019-11-21');//没有参数，返回当前系统的日期

        
    

案例：格式化日期 年 月 日

        
            var date = new Date();
            console.log(date.getFullYear());//返回当前日期的年 2019
            console.log(date.getMonth()+1);//月份，返回的月份小1个月，记得月份+1 哟
            console.log(date.getDate());//返回的是 几号
            console.log(date.getDay());//3 周一返回的是1 周六返回的是6 但是周日返回的是 0

            //写一个 2019年5月1日 星期三
            var year = date.getFullYear();
            var month = date.getMonth()+1;
            var dates = date.getDate();
            var arr = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'];
            var day = date.getDay();
            console.log('今天是:'+year+'年'+month+'月'+dates+'日'+arr[day]);
        
    

11.1.基本包装类型

为了方便操作基本数据类型，javaScript还提供了三个特殊的引用类型：String，Number和Boolean

基本包装类型就是把简单数据类型包装成为复杂数据类型，这样基本数据类型就有了属性和方法

    
        //下面的代码有什么问题？
        var str = 'andy';
        console.log(str.length);

        //对象才有属性和方法，复杂数据类型才有属性和方法
        //简单数据类型为什么会有length属性呢？
        //基本包装类型：就是把简单数据类型 包装成为了复杂数据类型
        //其执行过程如下：
        //1.生产临时变量，把简单类型包装为复杂数据类型
        var temp = new String('andy');
        //2.赋值给我们声明的字符变量
        str = temp;
        //3.销毁临时变量
        temp = null;
    

11.2.字符串的不可变性

指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间；

            
                var str = 'andy';
                str = 'bibi';

                //当重新给str赋值的时候，常量'andy'不会被修改，依然在内存中
                //重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变
                //由于字符串的不可变，在大量拼接字符串的时候会有效率问题
              
                var str = '';
                for(var i = 0;i<10000;i++){
                    str +=i;
                }
                console.log(str)
                //这个结果需要花费大量时间来显示，因为需要不断的开辟新的空间
                
            
        

11.3.根据字符返回位置

字符串所有的方法，都不会修改字符串本身（字符串是不可变的），操作完成会返回一个新的字符串；

             
               //字符串对象，根据字符返回位置， str.indexOf('要查找的字符',[起始的位置])
               var str = '情深深雨蒙蒙';
               console.log(str.indexOf('雨'));
               console.log(str.indexOf('深',2))//从第二个位置开始找               
             
    

案例：返回字符位置

查找字符串'abcodejpodeodedwo'中所有的o出现的位置与次数

                
                //核心算法：先查找第一个o出现的位置
                //然后只要indexof 返回的结果不是-1 就继续往后查找
                //因为indexof 只能查找到第一个，所以后面的查找，一定是当前索引+1，从而继续查找
                 var str =  'abcodejpodeodedwo';
                 var index =  str.indexOf('o');
                 var num = 0;
                 while(index !==1){
                    num++;
                    index = str.indexOf('o',index+1);
                 }    
                
    

11.4.根据位置返回字符(重点）

1⃣️charAt(index): 返回指定位置的字符（index字符串的索引号）

             
               //str.charAt(0)    
               //1. charAt(index) 根据位置返回字符
               var str = 'andy';
               console.log(str.charAt(0));//a
               
               //2.遍历所有的字符
               for(var i =0;i < str.length;i++){
                   console.log(str.charAt(i));
               }
             
         

2⃣️charCodeAt(index): 返回相应索引号的字符ASCII值 目的：判断用户按下了那个键

             
                var str = 'andy';
                console.log(str.charCodeAt(0));//97
             
    

3⃣️str[index]: H5新增的，IE8+支持和charAt()等效

             
                var str = 'andy';
                console.log(str[0]);//a
             
    

案例：统计出现最多的字符和次数

查找字符串'abcodejpodeodedwo'中所有的o出现的位置与次数

        
            //有一个对象，来判断是否有该属性 对象['']
            var o = {
                age:18
            }
            if(o['sex']){
                console.log('里面有该属性');
            }else{
                console.log('没有该属性');
            }
                
        
    

            
                //判断一个字符串'abcjdhuhdhdhodhsjodhdhso'中出现次数最多的字符，并统计其次数。
                //核心算法：利用charAt()遍历这个字符串
                //把每个字符串都存储给对象，如果对象没有该属性，就为1，如果存在了就+1
                //遍历对象，得到最大值和该字符
                var str = 'abchushdsudggygdyegysfgsgshgsdgs';
                var o={}
                for(var i = 0;i<str.length;i++){
                    var charts = str.charAt(i);//charts 是字符串的每一个字符
                    //o[charts] 得到的是属性值
                   if(o[charts]){
                    o[charts]++;
                   }else{
                       o[charts]=1;
                   }
                }
                console.log(o)
                var max=0;
                var ch = '';
                //遍历对象
                for(var k in o){
                   //k 得到的是属性名，
                   //o[k] 得到的是属性值
                    if(o[k]>max){
                        max=o[k];
                        ch =k;
                    }
                }
                console.log('出现的次数'+max)
                console.log('最多的字符是'+ch)
                    
            
        

11.5.字符串操作方法(重点)

1⃣️concat(str1,str2,str3):用于连接两个或多个字符串，拼接字符串，等效于+，+更常用

                 
                      var str = 'andy';
                      console.log(str+'vivi');//andyvivi        
                 
        

2⃣️substr(start,length):从start位置开始(索引号)，length 取的个数-重点记住这个

                 
                    var str1 = '改革春风吹满地';
                    console.log(str1.substr(2,2));//春风
                 
        

3⃣️slice(start,end):从start位置开始，截取到end位置，end 取不到(他们两都是索引号)

4⃣️substring(start,end):从start位置开始，截取到end位置，end 取不到,基本和slice相同，但是不接受负值

5⃣️替换字符 replace('被替换的字符','替换为的字符') 它只会替换第一个字符

                
                   var str1 = 'andy';
                   console.log(str1.replace('a','b'));//bndy
                
       

            
               //有一个字符串'sdshdshdshdhshs' 要求把里面所有的s 替换为*
               var str = 'sdshdshdshdhshs';
               while(str.indexOf('s') !==-1){
                   str=str.replace('s','*')
               }
               console.log(str);
            
       

6⃣️字符转换为数组 split('分隔符')---join 把数组转换为字符串

            
                    var str ='red,pink,blue';
                    console.log(str.split(','));//["red", "pink", "blue"]
             
                    var str ='red&pink&blue';
                    console.log(str.split('&'));//["red", "pink", "blue"]
            
       

11.6.简单类型与复杂类型

11.61简单类型：基本数据类型或者值类型放到栈里面

• 值类型：简单数据类型/基本数据类型，在存储临时变量中存储的值是本身，因此叫做值类型
string, number, boolen, undefined, null

               
                  //简单数据类型 null返回的是一个空的对象 object
                  //如果有个变量我们以后打算存储为对象，暂时没有想好放啥，这个时候就给null
                  var timer = null;
                  console.log(typeof timer);
               
           

11.62复杂类型：引用类型放到堆里面

• 引用类型：复杂数据类型，在存储时变量中存储的仅仅是地址(引用)，因此就叫做引用数据类型
通过new 关键字创建的对象（系统对象，自定义对象），如Object, Array, Date等

11.7.堆和栈

堆栈空间分配区别：

• 1.栈（操作系统）：存放简单数据类型，由操作系统自动分配释放存放函数的参数值，局部变量的值等，其操作方式类似于数据结构中的栈

            
            //简单数据类型 是放在栈里面 里面直接开辟一个空间存放的是值
            //复杂数据类型 首先在栈里面存放地址 十六进制表示 然后这个地址指向堆里面的数据
            
            

• 2.堆（操作系统）：存放复杂类型（对象），一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收；

11.8.简单数据类型传参

函数的形参也可以看作是一个变量，当我们把一个值类型变量作为参数传给函数的形参时，

其实是把变量在栈空间里的值复制了一份给形参,那么在方法内部对形参做任何修改，都不会影响到的外部变量；

                
                    function fn(a){
                        a++;
                        console.log(a);//11
                    }
                    var x =10;
                    fn(x);
                    console.log(x)//10
                
        

11.9.复杂类型传参

函数的形参也可以看作是一个变量，当我们把一个值类型变量作为参数传给函数的形参时，

其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象；

            
                function Person(name){
                    this.name=name;
                }
                function f1(x){
                    console.log(x.name);//刘德华
                    x.name = '张学友'；
                    console.log(x.name);//张学友
                }
                var p = new Person('刘德华')；
                console.log(p.name);//刘德华
                f1(p);
                console.log(p.name);//张学友