JavaScript

JavaScript 数据类型:

字符串、数字、布尔、Null、Undefined 

更细分为：数组、对象、

字符串：字符串要用单引号或者双引号引起来。

数字：直接写数字不需要引号。

变量的命名规则：

1.变量名区分大小写，允许包含字母、数字、美元符号($)和下划线，但第一个字符不允许是数字，不允许包含空格和其他标点符号

2.变量命名长度应该尽可能的短，并抓住要点，尽量在变量名中体现出值的类型

3.尽量避免使用没有意义的命名

4.禁止使用JavaScript关键词、保留字（保留字是将会成为关键词的字）

5.变量名命名方法常见的有匈牙利命名法、驼峰命名法和帕斯卡命名法、下划线法

6.格式  var变量

Null类型: null->0  true->1  

undefined->NaN    NAN不能等于任何数，不能和自身比较， undefined可以和自己比较。

！写非的时候占了一个等于号位置。数字类型不能写null。

强制转换的例子:

 其他类型转换成布尔类型false的有

var test=Boolean(0);

test=Boolean(-0);

test=Boolean(NaN);

test=Boolean(undefined);

test=Boolean(' ');

test=Boolean(0.0);

test=Boolean('0');

隐式转换的例子:

其它类型转换成字符串型

document.write(undefined);//'undefined'
   document.write('<br/>');
   document.write(null);//'null'
   document.write('<br/>');
   document.write(NaN);//'NaN'
   document.write('<br/>');
   document.write(123);//'123'
   document.write('<br/>');
   document.write(true);//'true'
   document.write('<br/>');
   document.write(false);//'false'
   document.write('<br/>');
   alert(1+"1");//拼接字符串
   alert('2'+12);//拼接字符串

其它类型转换成布尔类型假的有
  var a;//undefined->false
  //typeof得到变量的类型
  //alert(typeof a);
    a=null;//null->false
    //0 0.0 NaN->false
    a=0;
    a=0.0;
    a=0/0; 
    //NaN
    a=NaN;
  //alert(Number(NaN));
   //a='';//空字符串->false
   //a='0';
   a='a';
   //alert(a==b);
  if(a){
   alert('真');
  }else{
   alert('假');
  }
其它类型转换成数值型
   var b=undefined;//undefined->NaN
   b=null;//null->0
   b=true;//true->1
   b=false;//false->0
   //alert(1+b);
   var c='12';//'12'->12
   c='3king';//'3king'->NaN
   c='true';
   //alert(2*c);
   c='33';
   //alert(typeof c);
   c=c*1;
   alert(typeof c);
通过parseInt()进行转换成整型
   test=parseInt('123');
   console.log(typeof test);   //123
   test=parseInt('234',0);
   console.log(test);   //234
   test=parseInt('0xabcdef'); （ 0x开头是16进制）
   test=parseInt('012344');
   test=parseInt(45,16); 
   test=parseInt('356k8i23ng');
   test=parseInt('true');
   test=parseInt(true);
   test=parseInt('  35  6 a ');
   test=parseInt('44.666');
   console.log(test);
  通过parseFloat()转换成浮点型（只读一个小数点）
   test=parseFloat('123.34.9abc');
   test=parseFloat('123');
   test=parseFloat('sdf');
   test=parseFloat(' 2e8a');（e是10，几个e就是10的几次方）
   alert(test);
循环：
for循环可以控制循环次数  基本格式：for(初始化变量（i=1）；条件控制（i<=5）；增量(i++)){      循环语句     }
 执行循序：1.定义一个变量　　2.判断是否符合条件　　3符合执行循环语句　　4增量自增或自减
 进阶：多层嵌套for循环   最外层循环一次  里层整套循环  以此类推
while循环
 基本格式（if  与 循环的结合） ：while(循环条件){   循环语句 }
 执行循环：1判断是否符合循环条件　2符合循环语句执行循环条件
