JAVAScript 基本语法 笔记（一）

2020年03月06日

1、JAVA web

1.1 重定向

response.sendRedirect()
无法实现数据的传递，能够跨站点访问

1.2 请求转发

"request.getRequestDispatcher(’’/welcomeServelet’’).forWord(request,response)
能够实现数据的传递，不能实现跨站点访问

2、 JAVAScript

​ JAVAScript 语言基础

​ JAVAScript Dom 用途：来操作html 元素，制作一些网页效果

---

2.1、JAVAScript 语言基础 基础

2.1.1参考书：

JavaScript 高级程序设计 JavaScript权威指南

核心语法 ECMAScript ECMA 欧洲计算机制造商协会

DOM （文档对象模型）

BOM（浏览器对象模型）

2.1.2 javascript语法

//  通过连入外部的JS文件来进行改变，src可以是外部网站，不要自关闭及不要分开后面的script
<script src="scripts.js" type ="text/javascript"></script> 
<script type="text/javascript">  
     //JS中字符串推荐单引号 
     /* 说明性文字所用注释
     */
      alert('hello');    
      alert('new Date().toLocaleDateString()'+' '+ new Date().toLocaleTimeString());
     
 </script>

在Script中代码出错，只会影响当前Script，不会影响其他script及整个代码

---

js语言严格区分大小写（n和N是两个不同的变量）

声明变量统一用var来声明，不需要写数据类型

C#是强类型语言，JS是弱类型语言，支持动态类型。

//以下js代码都是正确的
var x=10;
x='aaaaa';
x=false;
x=99.5;

每条语句后面加上分号 “;”

变量命名以字母、下划线和$开头，中间可以包括字母、数字、下划线和$

JS共六种数据类型：

• Boolean (布尔) 取值：只有true和false
• Number（数字） 取值：所有数字，包含整数和小数等，范围相当于double
• String（字符串）取值：所有字符串
• Undefined(未定义) 只有一个值是 undefined
• Null （空对象） 只有一个值是null
• Object （对象类型） 取值：任何对象、Array、function等

object o= null;
o = new object();
Console.WriteLine("OK");

var n =10;
alert(typeof(n)); //打印出来是number
var m;
alert(typeof(m)); // 打印出来是undefined

演示for循环、switch语句

<script type="text/javascript">  
    //int   变黑为保留字
  var sum;//所以声明变量后，使用前一定要赋值；
    sum=0; //动态数据类型   
    for(var i=1;i<=100;i++){
        sum=sum+i;
    }
    alert(sum);  //返回NaN，原因是sum未赋初值，sum就是undefined
  
    
     
 </script>

“====” 和“ =====”

=== 三等号为严格等于 数据类型和值，不作数据类型转换

== 双等号 数据类型转换之后的值相等会返回true

<script type="text/javascript">  
    var	n1='123';
    var n2= 123;
    alert(n1==n2); //true
    alert(n1===n2);//false
    var n1= null;
    var n2;
    alert(n1==n2); //当使用双等号== 判断的时候，认为null和undefined相同true
    alert(n1===n2);//false
    var n1=true;
    var n2='true';
    alert(n1==n2); //false
    alert(n1===n2); //false
    //详见ECMA-262.pdf语法
     var s=123;
    //switch 内部使用的也是=== 严格等于来判断是否相等的
    switch(s){
        case '123':
            alert('等于字符串123');
            break;
        case 123:
            alert('等于数字123');
            break;
        default:
            alert('没有找到相等的');
            break;
    }
    //返回结果是  等于数字123.
 </script>

null 和 undefined

• 当声明变量为赋值时，那么变量的值就是undefined
• 变量压根就没有声明，例如 alert(w),浏览器报错，整个代码不执行，在使用变量之前先校验变量是否可用

if(typeof(w) =='undefined'){
 alert('变量不可用')
}else{
alert(w)
}
//返回结果为变量不可用

• 方法没有返回值的时候,接收到的返回值就是undefined

  var n = fun1()
  alert(n); //返回undefined
  function fun1(){
  }
  

null 值表示指向了一个“空对象”，需要我们显示为n赋值一个null值

一般在一个对象使用完毕，

var n =null;

无论变量的值是null值，还是undefined都表示该变量不可以用，所以在变量使用前进行变量校验，判断变量是否可用。

var x ; //var x
if (typeof(x)!='undefined' && x !=null){
    alert('x变量可用')
}else{
    alert('x变量不可用')
}
//返回结果： x变量不可用

变量作用域： JS中不存在块级作用范围

