语句、变量等js最基本知识

JavaScript的最为基本知识

---

 1语法

js是区分大小写的；标识符就是指变量、函数、属性的名字或者是参数，标识符可以是字母，下划线，美元符号，数字，注意第一个不能是数字；js采用的是驼峰大小格式；js的单行和多行注释；严格模式下直接“use strict”即可。关键字和保留字，比如break，case等等。

变量：js的变量类型是松散型的，即可以保留任何类型的数据，每个变量仅仅是个占位符，var 声明变量为局部变量，没有var的即为全局变量。

2数据类型

js的数据类型有五种简单的数据类型undefined，string，number，Boolean，null，还有一个复杂的数据类型object，由于js具有动态性，所以足以应付。

typeof操作符，检测数据类型，当然还能检测到function，注意：检测到为object时可能是对象可能是null

2.1undefined类型

只有一个值undefined，使用var声明变量，但是没有对其初始化，即为undefined，没有声明的变量会报错，注意：但是用typeof进行检测却为undefined，所以需要的变量一定先声明。

2.2null类型

只有一个值null，是一个空对象指针，所以typeof会检测为object，如果声明好的变量要保存为对象，最好保存为null比较好

2.3Boolean类型

有两个字面量为true和false，但是js中的所有类型都可以转为对应的Boolean值，用转型函数Boolean()即可，

string类型的任何非空字符串，number类型的任何非零数字值，object任何对象都为true

string类型的空字符串，number类型的0和NaN，和null都为false

这种转换对于流程控制语句比如（if条件语句）会自动的执行相应的Boolean转换

2.4number类型

使用IEEE754格式表示整数和浮点数

浮点数值：必须包含一个小数点并且小数点后必须至少有1个数字，浮点数值的内存空间为整数数值的两倍所以js会对其转换比如10.0会自动转为整数值；浮点数的计算精准度比较低比如0.1+0.2！=0.3，不要测试某个特定的浮点数值。

数值范围：存在无限大和无限小，测试某个值是不是有穷的用isFinite()

NaN：not a number，NaN与任何值都不相等包括NaN本身

数值转换：有3个函数可以将非数值转换为数值类型，为Number()，parseInt()，parseFloat()。Number()可以用于任何数据类型，而后俩个则专门应对字符串的。

Number()的转换 
       var num1=Number("hello") //NaN
       var num6=Number(undefined) //NaN 
       var num2=Number("")      //0
       var num3=Number(null)    //0
       var num4=Number("0001")  //1
       var num5=Number(true)    //1

面对string时，整数常常用parseInt()，只会得到前面的整数，八进制和十六进制，

 parseInt的转换
       var num1=parseInt("123blue")  //123
       var num2=parseInt("")     //NaN
       var num3=parseInt("070")  //八进制的56
       var num4=parseInt("70")   //70
       var num5=parseInt("0xf")  //十六进制的15

         var num1=parseInt("10"，2) //2按照2进制解析

小数用parseFloat，始终忽略前面的0，只有第一个小数点为有效的，只解析十进制

2.5string类型

字符串，单引号或者双引号

转义序列： 表示换行， 表示制表等等，看做一个字符来解析

转换为字符串：toString()方法，数值，布尔值，对象，字符串值，都有toString()方法，但是null，undefined没有；调用数值时可以用 toString(2)表示进制。当然可以使用String()转型函数，当不知道是不是null和undefined时候，

2.6object类型

js的对象是一组数据和功能的集合，可以通过new操作符创建，object每个实例都有以下属性和方法

constructor保存用于创建当前函数的对象

hasOwnProperty()用于检查给定的属性在当前对象实例中是否存在，参数属性名必须以字符串表示

isPrototypeOf()用于检查传入的对象是否是当前对象的原型

toLocaleString()返回对象的字符串表示

toString()返回对象的字符串表示

valueOf()返回对象的字符串、数值、布尔值表示

3操作符

操作符包括算术操作符、位操作符、关系操作符、相等操作符，可以适用于很多值，数值，字符串，布尔，对象，当应用于对象时，会将转为valueOf()和toString()方法取得操作的值

3.1一元操作符

只能操作一个值

递增递减操作符

分为前置型和后置型,比如i++和++i等等，前置的递增递减，变量的值都是在语句被求值以前被改变的；后置型的递增递减，变量值在语句被求值以后被改变的

       var num1=2
       var num2=20
       var num3=num1--+num2 //22
       var num4=num1+num2   //21

