主页 / user-478905

drako black's questions

Martin Hope
drako black
Asked: 2024-10-04 16:01:20 +0000 UTC
  • 5

所以，我有一个对象：

<div id="block"></div>

我需要为其分配一些属性。通常我用这个style，但是出现了一个问题：如果我style多次访问同一个元素，以前的设置将被覆盖：

document.getElementById('block').style.opacity='1';
document.getElementById('block').style.border='1';
document.getElementById('block').style.color='black';

那么，问题是如何突破这个限制呢？

js 中是否可以直接使用 CSS 数据，或者如何添加属性，style以便这些更新不会覆盖其中包含的其他属性？

javascript
Martin Hope
drako black
Asked: 2024-09-23 20:16:59 +0000 UTC
  • 5

先生们。

我需要你帮忙解决一个谷歌无法给我答案的小问题...我不排除我没有正确问他，但我不知道如何正确问...

一般来说，我有一个正则表达式可以清除一行 HTML 标签：

let str = '<b>this is game</b>'
let newStr = str.replace(/<\/?[a-zA-Z]+>/gi,'')
console.log(newStr)

这非常有效，直到表达式包含没有标签的行：

let str = 'this is game'
let newStr = str.replace(/<\/?[a-zA-Z]+>/gi,'')
console.log(newStr)

所以我的问题是：有没有办法修改正则表达式，以便在字符串中没有标签时不会抛出错误？

粗略地说，如果表达式包含带有标签的行，则需要删除它们，如果没有标签，则不执行任何操作并保留该行原样...

javascript
Martin Hope
drako black
Asked: 2024-07-31 12:48:14 +0000 UTC
  • 5

朋友们！

我们需要您的帮助来解决一个问题：

所以，我有一个复选框：

<label class="checkbox">
  <input type="checkbox" id="btn_cheats" class="chek">
  <span class="chek-label"></span>
  <span class="on-left">ON</span>
  <span class="off-right">OFF</span>
<label>

使用 CSS 中所有指定的样式和引用，一切都运行良好，直到我尝试在旧版本的浏览器上运行它，结果发现这个表达式

.checkbox:has(.chek:checked) {
  background-color: lime;
}

在那里不起作用，因为:has它仍然太新且处于实验阶段：

所以，问题是，我们可以用什么替换这个表达式，以便复选框在旧版浏览器中正确更改颜色？？？我尝试过媒体，但显然这件事不适用于课程，或者我做错了什么：

@media (.chek:checked) {
   .checkbox {
    background-color: lime;
  }
}
css
Martin Hope
drako black
Asked: 2024-07-30 12:14:12 +0000 UTC
  • 5

朋友们，帮我完成转换吧...

问题是什么：

总的来说，我决定用 CSS 制作一个带有滑块的标准 chekbox 开关（幸运的是，互联网上有足够多的此类东西），然后我决定向其添加文本“ON”/“OFF” ，然后问题就开始了，如何在纯CSS上不使用JS，让切换滑块时的铭文消失和出现呢？再次，我在互联网上发现@media通常在这种情况下使用的信息，但我没有找到任何关于如何准确执行此操作的信息......

我还尝试了使用“+”的标准选项：

.chek:checked + #off_right {
  visibility: hidden;
}

但似乎我要么没有完成某件事，要么做错了某件事，因为它不起作用。

.chek {
  visibility: hidden;
}
.chekbox {
  position: relative;
  width: 70px;
  height: 30px;
  background-color: red;
  border-radius: 50px;
}
.chekbox:after {
  content: '';
  position: absolute;
  top: 5px;
  right: 3px;
  width: 40px;
  height: 24px;
}

.chek-label {
  position: absolute;
  width: 25px;
  height: 25px;
  border-radius: 50px;
  background-color: black;
  top: 3px;
  left: 3px;
  transition: all 0.4s ease;
  cursor: pointer;
  z-index: 1;
}
.chek:checked + .chek-label {
  left: 40px;
}
#on_left {
  position: absolute;
  visibility: hidden;
  top: 5px;
  left: 5px;
  text-align: center;
  vertical-align: middle;
  font-weight: bold;
}
#off_right {
  position: absolute;
  visibility: visible;
  top: 5px;
  right: 5px;
  text-align: center;
  vertical-align: middle;
  font-weight: bold;
}
@media (checked) {
  #on_left {
    visibility: visible;
  }
  #off_right {
    visibility: hidden;
  }
}
<div class="chekbox">
  <input type="checkbox" id="btn_audio" class="chek">
  <label for="btn_audio" class="chek-label"></label>
  <span id="on_left">ON</span>
  <span id="off_right">OFF</span>
</div>

我将不胜感激的帮助和解释。另外，如果有人可以分享有关这一切如何运作的合理信息来源，我也将不胜感激。

PS 我所说的“明智”是指来源不是来自“2+2=4，现在求解积分”类别，而是来自“它像这样工作，但要得到这个，你需要使用这个”类别。 （一般来说，一切都用人类语言详细解释）。

html
Martin Hope
drako black
Asked: 2024-05-28 15:36:17 +0000 UTC
  • 5

朋友们，我遇到了一个问题：我有一个字符串数组，并且有一个循环，根据想法，应该从该数组中删除所有包含“**”（两个星号）的行：

