JS-2

var a;
var _;
var $;
var o0_00;
var a123;
var var;// 错误
var ~=aa;

                console.log(i);

* 变量名
组成部分: _ $ 字母 数字
第一个字符不能为数字
区分大小写 比如 a 和 A 是不同的变量名
不能是js的关键字和保留字

            

var 变量名;

            document.onclick();

变量
1 “未知数”,本质上相当于一个容器,可以存放任何的数据

                var texts=document.querySelectorAll(“input[type=text]”);

2 语法
// 变量定义
var a;
// 给变量赋值
a = 456;

十六、作用域

* 赋值

先定义后赋值
var a1;
a1 = 123.56;// 把123.56赋值给左边变量a1

// 定义同时赋值

var a1 = “alongQQ382867197”;
alert(a1);

var a = 10, b = 20, c = 30;
console.log(a+b+c);
var d;
console.log(d); // 不是错误 而是undefined 表示变量定义 但没有赋值
console.log(e); // e is not defined 报错 表示变量没定义就使用 语法报错

3 变量声明提升
console.log(a); // undefined
var a = 10;
console.log(a); // 10
原因
浏览器js引擎会把变量a的定义提升到所有语句之前 等价于下面
var a;
console.log(a); // undefined
a = 10;
console.log(a); // 10

4 数据类型

基本数据类型:Array,Boolean,Date,Math,*Number,*String,***RegExp,*Global
(8个)**

 

5 变量的数据类型
var b = 123;
b = “123”;
alert(typeof b); // string

* 变量的数据类型由存储的数据类型决定

* 数据类型转换
数字转成字符串
23+”10″ 先把23变成”23″,然后与”10″拼接成”2310″
23+”” —–>”23″

parseInt(12.99); //12
parseInt(“123”); //123
parseInt(“12.99”); //12
parseInt(“12xxx”); //12
parseInt(“xx12”); //NaN

按 X 进制解析  parseInt(“”,X);

parseInt(“10”,2);  //2

/****************/

parseFloat() 和上面等同,不赘述。

/****************/

prompt 框中输入的内容都会变成字符串。

 

             *     2、实参  (也具备数组的特性,arguments)

             *             false    假

            console.log(a==b);    //true

                 *             &&    并且的意思

            console.log(String(num));    //12

             *         1、Undefined转字符串

 九、while              

            console.log(isNaN(n));        //true

                    

             * 

             *         操作对象用的方法就是属性的方法

                                                 //undefinded是有存在,只是没有给值,而Null代表是不存在的意思、

                        var s5=”It ‘s me”;

            var s2=’ 100px’;

             *     一、基本(简单)数据类型(有五种)

             /*         2、Null

             * 系统定义的数据类型                typeof返回的数据类型

                    

                   var a=1;

             *     isNaN()传进来的值,如果是一个数字的话,那它就返回一个false

 
   想取所有的值,数组可以用for也可以用for in
,但是对象只能用for in 

             *             转数字的结果为0

             /*

            console.log(typeof u);        //undefined

                        //console.log(c);    //报错,因为只会往上面找

             */

             * 查找规则

             *         var 变量

                console.log(‘成立’);

                        //var s5=’学辉”;        //报错

                console.log(attr,person[attr]);

             *         1、Undefined转布尔值

          3. 赋值运算符(在前面的值的基础上与后面的值进行运算,并把得到的值重新赋给前面的值)

            var n4=12;

                    continue;    //当循环到第3次的时候,这次的循环不会走,会跳到下一次的循环

             *     如果一个函数需要用到一个变量,那它会先在自己的作用域里去找这个变量。如果自己有那它就直接使用自己的,如果自己没有,那它就会一层一层往外找,直到找到外面的变量,找到后就用外面的变量

             *             注意:函数表达式里的function后面如果有名字的话,在调用的时候是不能拿这个名字去调用

                        var b1=true;

               
 

                 * e=e+1;

            console.log(parseInt(s5));        //123

                    console.log(Number(nul));    //0

             *             1、变量(参数)

                        var b2=false;

                

             * 

                        return getComputedStyle(arguments[0])[arguments[1]];

             *         1、Undefined    

            /* b=b+a*/

            console.log(”-1);        //-1

             *             如果说不是一个纯数字,那结果就是NaN

                    var nul=null;

                        console.log(b1);        //true

             */

            var o={left:10};

             *             + – * /

                        console.log(btn);    //null   因为还没有有写HTML

             */

             *  –放在前面,先把自己加个1然后赋给另一个变量,然后自己再减个1

                        var s1=”;

             * 

             * 

               /*

            console.log(Boolean(nul));    //false

             *             有且只有一个值null

                console.log(name);

            

                    

             *     局部:函数范围

                    var result=0; 

七、switch

             *     

             *     注意:局部变量与局部函数只能在声明它们的地方用,在其它的地方是用不到的

                        console.log(s1);        //a

             *         5、String转字符串

                    

                        language:[‘汉语’,’日语’,’英语’]

                console.log(css(box,’height’));   

             * 

             *         语法

                        console.log(u1);        //undefined

             * 

                           }

            var s1=’kaivon’;

             * 

            var n2=3;  

            console.log(Boolean(s3));    //true

            }

                        var s3=”;

            var s2=”;

             *                 not a number

             *         return 值(值要和return在同一行)

                i++;

      

            var s3=’px100′;

                height:’180cm’,

                case 1:

             *         格式:由简单数据类型与复合数据类型任意组合而成的。它的数据是放在一对大括号当中,每个数据由一个键值对组成的,数据可以是0个也可以是多个,每个数据之间用逗号隔开,最后一个数据不能加逗号(如果加了逗号,那就会报错)

             *     !==        只有当两个数据类型不同,值不同才会返回true

             *             字符串里的内容是不是一个纯数字,如果是个纯数字的话,就转成对应的数字

             *             2、把函数声明变成函数表达式,在后加个一对小括号

                            //找到自己想要的东西就不走了。

                 * f=e+1;

                   getComputedStyle        获取计算后的样式集合

                        console.log(s2);        //kaivon

             */

            

 
           