在页面中声明的变量，在整个页面中任何一个地方都可以访问。

//eg1:
var n=10;
alert(n);   //返回10
<script type ="text/javascript">
    n++;
   alert(n);   //返回11
    </script>

//eg2:
var x =100;
function f1(){
    x++;
    alert(x);//返回101
}
f1();
alert(x);//返回101
//eg3:
var y=100;
function f1(){
    //x 是f1 内部定义的变量，只能在f1函数内部使用
    var x=1;
    x++;
    alert(x); //返回2
}
f1();
alert(x); //返回错误, x 未定义

//eg4:
 function f1(){
     //在js中不存在块级作用域，所以在方法内部任何一个地方声明变量，变量在整个方法内部有效
     var x=10;
     if(x>5){
         var y=100
         alert(y);//打印100
     }
     alert(y);//打印100，
 }
f1();
alert(y);//报错，y未定义


//eg5:
function f1(){
    var sum=0;
    for(var i=0;i<10;i++){
        sum=sum+i
    }
    alert(i); //打印10
    //当重复声明变量的时候，JS会自动忽略第议次声明以后的所有语句，但是不忽略第二次赋值语句
    for(var i=0;i<5;i++){
        alert(i); //不打印出来，可以不用var定义
    }
    alert(i);//打印5
}
f1();

//eg6:  不使用var关键字则认为X是在整个页面中声明的，相当于全局变量，整个页面都能访问，所以要避免使用“全局变量”

function f1(){
    x =100;
    x++;
    alert(x);//101
}
alert(x);//101

转义符号： \t \n \r \ \等

数据类型转换

// 1、把字符串转换为数字
var n='123';
alert(n+1);//打印1231
var n='123sdasdsad'
 n=parseInt(n);
alert(n+1)// 打印124
var n='12ss3dasdsad'
 n=parseInt(n);
alert(n+1)// 打印13
var n='sss123sdasdsad'
 n=parseInt(n);
alert(n+1)// 打印NaN,Not a Number ,NaN 是一个值，数据类型是Number

var n='15';
n=parseInt(n,10);
alert(n);//15
var n='15'
n=parseInt(n,8); //把n中的15当成八进制来转换，转换为十进制来返回
alert(n);//13

//
alert(parseFloat('99.3'))//转换为小数  99.3
alert(parseFloat('9P9999.3.3.3'));//打印为9

Number(object);//将任意类型转换为数字   null==> 0    object==> NaN
String(object);//将任意类型转换为字符串
对象.toString();//将任意类型转换为字符串
Bealean(object);//将任意类型转换为Boolean

n= null;
alert(n.toString());//null对象不能调用任何方法，报错

判断一个值是不是NaN，不能用==，必须使用isNaN()函数来校验

JAVA中eval()函数方法

var n ='var x=1;x++;alert(x);';
alert(n);//打印：var x=1;x++;alert(x);
eval(n);  //打印2,把字符串当做js代码来解析执行
x++;  
alert(x);//打印3

var n=10,m=1100;
alert(n<m && m>n);//true
//逻辑表达式，很重要
var r ="a" || "";
alert(r); // 打印a
r= null || 15
alert(r);//打印15
r="a" && 0;
alert(r);//打印0
r=null && 15;
alert(r);//打印null
r ="12312" || 12;
alert(r);//打印 12312
r="12312" && 12
alert(r);//12  返回最后一个结果

**逻辑表达式很重要 ** && 和 ||

错误调试 http://getfirebug.com

2.1.3 javascript函数

js 没有访问修饰符，没有返回值数据类型

function 相当于delegate ，js函数习惯用驼峰命名法

定义函数的注意点：

• 使用function关键字
• 无返回值类型
• 无参数的类型
• javascript中函数永远有返回值，如果没有执行return语句，则返回undefined，把函数当做构造函数时，return语句将不返回

//eg1:
function getMessage(id){
    return id+':hello';
}
var msg=getMessage('0001');
alert(msg); //输出0001：hello

//eg2:
function sayHi(){
    alert('Hi!')
}
sayHi();//调用一个函数
//eg3:
function getSum(x,y){
    return x+y;
}
var result=getSum(50,20)；
alert(result);  

js函数不能重载：

方法的签名指的是方法的名称和参数,及黑体部分 public string sayHi(string s)

function f1(){
    alert('first f1');
}
function f1(name){
    alert(name);
}
f1();// 打印 undefined，因js没有重载，用最后面的覆盖前面的函数定义，因为那么没有赋值

