JavaScript入门

发表于 | 分类于 | 阅读次数:

概述

Js 是基于对象和事件驱动的脚本语言，主要应用在客户端

  • 特点：
    • 交互性（他可以做信息的动态交互）
    • 安全性（不允许访问本地硬盘）
    • 跨平台性（只要有可以解析 Js 的浏览器就可执行，与平台无关）

区别（Java）

  • 它们分别是不同公司的产品
  • Js 基于对象，Java面向对象
  • Js 只需解释就可执行，Java需先编译为字节码文件，再执行
  • Js 弱类型，Java强类型

结合（HTML）

  • Js和html相结合的方式：
    • 1、将 Js 代码封装到 <script> 标签中。
    • 2、将 Js 代码封装到 Js 文件中，并通过 <script> 中的src属性进行导入。
  • 注意：如果 <script> 标签中使用src属性，那么该标签中封装的 Js 代码不会被执行，
  • 所以通常导入 Js 文件都是用单独 <script> 来完成
1
2
3
4
5
6
7
<!--导入一个js文件-->
<script type="text/javascript" src="demo.js"></script>

<!--封装javascript代码。-->
<script type="text/javascript">	
    alert("hello javascript");
</script>

语法

通用内容

通常高级程序设计语言所包含的语法内容：

  • 1、关键字:该种语言中被赋予了特殊含义的单词。
  • 2、标示符:用于标示数据和表达式的符号。通常可以理解为在程序中自定义的名称。比如变量名，函数名。
  • 3、注释:注解说明解释程序。用于调试程序。
  • 4、变量:用于标示内存中一片空间。用于存储数据，该空间的中的数据是可以变化的。
    • 什么时候使用变量，当数据不确定的时候。
  • 5、运算符：可以让数据进行运算的符号。
  • 6、语句:用于对程序的运行流程进行控制的表达式。
  • 7、函数:用于对功能代码进行封装，便于提高复用性。
  • 8、数组:对多数据进行存储，便于操作。就是传说中容器。
  • 9、对象:只要是基于对象的语言，或者是面向对象的语言，就存在着对象的概念，对象就是一个封装体。
    • 既可以封装数据有可以封装函数。
  • 这些都是高级程序设计语言具备的共性内容，只不过各种语言对这些内容的表现形式有所不同,
  • 但是使用基本思想是一致。

变量

  • Js 中定义变量，使用到关键字 var
  • 定义变量，Js是弱类型的
1
2
3
4
5
6
7
8
9
<script type="text/javascript">	
    //var不写也行，因为js是非严谨的语言，但是我们开发的时候建议都按照严谨的方式来定义。
    var x = 4；
    x = "abc";//重新赋值为字符串abc。
    x = 3.45;//赋值为小数。其实也是数字类型。
    x = true;//赋值为boolean类型。
    x = 'c';//赋值为字符串c。
    alert("x="+x);//这是一个函数，将具体的参数通过对话框进行显示。
</script>

运算符

  • 算术运算符
    • + - * / % ++ –
  • 赋值运算符
    • = += -= *= /= %=
  • 比较运算符：运算的结果要么是false要么是true。
    • > < >= <= != ==
  • 逻辑运算符：用来连接两个 Boolean 型的表达式
  • 位运算符
    • & | ^ >> << >>>
  • 三元运算符
    • ? :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<script type="text/javascript">
    //1、算术运算符演示。
    var a = 3710;
	alert("a="+a/1000*1000);//a=3710;
			
    var a1 = 2.3,b1 = 4.7;
    alert("a1+b1="+(a1+b1));//结果为 7

    alert("12"-1);//11
    alert("12"+1);//121
    alert(true+1);//2  因为在js中false就是0，或者null，非0，非null。就是true。默认用1表示。
    alert(2%5);//2
			
    var n = 3,m;
    m = n++;//若该句为 m=++n n=4,m=4	
    alert("n="+n+",m="+m);//n=4，m=3

	// 2、赋值运算符
    var i = 3;
    i = i+2;
    i+=2;
    alert("i="+i);

    // 3、比较运算符。
    var z = 3;
    alert(z!=4);
	
    // 4、逻辑运算符。
    var t = 4;
    alert(t>7 && t<6);
    alert(!true);// ！t false

    // 5、位运算符。
    var c  = 6;
    alert(c&3);//2

    alert(5^3^3);//5

    alert(c>>>1);//6/2的1次方;
    alert(c<<2);//24

    //6，三元运算符。	
    3>0?alert("yes"):alert("no");
    alert(3>10?100:200);
			