let arr = [
  '** Characters name **',
  'h0: Maks',
  'd0: Narrator',
  'n0: Merlin',
  'n1: Kitty',
  'n12: Berta',
  '** Например, вот здесь можно встатить свой комментарий или какое-то замечание. **',
  '** И это никак не скажется на работе эмулятора. **',
]

for (var i = 0; i < arr.length; i++) {
  if (arr[i].includes('**')) {
    arr.splice(i, 1)
  }
}

console.log(arr)

但问题是，由于我不知道的原因，数组的最后一个元素虽然在行中有“**”，但永远不会被删除......告诉我为什么会发生这种情况以及如何在不破坏逻辑的情况下修复它循环中还包含其他数组吗？当然，您可以添加+1到arr.length，但是存在会破坏其他内容的风险。

javascript
Martin Hope
drako black
Asked: 2024-05-03 12:33:27 +0000 UTC
  • 3

朋友们，非常感谢您帮助解决以下问题：本地PC上的某个目录下有一组文件（图片），并且有一个HTML文件需要将这些图片加载到其中。所有图片都按照一定的模式命名，例如 scene-1、scene-2 等。我制作了一个简单的脚本，只需单击按钮即可加载所需的图片，实际上仅增加文件名中的数字，但问题变成了如果图片用完如何停止程序。它们的数量可以是任意的，从没有到几千个，因此不可能将它们以某种数组的形式预先全部写入代码中。我找到了这样的解决方案：

  image.onerror = function(){
    num = 0;
    image.src = `./image/locations/scene-${num}.jpg`};

但是控制台中出现错误的选项在某种程度上非常烦人。所以我想知道，是否有可能以条件或回调函数的形式重新制作它？或者，也许您可​​以在执行脚本的其余部分之前对文件是否存在进行一些初步检查？

let num = 0;

function next_step() {
  num++;
  let div_img = document.getElementById('image_block');
  let image = document.createElement('img');

  image.src = `./image/locations/scene-${num}.jpg`;
  image.className = 'image';
  image.onerror = function(){
    num = 0;
    image.src = `./image/locations/scene-${num}.jpg`};
  div_img.innerHTML = '';
  div_img.appendChild(image);
}
}

其实上面就是目前所有的代码了。

javascript
Martin Hope
drako black
Asked: 2024-03-01 14:07:21 +0000 UTC
  • 5

所以，朋友们，我面临这样的问题：我有几张不同尺寸的图片，我需要先将它们在HTML页面上调整为相同的尺寸，然后使它们可伸缩，这样当屏幕尺寸变化时，它们保留它们的形状......在这里我很困惑，我可以想象如何以百分比或em进行缩放，而且我也知道如何将图像变为单一尺寸，清楚地指示它们的尺寸，例如，像素，但我无法想象如何将这两个任务合并为一个，因为本质上它们是相互矛盾的......救命！

<table class="tab_image">
    <tr>
      <td rowspan="4" width="80%"><img src="./image/Map.jpg" height="100%" width="100%"></td>
      <td id="td_btn_castle"></td>
    </tr>
    <tr>
      <td><img src="./image/building/lands/Farm.jpg" class="image_building_btn btn4" onclick="transition(this, 'village')" title="Lands"></td>
    </tr>
    <tr>
      <td><img src="./image/No_image.jpg" class="image_building_btn btn4" onclick="" title="No events" disabled></td>
    </tr>
    <tr>
      <td><img id="btn_travel_map" src="./image/Traveling.jpg" class="image_building_btn btn4" onclick="traveling(this)" title="Traveling"></td>
    </tr>
  </table>

.tab_image {
  border-spacing: 2mm;
  height: 90%;
  width: 90%;
}
.image_building_btn {
  height: 10rem;
  width: 20rem;
  margin-left: 5mm;
  border: 3px solid green;
  border-radius: 0.5rem;
}
.btn4 {
  cursor: pointer;
}
.btn4[disabled] {
  border: 3px solid red;
  opacity: 0.45;
}
@media (hover: hover) {
  .btn4:hover {
    transform: translateY(-2px);
    border: 3px solid green;
  }
  .btn4[disabled]:hover {
   border: 3px solid grey !important;
}
}
html
Martin Hope
drako black
Asked: 2024-02-17 20:41:27 +0000 UTC
  • 5

这次我的问题是出于教育目的......所以，我有一个功能：

function caption_building(caption, i, flag) {
  switch (caption) {
    case 'DONJON ROOMS':
      text = ROOMS_UPGRADE_INFO[i]
      data = Object.assign(BUILDINGS.rooms[i])
      pageInfoID = 1;
    break;
    case 'CASTLE BUILDING':
      text = BUILDINGS_UPGRADE_INFO[i]
      data = Object.assign(BUILDINGS.castle[i])
      pageInfoID = 2;
    break;
    case 'LANDS BUILDING':
      text = LANDS_UPGRADE_INFO[i]
      data = Object.assign(BUILDINGS.lands[i])
      pageInfoID = 3;
      break;
  }
  if (flag == 'bonus') {
    return text;
  } else {
    return data;
  }
}

有两个函数使用其执行结果：

let pageInfoID;
function page_bonus_info(el, i) {
  let caption = el.closest('#tableBuildimg').caption.textContent
  let text = caption_building(caption, i, 'bonus')
  document.getElementById('buildaing_page').style.display = 'none';
  document.getElementById('building_bonus_page').style.display = 'block';

  printText('bonus_text', text)
}
//------------------------------------------------------------------------------
function upgrade_build(el, i) {
  let div_id = el.closest('div').id
  let caption = el.closest('#tableBuildimg').caption.textContent
  let data = caption_building(caption, i, 'upgrade')

  document.getElementById(div_id).style.display = 'none';
  document.getElementById('building_upgrade_page').style.display = 'block';
  print_necessary_to_upgrade(data)
}

