JavaSript语法 定义变量方式

苦恼人的偷笑

JavaSript语法一.  定义变量方式
1.隐式定义变量
    a  = "Hello JavaScript";     //js为弱类型语言，可以不用声明数据类型
2.显式定义变量
    var b = "Hello JS";            //显示定义变量使用关键字“var”进行修饰
注意： javaScript是区分大小写的

二.类型转换
1.自动类型转换
        /**
         *    对于减号运算符，由于字符串不支持减法算术运算，所以系统自动将
         *  字符串转换为数值；
         *  对于加号运算，因为字符串加号作为连接符，所以系统自动将数值转换
         *  为字符串进行连接运算。
         */
        //定义字符串变量
        var a = "3.145";
        //让字符串遍历执行算术运算
        var b = a -2;
        alert("这里减号执行算术运算"+b);
        var c = a+2;
        alert("这里加号执行的是字符串连接"+c);
   
强制类型转换函数
toString() 将布尔值、数值转换为字符串,转换结果为Object
parseInt() 将布尔值、数值转换为整形
parseFloat() 将布尔值、数值转换为浮点数

三。变量

     //定义全局变量
        var test = "全局变量";
        function checkCode()
        {
            /**
             *输出结果为undefined,因为局部变量覆盖了全局变量且作用范围为整个函数内，
             *当输出语句执行时局部变量尚未赋值，所以输出undefined
             */
            alert(test);
            var test = "局部变量"
            
        }
        checkCode();

四.字符串类型的操作
         //大小写转换
        var a = "afsdfadsfsdfjsdjf";
        alert(a.toUpperCase());
        var b  = "asdjlAdsjlAJIAJLJ"
        alert(b.toLowerCase());
        
        //获取指定索引处的值
        alert(a.charAt(2));

        //返回索引处执法的unicode值
        document.writeln("返回索引处执法的unicode值"+a.charCodeAt(2)+"<br/>");
        //将unicode值转换为字符串的静态方法
        var unicode = a.charCodeAt(2);
        document.writeln("将unicode转换为字符"+String.fromCharCode(unicode)+"<br/>");
        //indexOf和lastIndexOf
        var str = "adsfdasfasdsfjjwoejflsnaf";
        //返回字符第一次出现的顺序
        document.writeln("第一次出现位置"+str.indexOf("a")+"<br/>")
        //返回字符最后一次出现的顺序
        document.writeln("最后一次出现位置"+str.lastIndexOf("a")+"<br/>");
        //返回字符串的某个子串substring()slice()<支持负数>
        var tt = str.substring(0,3);
        document.writeln("sunString()取字串"+tt+"<br/>");
        //slice()
        document.writeln(str.slice(-2,3));
        document.writeln("slice()取字串"+str.slice(-2,-1)+"<br/>");

        //字符串连接和替换
        var a1 = "abb";
        var a2 = "bcs";
        document.writeln("连接"+a1.concat(a2)+"<br/>");
        document.writeln("替换"+a1.replace('a','c')+"<br/>");


        //match()和search()都支持使用正则表达式作为字串
        //match()返回匹配的子字符串,serarch()返回字串匹配的索引值
        var mail = "*#sa@163.comsdfjo";
        document.writeln("match()返回匹配子串:"+mail.match(/\w{1,5}@\d{1,4}\.[com|cn|net]{1,4}/)+"<br/>");
        document.writeln("search()返回匹配子串索引:"+mail.search(/\w{1,5}@\d{1,4}\.[com|cn|net]{1,4}/));

五。 正则表达式
正则表达式的“通配符”
   
频率修饰符

字符	说明
?	0次或一次
*	0次或多次
+	一次或多次
{m,n}	最少出现m次，最多出现n次

六。复合类型

javascrip大致有三种复合类型：
1.   Object：对象
2.   Array ：数组
3.   Function：函数

Object ：对象
      对象是一系列命名空间和函数的集合。其中的命名空间可以是基本数据类型，也可以是复合类型。对象中的变量成为属性，
而对象中的函数成为方法。例如，下面利用对象访问属性获取里浏览器的版本:
     var version = navigator.appVersion;
     document.writeln("浏览器的版本为："version);
javaScript提供下面常用内置对象:
Array：数组类
Date：日期类
Error：错误类
Function：函数类
Math：数学类，包含常用数学运算方法
Number：数值类
Object：对象类
String：字符串类

数组：
/**
      *数组的三大特征
      *JS数组长度可变
      *数组内元素可以互不相同
      *访问数组不会出现越界，范围为赋值数组元素时，该元素值为undefined
      */
  //定义数组的三种方式
     var a = [12,23,53,21];  //数组直接复制
     var b = new Array();    //声明一个空数组
     var c = [];            //声明一个空数组
//直接给数组赋值
     for(var i = 0;i<10;i+)
     {
        b=i;
     }

函数：

1.局部函数