</script>

细节

  • undefined：未定义，其实它就是一个常量
1
2
3
4
5
6
7
8
9
10
11
12
<script type="text/javascript">
    var xx;
    alert(xx);//undefined
    alert(xx==undefined);//true 可用于健壮性判断

    //要想获取具体的值的类型。可以通过typeof来完成。
    alert(typeof("abc")=='string');//string
    alert(typeof(2.5)=='number');//number//判断类型。
    alert(typeof(true));//boolean
    alert(typeof(78));//number
    alert(typeof('9'));//string
</script>

语句

  • 顺序结构
  • 判断结构 代表语句：if
  • 选择结构 swich
  • 循环结构 while do while for
  • 其他语句 break continue:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<script type="text/javascript">

	//判断结构
	var x = 3;
    if(4==x){	//建议将常量放左边。以报错来修正代码。
        alert("yes");
    }else{
        alert("no");
    }

    //选择结构。
    var x = "abc";
    switch(x){
        case "kk":
            alert("a");
            break;
        case "abc":
            alert("b");
            break;
        default:
            alert("c");
            break;//省略。
    }
					
    //循环结构。
    var x = 1;
    document.write("<font color='blue' >");
    while(x<10)
    {
        //				alert("x="+x);
        //将数据直接写到当前页面当中。
        document.write("x="+x+"<br/>");
        x++;
    }
    document.write("</font>");
	
    for(var x=0; x<3; x++){	//别用int
        document.write("x="+x);
    }
			

    w:for(var x=0; x<3; x++){
        for(var y=0; y<4; y++){
            document.write("x==="+x);
            continue w;//跳出当前循环。
        }
    }
			
</script>

练习

  • 99乘法表，加上样式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=GBK">
		<title>Untitled Document</title>
		<link rel="stylesheet" href="table.css"/>
	</head>
	<body>
		
		<script type="text/javascript">
			document.write("<table>");
			for(var x=1; x<=9; x++){
				document.write("<tr>");
				for(var y=1; y<=x; y++){
					document.write("<td>"+y+"*"+x+"="+y*x+"</td>");
				}
				document.write("</tr>");
			}
			document.write("</table>");
		</script>

	</body>
</html>

数组

  • 数组用于存储更多的数据，是一个容器。
  • 特点：
    • 1、长度的是可变的。
    • 2、元素的类型是任意的。
  • 建议在使用数组时，存储同一类型的元素。操作起来较多方便。 
1
2
3
4
5
6
7
js中的数组定义的两种方式：
1、
	var arr = []; var arr = [3,1,5,8];
2、使用了javascript中的Array对象来完成的定义。 
    var arr = new Array();//var arr = [];
    var arr1 = new Array(5);//数组定义并长度是5.
    var arr2 = new Array(5,6,7);//定义一个数组，元素是5,6,7;

函数

  • 函数：就是一个功能的封装体。
  • 定义功能通常需要两个明确。
    • 1、功能的结果
    • 2、功能实现中的参与运算的未知的内容
  • Js中的定义函数的格式，通过指定的关键字来定义
1
2
3
4
5
6
7
8
9
10
11
12
13
function 函数名(参数列表){
		函数体：
return 返回值;//如果没有具体的返回值，return语句可以省略不写。
}

<script type="text/javascript">
    function add(x,y){
        return x+y;
    }
			
    var sum = add(4,5);
    alert("sum="+sum);
</script>