add(10,20);
add(10,20,30);
add(10,20,30,40);//类似于可变参数，在js中叫做arguments
//其实所有的方法都无需定义形参，定义形参的目的仅仅是为了使用方便
//在实际调用函数的时候，所有的参数都包含在了arguments对象中
function add(){
    var sum=0;
    for(var i=0;i<arguments.length;i++){
        sum+=arguments[i]
    }
    return sum;
}
var result=add(10,20,30,40);
alert(result);//打印100

 var x=1,y=0,z=0;
function add(n){
    n=n+1;
    return n;
}
y=add(x);//因为函数有“预解析”功能，程序在执行之前需要进行函数预解析，范围在一个标签之内，不能在整个页面中
function add(n){
    n=n+3;
    return n;
}
z=add(x);
alert(y+'....'+z);//打印4.....4

var user_name='steve';
function f1(){
    //重名时优先使用内部变量
    //1、在函数内部声明的变量整个函数都可以使用
    //2、如果遇到局部变量与全局变量冲突的情况下，优先使用局部变量
    //3、变量与函数具有同样的预解析功能，在函数的代码正式执行之前，先会解析函数中的所有的变量，然后在执行该函数，因为第一句代码，局部变量user_name已经声明了，但是没有赋值（因为预解析只解析声明，不包含赋值）所以就会返回undefined 
    alert(user_name); //undefined
    var user_name ='yzk';
     alert(user_name);//yzk
}
f1()
alert(user_name);//steve

 function myFunction(){
     var n =10,m,sum;//在函数的一开始就要把所有要使用的变量都声明好
     alert(n);
     m=n++;
     alert(m);
     sum=n+m;
     alert(sum);
 }

JavaScript “函数”也是“对象”

function myFunction(){
    for(var i=0;i<10;i++){
        alert(i);
    }
}
//把myFunction当做函数来调用
myFunction();
//同时myFunction 也是一个对象（是一个函数对象）
alert(myFunction.toString());//返回方法的源代码
alert(myFuction.length);//返回函数定义形参的个数

JavaScript中的匿名函数

//声明匿名函数
//一、匿名函数的第一种写法
var f1=function (){
    alert('这就是一个匿名函数!!!');
};//定义一个匿名函数
f1();//打印：这就是一个匿名函数！！！
f1=100;
alert(f1);//打印100
f1=function(x,y){
    return x+y；
}
var r=f1(10,20)
alert(r);//30

function f1(fn){
    alert('这是一个f1函数')；
    fn();
}
f1(f12);
function f12(){
    alert('12'); 
}

//等价于 
f1(function (){alert('直接传递一个匿名函数');});

//二、匿名函数的第二种写法：定义匿名函数的同时直接调用该函数
(function (x,y){alert(x+y);})(10,50);
//好处是限定了变量的作用域范围

//第三种匿名函数的写法
var f1 = new Function('x','y','z','alert(x+y+z);');
//通过new Function()的方式定义匿名函数，可以将函数代码用字符串来表示，同时在函数中使用的变量，不会作为页面的"全局变量"出现，在函数外部也访问不到，不像eval()一样。
var f1 = new Function('x,y,z','alert(x+y+z);');
f1(10,20,30);

数组的声明

//eg1:声明数组的同时初始化
var  numbers =[1,2,3,4,5];
alert(numbers.length);//数组长度是5
for(var i=0;i<numbers.length;i++){
    alert(numbers[i]);
}
//当调用数组对象的toString()方法的时候，会返回一个字符串，该字符串是以“逗号”隔开的每个数组元素组成的
alert(numbers.toString());//1,2,3,4,5


//eg2:声明一个空数组
 var data=[];
alert(data.length);//打印：0
data[0] =12;
data[1]= 120;
alert(data.length);//打印：2
//数组增加数值
 var data=[];
data[data.length]='a';
data[data.length]='b';
data[data.length]='c';

//将1至50的所有偶数存入data数组中
var data=[];
for(var i=1;i<=50;i++){
    if(i%2==0){
        data[data.length]=i;
    }
}
alert(data.toString());打印：2,4,6,8……50
    

---

var data=[];
date[5]='A';
data[10]=true;
data[20]=55.5;//数组的长度为21
data.length=3;// 数组的长度为3，类型都变为undefined

---

数组的其他声明方式

var arr = new Array();
alert(arr.length);//0 声明一个长度为0的数组

var arr = new Array(5);
alert(arr.length);//5 声明一个长度为5的数组

var arr = new Array(1,2,'hello',false,function(){alert('hello');});
alert(arr.length);//5

2.2 JAVAScript Dom