/**
       *局部函数，外部函数调用局部函数不能获得执行的机会
      */
      function out()
      {
        document.writeln("全局函数<br/>");
        function inner1()
        {
            with(document)
            {
                writeln("局部函数1<br/>");
            }
        }
        //调用局部函数1
        inner1();
        function inner2()
        {
            document.writeln("局部函数2<br/>");
        }
        //调用局部函数2
        inner2();
      }
      //这里调用全局函数
      document.writeln("调用全局函数<br/>");
      out();
      //外部函数范围局部函数报错
     //   inner1();

2. 匿名函数

   //定义匿名函数
        var fun = function ()
        {
            with(document)
            {
                writeln("匿名函数");
            }
        }

        //调用匿名函数
        fun();

3.函数和类

/*
     *函数（Function）不仅是函数，更是一个类,调用函数有两种方法
     */

     //匿名函数
     var fun = function()
     {
        this.a = "实例属性";
        var b = "局部变量"
        
        //为该函数定义一个实例方法
        this.info = function()
        {
            document.writeln("调用了匿名函数的实例方法");
        }
        //return放在函数执行语句最后
        return "匿名函数返回值";
     }
     //直接调用函数，返回return值
     var r = fun();
     document.writeln(r+"<br/>");
     //new 函数返回该函数的对象
     var obj = new fun();
     document.writeln(obj+"<br/>");
     //利用返回对象范围函数实例属性
     document.writeln(obj.a);
     //下面语句范围局部属性出错
     // document.writeln(obj.b);

     //调用匿名函数返回
     obj.info();

4.函数实例属性和静态属性
/**
       *局部变量：函数中用var修饰的变量
       *实例属性：函数中用this修饰的属性
       *静态属性: 函数中用函数名修饰的属性
       *下面是例子：
       */
       var fun = function()
       {
        //定义局部变量
        var a = "局部变量";
        //定义实例属性
        this.b = "实例属性";
        //定义静态属性
        fun.c = "静态属性"
        //定义实例方法
        this.d  = function()
        {
            with(document)
            {
                writeln("aaaaaaaaaaaa");
                writeln("bbbbbbbbbbbbbbb");
                writeln("ccccccccccccccc");
            }
        }
       }

       //范围函数属性
       var obj = new fun();
       //访问实例属性
       alert(obj.b);
       //访问静态属性
       alert(fun.c);
       //调用实例方法(引用)
       alert(obj.d);
       //调用实例方法(执行)
       alert(obj.d());


       /*
        * 为对象obj动态添加属性(不覆盖原有属性)
        */
       obj.student = "cxb";
       alert(obj.student);
       alert(obj.b);

5.基本类型和复合类型的参数传递
/**
         *基本类型值传递模式（变量a本身并未传入函数内，传入的仅是变量a的副本）
         */
         var fun = function (b)
         {
            b = 5;
            document.writeln("基本在函数类重新赋值为："+b+"<br/>");
         }

        var a = 10;
        document.writeln("基本传递前："+a+"<br/>");
        fun(a);            
        document.writeln("基本传递后："+a+"<br/>");

        /**
         *复合类型值传递模式（对象persion的副本传入函数并赋值为null）
         */
            
         //使用JSON定义一个
         var persion = {
            name : "cxb",
            age : 23,
            gender :"man"
         }
         //定义一个函数，传入persion
         var oo = function (persion)
         {
            persion = null;
         }

         //传递前
         document.writeln("传递前"+persion.name+"<br/>");
         oo(persion);
          //传递后
         document.writeln("传递后:"+persion.name);

6.为函数动态添加方法和属性
var fun = function()
    {
        document.writeln("调用fun函数");
    }
   
    //为fun函数添加方法
    fun.prototype.process = function()
    {
        document.writeln("为函数添加的方法");
    }
    //为fun函数添加对象
    fun.prototype.objs = {
        name : "cxb",
        age : 23,
        gender : "man"
    }

    //调用
    var obj = new fun();
    obj.process();
    var objs = obj.objs;
    //遍历输出对象
    for(p in objs)
    {
        alert(objs[p]);
    }

7.创建对象的两种方式
//创建对象有两种方式1.直接new Objecr 2.JSON

    //直接new Object

    var person = new Object();
    person.name = "cxb";
    person.age = 18;
    person.gender = "男";

    for(p in person)
    {
        document.writeln(person[p]+"<br/>");
    }

    //采用JSON创建对象数组

    var obj = {
        name : "cxb",
        age : 18,
        gender : "男",
        fav : [
        {
         name : "北京",
         age : "上海",
         gender : "广州"
        }
        ,
        {
            name : "北京",
            age : "上海",
            gender : "广州"
        }
        ]
        ,
        psw : "123456"
    };
   
    for(c in obj)
    {
        
        if(obj[c] instanceof Object)
        {
            for(ct in obj[c])
            {
                var oo = obj[c];
                var oot = oo[ct];
                if(oot instanceof Object)
                {
                    for(t in oot)
                    {
                        document.writeln(oot[t]+"<br/>");
                    }
                }
               
            }
        }else
        {
            document.writeln(obj[c]);
        }
        
    }