小编oco*_*mfd的帖子

假设我写的0.5是0.-5在意想不到的方式,但它仍然可以运行.是什么0.在0.-5这样做,它可以仍然可以运行,计算结果为-5？

我也试过alert(0.-5+1)打印-4,JavaScript忽略0.了0.-5吗？

为什么不呢

let=0

显示任何语法错误但

var=0

呢？(我在Safari上测试)

但是我试过了

console.log(let)

但它有错误,似乎'let'不是已定义的变量.为什么会这样？

例如,假设我需要根据布尔值的组合执行不同的操作:cond_0,cond_1和cond_2:

cond_0 cond_1 cond_2
false  false  false  a();
false  false  true   b();
.
.
.
true   true   true   h();

它看起来好像将位数映射到函数:

000:a()
001:b()
.
.
.
111:h()

虽然一般规则看起来很简单,但我不知道如何在没有if-else的情况下编写它,当前的表单看起来像这样:

var f=function(cond_0,cond_1,cond_2){
  if(!cond_0 && !cond_1 && !cond_2){
    a();
  }else if( cond_0 && !cond_1 && !cond_2)){
    b();
  }else if(!cond_0 &&  cond_1 && !cond_2)){
    c();
  }else if( cond_0 &&  cond_1 && !cond_2)){
    d();
  }else if(!cond_0 && !cond_1 &&  cond_2)){
    e();
  }else if( cond_0 && !cond_1 &&  cond_2)){
    f();
  }else if(!cond_0 &&  cond_1 &&  cond_2)){
  g(); …

假设我有这样的功能:

var f1=function(){
   return this;
};
console.log(f1.bind('abc')()==='abc');

我知道,f1.bind('abc')应该创建一个返回'abc'的新函数,所以我猜它应该输出相同的

console.log('abc'==='abc')

这是真的,但现在输出是假的,我的猜测有什么不对？

注意:我不是在问为什么0.1 + 0.2与0.3不同.

根据浮动点数学是否破碎？,0.1 + 0.2不等于0.3,因为在比较之前0.1和0.2已经四舍五入到不同的数字,这与0.3的舍入数不同.

但我的问题是,为什么0.1 + 0.2 + 0.3!= 0.3 + 0.2 + 0.1？

console.log(0.1+0.2+0.3==0.3+0.2+0.1);

我的假设:在计算机内部,浮点数将四舍五入为一个值:

0.1是圆到A.

0.2是圆到B.

0.3是圆到C.

因为舍入值是精确的(可以用二进制表示),所以我认为

A + B + C应该与C + B + A完全相等,就像1 + 2 + 3恰好等于3 + 2 + 1.但现在结果不同了.我的假设有什么问题？

例如,我有数组:

[1,2,3,2,2,2,1,2,3]

,它匹配模式XXXXYY,因为它有(至少)四个'2'和两个'1',但我的问题是,如何检查数组是否匹配这样的模式？我试过了:

const arr=[1,2,3,2,2,2,1,3,2];
const pattern=[4,2];
let m=new Map();
for(const num of arr){
  if(!m[num]){
    m[num]=0;
  }
  m[num]++;
}

let i=0;
let isMatch=true;
for(const key in m){
  if(m[key]<pattern[i]){
    isMatch=false;
  }
  i++;
}
console.log(isMatch);

但isMatch是假的.有没有更简单的方法来做到这一点？

例如,0.000000000000000000000000000000000000000000000000000000000000000000000000000000000011大于0.00000000000000000000000000000000000000000000000000000000000000000000000000000000001小数和转换为浮点数后:

document.writeln(0.00000000000000000000000000000000000000000000000000000000000000000000000000000011>0.0000000000000000000000000000000000000000000000000000000000000000000000000000001);

并且1.9999999999999999999小于2的小数,但在转换为浮点数后它们变得相等:

document.writeln(1.9999999999999999999==2);

我的问题是,是否有任何2个数字,A和B,它是A <B的十进制形式,但在转换为浮点数后变为A> B？

根据为什么浮点数不准确？,浮点数有错误.

我的问题是,对于正整数n,Math.random()*n是否有错误使其结果等于或大于n？

考虑有一个简单的用例，一个带有具有共同属性的子类的父类，例如：类 Animal 有一个名称：

public class abstract Animal{
    protected String name;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }

    abstract void printInfo();
}

和子类：

public class Cat extends Animal{
    @Override
    public void printInfo(){
        System.out.println("I'm a cat");
    }
}

public class Dog extends Animal{
    @Override
    public void printInfo(){
        System.out.println("I'm a dog");
    }
}

根据优先组合而不是继承？和https://softwareengineering.stackexchange.com/questions/162643/why-is-clean-code-suggesting-avoiding-protected-variables，应该避免继承和受保护的变量，所以我将 Animal 修改为一个接口：

public interface Animal{
    void setName(String name);
    String getName();
    void printInfo();
}

但是在移动类属性时噩梦就来了：

public class Cat implements Animal{
    private …

例如,假设我有一个数组:[3,2,2,1,4,5,3,2,2,1,1],我想将其排序为这种形式:

[2,2,2,2,1,1,1,3,3,4,5]

哪个2是最常见的元素,然后是1,依此类推,我该如何编写一个sort函数:

let arr=[3,2,2,1,4,5,3,2,2,1,1];
arr.sort(function(p0,p1){
  //how to write it?
});

要做到这一点？

我试过了:

 let arr=[3,2,2,1,4,5,3,2,2,1,1];
 let numPosMap=new Map();
 for(let i=0;i<arr.length;i++){
     let num=arr[i];
     if(!numPosMap[num]){
         numPosMap[num]=[];
     }
     numPosMap[num].push(i);
 }
 let posArrayArray=[];
 for(let num in numPosMap) {
     posArrayArray.push(numPosMap[num]);
 }
 posArrayArray.sort(function(a,b){
   return a.length<b.length;
 });

 let resultArr=[];
 for(let posArray of posArrayArray){
   for(let pos of posArray){
     resultArr.push(pos);
   }
 }

有多行代码,有没有更简单的方法？

例如,假设我有数组:[13,7,15,1,10,7,3,18,4,20],我有2个要求:

1. 只选择> 10的元素
2. 随机化结果数组

正常的做法:

let arr=[13,7,15,1,10,7,3,18,4,20];
let result=[];
for(let i=0;i<arr.length;i++){
    if(arr[i]>10){
      result.push(arr[i]);
    }
}

for(let i=0;i<result.length;i++){
  const r=Math.floor(Math.random()*result.length);
  const temp=result[i];
  result[i]=result[r];
  result[r]=temp;
}
for(let i=0;i<result.length;i++){
    console.log(result[i]);
}

但是我相信我可以用更简单的方式做到这一点:我可以把它放到一个随机位置来过滤而不是在获得所有结果后随机化整个数组,我试过:

let arr=[13,7,15,1,10,7,3,18,4,20];
let result=[];
for(let i=0;i<arr.length;i++){
    if(arr[i]>10){
      result.splice(Math.floor(Math.random()*result.length),0,arr[i]);
    }
}

for(let i=0;i<result.length;i++){
    console.log(result[i]);
}

但我发现它不起作用:最后一个元素总是13:

18
20
15
13

20
15
18
13

这个想法有什么不对？