do......while循环（无条件会执行一次循环）
 基本格式：do{ 循环语句}while(循环条件)
 执行循环：1无条件执行一次循环语句　　2判断循环条件来决定是否开始1次以后的循环
跳出循环的两个命令
 1.break　　:跳出循环
 2.contione　:跳出本次循环
 
 while(exp){        当……的时候      //when
     循环体;}
 do{
    document.write('hello meizi');
   }while(false);
   document.write('<hr/>');（先显示在判定）
条件语句：
 1.if ... else
 2.switch...case
（switch(exp){
     case 值1:
      执行的代码段;
      break;
     case 值2:
      执行的代码段;
      break;
     ...
     default:
      执行的代码段;
      break;
     严格类型比较）

 js函数：

1.函数名称严格区分大小写。

2.函数名称重复会产生覆盖。

3.（.length）控制着对象的长度（JavaScript 中的所有事物都是对象）

//实现默认参数的形式
// function calc4(x,y){  （false+false=0）
  x=x||0;
  y=y||0;
  return x+y;
 }
 function calc4(x,y){
  if(x===undefined){
   x=0;
  }
  y=y===undefined?0:y;
  return x+y;
 }
 //alert(calc4());
 //alert(calc(1,3,4));    //控制着对象的长度
 function calc(x,y){
  //return arguments;
//  alert(arguments[0]);
//  alert(arguments.length);
  x=arguments[0]?arguments[0]:0;
  y=arguments[1]?arguments[1]:0;
  return x+y;
 }
 //alert(calc());
 //alert(calc(1,2));
//可变参数形式的函数
 function test(){
  var paramsNum=arguments.length;//得到传入参数的个数
  var sum=0;
  for(var i=0;i<paramsNum;++i){
   sum+=arguments[i];
  }
  return sum;
 }
 //alert(test(1,2,3,4,5,6));
 function test1(){
  var paramsNum=arguments.length;
  var max=0;
  for(var i=0;i<=paramsNum-1;i++){
   if(arguments[i]>max){
    max=arguments[i];
   }
  }
  return max;
 }
 alert(test1(123,3432,23456,445643));（只取一个最大的值 445643）

//变量作用域  （window是最大的全局变量）
   var x=1;
   function test(){
    document.write('函数体内x的值为:'+x+'<br/>');   //undefined,x值取下面的，但是取不到值
    var x=19;
    document.write('函数体内对x重新赋值，此时x的值为：'+x+'<br/>');  //19
   }
   document.write('函数体外x的值为：'+x+'<br/>');    //1
   test();
   document.write('x的值为：'+x+'<br/>');      //1
   //document.write('<hr color="red"/>');

 

//全局变量和局部变量的区别（全局变量可以）加var是局部变量不加是全局变量
/*   function test(){
    var x=1;
    alert(x);
   }
   test();
   alert(x); //取不到变量，报错*/
   function test(){
    y=5;
    alert(y);
   }
//   test();
//   alert(y);
  var x=1,y=2;
  function calc(x,y){
   document.write('a的值为'+a+'<br/>');//undefined
   document.write('函数体内x的值为：'+x+'<br/>'); //1
   document.write('函数体内y的值为：'+y+'<br/>'); //2
   var x=0,y=6;
   z=x+y;
   x=x+y;
   var a=198;
   document.write('a的值为：'+a+'<br/>'); //198
   document.write('x的值为：'+x+'<br/>'); //6
   return z;
  }
  alert(calc(x,y));
  //alert(x+'-'+y+'-'+z);
  var a=1,b=2;
  function test1(){
   var a=5,b=10;
   return a+b;
  }
  function test2(){
   var a=11,b=22;
   return a+b;
  }
  alert(test1());
  alert(test2());
  alert(a+'--'+b);
回调函数的例子：
   function calc(x,y){
    return x()+y();
   }
   function test1(){
    return 3;
   }
   function test2(){
    return 5;
   }
   
   //alert(calc(test1,test2));
   //alert(calc(function(){return 5;},function(){return 10;}));   //匿名函数
   
   function say (value) {
       alert(value);
   }
   //alert(say);
   say('hi js.');