这可能听起来很奇怪，但是当我没有声明 或text时，为什么第一个函数可以工作data，它们也不是位于这些函数之外的全局变量？从理论上讲，应该会发生错误，但一切都很完美......向我解释一下为什么？

javascript
Martin Hope
drako black
Asked: 2024-01-10 18:44:57 +0000 UTC
  • 3

再说一遍，美好的一天，我还有另一个问题。所以，我有一个对象：

const NO = 0,
      YES = 1;

let rooms = {
    bedroom: NO,
    troneroom: NO,
    armory: NO,
    treasury: NO,
    dungeon: NO,
    library: NO,
    labratory: NO,
  },

有一个确定的变量：

let room_yes = YES

现在的问题是：如何将对象的所有属性与给定变量进行比较，如果其中一个属性的值对应于变量的值，则返回例如该属性的键？也许对象存在某种循环或类似的东西？

我尝试在Google上搜索信息，但大部分都是关于对象与对象的比较，并且没有任何关于如何将其内容与任何特定值进行比较的字...（我不排除我不能由于我问错了问题，所以找到了正确的答案，但如何正确地向 Google 询问这个问题，我不知道......）

javascript
Martin Hope
drako black
Asked: 2024-01-09 17:08:50 +0000 UTC
  • 6

我试图在谷歌上寻找答案，但结果总是不是我需要的……可能是我没有正确地表达问题，所以我向专家寻求帮助。

所以问题是这样的：

function status() {
      let a = [ 'Status',]
      let span = document.createElement('span')
      span.className = "text6"
      span.style = "color: red"
      span.innerText = 'Ruined'
      let span2 = String(span)
      console.log('span', span)
      console.log('span2', span2)
      for (var i = 0; i < 7; i++) {
        a.push('<span class="text6" style="color: red">Ruined</span>')
      }
      return a;
    },

我有一个小函数，它创建带有标签和其他必要属性的填充 HTML 元素，然后从它们形成一个数组，稍后将在此基础上构建一个表...但问题是：如果我将此标签格式化为一个字符串并将这一行推入数组中，然后一切正常，但如果我尝试这样做，createElement以下条目将添加到数组中[object HTMLSpanElement]......

据我了解，问题是我创建了一个要添加到 DOM 树的元素，而不是字符串...我尝试将结果值转换为字符串，但这也没有帮助（变量span2）.. 。

那么问题来了，怎样才能让执行结果 a.push(span)和中一样呢a.push('<span class="text6" style="color: red">Ruined</span>')？我希望我已经表达清楚了我的观点。

javascript
Martin Hope
drako black
Asked: 2024-01-03 13:52:23 +0000 UTC
  • 5

所以我有一个字符串数组：

const VEGETABLE_MESSAGE = [
  `Clean vegetable garden: ${VEGETABLE_GARDEN.building}%`,
  `Seeds planted: ${VEGETABLE_GARDEN.seedPlant} seeds`,
  `Collect the harvest: ${VEGETABLE_GARDEN.harvesting} %`,
  '<span style="color:red">You forgot to water the seeds, the entire harvest was lost!</span>',
  '<span style="color:red">Water seeds: no</span>',
  '<span style="color:green">Water seeds: yes</span>',
];

有所需行的输出：

let VEGETABLE_GARDEN = {
building: 0,}
const VG = VEGETABLE_GARDEN

function mes() {
if (VG.building < 100) {
    mesID = 0
  } else if (VG.seedPlant < 100) {
    mesID = 1
  } else if (VG.harvestDay == 0) {
    mesID = 2
  } else if (VG.seedDie == 1) {
    mesID = 3
  } else {
    mesID = waterMesVG();
  }

document.getElementById('massageVG').innerHTML = VEGETABLE_MESSAGE[mesID];
}
mes() // итог будет: `Clean vegetable garden: 0 %`
// далее я выполняю некоторые действия и значение VEGETABLE_GARDEN.building меняется, например:
VEGETABLE_GARDEN.building = 15
// но при повтором вызове mes()
mes() // итог будет все равно `Clean vegetable garden: 0 %` вместо `Clean vegetable garden: 15 %`. Это и есть моя проблема. 
// если же поместить VEGETABLE_MESSAGE в mes() то все будет прекрасно работать, однако это неудобно в силу ниже описанных проблем. Поэтому мне нужно, чтобы VEGETABLE_MESSAGE оставался за пределами исполняемой функции.

这就是问题所在：如果我VEGETABLE_MESSAGE在字符串发布函数内声明一个数组，那么该变量${VEGETABLE_GARDEN.building}和其他类似变量将根据需要更新和发布，不会出现任何问题，但一旦我将该数组移到函数外，更新就会停止。

据我了解，问题在于这些函数仅在首次启动时才读取变量的值，仅此而已。所以问题是，如何在被调用函数之外更新这些行中的变量，例如当变量本身的值发生变化时？我只是有很多这样的文本，我想将它们收集在一个地方，这样就不必遍历所有代码，例如，需要将其翻译成另一种语言。我将感谢您对如何处理这个问题的帮助和澄清。