细节

  • 1、只要使用函数的名称就是对这个函数的调用。
  • 2、函数中有一个数组在对传入的参数进行存储。这个数组就是arguments
1
2
3
4
5
6
7
8
9
10
<script type="text/javascript">
    function show(x,y){
        alert(arguments.length);
        alert(x+":"+y);
        for(var a=0;a<arguments.length; a++){
            document.write(arguments[a]);
        }	
	}
	show(4,5,6,9,7,4);//建议函数中定义几个参数就传递几个实参。
</script>
  • 小细节2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<script type="text/javascript">

    function getSum(){
		return 100;
	}
    //getSum函数运行，并将返回的结果赋值给sum
    var sum = getSum();
	
    //getSum本身是一个函数名，而函数本身在js中就是一个对象。getSum就是这个函数对象的引用.
    //将getSum这个引用的地址赋值给sum。这时sum也指向了这个函数对象。
    //相当于这个函数对象有两个函数名称
    var sum = getSum;

	//打印时候如果sum指向的是函数对象，那么会将该函数对象的字符串表现形式打印出来
	//就是该函数的代码定义格式
	alert("sum="+sum);，


    function show2(){
        alert("show2 run");
    }
    alert(show2());	//show2 run   undefined //因为有两个alert
</script>

动态函数

  • Js函数的其他表现形式
  • 动态函数：使用的是Js中内置的一个对象Function
  • 只不过用的不是很多
  • 参数列表，函数体都是通过字符串动态指定的
1
2
3
4
5
6
7
8
<script type="text/javascript">
    
    //参数列表，函数体都是通过字符串动态指定的
	var add = new Function("x,y","var sum; sum=x+y; return sum;");
    var he = add(4,8);
    alert("he="+he);
			
</script>

匿名函数

  • 匿名函数：没有名字的函数，通常是函数的简写形式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<script type="text/javascript">
	//示例一
    var add3 = function (a,b){

        return a+b;
    }
    alert(add3(7,8));

	//示例二
    function haha()
    {
        alert("haha run");
    }
    var xixi = haha;

    //上述代码可以简写成下面的方式。 
    var xixi = function()
    {
        alert("haha run");
    }
</script>

练习一

  • 综合练习：
  • 1、定义功能，完成对数组的最值获取
  • 2、对数组排个序
  • 3、对数组查个找
  • 4、对数组元素进行反转
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
<script type="text/javascript">
		
    var arr = [66,13,37,21,89,17];

    //取最值。
    function getMax(arr){

        var max = 0;

        for(var x=1; x<arr.length; x++){
            if(arr[x]>arr[max])
                max = x;
        }

        return arr[max];

    }
			

    var maxValue = getMax(arr);

    //排序。 
    function sortArray(arr){
        for(var x=0; x<arr.length-1; x++){
            for(var y=x+1; y<arr.length; y++){
                if(arr[x]>arr[y]){
                    swap(arr,x,y);
                }
            }
        }
    }
    //数组中的元素位置置换。
    function swap(arr,x,y){
        var temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }

    function println(val){
        document.write(val+"<br/>");
    }

    println("排序前:"+arr)
    sortArray(arr);
    println("排序后:"+arr)

    </script>


    <script type="text/javascript">
        //查找。
        function searchElement(arr,key){

        for(var x=0;x<arr.length; x++){
            if(arr[x]==key)
                return x;
        }
        return -1;
    }

    //折半，必须有前提。必须是有序的数组。
    function binarySearch(arr,key){

        var max,min,mid;
        min = 0;
        max = arr.length-1; 

        while(min<=max){
            mid = (max+min)>>1;

            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            else
                return mid;
        }
        return -1;

    }

    //对数组的反转。 
    function reverseArray(arr){
        for(var start=0,end=arr.length-1; start<end; start++,end--){
            swap(arr,start,end);
        }
    }
    reverseArray(arr);
    println("反转后:"+arr);

    </script>

全局和局部变量

  • 在脚本片段中定义的变量，是全局变量
  • 函数内定义的变量，是局部变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<script type="text/javascript">
