1、javascript 面向对象这一块
1)、 javascript的基本数据类型有哪些？
Number (数字) 1 1.2
String (字符串) ‘’ “”
Boolean 布尔 true false
Undefined 未定义
Null 空
2)、javascript的引用数据类型有哪些？
Object {}、 函数 function 、 数组 []
2、javascript定义对象，动态扩冲里面的变量或者属性
var a =new Object(); //实例化一个对象
a.id=1001; //内存中自动增加一个Number名为id变量
a.name=’text’; //内存中自动增加一个String名为name的变量
上面的 new Object() 等价于 {} var a={};
3、以下结果是什么？ 基本数据类型引用不会受影响
var a1=112;
var a2=a1;
a2=2;
alert(a1); //112
alert(a2); // 2
4、以下结果是什么？ 引用数据类型
var a1={}; a1.id=1001;
var a2=a1; a2.id=1;|
alert(a1.id +”,”+ a2.id); // 1 , 1
5、以下结果是什么？
function sum( a){
a=a+10;
return a;
}
调用： var a=2; //基本数据类型
var b=sum(a);
alert(a); //2
alert(b); //12
6、以下的结果是什么
function setName( obj ){
obj.id=1001;
obj.name=”test”;
}
var a={ “id” :1 }; //实例化一个对象名为a,默认它有一个id值为1
setName( a );
alert( a.id); // 1001
alert(a.name); // test
7、以下的结果是什么
function setName( obj ){
obj.id=1001;
obj=new Object(); //局变实例化，方法里面local再创建obj对象，不会影响全局的obj
obj.id=23;
}
var a={ “id” :1 }; //实例化一个对象名为a,默认它有一个id值为1
setName( a );
alert( a.id); // 1001
alert(a.name); // undefined
8、以下的结果是什么
var sum=100;
function setName( ){
var sum=0;
return sum+5;
}
var a=setName();
alert(a); //结果是5
//global全局变量 local局部变量
//调用方法时两个sum变量名一样，找作用于最近的sum
9、以下结果是什么？
function sum(){
return arguments[0]+arguments[1];
}
调用 alert( sum(1,2) ); //3
10、javascript 使用 typeof 检查类型返回类型
var a=2;
alert( typeof a); //string, number,boolean,undefined ,Object
11、使用 instanceof 判断它是不是某种类型，返回真假值
var a={};
alert(a instanceof Array ); //false
alert(a instanceof Object ); //true
12、javascript == 与 === 是有区别
== 比较2个变量的值是否相等 (可能发生值的类型转换)
=== 比较2个变量的类型和值都要相等
var a="2";
var b=2;
if(b==a){
console.log("==是对的");
console.log("a的类型:"+ (typeof a));
console.log("b的类型:"+ (typeof b));
}
if(a===b){
console.log("a===b:对的");
}else{
console.log("a===b:错误");
}
小结：
基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中
引用类型的值是对象，保存在堆内存中
13、使用js创建一个对象， 名称叫Person，有2个变量，一个叫id,一个叫name,并且为id和name提供get/set方法，并且带参的构造函数?
js创建对对象的方法： new Object(); {}
带参的构造函数: 函数是有参数的，参数2个
对象里面会有2个变量名为id,name,并且 每一个都有getId, setId getName,setName
调用:
var p=Person(1001,”test”);
p.setName(“xx”);
function Person(id, name){
this.pid=id; //函数内部 定义变量 局变变量
this.pname=name; //函数内部 定义变量 局变变量
getId=function(){
return this.pid;
}
setId=function(vid){
this.pid=vid;
}
getName=function(){
return this.pname;
}
setName=function(vname){
this.pname=vname;
}
return this;
}
14、Array 数组/集合 它的常用方法
concat() 连接两个或更多的数组，并返回结果。
join()把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
pop()删除并返回数组的最后一个元素
shift()删除并返回数组的第一个元素
push()向数组的末尾添加一个或更多元素，并返回新的长度。
unshift()向数组的开头添加一个或更多元素，并返回新的长度。
reverse()颠倒数组中元素的顺序。
slice()从某个已有的数组返回选定的元素
sort()对数组的元素进行排序
splice()删除元素，并向数组添加新元素。
toString()把数组转换为字符串，并返回结果。
valueOf()返回数组对象的原始值
every()对数组的每一项运动给定函数，如果该函数对每一项都返回true，则返回true
filter()对数组的每一项运动给定函数，返回该函数会返回true的项组成的数组
forEach()对数组的每一项运动给定函数，这个方法没有返回值
map()对数组的每一项运动给定函数，返回每次函数调用的结果组成的数组
some()对数组的每一项运动给定函数，如果该函数对任一项返回true，则返回true
<script>
//1、定义数组 相当于是 var arr=[];
var arr=new Array();
//2、往数组最后面插入数据
arr.push(10);
arr.push(11);
arr.push(12,13,14,15);
console.log(arr.toString());
//3、往最前面插入数据
arr.unshift(20,21,20,21);
console.log(arr.toString());
//4、从后面出栈 删除
var c=arr.pop();
console.log("删除的是"+c);
console.log(arr.toString());
//5、从顶部移出
var d=arr.shift();
console.log("删除的是"+d);
console.log(arr.toString());
//6、取出指定数组下标范围的数组
var newA=arr.slice(4);
console.log(newA);
//7、取得 下标4开始取，取2个
var newB=arr.slice(4,6);
console.log(newB);
//8、排序
arr.sort();
arr.reverse(); //降序
console.log(arr);
//9、 以-号连接出来
console.log( arr.join("-"));
</script>
15、eval() 用于动态执行代码
把字符串强制转换成可以运行的代码
var s=”2+3”;
alert(s); //结果: 2+3
alert( eval(s ) ); //结果：5
var s1=”alert(‘111’); ”;
alert( eval( s1) );
var s2=”{‘id’: 1001}”; //把字符串转为对象
var obj= eval( “(“ + s2 + ”)” );
16、面向对象
1)创建对象语法有很多种
1>var person=new Object();
person.name=”Nicholas”;
person.age=29;
person.job=”Software engineer”;
person.sayName=function(){
alert(this.name);
}
json格式：
2>var person={
name:”Nicholas”;
age:29;
job:”Software engineer”;
sayName:function(){
alert(this.name);
}
}
3>function person(id)={
this.pid=id;
getId=function(){
return this.pid;
}
setId=function(vid){
this.pid=vid;
}
return this;
}
4>function createPerson(id)={
var o=new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){
alert(this.name);
};
return o;
}
5>function person(id)={
this.pid=id;
getId=function(){
return this.pid;
}
setId=function(vid){
this.pid=vid;
}
}
var a=new Person(100);
//必须要new Person
6>function person(id)={
this.pid=id;
getId=function(){
return this.pid;
}
setId=function(vid){
this.pid=vid;
}
return this;
}
var a=new Person(100);
var a= Person(100);
//可以new Person也可以不new Person
2)、为某个对象创建只读的属性
var person={};
Object.defineProperty(person,”name”,{
writable:false,
value:”Nicholas”
});
alert(person.name); //”Nicholas”
person.name=”Greg”;
alert(person.name); //”Nicholas”
3)调用函数语法3种：console.log();谷歌浏览器的打印输出方法
1>调用方式
var a=new person(100);
console.log(“构造函数调用：”+a.getId());
2>作为Windows的对象
person(102);
console.log(“当成了windows了：”+windows.getId());
3>动态调用(委托)
var o=new Object();
person.call(o,105);
console.log(“委托别人调用的：”+o.getId());
4)
原型模式：我们创建的每个对象prototype(原型)属性，这个属性是一个指针，指向一个对象，而这个对象的用途包括可以有特定类型的所有实例共享的属性和方法。如果按字面意思来理解，那就是prototype就是通过调用构造函数的那个对象实例的原型对象。使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中
function person(){
}
person.prototype.name=”Nicholas”;
person.prototype.age=29;
person.prototype.job=”Software engineer”;
person.prototype.sayName=function(){
alert(this.name);
}
var p1=new person();
var p2=new person();
只创建一个实例对象，对象变量对指向这个对象，对象属性和方法改变时，就在下面保存改变变量，实例对象只有一个并且不会改变
原型模式最大的好处就是最大限度的节省内存空间
function person(){
this.name=name;
this.age=age;
this.job=job;
this.sayName=function sayName(){
alert(this.name);
}
var s1=new person(1,23,”a”);
var s2=new person(2,24,”b”);
创建实例就开辟新的空间
小结：
工厂模式，使用简单的函数创建对象，为对象添加属性和方法，然后返回对象。这个模式后来被构造函数所取代
构造函数模式，可以创建自定义引用类型，可以像创建内置对象实例一样new操作符。不过，构造函数模式也有缺点，即它的每个成员都无法得到复用，包括函数。由于函数可以不局限于任何对象(即与对象具有松散耦合的特点)，因此没有理由不在多个对象间共享函数
原型模式,使用构造函数的prototypes属性来指定那些该共享的属性和方法。组合使用构造函数模式和原型模式时，使用构造函数定义实例属性，而使用原型定义共享的属性和方法
Attribute与Parameter区别：
request.getParameter()方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据。request.getParameter()方法返回String类型的数据。
request.setAttribute()和getAttribute()方法传递的数据只会存在于Web容器内部，在具有转发关系的Web组件之间共享。这两个方法能够设置Object类型的共享数据。
request.getParameter()取得是通过容器的实现来取得通过类似post，get等方式传入的数据。
request.setAttribute()和getAttribute()只是在web容器内部流转，仅仅是请求处理阶段。
getAttribute是返回对象,getParameter返回字符串
jsp九大内置对象:
1>out 向客户端输出数据,字节流.如out.print(" dgaweyr");
2>request 接收客户端的http请求.
String getParameter(String name):得到表单参数名name的值.
String[] getParameterValues(String name):(得到String[]复选框时常用).
setAttribute(String name,Object obj):设置属性名为name,属性值为obj.
getAttribute(String name);得到属性值.
3>response:封装jsp产生的回应,然后发送到客户端以响应客户的请求.重定向跳转任意界面.(服务器跳转)
addCookie(Cookie cookie):
sendRedirect("/wel.jsp"):跳转到指定页面
4>session:用于保存用户信息,跟踪用户行为,当前打开的浏览器内,多个页面共享数据. session对象指的是客户端与服务器的一次会话,从客户连到服务器的一个WebApplication开始,直到客户端与服务器断开连接为止.它是HttpSession类的实例.
setAttribute(String name,Object obj):设置属性名为name,属性值为obj.
getAttribute(String name):得到属性值.
5>application对象:实现了用户间数据的共享,可存放全局变量.它开始于服务器的启动,直到服务器的关闭,在此期间,此对象将一直存在;这样在用户的前后连接或不同用户之间的连接中,可以对此对象的同一属性进行操作;在任何地方对此对象属性的操作,都将影响到其他用户对此的访问.服务器的启动和关闭决定了application对象的生命.它是ServletContext类的实例.
session,application,request的区别:
一个项目中session尽量少用几个,因为过多的session会影响程序的执行效率.它主要用于保存登录信息(用户信息,权限,资源)即频繁使用的信息.
application: 用于多个浏览器之间共享数据,多个用户共享该对象,可以做计数器.它的用法与session完全一样.
数据范围:
application(服务器关闭时失效)>session(浏览器关闭时失效)>request(只能用于两个跳转页面之间)
6>page对象代表jsp这个实体本身,即当前页面有效.相当于Java中的this.
数据范围:page<session<application
7>.exception:代表运行时的异常.
在会发生异常的页面加入指令:<%@ page errorPage="处理错误的页面.jsp"%>
在处理异常的页面写入:<%@ page isErrorPage="true"%>
8>.pageContext对象 pageContext对象提供了对JSP页面内所有的对象及名字空间的访问,也就是说他可以访问到本页所在的SESSION,也可以取本页面所在的application的某一属性值,他相当于页面中所有功能的集大成者,它的本类名也叫pageContext.
9>.config jsp对应的servlet的配置,可以得到web.xml中的初使化参数.
jsp七大动作:
一:include 动态包含(分别编译):
用jsp:include动作实现<jsp: include page="included.jsp" flush="true" />
它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。flush属性: 用true ，表示页面可刷新。默认为false;
二:useBean动作(jsp页面使用javaBean的第二种方式):
<jsp:useBean id="对象名" class="包名.类名" scope="作用范围(request/page/application/session)"/>
作用域默认为page(本页面有效).
三:getProperty动作(name为useBean动作中的id).
从对象中取出属性值：<jsp:getProperty name="javaBean对象" property="javaBean对象属性名" />
四:setProperty动作(name为useBean动作中的id):
为对象设置属性值：<jsp:setProperty name="javaBean对象" property="javaBean对象属性名" value=http://www.hake.cc/kf/201109/"值"/>
为对象设置属性值:<jsp:setProperty property="javaBean对象属性名" name="javaBean对象" param="username"/>
(param="username" 相当于 value=http://www.hake.cc/kf/201109/<%=request.getParameter("username")%>)
五:param动作(传递参数)):
到达跳转页面可以通过 request.getParameter(“参数名”)方式取出参数值
<jsp:include page="转向页面的url" >
<jsp:param name="参数名1" value=http://www.hake.cc/kf/201109/"参数值1">
<jsp:param name="参数名2" value=http://www.hake.cc/kf/201109/"参数值2">
...........
</jsp:include>
或:
<jsp:forward page="转向页面的url" >
<jsp:param name="参数名1" value=http://www.hake.cc/kf/201109/"参数值1">
<jsp:param name="参数名2" value=http://www.hake.cc/kf/201109/"参数值2">
...........
</jsp:forward>
六:forward动作:
跳转页面:<jsp:forward page="login.jsp" />
七:plugin动作:<jsp:plugin>:用于指定在客户端运行的插件
JSP三大指令之:
一:page指令:
1.指定页面编码.例:
<%@ page language="java" contentType="text/html;charset=gbk" pageEncoding="gbk" %>
2.导入包,例:
<%@ page import="java.util.*,java.text.*" %>.
二:include 指令
静态包含(统一编译):<%@ include file="included.jsp"%>
三：taglib
Jsp中的静态包含与动态包含
动态include(<jsp: include page="included.jsp"/>)
静态include(<%@ include file="included.jsp"%>)
1. 静态include的结果是把其他jsp引入当前jsp,两者合为一体,可以达到数据的共享即可以说是统一编译的,而
动态include的结构是两者独立的,直到输出时才合并即为分别编译的.
2.动态include的jsp文件独立性很强,是一个单独的jsp文件,需要使用的对象,页面设置,都由自己创建,而静态include纯粹是把代码写在外面的一种共享方法,所有的变量都是可以和include它的主文件共享,两者高度紧密结合,不能 有变量同名的冲突.而页面设置也可以借用主文件的.
3.动态包含总是检查被包含页面的变化,静态包含不一定检查被包含页面的变化.
4.动态包含可带参数,静态包含不能带参数.如(<jsp: include page="included.jsp">放入参数</jsp:include>);
1、全局变量和局变量在一起的时候，结果是什么
var sum=100;
function setName(){
var sum=0;
return sum+5;
}
alert( setName);//5
2、function无参数，可以使用内置的参数的数组来取值
function sum( ){
return arguments[0]+ arguments[1];
}
alert( sum(2,3) );
3、==和===的区别
var a = "2";
var b = 2;
if(b == a) {
console.log("==是对的");
console.log("a的类型:" + (typeof a));
console.log("b的类型:" + (typeof b));
}
if(a === b) {
console.log("a===b:对的")
} else {
console.log("a===b:错误")
}
var c = true;
if(c == "1") {
console.log("true==1是成立的");
} else {
console.log("true==1是不的");
}
4、方法中私有方法
var a=10;
function swapnum(){
var b=5;
//私有方法
function swap(){
var temp=b;
b=a;
a=temp;
}
//在内部实现调用
swap();
}
swapnum()
console.log( a );
5、使用with关键字
function buildUrl(){
var arg="?degub=true";
with(location){
var url=href+arg;
}
return url;
}
var a=buildUrl();
console.log(a);
6、创建对象
//构造函数
function Person(id) {
this.pid = id;
this.getId = function() {
return this.pid;
}
this.setId = function(vid) {
this.pid = vid;
}
return this;
}
// 调用
var a = new Person(100); //创建一个对象
console.log(a.getId());
a.setId(20);
console.log(a.getId());
7、Array数组
//1、定义数组 相当于是 var arr=[];
var arr=new Array();
//2、往数组最后面插入数据
arr.push(10);
arr.push(11);
arr.push(12,13,14,15);
console.log(arr.toString());
//3、往最前面插入数据
arr.unshift(20,21,20,21);
console.log(arr.toString());
//4、从后面出栈 删除
//var c=arr.pop();
// console.log("删除的是"+c);
//console.log(arr.toString());
//5、从顶部移出
// var d=arr.shift();
//console.log("删除的是"+d);
//console.log(arr.toString());
//6、取出指定数组下标范围的数组
var newA=arr.slice(4);
console.log(newA);
//7、取得 下标4开始取，取2个
var newB=arr.slice(4,6);
console.log(newB);
//8、排序
arr.sort();
arr.reverse(); //降序
console.log(arr);
//9、 以-号连接出来
console.log( arr.join("-"));
8、使用系统默认的方法为 变量添加 属性或者方法
var person = {
_id: 0,
_name: ""
};
//定义3个变量id,name,age (只读的)
Object.defineProperties(person, {
id: {
get: function() {
return this._id;
},
set: function(newValue) {
this._id = newValue;
}
},
name: {
get: function() {
return this._name;
},
set: function(newValue) {
this._name = newValue;
}
},
age: {
value: 18,
writable: false
}
});
//调用
person.id = 1001;
person.name = "ttt";
person.age = 23;
console.log(person.id)
console.log(person.name)
console.log(person.age)
9、对象的调用有3种方式
//构造函数
function Person(id) {
this.pid = id;
this.getId = function() {
return this.pid;
}
this.setId =function(vid) {
this.pid = vid;
}
}
// 1、调用方式
var a = new Person(100); //创建一个对象
console.log("构造函数调用:"+a.getId());
//2、做为window的对象
Person(102);
console.log( "当成window对象了:"+window.getId());
//3、动态调用(委托)
var o=new Object(); //我要委托的人
Person.call(o, 105);
console.log("委托别人调用："+ o.getId()); \
弹框：
1)
boolean boo=new BookManageBiz().delete(bm);
String info=boo?"删除成功":"删除失败";
String str="<script type='text/javascript'>alert('"+info+"');window.location.href=
"+req.getContextPath()+"/findall.do';</script>";
PrintWriter out=resp.getWriter();
out.print(str);
out.flush();
out.close();
2)
<a href="javascript:mydelete(${b.b_Id})">删除</a>
<script type="text/javascript">
function mydelete(id){
if(confirm("你确定要删除吗?")){
window.location.href="/20170519/delete.do?id="+id;
}
}
</script>
3)
<script type="text/javascript">
window.onload = function() {
document.getElementById("myForm").onsubmit = function() {
var arr=["b_name","b_author","b_time"];
var a=["图书名称不能为空","作者姓名不能为空","购买日期不能为空"];
for(var i=0;i<arr.length;i++){
if(myId(arr[i]).length==0){
alert(a[i]);
return false;
}
}
if(myId("b_time").length>0){
var reg=/\d{4}-([1-12]|\d{2})-([1-9]|\d{2})/;
if(!reg.test(myId("b_time"))){
alert("日期格式错误，必须为yyyy-MM-dd");
return false;
}
}
return true;
}
function myId(id){
return document.getElementById(id).value;
}
}
</script>