一元加和一元减操作符

一元加，没什么效果；一元减则是负数了

位操作符不说

布尔操作符

非，与，或

非：返回一个布尔值，然后求反；null，undefined，NaN都返回true

与：都是布尔值时，一个为true则为true，都是false才为false；

或：一个为true则为true

乘性操作符

乘法* 除法/ 求模%

加性操作符

普通的加法即为加法，当操作数为字符串时：两个都是则直接连接一起，一个是字符串，则另一个转为字符串再连接一起

当有一个操作数为对象，数值，布尔值时，则调用他们的toString()方法取得相应的字符串值，再连接，对于null和undefined则调用String()方法取得的是null和undefined

注意：每个加法是独立操作的，按照顺序的，所以加性操作的时候要注意括号括起来

       var age=25
       var sex="25"
       var name=true
       var one=null
       var two=undefined
       console.log(age+sex)  //2525
       console.log(age+name) //25true
       console.log(age+one)  //25
       console.log(name+one) //truenull
       console.log(one+two)  //NaN

减法：当有一个操作数为字符串，数值，布尔值，null，undefined时，则调用他们的Number()方法取得相应的字符串值；当有个操作符为对象时，则调用对象的valueOf()方法，否则为String()方法

       var age=25
       var sex="25"
       var name=true
       var one=null
       var two=undefined
       console.log(age-sex)  //0
       console.log(age-name) //NaN
       console.log(age-true) //24
       console.log(age-one)  //25 null转为0

关系操作符

两个都是数值则直接比较数值；都是字符串则比较字符串编码；一个是数值则另一个转为数值；一个是对象，则调用valueOf()方法，toString()方法，布尔值转换为数值

       var num1=23>3      
       var num2="23">"3"
       var num3="23">3
       var num4="Abc">"abc"
       var num5=true>false
       var num6=NaN<3
       console.log(num1) //true
       console.log(num2) //false
       console.log(num3) //true
       console.log(num4) //false
       console.log(num5) //true
       console.log(num6) //false   NaN无法比较都是false

相等操作符

相等和不相等，全等和不全等，区别在于是否进行数据类型的转变在做比较判断

相等操作符会先强制转换，布尔值则先转为1和0；一个为字符串和数值，则先转为数值；一个为对象则先调用valueOf()方法；null和undefined是相等的，NaN不等于NaN，都是对象则比较是否为同一对象

全等操作符则不会强制转换，保留原有的数据类型，“55”！==55

条件操作符

var max=（num1>num2）?num1:num2;

赋值操作符

age+= age*=等等之类

逗号操作符

声明多个变量；用于赋值时，返回表达式的最后一项

 4语句

条件语句

if语句：if条件语句，内为布尔值的判断

switch语句：一般多种情况的讨论，避免if语句的累积，也是布尔值的判断

     var i=5;
     switch(i){
         case 1:
         //合并两种情况，所以没有break，一般情况下都要带的
         case 2:
           console.log("hello");
           break;
         case 3:
           console.log("hello");
           break;
         case 4:
           console.log("hello");
           break;
         case 5:
           console.log("hello");
           break;
         case 6:
           console.log("hello");
           break;
         default:                           //不匹配时的情况
           console.log("world");
     }

     switch("hello"){                      //switch语句中可以是数值，字符串，对象；case值也可以是常量，变量甚至表达式
           case "hello":
             console.log("hello is founded");
             break;
           case "world":
             console.log("world is founded");
             break;
           default:
             console.log("nothing");
     }
     
     var i=7; 
     switch(true){                 //之所以可以传递true，因为每一个case返回的是布尔值，switch语句中比较是全等操作符，所以不会是"99"与99相等
           case i<10:
             console.log("i<10");
             break;
           case i>10:
             console.log("i>10");
             break;
           default:
             console.log("i=10");
     }

循环语句

一般来说：for循环适合已知的循环次数，while循环适合未知的循环次数。

do-while语句：后测试循环语句，这个循环至少执行一次；

while语句：前测试循环语句；

      var i=0;
      while(i<=100){
            i++                     i++一定要有的，否则这就是个死循环
      }
      console.log(i)  //101

      var j=0;
      do{
          j++
      }while(j<=100)
      console.log(j)  //101   循环至少先执行一次