javascript
Martin Hope
drako black
Asked: 2024-01-02 16:45:12 +0000 UTC
  • 5

所以，问题的本质是：是否有可能以某种方式从几组变量生成一个复合条件。如果可以的话，该怎么做？

为什么这是必要的？

所以，我有一个对象数组：

let people = [
{gender: 0, adult: 1, work: 0, workPlace: 0},
{gender: 1, adult: 0, work: 0, workPlace: 0},
{gender: 1, adult: 1, work: 1, workPlace: 2},
{gender: 0, adult: 0, work: 1, workPlace: 1},
...
]

我有一些元素select可以选择数组内对象属性的特定值：

  <select name="Gender" class="sum2 sum3">
          <option value="X">All</option>
          <option value="0">Male</option>
          <option value="1">Female</option>
        </select>
        <select name="Adult" class="sum2 sum3">
          <option value="X">All</option>
          <option value="1">Adult</option>
          <option value="0">Children</option>
        </select>
        <select name="Work" class="sum2 sum3">
          <option value="X">All</option>
          <option value="1">Yes</option>
          <option value="0">No</option>
        </select>

而如果元素中的值select没有被选中ALL，那么就没有问题，我们只需将值放入value条件中，并根据所需的属性检查数组是否匹配即可。

但这里ALL出现了一个问题。由于该值必须按值包含所有可用选项。理论上，您只需从测试条件中删除具有 value 的属性ALL，但我不知道如何执行此操作。

也就是说，我们如何从这个条件中删除所有等于 的内容ALL，然后检查剩下的内容？只是ALL选项可能有很多，并且手动检查所有选项在某种程度上不太方便。