最终的结果是49,但是这个运算结果不会输出,因为没有return

                            console.log(b);        //15

             *             有且只有一个值undefined

             */

             *             2、直接在后面加上一对小括号(不能换行到下一行写)

             *         调用

             *         6、Object

             */ 

                fn4();

                        height:’180cm’,

             *             2.NaN

       
     /*

             *     !=        比较的是两个值是不相同,如果两个值不相同的话返回true,相同的话返回false

             *  

             * 要做循环的时候,首先考虑for,如果for做不出来,那就选择用while

             *     如果不确定先算谁,那就给要算的内容加上小括号,提高它的优先级.

                    var person={

                    

            }

             *             var 变量=function(参数){

            console.log(1+’a’);        //1a

             *             1、函数名(参数)

                    

            console.log(parseInt(s3));        //NaN

             *                 当这个值与变量的值相同的时候,才会走这里的代码

             *             }

                    }

            }

                    alert(1);      
//这里是弹不出,因为放在了return后面。

             *         字符串

             *             case 值:

            var b=’10’;

            

             */

             */

     
二、局部作用域

 

                 */

             *         当条件满足的时候,会循环执行这里的代码

                        //说明现在传了两个参数,获取元素的属性值

                        var s3=’kaivon’;

             *         函数(函数声明,不是函数调用)可以嵌套的,嵌套的函数(局部函数)可以访问父函数里的内容

             *             true        真

                    break;

             *     关系运算符会把结果转成布尔值

      * ++    递增

             *         2、数字        Number

             *         通过一些方法,很明确的将某种数据类型转换为另一种数据类型

            var u=undefined;

            var b=true;

                var name=’kaivon’;

            console.log(typeof b);        //boolean

             *     + 加、- 减、* 乘、/ 除、c 取模(求余数)、++、–

             * 运算符优先级

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

               //形参不写,也不会影响实参

           
                       f=10; 
       

             *             转为对应的值

六、运算符

                        console.log(b2);        //false

            /*

             *     <、>、<=、>=、==、!=、===、!==

                        console.log(s4);        //空格字符串

                        age:30,

            var n=NaN;

            var e=’20’;

         3.把类型转为字符串–就是在外面加多一个引号

 
  2递增递减

             *     代表了所有的实参集合(类数组)

                        drive:true,

             *             放在一对单引号或者双引号里,由0个或者多个字符组成的串

                }

            console.log(Boolean(u));        //false

             /* 

             *     –放在后面,先把自己赋给另一个变量,自己再减1

             *     2、隐式类型转换

            };

             *     ===        首先先比较两个值的类型,如果说类型不同,那直接返回false

                    var o1=[];

            var s3=’ ‘;

                  console.log(attr,color[attr]);

             *     之所以全局变量在任何地方都可以访问到,是因为全局变量它是window下的属性

             *     用来做判断的,根据一个变量的值,做不同的事情

<script>

            var d=20;

 
     
  
   <input type=”button” id=”” value=”按钮一” />

                        var s2=’ ‘;

 

             * 类型转换分为两种

             *             case 值:

            switch(n){

            var f=e>0?10:20;

            var s=’kaivon’;

 
                     
 color[attr]显示的就是下标数对应的值。

                    

 
 

                console.log(e);    //2

                        var s5=’12a’;

          2.字符串转数字            

                age:30,

            var n2=NaN;

                }

             *     判断一个值是不是NaN,它会先把参数用Number()方法转一下

             *     检测一个数据的类型,返回这个类型对应的字符串(全小写)

            function add(){

             *                 把函数声明变成函数表达式的方法,在函数声明的前面加上+ – ! ~ ()

         
 }

             *  +=的意思是在原有的基础上再加

             *     Number(要转换的值)    把任意类型都转为数字

             *     如果a的值为真,返回b,否则返回c

                        console.log(s6);        //It ‘s me

            while(i<5){

             *         1、所变量或者函数放在函数外面声明

            console.log(d!==c);    //true

 

             *         5、String转布尔值

            
    *         如果当左边与右边的条件同时成立的时候,整个条件才成立

            

            console.log(String(nul));    //null

                }

             * 

             *     声明局部作用域的方法

                alert(‘成立’);

             *             Number()、parseInt()、parseFloat()        明确将数据转数字类型

            var nul=null;

             *     注意:作用域链会一层一层往外找,不会往里面找(儿子能找到爸爸的,但是爸爸不会找儿子的)

             *     这个集合中的每个数据都有一个自己对应的下标

             *                 要执行的代码

             *     x+=y

             * 如果只操作自己

             *         布尔值

            var n1=10;

             *             

                    var o2={};

            

                var age=undefined;*/

