offsettop(弹出窗口的代码是什么)

【最基本的弹出窗口代码】

<!--

window.open ('page.HTML')

-->

</SCRIPT>

因为这是一段javascript代码，所以它们应该放在<SCRIPT LANGUAGE ="javascript">标签和</script>之间。

是对一些版本低的浏览器起作用，在这些老浏览器中如果不支持javascript，不会将标签中的代码作

为文本显示出来。

Window.open ('page.html')用于控制弹出新的窗口page.html，如果page.html不与主窗口在同一路径下，前面

应写明路径，绝对路径(http://)和相对路径(../)均可。

用单引号和双引号都可以，只是不要混用。

这一段代码可以加入HTML的任意位置，加入到<head>和</head>之间也可以，位置越靠前执行越早，尤其是页面

代码较长时，又想使页面早点弹出就尽量往前放。

【经过设置后的弹出窗口】

下面再说一说弹出窗口外观的设置。只要再往上面的代码中加一点东西就可以了。

我们来定制这个弹出窗口的外观、尺寸大小、弹出位置以适应该页面的具体情况。

<!--

window.open('page.html','newwindow','height=100,width=400,top=0,left=0,toolbar=no,menubar=no,scrollbars=no, resizable=no,location=no,status=no')

//写成一行

-->

</SCRIPT>

参数解释：

<SCRIPT LANGUAGE="java script"> js脚本开始；

window.open 弹出新窗口的命令；

page.html 弹出新窗口的文件名；

newwindow 弹出窗口的名字（不是文件名），可用空〃代替；

height=100 窗口高度；

top=0 窗口距离屏幕上方的像素值；

left=0 窗口距离屏幕左侧的像素值；

toolbar=no 是否显示工具栏，yes为显示；

menubar,scrollbars 表示菜单栏和滚动栏；

resizable=no 是否允许改变窗口大小，yes为允许；

location=no 是否显示地址栏，yes为允许；

status=no 是否显示状态栏内的信息（通常是文件已经打开），yes为允许；

</SCRIPT> js脚本结束。

【用函数控制弹出窗口】

下面是一个完整的代码。

<html>

<head>

<!--

function openwin(){

window.open("page.html","newwindow","height=100,width=400,toolbar=no,menubar=no,scrollbars=no, resizable=no,location=no,status=no";)

//写成一行

}

-->

</script>

</head>

...任意的页面内容...

</body>

</html>

这里定义了一个函数openwin(),函数内容就是打开一个窗口。在调用它之前没有任何用途。怎么调用呢？

方法一：<body onload="openwen()"> 浏览器读页面时弹出窗口；

方法二：<body onunload="openwen()"> 浏览器离开页面时弹出窗口；

方法三：用一个连接调用：<a href="#" onclick="openwin()">打开一个窗口</a>

注意：使用的"#"是虚连接。

方法四：用一个按钮调用：<input type="button" onclick="openwin()" value="打开窗口">

【主窗口打开文件1.htm，同时弹出小窗口page.html】

将如下代码加入主窗口<head>区：

<!--

function openwin(){

window.open("page.html","","width=200,height=200";)

}

//-->

</script>

加入<body>区：<a href="1.htm" onclick="openwin()">open</a>即可。

【弹出的窗口之定时关闭控制】

下面我们再对弹出窗口进行一些控制，效果就更好了。如果我们再将一小段代码加入弹出的页面（注意是加入到page.html的HTML中，可不是主页面中，否则…），让它在10秒钟后自动关闭是不是更酷了？

首先，将如下代码加入page.html文件的<head>区：

function closeit() {

setTimeout("self.close()",10000) //毫秒

}

</script>

然后，再用<body onload="closeit()">这一句话代替page.html中原有的<BODY>这一句就可以了。（这一句话千

万不要忘记写啊！这一句的作用是调用关闭窗口的代码，10秒钟后就自行关闭该窗口。）

【在弹出窗口中加上一个关闭按钮】

<form>

</form>

呵呵，现在更加完美了！

【内包含的弹出窗口——一个页面两个窗口】

上面的例子都包含两个窗口，一个是主窗口，另一个是弹出的小窗口。

通过下面的例子，你可以在一个页面内完成上面的效果。

<html>

<head>

function openwin()

{

OpenWindow=window.open("","newwin","height=250,width=250,toolbar=no,scrollbars="+scroll+",menubar=no";);

//写成一行

OpenWindow.document.write("<TITLE>例子</TITLE>";)

OpenWindow.document.write("<BODY BGCOLOR=#FFFFFF>";)

OpenWindow.document.write("<H1>Hello!</h1>";)

OpenWindow.document.write("New window opened!";)

OpenWindow.document.write("</BODY >";)

OpenWindow.document.write("</HTML>";)

OpenWindow.document.close()

}

</script>

</head>

<body>

<a href="#" onclick="openwin()">打开一个窗口</a>

</body>

</html>

看看OpenWindow.document.write()里面的代码不就是标准的HTML吗？只要按照格式写更多的行即可。千万注意多一个标签或少一个标签都会出现错误。记住用OpenWindow.document.close()结束啊。

【终极应用——弹出窗口的cookie控制】

回想一下，上面的弹出窗口虽然酷，但是有一点小毛病（你沉浸在喜悦之中，一定没有发现吧？）比如你将上面的脚本放在一个需要频繁经过的页面里（例如首页），那么每次刷新这个页面，窗口都会弹出一次，是不是非常烦人？有解决的办法吗？Yes!Follow me。我们使用Cookie来控制一下就可以了。

首先，将如下代码加入主页面HTML的<HEAD>区：

function openwin(){

window.open("page.html","","width=200,height=200" ;)

}

function get_cookie(Name){

var search = Name+ "="

var returnvalue ="";

if (documents.cookie.length >0){

offset = documents.cookie.indexOf(search)

if (offset!=-1){

offset += search.length

end = documents.cookie.indexOf (";",offset);

if (end ==-1)

end = documents.cookie.length;

returnvalue =unescape(documents.cookie.substring(offset,end))

}

return returnvalue;

}

function loadpopup(){

if (get_cookie(’popped’)==";){

openwin()

documents.cookie="popped=yes"

}

</script>

然后，用<body onload="loadpopup()">（注意不是openwin 而是loadpop啊）替换主页面中原有的<BODY>这一句即可。你可以试着刷新一下这个页面或重新进入该页面，窗口再也不会弹出了。真正的Pop-Only-Once!

写到这里，弹出窗口的制作和应用技巧基本上算是讲完了，希望对正在制作网页的朋友有所帮助我就非常欣慰了。

需要注意的是，JS脚本中的大小写最好前后保持一致。

没有菜单、工具栏、地址栏的弹出窗口：

<!--

var gt = unescape('%3e');

var popup = null;

var over = "Launch Pop-up Navigator";

popup = window.open('', 'popupnav', 'width=500,height=500,resizable=0,scrollbars=auto'); // width=500,height=500为窗口长和宽

if (popup != null) {

if (popup.opener == null) {

popup.opener = self; }

popup.location.href = '要打开的文件名';

}

// -->

</script>

离开一个页面时弹出一个可定制的窗口

<!-- Begin

function leave() {

window.open(\'离开页面时弹出窗口的URL\',\'\',\'toolbar=no,menubar=no,location=no,height=235,width=320\');

}

// End -->

</script>

如下代码加入HTML的<BODY>区：<body onUnload="leave()">

超级弹窗代码(MYIE也照弹)

focusid=setTimeout("focus();window.showModelessDialog(\'http://www.3tian.com\',\'\',\'scroll:1;status:0;help:0;resizable:1;dialogWidth:0px;dialogHeight:0px\')",0000)

</script>

<!--

function clock(){i=i-1

document.title="";#定义标题

if(i>0)setTimeout("clock();",1000);

else self.close();}

var i=4#定义多少秒后关

clock();

//-->

</script>

线程出现异常测试

任务类：Task.javapublic class Task implements Runnable {

private int i;

public Task(int i) {

this.i = i;

}

@Override

public void run() {

if (i == 5) {

//System.out.println("throw exception");

throw new IllegalArgumentException();

}

System.out.println(i);

}

如果i==5，将抛出一个异常

线程测试类：TaskTest.java

public class TestTask {

public static void main(String[] args) {

int i = 0;

while (true) {

if (i == 10) break;

try {

new Thread(new Task(i++)).start();

} catch (Exception e) {

System.out.println("catch exception...");

}

通过使用try-catch，尝试对抛出的异常进行捕获

测试结果

Connected to the target VM, address: '127.0.0.1:64551', transport: 'socket'

Exception in thread "pool-1-thread-1" java.lang.IllegalArgumentException

at com.h2t.study.thread.Task.run(Task.java:21)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)

at java.lang.Thread.run(Thread.java:748)

异常没有被捕获，只是在控制台打印了异常，并且不影响后续任务的执行 emmmm这是为什么呢，捕获不到异常就不知道程序出错了，到时候哪天有个任务不正常排查都排查不到，这样是要不得的。看一下Thread这个类，有个叫dispatchUncaughtException的方法，作用如其名，分发未捕获的异常，把这段代码揪出来：Thread#dispatchUncaughtException

private void dispatchUncaughtException(Throwable e) {

getUncaughtExceptionHandler().uncaughtException(this, e);

}

find usage是找不到该方法在哪里调用的，因为这个方法只被JVM调用 Thread#getUncaughtExceptionHandler：获取UncaughtExceptionHandler接口实现类

public UncaughtExceptionHandler getUncaughtExceptionHandler() {

return uncaughtExceptionHandler != null ?

uncaughtExceptionHandler : group;

}

UncaughtExceptionHandler是Thread中定义的接口，在Thread类中uncaughtExceptionHandler默认是null，因此该方法将返回group，即实现了UncaughtExceptionHandler接口的ThreadGroup类 UncaughtExceptionHandler#uncaughtException： ThreadGroup类的uncaughtException方法实现

public void uncaughtException(Thread t, Throwable e) {

if (parent != null) {

parent.uncaughtException(t, e);

} else {

Thread.UncaughtExceptionHandler ueh =

Thread.getDefaultUncaughtExceptionHandler();

if (ueh != null) {

ueh.uncaughtException(t, e);

} else if (!(e instanceof ThreadDeath)) {

System.err.print("Exception in thread \""

+ t.getName() + "\" ");

e.printStackTrace(System.err);

}

因为在Thread类中没有对group【parent】和defaultUncaughtExceptionHandler【Thread.getDefaultUncaughtExceptionHandler】进行赋值，因此将进入最后一层条件，将异常打印到控制台中，对异常不做任何处理。整个异常处理器调用链如下：

首先判断默认异常处理器【defaultUncaughtExceptionHandler】是不是为null，在判断线程组异常处理器【group】是不是为null，在判断自定义异常处理器【uncaughtExceptionHandler】是不是为null，都为null则在控制台打印异常

线程异常处理

分析了一下源码就知道如果想对任务执行过程中的异常进行处理一个就是让ThreadGroup不为null，另外一种思路就是让UncaughtExceptionHandler类型的变量值不为null。

异常处理器：ExceptionHandler.java

private static class ExceptionHandler implements Thread.UncaughtExceptionHandler {

@Override

public void uncaughtException(Thread t, Throwable e) {

System.out.println("异常捕获到了：" + e);

}

设置默认异常处理器

Thread.setDefaultUncaughtExceptionHandler((t, e) -> System.out.println("异常捕获到了: " + e));

int i = 0;

while (true) {

if (i == 10) break;

Thread thread = new Thread(new Task(i++));

thread.start();

}

打印结果：

异常捕获到了：java.lang.IllegalArgumentException

通过设置默认异常就不需要为每个线程都设置一次了

设置自定义异常处理器

Thread t = new Thread(new Task(i++));

t.setUncaughtExceptionHandler(new ExceptionHandler());

打印结果：

异常捕获到了：java.lang.IllegalArgumentException

设置线程组异常处理器

MyThreadGroup myThreadGroup = new MyThreadGroup("测试线程线程组");

Thread t = new Thread(myThreadGroup, new Task(i++))

自定义线程组：MyThreadGroup.java

private static class MyThreadGroup extends ThreadGroup {

public MyThreadGroup(String name) {

super(name);

}

@Override

public void uncaughtException(Thread t, Throwable e) {

System.out.println("捕获到异常了：" + e);

}

打印结果：

捕获到异常了：java.lang.IllegalArgumentException

线程组异常捕获处理器很适合为线程进行分组处理的场景，每个分组出现异常的处理方式不相同设置完异常处理器后异常都能被捕获了，但是不知道为什么设置异常处理器后任务的执行顺序乱了，难道是因为为每个线程设置异常处理器的时间不同【想不通】

线程池异常处理

一般应用中线程都是通过线程池创建复用的，因此对线程池的异常处理就是为线程池工厂类【ThreadFactory实现类】生成的线程添加异常处理器

默认异常处理器

Thread.setDefaultUncaughtExceptionHandler(new ExceptionHandler());

ExecutorService es = Executors.newCachedThreadPool();

es.execute(new Task(i++))

自定义异常处理器

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>());

threadPoolExecutor.setThreadFactory(new MyThreadFactory());

threadPoolExecutor.execute(new Task(i++));

自定义工厂类：

MyThreadFactory.java

private static class MyThreadFactory implements ThreadFactory {

@Override

public Thread newThread(Runnable r) {

Thread t = new Thread();

//自定义UncaughtExceptionHandler

t.setUncaughtExceptionHandler(new ExceptionHandler());

return t;

}

设计原则，为什么要由线程自身进行捕获

来自JVM的设计理念"线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部"。因此在Java中，线程方法的异常【即任务抛出的异常】，应该在线程代码边界之内处理掉，而不应该在线程方法外面由其他线程处理

线程执行Callable任务

前面介绍的是线程执行Runnable类型任务的情况，众所周知，还有一种有返回值的Callable任务类型测试代码：

TestTask.java

public class TestTask {

public static void main(String[] args) {

int i = 0;

while (true) {

if (i == 10) break;

FutureTask<Integer> task = new FutureTask<>(new CallableTask(i++));

Thread thread = new Thread(task);

thread.setUncaughtExceptionHandler(new ExceptionHandler());

thread.start();

}

private static class ExceptionHandler implements Thread.UncaughtExceptionHandler {

@Override

public void uncaughtException(Thread t, Throwable e) {

System.out.println("异常捕获到了：" + e);

}

打印结果：

Disconnected from the target VM, address: '127.0.0.1:64936', transport: 'socket'

观察结果，异常没有被捕获，thread.setUncaughtExceptionHandler(new ExceptionHandler())方法设置无效，emmmmm，这又是为什么呢，在问为什么就是十万个为什么儿童了。查看FutureTask的run方法，FutureTask#run：

public void run() {

if (state != NEW ||

!UNSAFE.compareAndSwapObject(this, runnerOffset,

null, Thread.currentThread()))

return;

try {

Callable<V> c = callable;

if (c != null && state == NEW) {

V result;

boolean ran;

try {

result = c.call();

ran = true;

} catch (Throwable ex) {

result = null;

ran = false;

setException(ex);

}

if (ran)

set(result);

}

} finally {

// runner must be non-null until state is settled to

// prevent concurrent calls to run()

runner = null;

// state must be re-read after nulling runner to prevent

// leaked interrupts

int s = state;

if (s >= INTERRUPTING)

handlePossibleCancellationInterrupt(s);

}

FutureTask#setException：

protected void setException(Throwable t) {

if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {

//将异常设置给outcome变量

outcome = t;

//设置任务的状态为EXCEPTIONAL

UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state

finishCompletion();

}

看到catch这段代码，当执行任务捕获到异常的时候，会将任务的处理结果设置为null，并且调用setException方法对捕获的异常进行处理，因为setUncaughtExceptionHandler只对未捕获的异常进行处理，FutureTask已经对异常进行了捕获处理，因此调用setUncaughtExceptionHandler捕获异常无效对任务的执行结果调用get方法：

int i = 0;

while (true) {

if (i == 10) break;

FutureTask<Integer> task = new FutureTask<>(new CallableTask(i++));

Thread thread = new Thread(task);

thread.setUncaughtExceptionHandler(new ExceptionHandler());

thread.start();

//打印结果

try {

System.out.println(task.get());

} catch (Exception e) {

System.out.println("异常被抓住了, e: " + e);

}

执行结果将会将捕获到的异常打印出来，执行结果：

异常被抓住了, e: java.util.concurrent.ExecutionException: java.lang.IllegalArgumentException

Disconnected from the target VM, address: '127.0.0.1:50900', transport: 'socket'

FutureTask#get：

public V get() throws InterruptedException, ExecutionException {

int s = state;

if (s <= COMPLETING)

//未完成等待任务执行完成

s = awaitDone(false, 0L);

return report(s);

}

FutureTask#report：

private V report(int s) throws ExecutionException {

Object x = outcome;

if (s == NORMAL)

return (V)x;

if (s >= CANCELLED)

throw new CancellationException();

throw new ExecutionException((Throwable)x);

}

outcome在setException方法中被设置为了异常，并且s为state的状态最终8被设置为EXCEPTIONAL，因此方法将捕获的任务抛出【new ExecutionException((Throwable)x)】

总结：

Callable任务抛出的异常能在代码中通过try-catch捕获到，但是只有调用get方法后才能捕获到

【北京】IT技术人员面对面试、跳槽、升职等问题，如何快速成长，获得大厂入门资格和升职加薪的筹码？与大厂技术大牛面对面交流，解答你的疑惑。《从职场小白到技术总监成长之路：我的职场焦虑与救赎》活动链接：http://mk1.top/1ndjnvb

想了解更多Java相关，百度搜索圈T社区www.aiquanti.com，免费视频教程。纯干货

初始记录行的偏移量是0(而不是1)：为了与PostgreSQL兼容，MySQL也支持句方法：LIMIT#OFFSET#。

1、代码:SELECT*FROMtableLIMIT2OFFSET1; 比如这个SQL，limit后面跟的是2条数据，offset后面是从第1条开始读取。

2、代码:SELECT*FROMtableLIMIT2,1; 而这个SQL，limit后面是从第2条开始读，读取1条信息。查询时间最新目的几条记录的SQL语句：

3、代码:SELECT*FROMtableorderbytimedescLIMITn; 注意limit用法在sqlserver2000中却不适用！会查询错误。 sqlserver2000中查询的方法是 4、代码:selecttop2*fromtable; 也就是用到top。上面的语句查处表中的前两条数据。

首先要取得top值和left值，先要把这个div的定位设为 relative 或者 absolute比如：

top值： document.getElementById('tiao').offsetTop+document.body.scrollTopleft值：document.getElementById('tiao').offsetLeft;

这是最古老的js滚动代码了，人家的最初完成dome 是没问题的，估计的看到的是不知道转手多少次的了

问题出在这

demo.scrollTop -= demo1.offsetHeight //demo跳到最顶端

在浏览器中 P有默认margin ；但margin 高度不计算在 offsetHeight