JS
1)在html文件中,在一对script标记中,直接编写
1
2
3
|
<script language= 'javascript' > document.write( 'hello' ); </script> |
2)在js中,直接编写,在html中,使用一对script标记直接引用
1
|
<script language= 'javascript' src= 'xxx.js' ></script> |
- JavaScript区分大小写
- 变量a和变量A是两个变量
- JavaScript脚本程序须嵌入在HTML文件中
- JavaScript脚本程序中不能包含HTML标记代码
1
2
3
|
<script> document.write(‘<table></table>'); </script> |
每行写一条脚本语句
语句末尾可以加分号
JavaScript脚本程序可以独立保存为一个外部文件
Language:引用的语言 javascript、php、c#、VBSCRIPT
Src:引用一个外部的js文件
变量是用来临时存储数值的容器,变量存储的数值是可以变化的
变量必须要先声明才能使用,使用var声明变量
使用var声明:局部变量
没有使用var声明:全局变量
变量的命名规则:第一个字符必须是英文字母,或者是下划线(_);其后的字符,可以是英文字母,数字,下划线;变量名不能是JavaScript的保留字
变量的作用域:全局变量、局部变量
String :字符串 ‘' “”
Number :数字 10、10.01、100
Boolean :布尔型 true、false
Undefined :未定义
Null :空
Object:对象类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
<script language= 'javascript' > //使用js描述一个人的完整信息 var name= '张三' ; var age=30; var marry= true ; var height=1.8; document.write( '<ol>' ); document.write( '<li>姓名' +name+ '</li>' ); document.write( '<li>年龄' +age+ '</li>' ); document.write( '<li>婚否' +marry+ '</li>' ); document.write( '<li>身高' +height+ '</li>' ); document.write( '</ol>' ); function Person(){} var p1= new Person(); p1.name= '李四' ; p1.age=20;2013/12/31 document.write(p1.name+ '<br>' ); document.write(p1.age+ '<br>' ); </script> |
1)算术运算符
+、-、*、/、%、++、–
i++
++i
1
2
3
4
5
6
7
8
9
|
<script> var i=10; var j=i++; //先赋值再自加 var k=++i; //先自加再赋值 document.write(j); //10 document.write(k); //12 </script> |
2)比较运算符
、<、>=、<=、!=、==、===、!==
==和===有何区别?
== :判断值是否相等
===:判断值相等类型也相同
1
2
3
4
5
6
7
8
9
10
11
12
|
<script> var i=5; //Number var j= "5" ; //String if (i==j){ document.write( '相等' ); } if (i===j){ document.write( '全等于' ); } </script> |
3)逻辑运算符
&&、||、!
4)赋值运算符
=、+=、-=、*=、/=、%=
将运算符左边的与右边的进行计算,再赋值给左边的
字符串运算符
+、+=(PHP中是用点)
顺序结构
分支结构
循环结构
1、顺序结构
代码是一行接着一行执行
2、分支结构
If、else、else if、switch
3、循环结构
For、while、do….while、for…..in
小游戏:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<script language= 'javascript' > var n=Math.round(Math.random()*500); // 随机数 alert(n); while ( true ){ var number=prompt( '请输入一个0--500之间的数字' ); //用户输入 if (number>n) alert( '大了' ); if (number<n) alert( '小了' ); if (number==n){ alert( '答对了~~~~' ); break ; } } </script> |
1、函数的功能
代码重复性使用
模块化编程
2、语法:
使用函数前要先定义才能调用
函数定义有三个部分:函数名,参数列表,函数体
定义函数的格式
**function 函数名([参数1,参数2…]){
函数执行部分;
return 表达式;
}**
调用语法:
函数名(实参1,实参2,……,);
3、代码示例
例1:关于函数的定义和调用
1
2
3
4
5
6
7
8
9
|
//函数的定义 function display(){ alert( 'hello' ); } //函数的调用 display(); display(); display(); |
在js中,对象类型默认就是按地址传递
1
2
3
4
5
6
7
8
9
10
|
function display(obj){ obj.name= 'lisi' ; } var p1= new Object(); p1.name= 'zhangsan' ; display(p1); alert(p1.name); //lisi alert(p1); |
JS的基本类型,是按值传递的。
1
2
3
4
5
6
|
var a = 1; function foo(x) { x = 2; } foo(a); console.log(a); // 仍为1, 未受x = 2赋值所影响 |
1
2
3
4
5
6
|
var obj = {x : 1}; function foo(o) { o.x = 3; } foo(obj); console.log(obj.x); // 3, 被修改了! |
说明o和obj是同一个对象,o不是obj的副本。所以不是按值传递。 但这样是否说明JS的对象是按引用传递的呢?我们再看下面的例子:
1
2
3
4
5
6
|
var obj = {x : 1}; function foo(o) { o = 100; } foo(obj); console.log(obj.x); // 仍然是1, obj并未被修改为100. |
如果是按引用传递,修改形参o的值,应该影响到实参才对。但这里修改o的值并未影响obj。 因此JS中的对象并不是按引用传递。那么究竟对象的值在JS中如何传递的呢?
对于对象类型,由于对象是可变(mutable)的,修改对象本身会影响到共享这个对象的引用和引用副本。而对于基本类型,由于它们都是不可变的(immutable),按共享传递与按值传递(call by value)没有任何区别,所以说JS基本类型既符合按值传递,也符合按共享传递。
var a = 1; // 1是number类型,不可变 var b = a; b = 6;
据按共享传递的求值策略,a和b是两个不同的引用(b是a的引用副本),但引用相同的值。由于这里的基本类型数字1不可变,所以这里说按值传递、按共享传递没有任何区别。
基本类型的不可变(immutable)性质
基本类型是不可变的(immutable),只有对象是可变的(mutable). 例如数字值100, 布尔值true, false,修改这些值(例如把1变成3, 把true变成100)并没有什么意义。比较容易误解的,是JS中的string。有时我们会尝试“改变”字符串的内容,但在JS中,任何看似对string值的”修改”操作,实际都是创建新的string值。
1
2
3
4
|
var str = "abc" ; str[0]; // "a" str[0] = "d" ; str; // 仍然是"abc";赋值是无效的。没有任何办法修改字符串的内容 |
而对象就不一样了,对象是可变的。
1
2
3
4
5
6
7
|
var obj = {x : 1}; obj.x = 100; var o = obj; o.x = 1; obj.x; // 1, 被修改 o = true ; obj.x; // 1, 不会因o = true改变 |
这里定义变量obj,值是object,然后设置obj.x属性的值为100。而后定义另一个变量o,值仍然是这个object对象,此时obj和o两个变量的值指向同一个对象(共享同一个对象的引用)。所以修改对象的内容,对obj和o都有影响。但对象并非按引用传递,通过o = true修改了o的值,不会影响obj。
关于函数的返回值问题
1
2
3
4
5
6
7
8
9
|
function display(first,second){ //函数遇到return会立即返回,后面代码不执行 return first+second; } var i=10; var j=20; alert(display(i,j)); document.write(display(i,j));*/ |
关于匿名函数
1
2
3
4
5
6
7
8
9
10
|
/*var i=function(){ alert('hello'); }; i();*/ Var i=10; 变量可以保存数据,也可以保存地址 Function display(){ } 在window对象下添加一个叫display的变量,它指向了这个函数的首地址 Window.i=display 我们让window对象下的i指向这个函数的首地址 display() ======= i(); |
自调用匿名函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<script language= 'javascript' > /*var i=function(){ alert('hello'); }; i();*/ ( function (first){ alert(first); alert( 'hello,js' ); })(10) </script> Function(){} :相当于返回首地址 (Function(){}) :把这部分看做一个整体 ( function (){})():相当于找到这个地址并执行 |
1. 全局作用域(Global Scope)
在代码中任何地方都能访问到的对象拥有全局作用域,一般来说一下几种情形拥有全局作用域:
(1)最外层函数和在最外层函数外面定义的变量拥有全局作用域
1. 全局作用域(Global Scope)
在代码中任何地方都能访问到的对象拥有全局作用域,一般来说一下几种情形拥有全局作用域:
(1)最外层函数和在最外层函数外面定义的变量拥有全局作用域
1. 全局作用域(Global Scope)
在代码中任何地方都能访问到的对象拥有全局作用域,一般来说一下几种情形拥有全局作用域:
(1)最外层函数和在最外层函数外面定义的变量拥有全局作用域
var name="yuan";
function foo(){
var age=23;
function inner(){
console.log(age);
}
inner();
}
console.log(name); // yuan
//console.log(age); // Uncaught ReferenceError: age is not defined
foo(); // 23
inner(); // Uncaught ReferenceError: inner is not defined
(2)所有末定义直接赋值的变量自动声明为拥有全局作用域,例如:
var name="yuan";
function foo(){
age=23;
var sex="male"
}
foo();
console.log(age); // 23
console.log(sex); // sex is not defined
function bar(age) {
console.log(age);
var age = 99;
var sex="male";
console.log(age);
function age(){
alert(123);
} ;
console.log(age);
return 100;
}
result=bar(5);
一 词法分析过程(涉及参数,局部变量声明,函数声明表达式):
1-1 、分析参数,有一个参数,形成一个 AO.age=undefine;
1-2 、接收参数 AO.age=5;
1-3 、分析变量声明,有一个 var age, 发现 AO 上面有一个 AO.age ,则不做任何处理
1-4 、分析变量声明,有一个 var sex,形成一个 AO.sex=undefine;
1-5 、分析函数声明,有一个 function age(){} 声明, 则把原有的 age 覆盖成 AO.age=function(){};
二 执行过程:
2-1 、执行第一个 console.log(age) 时,当前的 AO.age 是一个函数,所以输出的一个函数
2-2 、这句 var age=99; 是对不 AO.age 的属性赋值, AO.age=99 ,所以在第二个输出的age是 99;
2-3 、同理第三个输出的是 99, 因为中间没有改变 age 值的语句了。
注意:执行阶段:
function age(){
alert(123)
} ;
不进行任何操作,将执行语句复制给age这部操作是在词法分析时,即运行前完成的。