十三、arguments

     5.逻辑运算符    (一般用作条件运算里面做判断)      

                    //这个就是复合对象数据,可以自己定义这个对象里面的许多东西

                        console.log(Number(s6));        //NaN

                    function fn5(){

             *                 break;    停止以下代码继续执行

                    if(arguments.length==3){

             /*         3、布尔值    Boolean

             */

             *     如果参数的结果为NaN,那它返回一个true

             /*         4、未定义    Undefined

             * 

            console.log(d!=e);    //false

                            var n2=23.56;

             *     取模的时候,如果前面的数字比后在的数字小,那得到的结果就是前面的数字

             *         实参必需与形参一一对应,在调用函数的时候,要把实参传够数量。如果有一个实参没有传,那它的值就是undefined

             *             }

            

            var nul=null;

                var result=0;

                2.

             *             0、NaN转布尔值的结果为false,其它的转布尔值的结果为true

            var s1=’100px’;

             *         3、Number转字符串

                    var u=undefined;

                        var s6=’It \’s me’;

             *  !的意思是反

                    console.log(person[‘girl-firend’]);        //null

                    };//其实写法是数组一样,最后一个是不需要逗号的

             * 语法

             *         2、Null转字符串

             */

                console.log(name);

            var b=2;

             *             

            console.log(Boolean(n3));    //true

             *                 value    数据对应的值,这个值可以是简单数据类型也可以是复杂数据类型

             *             false

             *                 当这个值与变量的值相同的时候,才会走这里的代码

             *     =、+=、-=、*=、/=、%=

            

            }

 
         
   }

             * 语法

             *     这个集合还有一个length,代表了实参的个数

             *     1、函数声明

             *     x=x+y

             * 把字符串转成数字

            //null的typeof的结果是object,

                            var c=28;

             *                 如果说字符串里面有引号,外在的引号一定要与里面的引号相反

             * while

 

             *     返回的结果与系统当中定义的类型是有区别

     
 1.     function fn(name){

            console.log(Boolean(n1));    //false

二、检车数据类型的方法—typeof

             *                 引号是成对出现的

            console.log(Boolean(n2));    //false

            console.log(String(b1));        //true

            /*

             *     它是一个运算符

                /*var name=undefined;

            fn3();

             * break

                    console.log(‘今天是星期二’);

             * 

                 */

                

             * return
 (函数内凡是有运算并且要输出这个运算结果的就用return)

             *             结果也是给对象加上引号

            var u=undefined;

             *         如果函数里没有return,那这个函数的返回结果就是undefined

             *         6、Object转字符串

 

                /*

                ++a;  //这个意思就是操作符在后面

            var a=1;

             */

                }

             *     1、显式类型转换 —–我们自己认为操作的。

             *         4、Boolean转布尔值

             */

                        arguments[0].style[arguments[1]]=arguments[2];

             *             false转字符串的结果为’false’

            for(var i=0;i<5;i++){

             * 注意:尽量避免使用全局变量,声明变量的时候一定要加var

                                  f=20;
     

             /* ++放在前面,先把自己加个1然后赋给另一个变量,然后自己再加个1

            var i=0;

四、类型转换分类、

             */

            console.log(b);        //3

                        

            console.log(parseInt(s1));        //100

            console.log(5%0);    //NaN             7%5        2

 
                       这里的person[attr]
会显示所有属性名所对应的值。

             *             键值对:key:value

                        weight:’90kg’,

             *     它具有一个功能是用来检测数字的,但是它的本意并不是用来检测数字的

                name:’老王’,

            

             *             falae    转数字的结果为0

             *                 当以上变量都不满足的时候,会执行这里的代码

             *     声明全局作用域的方法

                        fn6();

            for(var attr in person){

             * arguments对象

             *         

   
 *     停止循环,只不过它停止的是当次的循环,后面的循环还是会走

             *     String                            string

                var age=2;

            console.log(false-true);    //-1        减号的作用就是数学上的减法运算,会把两边都转成数字

             * 

             * 如果操作别人(有赋值给其它变量)

            

                var e=1;

         
      default:

             *         2、变量不用var声明,直接给变量赋值

                console.log(f);    //2