if (gen != ALL && ad == ALL && work == ALL) {
      let i = 0
      let key = 0
      while (i != quality - 1) {
        if (people[key].gender == gen) {
          people[key].workPlace = VEGETABLE
          i++
        }
        key++
      }

我只是觉得这个问题一定有一些简单的解决方案，但我就是找不到。事实上，样式中一定有一些条件；如果这是值ALL，那么我们在检查数组时就不会考虑它。但如何以编程方式表达这一点？帮助！

javascript
Martin Hope
drako black
Asked: 2023-12-11 20:46:03 +0000 UTC
  • 5

朋友们，我们需要专家的帮助！

因此，我有几个使用以下命令制作的下拉列表select：

<table>
<tr>
<td class="cell4 cell1">
  <select name="Gender" class="sum2 sum3">
    <option value="X">All</option>
    <option value="0">Male</option>
    <option value="1">Female</option>
  </select>
</td>
<td class="cell4 cell1">
  <select name="Social status" class="sum2 sum3">
     <option value="X">All</option>
     <option value="1">Free</option>
     <option value="0">Slave</option>
  </select>
</td>
<td class="cell4 cell1">
  <select name="Adult" class="sum2 sum3">
     <option value="X">All</option>
     <option value="1">Adult</option>
     <option value="0">Children</option>
  </select>
</td>
<td class="cell4 cell1">
  <span id="qualityTotal"></span>
</td>
</tr>
</table>

我有一个包含数据的对象：

const ADULT_YES = 1,
      ADULT_NO = 0;

const WORK_YES = 1,
      WORK_NO = 0;

const MEN = 0,
      FEMALE = 1;
      //ALL = X;

const SLAVE = 0,
      FREE = 1,
      ALL_SOC = 2;

let summary = {
  'TOTAL': 1,

  [`${MEN}`]:0,//0
  [`${MEN}${SLAVE}`]:0,//00
  [`${MEN}${SLAVE}${ADULT_YES}`]:0,//001
  [`${MEN}${SLAVE}${ADULT_NO}`]:0,//000
  [`${MEN}${SLAVE}${ADULT_YES}${WORK_YES}`]:0,//0011
  [`${MEN}${SLAVE}${ADULT_YES}${WORK_NO}`]:0,//0010
  [`${MEN}${SLAVE}${ADULT_NO}${WORK_YES}`]:0,//0001
  [`${MEN}${SLAVE}${ADULT_NO}${WORK_NO}`]:0,//0000
  [`${MEN}${FREE}`]:0,//01
  [`${MEN}${FREE}${ADULT_YES}`]:0,//011
  [`${MEN}${FREE}${ADULT_NO}`]:0,//010
  [`${MEN}${FREE}${ADULT_YES}${WORK_YES}`]:0,//0111
  [`${MEN}${FREE}${ADULT_YES}${WORK_NO}`]:0,//0110
  [`${MEN}${FREE}${ADULT_NO}${WORK_YES}`]:0,//0101
  [`${MEN}${FREE}${ADULT_NO}${WORK_NO}`]:0,//0100

  [`${ALL}${ALL}${ALL}${ALL}`]: 0,

};

任务是：如何做到<span id="qualityTotal"></span>当选择改变时自动显示对象的特定参数的内容select，这样你就会得到这样的结果： 在此输入图像描述

如果有红色10，则应根据select元素的选择从摘要中显示数量，无需任何额外的移动。

理论上，输出<span id="qualityTotal"></span>应该如下所示：

let gen = document.querySelector('[name="Gender"]').value
let soc = document.querySelector('[name="Social status"]').value
let adult = document.querySelector('[name="Adult"]').value

document.querySelector('qualityTotal').innerHTML = summary[`${gen}${soc}${adult}${WORK_NO}`]

这里的值value与 中的常量一致summary，因此我可以选择特定的数据类型，但我不知道如何自动执行此操作。

另外，还有一个与参数有关的问题ALL，即我无法想象如何只为一个参数而不是所有三个参数生成输出。例如，我需要只选择男性，而不考虑他们的社会地位或年龄......在这个例子中如何实现？这是我的意思的一个例子：

在此输入图像描述

理论上，这里我们指的是，就是我在设计的['${MEN}${WORK_NO}']:0,时候需要考虑到所有可能的选择。如何才能做到这一点？${soc}${adult}summary['${MEN}${soc}${adult}${WORK_NO}']:0,

javascript
Martin Hope
drako black
Asked: 2023-12-06 01:22:42 +0000 UTC
  • 5

小伙伴们，问题是：如何在js对象中设置严格的属性顺序？问题如下：例如，我们有一个具有不同属性的对象：

let objekt = {
get arr1() {
    let a = []
    delete this.arr1
    return this.arr1 = a
},
arr2: ['bbbb'],
get arr3() {
    let a = []
    return a
},
get rows() {
    let a = this.arr1.length;
    delete this.rows
    return this.rows = a;
},
get colums() {
    let a = 0
    let property = Object.getOwnPropertyNames(this)
    for (var i = 0; i < property.length; i++) {
        if (property[i] === 'colums') continue
           if (Array.isArray(this[property[i]])) {
              a++
           }
        }
     delete this.colums
     return  this.colums = a;
},
obj2: {},
}

console.log(objekt)

但是当我查看发布这个对象的最终结果时，我发现属性的顺序发生了变化：

在此输入图像描述

具体来说，在这个例子中，这并不是特别重要，但我积极使用类似的对象结构来填充表格，并且数组的顺序至关重要；如果任何数组更改其在对象中的位置，则可能会破坏整个数组桌子。现在我想知道是否可以以某种方式解决这个问题？

javascript
Martin Hope
drako black
Asked: 2023-12-03 17:18:57 +0000 UTC
  • 5

朋友们，我再次需要有识之士的帮助。我有一个用于构建表格的简单函数和一个用于填充这张表格的函数：

function createTableEmpty(id, colRows, colColums) {
  let table = document.getElementById(id);
  let caption = document.createElement('caption')
  caption.id = "caption"
  caption.className = "text2"

  for (let i = 0; i < colRows; i++) {
    let tr = document.createElement('tr');

      for (let j = 0; j < colColums; j++) {
        let td = document.createElement('td');
        td.id = `tc${i}${j}`
        if (i == 0) {
          td.className = "cell4 cell"
        } else {
          td.className = "cell4"
        }
        tr.appendChild(td);
      }

    table.appendChild(caption);
    table.appendChild(tr);
  }
}


function printDataResTest(data) {
  let j = 0;
  let property = Object.getOwnPropertyNames(data)
  for (var i = 0; i < property.length; i++) {
    if (Array.isArray(data[property[i]])) {
      for (var k = 0; k < data.rows.length; k++) {
        document.getElementById(`tc${k}${j}`).innerHTML = data[property[i]][k]
      }
      j++
    }
  }
};

建表函数考虑了 HTML 中的“构建位置”，以及未来表格的列数和行数，这些数是根据基变量 中的数组数量计算的resName，基变量是一个对象，(number列数）和这些数组的长度（行数）。

构建表后，它开始填充变量 中的数组内容resName。

变量本身如下所示：

const HSS = HERO.sexStats;

  let resName = {
      name: ['Act', 'Virginity', 'Pregnant', 'Birth', 'Fertilization', 'Vaginal sex', 'Anal sex', 'Oral sex', 'Piss drinking', 'Rimjob', 'Footjob', 'Breastjob'],

      get data1() {
          let a = [];

            a[0] = 'Data'
          if (HSS.virginity == 0) {
            a[1] = 'Yes'
          } else {
            a[1] = 'No'
          }
          if (HERO.genderStats.pregnancy == 1) {
            a[2] = 'Yes'
          } else {
            a[2] = 'No'
          }
          if (HERO.genderStats.birth != 0) {
            a[3] = HERO.genderStats.birth
          } else {
            a[3] = 'No'
          }
          if (HERO.genderStats.inseminate == 'Yes') {
            a[4] = 'Yes'
          } else {
            a[4] = 'No'
          }
          for (var i = 0; i < this.support.dom.length; i++) {
            a[i+5] = this.support.dom[i] + this.support.sub[i];
          }
      return a;
    },

      get data2() {
      let j = 0
      let a = []
      let b = ['Virginity', 'Pregnant', 'Birth', 'Fertilization']
      for (var i = 0; i < this.name.length; i++) {
        if (this.name[i] == 'Act') {
          a[i] = 'Details'
        } else {
            if (b.includes(this.name[i])) {
              a[i] = '';
            } else {
              a[i] = `Dom: ${this.support.dom[j]} </br> Sub: ${this.support.sub[j]}`
              j++
            }
          }
      }
      if (this.data1[4] == 'Yes') {
        a[4] = HSS.sexFertilization
      } else {
        a[4] = '';
      }
      return  a;
      },

      get rows() {
        let a = this.name.length;
        return a;
      },
      get colums() {
        let a = 0
        let property = Object.getOwnPropertyNames(this)
        console.log('property: ', property)
        for (var i = 0; i < property.length; i++) {
          if (Array.isArray(this[property[i]])) {
            a++
          }
        }
        return a;
      },
      get keys() {
           return objectKey(this)
         },
      support: {
        
        dom: [HSS.sexVaginalDom, HSS.sexAnalDom, HSS.sexOralDom, HSS.pissDrinkingDom, HSS.sexRimjobDom, HSS.sexFootjobDom, HSS.sexBreastjobDom,],
        sub: [HSS.sexVaginalSub, HSS.sexAnalSub, HSS.sexOralSub, HSS.pissDrinkingSub, HSS.sexRimjobSub, HSS.sexFootjobSub, HSS.sexBreastjobSub,],
        id: [
        ['tc00', 'tc01', 'tc02'],
        ['tc10', 'tc11', 'tc12'],
        ['tc20', 'tc21', 'tc22'],
        ['tc30', 'tc31', 'tc32'],
        ['tc40', 'tc41', 'tc42'],
        ['tc50', 'tc51', 'tc52'],
        ['tc60', 'tc61', 'tc62'],
        ['tc70', 'tc71', 'tc72'],
        ['tc80', 'tc81', 'tc82'],
        ['tc90', 'tc91', 'tc92'],
        ['tc100', 'tc101', 'tc102'],
        ['tc110', 'tc111', 'tc112'],
      ],
      },

    };

function objectKey(obj) {
  let keys = Object.keys(obj)
  return keys;
}

createTableEmpty('tableHeroStats', resName.rows, resName.colums);
printDataResTest(resName);

从代码中可以看到，里面有很多getter，在代码执行时立即进行计算。但这就是问题出现的地方：每次建表函数和/或其填充函数执行循环时，所有 getter 都会再次开始重新计算。

结果，代码冻结了（或者更确切地说，执行时间非常长。时间长到编译器只是中断此过程，认为该过程是无限的）。

所以，我的问题是：是否有可能以某种方式转换 getter，以便它们不在构建表和/或填充它的函数循环的每个新步骤中执行重新计算，而是在第一次运行时仅执行一次，然后简单地存储结果值？

=================================================== =============================

let resName = {
      name: ['Act', 'Virginity', 'Pregnant', 'Birth', 'Fertilization', 'Vaginal sex', 'Anal sex', 'Oral sex', 'Piss drinking', 'Rimjob', 'Footjob', 'Breastjob'],
      data1: [],
      data2: [],
      get creatData1() {
          let a = [];
          if (this.data1.length != 0) {
            return this.data1
          } else {
            a[0] = 'Data'
          if (HSS.virginity == 0) {
            a[1] = 'Yes'
          } else {
            a[1] = 'No'
          }
          if (HERO.genderStats.pregnancy == 1) {
            a[2] = 'Yes'
          } else {
            a[2] = 'No'
          }
          if (HERO.genderStats.birth != 0) {
            a[3] = HERO.genderStats.birth
          } else {
            a[3] = 'No'
          }
          if (HERO.genderStats.inseminate == 'Yes') {
            a[4] = 'Yes'
          } else {
            a[4] = 'No'
          }
          for (var i = 0; i < this.support.dom.length; i++) {
            a[i+5] = this.support.dom[i] + this.support.sub[i];
          }
      //return a;
      this.data1 = a
          }

    },

      get creatData2() {
      let j = 0
      let a = [];
      let b = ['Virginity', 'Pregnant', 'Birth', 'Fertilization']
      if (this.data2.length != 0) {
        return this.data2
      } else {
        for (var i = 0; i < this.name.length; i++) {
          if (this.name[i] == 'Act') {
            a[i] = 'Details'
          } else {
              if (b.includes(this.name[i])) {
                a[i] = '';
              } else {
                a[i] = `Dom: ${this.support.dom[j]} </br> Sub: ${this.support.sub[j]}`
                j++
              }
            }
        }
        if (this.data1[4] == 'Yes') {
          a[4] = HSS.sexFertilization
        } else {
          a[4] = '';
        }
        //return  a;
        this.data2 = a
      }

      },

      get rows() {
        let a = this.name.length;
        return a;
      },
      
      colums: 0,
      get sumColums() {
        let a = 0
        if (this.colums != 0) {
          return this.colums
        } else {
          let property = Object.keys(this)
          console.log('property: ', property)
          for (var i = 0; i < property.length; i++) {
            if (Array.isArray(this[property[i]])) {
              a++
            }
          }
          this.colums = a;
        }

      },

      support: {
        dom: [HSS.sexVaginalDom, HSS.sexAnalDom, HSS.sexOralDom, HSS.pissDrinkingDom, HSS.sexRimjobDom, HSS.sexFootjobDom, HSS.sexBreastjobDom,],
        sub: [HSS.sexVaginalSub, HSS.sexAnalSub, HSS.sexOralSub, HSS.pissDrinkingSub, HSS.sexRimjobSub, HSS.sexFootjobSub, HSS.sexBreastjobSub,],
        id: [
        ['tc00', 'tc01', 'tc02'],
        ['tc10', 'tc11', 'tc12'],
        ['tc20', 'tc21', 'tc22'],
        ['tc30', 'tc31', 'tc32'],
        ['tc40', 'tc41', 'tc42'],
        ['tc50', 'tc51', 'tc52'],
        ['tc60', 'tc61', 'tc62'],
        ['tc70', 'tc71', 'tc72'],
        ['tc80', 'tc81', 'tc82'],
        ['tc90', 'tc91', 'tc92'],
        ['tc100', 'tc101', 'tc102'],
        ['tc110', 'tc111', 'tc112'],
      ],
      },

    };
javascript
Martin Hope
drako black
Asked: 2023-11-24 14:57:31 +0000 UTC
  • 5

专家问题：如何检查数组中的数据类型，以便此检查不检查数组变量本身的数据类型？也就是说，我有一个数组：

let BB = 'ccc';
let arr = ['aaa','ggg', BB,'']

我有一个函数可以迭代数组并执行一些操作，具体取决于数组元素的数据类型。在这种特殊情况下，绑定将转到以下行：

function change() {
        let a = [];
        for (var i = 0; i < arr.length; i++) {
          if (arr[i] == '' || typeof arr[i] != 'string') {
            a[i] = arr[i]
          } else {
            a[i] = getSummary(arr[i]) // здесь производятся некоторые вычисления в зависимости от того, какая строка содержалась в массиве.
          }
        }
        return a;
      }

console.log(a); 
// итоговый массив получается вот такой: true, true, undefined, ''
// а нужно чтобы получилось: true, true, 'ccc', ''

一切都会好起来的，但我需要当算法偶然发现 时ВВ，它会写入最终的数组'ccc'而不是自身，但是，在检查数组的数据类型时，它还会检查ВВ并发现它还包含string，试图应用到它getSummary(arr[i])，但是由于这一行没有规定的动作，所以结果很自然是错误的。

因此，我将重复我的问题，如何在不检查数组所包含变量的数据类型的情况下检查数组的数据类型？也就是说，如果它是一个字符串，那么我们执行指定的操作，如果它是其他东西（例如，字符串类型的变量），那么我们忽略它。这些方法isNaN()没有typeof帮助，因为它们仍然查看变量的数据类型。

javascript
Martin Hope
drako black
Asked: 2023-11-20 18:24:42 +0000 UTC
  • 5

所以，朋友们，问题来了：我有一个带有随机生成参数的对象，并且有一个函数可以根据对象的因变量所取的值，为对象的变量之一分配一个特定值。例如，有一个对象变量“age”，范围可以是5到60岁。还有一个变量“adult”，如果年龄等于或大于 18，则应评估为 true，如果年龄小于 18，则应评估为 false。对于此任务，我编写了一个小函数：

const ADULT_YES = 1,
      ADULT_NO = 2;

function getAdult(people) {
  if (people.age < 18) {
    people.adult = ADULT_NO;
  } else {
    people.adult = ADULT_YES;
  }
}  

function getRandom(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min; //Максимум и минимум включаются
};

{
      gender: newGender,
      fraction: getRandom(0, 6),
      race: getRandom(0, 4),
      age: getRandom(age1, age2),
      adult: getAdult(this),
      socialStats: socStat,
      work: getWorker(this),
      workPlace: 0,
    }

但是，运行此代码时，变量“adult”始终返回值“undefined”。我怀疑问题出在 this 的使用上，也许它读取了函数所在的错误对象，或者可能是其他问题。帮我找出问题所在以及如何解决？

javascript
Martin Hope
drako black
Asked: 2023-11-13 16:58:32 +0000 UTC
  • 5

朋友们，我需要帮助来弄清楚如何使用多个对象，否则我会完全困惑，不明白做什么以及如何做。所以，我有一个对象：

let HERO = {
   name: '',
   age: 0,
   gender: 0,
}

还有另一个对象：

let PARTY = {
   qualyty: [],
   men: 0,
   woman: 0,
}

PARTY.qualyty[0] = HERO;

问题是，如何才能在将PARTY.qualyty对象添加到数组时，根据对象的属性自动计算HERO参数？我创建了一个执行计算的函数，但我不知道将它放在哪里，以便它在向数组添加新元素时自动工作并重新计算：PARTY.manPARTY.womangenderHERO

function Counter() {
      var result = 0;
      for (var i = 0; i < PARTY.qualyty.length; i++) {
        if (PARTY.qualyty[i].gender == 1) {
          result = result + 1;
        }
        return result;
      }

如何实施？这样您就不必在每次添加新对象时都调用该 HERO函数PARTY.qualyty？

=====

考虑到您的提示和澄清，我提出了以下目标：

let PEOPLE = {
    gender: 0,
    fraction: 0,
    race: 0,
    age: 0,
    socialStats: 0,
    work: 0,
};

let CASTLE = {
  social: {
    peopleTotal: [],
    freeMen: 0,
    freeFemale: 0,
    slaveMen: 0,
    slaveFemale: 0,
    children: 0,
    happy: 100,
    addPeople(people) {
      console.log('people', people);
      if (CASTLE.social.peopleTotal.length > 0) {
        for (var i = 0; i < CASTLE.social.peopleTotal.length; i++) {
          if (people.gender == 0 && people.socialStats == 1) {
            CASTLE.social.freeMen += 1;
          } else if (people.gender == 0 && people.socialStats == 0) {
            CASTLE.social.slaveMen += 1;
          } else if (people.gender == 1 && people.socialStats == 1) {
            CASTLE.social.freeFemale += 1;
          } else if (people.gender == 1 && people.socialStats == 0) {
            CASTLE.social.slaveFemale += 1;
          }
        }
      }

    }
  },
  laws: {
    taxes: 0,
    slavery: 0,
    drinking: 0,
  }
};

但是，当我尝试将 PEOPLE 对象分配给 CASTLE.social.peopleTotal 数组的零元素时，相应的计数器不会更新，也就是说，该函数要么根本不起作用，要么起作用，但不正确：

function getRandom(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min; //Максимум и минимум включаются
}

CASTLE.social.peopleTotal[0] = Object.assign({}, PEOPLE, { gender: getRandom(0, 1), fraction: getRandom(0, 6), race: getRandom(0, 4), age: getRandom(5, 60), socialStats: getRandom(0, 1), work: 0})
console.log('human: ', CASTLE.social.peopleTotal[0]);
console.log('free male: ', CASTLE.social.freeMen);
console.log('free female: ', CASTLE.social.freeFemale);
console.log('slave man: ', CASTLE.social.slaveMen);
console.log('slave female: ', CASTLE.social.slaveFemale);
javascript
Martin Hope
drako black
Asked: 2023-11-07 18:39:59 +0000 UTC
  • 5

这就是问题所在：有一个“文本”类型的输入：

<input id="WPVG" type="text" name="workpay">

输入小数（例如 1.1），但是当我尝试使用小数值在任何条件下应用结果值时，系统仅选择两个可能的选项：0 和 1，并忽略所有其他小数选项。没有任何错误，这让我无法找出问题所在。

let WorkPayVG = 0; 
WorkPayVG = Number(document.querySelector('[name="workpay"]').value);
if (WorkPayVG == 0) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'red';
     document.getElementById('RVG03').innerHTML = 'Warning! Your people are unhappy that you don\'t pay them! Settle this issue quickly or it may lead to an uprising and loss of people!';
   } else if (0 < WorkPayVG <= 0.25) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'red';
     document.getElementById('RVG03').innerHTML = 'Warning! Your people are unhappy that you pay them too little for their work! Please resolve this issue quickly or it may lead to people fleeing!'
   } else if (0.25 < WorkPayVG <= 0.5) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'red';
     document.getElementById('RVG03').innerHTML = 'Warning! You pay your people too little! If you don\'t take action, they will begin to starve!';
   } else if (0.5 < WorkPayVG <= 0.75) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'red';
     document.getElementById('RVG03').innerHTML = 'Warning! Your people\'s income is barely enough to make ends meet!';
   } else if (0.75 < WorkPayVG <= 1) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'green';
     document.getElementById('RVG03').innerHTML = 'Your people are fed and clothed, what else is needed for happiness?'
     console.log('WorkPayVG 0.75-1:', WorkPayVG);
   } else if (WorkPayVG > 1) {
     document.getElementById('RVG03').style.display = 'inline';
     document.getElementById('RVG03').style.color = 'green';
     document.getElementById('RVG03').innerHTML = 'Your people are happy about your generosity, which translates into increased efficiency at work.';
     console.log('WorkPayVG >1:', WorkPayVG);
   }

