js

　　JScript 脚本技术　　Microsoft 功能强大的脚本编写语言是专为 Internet 而设计的 JScript NET 是 Microsoft ECMA 语言的下一代实施产品 与 ECMAScript Edition 一起开发的 JScript NET 中的改进功能包括了准确编译的代码 类型与无类型的变量 类（内含继承 函数重载 属性访问器等等） 包 跨语言支持 以及对 NET 框架的访问 　　VBScript 　　Microsoft Visual Basic Scripting Edition 为各种环境提供有效的脚本编写手段 包括 Microsoft Internet Explorer 中的 Web 客户端脚本编写及 Microsoft Internet Information Services 中的 Web 服务器端脚本编写 　　脚本运行时 　　Dictionary 对象相当于 PERL 的关联数组 项可以是任意形式的数据 存储在数组中 每一个项与唯一的关键字相关联 关键字用于检索个别项 通常是一个整数或字符串 它可以是数组以外的任何内容 　　FileSystemObject (FSO) 对象模型允许您使用熟悉的 thod 语法以及一系列属性 方法和事件来处理文件夹和文件 　　脚本 Encoder 是一种简单的命令行工具 它使脚本设计者能够对自己的最终脚本进行编码 这样 Web 主机和 Web 客户机就不能查看或修改它们的源代码 lishixinzhi/Article/program/Java/JSP/201311/19384

因为ajax提交时，必须显示的把表单值设上，你看看你写的这句：data:{ "action":"get", "dz":"jbxx" }里面没pwd这个值，所以System.out.println(request.getParameter("pwd"));是null

这次给大家带来如何使用JS装饰器函数，使用JS装饰器函数的注意事项有哪些，下面就是实战案例，一起来看一下。在 ES6 中增加了对类对象的相关定义和操作（比如 class 和 extends ），这就使得我们在多个不同类之间共享或者扩展一些方法或者行为的时候，变得并不是那么优雅。这个时候，我们就需要一种更优雅的方法来帮助我们完成这些事情。什么是装饰器Python 的装饰器在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持 OOP 的 decorator 外，直接从语法层次支持 decorator。如果你熟悉 python 的话，对它一定不会陌生。那么我们先来看一下 python 里的装饰器是什么样子的吧：def decorator(f): print "my decorator" return f@decoratordef myfunc(): print "my function"myfunc()# my decorator# my function这里的 @decorator 就是我们说的装饰器。在上面的代码中，我们利用装饰器给我们的目标方法执行前打印出了一行文本，并且并没有对原方法做任何的修改。代码基本等同于：def decorator(f): def wrapper(): print "my decorator" return f() return wrapperdef myfunc(): print "my function"myfunc = decorator(myfuc)通过代码我们也不难看出，装饰器 decorator 接收一个参数，也就是我们被装饰的目标方法，处理完扩展的内容以后再返回一个方法，供以后调用，同时也失去了对原方法对象的访问。当我们对某个应用了装饰以后，其实就改变了被装饰方法的入口引用，使其重新指向了装饰器返回的方法的入口点，从而来实现我们对原函数的扩展、修改等操作。ES7 的装饰器ES7 中的 decorator 同样借鉴了这个语法糖，不过依赖于 ES5 的 Object.defineProperty 方法 。Object.definePropertyObject.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。该方法允许精确添加或修改对象的属性。通过赋值来添加的普通属性会创建在属性枚举期间显示的属性（for...in 或 Object.keys 方法）， 这些值可以被改变，也可以被删除。这种方法允许这些额外的细节从默认值改变。默认情况下，使用 Object.defineProperty() 添加的属性值是不可变的。语法Object.defineProperty(obj, prop, descriptor)obj：要在其上定义属性的对象。prop：要定义或修改的属性的名称。descriptor：将被定义或修改的属性描述符。返回值：被传递给函数的对象。在ES6中，由于 Symbol类型 的特殊性，用 Symbol类型 的值来做对象的key与常规的定义或修改不同，而Object.defineProperty 是定义 key为 Symbol 的属性的方法之一。属性描述符对象里目前存在的属性描述符有两种主要形式：数据描述符和存取描述符。数据描述符是一个具有值的属性，该值可能是可写的，也可能不是可写的。存取描述符是由 getter-setter 函数对描述的属性。描述符必须是这两种形式之一；不能同时是两者。数据描述符和存取描述符均具有以下可选键值：configurable当且仅当该属性的 configurable 为 true 时，该属性描述符才能够被改变，同时该属性也能从对应的对象上被删除。默认为 false。enumerableenumerable定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举。当且仅当该属性的 enumerable 为 true 时，该属性才能够出现在对象的枚举属性中。默认为 false。数据描述符同时具有以下可选键值：value该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined。writable当且仅当该属性的 writable 为 true 时，value 才能被赋值运算符改变。默认为 false。存取描述符同时具有以下可选键值：get一个给属性提供 getter 的方法，如果没有 getter 则为 undefined。该方法返回值被用作属性值。默认为 undefined。set一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。该方法将接受唯一参数，并将该参数的新值分配给该属性。默认为 undefined。如果一个描述符不具有value,writable,get 和 set 任意一个关键字，那么它将被认为是一个数据描述符。如果一个描述符同时有(value或writable)和(get或set)关键字，将会产生一个异常。用法类的装饰@testableclass MyTestableClass { // ...}function testable(target) { target.isTestable = true;}MyTestableClass.isTestable // true上面代码中，@testable 就是一个装饰器。它修改了 MyTestableClass这 个类的行为，为它加上了静态属性isTestable。testable 函数的参数 target 是 MyTestableClass 类本身。基本上，装饰器的行为就是下面这样。@decoratorclass A {}// 等同于class A {}A = decorator(A) || A;也就是说，装饰器是一个对类进行处理的函数。装饰器函数的第一个参数，就是所要装饰的目标类。如果觉得一个参数不够用，可以在装饰器外面再封装一层函数。function testable(isTestable) { return function(target) { target.isTestable = isTestable; }}@testable(true)class MyTestableClass {}MyTestableClass.isTestable // true@testable(false)class MyClass {}MyClass.isTestable // false上面代码中，装饰器 testable 可以接受参数，这就等于可以修改装饰器的行为。注意，装饰器对类的行为的改变，是代码编译时发生的，而不是在运行时。这意味着，装饰器能在编译阶段运行代码。也就是说，装饰器本质就是编译时执行的函数。前面的例子是为类添加一个静态属性，如果想添加实例属性，可以通过目标类的 prototype 对象操作。下面是另外一个例子。// mixins.jsexport function mixins(...list) { return function (target) { Object.assign(target.prototype, ...list) }}// main.jsimport { mixins } from "./mixins"const Foo = { foo() { console.log("foo") }};@mixins(Foo)class MyClass {}let obj = new MyClass();obj.foo() // "foo"上面代码通过装饰器 mixins，把Foo对象的方法添加到了 MyClass 的实例上面。方法的装饰装饰器不仅可以装饰类，还可以装饰类的属性。class Person { @readonly name() { return `${this.first} ${this.last}` }}上面代码中，装饰器 readonly 用来装饰“类”的name方法。装饰器函数 readonly 一共可以接受三个参数。function readonly(target, name, descriptor){ // descriptor对象原来的值如下 // { // value: specifiedFunction, // enumerable: false, // configurable: true, // writable: true // }; descriptor.writable = false; return descriptor;}readonly(Person.prototype, "name", descriptor);// 类似于Object.defineProperty(Person.prototype, "name", descriptor);装饰器第一个参数是 类的原型对象，上例是 Person.prototype，装饰器的本意是要“装饰”类的实例，但是这个时候实例还没生成，所以只能去装饰原型（这不同于类的装饰，那种情况时target参数指的是类本身）；第二个参数是 所要装饰的属性名第三个参数是 该属性的描述对象另外，上面代码说明，装饰器（readonly）会修改属性的 描述对象（descriptor），然后被修改的描述对象再用来定义属性。函数方法的装饰装饰器只能用于类和类的方法，不能用于函数，因为存在函数提升。另一方面，如果一定要装饰函数，可以采用高阶函数的形式直接执行。function doSomething(name) { console.log("Hello, " + name);}function loggingDecorator(wrapped) { return function() { console.log("Starting"); const result = wrapped.apply(this, arguments); console.log("Finished"); return result; }}const wrapped = loggingDecorator(doSomething);core-decorators.jscore-decorators.js是一个第三方模块，提供了几个常见的装饰器，通过它可以更好地理解装饰器。@autobindautobind 装饰器使得方法中的this对象，绑定原始对象。@readonlyreadonly 装饰器使得属性或方法不可写。@overrideoverride 装饰器检查子类的方法，是否正确覆盖了父类的同名方法，如果不正确会报错。import { override } from "core-decorators";class Parent { speak(first, second) {}}class Child extends Parent { @override speak() {} // SyntaxError: Child#speak() does not properly override Parent#speak(first, second)}// orclass Child extends Parent { @override speaks() {} // SyntaxError: No descriptor matching Child#speaks() was found on the prototype chain. // // Did you mean "speak"?}@deprecate (别名@deprecated)deprecate 或 deprecated 装饰器在控制台显示一条警告，表示该方法将废除。import { deprecate } from "core-decorators";class Person { @deprecate facepalm() {} @deprecate("We stopped facepalming") facepalmHard() {} @deprecate("We stopped facepalming", { url: "http://knowyourmeme.com/memes/facepalm" }) facepalmHarder() {}}let person = new Person();person.facepalm();// DEPRECATION Person#facepalm: This function will be removed in future versions.person.facepalmHard();// DEPRECATION Person#facepalmHard: We stopped facepalmingperson.facepalmHarder();// DEPRECATION Person#facepalmHarder: We stopped facepalming//// See http://knowyourmeme.com/memes/facepalm for more details.//@suppressWarningssuppressWarnings 装饰器抑制 deprecated 装饰器导致的 console.warn() 调用。但是，异步代码发出的调用除外。使用场景装饰器有注释的作用@testableclass Person { @readonly @nonenumerable name() { return `${this.first} ${this.last}` }}有了装饰器，就可以改写上面的代码。装饰@connect(mapStateToProps, mapDispatchToProps)export default class MyReactComponent extends React.Component {}相对来说，后一种写法看上去更容易理解。新功能提醒或权限菜单点击时，进行事件拦截，若该菜单有新功能更新，则弹窗显示。/** * @description 在点击时，如果有新功能提醒，则弹窗显示 * @param code 新功能的code * @returns {function(*, *, *)} */ const checkRecommandFunc = (code) => (target, property, descriptor) => { let desF = descriptor.value; descriptor.value = function (...args) { let recommandFuncModalData = SYSTEM.recommandFuncCodeMap[code]; if (recommandFuncModalData && recommandFuncModalData.id) { setTimeout(() => { this.props.dispatch({type: "global/setRecommandFuncModalData", recommandFuncModalData}); }, 1000); } desF.apply(this, args); }; return descriptor; };loading在 React 项目中，我们可能需要在向后台请求数据时，页面出现 loading 动画。这个时候，你就可以使用装饰器，优雅地实现功能。@autobind@loadingWrap(true)async handleSelect(params) { await this.props.dispatch({ type: "product_list/setQuerypParams", querypParams: params });}loadingWrap 函数如下：、export function loadingWrap(needHide) { const defaultLoading = ( <p className="toast-loading"> <Loading className="loading-icon"/> <p>加载中...</p> </p> ); return function (target, property, descriptor) { const raw = descriptor.value; descriptor.value = function (...args) { Toast.info(text || defaultLoading, 0, null, true); const res = raw.apply(this, args); if (needHide) { if (get("finally")(res)) { res.finally(() => { Toast.hide(); }); } else { Toast.hide(); } } }; return descriptor; };}问题：这里大家可以想想看，如果我们不希望每次请求数据时都出现 loading，而是要求只要后台请求时间大于 300ms 时，才显示loading，这里需要怎么改？相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：怎样进行JQuery元素查找与操作怎样使用nodeJS模块

这次给大家带来怎样在项目中使用JS装饰器函数，怎在项目中使用JS装饰器函数的注意事项有哪些，下面就是实战案例，一起来看一下。在 ES6 中增加了对类对象的相关定义和操作（比如 class 和 extends ），这就使得我们在多个不同类之间共享或者扩展一些方法或者行为的时候，变得并不是那么优雅。这个时候，我们就需要一种更优雅的方法来帮助我们完成这些事情。什么是装饰器Python 的装饰器在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持 OOP 的 decorator 外，直接从语法层次支持 decorator。如果你熟悉 python 的话，对它一定不会陌生。那么我们先来看一下 python 里的装饰器是什么样子的吧：def decorator(f): print "my decorator" return f@decoratordef myfunc(): print "my function"myfunc()# my decorator# my function这里的 @decorator 就是我们说的装饰器。在上面的代码中，我们利用装饰器给我们的目标方法执行前打印出了一行文本，并且并没有对原方法做任何的修改。代码基本等同于：def decorator(f): def wrapper(): print "my decorator" return f() return wrapperdef myfunc(): print "my function"myfunc = decorator(myfuc)通过代码我们也不难看出，装饰器 decorator 接收一个参数，也就是我们被装饰的目标方法，处理完扩展的内容以后再返回一个方法，供以后调用，同时也失去了对原方法对象的访问。当我们对某个应用了装饰以后，其实就改变了被装饰方法的入口引用，使其重新指向了装饰器返回的方法的入口点，从而来实现我们对原函数的扩展、修改等操作。ES7 的装饰器ES7 中的 decorator 同样借鉴了这个语法糖，不过依赖于 ES5 的 Object.defineProperty 方法 。Object.definePropertyObject.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。该方法允许精确添加或修改对象的属性。通过赋值来添加的普通属性会创建在属性枚举期间显示的属性（for...in 或 Object.keys 方法）， 这些值可以被改变，也可以被删除。这种方法允许这些额外的细节从默认值改变。默认情况下，使用 Object.defineProperty() 添加的属性值是不可变的。语法Object.defineProperty(obj, prop, descriptor)obj：要在其上定义属性的对象。prop：要定义或修改的属性的名称。descriptor：将被定义或修改的属性描述符。返回值：被传递给函数的对象。在ES6中，由于 Symbol类型 的特殊性，用 Symbol类型 的值来做对象的key与常规的定义或修改不同，而Object.defineProperty 是定义 key为 Symbol 的属性的方法之一。属性描述符对象里目前存在的属性描述符有两种主要形式：数据描述符和存取描述符。数据描述符是一个具有值的属性，该值可能是可写的，也可能不是可写的。存取描述符是由 getter-setter 函数对描述的属性。描述符必须是这两种形式之一；不能同时是两者。数据描述符和存取描述符均具有以下可选键值：configurable当且仅当该属性的 configurable 为 true 时，该属性描述符才能够被改变，同时该属性也能从对应的对象上被删除。默认为 false。enumerableenumerable定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举。当且仅当该属性的 enumerable 为 true 时，该属性才能够出现在对象的枚举属性中。默认为 false。数据描述符同时具有以下可选键值：value该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined。writable当且仅当该属性的 writable 为 true 时，value 才能被赋值运算符改变。默认为 false。存取描述符同时具有以下可选键值：get一个给属性提供 getter 的方法，如果没有 getter 则为 undefined。该方法返回值被用作属性值。默认为 undefined。set一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。该方法将接受唯一参数，并将该参数的新值分配给该属性。默认为 undefined。如果一个描述符不具有value,writable,get 和 set 任意一个关键字，那么它将被认为是一个数据描述符。如果一个描述符同时有(value或writable)和(get或set)关键字，将会产生一个异常。用法类的装饰@testableclass MyTestableClass { // ...}function testable(target) { target.isTestable = true;}MyTestableClass.isTestable // true上面代码中，@testable 就是一个装饰器。它修改了 MyTestableClass这 个类的行为，为它加上了静态属性isTestable。testable 函数的参数 target 是 MyTestableClass 类本身。基本上，装饰器的行为就是下面这样。@decoratorclass A {}// 等同于class A {}A = decorator(A) || A;也就是说，装饰器是一个对类进行处理的函数。装饰器函数的第一个参数，就是所要装饰的目标类。如果觉得一个参数不够用，可以在装饰器外面再封装一层函数。function testable(isTestable) { return function(target) { target.isTestable = isTestable; }}@testable(true)class MyTestableClass {}MyTestableClass.isTestable // true@testable(false)class MyClass {}MyClass.isTestable // false上面代码中，装饰器 testable 可以接受参数，这就等于可以修改装饰器的行为。注意，装饰器对类的行为的改变，是代码编译时发生的，而不是在运行时。这意味着，装饰器能在编译阶段运行代码。也就是说，装饰器本质就是编译时执行的函数。前面的例子是为类添加一个静态属性，如果想添加实例属性，可以通过目标类的 prototype 对象操作。下面是另外一个例子。// mixins.jsexport function mixins(...list) { return function (target) { Object.assign(target.prototype, ...list) }}// main.jsimport { mixins } from "./mixins"const Foo = { foo() { console.log("foo") }};@mixins(Foo)class MyClass {}let obj = new MyClass();obj.foo() // "foo"上面代码通过装饰器 mixins，把Foo对象的方法添加到了 MyClass 的实例上面。方法的装饰装饰器不仅可以装饰类，还可以装饰类的属性。class Person { @readonly name() { return `${this.first} ${this.last}` }}上面代码中，装饰器 readonly 用来装饰“类”的name方法。装饰器函数 readonly 一共可以接受三个参数。function readonly(target, name, descriptor){ // descriptor对象原来的值如下 // { // value: specifiedFunction, // enumerable: false, // configurable: true, // writable: true // }; descriptor.writable = false; return descriptor;}readonly(Person.prototype, "name", descriptor);// 类似于Object.defineProperty(Person.prototype, "name", descriptor);装饰器第一个参数是 类的原型对象，上例是 Person.prototype，装饰器的本意是要“装饰”类的实例，但是这个时候实例还没生成，所以只能去装饰原型（这不同于类的装饰，那种情况时target参数指的是类本身）；第二个参数是 所要装饰的属性名第三个参数是 该属性的描述对象另外，上面代码说明，装饰器（readonly）会修改属性的 描述对象（descriptor），然后被修改的描述对象再用来定义属性。函数方法的装饰装饰器只能用于类和类的方法，不能用于函数，因为存在函数提升。另一方面，如果一定要装饰函数，可以采用高阶函数的形式直接执行。function doSomething(name) { console.log("Hello, " + name);}function loggingDecorator(wrapped) { return function() { console.log("Starting"); const result = wrapped.apply(this, arguments); console.log("Finished"); return result; }}const wrapped = loggingDecorator(doSomething);core-decorators.jscore-decorators.js是一个第三方模块，提供了几个常见的装饰器，通过它可以更好地理解装饰器。@autobindautobind 装饰器使得方法中的this对象，绑定原始对象。@readonlyreadonly 装饰器使得属性或方法不可写。@overrideoverride 装饰器检查子类的方法，是否正确覆盖了父类的同名方法，如果不正确会报错。import { override } from "core-decorators";class Parent { speak(first, second) {}}class Child extends Parent { @override speak() {} // SyntaxError: Child#speak() does not properly override Parent#speak(first, second)}// orclass Child extends Parent { @override speaks() {} // SyntaxError: No descriptor matching Child#speaks() was found on the prototype chain. // // Did you mean "speak"?}@deprecate (别名@deprecated)deprecate 或 deprecated 装饰器在控制台显示一条警告，表示该方法将废除。import { deprecate } from "core-decorators";class Person { @deprecate facepalm() {} @deprecate("We stopped facepalming") facepalmHard() {} @deprecate("We stopped facepalming", { url: "http://knowyourmeme.com/memes/facepalm" }) facepalmHarder() {}}let person = new Person();person.facepalm();// DEPRECATION Person#facepalm: This function will be removed in future versions.person.facepalmHard();// DEPRECATION Person#facepalmHard: We stopped facepalmingperson.facepalmHarder();// DEPRECATION Person#facepalmHarder: We stopped facepalming//// See http://knowyourmeme.com/memes/facepalm for more details.//@suppressWarningssuppressWarnings 装饰器抑制 deprecated 装饰器导致的 console.warn() 调用。但是，异步代码发出的调用除外。使用场景装饰器有注释的作用@testableclass Person { @readonly @nonenumerable name() { return `${this.first} ${this.last}` }}有了装饰器，就可以改写上面的代码。装饰@connect(mapStateToProps, mapDispatchToProps)export default class MyReactComponent extends React.Component {}相对来说，后一种写法看上去更容易理解。新功能提醒或权限菜单点击时，进行事件拦截，若该菜单有新功能更新，则弹窗显示。/** * @description 在点击时，如果有新功能提醒，则弹窗显示 * @param code 新功能的code * @returns {function(*, *, *)} */ const checkRecommandFunc = (code) => (target, property, descriptor) => { let desF = descriptor.value; descriptor.value = function (...args) { let recommandFuncModalData = SYSTEM.recommandFuncCodeMap[code]; if (recommandFuncModalData && recommandFuncModalData.id) { setTimeout(() => { this.props.dispatch({type: "global/setRecommandFuncModalData", recommandFuncModalData}); }, 1000); } desF.apply(this, args); }; return descriptor; };loading在 React 项目中，我们可能需要在向后台请求数据时，页面出现 loading 动画。这个时候，你就可以使用装饰器，优雅地实现功能。@autobind@loadingWrap(true)async handleSelect(params) { await this.props.dispatch({ type: "product_list/setQuerypParams", querypParams: params });}loadingWrap 函数如下：、export function loadingWrap(needHide) { const defaultLoading = ( <p className="toast-loading"> <Loading className="loading-icon"/> <p>加载中...</p> </p> ); return function (target, property, descriptor) { const raw = descriptor.value; descriptor.value = function (...args) { Toast.info(text || defaultLoading, 0, null, true); const res = raw.apply(this, args); if (needHide) { if (get("finally")(res)) { res.finally(() => { Toast.hide(); }); } else { Toast.hide(); } } }; return descriptor; };}相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：express + mock如何操作前后台并行开发字符串+数组去重实战案例解析