（call 和apply）它们的作用都是将函数绑定到另外一个对象上去运行，
alert(test1.call(test1,5,10));（call有多个参数，但是第一个参数是对象，后面都是要传的参数）
alert(test1.apply(test1,params));（apply有两个参数，第一个对象，第二个是数组）

ECMAScript 闭包:

闭包:指的是词法表示包括不被计算的变量的函数，也就是说，函数可以使用函数之外定义的变量。

例子：

 

var sMessage = "hello world";

function sayHelloWorld() {
  alert(sMessage);
}

sayHelloWorld();

创建对象：
\t 的意思是 横向跳到下一制表符位置，\n是换行
1.通过对象字面量的形式创建对象
注意：要用逗号隔开，
两种方式写：横着写，竖着写（好看）
   var obj={};//没有任何属性的对象
   //alert(typeof obj);
   var obj1={x:1,y:2,z:3};
   var obj2={
    'x':1,
    "y":2,
    username:'king',
    'for':'Javascript关键字必须放到引号之间',
    'first-name':'queen',
    married:true,
    test:null,
    test1:undefined,
    salary:12.3,
    person:{
     username:'king',
     age:12,
     addr:'北京'
    }
    
   };
2.通过new Object（）创建对象
   var obj3=new Object();//创建一个空对象,{}
   var arr=new Array();//空数组，[]
   var date=new Date();//日期时间对象
   var reg=new  RegExp('js');//创建正则对象
3.通过构造函数的形式创建对象
   function Test(){
    
   }
   var obj4=new Test();
   function Test1(num1,num2){
    this.n1=num1;
    this.n2=num2;
   }
   var obj5=new Test1(5,6);
   alert(typeof obj5);
   alert(obj5 instanceof Test1);
4.通过Object.create（）创建对象
   var obj6=Object.create({x:1});
   var obj7=Object.create(null);
