js内部私有函数
js的常用函数
js的常用函数（原创实用版）目录一、JavaScript 函数分类二、常规函数1.alert 函数2.confirm 函数3.escape 函数4.eval 函数5.isNaN 函数6.parseFloat 函数7.parseInt 函数三、数组函数四、日期函数五、数学函数六、字符串函数正文JavaScript 是一种广泛应用于网页开发的编程语言，其中的函数是其重要的组成部分。
JavaScript 函数可以根据其用途和特性分为五类，包括常规函数、数组函数、日期函数、数学函数和字符串函数。
一、JavaScript 函数分类1.常规函数：这类函数主要用于处理一些常见的任务，如显示警告对话框、确认对话框、转换字符编码等。
2.数组函数：这类函数主要用于处理数组数据，包括数组的创建、修改、遍历等操作。
3.日期函数：这类函数主要用于处理日期和时间相关的任务，如获取当前日期、格式化日期等。
4.数学函数：这类函数主要用于执行一些数学运算，如计算平方根、绝对值、乘法等。
5.字符串函数：这类函数主要用于处理字符串数据，包括字符串的创建、修改、遍历等操作。
二、常规函数1.alert 函数：用于显示一个带有 OK 按钮的警告对话框。
2.confirm 函数：用于显示一个带有 OK 和 Cancel 按钮的确认对话框。
3.escape 函数：用于将特殊字符转换为对应的 Unicode 编码。
4.eval 函数：用于计算一个表达式的结果。
5.isNaN 函数：用于测试一个值是否为非数字。
6.parseFloat 函数：用于将一个字符串转换为浮点数。
7.parseInt 函数：用于将一个字符串转换为整数。
以上就是 JavaScript 中的常用函数大全，包括常规函数、数组函数、日期函数、数学函数和字符串函数。
js三种定义类的方法
js三种定义类的⽅法之前在伯乐看到的javascript定义类的三种⽅法。
javascript不⽀持类，但变通⼀下⽅法就可以模拟出‘类’；1、构造函数法⽤构造函数模拟“类”，在其内部⽤this关键字指向实例对象。
function Cat(){="⼩⿊";}要⽣成实例的话就⽤new关键字var cat1=new Cat();alert();类的属性和⽅法可以定义在构造函数的prototype对象上。
Cat.prototype.makeSound=function(){alert("喵喵喵");}⼆、Object.create()法。
为了解决”构造函数法”的缺点，更⽅便地⽣成对象，Javascript的国际标准ECMAScript第五版（⽬前通⾏的是第三版），提出了⼀个新的⽅法Object.create()。
⽤这个⽅法，”类”就是⼀个对象，不是函数。
var Cat={name:"⼩⿊";makeSound:function(){alert("喵喵喵");}}然后直接⽤Object.create()⽣成实例，这个就不需要⽤到new关键字了。
var cat1=Object.create(Cat);alert(); //⼩⿊cat1.makeSound();//喵喵喵各⼤浏览器的最新版本都⽀持这个⽅法，包括IE9，如果不⽀持此⽅法的话，如下做：if(!Object.create){Object.create=function(o){function F(){};F.prototype=o;return new F();}}这种⽅法⽐”构造函数法”简单，但是不能实现私有属性和私有⽅法，实例对象之间也不能共享数据，对”类”的模拟不够全⾯。
那么接下去看第三种⽅法。
三、极简主义法1、封装这种⽅法不实⽤this和prototype，代码部署起来⾮常简单，这⼤概也就是他被叫做“极简主义法”的原因。
JS中常用的内置函数
JS中常⽤的内置函数JS内置函数不从属于任何对象，在JS语句的任何地⽅都可以直接使⽤这些函数。
JS中常⽤的内置函数如下: 1、eval(str)接收⼀个字符串形式的表达式，并试图求出表达式的值。
作为参数的表达式可以采⽤任何合法的操作符和常数。
如果参数中包含JS命令，这些命令也可以被执⾏，就像这些命令是JS程序的⼀部分⼀样。
2、parseInt(str,n)试图从⼀个字符串中提取⼀个整数。
可附加⼀个n整数实现返回n进制整数。
如果在字符串中存在除了数字、符号、⼩数点和指数符号以外的字符，就停⽌转换，返回已有的结果。
如果第⼀个字符就不能转换，函数就返回NaN值。
3、parseFloat(str)试图从⼀个字符串中提取⼀个浮点值。
如果在字符串中存在除了数字、符号、⼩数点和指数符号以外的字符，就停⽌转换并返回已有的结果。
如果第⼀个字符就不能转换，函数就返回NaN值。
4、isNaN()⽤于判断是否为NaN值类型，如果是函数返回true。
5、isFinite(number)可以判断参数number是否是⼀个⽆穷。
如果是则函数返回false，否则返回true。
6、escape()接受⼀个字符串，这个字符串中可能含有空格、分号等字符。
函数把字符串转换成Cookie的内部表⽰⽅式。
函数返回值就是这种内部的表达⽅式。
7、unescape()接受⼀个Cookie，把其内部表达⽅式转化成普通的字符串形式。
JS函数⼀共可分为常规函数、数组函数、⽇期函数、数学函数、字符串函数等五类。
1.9个常规函数 (1)alert函数：显⽰⼀个警告对话框，包括⼀个OK按钮。
(2)confirm函数：显⽰⼀个确认对话框，包括OK、Cancel按钮。
(3)escape函数：将字符转换成Unicode码。
(4)eval函数：计算表达式的结果。
(5)isNaN函数：测试是(true)否(false)不是⼀个数字。
(6)parseFloat函数：将字符串转换成符点数字形式。
js面向对象之公有、私有、静态属性和方法详解
js⾯向对象之公有、私有、静态属性和⽅法详解现下，javascript⼤⾏其道，对于⽹站开发⼈员来说，javascript是必需掌据的⼀门语⾔，但随着jquery等框架的流⾏和使⽤，许多⼈对于原⽣javascript缺乏深⼊的理解，习惯了函数式的编辑风格，对于闭包、原型总是说不清道不明．对于js⾯向对象蹩脚的⽤着，⽽要了解js⾯向对象，就必需先了解js中什么是公有⽅法、特权⽅法、静态⽅法⽅法/步骤1.公有属性和公有⽅法function User(name,age){ = name;//公有属性this.age = age;}User.prototype.getName = function(){//公有⽅法return ;}var user = new User('fire⼦海',26);console.log(user.getName());//output:fire⼦海2.私有属性和⽅法function User(name,age){var name = name;//私有属性var age = age;function alertAge(){//私有⽅法alert(age);}alertAge(age); //弹出26}var user = new User('fire⼦海',26);3.静态属性和⽅法在php中，⽆需实例化就可以调⽤的⽅法就叫静态⽅法，js也⼀样，⽆需实例化，即⽤new操作符实化对象，就可调⽤对象的⽅法和属性。
function User(){}User.age = 26;//静态属性User.myname = 'fire⼦海';User.getName =function(){//静态⽅法return this.myname;//如果这⾥使⽤，返回的将是User，所有改⽤了myname，}console.log(User.getName());//output:fire⼦海4.特权⽅法function User(name,age){var name = name;//私有属性var age = age;this.getName = function(){ //特权⽅法return name;//私有属性和⽅法不能使⽤this调⽤}}var user = new User('fire⼦海',26);console.log(user.getName());//output:fire⼦海5.静态类对于静态⽅法和静态属性，我们⽆需像第三步中那样去创建，如果⽹友看过我那篇“js如何制作图⽚轮播”，就知道可以使⽤字⾯量的⽅式来创建。
JS的闭包、高阶函数、柯里化
JS的闭包、⾼阶函数、柯⾥化JS的闭包，是⼀个谈论得⽐较多的话题了，不过细细想来，有些⼈还是理不清闭包的概念定义以及相关的特性。
这⾥就整理⼀些，做个总结。
⼀、闭包1. 闭包的概念闭包与执⾏上下⽂、环境、作⽤域息息相关执⾏上下⽂执⾏上下⽂是⽤于跟踪运⾏时代码求值的⼀个规范设备，从逻辑上讲，执⾏上下⽂是⽤执⾏上下⽂栈（栈、调⽤栈）来维护的。
代码有⼏种类型：全局代码、函数代码、eval代码和模块代码；每种代码都是在其执⾏上下⽂中求值。
当函数被调⽤时，就创建了⼀个新的执⾏上下⽂，并被压到栈中 - 此时，它变成⼀个活动的执⾏上下⽂。
当函数返回时，此上下⽂被从栈中弹出function recursive(flag) {// Exit condition.if (flag === 2) {return;}// Call recursively.recursive(++flag);}// Go.recursive(0);调⽤另⼀个上下⽂的上下⽂被称为调⽤者（caller）。
被调⽤的上下⽂相应地被称为被调⽤者（callee），在这段代码中，recursive 既是调⽤者，⼜是被调⽤者对应的执⾏上下⽂栈通常，⼀个上下⽂的代码会⼀直运⾏到结束。
然⽽在异步处理的 Generator中，是特殊的。
⼀个Generator函数可能会挂起其正在执⾏的上下⽂，并在结束前将其从栈中删除。
⼀旦Generator再次激活，它上下⽂就被恢复，并再次压⼊栈中function *g() {yield 1;yield 2;}var f = g();f.next();f.next();yield 语句将值返回给调⽤者，并弹出上下⽂。
⽽在调⽤ next 时，同⼀个上下⽂被再次压⼊栈中，并恢复环境每个执⾏上下⽂都有⼀个相关联的词法环境可以把词法环境定义为⼀个在作⽤域中的变量、函数和类的仓库，每个环境有⼀个对可选的⽗环境的引⽤⽐如这段代码中的全局上下⽂与foo函数的上下⽂对应的环境let x = 10;let y = 20;function foo(z) {let x = 100;return x + y + z;}foo(30); // 150作⽤域当⼀个执⾏上下⽂被创建时，就与⼀个特定的作⽤域（代码域 realm）关联起来。
js自调用函数
js自调用函数
JavaScript自调用函数是一种特殊的函数，它可以自行调用自身，而不需要外部调用。
它通常用于创建独立的作用域，以保护变量和函数不受外部干扰。
它也可以用于模块化编程，以便将程序分割成一个个可重用的代码段。
JavaScript的自调用函数通常以下面的语法进行定义：
(function(){
//函数体
})();
在这里，函数被包裹在一对圆括号中，同时又被另一对括号调用，所以它就被称为“自调用函数”。
当JavaScript解释器遇到这种情况时，它会立即调用这个函数，而不需要外部调用。
在JavaScript中，自调用函数可以创建一个局部作用域，从而防止变量和函数被外部访问。
除了变量和函数之外，也可以使用自调用函数来实现模块化编程，以便将复杂程序分割成一个个可重用的代码段。
自调用函数还可以用来实现某些特殊的功能，例如延迟执行某些代码，在某些特定的事件发生后执行代码，或者执行某些循环操作。
总的来说，JavaScript自调用函数是一种非常实用的技术，它可以帮助我们实现一些特殊的功能，并有效地保护变量和函数不受外部干扰。
它同时也是模块化编程的重要工具，可以有效地将复杂的程序分割成一个个可重用的模块。
Js函数大全
Js函数大全1. document.write("");为输出语句2 .JS中的注释为//3. 传统的HTML文档顺序是:document->html->(head,body)4. 一个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document)5. 得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value)6. 一个小写转大写的JS:document.getElementById("output").value = document.getElementById("input").value.toUpperCase();7. JS中的值类型:String,Number,Boolean,Null,Object,Function8. JS中的字符型转换成数值型:parseInt(),parseFloat()9. JS中的数字转换成字符型:(""+变量)10. JS中的取字符串长度是:(length)11. JS中的字符与字符相连接使用+号.12. JS中的比较操作符有:==等于,!=不等于,>,>=,<.<=13. JS中声明变量使用:var来进行声明14. JS中的判断语句结构:if(condition){}else{}15. JS中的循环结构:for([initial expression];[condition];[upadte expression]) {inside loop}16. 循环中止的命令是:break17. JS中的函数定义:function functionName([parameter],...){statement[s]}18. 当文件中出现多个form表单时.可以用document.forms[0],document.forms[1]来代替.19. 窗口:打开窗口window.open(), 关闭一个窗口:window.close(), 窗口本身:self20. 状态栏的设置:window.status="字符";21. 弹出提示信息:window.alert("字符");22. 弹出确认框:window.confirm();23. 弹出输入提示框:window.prompt();24. 指定当前显示链接的位置:window.location.href="URL"25. 取出窗体中的所有表单的数量:document.forms.length26. 关闭文档的输出流:document.close();27. 字符串追加连接符:+=28. 创建一个文档元素:document.createElement(),document.createTextNode()29. 得到元素的方法:document.getElementById()30. 设置表单中所有文本型的成员的值为空:var form = window.document.forms[0]for (var i = 0; i<form.elements.length;i++){if (form.elements[i].type == "text"){form.elements[i].value = "";}}31. 复选按钮在JS中判断是否选中:document.forms[0].checkThis.checked (checked属性代表为是否选中,返回TRUE或FALSE)32. 单选按钮组(单选按钮的名称必须相同):取单选按钮组的长度document.forms[0].groupName.length33. 单选按钮组判断是否被选中也是用checked.34. 下拉列表框的值:document.forms[0].selectName.options[n].value (n有时用下拉列表框名称加上.selectedIndex来确定被选中的值)35. 字符串的定义:var myString = new String("This is lightsword");36. 字符串转成大写:string.toUpperCase(); 字符串转成小写:string.toLowerCase();37. 返回字符串2在字符串1中出现的位置:String1.indexOf("String2")!=-1则说明没找到.38. 取字符串中指定位置的一个字符:StringA.charAt(9);39. 取出字符串中指定起点和终点的子字符串:stringA.substring(2,6);40. 数学函数:Math.PI(返回圆周率),Math.SQRT2(返回开方),Math.max(value1,value2)返回两个数中的最在值,Math.pow(value1,10)返回value1的十次方,Math.round(value1)四舍五入函数,Math.floor(Math.random()*(n+1))返回随机数41. 定义日期型变量:var today = new Date();42. 日期函数列表:dateObj.getTime()得到时间,dateObj.getYear()得到年份,dateObj.getFullYear()得到四位的年份,dateObj.getMonth()得到月份,dateObj.getDate()得到日,dateObj.getDay()得到日期几,dateObj.getHours()得到小时,dateObj.getMinutes()得到分,dateObj.getSeconds()得到秒,dateObj.setTime(value)设置时间,dateObj.setYear(val)设置年,dateObj.setMonth(val)设置月,dateObj.setDate(val)设置日,dateObj.setDay(val)设置星期几,dateObj.setHours设置小时,dateObj.setMinutes(val) 设置分,dateObj.setSeconds(val)设置秒[注意:此日期时间从0开始计]43. FRAME的表示方式:[window.]frames[n].ObjFuncVarName,frames["frameName"].ObjFuncVarName,frameName.ObjFu ncVarName44. parent代表父亲对象,top代表最顶端对象45. 打开子窗口的父窗口为:opener46. 表示当前所属的位置:this47. 当在超链接中调用JS函数时用:(javascript:)来开头后面加函数名48. 在老的浏览器中不执行此JS:<!-- //-->49. 引用一个文件式的JS:<script type="text/javascript" src="aaa.js"></script>50. 指定在不支持脚本的浏览器显示的HTML:<noscript></noscript>51. 当超链和ONCLICK事件都有时,则老版本的浏览器转向 a.html,否则转向 b.html.例:<a href="a.html" onclick="location.href='b.html';return false">dfsadf</a>52. JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError, RegExp,String,SyntaxError,TypeError,URIError53. JS中的换行:\n54. 窗口全屏大小:<script>functionfullScreen(){ this.moveTo(0,0);this.outerWidth=screen.availWidth;this.outerHeight=screen.availH eight;}window.maximize=fullScreen;</script>55. JS中的all代表其下层的全部元素56. JS中的焦点顺序:document.getElementByid("表单元素").tabIndex = 157. innerHTML的值是表单元素的值:如<p id="para">"how are <em>you</em>"</p>,则innerHTML 的值就是:how are <em>you</em>58. innerTEXT的值和上面的一样,只不过不会把<em>这种标记显示出来.59. contentEditable可设置元素是否可被修改,isContentEditable返回是否可修改的状态.60. isDisabled判断是否为禁止状态.disabled设置禁止状态61. length取得长度,返回整型数值62. addBehavior()是一种JS调用的外部函数文件其扩展名为.htc63. window.focus()使当前的窗口在所有窗口之前.64. blur()指失去焦点.与FOCUS()相反.65. select()指元素为选中状态.66. 防止用户对文本框中输入文本:onfocus="this.blur()"67. 取出该元素在页面中出现的数量:document.all.tags("div(或其它HTML标记符)").length68. JS中分为两种窗体输出:模态和非模态.window.showModaldialog(),window.showModeless()69. 状态栏文字的设置:window.status='文字',默认的状态栏文字设置:window.defaultStatus = '文字.';70. 添加到收藏夹:external.AddFavorite("","Google");71. JS中遇到脚本错误时不做任何操作:window.onerror = doNothing; 指定错误句柄的语法为:window.onerror = handleError;72. JS中指定当前打开窗口的父窗口:window.opener,支持opener.opener...的多重继续.73. JS中的self指的是当前的窗口74. JS中状态栏显示内容:window.status="内容"75. JS中的top指的是框架集中最顶层的框架76. JS中关闭当前的窗口:window.close();77. JS中提出是否确认的框:if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");}78. JS中的窗口重定向:window.navigate("");79. JS中的打印:window.print()80. JS中的提示输入框:window.prompt("message","defaultReply");81. JS中的窗口滚动条:window.scroll(x,y)82. JS中的窗口滚动到位置:window.scrollby83. JS中设置时间间隔:setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout84. JS中的模态显示在IE4+行,在NN中不行:showModalDialog("URL"[,arguments][,features]);85. JS中的退出之前使用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}} window.onbeforeunload=verifyClose;86. 当窗体第一次调用时使用的文件句柄:onload()87. 当窗体关闭时调用的文件句柄:onunload()88. window.location的属性:protocol(http:),hostname(),port(80),host(:80),pathname("/a/ a.html"),hash("#giantGizmo",指跳转到相应的锚记),href(全部的信息)89. window.location.reload()刷新当前页面.89-1. parent.location.reload()刷新父亲对象（用于框架）89-2. opener.location.reload()刷新父窗口对象（用于单开窗口）89-3. top.location.reload()刷新最顶端对象（用于多开窗口）90. window.history.back()返回上一页,window.history.forward()返回下一页,window.history.go(返回第几页,也可以使用访问过的URL)91. document.write()不换行的输出,document.writeln()换行输出92. document.body.noWrap=true;防止链接文字折行.93. 变量名.charAt(第几位),取该变量的第几位的字符.94. "abc".charCodeAt(第几个),返回第几个字符的ASCii码值.95. 字符串连接:string.concat(string2),或用+=进行连接96. 变量.indexOf("字符",起始位置),返回第一个出现的位置(从0开始计算)97. stIndexOf(searchString[,startIndex])最后一次出现的位置.98. string.match(regExpression),判断字符是否匹配.99. string.replace(regExpression,replaceString)替换现有字符串.100. string.split(分隔符)返回一个数组存储值.101. string.substr(start[,length])取从第几位到指定长度的字符串.102. string.toLowerCase()使字符串全部变为小写.103. string.toUpperCase()使全部字符变为大写.104. parseInt(string[,radix(代表进制)])强制转换成整型.105. parseFloat(string[,radix])强制转换成浮点型.106. isNaN(变量):测试是否为数值型.107. 定义常量的关键字:const,定义变量的关键字:var。
JS的数组，string类的定义及基本方法
JS的数组，string类的定义及基本⽅法函数：函数在调⽤的时候，会形成⼀个私有作⽤域，内部的变量不会被外⾯访问，这种保护机制叫闭包。
这就意味着函数调⽤完毕，这个函数形成的栈内存会被销毁。
function fn(){var a=12;a++;console.log(a)}fn()----13fn()----13fn()----13但有时候我们不希望他被销毁。
函数归属谁跟它在哪调⽤没有关系，跟在哪定义有关。
function fn(){var a=12;return function(){a++;console.log(a)}}var ss=fn()----function(){a++;console.log(a)}ss()------13ss()------14ss()-------15Fn()调⽤完毕后得到的是⼀个匿名函数，但是这个函数在fn这个作⽤域下定义的，所以这个匿名函数内部的变量在fn作⽤域下查找。
这种写法可以使函数内部的变量不被销毁。
function fun(n,o) {console.log(o)return {fun:function(m){// 1,0return fun(m,n);}};}//var a = fun(0); //{fun:function(m){return fun(m,n)}}//a.fun(1); // fun(1,0) //0//a.fun(2); //fun(2,0) //0//a.fun(3);//fun(3,0) //0//var b = fun(0).fun(1).fun(2).fun(3);//undefined,0,1,2var c = fun(0).fun(1); c.fun(2); c.fun(3);//undefined,0,1,1基类Object的⼦类有Function Array Number Boolean String Date Math RegExp函数数组数字布尔字符串⽇期算数正则都是类。
自调用函数
自调用函数自调用函数（Self-InvokingFunction）是JavaScript中一个非常强大的特性，它可以让我们创建一个函数，在被调用时将自己调用（自我调用）。
这种特殊的函数，也被称之为“闭包”（Closure），它可以帮助我们避免全局变量的衍生弊端，从而保护我们的程序免受外部变量的污染，提高程序的安全性和可维护性。
自调用函数的形式是一个函数包裹在括号内，并以小括号结尾。
这些小括号之内是函数参数，它把函数参数传入函数中，函数体接受参数并执行相应操作。
由于函数在被定义时就执行了，它们通常被称之为“立即执行函数”（Immediately-Invoked Function Expression，简称IIFE）。
自调用函数的一个优势是可以创建一个函数的“私有作用域”（Private Scope），从而有效地隔离全局变量。
它可以帮助程序员有效避免变量污染，防止全局变量被不同模块间误用，从而提高程序的可维护性。
此外，自调用函数还可以为变量提供更安全的保护，因为变量绑定到函数中，仅在函数作用域中有效，不会被外部模块访问。
例如，使用以下代码：(function () {var userName = John}());可以创建一个函数，它在执行时自调用，并在函数中声明一个变量“userName”，只在函数中有效，不会影响到全局变量。
另一方面，自调用函数也可以帮助我们封装一些全局函数或对象，从而使程序更加模块化，便于维护和扩展。
例如，如果我们想要封装一组函数，比如“Validate”、“Calculate”等，可以使用：var MyNamespace = (function () {// Validation functionsfunction isNumber(num) { ... }function isString(str) { ... }// Calculation functionsfunction add(a, b) { ... }function subtract(a, b) { ... }return {isNumber: isNumber,isString: isString,add: add,subtract: subtract};}());在这种情况下，MyNamespace是一个闭包，里面包含了一组有用的函数，而这些函数也可以在其他地方（尤其是不同的模块）被调用，而不会影响全局变量。
JS中常用的一切函数和写法
JS中常⽤的⼀切函数和写法⼀、箭头函数arrow funtion1.定义⼀个匿名函数常规语法：function (x) {return x * x;}2.该函数使⽤箭头函数可以使⽤仅仅⼀⾏代码搞定！x => x * x箭头函数相当于匿名函数，并且简化了函数定义箭头函数有两种格式：⼀种像上⾯的，只包含⼀个表达式，连{ ... }和return都省略掉了。
还有⼀种可以包含多条语句，这时候就不能省略{ ... }和return。
例如：x => {if (x > 0) {return x * x;}else {return - x * x;}}箭头函数的语法规则：(parameters) => { statements }如果函数有多个参数或者没有参数，可按照下⾯写法：如果返回值仅仅只有⼀个表达式(expression), 还可以省略⼤括号。
// ⽆参数:() => 3.14//⼀个参数//如果只有⼀个参数，可以省略括号:x=>x*x// 两个参数:(x, y) => x * x + y * y// 可变参数:(x, y, ...rest) => {var i, sum = x + y;for (i=0; i<rest.length; i++) {sum += rest[i];}return sum;}注解：当传⼊的参数不确定时，使⽤rest运算符...rest注意：如果要返回⼀个对象，就要注意，如果是单表达式，这么写的话会报错：// SyntaxError:x => { foo: x }因为和函数体的 { ... } 有语法冲突，所以要改为：// ok:x => ({ foo: x })⼆、JS中filter的⽤法filter() ⽅法创建⼀个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进⾏检测。
常用原生js自定义函数总结
常⽤原⽣js⾃定义函数总结js获取⽇期函数//获取当前时间⽇期function CurentTime(){var now = new Date();var year = now.getFullYear(); //年var month = now.getMonth() + 1; //⽉var day = now.getDate(); //⽇var hh = now.getHours(); //时var mm = now.getMinutes(); //分var clock = year + "-";if(month < 10)clock += "0";clock += month + "-";if(day < 10)clock += "0";clock += day + " ";if(hh < 10)clock += "0";clock += hh + ":";if (mm < 10) clock += '0';clock += mm;return(clock);}js获取时间差函数//获取时间差多少天function getLastTime(){var startTime=new Date("1996-5-11 00:00"); //开始时间var endTime=new Date(); //结束时间var lastTime=endTime.getTime()-startTime.getTime() //时间差的毫秒数//计算出相差天数var days=Math.floor(lastTime/(24*3600*1000))//计算出⼩时数var leave1=lastTime%(24*3600*1000) //计算天数后剩余的毫秒数var hours=Math.floor(leave1/(3600*1000))//计算相差分钟数var leave2=leave1%(3600*1000) //计算⼩时数后剩余的毫秒数var minutes=Math.floor(leave2/(60*1000))//计算相差秒数var leave3=leave2%(60*1000) //计算分钟数后剩余的毫秒数var seconds=Math.round(leave3/1000)return " 相差 "+days+"天 "+hours+"⼩时 "+minutes+" 分钟"+seconds+" 秒";}js只⾃动刷新页⾯⼀次//⾃动刷新页⾯⼀次后停⽌刷新window.onload = function(){if(location.search.indexOf("?")==-1){location.href += "?myurl";}else{if(location.search.indexOf("myurl")==-1) location.href += "&myurl";}}ajax实例$.ajax({type: "POST",url: "join.php",data: dataString,success: function(){$('.success').fadeIn(200).show();$('.error').fadeOut(200).hide();}});实时获取窗⼝⼤⼩$(window).resize(function(){var Height = $(window).height();var Width = $(window).width();})js循环执⾏函数和定时执⾏函数//循环执⾏，每隔3秒钟执⾏⼀次showalert（）window.setInterval(showalert, 3000);function showalert(){alert("循环执⾏");}//定时执⾏，5秒后执⾏show()window.setTimeout(show,5000);function show(){alert("定时执⾏");}js获取get参数函数function GetQueryString(name){var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)");var r = window.location.search.substr(1).match(reg);if(r!=null)return unescape(r[2]); return null;}alert(GetQueryString("参数名1"));js页⾯打印数组函数/*** 打印数组* @param {[type]} arr 要打印的数组* @param {[type]} space 控制打印的缩进* @param {[type]} space2 控制打印的缩进2*/function print_arr(arr, space, space2){space = space || ' ';space2 = space2 || ' ';var str = "Array<br>"+space+"(<br>";for(var i=0; i<arr.length; i++){if( Object.prototype.toString.call(arr[i]) == '[object Array]' ){ //判断是否是数组，如果是，进⾏递归拼接str += space2 + '[' +i+"] => "+ print_arr(arr[i], space+' ', space2+' '); }else{str += space2 +'['+i+"] => "+ arr[i] +"<br>";}}str += space+")<br>";document.write(str);}js打印json数据成数组形式输出在html/** 输出空格函数 */function blank(num) {var res = '';for (var i = 0; i < num; i++) {res += ' ';}return res;}/** 计算JSON对象数据个数 */function jsonLen(jsonObj) {var length = 0;for (var item in jsonObj) {length++;}return length;}/** 解析JSON对象函数 */function printObj(obj) {// JSON对象层级深度deep = (typeof(deep)=='undefined') ? 0: deep;var html = "Array\n"; // 返回的HTMLhtml += kong(deep) + "(\n";var i = 0;// JSON对象，不能使⽤.length获取数据的个数，故需⾃定义⼀个计算函数var len = typeof(obj) == 'array' ? obj.length : jsonLen(obj);for(var key in obj){// 判断数据类型，如果是数组或对象，则进⾏递归// 判断object类型时，&&jsonLen(obj[key])是由于// 1、值（类似：email:）为null的时候，typeof(obj[key])会把这个key当做object类型// 2、值为null的来源是，数据库表中某些字段没有数据，查询之后直接转为JSON返回过来 if(typeof(obj[key])=='array'|| (typeof(obj[key])=='object' && jsonLen(obj[key]) > 0) ){deep += 3;html += kong(deep) + '[' + key + '] => ';// 递归调⽤本函数html += printObj(obj[key],deep);deep -= 3;}else{html += kong(deep + 3) + '[' + key + '] => ' + obj[key] + '\n';}if (i == len -1) {html += kong(deep) + ")\n";};i++;}return html;}/** 向HTML页⾯追加打印JSON数据 */function p_Obj(obj) {var div = document.getElementById('print-json-html');if (div != null) {document.body.removeChild(div);};var node = document.createElement("div");//创建⼀个div标签node.id = 'print-json-html';node.innerHTML = '<pre>' + printObj(obj) + '</pre>';document.body.appendChild(node);}js打印多维数组的数组长度函数//获取多维数组的数量function getArrNum(arr) {var eleNum = 0;if (arr == null) {return 0;}for (var i = 0; i < arr.length; i++) {for (var j = 0; j < arr[i].length; j++) {eleNum++;}}document.write(eleNum);}以上这篇常⽤原⽣js⾃定义函数总结就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
js匿名函数和命名函数
js匿名函数和命名函数JavaScript是一种具有灵活性和互动性的编程语言，它可以帮助我们创建动态和交互式的网页和应用程序。
在JavaScript中，函数是非常重要的概念。
在函数中，我们可以封装一些代码以便以后重复使用，或者我们可以将代码在程序中分成更小的、可管理的部分。
在JavaScript中，有两种类型的函数：匿名函数和命名函数。
1. 匿名函数匿名函数是没有名称的函数。
它们被创建并存储在变量中，通常作为另一个函数的参数传递。
例如，我们可以使用匿名函数来指定JavaScript中的回调函数。
以下是一个使用匿名函数的示例：```setTimeout(function() {alert('Hello, world!');}, 1000);```上面的代码将等待1000毫秒，然后显示一个弹出消息框。
在这里，我们传递了一个匿名函数作为第一个参数，它将在计时器完成后执行。
另一个示例是在DOM事件处理程序中使用匿名函数。
以下是一个用于单击按钮的HTML元素的示例：```<button id="myButton">Click me!</button>```我们将在JavaScript中创建一个事件处理程序，当用户单击按钮时将在控制台中记录一条消息。
我们可以使用匿名函数完成这个任务，如下所示：```var myButton = document.getElementById('myButton');myButton.addEventListener('click', function() {console.log('Button clicked!');});```在这里，我们使用addEventListener方法将匿名函数作为事件处理程序传递给按钮元素。
2. 命名函数命名函数是命名了的函数。
它们是在JavaScript中定义并存储在变量中，以便稍后在程序中使用。
js对函数的说明
js对函数的说明1.函数的定义及特点在JavaScript中，函数可以定义为一组指令及逻辑结构，用于完成特定的任务。
函数一般由关键字function开头，后面紧跟函数名，参数用括号括起来，参数之间用逗号分隔，然后是函数体，最后用return语句返回一个值。
函数的定义形式如下：```javascriptfunction functionName(parameter1, parameter2, …, parameterN){//执行的操作return result;}```其中，functionName是函数名，parameter1、parameter2、…、parameterN是参数，可以为0个或多个，result是返回值，可以为0个或1个。
函数的特点主要有以下几点：- 函数是一段可重复使用的代码块。
通过调用函数可以减少代码冗余，提高代码的可维护性和复用性。
- 函数的执行结果可以用return语句返回，可以作为表达式的值参与运算。
- 函数具有局部作用域，函数内部定义的变量在函数外部是无法访问的，保证了函数的封装性。
- 函数可以作为参数传递给其他函数，也可以作为返回值返回给其他函数，实现函数的组合和复合。
- 函数可以递归调用自己，实现较复杂的计算和算法。
2.函数的调用方式JavaScript中函数的调用方式分为三种：函数调用、方法调用和构造函数调用。
2.1 函数调用函数调用是最基本的调用方式，可以通过函数名直接调用函数。
函数调用语法如下：```javascriptfunctionName(argument1, argument2, …, argumentN);```其中，argument1、argument2、…、argumentN是实参，传入函数内部的参数值。
下面是一个简单的例子：```javascriptfunction add(a, b) {return a + b;}var result = add(1, 2);```add函数接收两个参数a和b，返回两个参数相加的结果。
js的匿名函数
js的匿名函数匿名函数1、定义匿名函数就是没有名字的函数了，也叫闭包函数(closures),允许临时创建⼀个没有指定名称的函数。
最经常⽤作回调函数(callback)参数的值。
2、创建⽅式⼀般有名字的函数的创建⽅式是：function 函数名(参数列表){函数体;}如果是创建匿名函数，那就应该是：function(){函数体;}很明显能看出区别就是，匿名函数没有名字。
因为是匿名函数，所以⼀般也不会有参数传给他。
3、匿名函数的作⽤为什么要创建匿名函数呢？在什么情况下会使⽤到匿名函数。
匿名函数主要有两种常⽤的场景，⼀是回调函数，⼆是直接执⾏函数。
回调函数，像ajax的异步操作，就需要回调函数。
这⾥就不详解。
关于直接执⾏函数，看⼀个例⼦就明⽩了：<script language="javascript">var a = "a";(function(){var a="b";alert(a);})();alert(a);</script>在上⾯这段代码中，会顺序输出两个alert框。
第⼀个alert框内容为b，第⼆个为a。
⼤家看到什么好处了吗？对的，使⽤函数直接执⾏可以限定变量的作⽤域，使不同脚本的相同变量可以得以共存。
4、和匿名函数相关的概念下⾯，我们先初步了解⼀下和匿名函数相关的概念。
函数声明（function 语句），要使⽤⼀个函数，我们就得⾸先声明它的存在。
⽽我们最常⽤的⽅式就是使⽤function 语句来定义⼀个函数，如：function abc(){// code to process}当然，你的函数也可以是带参数的，甚⾄是带返回值的。
function abc(x,y){return x+y;}但是，⽆论你怎么去定义你的函数，JS 解释器都会把它翻译成⼀个Function 对象。
例如，你在定义上⾯的其中⼀个例⼦的函数号，再输⼊如下代码：alert(typeof abc);// "function"你的浏览器就会弹出提⽰框，提⽰你abc 是⼀个Function 对象。
js中常用的函数
js中常用的函数JavaScript是一种广泛使用的编程语言，它具有许多常用的函数，这些函数可以帮助开发人员更轻松地完成任务。
在本文中，我们将介绍一些常用的JavaScript函数。
1. alert()alert()函数用于在浏览器中显示一个警告框，通常用于向用户显示一些重要的信息。
例如，当用户忘记填写必填字段时，可以使用alert()函数来提醒他们。
2. prompt()prompt()函数用于在浏览器中显示一个提示框，通常用于向用户询问一些信息。
例如，当用户需要输入他们的姓名时，可以使用prompt()函数来获取这些信息。
3. console.log()console.log()函数用于在浏览器的控制台中输出一些信息，通常用于调试JavaScript代码。
例如，当开发人员需要查看变量的值时，可以使用console.log()函数来输出这些值。
4. parseInt()parseInt()函数用于将字符串转换为整数。
例如，当开发人员需要将用户输入的字符串转换为数字时，可以使用parseInt()函数来完成这个任务。
5. parseFloat()parseFloat()函数用于将字符串转换为浮点数。
例如，当开发人员需要将用户输入的字符串转换为小数时，可以使用parseFloat()函数来完成这个任务。
6. Math.random()Math.random()函数用于生成一个随机数。
例如，当开发人员需要在游戏中生成一个随机数时，可以使用Math.random()函数来完成这个任务。
7. Math.round()Math.round()函数用于将一个数字四舍五入为最接近的整数。
例如，当开发人员需要将一个小数四舍五入为整数时，可以使用Math.round()函数来完成这个任务。
8. String.fromCharCode()String.fromCharCode()函数用于将Unicode编码转换为字符。
js函数内部定义函数
js函数内部定义函数
在JavaScript 中，我们可以在函数内部定义另一个函数。
这种函数被称为内部函数或者嵌套函数。
内部函数可以访问其外部函数中定义的变量和参数。
下面是一个简单的例子：
javascript
function outerFunction() {
var outerVar = "outer";
function innerFunction() {
var innerVar = "inner";
console.log(outerVar, innerVar);
}
innerFunction();
}
outerFunction(); 输出：outer inner
在上面的代码中，我们定义了一个外部函数`outerFunction()` 和一个内部函数
`innerFunction()`。
内部函数`innerFunction()` 可以访问其外部函数
`outerFunction()` 中定义的变量`outerVar`。
我们在`innerFunction()` 中打印了`outerVar` 和`innerVar` 的值，输出为`"outer inner"`。
需要注意的是，内部函数不能通过其外部函数的变量和参数来修改其外部函数的值。
这意味着，如果我们尝试在内部函数中修改外部函数的变量，外部函数中的值不会被改变。
js hook 闭包函数
js hook 闭包函数JS Hook 闭包函数在JavaScript编程中，闭包函数是一个非常重要的概念。
它不仅可以帮助我们实现一些高级的编程技巧，还可以提升代码的可维护性和可扩展性。
本文将深入探讨JS Hook闭包函数的原理和用法，帮助读者更好地理解和运用这一概念。
让我们来了解一下什么是闭包函数。
简单来说，闭包函数是指在一个函数内部定义的函数，并且这个内部函数可以访问到外部函数的变量。
它的特殊之处在于，即使外部函数已经执行完毕，内部函数仍然可以访问和操作外部函数的变量。
这种特性使得闭包函数非常灵活和强大。
那么闭包函数有什么用呢？我们可以利用闭包函数来实现一些高级的编程技巧，例如在函数内部定义私有变量、实现函数柯里化、实现模块化等。
下面我们将分别介绍这些用法。
闭包函数可以用来实现私有变量。
在JavaScript中，所有的变量默认都是全局变量，这可能会导致变量名冲突的问题。
但是利用闭包函数，我们可以在函数内部定义一些局部变量，使其成为私有变量，从而避免命名冲突的问题。
例如：```function createCounter() {var count = 0;return function() {count++;console.log(count);};}var counter = createCounter();counter(); // 输出1counter(); // 输出2```在上面的例子中，我们利用闭包函数createCounter来创建一个计数器对象。
在createCounter函数内部定义了一个局部变量count，并返回了一个匿名函数。
这个匿名函数可以访问和修改count变量，而且每次调用它时，计数器的值都会加1。
这样我们就实现了一个具有私有计数器的对象。
闭包函数还可以用来实现函数柯里化。
柯里化是一种函数转换的技术，它可以把一个具有多个参数的函数转换成一系列只有一个参数的函数。
这种转换可以使得函数的调用更加灵活和简洁。
javascript函数的几种写法集合
javascript函数的⼏种写法集合1.常规写法1function fnName(){2 console.log("常规写法");3 }2.匿名函数，函数保存到变量⾥1var myfn = function(){2 console.log("匿名函数，函数保存到变量⾥");3 }3.如果有多个变量，可以⽤对象收编变量3.1 ⽤json对象1var fnobject1={2 fn1:function(){3 console.log("第⼀个函数");4 },5 fn2:function(){6 console.log("第⼆个函数");7 },8 fn3:function(){9 console.log("第三个函数");10 }11 }3.2 声明⼀个对象，然后给它添加⽅法1var fnobject2 = function(){};2 fnobject2.fn1 = function(){3 console.log("第⼀个函数");4 }5 fnobject2.fn2 = function(){6 console.log("第⼆个函数");7 }8 fnobject2.fn3 = function(){9 console.log("第三个函数");10 }3.3 可以把⽅法放在⼀个对象函数⾥1var fnobject3 = function(){2return {3 fn1:function(){4 console.log("第⼀个函数");5 },6 fn2:function(){7 console.log("第⼆个函数");8 },9 fn3:function(){10 console.log("第三个函数");11 }12 }13 };4.可⽤类来实现,注意类的第⼆种和第三种写法不能混⽤，否则⼀旦混⽤，如在后⾯为对象的原型对象赋值新对象时，那么他将会覆盖掉之前对prototype对象赋值的⽅法4.1 第⼀种写法1var fnobject4 = function(){2this.fn1 = function(){3 console.log("第⼀个函数");4 }5this.fn2 = function(){6 console.log("第⼆个函数");7 }8this.fn3 = function(){9 console.log("第三个函数");10 }11 };4.2 第⼆种写法1var fnobject5 = function(){};2 fnobject5.prototype.fn1 = function(){3 console.log("第⼀个函数");4 }5 fnobject5.prototype.fn2 = function(){6 console.log("第⼆个函数");7 }8 fnobject5.prototype.fn3 = function(){9 console.log("第三个函数");10 }4.3 第三种写法1var fnobject6 = function(){};2 fnobject6.prototype={3 fn1:function(){4 console.log("第⼀个函数");5 },6 fn2:function(){7 console.log("第⼆个函数");8 },9 fn3:function(){10 console.log("第三个函数");11 }12 }4.4 第四种写法var fnobject7 = function(){};fnobject7.prototype={fn1:function(){console.log("第⼀个函数");return this;},fn2:function(){console.log("第⼆个函数");return this;},fn3:function(){console.log("第三个函数");return this;}}5.对Function对象类的扩展(下⾯三种只能⽤⼀种) 5.1 第⼀种写法（对象）1 Function.prototype.addMethod = function(name,fn){2this[name] = fn;3 }4var methods=function(){};//var methods=new Function();5 methods.addMethod('fn1',function(){6 console.log("第⼀个函数");7 });8 methods.addMethod('fn2',function(){9 console.log("第⼆个函数");10 });11 methods.addMethod('fn3',function(){12 console.log("第三个函数");13 });5.2 链式添加（对象）1 Function.prototype.addMethod = function(name,fn){2this[name] = fn;3return this;4 }5var methods=function(){};//var methods=new Function();6 methods.addMethod('fn1',function(){7 console.log("第⼀个函数");8 }).addMethod('fn2',function(){9 console.log("第⼆个函数");10 }).addMethod('fn3',function(){11 console.log("第三个函数");12 });5.3 链式添加（类）Function.prototype.addMethod = function(name,fn){ this.prototype[name] = fn;return this;}var Methods=function(){};//var methods=new Function(); methods.addMethod('fn1',function(){console.log("第⼀个函数");}).addMethod('fn2',function(){ console.log("第⼆个函数"); }).addMethod('fn3',function(){ console.log("第三个函数"); });。
js函数嵌套函数
js函数嵌套函数JavaScript中的函数嵌套函数是一种非常有用的编程技术，可以让我们在代码中更加灵活地组织和处理数据。
在这篇文章中，我们将会介绍函数嵌套、闭包、作用域链等概念，并且接下来的几个例子将会展示函数嵌套函数的应用场景和实现方法。
1. 函数嵌套的基础概念函数嵌套是Javascript中一个非常基础的概念，可以用来组织复杂的代码和数据。
嵌套函数是指一个函数中包含了其他函数。
嵌套函数有时也被称为“内部函数”。
在Javascript中，内部函数可以轻松地访问外部函数的所有变量、对象和方法。
这就是函数的作用域链。
2. 闭包的定义和原理一个函数作用域是指函数内部的变量和参数可以被该函数里嵌套的所有内部函数所访问。
而在javascript中，函数可以返回一个函数，这个函数可以继续使用该函数的变量和参数，这样的就形成了一个闭包。
闭包由两部分组成：环境和函数。
环境就是闭包创建时的作用域链，函数就是闭包里嵌套的函数。
闭包的原理可以通过这个例子来理解：``` function outerFunction() { var outerVariable = "I am a variable from outer function"; return function (){ console.log(outerVariable); } } var innerFunction = outerFunction(); innerFunction(); ```这段代码首先定义了一个函数 `outerFunction`。
该函数返回了一个新的函数，这个函数又被赋值给了一个变量 `innerFunction`。
最后执行了这个函数。
重点在于嵌套函数可以访问外部函数的变量。
这就是闭包的概念。
在这个例子中，内部函数可以访问外部函数的变量 `outerVariable`，并把该变量的值输出到控制台上。
3. 闭包的作用闭包可以用于实现一下几个常见场景：（1）依赖注入：闭包能够轻松地实现依赖注入。
javascript中定义私有方法（privatemethod）
javascript中定义私有⽅法（privatemethod）⼀度以为在javascript的世界⾥，所有⽅法都是公有的，⽆法真正从技术上定义⼀个私有⽅法，今天⼜⼀次发现：其实我错了!var Person = function(name,sex){ = name;this.sex = sex;var _privateVariable = "";//私有变量//构造器中定义的⽅法，即为私有⽅法function privateMethod(){_privateVariable = "private value";alert("私有⽅法被调⽤！私有成员值：" + _privateVariable);}privateMethod(); //构造器内部可以调⽤私有⽅法}Person.prototype.sayHello = function(){alert("姓名：" + + "，性别：" + this.sex);}var p = new Person("菩提树下的杨过","男");p.sayHello();//p.privateMethod();//这⾥将报错，私成⽅法⽆法被实例调⽤alert(p._privateVariable);//显⽰: undefined说明：类的构造函数⾥定义的function，即为私有⽅法；⽽在构造函数⾥⽤var声明的变量，也相当于是私有变量。
(不过类⽐于c#这类强类型语⾔中的私有成员概念还是有区别的，⽐如⽆法在⾮构造函数以外的其它⽅法中调⽤)类似的，我们还能实现类似set,get属性的封装var Person = function(){var salary = 0.0;this.setSalary = function(value){salary = value;}this.getSalary = function(){return salary;}}var p = new Person();p.setSalary(1000);alert(p.getSalary());//返回1000alert(p.salary);//返回undefined注：js中的"变量作⽤域","函数调⽤上下⽂(this)","闭包","原型链"这⼏个概念确实值得花点⼯夫理解，这⼏道坎跨过去了，js新⼿(⽐如我辈之流)的⽔平相信也将⼩上⼀个新台阶.。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1 内部私有函数<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">//内部私有函数// function a(param){// function b(param1){// return param1+10;// };// return '在a函数体内调用b函数的结果为：'+b(param); // }// document.write(a(5));// document.write(b(1));// function a(param){// var b=function(param1){// return param1+10;// };// return '在a函数体内调用b的结果'+b(param);// }// document.write(a(5));//返回函数的函数//function a(){// alert('aaa');// return function(){// alert('bbb');// };//}////var func=a();////func();//a()();//重写自己的函数//function a(){// alert('aaa');// a=function(){// alert('bbbb');// };//}//a();//a();var a=function(){function setUp(){var setup='doSomeThing';}function doWhat(){alert('要执行的操作');}setUp();return doWhat;}();a();</script></body></html>2 js内置函数<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">//通过Js内置函数构造器创建函数// var func=new Function('a','b','return a+b'); //// alert(typeof func);// alert(func(3,5));// var func1=function(a,b){return a+b};// alert(func1(6,7));//作用域链// var a=1;// function test(){// var b=2;// return a;// }// alert(test());// alert(b);//scope chain// var a=1;// function test(){// var b=2;// function test1(){// var c=3;// alert(a);// alert(b);// alert(c);// return c;// }// test1();// }// test();//词法作用域//function f1(){// var a=12;// return f2();//}//function f2(){// var b=12;// return a;//}//alert(f1());function f1(){var a=1;return f2();}function f2(){var b=3;// alert(b);return a;}alert(f1());var a=55;alert(f1());a=656;alert(f1());</script></body></html>3 闭包<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">//通过闭包突破全局作用域链function f(){var a='king';return function(){return a;}}// alert(a);var test=f();alert(test());</script></body></html>4 return<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript"> // var n;// function f(){// var a='king';// n=function(){// return a;// };// }// f();// alert(n());function f(param){var n=function(){return param;}param++;return n;}var test=f(456);alert(test());</script></body></html>5 参数类型<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">function f1(){var n=1;test=function(){n+=1;};function f2(){alert(n);}return f2;}var res=f1();alert(res());test();alert(res());</script></body></html>6 获取参数<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">var setValue,getValue;(function(){var n=0;getValue=function(){return n;};setValue=function(x){n=x;};})();// alert(n);alert(getValue());setValue(567);alert(getValue());</script></body></html>7 迭代器<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">//迭代器中得应用function test(x){var i=0;return function(){return x[i++];};}var next=test(['a','b','c','d']);alert(next());alert(next());alert(next());alert(next());</script></body></html>8 参数属性<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body><script type="text/javascript">// function f(){// var a=[];// var i;// for(i=0;i<3;i++){// a[i]=function(){ // return i;// };// }// return a;// }// var test=f();// alert(test[0]());// alert(test[1]());// alert(test[2]());// function f(){// var a=[];// var i;// for(i=0;i<3;i++){// a[i]=(function(x){// return function(){ // return x;// }// })(i);// }// return a;// }// var test=f();// alert(test[0]());// alert(test[1]());// alert(test[2]());function f(){function test(x){return function(){return x;}}var a=[];var i;for(i=0;i<3;i++){a[i]=test(i);}return a;}var res=f();alert(res[0]());alert(res[1]());alert(res[2]());</script></body></html>。