百度搜索下载。就能使用

//连接SQL 代码如下: var conn = new ActiveXObject("ADODB.Connection"); conn.Open("Provider=SQLOLEDB.1; Data Source=tgf; User ID=sa; " +"Password=sasa; Initial Catalog=MyBulletin"); var rs = new ActiveXObject("ADODB.Recordset"); var sql="select id,name from Category"; rs.open(sql, conn); alert(rs(0));//取出第一个来 rs.close(); rs = null; conn.close(); conn = null; //连接ACCESS 代码如下: function conn(){ var db_bbs db_bbs="dd.mdb"//定义数据库 var conn = new ActiveXObject("ADODB.Connection"); conn.Open("Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+db_bbs+""); var rs = new ActiveXObject("ADODB.Recordset"); var sql="select name from authors"; //数据库中有authors表，name字段 rs.open(sql,conn); alert(rs(0))//取出第一个来 conn.close(); conn = null; }

target一般跟frameset使用，比如，form.target="值"，这里的值就是你定义的frameset中iframe的name。form.submit()表单提交后只刷新这个iframe，其他iframe不变。

最近学习了target属性，是真的强大，可以不使用for()循环或者数组forEach()去判断我点击或者我需要找的是哪个元素，直接使用target点击就可获取。 接下来说说target哪里强大。 先看看target是什么意思 target 事件属性可返回事件的目标节点（触发该事件的节点），如生成事件的元素、文档或窗口。 我认为target事件就是会自动判断我们点的是哪个元素，我给大家举个简单的例子 当我们的鼠标点击第一个li时，会提示“你刚刚点击了我”，并打印<li>今天6.11</li> 当我们的鼠标点击第二个li时，会提示“你刚刚点击了我”，并打印<li>今天6.12</li> 当我们的鼠标点击第三个li时，会提示“你刚刚点击了我”，并打印<li>今天6.13</li> 还有各个属性，说几个比较常用的 获取文本内容： tar.textContent 获取父级节点： tar.parentNode 获取节点名称： tar.nodeName 需要注意，使用target获取到的节点名称全部为大写 这就是他的强大的地方，会根据我们鼠标点击的元素来返回相应的数据，帮助我们更快的获取该属性，感兴趣的朋友可以试试。

