继续查找其他问题的答案？
其他答案(0)javascript问题,请求解答和提示!!!!!!!!急求_javascript吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：160,849贴子：
javascript问题,请求解答和提示!!!!!!!!急求收藏
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"&&html&&head&&script type="text/javascript"&
function hightlight_td(){var text=txt.var objTable=document.getElementById("table");var rownum=objTable.rows.
for(var i=0;i&i++)
for(var j=0;j&objTable.rows[i].cells.j++)
a=objTable.rows[i].cells[j].innerHTML;
if(text==a){
objTable.rows[i].style.background="#ff0ff0";
objTable.rows[i].style.background="#FFFFFF";
}&/script&&/head&&body&&table id="table" border="1"&
&th scope="col"&Name&/th&
&th scope="col"&Class&/th&
&th scope="col"&Birthday&/th&
&th scope="col"&Constellation&/th&
&th scope="col"&Mobile&/th&
&td&isaac&/td&
&td&W13&/td&
&td&Jun 24th&/td&
&td&Cancer&/td&
&td&1118159&/td&
&td&fresheggs&/td&
&td&W610&/td&
&td&Nov 5th&/td&
&td&Scorpio&/td&
&td&1038818&/td&
&/tr&&/table&&input type="text" name="txt"&&input type="button" value="查询" onClick="hightlight_td()" &&/body&&/html&我要求输入一个值,那个值所在的行的背景色都变化,但是为什么没有实现?求解,谢谢!
应该在内循环内判断，然后用一个标识去，不然a的值一直被覆盖，就像小熊掰玉米似的。。 function hightlight_td(){
var text=txt.
var objTable=document.getElementById("table");
var rownum=objTable.rows.
for(var i=0;i&i++){
var a="",q=
for(var j=0;j&objTable.rows[i].cells.j++){
a=objTable.rows[i].cells[j].innerHTML;
if(a==text){
objTable.rows[i].style.background="#ff0ff0";
objTable.rows[i].style.background="#FFFFFF";
另外，代码可以优化 function $(e){return document.getElementById(e)};//从ID获取元素function hightlight_td(){
var i,j,q,o,t=$("txt").//为了兼容性，请用ID取元素
with($("table"))for(i=0;i&rows.i++){//遍历行
with(o=rows[i])for(j=0,q=0;j&cells.j++)//初始化标识q，遍历单元格
if(cells[j].innerHTML==t){q=1;break};//判断相等设置标识q
o.style.background=q?"#ff0ff0":"#FFF";//设置行背景颜色
多谢高手的帮助,现在我理解了!
很厉害啊，那么长的代码这么一优化就这么一点了，公司一个5000多行的地图网站说是要优化，想请教一下怎么优化，怎么弄，用什么技术优化？
小熊掰玉米
你太可爱了
用好with和while语句可以省下很多代码。。
哦，谢谢啊
登录百度帐号没有更多推荐了，
不良信息举报
举报内容：
解决浏览器不支持javascript问题
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！JavaScript中的各种奇葩问题
时间： 22:18:21
&&&& 阅读：341
&&&& 评论：
&&&& 收藏：0
标签：原文:JavaScript浮点数
var a = (0.1 + 0.2) + 0.3;
var b = 0.1 + (0.2 + 0.3);
console.log(a);//0.0001
console.log(b);//0.6
在JavaScript中是没有整数的，所有数字都是双精度浮点数。
尽管JavaScript中缺少明显的整数类型，但是可以进行整数运算。
位算术运算符不会将操作数作为浮点数进行运算，而是会将其隐匿转换为32位整数后进行运算。
尽可能的采用整数值运算，因为整数在表示时不需要舍入。
上述代码最好用如下代码替换
var a = ((10 + 20) + 30)/100;
var b = (10 + (20 + 30))/100;
console.log(a);//0.6
console.log(b);//0.6
当心强制类型转换
var obj = {
toString: function () {
return "[object MyObject]";
valueOf: function () {
return 17;
console.log(obj.valueOf);
也许你会想当然的认为结果是17，可是结果却如下图所示，是不是让你大失所望。原因是对象通过valueOf方法强制转换为数字，通过toString方法强制转换为字符串。
像写如下代码，你本来的原意是想如果用户没有传入x,y，则设置默认值为320，240，结果当你x,y分别传入0，0的时候，函数也将x,y设置为了320，240
function point(x,y) {
return { x: x, y: y };
因为在JavaScript中有7个假值：false 、0、-0、""、 NaN、 null、 undefined，所以当你传入0的时候就自动转换为false了......
function point(x, y) {
if (typeof x===‘undefined‘) {
if (typeof y===‘undefined‘) {
return { x: x, y: y };
再来看一个例子。
"1.0e0" == {
valueOf: function () {
return true;
这也就是为什么在JS里面尽量使用全等运算符===而不要使用==，除非你了解如下规则。
尽量使用原始类型而不用封闭对象
var s = new String(‘hello‘);
console.log(typeof ‘hello‘);//string
console.log(typeof s);//object
JavaScript有5个原始值类型：布尔值、数字、字符串、null和undefined
String对象是一个真正的对象，它不同于原始的字符串
var s1 = new String(‘hello‘);
var s2 = new String(‘hello‘);
console.log(s1 === s2);//false
console.log(s1 == s2);//false
由于String对象都是一个单独的对象，其总是只等于自身，对于非严格相等运算结果同样如此。
当做相等比较时，原始类型的封装对象与其原始值行为不一样。
命名函数相关问题
var f = function g() {
return 17;
alert(g());
上述代码在ie6执行，弹出17，而在谷歌下则直接报错。这是因为JavaScript环境把f和g这两个函数作为不同的对象，从而导致不必要的内存分配。
所以上述代码在ie6下面最好写成如下所示
var f = function g() {
return 17;
var g = null;
alert(g());
看一下下面代码
function f() {
return ‘global‘;
function test(x) {
function f() {
return ‘local‘;
var result = [];
result.push(f());
result.push(f());
console.log(test(true));//[local,local]
console.log(test(false));//[local]
也许这样的代码你一眼就能看出答案，那下面的代码呢，你试着猜下结果。
function f() {
return ‘global‘;
function test(x) {
var result = [];
function f() {
return ‘local‘;
result.push(f());
result.push(f());
alert(test(true));//[local,local]
alert(test(false));//[local]
ES5建议将非标准环境的函数声明转变成警告或错误，编写可移植的函数的最好方式是始终避免将函数声明置于局部块或子语句中。
eval最令人吐血的地方就是干扰作用域。也就是说eval函数具有访问调用它那时的整个作用域的能力。
var y = ‘global‘;
function test(x) {
eval(‘var y="local";‘);
console.log(test(true));//local
console.log(test(false));//global
那怎样保证eval函数不影响外部作用域呢，那就是匿名函数立即执行。如下所示
var y = ‘global‘;
function test(x) {
(function (src) {
eval(src);
console.log(test(‘var y="local";‘));//global
console.log(test(‘var z="local";‘));//global
事实上，我们可以绑定eval函数到另一个变量名，通过该变量名调用函数会使代码失去对所有局部作用域的访问能力。
var y = "global";
function test(x) {
var x = "var y=‘local‘";
return f(x);
console.log(test());//undefnied
这个答案undefined我想应该是你想不到的吧。
将eval函数同一个字面量包裹在序列表达式中以达到强制使用间接调用eval函数的目的。其实我们最常用的间接调用eval的方式是如下所示
(0,eval)(src);
函数相关的巧用
var names = [‘Fred‘, ‘Wilma‘, ‘Pebbles‘];
var upper = [];
for (var i = 0, n = names. i & i++) {
upper[i] = names[i].toUpperCase();
console.log(upper);
像上面代码，我们要实现将数组中每个项都强制转换成大写，有什么更好的方面吗？
var names1 = [‘Fred‘, ‘Wilma‘, ‘Pebbles‘];
var upper1 = names1.map(function (name) {
return name.toUpperCase();
console.log(upper);
这个代码是否比上面要简单很多，事实上ES5提供了很多类似map的函数，如every,some,forEach等等
var aIndex = ‘a‘.charCodeAt(0);
var alphabet = ‘‘;
for (var i = 0; i & 26; i++) {
alphabet += String.fromCharCode(aIndex + i);
console.log(alphabet);
var digits = ‘‘;
for (var i = 0; i & 10; i++) {
console.log(digits);
var random = ‘‘;
for (var i = 0; i & 8; i++) {
random += String.fromCharCode(Math.floor(Math.random() * 26) + aIndex);
console.log(random);
像上面三个方面的逻辑当中都有类似的部分，大家都知道程序的坏味道就是重复相同的代码，那怎样让代码更加简单。将相似的逻辑封装成方法，然后。。。
function buildString(n, callback) {
var result = ‘‘;
for (var i = 0; i & i++) {
result += callback(i);
var alphabet1 = buildString(26, function (i) {
return String.fromCharCode(aIndex + i);
console.log(alphabet1);
var digits1 = buildString(10, function (i) {
console.log(digits1);
var random1 = buildString(8, function () {
return String.fromCharCode(Math.floor(Math.random() * 26) + aIndex);
console.log(random1);
是不是简单了很多。
arguments的一些异样。。。
先从例子说起吧，下面的方法原意是想得到两数相加的结果，可是却报错了
function callMethod(obj,method) {
var shift = [].
shift.call(arguments);
shift.call(arguments);
return obj[method].apply(obj, arguments);
var obj = {
add: function (x, y) {
return x +
console.log(callMethod(obj, ‘add‘, 17, 25));
那么我们应该如何修改才能达到相加的效果呢？事实上很简单
function callMethod(obj, method) {
var args = [].slice.call(arguments, 2);
return obj[method].apply(obj, args);
var obj = {
add: function (x, y) {
return x +
console.log(callMethod(obj, ‘add‘, 17, 25));//42
这个例子说明了什么呢，也就是说我们不要随意修改arguments的值。[].slice.call(arguments)将arguments对象复制到一个真正的数组中再进行修改。
使用事实上在严格模式下，函数参数不支持对arguments修改。
function strict(x) {
‘use strict‘;
arguments[0] === ‘modified‘;
return x === arguments[0];
function nonstrict(x) {
arguments[0] === ‘modified‘;
return x === arguments[0];
console.log(strict(‘unmodified‘))//true
console.log(nonstrict(‘unmodified‘));//true
再看一个相关的例子
function values() {
var i = 0, n = arguments.
hasNext: function () {
return i &
next: function () {
if (i &= n) {
throw new Error(‘end of iteration‘);
return arguments[i++];
var it = values(1, 3, 4, 5, 2, 4, 6, 7, 8, 3, 45);
console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());
本来我们期望是得到1，3，4，5，结果却发现每个值都是undefined，原因在next函数中的arguments和values函数中的arguments不是一个对象，所以一定要当心函数嵌套层级问题，
那我们应该如何改正问题呢
function values() {
var i = 0, n = arguments.length, a =
hasNext: function () {
return i &
next: function () {
if (i &= n) {
throw new Error(‘end of iteration‘);
return a[i++];
var it = values(1, 3, 4, 5, 2, 4, 6, 7, 8, 3, 45);
console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());
也就是说我们最好使用临时变量来保存中间值。
当心函数的接收者
var buffer = {
entries: [],
add: function (s) {
this.entries.push(s);
concat: function () {
return this.entries.join(‘‘);
var source = [‘897‘, ‘_‘, ‘8579‘];
console.log(source.forEach(buffer.add));//这种是错误的
也许你期望着能得到897_8579
却发现报错了
事实上这个问题就是this导致的，也就是说在提取一个方法的时候不会将方法的接收者绑定到该方法的对象上。那如何解决呢，有好些方法呢，看看吧！
var buffer = {
entries: [],
add: function (s) {
this.entries.push(s);
concat: function () {
return this.entries.join(‘‘);
var source = [‘897‘, ‘_‘, ‘8579‘];
//console.log(source.forEach(buffer.add));//这种是错误的
也许你期望着能得到897_8579
却发现报错了
source.forEach(buffer.add, buffer);//这个方法就是说我们把this对象的接收者给传进去
source.forEach(function (s) {//也可以这样
在函数方法里面在适应的接收者上调用该方法...
buffer.add(s);
source.forEach(buffer.add.bind(buffer));//也可以使用bind方法来指定对象的接收者
console.log(buffer.add === buffer.add.bind(buffer));//再来看看这句代码
我相信你应该悟出了点什么吧
使用闭包而不是字符串来封装代码
function repeat(n, action) {
for (var i = 0; i & i++) {
eval(action);
function f() {
var a = 0, b = 1, n = 100, sum = 0;
for (var i = 0; i & i++) {
var start = [],
timings = [];
repeat(1000, "start.push(Date.now());f();end.push(Date.now());");
上面的代码就是实现计时的功能。你或许不知道我在说什么，但是你接着往下看。
*@desc:这样写就报错了，大家知道原因吗？？？
*/function benchmark() {
var start = [],
timings = [];
repeat(1000, "start.push(Date.now());f();end.push(Date.now());");
for (var i = 0, n = start. i & i++) {
timings[i] = end[i] - start[i];
return timings[i];
上述代码报错了，你知道为什么我仅仅移动了一下位置，只是把代码移动到一个函数中就导致报错的原因了吗？因为这时的start只是benchmark函数内的局部变量，而eval执行时是调用的全局变量start.
那怎么样让代码正常执行不报错而又能起到封装效果呢？用下面的代码试试吧！
*@desc:还是这样写比较靠谱
function benchmark() {
var start = [],
timings = [];
repeat(1000, function () {
start.push(Date.now()); f(); end.push(Date.now());
for (var i = 0, n = start. i & i++) {
timings[i] = end[i] - start[i];
console.log(benchmark());;
暂时先写这些吧！其实还有好多，文笔不好，写的不够容易理解，望见谅标签：原文地址：http://www.cnblogs.com/lonelyxmas/p/4260872.html
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！JavaScript 是所有现代浏览器的官方语言。因此，各种语言的开发者面试中都会遇到 JavaScript 问题。
本文不讲最新的 JavaScript 库，通用开发实践，或任何新的 ES6 函数。而是讲讲面试中经常出现的 3 个 JavaScript 问题。我问过这些问题，我的朋友说他们也问。
当然不是说你在准备 JavaScript 面试时只要学习这 3 个问题 —— 你还有很多途径去更好的准备即将到来的面试 —— 但面试官很有可能通过下面 3 个问题来判断你了解和掌握 JavaScript 和 DOM 的情况。
让我们开始吧！注意下面的例子中我们使用原生 JavaScript， 因为面试官通常想考查你在不借助库（例如 jQuery）的帮助时掌握 JavaScript 和 DOM 的情况。
问题 #1： 事件代理
创建应用时，有时需要给页面中的按钮，文字，或图片添加事件监听器，当用户与这些元素交互时触发某些操作。
我们以一个简单的代办事项列表为例，面试官会告诉你，他们希望在用户点击列表中某一项时触发一个动作。并让你用 JavaScript 根据下面的 HTML 代码实现这个功能：
&ul id="todo-app"&
&&li class="item"&Walk the dog&/li&
&&li class="item"&Pay bills&/li&
&&li class="item"&Make dinner&/li&
&&li class="item"&Code for one hour&/li&&/ul&
你可能会像下面的代码一样给元素添加事件监听器：
document.addEventListener('DOMContentLoaded', function() {
&let app = document.getElementById('todo-app');
&let items = app.getElementsByClassName('item');
&// 给每个列表项添加事件监听器
&for (let item of items) {
& &item.addEventListener('click', function() {
& & &alert('you clicked on item: ' + item.innerHTML);
当然上面的代码能完成面试官的需求，问题是每个列表项都会加上一个事件监听器。当列表只有 4 项时没有问题，但如果有人给代办事项列表新增了 10,000 个事项呢（他们也许有一大堆事情要做）？那时函数会创建 10,000 个事件监听器，然后把它们都添加到 DOM 上。这样效率非常低。
面试中最好首先问一下面试官用户最多可以添加多少个代办事项。如果永远不会超过 10 个，那上面的代码运行起来就没有问题。但如果用户输入待办事项的数量没有上限，那你就得换一个更高效的解决方案。
如果应用有上百个事件监听器，更高效的解决方案是给最外层的容器添加一个事件监听器，当用户真正点击的时候再去获取实际被点击的代办事项。这被称为事件代理，这比给每个代办事项都单独添加事件监听器更高效。
下面是事件代理的代码：
document.addEventListener('DOMContentLoaded', function() {
&let app = document.getElementById('todo-app');
&// 给容器添加事件监听器
&app.addEventListener('click', function(e) {
& &if (e.target && e.target.nodeName === 'LI') {
& & &let item = e.target;
& & &alert('you clicked on item: ' + item.innerHTML);
问题 #2: 在循环中使用闭包
面试中经常会问到闭包，因为面试官能通过这个问题的回答判断你对语言的熟悉程度，以及考察你是否知道什么时候使用闭包。
闭包就是能访问作用域外部变量的内部函数 。闭包能用来实现私有化和创建工厂函数等作用。关于闭包的常见面试题是这样的：
写一个函数，循环一个整数数组，延迟 3 秒打印这个数组中每个元素的索引。
这个问题常见（不正确）的实现是这样：
const arr = [10, 12, 15, 21];
for (var i = 0; i & arr. i++) {
&setTimeout(function() {
& &console.log('The index of this number is: ' + i);
&}, 3000);
如果你运行这段函数，你会发现 3 秒之后每次都打印的是&4，而不是预期的&0, 1, 2, 3。
为了正确的找到出现这种情况的原因，你需要理解 JavaScript 是如何运行这段代码的，这也是面试官想要考察你的地方。
原因是&setTimeout&函数创建了一个访问外部作用域的函数（闭包），就是包含索引&i&的那个循环。3 秒之后，函数开始执行打印&i&的值，而此时循环也结束了，i&的值已经是 4。因为循环遍历 0, 1, 2, 3, 4 后最终停在了 4。
实际上有好几种方法能正确解决这个问题。这里有两个：
const arr = [10, 12, 15, 21];for (var i = 0; i & arr.length; i++) {
&// 给每个函数传入变量 i 让其能访问正确的索引
&setTimeout(function(i_local) {
& &return function() {
& & &console.log('The index of this number is: ' + i_local);
&}(i), 3000);}
const arr = [10, 12, 15, 21];for (let i = 0; i & arr.length; i++) {
&// 使用 ES6 中的 let 关键字，它会在函数调用时创建一个新的绑定
&// 了解更多：http://exploringjs.com/es6/ch_variables.html#sec_let-const-loop-heads
&setTimeout(function() {
& &console.log('The index of this number is: ' + i);
&}, 3000);}
问题 #3： Debouncing（防抖动）
有些浏览器事件能在很短的时间内被触发多次，例如调整窗口大小或滚动页面。如果你给窗口滚动事件添加一个事件监听器，然后用户不停地快速向下滚动页面，那你的事件可能在 3 秒之内被触发数千次。这会导致非常严重的性能问题。
如果在面试中讨论到构建应用程序，以及滚动事件，窗口调整事件，或者键盘事件等，请务必提及 debouncing 或者 throttling，作为提高页面速度与性能的方法。来一个 css-tricks 的实例：
2011 年，Twitter 出了一个问题：当滚动 Twitter 摘要时，页面变的很卡甚至无响应。John Resig 写了一篇关于这个问题的博客，解释了直接将耗时的函数绑定在&scroll&事件上是一个多么糟糕的想法。
Debouncing 是解决这个问题的一种方法，它的做法是限制下次函数调用之前必须等待的时间间隔。正确实现 debouncing 的方法是将若干个函数调用&合成&一次，并在给定时间过去之后仅被调用一次。下面是一个原生 JavaScript 的实现，用到了作用域, 闭包, this, 和 计时事件：
// 将会包装事件的 debounce 函数function debounce(fn, delay) {
&// 维护一个 timer
&let timer = null;
&// 能访问 timer 的闭包
&return function() {
& &// 通过 ‘this’ 和 ‘arguments’ 获取函数的作用域和变量
& &let context = this;
& &let args = arguments;
& &// 如果事件被调用，清除 timer 然后重新设置 timer
& &clearTimeout(timer);
& &timer = setTimeout(function() {
& & &fn.apply(context, args);
& &}, delay);
这个函数 — 当传入一个事件（fn）时 — 会在经过给定的时间（delay）后执行。
函数这样用：
// 当用户滚动时被调用的函数function foo() {
&console.log('You are scrolling!');}// 在 debounce 中包装我们的函数，过 2 秒触发一次let elem = document.getElementById('container');elem.addEventListener('scroll', debounce(foo, 2000));
Throttling 是与 debouncing 类似的一种技术，但它不是在调用函数之前等待一段时间，throttling 是在较长的时间间隔内调用函数。所以如果一个事件每 100 毫秒被触发 10 次，throttling 会在每隔 2 秒时执行一次这个函数，而不是在 100 毫秒内执行 10 次事件。
更多关于 debouncing 和 throttling 的信息请参考以下文章和教程：
JavaScript 中的 Throttling 和 Debouncing
Throttling 与 Debouncing 的区别
实例解析 Throttling 和 Debouncing
Throttling 函数调用 —— Remy Sharp
阅读(...) 评论()