Day15

时间  2019-12-17
标签 day15 day 繁體版
原文   原文链接

JSjavascript

1）在html文件中，在一对script标记中，直接编写php

 
1
2
3
<script language= 'javascript' >
   document.write( 'hello' );
</script>

2）在js中，直接编写，在html中，使用一对script标记直接引用html

 
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脚本程序能够独立保存为一个外部文件java


Language：引用的语言 javascript、php、c#、VBSCRIPT 
Src：引用一个外部的js文件编程


变量是用来临时存储数值的容器，变量存储的数值是能够变化的 
变量必需要先声明才能使用，使用var声明变量 
使用var声明：局部变量 
没有使用var声明：全局变量 
变量的命名规则：第一个字符必须是英文字母，或者是下划线(_)；其后的字符，能够是英文字母，数字，下划线；变量名不能是JavaScript的保留字 
变量的做用域:全局变量、局部变量c#


String ：字符串 ‘' “” 
Number ：数字 十、10.0一、100 
Boolean ：布尔型 true、false 
Undefined ：未定义 
Null ：空 
Object:对象类型dom

 
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）比较运算符函数

、<、>=、<=、!=、==、===、!== 
==和===有何区别？ 
== ：判断值是否相等 
===：判断值相等类型也相同spa

 
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中是用点）

 

顺序结构 
分支结构 
循环结构

一、顺序结构 
代码是一行接着一行执行

二、分支结构 
If、else、else if、switch

三、循环结构 
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> 

 
一、函数的功能 
代码重复性使用 
模块化编程

二、语法：

使用函数前要先定义才能调用 
函数定义有三个部分:函数名,参数列表,函数体 
定义函数的格式 
**function 函数名([参数1,参数2…]){ 
函数执行部分; 
return 表达式; 
}**

调用语法：

函数名(实参1,实参2,……,);

三、代码示例

例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这部操做是在词法分析时，即运行前完成的。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程