这次给大家带来怎样对JS+TypeScript中class进行使用，对JS+TypeScript中class进行使用的注意事项有哪些，下面就是实战案例，一起来看一下。前言对于一个前端开发者来说，很少用到 class ，因为在 JavaScript 中更多的是 函数式 编程，抬手就是一个 function，几乎不见 class 或 new 的踪影。所以 设计模式 也是大多数前端开发者的一个短板。最近在学习 Angular 的过程中发现其大量的运用了 class，不得不佩服，Angular 确实是一个优秀的、值得深入研究的 框架。本文将简单的介绍一下 JavaScript 和 TypeScript 中的 class。基本概念在介绍 class 之前，要先介绍一些基本的概念。1、静态成员类自身的成员，可以继承，但实例无法访问，一般多见于工具类，比如在jQuery时代最常见的 $.ajax ，ajax 便是 $ 的静态方法，使用方便，不需要再通过 new 或者函数调用的得到一个新实例。2、私有成员类内部的成员，一般是不能继承的，只能在内部使用，实例无法访问，有一点点像闭包内部的变量，但是还是一定的差别，目前 JavaScript 无法直接定义私有成员，只能通过其它方式辅助实现。3、getter/setter存取器属性，当我们访问或者修改一个实例的属性的时候，我们可通过存取器属性拦截这两个操作，从而做一些其它的事情，vue正是通过这个api来实现对数据变化的追踪。4、实例成员指 new 出来的实例所具有的成员，可以被继承，也是通过这个特性实现了代码的复用。5、抽象类，抽象方法抽象类指不可以被实例化的类，通过 new 关键字调用会报错，一般都被设计成父类。抽象方法，只提供方法的名称，参数和返回值，不负责实现，具体的实现由子类去完成，如果一个子类继承于抽象类，那么这个子类必须实现父类所有的抽象方法，否则会报错。这两个概念在 JavaScript 都无法直接实现，但在 TypeScript 或 其它面向对象语言中可以轻松实现，另外这个特性也是用于实现 多态 的重要手段。案例介绍为了更好的介绍 class，本文将采用三个 类 来做例子，分别是 Person、Chinese、American。从字面上可以很快的知道： Person 是 父类(基类) ，Chinese 和 American 是 子类(派生类) 。Person 有 name、age、gender 三个属性，sayHello 方法和 fullName 存取器属性。同时 Person 还有一些 静态成员 和 私有成员 ，由于实在太难想例子了，所以就用 foo、bar、x、y、z 这些来代替吧。作为子类的 Chinese 和 American 继承了 Person 的实例成员和静态成员。同时它们自身也有一些自己的方法和属性:Chinese 有 kungfu 属性，会习武 martial。American 有 twitter，还可以 sendTwitter。接下来我们就分别使用 JavaScript 和 TypeScript 来实现这个案例。JavaScript 中的 classJavaScript 中的 class 要分开说，在 ES6 中提供了两个关键字 class 和 extends ，虽然它们只是语法糖，底层还是再利用 prototype 实现继承的，但是不能否认，这中写法确实让代码更清晰，更易读。ES6 中的 classclass Person { // #x = "私有属性x"; // static x = "静态属性x"; // name; // age; // gender; // 上面的写法还在提案中，并没有成为正式标准，不过变化的可能性已经不大了。 // 顺便吐槽一下，用 # 表示私有成员，真的是很无语. /** * Person的静态方法，可以被子类继承 * 可以通过 this 访问静态成员 */ static foo() { console.log(`类 ${this.name} 有一个 ${this.x}`); } constructor(name, age, gender) { this.name = name; this.age = age; this.gender = gender; } /** * 数据存储器，可以访问实例成员，子类的实例可以继承 * 以通过 this 访问实例成员 */ get fullName() { const suffix = this.gender === "男" ? "先生" : "女士"; return this.name + suffix; } set fullName(value) { console.log(`你已改名为 ${value} `); } /** * Person的实例方法，可以被子类的实例继承 * 可以通过 this 访问实例成员 */ sayHello() { console.log(`你好我是 ${this.fullName} ,我 ${this.age} 岁了`); }}Person.x = "静态属性x";class Chinese extends Person { static bar() { console.log(`类 ${this.name} 的父类是 ${super.name}`); super.foo(); } constructor(name, age, gender, kungfu) { super(name, age, gender); this.kungfu = kungfu; } martial() { console.log(`${this.name} 正在修炼 ${this.kungfu} `); }}class American extends Person { // static y = "静态属性y"; static bar() { console.log(`类 ${this.name} 有自己的 ${this.y} ，还继承了父类 ${super.name} 的 ${super.x}`); } constructor(name, age, gender, twitter) { super(name, age, gender); this.twitter = twitter; } sendTwitter(msg) { console.log(`${this.name} : `); console.log(` ${msg}`); }}American.y = "静态属性y";Person.x; // 静态属性xPerson.foo(); // 类 Person 有一个 静态属性xChinese.x; // 静态属性xChinese.foo(); // 类 Chinese 有一个 静态属性xChinese.bar(); // 类 Chinese 的父类是 PersonAmerican.x; // 静态属性xAmerican.y; // "静态属性yAmerican.foo(); // 类 American 有一个 静态属性xAmerican.bar(); // 类 American 有自己的 静态属性y ，还继承了父类 Person 的 静态属性xconst p = new Person("Lucy", 20, "女");const c = new Chinese("韩梅梅", 18, "女", "咏春拳");const a = new American("特朗普", 72, "男", "Donald J. Trump");c.sayHello(); // 你好我是 韩梅梅女士 ,我 18 岁了c.martial(); // 韩梅梅 正在修炼 咏春拳 a.sayHello(); // 你好我是 特朗普先生 ,我 72 岁了a.sendTwitter("推特治国"); // 特朗普 : 推特治国ES6 之前的 classES5 的继承，实质是先创造子类的实例对象 this，然后再将父类的方法添加到 this 上面 Parent.apply(this) 。ES6 的继承机制完全不同，实质是先创造父类的实例对象 this，所以必须先调用 super 方法，然后再用子类的构造函数修改this。为了实现继承，我们需要先实现一个 extendsClass 函数，它的作用是让子类继承父类的静态成员和实例成员。function extendsClass(parent, child) { // 防止子类和父类相同名称的成员被父类覆盖 var flag = false; // 继承静态成员 for (var k in parent) { flag = k in child; if (!flag) { child[k] = parent[k]; } } // 继承父类prototype上的成员 // 用一个新的构造函数切断父类和子类之间的数据共享 var F = function () { } F.prototype = parent.prototype; var o = new F(); for (var k in o) { flag = k in child.prototype; if (!flag) { child.prototype[k] = o[k]; } }}function Person(name, age, gender) { this.name = name; this.age = age; this.gender = this.gender; // 如果将 getter/setter 写在 prototype 会获取不到 Object.defineProperty(this, "fullName", { get: function () { var suffix = this.gender === "男" ? "先生" : "女士"; return this.name + suffix; }, set: function () { console.log("你已改名为 " + value + " "); }, });}Person.x = "静态属性x";Person.foo = function () { console.log("类 " + this.name + " 有一个 " + this.x);}Person.prototype = { constructor: Person, // get fullName() { }, // set fullName(value) { }, sayHello: function () { console.log("你好我是 " + this.fullName + " ,我 " + this.age + " 了"); },};function Chinese(name, age, gender, kungfu) { // 用call改变this指向，实现继承父类的实例属性 Person.call(this, name, age, gender); this.kungfu = kungfu;}Chinese.bar = function () { console.log("类 " + this.name + " 的父类是 " + Person.name); Person.foo();}Chinese.prototype = { constructor: Chinese, martial: function () { console.log(this.name + " 正在修炼 " + this.kungfu + " "); }};extendsClass(Person, Chinese);function American(name, age, gender, twitter) { Person.call(this, name, age, gender); this.twitter = twitter;}American.y = "静态属性y";American.bar = function () { console.log("类 " + this.name + " 有自己的 " + this.y + " ，还继承了父类 " + Person.name + " 的 " + Person.x);}American.prototype = { constructor: American, sendTwitter: function (msg) { console.log(this.name + " : "); console.log(" " + msg); }};extendsClass(Person, American);TypeScript 中的 class讲完了 JavaScript 中的类，还是没有用到 抽象类，抽象方法，私有方法这三个概念，由于 JavaScript 语言的局限性，想要实现这三种概念是很困难的，但是在 TypeScript 可以轻松的实现这一特性。首先我们稍微修改一下例子中的描述，Person 是抽象类，因为一个正常的人肯定是有国籍的，Person 的 sayHello 方法是抽象方法，因为每个国家打招呼的方式不一样。另外一个人的性别是只能读取，不能修改的，且是确定的是，不是男生就是女生，所以还要借助一下枚举。enum Gender { female = 0, male = 1};abstract class Person { private x: string = "私有属性x，子类和实例都无法访问"; protected y: string = "私有属性y，子类可以访问，实例无法访问"; name: string; public age: number; public readonly gender: Gender; // 用关键字 readonly 表明这是一个只读属性 public static x: string = "静态属性x"; public static foo() { console.log(`类 ${this.name} 有一个 ${this.x}`); } constructor(name: string, age: number, gender: Gender) { this.name = name; this.age = age; this.gender = gender; } get fullName(): string { const suffix = this.gender === 1 ? "先生" : "女士"; return this.name + suffix; } set FullName(value: string) { console.log(`你已改名为 ${value} `); } // 抽象方法，具体实现交由子类完成 abstract sayHello(): void;}class Chinese extends Person { public kungfu: string; public static bar() { console.log(`类 ${this.name} 的父类是 ${super.name}`); super.foo(); } public constructor(name: string, age: number, gender: Gender, kungfu: string) { super(name, age, gender); this.kungfu = kungfu; } public sayHello(): void { console.log(`你好我是 ${this.fullName} ,我 ${this.age} 岁了`); } public martial() { console.log(`${this.name} 正在修炼 ${this.kungfu} `); }}class American extends Person { static y = "静态属性y"; public static bar() { console.log(`类 ${this.name} 有自己的 ${this.y} ，还继承了父类 ${super.name} 的 ${super.x}`); } public twitter: string; public constructor(name: string, age: number, gender: Gender, twitter: string) { super(name, age, gender); this.twitter = twitter; } public sayHello(): void { console.log(`Hello, I am ${this.fullName} , I"m ${this.age} years old`); } public sendTwitter(msg: string): void { console.log(`${this.name} : `); console.log(` ${msg}`); }}Person.x; // 静态属性xPerson.foo(); // 类 Person 有一个 静态属性xChinese.x; // 静态属性xChinese.foo(); // 类 Chinese 有一个 静态属性xChinese.bar(); // 类 Chinese 的父类是 PersonAmerican.x; // 静态属性xAmerican.y; // "静态属性yAmerican.foo(); // 类 American 有一个 静态属性xAmerican.bar(); // 类 American 有自己的 静态属性y ，还继承了父类 Person 的 静态属性xconst c: Chinese = new Chinese("韩梅梅", 18, Gender.female, "咏春拳");const a: American = new American("特朗普", 72, Gender.male, "Donald J. Trump");c.sayHello(); // 你好我是 韩梅梅女士 ,我 18 岁了c.martial(); // 韩梅梅 正在修炼 咏春拳 a.sayHello(); // Hello, I am 特朗普先生 , I"m 72 years olda.sendTwitter("推特治国"); // 特朗普 : 推特治国相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：从零开始使用vue-devtoolsvue计算属性与侦听器实战项目详解

用记事本,另存一下就OK了.无语,这个别人给你转了,贴上来的文字,你创建的文件不是UTF-8的还不是照样不能用.

设置collapsed为true就是收缩状态 Ext.create("Ext.Panel" , { //设置collapsed为true , 就是收缩状态 collapsed: true , collapsible: true});

是不是布局的事，你不举设的‘fit"，只能显示一个组件啊

三益（Samick）钢琴品牌创始于1958年，是目前全球最大最专业的钢琴、吉他生产商之一，随着2008年11月正式收购有着160年历史的德国顶级钢琴品牌Seiler(赛乐尔钢琴)及2009年11月正式控股全球顶级钢琴品牌斯坦威（STEINWAY&SONS）成为其最大执行股东，三益如今已成全面超越亚洲其他乐器企业，为全球最大的、最重要的、最专业的乐器企业，在世界音乐事业的发展中起着举足轻重的作用。

循环调用了，如果是递归形式的，那就要清理，不然就一直调用如果不是递归形式的，就是延迟执行作用，可以不clear

这个setTimeout的时候因为引用了上层作用域中的变量a，此时形成一个闭包，setTimeout中的function保持了一个对a的引用，但是当这个回调执行完的时候，a的引用也没了，此时垃圾回收器会自动讲a回收，不需要手动删除

js 中 setTimeout 用了之后怎么没效果 function over(param){ param1 = { id:param.id, datadate:jQuery("#statMonthDate").val() }; disposeCharts(); jQuery("#chartd").css({left:event.clientX+50,top:event.clientY-200}); setTimeout(buildGraph(param1), 5000); jQuery("#chartd").show(); jQuery("#char2d").show(); } 我想让 onmouseover 时间 buildGraph(param1)方法等待 5 秒再执行 为什么没效果 立即就执行了 ------最佳解决方案-------------------------------------------------------- setTimeout(function(){ buildGraph(param1); }, 5000); ------其他解决方案-------------------------------------------------------- setTimeout(function(){ alert("111"); }, 5000); LZ，你可以自己先试试这样是否可以 5 秒之后弹出，可以的话， 在修改成自己调用的 function 方法名！ ------其他解决方案-------------------------------------------------------- setTimeout("buildGraph("+param1+")", 5000); 试试看 ------其他解决方案-------------------------------------------------------- 引用: setTimeout("buildGraph("+param1+")", 5000); 试试看 引用: setTimeout(function(){ buildGraph(param1); }, 5000); 引用: setTimeout(function(){ alert("111"); }, 5000); LZ，你可以自己先试试这样是否可以 5 秒之后弹出，可以的话， 在修改成自己调用的 function 方法名！

关键代码粘贴上来，帮你改

题主是说代码里面用setTimeout调用自己吧？这样的效果跟setInterval是一样的，定时跑一段代码，跟递归不是一样的概念，每次执行完浏览器就空闲了，等待下一次执行，递归的话是在单次运行的时候无限调用，死循环出不来了，这样浏览器就会卡住，最后提示too much recursion，楼下说的也不对，不一定要终止的，比如你可以给页面加个时间显示，一秒钟更新一次，可以不用判断停止，页面会无限执行，直到你关闭浏览器。

<script language="Javascript"><!--function show(){if (!document.layers&&!document.all)returnvar Digital=new Date()var todayyear=Digital.getYear()var todaymonth=Digital.getMonth()var todaydate=Digital.getDate()var todayday=Digital.getDay()var hours=Digital.getHours()var minutes=Digital.getMinutes()var seconds=Digital.getSeconds()var swatchseconds=hours*3600+minutes*60+secondsvar zoneseconds=7*3600var beat=((swatchseconds-zoneseconds)*10-(swatchseconds-zoneseconds)*10%864)/864if (beat < 0) beat = 1000+beat;if (beat < 100) beat = "0"+beat;if (beat < 10) beat = "0"+beat;if (todayday == 0) todayday = "<font class=time color=red>星期天</font>";if (todayday == 1) todayday = "<font class=time color=blue>星期一</font>";if (todayday == 2) todayday = "<font class=time color=blue>星期二</font>";if (todayday == 3) todayday = "<font class=time color=blue>星期三</font>";if (todayday == 4) todayday = "<font class=time color=blue>星期四</font>";if (todayday == 5) todayday = "<font class=time color=blue>星期五</font>";if (todayday == 6) todayday = "<font class=time color=red>星期六</font>";if (hours<=9) hours="0"+hours;if (minutes<=9) minutes="0"+minutes;if (seconds<=9) seconds="0"+seconds;myclock="<font color=blue>"+todayyear+"年"+(todaymonth+1)+"月"+todaydate+"日</font> "+todayday+" <font color=blue>"+hours+":"+minutes+":"+seconds+" <font class=time color=red></font>"if (document.layers){document.layers.clock.document.write(myclock)document.layers.clock.document.close()}else if (document.all)clock.innerHTML=myclocksetTimeout("show()",1000)}//--></script><body onload=show()><div><span class="time" id="clock" name="clock"></span></div></body>

前两天也解答了一个类似的问题。从实际来说，没有这样写的，f函数的执行次数以指数形式增加，且没有终结。从纯研究的角度来说，这个没有全局变量和局部变量，不存在变量占用内存的情况，只将调用函数的指针压入堆栈，堆栈满了就报错了。

请使用setInterval这个函数是 ，每隔多少秒执行 一次举例：window.onload = function (){ setInteval(func, 20); }function func() { func1(); func2();}

代表定时器的执行时间间隔,相当于VB里的IntervalsetTimeout()就是用来实现"每一秒加1"的

function 套function settimeout 当然找不到timeoutshow当然无法执行了,吧里面那个function timeoutshow拿出来就可以

设置定时器，设置一段时间后执行一个定时任务

任务队列那么单线程的JavasScript是怎么实现“非阻塞执行”呢？答：异步容易实现非阻塞，所以在JavaScript中对于耗时的操作或者时间不确定的操作，使用异步就成了必然的选择。诸如事件点击触发回调函数、ajax通信、计时器这种异步处理是如何实现的呢？答：任务队列所有任务可以分成两种，一种是同步任务（synchronous），另一种是异步任务（asynchronous）。任务队列：一个先进先出的队列，它里面存放着各种事件和任务。同步任务同步任务：在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务。 输出 如：console.log() 变量的声明 同步函数：如果在函数返回的时候，调用者就能够拿到预期的返回值或者看到预期的效果，那么这个函数就是同步的。异步任务 setTimeout和setInterval DOM事件 Promise process.nextTick fs.readFile http.get 异步函数：如果在函数返回的时候，调用者还不能够得到预期结果，而是需要在将来通过一定的手段得到，那么这个函数就是异步的。除此之外，任务队列又分为macro-task（宏任务）与micro-task（微任务），在ES5标准中，它们被分别称为task与job。宏任务 I/O setTimeout setInterval setImmdiate requestAnimationFrame微任务 process.nextTick Promise Promise.then MutationObserver宏任务和微任务的执行顺序一次事件循环中，先执行宏任务队列里的一个任务，再把微任务队列里的所有任务执行完毕，再去宏任务队列取下一个宏任务执行。注：在当前的微任务没有执行完成时，是不会执行下一个宏任务的。三、setTimeout运行机制setTimeout 和 setInterval的运行机制是将指定的代码移出本次执行，等到下一轮 Event Loop 时，再检查是否到了指定时间。如果到了，就执行对应的代码；如果不到，就等到再下一轮 Event Loop 时重新判断。这意味着，setTimeout指定的代码，必须等到本次执行的所有同步代码都执行完，才会执行。优先关系：异步任务要挂起，先执行同步任务，同步任务执行完毕才会响应异步任务。四、进阶console.log("A");setTimeout(function () { console.log("B");}, 0);while (1) {}大家再猜一下这段程序输出的结果会是什么？答：A注：建议先注释掉while循环代码块的代码，执行后强制删除进程，不然会造成“假死”。同步队列输出A之后，陷入while(true){}的死循环中，异步任务不会被执行。类似的，有时addEventListener()方法监听点击事件click，用户点了某个按钮会卡死，就是因为当前JS正在处理同步队列，无法将click触发事件放入执行栈，不会执行，出现“假死”。五、定时获取接口更新数据for (var i = 0; i < 4; i++) { setTimeout(function () { console.log(i); }, 1000);}输出结果为，隔1s后一起输出：4 4 4 4for循环是一个同步任务，为什么连续输出四个4？答：因为有队列插入的时间，即使执行时间从1000改成0，还是输出四个4。那么这个问题是如何产生和解决的呢？请接着阅读异步队列执行的时间执行到异步任务的时候，会直接放到异步队列中吗？答案是不一定的。因为浏览器有个定时器（timer）模块，定时器到了执行时间才会把异步任务放到异步队列。for循环体执行的过程中并没有把setTimeout放到异步队列中，只是交给定时器模块了。4个循环体执行速度非常快（不到1毫秒）。定时器到了设置的时间才会把setTimeout语句放到异步队列中。即使setTimeout设置的执行时间为0毫秒，也按4毫秒算。这就解释了上题为什么会连续输出四个4的原因。HTML5 标准规定了setTimeout()的第二个参数的最小值，即最短间隔，不得低于4毫秒。如果低于这个值，就会自动增加。在此之前，老版本的浏览器都将最短间隔设为10毫秒。利用闭包实现 setTimeout 间歇调用for (let i = 0; i < 4; i++) { (function (j) { setTimeout(function () { console.log(j); }, 1000 * i) })(i);}执行后，会隔1s输出一个值，分别是：0 1 2 3 此方法巧妙利用IIFE声明即执行的函数表达式来解决闭包造成的问题。 将var改为let，使用了ES6语法。这里也可以用setInterval()方法来实现间歇调用。详见：setTimeout和setInterval的区别利用JS中基本类型的参数传递是按值传递的特征实现var output = function (i) { setTimeout(function () { console.log(i); }, 1000 * i)}for (let i = 0; i < 4; i++) { output(i);}执行后，会隔1s输出一个值，分别是：0 1 2 3实现原理：传过去的i值被复制了。基于Promise的解决方案const tasks = [];const output = (i) => new Promise((resolve) => { setTimeout(() => { console.log(i); resolve(); }, 1000 * i);});//生成全部的异步操作for (var i = 0; i < 5; i++) { tasks.push(output(i));}//同步操作完成后，输出最后的iPromise.all(tasks).then(() => { setTimeout(() => { console.log(i); }, 1000)})执行后，会隔1s输出一个值，分别是：0 1 2 3 4 5优点：提高了代码的可读性。注意：如果没有处理Promise的reject，会导致错误被丢进黑洞。使用ES7中的async await特性的解决方案（推荐）const sleep = (timeountMS) => new Promise((resolve) => { setTimeout(resolve, timeountMS);});(async () => { //声明即执行的async for (var i = 0; i < 5; i++) { await sleep(1000); console.log(i); } await sleep(1000); console.log(i);})();执行后，会隔1s输出一个值，分别是：0 1 2 3 4 5六、事件循环 Event Loop主线程从任务队列中读取事件，这个过程是循环不断的，所以整个的这种运行机制又称为Event Loop。有时候 setTimeout明明写的延时3秒，实际却5，6秒才执行函数，这又是因为什么？答：setTimeout 并不能保证执行的时间，是否及时执行取决于 JavaScript 线程是拥挤还是空闲。浏览器的JS引擎遇到setTimeout，拿走之后不会立即放入异步队列，同步任务执行之后，timer模块会到设置时间之后放到异步队列中。js引擎发现同步队列中没有要执行的东西了，即运行栈空了就从异步队列中读取，然后放到运行栈中执行。所以setTimeout可能会多了等待线程的时间。这时setTimeout函数体就变成了运行栈中的执行任务，运行栈空了，再监听异步队列中有没有要执行的任务，如果有就继续执行，如此循环，就叫Event Loop。七、总结JavaScript通过事件循环和浏览器各线程协调共同实现异步。同步可以保证顺序一致，但是容易导致阻塞；异步可以解决阻塞问题，但是会改变顺序性。知识点梳理： 理解JS的单线程的概念：一段时间内做一件事 理解任务队列：同步任务、异步任务 理解 Event Loop 理解哪些语句会放入异步任务队列 理解语句放入异步任务队列的时机最后，希望大家阅后有所收获。U0001f920好了，

1. SetTimeOut()1.1 SetTimeOut()语法例子1.2 用SetTimeOut()执行Functio1.3 SetTimeOut()语法例子1.4 设定条件使SetTimeOut()停止1.5 计分及秒的counter2. ClearTimeout()3. Set FlagetTimeout( ) 是属於 window 的 method, 但我们都是略去 window 这顶层物件名称, 这是用来设定一个时间, 时间到了, 就会执行一个指定的 method。请先看以下一个简单, 这是没有实际用途的例子, 只是用来示范 setTimeout( ) 的语法。练习-69　等候三秒才执行的 alert( )在 第 3 章 说到 alert 对话盒, 一般是用按钮叫出来, 在这练习, 你会看到网页开启後 3 秒, 就会自动出现一个 alert 对话盒。1.　请用浏览器开启示范磁碟中的 timeout1.htm, 这档案有以下内容:<html> <body bgcolor=lightcyan text=red> <h1> <font color=blue> 示范网页 </font> </h1> <p> </br> <p> 请等三秒! <script> setTimeout("alert("对不起, 要你久候")", 3000 ) </script> </body> </html>2.　留意网页开启後三秒, 就会出现一个 alert 对话盒。etTimeout( ) 是设定一个指定等候时间 (单位是千分之一秒, millisecond), 时间到了, 浏览器就会执行一个指定的 method 或 function, 有以下语法:今次例子是设定等 3 秒 (3000 milliseconds), 浏览器就会执行 alert( ) 这一个method。etTimeout( ) 通常是与 function 一起使用, 以下是一个较上个练习复杂的例子。练习-70　状态列中自动消失的文字在练习-20, 你看过如何用按钮在状态列显示文字, 然後再用按钮消除文字, 在这练习, 你看到如何用按钮在状态列显示文字, 而这文字会在三秒後自动消失。1.　请用浏览器开启示范磁碟中的 timeout2.htm, 这档案有以下内容:<html> <body bgcolor=lightcyan text=red> <h1> <font color=blue> 示范网页 </font> </h1> <p> </br><script> function clearWord( ) {　window.status=""　} </script> <form> <input type="button" value="在状态列显示文字" 　　onClick="window.status="Hello" , setTimeout("clearWord( )", 3000) "> </form> </body> </html>2.　请在按钮上按一下, 你应见到状态列出现 Hello 这字, 留意过了三秒, 这字就会消失。1.　这处先设定一个名为 clearWord( ) 的 function, 作以下定义:window.status=""这是用来消除状态列的文字 (请看练习-20 的说明), 浏览器执行 clearWord( ) , 就会消除状态列的文字。2.　今次按钮设定了启动以下两项工作, 用 ， 分隔, 浏览器会顺序执行这两项工作:onClick="window.status="Hello" , setTimeout("clearWord( )", 3000) "3.　今次的 setTimeout( ) 有以下设定:这是设定等 3 秒 (3000 milliseconds) 浏览器就会执行 clearWord( ) 这一个function。在第 2 章, 你看过如何使到父视窗开启时自动开启一个子视窗, 若观看者不关闭这子视窗, 这子视窗就会一路开启。看过以上的练习, 请你设计一个会开启子视窗的网页, 而这子视窗在开启後两秒, 就会自动关闭。etTimeout( ) 预设只是执行一次, 但我们可以使用一个循环方式, 使到一个setTimeout( ) 再启动自己一次, 就会使到第二个 setTimeout( ) 执行, 第二个又启动第三个, 这样循环下去, 这 setTimeout( ) 就会不断执行。练习-71　自动每秒加 1 的 functio在这练习, 你看到如何使用 setTimeout( ) 令文字框的数值每秒就加 1, 当然你也可以设定其他递增的速度, 例如每五秒就加 5, 或每五秒就加 1。1.　请用浏览器开启示范磁碟中的 timeout3.htm, 这档案有以下内容:2.　网页开启後, 请你留意文字框中的数值转变。3.　请你将这档案复制去硬碟, 更改一些设定, 例如 x = x+5, 或将等候时间改为5000, 看有什麼反应。1.　这网页有两个 script, 第一个是设定 countSecond( ) 这个 function, 第二个在後的是在网页完全载入後, 就启动这 function。2.　留意今次以下的设定:当 countSecond( ) 启动後, 就会启动 setTimeout( ), 这个 method 在一秒後又启动 countSecond( ), countSecond( ) 启动後又启动 setTimeout( ) , 所以得出的结果是 countSecond( ) 每秒执行一次。3.　在 JavaScript, 我们是使用这处说的方法使到一些事项不断执行, 其中一个用途是显示转动时间, 另一个用途是设定跑动文字, 随後的章节会有例子。用上述的方法设定时间, setTimeout( ) 虽然设定了是一秒, 但浏览器还有另外两项功能要执行, 所以一个循环的时间是稍多於一秒, 例如一分钟可能只有58 个循环。etTimeout( ) 的回圈开始後, 就会不断重复, 在上个练习, 你看到文字框的数字不断跳动, 但我们是有方法使到数字跳到某一个数值就停下来, 其中一个方法是用 if...else 设定一个条件, 若是 TRUE 就继续执行 setTimeout( ) , 若是 FALSE 就停止。例如要使到上个练习的 counter 跳到 20 就停下, 可将有关的 function 作以下的更改。在前面的练习, 相信你已学识如何使用 setTimeout( ), 现在请你看一个较复习的例子。练习-72　计时的 counter在这练习, 你要设定两个文字框, 一个显示分钟, 另一个显示秒, 网页开启後, 就会在这两个文字框中自动计时。1.　请用浏览器开启示范磁碟中的 timeout4.htm, 这档案有以下内容:<html> <head> <script> x=0 y=-1 function countMin( ) {　y=y+1 　 document.displayMin.displayBox.value=y 　 setTimeout("countMin( )",60000) }2.　请你留意两个文字框中的数字转变。1.　这网页有两个 function, 一个用来计分钟, 一个用来计秒。在这处, 笔者只是示范setTimeout( ) 的操作, 因为计时器有其他更精简的写法。(留意: 这方式的计时并不准确。)2.　留意计秒的 function:这处的 % 符号是 modulus (馀数), 例如 z = x % 60 表示先进行 x / 60, 得出的馀数作为 z 这变数, 例如 82 秒, modulus 就是 22, 所以文字框会显示 22 而不是 82。3.　若你要将单位数字在前加上 0, 例如 01, 02, 03 等, 可用以下方法:在前一节, 你看过如何使用 setTimeout( ) 来使到浏览器不断执行一个 function, 当一个 setTimeout( ) 开始了循环的工作, 我们要使它停下来, 可使用 clearTimeout( ) 这 method。clearTimout( ) 有以下语法:　clearTimeout(timeoutID)要使用 clearTimeout( ), 我们设定 setTimeout( ) 时, 要给予这 setTimout( ) 一个名称, 这名称就是 timeoutID , 我们叫停时, 就是用这 timeoutID来叫停, 这是一个自订名称, 但很多程式员就以 timeoutID 为名。在下面的例子, 笔者设定两个 timeoutID, 分别命名为 meter1 及 meter2, 如下:timeoutID 　↓ meter1 = setTimeout("count1( )", 1000) meter2 = setTimeout("count2( )", 1000)使用这 meter1 及 meter2 这些 timeoutID 名称, 在设定 clearTimeout( ) 时, 就可指定对哪一个 setTimeout( ) 有效, 不会扰及另一个 setTimeout( ) 的操作。练习-73　可停止的 setTimeout( )这练习以练习-71 为蓝本, 但作了两个改变: (1) 有两个 setTimeout( ), (2) 有两个按钮, 分别可停止这两个 setTimout( )。1.　请用浏览器开启示范磁碟中的 clear.htm, 这档案有以下内容:<html> <head> <script> x = 0 y = 02.　留意网页中的两个文字框及内里变动的数字, 每个文字框旁有两个按钮, 请你试试两个按钮的反应。3.　请你连续按多次 [继续计时] 的按钮, 留意数值的跳动加快了, 原因是每按一次就启动 function 一次, 每个 function 都令数值跳动, 例如启动同一的 function 四次, 就会一秒跳四次。(请看下一节)前个练习说到我们用一个按钮来启动一个 function, 每按一下就会启动这 function 一次, 请看以下例子。练习-74　效果重复的 setTimeout( )这练习实际是将 练习-73 简化, 只有一个计时器, 笔者想示范的是每按 [继续计时] 一次, 就会启动 count( ) 这 function 一次。1.　请用浏览器开启示范磁碟中的 flag1.htm, 这档案有以下内容:<script> count( ) </script> </body> </html>2.　网页开启後, 你应见到文字框中的数字跳动, 请你按四次 [继续计时], 留意这会加快数字跳动, 原因是有关的 function 被开启了多个, 每个都会使数字转变。3.　按了四次 [继续计时] 的按钮後, 请你按 [停止计时] 的按钮, 你会发现要按五次才能停止数字跳动。在编写程式时, 我们常要提防使用者作出一些特别动作, 例如使用者按两次 [继续计时] 按钮, 这计时器就失准了。我们是否有办法使到一个按钮被按一次就失效呢? 这就不会产生重复效果。笔者藉这处的例子 (随後还有多个例子), 解说程式中一个 set flag (设定旗标) 的概念, flag 是一个记认, 一般来说, 这可以是 0 或是 1 (也可用 on 或 off, 或任何两个自选的名称或数字), 但也可以是 2、3、4 或更大的数字, 在这例子有以下设定:1.　程式开启时 flag=0。2.　当 counter( ) 执行时会顺便将 flag 变为 1。3.　在 [继续计时] 这按钮的反应中, 会先检查 flag 是 0 或是 1, 若是 0 就会产生作用, 若是 1 就没有反应。4.　使用这 flag 的方式, count( ) 这 function 开启後, [继续计时] 这按钮就没有作用。这处的 flag 是一个变数, 可任意取名, 我们用 flag来称呼这变数的原因, 是因为这变数好处一支旗, 将旗竖起 (flag is on), 就会产生一个作用, 将旗放下 (flag is off), 就产生另一个作用。练习-75　只可开启一次的 functio这练习是将上个练习加多一个 flag, 使到每次只能有一个 count( ) 这 function 在进行。1.　请用浏览器开启示范磁碟中的 flag2.htm, 这档案有以下内容:function restart( ) {　if (flag==0) 　　　{　count( )　} } </script> </head><script> count( ) </script><form> <input type=button value="Show flag" onClick="alert("The flag now is "+ flag) " > </form> </body> </html>2.　在网页中, 你应见到三个按钮及文字框中的数字跳动。3.　请你按 [Show flag] 这按钮, 应见到一个话对盒显示 flag 是 1。4.　请你按 [停止计时] 这按钮, 数字停止跳动, 请你按 [Show flag] 这按钮, 应见到话对盒显示 flag 是 0。5.　请你按多次 [继续计时] 这按钮, 你应见到数字不会加快, 请你按 [Show flag] 这按钮, 应见到话对盒显示 flag 变回 1。1.　这网页第 4 行有这一句: flag=0 , 这是设定 flag 这变数及将初始值定为 0, 你也可将初始值定为 1, 随後有关的 0 和 1 对调。2.　count( ) 这 function 最後一句是 flag=1 , 所以启动 count( ) 後, flag 就会变为 1。3.　[继续计时] 的按钮是用来启动 restart( ), 这 function 有以下设定:function restart( ) {　if (flag==0) 　　　{　count( )　} }这处的 if statement 检查 flag 是否等於 0, 若是 0 就启动 count( ), 若是 1 (即不是 0) 就没有反应, 使用这方法, 若 count( ) 已在执行中, [继续计时] 这按钮不会有作用。这处的 flag=1 设定, 实际设为 1 或 2 或 3 等数值都是一样的, 只要不是 0 就可以了, 所以这两个相对的旗标, 看似是 "0" 和 "1", 实际是 "0" 和 "non-zero" (非-0)。4.　[停止计时] 的按钮有以下设定:onClick="clearTimeout(timeoutID); flag=0 "这是停止 setTimeout( ) 的操作时, 同时将 flag 转回 0, 这使到 restart( ) 这 function 可以重新启动 count( )。

这段代码是一个错误的示例，因为在 Node.js 中的事件循环机制导致 setTimeout 函数无法按预期工作。在上面的代码中，while 循环会一直运行，不会等待 setTimeout 函数执行完成。因此，setTimeout 的回调函数永远不会被触发。如果要在循环中使用 setTimeout 函数，可以考虑使用递归或者使用 Promise 或 async/await 等异步操作来实现。例如，可以使用递归来执行多个 setTimeout 函数，每次循环内调用一个 setTimeout，并在其回调函数中递归调用下一次 setTimeout。这样可以模拟出延迟效果：var temp1 = 0;function myFunc() {if (temp1 < 5) {console.log("doing");temp1 += 1;setTimeout(myFunc, 1000);} else {console.log("done");}}myFunc();这段代码会每隔一秒输出一次 "doing"，并在循环结束后输出一次 "done"。通过递归调用 setTimeout，可以确保每次 setTimeout 的回调函数执行时都在上一个 setTimeout 的回调函数执行完成之后。

这个问句的意思是: 你认为英语学习怎么样？回答。I think English learning is very interesting.

现在还需要吗？

连接器类型： 线对板连接器 温度范围： –25℃ to ＋85℃ 绝缘电阻： 1000M Ωmin 额定电压： 250V AC DC 额定电流： 3A AC DC（AMG#22） 接触电阻最大： 10 mΩmax 使用导线： AWG #30 to #22 产品使用范围： 产品广泛用于各类电子玩具、DVD、MP3、数码相机、液晶显示器、笔记本电脑、电脑周边、家用电器、汽车电子、通讯产品及机械设备等。 具体的您可以参照http://www.jst-e.com/goods.php?id=149

main.jsp<%@page contentType="text/html;charset = gb2312"%><HTML><head></head><body bgcolor=cyan><%double r = 3, a = 2, b = 5, c = 2;%><br>加载circle.jsp计算半径<%=r%>的圆的面积：<jsp:include page="circle.jsp"><jsp:param value="<%=r %>" name="sideR" /></jsp:include><br>加载ladder.jsp计算上底为<%=a %>,下底为<%=b %>,高为<%=c %>的梯形面积<jsp:include page="ladder.jsp"><jsp:param value="<%=a %>" name="sideA" /><jsp:param value="<%=b %>" name="sideB" /><jsp:param value="<%=c %>" name="sideC" /></jsp:include></body></HTML>circle.jsp<%@page contentType="text/html;charset = gb2312"%><%!public String getArea(double r) {if (r > 0) {double area = r * r * 3.14;return "" + area;} else {return ("输入的值不规范，不能计算，请重新输入");}}%><%String sideR = request.getParameter("sideR");double r = Double.parseDouble(sideR);%><font color=blue size=2><br><br>我是被加载的文件，负责计算圆的面积<br>给我传递的半径是：<%=r%><br>圆的面积是：<%=getArea(r)%></font>ladder.jsp<%@page contentType="text/html;charset = gb2312"%><%!public String getArea(double a, double b, double c) {if (a > 0 && b > 0 && c > 0) {double area = (a + b) * c / 2;return "" + area;} else {return ("输入的值不规范，不能计算，请重新输入");}}%><%String sideA = request.getParameter("sideA");String sideB = request.getParameter("sideB");String sideC = request.getParameter("sideC");double a = Double.parseDouble(sideA);double b = Double.parseDouble(sideB);double c = Double.parseDouble(sideC);%><font color=blue size=2><br><br>我是被加载的文件，负责计算梯形的面积<br>给我传递的上底<%=sideA%>,下底<%=sideB%>,高<%=sideC%><br>梯形的面积是：<%=getArea(a, b, c)%></font>运行的结果

本篇文章主要介绍了angularjs实现时间轴效果的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧一 引入包引入angular-timeline包。下载地址：angular-timeline.zip在index.html中引入<link href="lib/angular-timeline/dist/angular-timeline.css" rel="external nofollow" rel="stylesheet"><script src="lib/angular-timeline/dist/angular-timeline.js"></script>app.js中引用，不引用就没有效果。二 改写css根据需求改写css,核心部分的改写。可以写在style.css中，也可以新建一个css文件，但是一定要在index.html中引用。/* 时间轴 */.timeline-event { margin-bottom: 0px !important;}timeline-badge.infos { background-color: #47d09e !important;}.timeline:before { width: 1px !important; left: 24px !important; margin-top: 30px !important; background-color: #47d09e !important;}timeline-badge { left: 16px !important; width: 15px !important; height: 15px !important; top: 15px !important; box-shadow: none !important;}timeline-panel { float: left !important; width: 85% !important; padding: 13px 0px 6px 0px !important; margin-left: 39px !important; background: none !important; border: none !important; box-shadow: none !important;}timeline-panel:before { visibility: hidden !important;}timeline-panel:after { visibility: hidden !important; display: none !important;}timeline-panel .time { font-size: 14px; font-family: "PingFangSC-Regular";}timeline-panel .detail { display: flex; display: -webkit-flex; align-items: center; -webkit-align-items: center; justify-content: space-between; -webkit-justify-content: space-between; margin-top: 10px;}timeline-panel .detail .linename { font-size: 16px; max-width: 80%; color: #1c1c1c; display: inline-block; font-family: "PingFangSC-Medium";}timeline-panel .detail .linelevel { position: absolute; right: 18%; border-radius: 4px; color: white; padding: 1px 5px 1px 5px; font-size: 11px;}timeline-panel .detail .linelevel-g { background-color: #f27373;}timeline-panel .detail .linelevel-p { background-color: #e29431;}timeline-panel .detail .linenum { float: right; font-size: 14px; color: #323232;}三 页面准备工作做完了，下面是页面的编写。<!--html页面--><ion-view view-title="{{title}}"> <ion-content scroll="true"> <timeline> <timeline-event ng-repeat="event in teamDataList" side="right"> <timeline-badge class="infos"> </timeline-badge> <timeline-panel class="infos"> <span class="time"> {{event.hour}} </span> <p class="detail" ng-repeat="item in event.data"> <span class="linename">{{item.customerName}}</span> <p style="float: right;"> <span class="linenum"> {{item.reserveNumber}}人 </span> </p> </p> </timeline-panel> </timeline-event> </timeline> </ion-content></ion-view>//controllerangular.module("studyApp.controllers") .controller("TimeLineCtrl", function ($scope, $rootScope, $location) { $scope.title = "时间轴"; makeData(); function makeData() { $scope.teamDataList=[ { hour:"12:00", data:[ { customerName:"中国国旅（江苏）国际旅行社有限公司", reserveNumber:"12", id:"aaaabbb12112" }, { customerName:"江苏2", reserveNumber:"122", id:"aaaabbb12112" } ] }, { hour:"13:00", data:[{ customerName:"江苏2", reserveNumber:"112", id:"aaaabbb12112" }] }, { hour:"14:00", data:[{ customerName:"江苏3", reserveNumber:"12", id:"aaaabbb12112" }] }, { hour:"13:00", data:[{ customerName:"江苏2", reserveNumber:"112", id:"aaaabbb12112" }] }, { hour:"14:00", data:[{ customerName:"江苏3", reserveNumber:"12", id:"aaaabbb12112" }] } ]; } });四 效果图上面是我整理给大家的，希望今后会对大家有帮助。相关文章：使用JS如何实现去除重复json使用js+cookie如何实现购物车功能在jQuery中如何使用Validate插件使用axios如何实现上传图片带有进度条功能

事情的起因是这样的， 因为某些原因， 最近在写 Nodejs 的 c++ module， 然后在js这边调用。 网络通信自然离不开ssl， 于是需要链接到Openssl的库。我们本来的期望是，需要用户安装有Openssl的运行库， 然后我们的c++ module 动态链接到Openssl的so库上来运行。起初一切看起来还不错，直到我们发现这个openssl的函数不能工作：PKCS7_sign()PKCS7_sign ( )我们发现：如果我们的 c++ 模块与Openssl库动态链接的话, 编译都没问题. 但是运行会出现: PKCS7_sign 符号无法找到的错误.如果我们的 c++ 模块与Openssl库静态链接的话, 编译也没问题, 但是运行时,调用这个函数的地方没有效果, 这个函数返回值是 0. 按照文档表示出现错误, 但是用 Openssl的函数 ERR_get_error 获取错误码也是0. 表示没有错误码.在linux上是这样, 那在Mac上呢? 用Mac试了一下, 发现Mac没有问题. 于是,想到这可能是Nodejs的一个bug. 然后就去 Nodejs 给它报了一个bug: [https://github.com/joyent/node/issues/8026][1]同时, google上搜索了 nodejs linking to openssl 类似的关键字.找到这样几篇文章:https://github.com/TooTallNate/node-gyp/wiki/Linking-to-OpenSSLhttps://github.com/joyent/node/issues/3915http://serverfault.com/questions/338092/how-can-i-build-node-js-using-static-libssl-and-crypto-librarieshttps://github.com/robhawkes/node-extension/issues/1通过搜索, 我们发现, 原来Nodejs自己也使用了Openssl 库, 推测nodejs自己的crypto模块也是使用Openssl lib实现的. 这点从Nodejs的源码中就能发现, 它包含了最新的Openssl的全部源码.其中写上面第一篇文章: https://github.com/TooTallNate/node-gyp/wiki/Linking-to-OpenSSL 的那个帅哥是Nodejs的开发人员.基本结论:Nodejs 自己使用了Openssl在Nodejs 0.6之前, Nodejs是动态链接到 Openssl 库的. 而之后的版本都是静态链接的.这时发现 Node 那边已经回复我的bug了: https://github.com/joyent/node/issues/8026Node 解释的原因:Node 自己编译之后, 把自己没用到的符号清除, 所以我们在运行时就找不到符号了. 于是他们把这bug 修掉了. 保留了全部符号. 这导致 Node 的体积大了 400k.

注：参考 Spring Security 整合 JSON Web Token(JWT) 提升 REST 安全性 ，写的特别全面，本文只是学习总结基于token的鉴权机制基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息。这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。 流程上是这样的： 1.用户使用用户名密码来请求服务器 2.服务器进行验证用户的信息 3.服务器通过验证发送给用户一个token 4.客户端存储token，并在每次请求时附送上这个token值 5.服务端验证token值，并返回数据 这个token必须要在每次请求时传递给服务端，它应该保存在请求头里， 另外，服务端要支持CORS(跨来源资源共享)策略，一般我们在服务端这么做就可以了Access-Control-Allow-Origin: *。 第一部分我们称它为头部（header),第二部分我们称其为载荷（payload, 类似于飞机上承载的物品)，第三部分是签证（signature). jwt的头部承载两部分信息： 声明类型，这里是jwt 声明加密的算法 通常直接使用 HMAC SHA256 完整的头部就像下面这样的JSON： 然后将头部进行base64加密（该加密是可以对称解密的),构成了第一部分. 载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分 1.标准中注册的声明 2.公共的声明 3.私有的声明 标准中注册的声明 (建议但不强制使用) ： iss : jwt签发者 sub : jwt所面向的用户 aud : 接收jwt的一方 exp : jwt的过期时间，这个过期时间必须要大于签发时间 nbf : 定义在什么时间之前，该jwt都是不可用的. iat : jwt的签发时间 jti : jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。 公共的声明 ： 公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密. 私有的声明 ： 私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。 定义一个payload: 然后将其进行base64加密，得到Jwt的第二部分。 jwt的第三部分是一个签证信息，这个签证信息由三部分组成： 1.header (base64后的) 2.payload (base64后的) 3.secret 这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。 将这三部分用.连接成一个完整的字符串,构成了最终的jwt: 注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。 如何应用 一般是在请求头里加入Authorization，并加上Bearer标注： 服务端会验证token，如果验证通过就会返回相应的资源。整个流程就是这样的: jwt-diagram 总结 优点 因为json的通用性，所以JWT是可以进行跨语言支持的，像JAVA,JavaScript,NodeJS,PHP等很多语言都可以使用。 因为有了payload部分，所以JWT可以在自身存储一些其他业务逻辑所必要的非敏感信息。 便于传输，jwt的构成非常简单，字节占用很小，所以它是非常便于传输的。 它不需要在服务端保存会话信息, 所以它易于应用的扩展 安全相关 不应该在jwt的payload部分存放敏感信息，因为该部分是客户端可解密的部分。 保护好secret私钥，该私钥非常重要。 如果可以，请使用https协议 在SpringBoot中整合JWTSpring Security的步奏： 1.在项目中引入（本项目使用Gradle） 2.配置 目录结构如下： WebSecurityConfig文件：

这次给大家带来Vuejs怎样实现购物车功能，Vuejs实现购物车功能的注意事项有哪些，下面就是实战案例，一起来看一下。开始更新前端框架Vue.JS的相关博客。功能概述 学习了Vue.JS的一些基础知识，现在利用指令、数据绑定这些基础知识开发一个简单的购物车功能。功能要点如下： （1）展示商品的名称、单价和数量； （2）商品的数量可以增加和减少； （3）购物车的总价要实时更新，即数量发生变动，总价也要相应的改变； （4）商品可以从购物车中移除； （5）具有选择功能，只计算选中的商品的总价。代码 代码分成三部分，分别是HTML、JS、css。关键的是HTML和JS。 HTML<!DOCTYPE html><html> <head> <meta charset="utf-8"> <title>Vue 购物车</title> <script src="../js/vue.min.js"></script> <link href="../css/cart.css" rel="external nofollow" rel="stylesheet"> </head> <body> <p id="app" v-cloak> <template v-if="list.length"> <table> <thead> <tr> <th><input type="checkbox" v-on:click="swapCheck" v-model="checked"></th> <th>商品名称</th> <th>商品单价</th> <th>商品数量</th> <th>操作</th> </tr> </thead> <tbody> <tr v-for="(item,index) in list"> <td><input type="checkbox" v-model="selectList" :id="item.id" :value="index" name="selectList" ></td> <td>{{ item.name }}</td> <td>{{ item.price }}</td> <td> <button @click="handleReduce(index)" :disabled="item.count === 1">-</button> {{ item.count }} <button @click="handleAdd(index)">+</button> </td> <td><button @click="handleRemove(index)">移除</button></td> </tr> </tbody> </table> <p>总价：￥ {{ totalPrice }}</p> </template> <p v-else>购物车为空！</p> </p> <script src="../js/cart.js"></script> </body></html> JSvar app = new Vue({ el:"#app", data:{ list:[ { id:1, name:"iPhone 8", price:8888, count:1 }, { id:2, name:"Huwei Mate10", price:6666, count:1 }, { id:3, name:"Lenovo", price:6588, count:1 } ], selectList:[], checked:false }, computed:{ totalPrice:function(){ var total = 0; for(var i = 0,len = this.selectList.length;i < len;i++){ var index = this.selectList[i]; var item = this.list[index]; if(item){ total += item.price * item.count; } else{ continue; } } return total.toString().replace(/B(?=(d{3})+$)/g,","); } }, methods:{ handleReduce:function(index){ var item = this.list[index]; if(item.count < 2){ return; } item.count--; }, handleAdd:function(index){ var item = this.list[index]; item.count++; }, handleRemove:function(index){ this.list.splice(index,1); }, swapCheck:function(){ var selectList = document.getElementsByName("selectList"); var len = selectList.length; if(this.checked){ for(var i = 0;i < len;i++){ var item = selectList[i]; item.checked = false; } this.checked = false; this.selectList = []; } else{ for(i = 0;i < len;i++){ item = selectList[i]; if(item.checked === false){ item.checked = true; this.selectList.push(selectList[i].value); } } this.checked = true; } } }}); CSS[v-cloak]{ display: none;}table{ border: 1px solid black; border-collapse: collapse; border-spacing: 0; empty-cells: show;}th,td{ padding: 8px 16px; border:1px solid black; text-align: center;}th{ background-color: gray;}相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！

本文主要为大家分享一篇JS正则表达式如何确保输入为整数的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧.<span class="show_total"> <span class="edit_ifo">{{totalRunTimes}}</span> <a class="btn btn-primary edit_btn" (click)="editTotalTimes()">编辑</a></span>editTotalTimes() { $(".show_total").addClass("display_none"); $(".edit_total").removeClass("display_none");// 确保输入的为整数 $(".total_times").off("input propertychange"); 、(".total_times").on("input propertychange", function() { let v = $(this).val().toString();//获取输入框的数 v = v.replace(/D/g,"");//将除整数的其他字符替换为空 $(this).val(v);//返回输入框 });}这样所有输入的非数字都会被替换成空字符串了。相关推荐：

broswer 浏览器（客户端） html 超文本标记语言 css 层叠样式表 javascript 语言名字(类似python/php/c…) title 标题 body 身体 head 头 div 盒子(类似收纳箱) font 字体 width 宽 height 高 background 背景 color 颜色 ul (Unordered List) 无序列表 ol (Ordered List) 有序列表 li (List Item) 列表项 dl (Definition List) 自定义列表 form 表单 action 地址 method 方法 input 输入框 text 文本 password 密码 radio 单选 checkbox 多选 select 下拉菜单 option 选项 padding 内边距 margin 外边距 border 边线 solid 直线 dashed 虚线 dotted 点线 overflow 溢出 hidden 隐藏 visibility 可见度 table 表格 thead 表头 tbody 表格内容 tr (table row) 行 td/th (table data, table headline)列 rowspan 合并行 colspan 合并列 collapse 合并 position 定位 relative 绝对定位 absolute 相对定位 fixed 固定定位 static 静态定位 script 脚本 string 字符串 number 数字 boolean 布尔 undefined 未定义 null 空(None) function 函数 document 文档 get 获取 element 元素 by 通过 id id tagName 标签名 window 窗口 object 对象 array 数字(类似python中的list列表) setInterval 定时器 clearInterval 清除定时器 $ 美元符号 next 下一个 prev 前一个（previous） parent 父母/双亲 children 孩子 click 点击 mouseleave 鼠标移开 mouseenter 鼠标进入 animate 动画 slide 滑动 fade 渐进 show 显示 hide 隐藏 test 测试 stopProperation 阻止冒泡 preventDefault 阻止默认行为 DOM document object model 文档对象模型 ajax 啊甲克斯 type 类型 url 统一资源定位符 data 数据 dataTpye 数据类型 success 成功 error 失败 done 成功 fail 失败 mustache 胡子 computed 计算 watch 监听 filters 过滤器 mounted 挂载，生成 axios vue中的ajax let 变量 const 常量

调用：直接写在html代码里，不管头部还是底部<script type="text/javascript" src="mustache.js"></script> src下是路径，跟图片等的路径一样计算存放：就放在文件里，后缀名“.js”，就像html文件的后缀名是“.html”一样

结合jquery去做。

前言本文主要给大家介绍了关于vue.js将echarts封装为组件一键使用的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。说明做项目的时候为了让数据展示的更加直观，总会用到图表相关的控件，而说到图表控件第一时间当然想到ECharts这个开源项目，而它不像iview、element-ui这些组件使用起来那么便捷，需要绕一个小弯，为了图方便于是对ECharts进行了一层封装控件演示控件使用概要 基于echarts的二次封装 由数据驱动 控件源码见src/components/charts文档props 属性 说明 类型 _id 图表唯一标识，当id重复将会报错 String _titleText 图表标题 String _xText x轴描述 String _yText y轴描述 String _chartData 图表数据 Array _type 图表类型，提供三种(LineAndBar/LineOrBar/Pie)调用示例 <chart :_id=""testCharts"" :_titleText=""访问量统计"" :_xText=""类别"" :_yText=""总访问量"" :_chartData="chartData" :_type=""Pie""></chart> //测试数据样例 [["类别1",10],["类别2",20]]实现方式创建一个待渲染的dom<template> <div :id="_id" class="chart"></div></template>绘制函数function drawPie(chartData,id,titleText,xText,yText) { var chart = echarts.init(document.getElementById(id)) var xAxisData = chartData.map(function (item) {return item[0]}) var pieData = [] chartData.forEach((v,i)=>{ pieData.push({ name:v[0], value:v[1] }) }) chart.setOption({ title : { text: titleText, subtext: "", x:"center" }, tooltip : { trigger: "item", formatter: "{a} <br/>{b} : {c} ({d}%)" }, legend: { orient: "vertical", left: "left", data: xAxisData }, series : [ { name: xText, type: "pie", radius : "55%", center: ["50%", "60%"], data:pieData, itemStyle: { emphasis: { shadowBlur: 10, shadowOffsetX: 0, shadowColor: "rgba(0, 0, 0, 0.5)" } } } ] }) }挂载结束、数据源改变时重绘 watch:{ _chartData(val){ switch (this._type){ case "LineAndBar": drawLineAndBar(val,this._id,this._titleText,this._xText,this._yText); break case "LineOrBar": drawLineOrBar(val,this._id,this._titleText,this._xText,this._yText); break case "Pie": drawPie(val,this._id,this._titleText,this._xText,this._yText); break default: drawLineAndBar(val,this._id,this._titleText,this._xText,this._yText); break } } }, mounted() { switch (this._type){ case "LineAndBar": drawLineAndBar(this._chartData,this._id,this._titleText,this._xText,this._yText); break case "LineOrBar": drawLineOrBar(this._chartData,this._id,this._titleText,this._xText,this._yText); break case "Pie": drawPie(this._chartData,this._id,this._titleText,this._xText,this._yText); break default: drawLineAndBar(this._chartData,this._id,this._titleText,this._xText,this._yText); break } }总结

我给你一个饼图和一个折线图的例子class BChart{public static void main(String[] args){ PieDataset dataset = getDataSet();//设置数据源 JFreeChart chart = ChartFactory.createPieChart3D( "时延分布统计图", // chart title dataset,// data true,// include legend true, false ); PiePlot3D plot=(PiePlot3D)chart.getPlot(); // 图片中显示百分比:默认方式 //plot.setLabelGenerator(new StandardPieSectionLabelGenerator(StandardPieToolTipGenerator.DEFAULT_TOOLTIP_FORMAT)); // 图片中显示百分比:自定义方式，{0} 表示选项， {1} 表示数值， {2} 表示所占比例 ,小数点后两位 plot.setLabelGenerator(new StandardPieSectionLabelGenerator("{0}={1}({2})", NumberFormat.getNumberInstance(), new DecimalFormat("0.00%"))); // 图例显示百分比:自定义方式， {0} 表示选项， {1} 表示数值， {2} 表示所占比例 plot.setLegendLabelGenerator(new StandardPieSectionLabelGenerator("{0}={1}({2})")); // 设置背景色为白色 chart.setBackgroundPaint(Color.white); // 指定图片的透明度(0.0-1.0) plot.setForegroundAlpha(1.0f); // 指定显示的饼图上圆形(false)还椭圆形(true) plot.setCircular(true); // 设置图标题的字体 Font font = new Font(" 黑体",Font.CENTER_BASELINE,20); TextTitle title = new TextTitle(" 时延分布统计图"); title.setFont(font); chart.setTitle(title); FileOutputStream fos_jpg = null; try { fos_jpg=new FileOutputStream("D:\时延分布统计图.jpg"); ChartUtilities.writeChartAsJPEG(fos_jpg,100,chart,640,480,null); fos_jpg.close(); } catch (Exception e) { } } private static PieDataset getDataSet()//数据源构造 { DefaultPieDataset dataset = new DefaultPieDataset(); dataset.setValue("login.jsp",50); dataset.setValue("reg.jsp",60); return dataset; } ｝

<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <style type="text/css"> #content{width:600px; height:300px; border: 1px solid #ddd; overflow: auto; margin-top:10px;} </style> </head> <body> <input type="file" name="" id="myFile" value="" multiple="multiple" /> </body> <div id="content"></div></html><script type="text/javascript"> window.onload = function() { var oFile = document.getElementById("myFile"); var oCotnent = document.getElementById("content"); oFile.addEventListener("change", function(ev) { var event = ev || window.event; var files = this.files; for (var i = 0, len = files.length; i < len; i++) { var reader = new FileReader(); var file = files[i]; reader.onload = (function(file) { return function(e) { var div = document.createElement("div"); div.innerHTML =this.result; oCotnent.insertBefore(div, null); }; })(file); //读取文件内容 reader.readAsText(file,"utf-8"); } }, false); }</script>

了解http.js模块：我们都只有要创建一个http服务，必须引用http模块,http模块最终会调用net.js实现网络服务// lib/net.js"use strict"; ...Server.prototype.listen = function(...args) { ... if (options instanceof TCP) { this._handle = options; this[async_id_symbol] = this._handle.getAsyncId(); listenInCluster(this, null, -1, -1, backlogFromArgs); // 注意这个方法调用了cluster模式下的处理办法 return this; } ...};function listenInCluster(server, address, port, addressType,backlog, fd, exclusive) {// 如果是master 进程或者没有开启cluster模式直接启动listenif (cluster.isMaster || exclusive) { //_listen2,细心的人一定会发现为什么是listen2而不直接使用listen // _listen2 包裹了listen方法，如果是Worker进程，会调用被hack后的listen方法，从而避免出错端口被占用的错误 server._listen2(address, port, addressType, backlog, fd); return; } const serverQuery = { address: address, port: port, addressType: addressType, fd: fd, flags: 0 };// 是fork 出来的进程，获取master上的handel,并且监听，// 现在是不是很好奇_getServer方法做了什么 cluster._getServer(server, serverQuery, listenOnMasterHandle);} ...答案很快就可以通过cluster._getServer 这个函数找到代理了server._listen2 这个方法在work进程的执行操作向master发送queryServer消息，向master注册一个内部TCP服务器// lib/internal/cluster/child.jscluster._getServer = function(obj, options, cb) { // ... const message = util._extend({ act: "queryServer", // 关键点：构建一个queryServer的消息 index: indexes[indexesKey], data: null }, options); message.address = address;// 发送queryServer消息给master进程，master 在收到这个消息后，会创建一个开始一个server，并且listen send(message, (reply, handle) => { rr(reply, indexesKey, cb); // Round-robin. }); obj.once("listening", () => { cluster.worker.state = "listening"; const address = obj.address(); message.act = "listening"; message.port = address && address.port || options.port; send(message); });}; //... // Round-robin. Master distributes handles across workers.function rr(message, indexesKey, cb) { if (message.errno) return cb(message.errno, null); var key = message.key; // 这里hack 了listen方法 // 子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误 function listen(backlog) { return 0; } // ... const handle = { close, listen, ref: noop, unref: noop }; handles[key] = handle; // 这个cb 函数是net.js 中的listenOnMasterHandle 方法 cb(0, handle);}// lib/net.js/*function listenOnMasterHandle(err, handle) { err = checkBindError(err, port, handle); server._handle = handle; // _listen2 函数中,调用的handle.listen方法，也就是上面被hack的listen server._listen2(address, port, addressType, backlog, fd); }*/master进程收到queryServer消息后进行启动服务如果地址没被监听过，通过RoundRobinHandle监听开启服务如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求// lib/internal/cluster/master.jsfunction queryServer(worker, message) { const args = [ message.address, message.port, message.addressType, message.fd, message.index ]; const key = args.join(":"); var handle = handles[key]; // 如果地址没被监听过，通过RoundRobinHandle监听开启服务 if (handle === undefined) { var constructor = RoundRobinHandle; if (schedulingPolicy !== SCHED_RR || message.addressType === "udp4" || message.addressType === "udp6") { constructor = SharedHandle; } handles[key] = handle = new constructor(key, address, message.port, message.addressType, message.fd, message.flags); } // 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求 // Set custom server data handle.add(worker, (errno, reply, handle) => { reply = util._extend({ errno: errno, key: key, ack: message.seq, data: handles[key].data }, reply); if (errno) delete handles[key]; // Gives other workers a chance to retry. send(worker, reply, handle); });}看到这一步，已经很明显，我们知道了多进行端口共享的实现原理其实端口仅由master进程中的内部TCP服务器监听了一次因为net.js 模块中会判断当前的进程是master还是Worker进程如果是Worker进程调用cluster._getServer 去hack原生的listen 方法所以在child调用的listen方法，是一个return 0 的空方法，所以不会报端口占用错误那现在问题来了，既然Worker进程是如何获取到master进程监听服务接收到的connect呢？监听master进程启动的TCP服务器的connection事件通过轮询挑选出一个worker向其发送newconn内部消息，消息体中包含了客户端句柄有了句柄，谁都知道要怎么处理了哈哈// lib/internal/cluster/round_robin_handle.jsfunction RoundRobinHandle(key, address, port, addressType, fd) { this.server = net.createServer(assert.fail); if (fd >= 0) this.server.listen({ fd }); else if (port >= 0) this.server.listen(port, address); else this.server.listen(address); // UNIX socket path. this.server.once("listening", () => { this.handle = this.server._handle; // 监听onconnection方法 this.handle.onconnection = (err, handle) => this.distribute(err, handle); this.server._handle = null; this.server = null; });}RoundRobinHandle.prototype.add = function (worker, send) { // ...};RoundRobinHandle.prototype.remove = function (worker) { // ...};RoundRobinHandle.prototype.distribute = function (err, handle) { // 负载均衡地挑选出一个worker this.handles.push(handle); const worker = this.free.shift(); if (worker) this.handoff(worker);};RoundRobinHandle.prototype.handoff = function (worker) { const handle = this.handles.shift(); const message = { act: "newconn", key: this.key }; // 向work进程其发送newconn内部消息和客户端的句柄handle sendHelper(worker.process, message, handle, (reply) => { // ... this.handoff(worker); });};下面让我们看看Worker进程接收到newconn消息后进行了哪些操作// lib/child.jsfunction onmessage(message, handle) { if (message.act === "newconn") onconnection(message, handle); else if (message.act === "disconnect") _disconnect.call(worker, true); }// Round-robin connection.// 接收连接，并且处理function onconnection(message, handle) { const key = message.key; const server = handles[key]; const accepted = server !== undefined; send({ ack: message.seq, accepted }); if (accepted) server.onconnection(0, handle);}总结net模块会对进程进行判断，是worker 还是master, 是worker的话进行hack net.Server实例的listen方法worker 调用的listen 方法是hack掉的，直接return 0,不过会向master注册一个connection接手的事件master 收到客户端connection事件后，会轮询向worker发送connection上来的客户端句柄worker收到master发送过来客户端的句柄，这时候就可以处理客户端请求了相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：Vue.js双向绑定项目实战分析jquery如何判断元素内容为空

这篇文章主要介绍了nodejs结合socket.io实现websocket通信功能的方法,结合实例形式分析了nodejs结合socket.io实现websocket通信的具体步骤与相关操作技巧,需要的朋友可以参考下本文实例讲述了nodejs结合socket.io实现websocket通信功能的方法。分享给大家供大家参考，具体如下：因为项目中有需要实时获取后台数据的场景，之前一直是使用http心跳请求的方法。因为websocket与此模式相比有很大的性能提升，而且可以提高实时性，所以对websocket作了一些研究。这里是使用nodejs+socket.io来实现的。达成目标将原来心跳请求后台数据的方式，修改为通过socket连接后台统一推送的方式。后台的数据由别的进程写入文件或写入redis，这里实现的是读取文件的方式。前期准备安装nodejs(略)服务器端新建一个项目目录，这里是sockettest进入sockettest目录，安装express模块和socketio模块npm install --save express@4.10.2npm install --save socket.io新建package.json文件，在其中写入如下内容：{ "name": "socket-test", "version": "0.0.1", "description": "my first socket.io app", "dependencies": { "express": "^4.10.2", "socket.io": "^1.7.2" }}新建index.html，用于作为默认的访问显示页面，因为这里不会用到它，内容随意；新建trends.js文件，在其中写入内容：var app = require("express")();var http = require("http").Server(app);var io = require("socket.io")(http);var fs = require("fs");#默认打开文件app.get("/", function(req, res){ res.sendfile("index.html");});#用于存储所有socket以广播数据var iolist = [];#定义socket on connection（连入）事件行为io.on("connection", function(socket){ #将连入socket加入列表 iolist.push(socket); #记录index，在disconnect（断开连接）发生时将对应的socket删除 var sockex = iolist.indexOf(socket); #定义on disconnect事件行为 socket.on("disconnect", function(){ #将断开连接的socket从广播列表里删除 iolist.splice(sockex, 1); });});# 数据广播进程:每1秒钟广播一次setInterval(function() { # 如果没有正在连接的socket，直接返回； if (iolist.length <= 0) return; var trends = fs.readFileSync("./data/trends.json","utf-8");#trends数据 var coins = fs.readFileSync("./data/coins.json","utf-8");#coins数据 #向所有socket连接发送数据 for (i in iolist) { # 向客户端发送trends数据 iolist[i].emit("trends", trends); # 向客户端发送coins数据 iolist[i].emit("coins", coins); }}, 1000);# 服务器侦听在sockettest.com的3000端口上http.listen(3000, function(){ # 输出到标准输出 console.log("listening on sockettest.com:3000");});新建data目录，并在下面新建两个文件trends与coins，用于存放socket服务器将要读取的数据。新建public目录，在其中新建一个文件index.html，文件内容如下：<!--引入必要的js文件--><script type="text/javascript" src="http://sockettest:3000/socket.io/socket.io.js"></script><script type="text/javascript"> //新建socket var socket = io("http://sockettest.com:3000"); socketdata(socket); function socketdata() { #定义接收到coins类型数据时的行为 socket.on("coins", function(msg){ console.log(msg); } #定义接收到trends类型数据时的行为 socket.on("trends", function(msg){ console.log(msg); } }</script>代码部署刚才之所以要建两个index.html文件，是为了能够方便地在既有的web项目中使用nodejs提供的socket服务。这样我们把public/index.html可以部署在别的服务器中，比如nginx或tomcat之类，然后在根目下启动socket的服务器，为其提供socket服务。 首先在刚才的项目根目录下执行node ./trends.js并保持终端运行，然后再把项目部署在nginx里，通过chrome下访问nginx提供的web服务：http://hostname/public/index.html打开开发者模式，就能在console里看到每隔一秒便会收到来自node服务器的socket推送消息了。通过修改data目录下的两个文件，可以看到写入到文件的数据也会实时地推送到客户端这里来。上面是我整理给大家的，希望今后会对大家有帮助。相关文章：在vue中使用cli如何实现重构多页面脚手架在JS中实现点击下拉菜单内容同步输入框实现输入框与下拉框联动使用parcel.js打包出错的问题详细解读vue重构技术

与HTML相比，ASP网页具有6大特点。 ASP是Active Server Page的缩写，意为“活动服务器网页”。ASP是微软公司开发的代替CGI脚本程序的一种应用,它可以与数据库和其它程序进行交互，是一种简单、方便的编程工具。ASP的网页文件的格式是.asp，现在常用于各种动态网站中。 ASP是一种服务器端脚本编写环境，可以用来创建和运行动态网页或web应用程序。ASP网页可以包含HTML标记、普通文本、脚本命令以及COM组件等。利用ASP可以向网页中添加交互式内容（如在线表单），也可以创建使用HTML网页作为用户界面的web应用程序。 CGI(Common Gateway Interface)是一种共用网关接口,它可以称之为一种机制.因此您可以使用不同的程序编写适合的CGI程序，这些程序语言包括Visual Basic、Delphi或C/C++等，您将已经写好的程序放在WEB服务器的计算机上运行，再将其运行结果通过WEB服务器传输到客户端的浏览器上。事实上，这样的编制方式比较困难而且效率低下，因为你每一次修改程序都必须重新将CGI程序编译成可执行文件。而ASP与Script(脚本)的编写方式非常类似，它完全不需要重新编译成可执行文件就可以直接运行，再者ASP内置的ADO组件，允许用户通过客户端浏览器存取各种各样的数据库。此外，ASP与CGI最大的不同在于对象向导和组件重用，ASP除了内置的Request对象、Response对象、Server对象、Session对象、Application对象、ObjectContext对象等基本对象外，另外可以允许用户以外挂的方式使用ActiveX控件。当然，ASP本身也提供了多个ActiveX控件供使用，这些组件包括广告轮显组件、文件存取组件、文件连接组件几数据库存取组件等，这些大量扩充且重复使用的组件使ASP的功能远大于CGI。 PHP是一种服务器端HTML-嵌入式脚本描述语言。 其最强大和最重要的特征是其数据库集成层，使用它完成一个含有数据库功能的网页是不可置信的简单。在HTML文件中， PHP脚本程序（语法类似于Perl或者c语言）可以使用特别的PHP标签进行引用， 这样网页制作者也不必完全依赖HTML生成网页了。由于PHP是在服务器端执行的， 客户端是看不到PHP代码的。 PHP可以完成任何CGI脚本可以完成的任务，但它的功能的发挥取决于它和各种数据库的兼容性。 PHP除了可以使用HTTP进行通信，也可以使用IMAP, SNMP, NNTP, POP3协议。 JSP(JavaServer Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件(*.jsp)。 Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。 JSP与Java Servlet一样，是在服务器端执行的，通常返回该客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。

1、AJAX不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术,核心对象XMLHTTPRequest。该对象是浏览器API，支持向http服务器发送get post等http协议规定的请求方式。该方式不会重载页面，无刷新交换数据。是客户端browser与浏览器通讯的方式。执行宿主在浏览器的javascript引擎里面。2、cgi是服务器端的一段脚本。该脚本执行时信息输入来自管道，服务器会把请求输入重定向到cgi脚本的标准输入，把cgi脚本的执行的标准输出作为请求的响应！cgi也是一种形式上的后台接口！

与HTML相比，ASP网页具有6大特点。 ASP是Active Server Page的缩写，意为“活动服务器网页”。ASP是微软公司开发的代替CGI脚本程序的一种应用,它可以与数据库和其它程序进行交互，是一种简单、方便的编程工具。ASP的网页文件的格式是.asp，现在常用于各种动态网站中。 ASP是一种服务器端脚本编写环境，可以用来创建和运行动态网页或web应用程序。ASP网页可以包含HTML标记、普通文本、脚本命令以及COM组件等。利用ASP可以向网页中添加交互式内容（如在线表单），也可以创建使用HTML网页作为用户界面的web应用程序。 CGI(Common Gateway Interface)是一种共用网关接口,它可以称之为一种机制.因此您可以使用不同的程序编写适合的CGI程序，这些程序语言包括Visual Basic、Delphi或C/C++等，您将已经写好的程序放在WEB服务器的计算机上运行，再将其运行结果通过WEB服务器传输到客户端的浏览器上。事实上，这样的编制方式比较困难而且效率低下，因为你每一次修改程序都必须重新将CGI程序编译成可执行文件。而ASP与Script(脚本)的编写方式非常类似，它完全不需要重新编译成可执行文件就可以直接运行，再者ASP内置的ADO组件，允许用户通过客户端浏览器存取各种各样的数据库。此外，ASP与CGI最大的不同在于对象向导和组件重用，ASP除了内置的Request对象、Response对象、Server对象、Session对象、Application对象、ObjectContext对象等基本对象外，另外可以允许用户以外挂的方式使用ActiveX控件。当然，ASP本身也提供了多个ActiveX控件供使用，这些组件包括广告轮显组件、文件存取组件、文件连接组件几数据库存取组件等，这些大量扩充且重复使用的组件使ASP的功能远大于CGI。 PHP是一种服务器端HTML-嵌入式脚本描述语言。 其最强大和最重要的特征是其数据库集成层，使用它完成一个含有数据库功能的网页是不可置信的简单。在HTML文件中， PHP脚本程序（语法类似于Perl或者c语言）可以使用特别的PHP标签进行引用， 这样网页制作者也不必完全依赖HTML生成网页了。由于PHP是在服务器端执行的， 客户端是看不到PHP代码的。 PHP可以完成任何CGI脚本可以完成的任务，但它的功能的发挥取决于它和各种数据库的兼容性。 PHP除了可以使用HTTP进行通信，也可以使用IMAP, SNMP, NNTP, POP3协议。 JSP(JavaServer Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件(*.jsp)。 Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。 JSP与Java Servlet一样，是在服务器端执行的，通常返回该客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。

先给大家展示下运行效果图： 1.后台action产生json数据。List blackList = blackService.getBlackInfoList(mobileNum, gatewayid, startDate, endDate); int totalRows = blackList.size(); StringBuffer sb = new StringBuffer(); sb.append("{"totalCount":""+totalRows+"","); sb.append(""jsonRoot":["); for (int i=0;i<blackList.size();i++) { LBlack blackInfo = (LBlack)blackList.get(i); sb.append("{"id":""+ blackInfo.getId()); sb.append("","); sb.append(""mobile":""+ blackInfo.getMobile()); sb.append("","); sb.append(""province":""+ blackInfo.getProvince()); sb.append("","); sb.append(""gateway":""+ blackInfo.getGateway()); sb.append("","); sb.append(""insertTime":""+ blackInfo.getInsertTime()); sb.append("","); sb.append(""remark":""+ blackInfo.getRemark()); sb.append("""); sb.append("},"); } sb.deleteCharAt(sb.lastIndexOf(",")); // 删去最后一个逗号 sb.append("]}"); HttpServletResponse response = ServletActionContext.getResponse(); response.setContentType("text/plain"); response.getWriter().print(sb); 2.struts.xml相关配置<action name="blackList" class="blackAction" method="blackList"> <!--plaintext用于显示页面原始代码的结果类型--> <result type="plainText"> <param name="charSet">UTF-8</param> <param name="location">/WEB-INF/jsp/manage/black.jsp</param> </result></action>3.js获取json数据分页显示function getJSONData(pn) { // alert(pn); $.getJSON("blackList.ce", function(data) { var totalCount = data.totalCount; // 总记录数 var pageSize = 10; // 每页显示几条记录 var pageTotal = Math.ceil(totalCount / pageSize); // 总页数 var startPage = pageSize * (pn - 1); var endPage = startPage + pageSize - 1; var $ul = $("#json-list"); $ul.empty(); for (var i = 0; i < pageSize; i++) { $ul.append("<li class="li-tag"></li>"); } var dataRoot = data.jsonRoot; if (pageTotal == 1) { // 当只有一页时 for (var j = 0; j < totalCount; j++) { $(".li-tag").eq(j).append("<span class="col1"><input type="checkbox" value=""+parseInt(j + 1)+""/></span>") .append("<span class="col2">" + parseInt(j + 1) + "</span>").append("<span class="col3">" + dataRoot[j].mobile + "</span>").append("<span class="col4">" + dataRoot[j].province + "</span>").append("<span class="col5">" + dataRoot[j].gateway + "</span>").append("<span class="col6">" + dataRoot[j].insertTime + "</span>").append("<span class="col7">" + dataRoot[j].remark + "</span>") } } else { for (var j = startPage, k = 0; j < endPage, k < pageSize; j++, k++) { if( j == totalCount){ break; // 当遍历到最后一条记录时，跳出循环 } $(".li-tag").eq(k).append("<span class="col1"><input type="checkbox" value=""+parseInt(j + 1)+""/></span>") .append("<span class="col2">" + parseInt(j + 1) + "</span>").append("<span class="col3">" + dataRoot[j].mobile + "</span>").append("<span class="col4">" + dataRoot[j].province + "</span>").append("<span class="col5">" + dataRoot[j].gateway + "</span>").append("<span class="col6">" + dataRoot[j].insertTime + "</span>").append("<span class="col7">" + dataRoot[j].remark + "</span>") } } $(".page-count").text(pageTotal); })}function getPage() { $.getJSON("blackList.ce", function(data) { pn = 1; var totalCount = data.totalCount; // 总记录数 var pageSize = 10; // 每页显示几条记录 var pageTotal = Math.ceil(totalCount / pageSize); // 总页数 $("#next").click(function() { if (pn == pageTotal) { alert("后面没有了"); pn = pageTotal; } else { pn++; gotoPage(pn); } }); $("#prev").click(function() { if (pn == 1) { alert("前面没有了"); pn = 1; } else { pn--; gotoPage(pn); } }) $("#firstPage").click(function() { pn = 1; gotoPage(pn); }); $("#lastPage").click(function() { pn = pageTotal; gotoPage(pn); }); $("#page-jump").click(function(){ if($(".page-num").val() <= pageTotal && $(".page-num").val() != ""){ pn = $(".page-num").val(); gotoPage(pn); }else{ alert("您输入的页码有误！"); $(".page-num").val("").focus(); } }) $("#firstPage").trigger("click"); })}function gotoPage(pn) { // alert(pn); $(".current-page").text(pn); getJSONData(pn)}$(function() { getPage();})ps：JAVA+JQuery实现异步分页最近一个项目要求实现异步分页，简单的写了一下，不好的请指出~/***分页类*/public class PageBean { publicint rowCount = 0; // 总记录数 publicint currentPage = 1;// 当前页数 publicint sizePerPage = 20;// 每页显示条数 publicint pageCount = 0;// 总页数 publicString pageURL;// 请求URL publicString pageDisplay;// JSP页面显示 publicString pageStyle = "numberStyle";// 分页样式 publicint pagePreOffset = 10;// 向前偏移量 publicint pageNextOffset = 9;// 向后偏移量 publicString pageCss;// 预留 publicString getPageCss() { returnpageCss; } publicvoid setPageCss(String pageCss) { this.pageCss = pageCss; } publicString getPageStyle() { returnpageStyle; } publicvoid setPageStyle(String pageStyle) { this.pageStyle = pageStyle; } publicint getPagePreOffset() { returnpagePreOffset; } publicvoid setPagePreOffset(intpagePreOffset) { this.pagePreOffset = pagePreOffset; } publicint getPageNextOffset() { returnpageNextOffset; } publicvoid setPageNextOffset(intpageNextOffset) { this.pageNextOffset = pageNextOffset; } publicString getPageDisplay() { String nextClick=" onclick="ajaxpage(""+this.pageURL+ "?currentPage=" + (this.currentPage + 1)+"");return false;" "; String preClick=" onclick="ajaxpage(""+this.pageURL+ "?currentPage=" + (this.currentPage - 1)+"");return false;" "; String firstClick=" onclick="ajaxpage(""+this.pageURL+ "?currentPage=1");return false;" "; String lastClick=" onclick="ajaxpage(""+this.pageURL+ "?currentPage=" + (this.getPageCount())+"");return false;" "; String onChange=" onchange="ajaxpage(""+this.pageURL+ "?currentPage=" + (1)+"");return false;" "; StringBuffer pageString =new StringBuffer(); pageString.append("<div class=""+ this.pageStyle +""><span >"); // 数字样式 if("numberStyle".equalsIgnoreCase(this.pageStyle)) { // 如果只有一页，不需要分页 if(this.getPageCount() ==1) { // pageString.append("<strong> 1</strong> "); }else { if(this.currentPage >1) {// 如果当前页数大于1，<< <可用 pageString.append("<a class="pagination-first" "+firstClick+" title="首页" href="" + this.pageURL +"?currentPage=1"><<</a> "); pageString.append("<a class="pagination-prev" "+preClick+"title="上一页" href="" + this.pageURL +"?currentPage=" + (this.currentPage -1) +""><</a> "); }else { pageString .append("<a class="pagination-first"><<</a> "); pageString .append("<a class="pagination-prev"><</a> "); } // 定义向前偏移量 intpreOffset = this.currentPage -1 > this.pagePreOffset ?this.pagePreOffset :this.currentPage -1; // 定义向后偏移量 intnextOffset = this.getPageCount() -this.currentPage >this.pageNextOffset ?this.pageNextOffset :this.getPageCount() -this.currentPage; // 循环显示链接数字，范围是从 当前页减向前偏移量 到 当前页加向后偏移量 for(int i = (this.currentPage - preOffset); i <= (this.currentPage + nextOffset); i++) { String numClick=" onclick="ajaxpage(""+this.pageURL+ "?currentPage=" + (i)+"");return false;" "; if(this.currentPage == i) {// 当前页要加粗显示 pageString .append("<strong style="color:black;border:0">" + i +"</strong> "); }else { pageString.append("<a "+numClick+"href=""+ this.pageURL +"?currentPage=" + i + "">" + i +"</a> "); } } // 如果当前页小于总页数，> >>可用 if(this.currentPage <this.getPageCount()) { pageString.append(&

Can I have fish and rice, please ?我能吃鱼和米饭吗？下面划有连接号的要连读，加括号的是不完全爆破。谐音读作看耐寒v 费善(的)ruai (四)，p 里日？

FUCK!伤心了，真的伤心了，辛辛苦苦没回报，社会真的就是这样吗？

AngularJS为我们提供了自定义指令的功能，通过此功能，我们可以自定义一些标签，为我们自己的开发来提供帮助。下面的内容我将给大家分享关于AngularJs通过directive和restrict来设置自定义指令的方法。一、AngularJs自定义指令directive的restrict属性说明：今天公用的html部分：<h1 zym-blog></h1>JavaScript部分：var m = angular.module("app", []);m.directive("zymBlog", [function(){ return { restrict : "AEC", template : "<p>hello world</p>", replace : true };}]);通过directive设置自定义指令，第一个参数是指令名称，第二个参数是数组，包含一个回调函数，函数的返回值是一个json对象，其中：restrict表示指令的形式：A是属性、E是元素、C是class类，为了避免和style中的class类混淆，不推荐使用C。template是模板内容，表示使用这个自定义属性的标签中要插入的内容。replace的值默认是false，如果是true，说明要用templace中的标签替换html代码中使用这个自定义指令的标签。注意，如果使用replace，那么template中必须包含html元素，不能只是几个文字，否则angular会报错。下面再来看一个属性，templateUrl和template不能同时出现，templateUrl是引用的模板地址：var m = angular.module("app", []);m.directive("zymBlog", [function(){ return { restrict : "AEC", templateUrl : "./46-1.html", replace : true };}]);注意，因为这里使用了replace，所以templateUrl对应的模板内容中必须包含html标签元素。二、自定义指令的标准命名规范：directive指令名称用驼峰命名法，例如【zymBlog】，那么在html代码中进行调用时，需要在大写字母之前加一个横杠，例如【zym-blog】。三、自定义指令template函数式操作：template不仅可以是一个字符串，也可以是一个函数，例如：var m = angular.module("app", []);m.directive("zymBlog", [function(){ return { restrict : "AEC", template : function(){ return "<p>赵一鸣个人技术博客</p>"; }, replace : true };}]);四、自定义指令transclude属性：有一种情况，在html中使用了自定义指令，但是标签内部原来就有内容，这样的话，自定义指令里边的内容会把标签原来的内容替换掉，所以需要一个添加一个属性来解决这个问题（ng-transclude）：html部分：<h1 zym-blog>赵一鸣博客http://www.zymseo.com</h1>js部分：var m = angular.module("app", []);m.directive("zymBlog", [function(){ return { restrict : "AEC", template : function(){ return "<p>赵一鸣AngularJs学习笔记<span ng-transclude></span></p>"; }, replace : true, transclude : true };}]);设置ng-transclude的值为true之后，还必须在自定义指令的内部再加入一个标签，并且制定ng-transclude，这样是把原来html标签里边的内容放到这个标签里边！

1. watch 与 computed 的巧妙结合如上图，一个简单的列表页面。你可能会这么做： created(){ this.fetchData() }, watch: { keyword(){ this.fetchData() } }如果参数比较多，比如上图 关键字筛选， 区域筛选， 设备ID筛选， 分页数， 每页几条数据，可能会是这样：data(){ return { keyword:"", region:"", deviceId:"", page:1 }},methods:{ fetchData(paramrs={ keyword:this.keyword, region:this.region, deviceId:this.deviceId, page:this.page, }){ this.$http.get("/list",paramrs).then("do some thing") }},created(){ this.fetchData()},watch: { keyword(data){ this.keyword=data this.fetchData() }, region(data){ this.region=data this.fetchData() }, deviceId(data){ this.deviceId=data this.fetchData() }, page(data){ this.page=data this.fetchData() }, requestParams(params){ this.fetchData(params) }}不过这么写，明显有问题，主要是watch了很多参数，而且函数的处理都差不多，可以修改一下，通过methods处理data(){ return { keyword:"", region:"", deviceId:"", page:1 }},methods:{ paramsChange(paramsName,paramsValue){ this[paramsName]=paramsValue this.fetchData() }, fetchData(paramrs={ keyword:this.keyword, region:this.region, deviceId:this.deviceId, page:this.page, }){ this.$http.get("/list",paramrs).then("do some thing") }},created(){ this.fetchData()}当然这么写，需要在模板里面每个参数change的地方绑定事件，并传递参数值,比如分页change时：<el-pagination layout="total, prev, pager, next, jumper" :total="total" prev-text="上一页" next-text="下一页" @current-change="paramsChange("page",$event)" ></el-pagination>相比上面的各种watch，代码明显少了很多，但是还有一个问题，那就是要在template的很多地方绑定change事件。最后，当然是使用我们重点推荐的computed + watch了data(){ return { keyword:"", region:"", deviceId:"", page:1 }},computed:{ requestParams() { return { page: this.page, region: this.region, id: this.deviceId, keyword: this.keyword } }},methods:{ fetchData(paramrs={ keyword:this.keyword, region:this.region, deviceId:this.deviceId, page:this.page, }){ this.$http.get("/list",paramrs).then("do some thing") }},watch: { requestParams: { handler: "fetchData", immediate: true }},通过增加一个computed属性，watch这个属性并设置immediate为true，无需再手动绑定事件，相比之上的方法都要简洁。当然，缺点就是对性能稍微有些影响，不过问题不大。2. 使用mixin提取公共部分很多列表页其实使用的很多属性都是一样的，比如 分页 page 数量 size 搜索关键 字keyword 表格数据 tableData这些公共的部分其实可以通过mixin来提取出来/** * mixin/table.js */export default { data() { return { keyword: "", requestKeyword: "", pages: 1, size: 10, total: 0, tableData: [] } }}在要用到的页面import mixin from "@/mixin/table"export default { mixins: [mixin], data() { return { selectRegion: "", selectDevice: "", deviceList: [], } } /* 其他代码 */ ...3. 自动注册全局组件正常情况下，我们需要使用一个我们自己封装的组件时，需要先引入，再注册，最后才能在template模板中使用。<template> <all-region :selectRegion="selectRegion" @region-change="selectRegion=$event"/></template><script>import AllRegion from "./baseButton"export default { components: { AllRegion, }}</script> 当有多个页面需要用到这些组件时，那么就需要在每个需要的页面重复这些步骤。为了简化这些步骤，可以考虑把这些组件作为全局组件来使用，这样每个页面需要时，就可以直接使用了。不过还有一个问题，那就是需要我们手动的全局注册。/* main.js */import Component1 from "@/component/compenent1"import Component2 from "@/component/compenent2"import Component3 from "@/component/compenent3"Vue.component("component1", Component1)Vue.component("component2", Component2)Vue.component("component3", Component3)当组件多了以后，手动注册也变得繁琐起来，可以通过require.context()实现自动注册组件。/** * main.js * 读取componetns下的vue文件并自动注册全局组件 */const requireComponent = require.context("./components", false, /.vue$/)requireComponent.keys().forEach(fileName => { const componentConfig = requireComponent(fileName) const componentName = fileName.replace(/^.//, "").replace(/.vue/, "") Vue.component(componentName, componentConfig.default || componentConfig)})4. 自动注册vuex模块之前我们是这么注册vuex模块的/* module.js */import alarm from "./modules/alarm"import history from "./modules/history"import factory from "./modules/factory"import contact from "./modules/contact"import company from "./modules/company";import deviceManage from "./modules/device-manage"import deviceModel from "./modules/device-model"import deviceActivation from "./modules/device-activation"import user from "./modules/user"import role from "./modules/role"import setAlarm from "./modules/setAlarm"import factoryMode from "./modules/factoryMode";import ScreenDeviceWatch from "./modules/screen-device-watch"import ScreenDeviceForecast from "./modules/screen-device-forecast"export default { alarm, company, deviceManage, deviceModel, user, factory, contact, deviceActivation, history, role, setAlarm, factoryMode, ScreenDeviceWatch, ScreenDeviceForecast,}/* index.js */import Vue from "vue"import Vuex from "vuex"import state from "./state"import getters from "./getters"import modules from "./modules"import actions from "./actions"import mutations from "./mutations"Vue.use(Vuex)export default new Vuex.Store({ state, getters, mutations, actions, modules})可以发现每个模块都要我们手动导入，然后加入到module里面，如此重复。当模块不多还好，假如项目大了，有50个模块，那就得要做很多重复的工作。跟注册组件一样，我们还是利用require.context来实现。/** * 读取./modules下的所有js文件并注册模块 */const requireModule = require.context("./modules", false, /.js$/)const modules = {}requireModule.keys().forEach(fileName => { const moduleName = fileName.replace(/(./|.js)/g, "") modules[moduleName] = { namespaced: true, ...requireModule(fileName).default }})export default modules/* index.js */import Vue from "vue"import Vuex from "vuex"import modules from "./modules"Vue.use(Vuex)export default new Vuex.Store({ state, getters, mutations, actions, modules})这篇关于如何写出更优雅的vue.js代码的文章就介绍到这了，希望大家以后多多支持脚本之家。

JS判断数据类型的方法有：typeof方法用于返回该类型的字符串形式，instanceof方法用来判断原型，constructor方法以及Object.prototype.toString 方法在JavaScript中有多种方法可以帮助我们去判断数据类型，接下来将在文章中为大家详细介绍这些方法，具有一定的参考作用希望对大家有所帮助。【推荐课程：JavaScript教程】方法一：typeof方法typeof 是一个操作符，右侧是一个一元表达式，并返回这个表达式的数据类型。返回的结果用该类型的字符串的形式表示，包括：number、boolean、symbol、string、object、undefined、function 等。返回值分以下几种类型：对于基本类型。除了null值返回object以外，其他均返回正确的结果对于引用值来说，除了function返回function类型，其他都返回object类型例：<script type="text/javascript">var a = "string"; console.log(a); //string var a = 1; console.log(typeof a); //number var a = false; console.log(typeof a); //boolean var a; console.log(typeof a); //undfined var a = null; console.log(typeof a); //object var a = document; console.log(typeof a); //object var a = []; console.log(a); //[] var a = function() {}; console.log(typeof a) //function </script>效果图：方法二：instanceof方法instanceof 是用来判断 A 是否为 B 的实例，表达式为：A instanceof B，如果 A 是 B 的实例，则返回 true,否则返回 false。 在这里需要特别注意的是：instanceof 检测的是原型。<script type="text/javascript">var a=[];console.log(a instanceof Array)</script>返回的结果：true方法三：constructor方法当一个函数被定义时，JS引擎会为它添加 prototype 原型，然后再在 prototype上添加一个 constructor 属性，并让其指向该函数的引用。当执行 var f = new F() 时，F被当成了构造函数，f 是F的实例对象，此时 F 原型上的 constructor 传递到了 f 上，因此 f.constructor == F方法四：Object.prototype.toString 方法toString是Object原型对象上的一个方法，该方法默认返回其调用者的具体类型，更严格的讲，是 toString运行时this指向的对象类型, 返回的类型格式为[object,xxx],xxx是具体的数据类型，其中包括：String，Number，Boolean，Undefined，Null，Function，Date，Array，RegExp，Error，HTMLDocument等等都可以通过这个方法获取到。 console.log(Object.prototype.toString.call(num));console.log(Object.prototype.toString.call("")) ; console.log(Object.prototype.toString.call(1)) ; console.log(Object.prototype.toString.call(true)) ; console.log(Object.prototype.toString.call(null)) ; console.log(Object.prototype.toString.call(new Function()) ); console.log(Object.prototype.toString.call(new Date())) ; console.log(Object.prototype.toString.call([])) ; console.log(Object.prototype.toString.call(document)) ; console.log(Object.prototype.toString.call(window) );效果图：总结：

1、typeof 操作符 typeof 目前能返回string，number，boolean，unfined，object，function，symbol，bigint，这八种判断类型。使用方式：typeof(表达式)和typeof 变量名，具体判断如下： 特别注意数组array的typeof 操作符判断 2、instanceof A instanceof B 可以判断A是不是B的实例，返回一个布尔值，由构造类型判断出数据类型，目前支持数组，对象，date，function类型。 注： instanceof 后面一定要是对象类型，大小写不能写错!!! 亲测： Symbol is not a constructor 3、Object.prototype.toString.call() 通过Object下的toString.call()方法来判断，目前是最为可靠的类型检测手段，它会将当前对象转换为字符串并输出。但它也不是完美的，它无法检测用户自定义类型。 因为Object.prototype是不知道用户会创造什么类型的， 它只能检测ECMA标准中的那些 内置类型 。 注意， 这里的Object和function判断打印都是[object Object]。使用Object.prototype.toString.call判断Symbol报错。 4、contructor 依据 对象 的contructor判断，返回一个布尔值。 注： ===后面一定要是对象类型，大写且不能写错!!!

var a = function(){};var b = "abc";var c = 123;function isFunc(test){ return typeof test == "function";}isFunc(a);//trueisFunc(b);//falseisFunc(c);//false

不需要括号 属于一元操作符就像 +a 中的加号一样 你写+(a)也没错，但是可以不写

1、typeof操作符实例：// 数值typeof 37 === "number";// 字符串typeof "" === "string";// 布尔值typeof true === "boolean";// Symbolstypeof Symbol() === "symbol";// Undefinedtypeof undefined === "undefined";// 对象typeof {a: 1} === "object";typeof [1, 2, 4] === "object";// 下面的例子令人迷惑，非常危险，没有用处。避免使用它们。typeof new Boolean(true) === "object";typeof new Number(1) === "object";typeof new String("abc") === "object";// 函数typeof function() {} === "function";从上面的实例我们可以看出，利用typeof除了array和null判断为object外，其他的都可以正常判断。（推荐教程：javascript教程）2、instanceof操作符 和 对象的constructor 属性这个操作符和JavaScript中面向对象有点关系，了解这个就先得了解JavaScript中的面向对象。因为这个操作符是检测对象的原型链是否指向构造函数的prototype对象的。实例：3、使用 Object.prototype.toString 来判断是否是数Object.prototype.toString.call( [] ) === "[object Array]" // trueObject.prototype.toString.call( function(){} ) === "[object Function]" // true这里使用call来使 toString 中 this 指向 obj。进而完成判断4、使用 原型链 来完成判断[].__proto__ === Array.prototype // truevar fun = function(){}fun.__proto__ === Function.prototype // true5、Array.isArray()Array.isArray([]) // trueECMAScript5将Array.isArray()正式引入JavaScript，目的就是准确地检测一个值是否为数组。IE9+、 Firefox 4+、Safari 5+、Opera 10.5+和Chrome都实现了这个方法。但是在IE8之前的版本是不支持的。相关视频教程推荐：javascript视频教程

typeof运算符返回值中跟js数据类型不一致的是null。1、null在数据库中表示不知道(Unknown) 的数据。2、在编程中，变量以null结尾，表示其后没有可用的数据，数据读取在此结束。

JavaScript数据类型是非常简洁的，它只定义了6中基本数据类型•null：空、无。表示不存在，当为对象的属性赋值为null，表示删除该属性•undefined：未定义。当声明变量却没有赋值时会显示该值。可以为变量赋值为undefined•number：数值。最原始的数据类型，表达式计算的载体•string：字符串。最抽象的数据类型，信息传播的载体•boolean：布尔值。最机械的数据类型，逻辑运算的载体•object：对象。面向对象的基础#当弹出一个变量时：varaa;alert(aa);//变量定义，弹出undefinedalert(aa);//变量未定义,undefined,未定义的变量也是undefined#当判断一个变量是否存在时：varstr;if(str==undefined)//变量定义，可以这样判断if（str==undefined)//变量未定义,报错ReferenceError:strisnotdefined所以，当判断一个变量是否不存在时，用if(typeofstr==undefined)typeof：alert(typeof1);//返回字符串"number"alert(typeof"1");//返回字符串"string"alert(typeoftrue);//返回字符串"boolean"alert(typeof{});//返回字符串"object"alert(typeof[]);//返回字符串"object"alert(typeoffunction(){});//返回字符串"function"alert(typeofnull);//返回字符串"object"alert(typeofundefined);//返回字符串"undefined"你会发现：JavaScript解释器认为null是属于object数据类型的一种特殊形式，而function(){}是function类型，也就是说函数也是一种基本数据类型，而不是对象的一种特殊形式。实际上，在JavaScript中，函数是一个极容易引起误解或引发歧义的数据类型，它可以是独立的函数类型，又可以作为对象的方法，也可以被称为类或构造器，还可以作为函数对象而存在等。所以，在《JavaScript权威指南》中把function被看做是object基本数据类型的一种特殊对象，另外《悟透JavaScript》和《JavaScript高级程序设计》也把函数视为对象，而不是一种基本数据类型。但是在《JavaScript语言精髓与编程实践》中却把function视为一种基本数据类型，而把null视为object类型的一种特殊形式。至于谁对谁错，看来只有根据具体情况而定了。以上这篇浅谈js基本数据类型和typeof就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

如何判断js中的数据类型：typeof、instanceof、 constructor、 prototype方法比较如何判断js中的类型呢，先举几个例子：var a = "iamstring.";var b = 222;var c= [1,2,3];var d = new Date();var e = function(){alert(111);};var f = function(){this.name="22";};最常见的判断方法：typeofalert(typeof a) ------------> stringalert(typeof b) ------------> numberalert(typeof c) ------------> objectalert(typeof d) ------------> objectalert(typeof e) ------------> functionalert(typeof f) ------------> function其中typeof返回的类型都是字符串形式，需注意，例如：alert(typeof a == "string") -------------> truealert(typeof a == String) ---------------> false另外typeof 可以判断function的类型；在判断除Object类型的对象时比较方便。判断已知对象类型的方法： instanceofalert(c instanceof Array) ---------------> truealert(d instanceof Date) alert(f instanceof Function) ------------> truealert(f instanceof function) ------------> false注意：instanceof 后面一定要是对象类型，并且大小写不能错，该方法适合一些条件选择或分支。根据对象的constructor判断： constructoralert(c.constructor === Array) ----------> truealert(d.constructor === Date) -----------> truealert(e.constructor === Function) -------> true注意： constructor 在类继承时会出错eg, function A(){}; function B(){}; A.prototype = new B(); //A继承自B var aObj = new A(); alert(aobj.constructor === B) -----------> true; alert(aobj.constructor === A) -----------> false;而instanceof方法不会出现该问题，对象直接继承和间接继承的都会报true： alert(aobj instanceof B) ----------------> true; alert(aobj instanceof B) ----------------> true;言归正传，解决construtor的问题通常是让对象的constructor手动指向自己： aobj.constructor = A; //将自己的类赋值给对象的constructor属性 alert(aobj.constructor === A) -----------> true; alert(aobj.constructor === B) -----------> false; //基类不会报true了;通用但很繁琐的方法： prototypealert(Object.prototype.toString.call(a) === ‘[object String]") -------> true;alert(Object.prototype.toString.call(b) === ‘[object Number]") -------> true;alert(Object.prototype.toString.call(c) === ‘[object Array]") -------> true;alert(Object.prototype.toString.call(d) === ‘[object Date]") -------> true;alert(Object.prototype.toString.call(e) === ‘[object Function]") -------> true;alert(Object.prototype.toString.call(f) === ‘[object Function]") -------> true;大小写不能写错，比较麻烦，但胜在通用。通常情况下用typeof 判断就可以了，遇到预知Object类型的情况可以选用instanceof或constructor方法，简单总结下，挖个坑，欢迎补充！

js判断undefined类型if(reValue==undefined){alert("undefined");}发现判断不出来，最后查了下资料要用typeof方法：if(typeof(reValue)=="undefined"){alert("undefined");} typeof返回的是字符串，有六种可能："number"、"string"、"boolean"、"object"、"function"、"undefined"

typeof 返回一个表示数据类型的字符串，返回结果包括：number、boolean、string、object、undefined、function、Symbol6种数据类型。对于引用类型，返回的都是object，其实返回object也没有错，因为所有对象的原型链最终都指向了Object,Object是所有对象的`祖宗`。 但当我们需要知道某个对象的具体类型时，typeof 就显得有些力不从心了

mjstyle牌子念作mj风格 Mjstyle属于Fishop旗下的主力潮流品牌,是国内的服装品牌。Mjstyle设计风格简单轻巧,颜色亮丽,注重时尚甜美。MJStyle是快时尚品牌

“style”的读音是:英[stau026al];美[stau026al] 。MJ Style 也就是MJ风格的意思，MJSTYLE设计风格简单轻巧颜色亮丽，更区别与欧美时尚品牌H&M ZARA等宽松休闲的产品风格。MJSTYLE更注重于时尚甜美，故深受众多年轻人喜爱。MJSTYLE每季同步推出3000款以上的流行款式，每周都会根据每一店铺的顾客反馈更新上百款新品以最大可能满足顾客对潮流和个性化的需要，并以亲民的价格来吸引大众的需求。集合了各类牛仔服饰产品，再综合了公司旗帜下多个时尚品牌的相关搭配男女服饰、鞋帽、配饰等产品，给消费者更新的时尚理念。发展历程2011.11，北京开设第一家店铺 MJstyle欧美汇店。2015.12，香港开设第一家门店 香港海港中心店。2017.12，旗下所有门店升级“智慧门店”全程数据化管理。2018.12，官方天猫商城开业。2019.06，微信小程序官方商城上线。

一、江苏城乡建设职业学院教务管理系统入口及简介 江苏城乡建设职业学院是一所独立设置的公办全日制专科层次普通高等学校，2013年6月获批筹建，2015年2月经江苏省人民政府批准正式设立。学院由江苏省人民政府举办，隶属于江苏省住房和城乡建设厅，同时受江苏省教育厅业务指导和管理。 学院前身为江苏省城镇建设学校，1986年筹建并招生，1988年正式成立，2000年被确定为首批国家级重点中等职业学校。1999年起开办五年制高职专业，2003年升格为五年制高等职业技术学校，更名为江苏省常州建设高等职业技术学校（增挂江苏联合职业技术学院常州建设分院校牌）。2011年起与常州市职工大学实施教育资源共享，2013年两校合并筹建高职院。 江苏城乡建设职业学院教务管理系统入口： http://www.js-cj.com/html/yxsz/xzjg/1.html 二、江苏城乡建设职业学院王牌专业有哪些 《高等职业教育创新发展行动计划（2015—2018 年）》项目认定骨干专业：建筑智能化工程技术 省级高职示范专业：城镇规划、工程监理、市政工程技术、园林工程技术、建筑智能化工程技术 省级高职品牌专业：建筑装饰工程技术、园林工程技术、建筑智能化工程技术 省级高职建设优秀专业：物业管理、环境监测与治理技术、城镇规划、建筑智能化工程技术 省联合职业技术学院课改牵头专业、重点专业：建筑装饰工程技术、建筑工程技术 市级高职示范专业：建筑装饰工程技术、工程造价、建筑智能化工程技术、城镇规划、工程监理、市政工程技术、园林工程技术 院级特色专业：房地产经营与管理

这篇文章主要介绍了关于如何使用NodeJS + Lighthouse + Gulp搭建自动化网站性能测试的工具，有着一定的参考价值，现在分享给大家，有需要的朋友可以参考一下假设你还不知道Lighthouse是什么Lighthouse 是Google公司旗下一个开源的、可自动化检测网站质量的工具，界面友好、操作简单、使用方式多样、视角全面，可以用它来测试任意网页，普通用户、QA、开发都可以快速上手。启动姿势难度系数 +1使用Lighthouse的方式有很多种，最简单的，可以使用 Chrome 的开发者工具，步骤如下：打开 Chrome 浏览器按F12在弹出来的窗口中打开 audits 标签点击 Perform an audit...勾选全部Run audit难度系数+2也可以使用命令行。安装Node安装Lighthouse npm install -g lighthouse在命令行中run lighthouse <url>以上两种使用方式都不是本文的重点，如果想深入了解，可参照 Run Lighthouse in DevTools难度系数+3由于最近在学习 NodeJS， 因此笔者决定使用 Node 8 + Gulp 来跑 lighthouse，为了提高结果的准确性，每次task都跑10次 lighthouse， 并且只关心结果指标中的 first-meaningful-paint 毫秒数，最终取10次的平均值，为了可视化与可读性，最终的结果以网页的形式展示，用户可在网页上看到每次执行 Lighthouse 之后 first-meaningful-paint 的毫秒数，也可以看到平均值，如果用户对某次执行的细节感兴趣，可以点击链接察看。最终的结果长这个样子：环境搭建安装 Node 8安装依赖包npm i lighthouse --save-devnpm i chrome-launcher --save-devnpm i fs-extra --save-devnpm i gulp --save-dev配置在项目根目录下创建Lighthouse的配置文件 lighthouse-config.js, 这里我们全部使用默认配置，使用默认配置需在配置文件中声明 extends: "lighthouse:default"。module.exports = { extends: "lighthouse:default"}如果读者需要了解更详细的配置选项，可参考：Lighthouse 这篇大部分内容是关于命令行的，命令行参数同样可用于Nodethrottling这篇是关于网络模拟的Default Config 具体的默认配置参数Web Page Test 模拟不同的网速Emulation 模拟不同的设备Coding在项目根目录下创建 gulpfile.js，首先引入所有依赖的工具：const gulp = require("gulp");const lighthouse = require("lighthouse");const chromeLauncher = require("chrome-launcher");const printer = require("lighthouse/lighthouse-cli/printer");const Reporter = require("lighthouse/lighthouse-core/report/report-generator");const fs = require("fs-extra");const config = require(".lighthouse-config.js");在开始使用 lighthouse 之前，首先创建一个写入文件的方法， 用于最后生成自定义的 report 文件:async function write(file, report) { try { await fs.outputFile(file, report); } catch (Error e) { console.log("error while writing report ", e); }}调用 Lighthouse 之前，我们需要首先启动一个 Chrome 的 instance ，并将端口号提供给 Lighthouse 。--headless表示不打开 browser 窗口。async function launchChrome() { let chrome; try { chrome = await chromeLauncher.launch({ chromeFlags: [ "--disable-gpu", "--no-sandbox", "--headless" ], enableExtensions: true, logLevel: "error" }); console.log(chrome.port) return { port: chrome.port, chromeFlags: [ "--headless" ], logLevel: "error" } } catch (e) { console.log("Error while launching Chrome ", e); }}Chrome 实例启动之后，我们就可以调用 Lighthouse ， 调用时，须提供需要进行性能测试的网站，参数，以及前文创建好的配置，参数包含了 Chrome 启动端口，启动方式（是否 headless 等信息）。async function lighthouseRunner(opt) { try { return await lighthouse("https://www.baidu.com", opt, config); } catch (e) { console.log("Error while running lighthouse"); }}Lighthouse 的返回结果是一个包含性能测试结果， 最终版的配置参数， 指标分组等信息的 json 对象，读者可以参考 Understanding Results 获得更深入的理解。由于这里我们需要使用 Lighthouse 官方的模板生成报告，因此调用官方提供的方法，注意第一个参数传入 result.lhr， 第二个参数声明生成 html 报告（还可以生成 csv 等格式的报告）。function genReport(result) { return Reporter.generateReport(result.lhr, "html");}下面我们写一个将上面几个方法串起来的函数，首先启动一个 Chrome 实例， 然后将 Chrome 实例的某些参数传递给 Lighthouse，使用 lighthouse 跑出来的结果生成报告，并写入 html 文件， html文件应带有时间戳和执行顺序作为唯一标识。start 方法返回结果中的first-meaningful-paint（这是我们最关心的指标，读者可根据自身需要替换，具体指标可参考 Lighthouse)。async function run(timestamp, num) { let chromeOpt = await launchChrome(); let result = await lighthouseRunner(chromeOpt); let report = genReport(result); await printer.write(report, "html", `./cases/lighthouse-report@${timestamp}-${num}.html`); return result.lhr.audits["first-meaningful-paint"].rawValue; await chrome.kill();}下面， 我们可以正式开始写一个 gulp task 啦，首先获得当前时间戳，用于最终生成的报告命名，然后声明一个数组，用于记录每次跑 Lighthouse 生成的 first-meaningful-paint 毫秒数，然后跑10次 Lighthouse， 使用提前创建的模板文件，根据这10的结果，生成一个汇总报告，这里，笔者使用了Lighthouse对外暴露的工具函数进行字符串的替换。gulp.task("start", async function() { let timestamp = Date.now(); let spent = []; for(let i=0; i<5; i++) { spent.push(await run(timestamp, i)); } let template = await fs.readFileSync("./summary/template/template.html", "utf-8"); let summary = Reporter.replaceStrings(template, [{ search: "%%TIME_SPENT%%", replacement: JSON.stringify(spent) }, { search: "%%TIMESTAMP%%", replacement: timestamp }]); write(`./summary/report/summary@${timestamp}.html`, summary)})最后的最后， 执行：gulp start万事大吉。附上汇总界面的模板源码：<!doctype html><html lang="en"><head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1"> <title>Lighthouse Summary Report</title> <style> body { font-family: sans-serif; } table { margin: auto; } tr { border: 1px solid grey; } h1 { text-align: center; margin: 30px auto 50px auto } </style></head><body><table> <h1>Performance Summary Report</h1> <tr> <th> Case No. </th> <th> First Meaningful Paint </th> <th> Link To Details </th> </tr> <tbody id="tableBody"> </tbody></table><script>let timespent = %%TIME_SPENT%%;let timestamp = %%TIMESTAMP%%;let tableBody = document.getElementById("tableBody");let content = "";for(let i=0; i < timespent.length; i++) { content += `<tr style="border: 1px solid grey"> <td> ${i+1} </td> <td> ${timespent[i]} </td> <td> <a href="../../cases/lighthouse-report@${timestamp}-${i}.html">View Details</a> </td> </tr>`}let total = timespent.reduce((i, j) => { return i + j;})let count = timespent.filter(function(i) { return i}).lengthcontent += `<tr><td> AVG</td><td>${total / count}</td></tr>`tableBody.innerHTML = content;</script></body></html>

用一个计时器，在里面判断时间段

1． JSON的数据格式a) 按照最简单的形式，可以用下面这样的 JSON 表示名称/值对：{ "firstName": "Brett" }b) 可以创建包含多个名称/值对的记录，比如：{ "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" }c) 可以创建值的数组{ "people": [ { "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" }, { "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" }]}d) 当然，可以使用相同的语法表示多个值（每个值包含多个记录）：{ "programmers": [ { "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" }, { "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" } ],"authors": [ { "firstName": "Isaac", "lastName": "Asimov", "genre": "science fiction" }, { "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" }],"musicians": [ { "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" }]}注意，在不同的主条目（programmers、authors 和 musicians）之间，记录中实际的名称/值对可以不一样。JSON 是完全动态的，允许在 JSON 结构的中间改变表示数据的方式。2． 在 JavaScript 中使用 JSONJSON 是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON 数据不需要任何特殊的 API 或工具包。 2.1 将 JSON 数据赋值给变量例如，可以创建一个新的 JavaScript 变量，然后将 JSON 格式的数据字符串直接赋值给它：var people = { "programmers": [ { "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" }, { "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" } ], "authors": [ { "firstName": "Isaac", "lastName": "Asimov", "genre": "science fiction" }, { "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" } ], "musicians": [ { "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" } ] }2.2 访问数据将这个数组放进 JavaScript 变量之后，就可以很轻松地访问它。实际上，只需用点号表示法来表示数组元素。所以，要想访问 programmers 列表的第一个条目的姓氏，只需在JavaScript 中使用下面这样的代码：people.programmers[0].lastName;注意，数组索引是从零开始的。2.3 修改 JSON 数据正如访问数据，可以按照同样的方式修改数据：people.musicians[1].lastName = "Rachmaninov";2.4 转换回字符串a) 在 JavaScript 中这种转换也很简单：String newJSONtext = people.toJSONString();b) 可以将任何 JavaScript 对象转换为 JSON 文本。并非只能处理原来用 JSON 字符串赋值的变量。为了对名为 myObject 的对象进行转换，只需执行相同形式的命令：String myObjectInJSON = myObject.toJSONString();说明：将转换回的字符串作为Ajax调用的字符串，完成异步传输。小结：如果要处理大量 JavaScript 对象，那么 JSON 几乎肯定是一个好选择，这样就可以轻松地将数据转换为可以在请求中发送给服务器端程序的格式。3． 服务器端的 JSON3.1 将 JSON 发给服务器a) 通过 GET 以名称/值对发送 JSON在 JSON 数据中会有空格和各种字符，Web 浏览器往往要尝试对其继续编译。要确保这些字符不会在服务器上（或者在将数据发送给服务器的过程中）引起混乱，需要在JavaScript的escape()函数中做如下添加：var url = "organizePeople.php?people=" + escape(people.toJSONString());request.open("GET", url, true);request.onreadystatechange = updatePage;request.send(null);b) 利用 POST 请求发送 JSON 数据当决定使用 POST 请求将 JSON 数据发送给服务器时，并不需要对代码进行大量更改，如下所示：var url = "organizePeople.php?timeStamp=" + new Date().getTime();request.open("POST", url, true);request.onreadystatechange = updatePage;request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");request.send(people.toJSONString());注意：赋值时格式必须是var msg=eval("(" + req.responseText + ")");3.2 在服务器上解释 JSONa) 处理 JSON 的两步骤。 针对编写服务器端程序所用的语言，找到相应的 JSON 解析器/工具箱/帮助器 API。 使用 JSON 解析器/工具箱/帮助器 API 取得来自客户机的请求数据并将数据转变成脚本能理解的东西。 b) 寻找 JSON 解析器寻找 JSON 解析器或工具箱最好的资源是 JSON 站点。如果使用的是 Java servlet，json.org 上的 org.json 包就是个不错的选择。在这种情况下，可以从 JSON Web 站点下载 json.zip 并将其中包含的源文件添加到项目构建目录。编译完这些文件后，一切就就绪了。对于所支持的其他语言，同样可以使用相同的步骤；使用何种语言取决于您对该语言的精通程度，最好使用您所熟悉的语言。c) 使用 JSON 解析器一旦获得了程序可用的资源，剩下的事就是找到合适的方法进行调用。如果在 servlet 中使用的是 org.json 包，则会使用如下代码：public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { StringBuffer jb = new StringBuffer(); String line = null; try { BufferedReader reader = request.getReader(); while ((line = reader.readLine()) != null) jb.append(line); } catch (Exception e) { //report an error } try { JSONObject jsonObject = new JSONObject(jb.toString()); } catch (ParseException e) { // crash and burn throw new IOException("Error parsing JSON request string"); } // Work with the data using methods like... // int someInt = jsonObject.getInt("intParamName"); // String someString = jsonObject.getString("stringParamName"); // JSONObject nestedObj = jsonObject.getJSONObject("nestedObjName"); // JSONArray arr = jsonObject.getJSONArray("arrayParamName"); // etc...}

数据库一直以来给我的感觉就是——麻烦！！！接触了Realm之后才终于可以开开心心的使用数据库了。本文总结一些Realm数据库的常用知识点，包括多线程访问，以及如何与Retrofit2.0一起使用等...看懂这些知识点之后，个人认为就可以在一般的项目中使用Realm了。1. model类必须extends RealmObject,所有属性必须用private修饰2. model中支持基本数据结构：boolean, byte, short, ìnt, long, float, double, String, Dateand byte[]3.若要使用List必须用RealmList<T>，或者继承RealmList4.与Retrofit2.*一起使用，通过Gson来解析Json数据并直接生成RealmObject，可参考如下写法：[java] view plain copy Gson gson = new GsonBuilder().setExclusionStrategies(new ExclusionStrategy() {@Overridepublic boolean shouldSkipField(FieldAttributes f) {return f.getDeclaringClass().equals(RealmObject.class);}@Overridepublic boolean shouldSkipClass(Class<?> clazz) {return false;}

直接上个实例吧。通过retrofit库post一串json格式的数据。首先post的json数据格式如下：12345678910111213141516171819202122232425{"Id": "string","DeviceId": "string","Name": "string","SumDistance": 0,"RouteNo": "string","SumPoints": 0,"SetupTime": "2016-06-10T13:11:00.766Z","UsedTime": 0,"Points": [{"Id": "string","RouteNo": "string","Name": "string","Longitude": "string","Latitude": "string","Height": 0,"Distance": 0,"Yaw": 0,"Pitch": 0,"Speed": 0,"Usedtime": 0}]}通过安装Android studio gsonformat插件，根据上面的json格式自动生成一个Bean类，本文命名为FlyRouteBean，1234567然后就来建立接口了，其内容如下：[java] view plain copypublic interface PostRoute { @Headers({"Content-Type: application/json","Accept: application/json"})//需要添加头 @POST("api/FlyRoute/Add") Call<FlyRouteBean> postFlyRoute(@Body RequestBody route);//传入的参数为RequestBody }接下来就是提交数据的了：12345678910111213141516171819202122FlyRouteBean flyRouteBean=new FlyRouteBean(); flyRouteBean=initdata(flyRouteBean);//根据Bean类初始化一个需要提交的数据类 Gson gson=new Gson(); String route= gson.toJson(flyRouteBean);//通过Gson将Bean转化为Json字符串形式 [java] view plain copyRetrofit retrofit=new Retrofit.Builder() .baseUrl(URL) .addConverterFactory( GsonConverterFactory.create()) .build(); PostRoute postRoute=retrofit.create(PostRoute.class); RequestBody body=RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),route); Call<FlyRouteBean> call=postRoute.postFlyRoute(body); call.enqueue(new Callback<FlyRouteBean>() { @Override public void onResponse(Call<FlyRouteBean> call, Response<FlyRouteBean> response) { Log.e("sssss","-----------------------"+response.body().getDeviceId());//这里是用于测试，服务器返回的数据就是提交的数据。 } @Override public void onFailure(Call<FlyRouteBean> call, Throwable t) { Log.e("sssss",t.getMessage()); } });

以下是我们在Api接口中的定义方法//以前我们使用我们定义好的POJO或javabean类作为callback的泛型，以便Retrofit帮我们解析@POST("/interface/xxxxxx")void getCouponList(Callback<Coupon> reponse);//但如果我们想获得JSON字符串，Callback的泛型里就不能写POJO类了，要写Response（retrofit.client包下）@POST("/interface/xxxxxx")void getCouponList(Callback<Response> reponse);那么在我们请求接口的时候，只需简单一行代码，就能拿到服务器返回的JSON字符串了ZhixueApiUtil.getInstance().getZhixueApi().getCouponList(new Callback<Response>() {@Overridepublic void success(Response response, Response response1) {//注意这里用第一个Response参数的String jsonString = new String(((TypedByteArray) response.getBody()).getBytes());//再使用Retrofit自带的JSON解析（或者别的什么）Coupon coupon = new Gson().fromJson(jsonString, Coupon.class);......}@Overridepublic void failure(RetrofitError error) {......}});

JStockChart是一款简单但实用的开源图表工具，是对JFreeChart的扩展，仅关注于金融时序图与K线图。(2008.08.29最后更新) JStockChart对利用JFreeChart生成金融时序图与K线图进行了简化。目前，JStockChart已实现了时序图部分，包括价格线，均线，量图，中间价和涨跌幅。用户仅需传入指定格式的数据，JStockChart即可生成期望的图片。 对于时序图，如果提供的数据不是"连续"的，JStockChart能够自动补全缺失的数据--被补数据的价格与最近一笔数据的价格相同，而量为0；价格图的纵坐标以指定的"中间价"为中心均匀分布，可重点突出中间价。 该项目的源文件会在晚些时候上传到Google Code中，但可以通过下面一组图片先预览一下JStockChart生成的金融时序图。允许指定中间价(20.88)，以中间价为基准向上和向下均匀地分布坐标点；允许自由地指定单个坐标点标签的对齐方式--左对齐，右对齐，居中(对于时间坐标，这尤其有用)。自动补全缺失的数据(黑色方框指示的区域)。允许指定各个坐标轴显示的坐标点的个数。允许指定是否显示某些图线元素(中间价，均线，涨跌幅，...)。允许只显示价格线图。允许只显示量图。对于时序线图，目前我认为JStockChart的三个功能比较重要：(a)自动补全非连续数据序列中的"缺失"数据。(b)以"中间价"为中心，价格坐标均匀分布。(c)"自由"地定制每个坐标的对齐方式，这对于时间坐标尤为重要。目前JFreeChart就没有提供上述功能，而[1]JStockChart扩展了JFreeChart中的DateAxis和NumberAxis，根据用户指定的数据与坐标对齐方式，重新计算并生成了DateTick和NumberTick。[2]JStockChart对JFreeChart中的TimeSeries进行了修饰，结合SegmentedTimeline，新创建了SegmentedTimeSeries，使得能够自动补全缺失的数据。

jquery.validate.js表单验证 官方网站： http://bassistance.de/jquery-plugins/jquery-plugin-validation/ API: http://jquery.bassistance.de/api-browser/plugins.html 当前版本：1.5.5 需要JQuery版本：1.2.6+, 兼容 1.3.2 <script src="../js/jquery.js" type="text/javascript"></script> <script src="../js/jquery.validate.js" type="text/javascript"></script> (1)required:true 必输字段 (2)remote:"check.php" 使用ajax方法调用check.php验证输入值 (3)email:true 必须输入正确格式的电子邮件 (4)url:true 必须输入正确格式的网址 (5)date:true 必须输入正确格式的日期 (6)dateISO:true 必须输入正确格式的日期(ISO)，例如：2009-06-23，1998/01/22 只验证格式，不验证有效性 (7)number:true 必须输入合法的数字(负数，小数) (8)digits:true 必须输入整数 (9)creditcard: 必须输入合法的信用卡号 (10)equalTo:"#field" 输入值必须和#field相同 (11)accept: 输入拥有合法后缀名的字符串（上传文件的后缀） (12)maxlength:5 输入长度最多是5的字符串(汉字算一个字符) (13)minlength:10 输入长度最小是10的字符串(汉字算一个字符) (14)rangelength:[5,10] 输入长度必须介于 5 和 10 之间的字符串")(汉字算一个字符) (15)range:[5,10] 输入值必须介于 5 和 10 之间 (16)max:5 输入值不能大于5 (17)min:10 输入值不能小于10 例子：自定义密码验证的规则

1,动态添加验证规则// 添加$("#addConnectUser").rules("add",{rules:{required:true,isString:true},messages:{required:"用户名为必填项",isString:"请输入规范字符"}});// 移除$("#addConnectUser").rules("remove","required");在此我要讲一下为什么有一个isString验证规则；这个是为了限制表单中input的输入规则；比如:不允许特殊字符，或者一些特殊的要求；这个isString是自己配置的jQuery.validator.addMethod("isString", function(value, element) {return this.optional(element) || (inputTest.test(value));},"请输入规范内容");// 此处的inputTest为你自定义的验证规则2,如何给已经添加了表单验证的选项移除验证规则;$("#addConnectUser").rules("remove","required");//再次添加可以直接用$("#addConnectUser").rules("add","required");

看api有一个手动验证的方法

本篇文章给大家带来的内容是介绍jQuery的validate.js表单验证插件如何使用（代码示例）。有一定的参考价值，有需要的朋友可以参考一下，希望对你们有所帮助。 效果：代码：<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title>表单验证插件Validate</title> <script src="js/jquery-1.10.2.min.js"></script> <script src="js/jquery.validate.min.js"></script> <style> body { background-color: #000; } form { width: 361px; margin: 80px auto; padding: 50px; border: 2px solid #666; box-shadow: 0 0 5px rgba(255, 255, 255, 0.2); background-color: #999; border-radius: 10px; box-sizing: border-box; } form>p { margin-bottom: 20px; color: #fff; } form>p>label { display: inline-block; width: 80px; text-align: center; } label.error { display: block; width: 100%; color: rgb(189, 42, 42); font-size: 12px; text-align: right; margin-top: 5px; } input { width: 170px; height: 20px; outline: none; background-color: #ddd; border: 1px solid #ddd; border-radius: 4px; } .submit { width: 170px; margin: 30px auto 0; } .submit input { background-color: #0099aa; color: #fff; border: 0; padding: 5px; height: 30px; } </style></head><body> <form id="signupForm" action="" method="post"> <p> <label for="name">姓名：</label> <input type="text" id="name" name="name"> </p> <p> <label for="email">邮箱：</label> <input type="email" id="email" name="email"> </p> <p> <label for="password">密码：</label> <input type="password" id="password" name="password"> </p> <p> <label for="confirm_password">确认密码：</label> <input type="password" id="confirm_password" name="confirm_password"> </p> <p class="submit"> <input type="submit" value="提交"> </p> </form></body><script> $(function() { $("#signupForm").validate({ rules: { name: "required", email: { required: true, email: true }, password: { required: true, minlength: 5 }, confirm_password: { required: true, minlength: 5, equalTo: "#password" } }, messages: { name: "请输入姓名", email: { required: "请输入Email地址", email: "请输入正确的Email地址" }, password: { required: "请输入密码", minlength: "密码不能小于5个字符" }, confirm_password: { required: "请输入确认密码", minlength: "确认密码不能小于5个字符", equalTo: "两次输入的密码不一致" } } }); })</script></html>

获取到对应的值 例如 <input value="1" id="input">var values=document.getElementById("input").value 这个.value代表获取到id为input的input表单内的值(值为1)你要是输入123那么就是123 若是你是一个对象 如var obj={value:1}那么你 var valuess=obj.value的话就是获取到obj里面的value键的值

使用“js压缩”工具可缩小体积，可百度搜索“js压缩”查找工具 把vendor.js代码ctrl + a全选，再ctrl + c复制，粘贴到js压缩工具里，点击“压缩”或“普通压缩”，然后再把压缩后的代码复制粘贴到vendor.js文件中。

这篇文章主要介绍了使用vue打包时vendor文件过大或者是app.js文件很大问题的解决方法,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下第一次使用vue2.0开发，之前都是用的angular1.x。在使用vue-cli脚手架打包后（UI用的Element-ui），发现vendor文件很大，将近1M左右。后来翻阅资料才明白，原来webpack把所有的库都打包到了一起，导致文件很大。我的解决办法： 1、把不常改变的库放到index.html中，通过cdn引入，比如下面这样：然后找到build/webpack.base.conf.js文件，在 module.exports = { } 中添加以下代码externals: { "vue": "Vue", "vue-router": "VueRouter", "element-ui": "ELEMENT", },这样webpack就不会把vue.js, vue-router, element-ui库打包了。声明一下，我把main.js中对element的引入删掉了，不然我发现打包后的app.css还是会把element的css打包进去，删掉后就没了。然后你打包就会发现vendor文件小了很多~如果你还不满足，请接着往下看·····2、vue路由的懒加载（具体作用，官网查看哦，这里就不多介绍了）。刚开始我们使用路由可能是下面这样（router.js），这样一开始进入页面就会把所有的路由资源都加载，如果项目大，加载的内容就会很多，等待的时间页就会越长，导致给用户的不好的体验效果。为了把路由分模块，然后每次进入一个新页面才加载该页面所需要的资源（也就是异步加载路由），我们可以像下面这样使用(router.js)：然后你打包就会发现，多了很多1.xxxxx.js；2.xxxxx.js等等，而vendor.xxx.js没了，剩下app.js 和manifest.js，而且app.js还很小，我这里是100k多一点。这里我没有生成map文件，这样打包速度快一些，整个项目文件也小很多（map文件一般都很大）;取消生成map文件，找到config/index.js ，修改下面箭头指向为false，就行了。刚开始使用，一路磕磕碰碰在所难免，也借鉴了很多前辈们的经验，所以在这里记录一下，希望能帮到更多的人。

disabled 属性规定应该禁用 input 元素被禁用的 input 元素既不可用，也不可点击。可以设置 disabled 属性，直到满足某些其他的条件为止（比如选择了一个复选框等等）。然后，就需要通过 JavaScript 来删除 disabled 值，将 input 元素的值切换为可用。disabled 属性无法与 <input type="hidden"> 一起使用。<input type="text" disabled="disabled" />