计算1——100之间的和

      var sum=0;
      var summ=0;
      var n=1;
      while(n<=100){
            sum+=n;
            n++
      }    
      console.log(sum)    //5050

      for(var i=1;i<=100;i++){
              summ+=i
      }
      console.log(summ)   //5050

计算1——100之间奇数的和

      var sum=0;
      for(var i=1;i<=100;i+=2){
              console.log(i)
            sum+=i
      }
      console.log(sum)   //2500
      
      var summ=0;
      var j=1;
      while(j<=100){
            if(j%2==1){
                  console.log(j)
                  summ+=j
            }
            j++
      }
      console.log(summ)  //2500

for语句：前测试循环语句，具有初始化变量和定义循环后要执行代码的能力；由于js不存在块级作用域，所以循环内部定义的变量也可以在外部访问；

for（语句一；语句二；语句三）语句一为初始化变量，首先执行；语句二为循环的条件判断；语句三是对变量的增值，在循环代码块执行后才执行；

执行的顺序：语句一先经过语句二判断然后进入循环（这里不会经过语句三），执行循环后再执行语句三，再语句二，再进入循环

       for(var i=1;i<=100;i++){
          console.log(i)          //1——100
       }
       alert(i)                   //101

       for(var i=99;i>=1;i-=2){
         console.log(i)           //99,97……1
       }
       alert(i)                   //-1

循环的嵌套：外层循环为假，内层循环不执行；先执行外层再执行内层，直到内层为假时才返回外层执行

      for(var i=1;i<=3;i++){
             console.log(i)
             for(var j=1;j<=5;j++){
                     console.log(j)
             }
      }

for-in语句：精准的迭代语句，用来枚举对象的属性；在枚举之前检测迭代的变量值不是null或undefined

       for(var propName in window){
                 console.log(propName)
       }

label语句：添加标签，一遍将来使用

       start:for(var i=0;i<3;i++){
               alert(i)
       }

break和continue语句：在循环中精准的控制代码的执行

break语句直接退出循环，执行循环之后的代码

continue直接退出本次循环，重新执行下一次的循环

       var num=0;
       for(var i=1;i<10;i++){
                if(i%5==0){
                     break        //直接退出此次循环
                }                 
                num++
       }
       alert(num)                 //4

       var num=0;
       for(var i=1;i<10;i++){
           if(i%5==0){
               continue            //不会执行后面操作，会从循环顶部重新的开始
          }
           num++
      }
      alert(num)                   //8

注意：在分辨循环前，首先看循环的范围到底是什么，然后再看里面的代码块。break和continue会和label联合使用，从而返回代码中特定的位置，常常发生在循环嵌套的情况下

以下讨论break和continue以及label的用法：

     var numb=0;
     for(var i=0;i<10;i++){
           for(var j=0;j<10;j++){
                     if(i==5&&j==5){
                            break        //这里的break只是退出了内部循环，忽略了55,56,57,58,59，当i=6时又为正常
                     }
                     numb++
           }
     }
     alert(numb)                        //95
     
     var numb=0;
     output:
     for(var i=0;i<10;i++){
             for(var j=0;j<10;j++){
                    if(i==5&&j==5){
                            break output     //由于有label的缘故，直接退出整个大循环
                    }
                    numb++
             }
     }
    alert(numb)                       //55

     var numb=0;
     for(var i=0;i<10;i++){
           for(var j=0;j<10;j++){
                     if(i==5&&j==5){
                            continue        //这里的continue只是当i，j为5时重新下一次循环
                     }
                     numb++
           }
     }
     alert(numb)                      //99
     
     var numb=0;
     output:
     for(var i=0;i<10;i++){
             for(var j=0;j<10;j++){
                    if(i==5&&j==5){
                            continue output     //由于有label的缘故，直接退出整个大循环55,56,57,58,59直接忽略，然后重新
                    }
                    numb++
             }
     }
    alert(numb)                     //95

with语句

将代码的作用域设置到一个特定的对象中，简化多次编写同一个对象的工作；width内的变量都为局部变量，当局部环境找不到变量的定义，会从location对象的属性中查找，如果有则可以的。由于调试困难和性能下降，不建议大量使用

     var qs=location.search.substring(1);
     var hostname=location.hostname;
     var url=location.href;
                                         
     with(location){                    //由于上述代码都包含对象location，所以说用width来简化
           var qs=search.substring(1);
           var hostname=hostname;
           var url=href;
     }

基础不牢，地动山摇