帮助我了解出了什么问题？为什么系统看不到小数？我怀疑问题出在数据类型上，但我不明白如何告诉系统它需要考虑小数部分。

javascript
Martin Hope
drako black
Asked: 2023-10-20 20:12:55 +0000 UTC
  • 5

朋友们，这就是问题所在：有3个div元素：div1、div2和div3。在 div1 和 div2 中有 2 个按钮（b1、b2、b3、b4），在 div3 中有 1 个按钮（b5）。默认情况下：div2和div 3被visibility属性隐藏，div1可见。分别在 div1 和 div2 中使用按钮 b1 和 b2，可以将 div1 和 div2 之间的可见性状态更改为相反的状态，按钮 b3 和 b4 允许您使 div1 和 div2 不可见，而 div3 可见。然后我的问题是：我需要当您单击按钮 b5 时，div3 被隐藏，并且使 div3 可见的 div（div1 或 div2）变得可见。我的推理是，需要记住单击使 div3 可见的按钮，然后当单击 b5 时，将交换相应的属性。但结果是，div1 总是启动的。

这是代码：

html:

<div id="d1" style="visibility: active;">
<p><button id="b1" onclick="fun11()">1.1</botton></p>
<p><button id="b2" onclick="fun12()">1.2</botton></p>
</div>
<div id="d2" style="visibility: hidden;">
<p><button id="b3" onclick="fun21()">2.1</botton></p>
<p><button id="b4" onclick="fun12()">2.2</botton></p>
</div>
<div id="d3" style="visibility: hidden;">
<p><button id="b5" onclick="fun3()">3</botton></p>
</div>

js

function fun11() {
document.getElementById('d1').style.visibility = 'hidden';
document.getElementById('d2').style.visibility = 'visible';
}

function fun12() {
document.getElementById('d1').style.visibility = 'hidden';
document.getElementById('d2').style.visibility = 'hidden';
document.getElementById('d3').style.visibility = 'visible';
}

function fun21() {
document.getElementById('d2').style.visibility = 'hidden';
document.getElementById('d1').style.visibility = 'visible';
}

function fun3() {
document.getElementById('d3').style.visibility = 'hidden';
If (document.getElementById('b2').onclick = true) {
document.getElementById('d1').style.visibility = 'visible';
} 
elseif (document.getElementById('b4').onclick = true) {
document.getElementById('d2').style.visibility = 'visible';
}
}

那么我做错了什么？

javascript