//			for(var x=0; x<3; x++){//在脚本片段中定义的变量，是全局变量。
//				document.write("x="+x);
//			}		
			
//			function show(){
//				var x = 6;//局部变量。
//			}
			
//			document.write("X======="+x);
			
			var x = 3;//全局变量x.
			
			function show(x){//函数局部的变量x
				x = 8;
			}
			
			show(x);
			
			document.write("x="+x);//x=3;
			
			
		</script>

常见对象

Object

  • toString()：将对象变成字符串
  • valueOf()：返回制定对象原始值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<script type="text/javascript">

    function show(){
        alert("show run");
    }			
    alert(show.toString());

    var arr = [3,4,1,6,8];
    alert(arr.toString());

    var abc = function(){
        alert("abc run");
    }
    alert(abc);

    alert(abc.valueOf());
</script>

String

  • Js相比 Java 的String少很多功能 我们可以自行添加
1
2
3
4
5
6
7
8
9
10
11
//out.js
//打印指定参数数据到页面上，并换行
function println(param){
	document.write(param+"<br/>");
}

//out.js
打印指定参数数据到页面上。
function print(param){
	document.write(param);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<body>
//导入out.js
<script type="text/javascript" src="out.js"></script>
<script type="text/javascript" src="stringtool.js"></script>
<script type="text/javascript">
    
    //演示简单功能
    var str = "abcde";
    println("len="+str.length);
    println(str.bold());//加粗
    println(str.fontcolor("red"));//字体颜色。
    println(str.link("http://www.163.com"));//将字符串变成超链接。
    println(str.substr(1,3));//bcd
    println(str.substring(1,3));//bc


    //自定义
    //去除字符串两端的空格。
    function trim(str){

        //定义两个变量，一个记录开始的位置。一个记录结束的位置。
        //对开始的位置 的字符进行判断，如果是空格，就进行递增，直到不是空格为止。
        //对结束的位置 的字符进行判断，如果是空格，就进行递减，直到不是空格为止。
        //必须要保证开始<=结束，这样才可以进行截取。

        var start,end;
        start=0;
        end=str.length-1;

        while(start<=end && str.charAt(start)==' '){
            start++;
        }
        while(start<=end && str.charAt(end)==" "){
            end--;
        }
        
        return str.substring(start,end+1);
    }

	var s = "     ab c      ";

    alert("-"+trim(s)+"-");
    //alert("abc".bold());//<b>this</b>

//给string的原型中添加一个功能。 注意：给对象添加新功能直接使用  对象.新内容   即可。
//			String.prototype.len = 199;//给string的原型对象中添加一个属性 名为len。值为199.

//添加行为。



//			println("abc".len);

//			alert("-"+"     ab cd     ".trim()+"-");
</script>
</body>
  • 既然trim方法是用来操作字符串的方法，可不可以像字符串已有的方法一样，
  • 将该方法也定义到字符串对象中呢？直接用字符串对象调用就欧了

原型

  • 这里就可以使用一个该字符串的原型属性来完成：
  • 原型：就是该对象的一个描述。该描述中如果添加了新功能，那么该对象都会具备这些新功能。
  • 而prototype就可以获取到这个原型对象，通过prototype就可以对对象的功能进行扩展。
  • 需求：想要给string对象添加一个可以去除字符串两端空格的新功能，就可以使用原型属性来完成。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<script>
    //String.prototype.mytrim = trim();	//在已有该函数时也可以这样写
    String.prototype.trim = function(){	//匿名函数

        var start,end;
        start=0;
        end=this.length-1;

        while(start<=end && this.charAt(start)==' '){
            start++;
        }
        while(start<=end && this.charAt(end)==" "){
            end--;
        }

        return this.substring(start,end+1);

    }
</script>
  • 我们来试着用原型完成一个小练习
    • 添加一个，将字符串进行反转的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
String.prototype.reverse = function(){
	
	var arr = this.toCharArray();
	
	//将数组位置置换功能进行封装。并定义到了反转功能内部。 
	function swap(arr,a,b){
		var temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	
	for(var x=0,y=arr.length-1;  x<y ; x++,y--){
		
		swap(arr,x,y);
	}
	return arr.join("");
}

Array

  • 在下面代码中展示了一些常用的Array方法
  • concat、join、pop、reverse、shift、sort、splice、unshift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<script type="text/javascript" src="../demo/out.js"></script>
<script type="text/javascript">

    var arr = ["nba","haha","cba","aaa","abc"];

    var arr2 = ["qq","xiaoqiang",70];

    //在arr数组上连接一个元素"mm"，再连接一个arr2数组
	//将mm作为新数组中的元素，将arr2数组中的元素也作为新数组中的元素
    var newArr = arr.concat("mm",arr2);
    println(newArr);

    println(arr.join("-"));
    println(myJoin(arr,"+"));//以"+"为分隔符

    //模拟一下的join的实现原理
    function myJoin(arr,separator){

    var str = "";
    for(var x=0;x<arr.length ; x++){
        if(x!=arr.length-1)
        	str += arr[x]+separator;
        else
        	str += arr[x];
        }
        return str;
    }
    //移除数组中的元素，并返回该元素。pop

    println("<hr/>");

    println(arr.pop());//删除并返回最后一个元素。

    println(arr.reverse());//反转

    println(arr.shift());//删除并返回第一个元素
    println(arr);


    println(arr);
    arr.sort();
	//删除元素并可以进行元素的替换。
    var temp = arr.splice(1,3,8080,9527,"xixixi","wangcai"); 
    println(temp);
    println(arr.unshift("uuuu"));//在头部插入

    println(arr);

</script>
  • pop() 方法是删除最后一个元素，unshift()方法是在头部插入
  • 那么是不是可以用他们做出堆栈，队列那？可以自己试试呀

Date

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<script type="text/javascript" src="out.js"></script>
<script type="text/javascript">
        var date = new Date();
    println(date);
    println(date.toLocaleString());//日期和时间
    println(date.toLocaleDateString());//只有日期。

    function getWeek(num){

        var weeks = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'];
        return weeks[num];
    }

    // 日期对象和毫秒值之间的转换
    var date2 = new Date();
    //获取毫秒值  日期对象-->毫秒值
    var time = date2.getTime();
    println("time:"+time);//1338191622156
    //将毫秒值转成日期对象。
    //1、new Date(time);//setTime();
    var date3 = new Date(time);

    //将日期对象和字符串之间进行转换
    //日期对象转成字符串，toLocaleString  toLocaleDateString
    //将字符串转成日期对象，具备指定格式的日期字符串-->毫秒值--->日期对象
    var str_date = "9/28/2017";
    var time2 = Date.parse(str_date);
    var date3 = new Date(time2);
    println(date3.toLocaleDateString());

</script>

Math

  • 该对象的中的方法都是静态的。不需要new，直接Math调用即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<script type="text/javascript" src="out.js"></script>
<script type="text/javascript">

    var num1 = Math.ceil(12.34);//返回大于等于指定参数的最小整数。
    var num2 = Math.floor(12.34);//返回小于等于指定数据的最大整数。
    var num3 = Math.round(12.54);//四舍五入
    println("num1="+num1);	//13
    println("num2="+num2);	//12
    println("num3="+num3);	//13

    var num4 = Math.pow(10,2);//10的2次方
    println("num4="+num4);

    println("<hr/>");
    for(var x=0; x<10; x++){
        //伪随机数
//      var num = Math.floor(Math.random()*10+1);
        //ParseInt 全局方法
        var num = parseInt((Math.random()*10+1));
        println(num);
    }

	//将指定进制格式的字符串转成十进制
    var num = parseInt("110",2);
    println("num="+num);

    var num1 = parseInt('0x3c',16);
    println("num1="+num1);

</script>

全局方法

  • 全局对象都在 global 中, 如 ParseInt
1
2
3
4
5
6
7
8
9
10
11
12
13
parseInt("123");
println(parseInt("123")+1);
var val = parseInt("12abc");//val = 12;
val val = parseInt("abc12");//非法，返回NAN
println("value="+val);//通过isNaN来判断结果是否非法。


//将指定进制格式的字符串转成十进制
var num = parseInt("110",2);
println("num="+num);

var num1 = parseInt('0x3c',16);
println("num1="+num1);

Number

  • 我们刚刚在ParseInt 里，已经知道了怎么将指定进制转换十进制
  • 那么如何把十进制 转换为 指定进制 那？
1
2
3
4
5
6
7
8
//将十进制转成其他进制，使用数字对象完成
			
var num3 = new Number(6);

println("num3="+num3.toString(2));

var num4 = 60;
println("num4="+num4.toString(16));

特有语句

  • 为了简化对象调用内容的书写，可以使用 Js中的特有语句 with 来完成。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
格式：
    with(对象)
    {
    	在该区域中可以直接使用指定的对象的内容。不需要写对象.
    }
*/			

			
//	var year = date.getFullYear();
//	var month = date.getMonth()+1;
//	var day = date.getDate();
//	var week = getWeek(date.getDay());

with(date){
    var year = getFullYear();
    var month = getMonth()+1;
    var day = getDate();
    var week = getWeek(getDay());

    println(year+"-----"+month+"---+--"+day+"-----"+week);
}
  • for in ：对对象进行变量的语句
1
2
3
4
5
6
7
8
9
10
var arr = [32,80,65];

for(i in arr){
println("i="+arr[i]);
}
println("<hr/>");

for(x in numObj){
println(x);
}

自定义对象

  • 如果想要自定义对象，应该先对对象进行描述
  • Js是基于对象，不是面向对象的，不具备描述事物的能力
  • 我们还想按照面向对象的思想编写 Js
  • 就要先描述，在 Js中，可以用函数来模拟面对对象的中的描述
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//用js来描述人
function Person(){//相当于构造器。
    alert("person run");
}

//通过描述进行对象的建立。 new.
var p  = new Person();

//动态给p对象添加属性。直接使用p.属性名即可。
p.name = "zhangsan";
p.age = 29;

//如果定义的p对象的属性赋值为一个函数，即是给p对象添加一个方法。
p.show = function(){
    alert("show :"+this.name+":"+this.age);
}

p.show();


var obj = new Object();
obj.name = "god father";
obj.age = 2012;

alert(obj.name+":"+obj.age);
  • 封装
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function Person(name,age){
    //在给Person对象添加了两个属性。
    this.name = name;
    this.age = age;

    this.setName = function(name){
        this.name = name;
    }
    this.getName = function(){
        return this.name;
    }
}
						
var p = new Person("旺财",20);

for(x in p){
    //记得导入out.js	
    println(x+":"+p[x]);
}

p.setName("小强");
alert(p.getName());
  • 直接使用{}定义属性和值的键值对方式。键值键通过:连接，键与键之间用逗号隔开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var pp  = {
				
    //定义一些成员。
    "name":"小明","age":38,
    "getName":function(){
        return this.name;
    }	
}
			

//对象调用成员有两种方式：对象.属性名    对象["属性名"]
alert(pp["age"]+":"+pp.name);
			
			
//用js实现键值对映射关系的集合容器。 
var oMap = {
    8:"小强",3:"旺财",7:"小明"
}		
			
var val1 = oMap[8];
alert("val1:"+val1);

var val2 = get(7);
alert("val2:"+val2);

function get(key){
    return oMap[key];
}
  • 定义对象 比较常用map，键值对的形式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var myobj = {
    myname:"lisisi",myage:30
}		
alert(myobj.myname+":"+myobj["myage"]);


var myobj2 = {
    "myname2":"hahahah","myage2":48
}
alert(myobj2.myname2+":"+myobj2["myage2"]);


var myMap = {

    //names:["lsii1","lisi2","lisi4"],nums:[34,10,48]
    names:[{name1:"zhangsan"},{myname:"hahahah"}]
}

alert(myMap.names[1]);

alert(myMap.names[0].name1);