创建一个普通的空对象
   var obj8=Object.create(Object.prototype　　　　

Number string


number




Js只有一种数字类型（包括整型，浮点型）




极大或极小的可用科学计数法来表示。（7.7123e+1）




所有js数字均为64位




Js所有的数字都存储为浮点型




小数的最大位数是17位




0开头的为八进制 0x开头的为16进制


//   var str='king';
//   console.log(typeof str);  //string
//   var strObj=new String('king');
//   console.log(typeof strObj);  //obj
//   console.log(strObj[0]); // 数组的第一位是k
//       console.log(strObj.length);   //4
//      console.log(strObj.valueOf());  //king  返回原始值
//      console.log(strObj.toString());  //king
//   console.log("nana"[0]);    //n
//   console.log("helloworld".length);  //10  字符串空格也计算
//   var str=String('1234');    
//   str=String(true); 
//      str=String({x:1});                   /ar obj={}; 字面量
//   str=String(null);                    //输出为空
//   console.log(str);      
//   var str='king';
   /arAt()根据下标返回指定的字符
   //console.log(str.charAt(0));           //k
//   console.log(str.charAt(1));             //i
//   console.log(str.charAt(2));             //n
   //console.log(str.charAt(3));              //g
     //console.log(str.charAt(10));              //当定义的字符串中没有第10位显示为空。和indexof 检查不到的值不一样  为-1
   /ar str='abcdef';
   /arCodeAt():返回指定字符的ASCII码值
   //console.log(str.charCodeAt(0));
   //console.log(str.charCodeAt(100));      //没有第100位 为null  没有ascii值
   //console.log(str.charCodeAt(-123));         //同理
   //fromCharCode():根据指定的ASCII放回对应的字符
//   console.log(String.fromCharCode(97));         //a
//   console.log(String.fromCharCode(65,66,67));    // ABC
   //concat()：连接字符串
//   var str='hello ';
//   console.log(str.concat('world'));
//   console.log(str.concat('world ','!'));
   //字符串搜索相关
   /ar str='this is a test';
   //console.log(str.indexOf('t'));        //0
   //console.log(str.indexOf('is'));           //2
      //console.log(str.indexOf('Is'));            //没有出来-1
   //console.log(str.indexOf('i'));           //2
   //console.log(str.indexOf('i',3));          //5      后面的3是规定字符串从第几个开始  检索 
   //通过indexOf()可以统计一个字符在指定字符串中出现的次数
//   var str='sssssdlkfjlwk34jlksdfjlksjdlf234';
//   var count=0;
//   var pos=str.indexOf('s');        //从0开始 
//   while(pos!=-1){
//    count++;
//    pos=str.indexOf('s',pos+1);
//   }
//   console.log(count);
   //lastIndexOf():最后一次出现的位置
   /ar str='this is a test';        
   //console.log(str.indexOf('is'));     //2
   //console.log(str.lastIndexOf('is'));   //5
   //比较两个字符串
//   console.log('h'.localeCompare('j'));//-1       j的ascii码为106   后面大的取反值
//   console.log('z'.localeCompare('a'));//1         后面的值小为正值
//   console.log('a'.localeCompare('a'));//0           相等
//   console.log('b'.localeCompare('B'));//1       后面的值小为正值
   //match():找到一个或多个正则表达式的结果
   /ar str='this is a test of king show time';
   /ar re=/IS/i;
   //console.log(str.match(re));         //index 为下标从1开始
      /ar str='QWERTYUIOPASDFGHJKLZXCVBNMqwertyuioasdfghjkzxcvbnm';
   //console.log(str.match(/[a-f]/ig));    //i 是不分别大小写   g是全局
   /arch():根据正则表达式进行搜索
   /ar str='this is a test';
   //console.log(str.search(/is/));
   //console.log(str.search(/IS/));   和indexof()没有为-1
      //console.log(str.search(/IS/i));
   
   /ar str='this is a test';
      /ar newStr=str.replace(/IS/ig,'!');    //两个is都替换
       // console.log(newStr);
     // var str="2015-09-26";
   /ar newStr=str.replace(/(\d{4})-(\d{2})-(\d{2})/,"$2/$3/$1");   //查找数字然后在按$顺序排列
   //console.log(newStr);
   
   /ar str="2015-09-25";
   /ar newStr=str.replace(/(\d{4})-(\d{2})-(\d{2})/,func);
   //function func(match,d1,d2,d3){
   ///return [d2,d3,d1].join('/');
   //}
   //console.log(newStr);
   
   //截取字符串
  /ar str='abcdef';
   //console.log(str.slice(2));
   //console.log(str.slice(0,2));    //2结束时不读
   //console.log(str.slice(-3));         //-3开始
   //console.log(str.slice(-4,-2));      //-2 左开右闭
   //console.log(str.slice(0,-1));
   //console.log(str.substr(3));
   //console.log(str.substr(0,4));  
   //split()将字符串拆分成数组
   /ar str='2015-08-12';
      /ar arr=str.split('-');
  //    console.log(arr);
  /ar str='a b c d e f';
//   var arr=str.split(' ');
//   console.log(arr);
   //arr=str.split(' ',2);   //出来是a b
   //console.log(arr);
   
   //字符串大小写相关
//   console.log("KING".toLowerCase());   //小写
//   console.log("KING".toLocaleLowerCase());   //本地小写
//   console.log('nana'.toUpperCase());
//   console.log('nana'.toLocaleUpperCase());
   
   //trim()        //移除字符串两侧的空格
   /ar str=' abc ';
   //alert("!"+str+"!");
   //alert("!"+str.trim()+"!");
   //产生锚点
   /ar str="this is a test";
    // document.body.innerHTML=str.anchor('contents_anchor');   //写进body的html里面
   //<a name="contents_anchor">this is a test</a>
   //产生链接
        /ar title='this is of king show time';
   /ar url='http://phpfamily.org';
   //document.write('Click Me to Visit My Blog'+title.link(url));


Math（算数）对象：


  console.log(Math.E);   //返回算术常量 e，即自然对数的底数（约等于2.718）。
  console.log(Math.PI);   //返回圆周率（约等于3.14159）。
  console.log(Math.abs(-12));  //绝对值   12
  console.log(Math.ceil(12.3));  //向上取整  13
  console.log(Math.floor(14.8));   //向下取整 14
  console.log(Math.round(1234.5678)); //取整数四舍五入  1235
  console.log(Math.pow(2,3));     //2的3次幂    x 的 y 次幂。
  console.log(Math.sqrt(4));   //返回数的平方根
  console.log(Math.ceil(Math.random()*10));  //1-10的随机数        random  0-1之间的随机数不包括0和1
  console.log(Math.max(12,3423,45345,6435655345));    //最大的数   6435655345
  console.log(Math.min(-234,23,2346,324536));   //最小的数   -234


正则表达是：（var patt1=new RegExp("e");）：


例子：var patt1=new RegExp("e");

document.write(patt1.test("The best things in life are free"));　　（如果有显示trun如果没有显示flase）


例子：var patt1=new RegExp("e");


document.write(patt1.exec("The best things in life are free"));  （写一个数字，这串字符里面有将显示出来。）


例子：




var patt1=new RegExp("e","g");


do
{
result=patt1.exec("The best things in life are free");
document.write(result);
}                           //写出这串字符串里的所有个数，没有的会显示出null





　　　　　　　　^       表示匹配输入的开始


                           $      表示匹配输入的结束


                           *   一个表达式的多次或0次


                           +       匹配前面一个表达式一次或多次


                           ?   匹配前面一个表达式0次或者一次  ？？？


                           .        匹配除换行符之外的任何单个字符


                                    [abc] 查找方括号之间的字符


                                    [^abc] 查找不在方括号之间的字符


                                    （a|b|c） 查找任何指定选项


                                    \w 查找单词字符


                                    \W 查找非单词字符


                                    \d 查找数字字符 \D 查找非数字字符 


                                    \s 查找空字符   \S 查找非空白字符


数组：


有两种向数组赋值的方法（你可以添加任意多的值，就像你可以定义你需要的任意多的变量一样）。


1.var mycars=new Array()
mycars[0]="Saab"
mycars[1]="Volvo"
mycars[2]="BMW"


var mycars=new Array(3)（也可以使用一个整数自变量来控制数组的容量）
mycars[0]="Saab"
mycars[1]="Volvo"
mycars[2]="BMW"


2.var mycars=new Array("Saab","Volvo","BMW")（如果你需要在数组内指定数值或者逻辑值，那么变量类型应该是数值变量或者布尔变量，而不是字符变量。）


document.write(mycars[0])


输出（saab）


修改：


mycars[0]="Opel";


现在，以上代码：


document.write(mycars[0]);


将输出：（Opel）


 var arr=[];
   arr[0]='a';
   arr[1]='b';
   arr.shift();    //开头删除
   arr.push('d','e','f',12,34);  //尾部添加
   console.log(arr);
   
   
   var res=arr.pop();     //尾部删除
   console.log(res);
   console.log(arr);
   arr.unshift(1,2,3,4,5);    //开头添加
   console.log(arr);
   
   
   
   res=arr.shift();
   console.log(res);
   console.log(arr);
   
   var arr=['a','b','c','d'];
   delete arr[0];   //位置保留
   console.log(arr);
   console.log(arr.length);


 


 


 


 









	

	
posted on 
2018-08-20 18:03 
听风说爱你 
阅读(119) 
评论(0) 
 
收藏 
举报










    
    

    
    

    

        

    

        

            
                
                
            
        

    

    
    

    

    







	


    博客园  ©  2004-2026


    浙公网安备 33010602011771号
    浙ICP备2021040463号-3