在移动浏览器中,实现了这样一个功能,如果您从上到下滑动,同时滚动在正确的位置,则页面将重新加载。
我看到了一个类似的问题,但是作者overflow: hidden
在标签上使用了拐杖body
。我对取消此操作的更正确的解决方案感兴趣。
pepel_xD's questions
我有一个问题要问专家:使用了嵌套路由 - 例如:
{
path: 'root',
component: Root,
children: [
{
path: 'child',
component: Child,
children: [
{
path: 'child-child',
component: ChildChild
}
]
}
]
}
在mounted的每一层都有一个对api的数据调用,每个低层组件都依赖于其父组件的数据。似乎一切都在嗡嗡作响,但那是不幸的 - 安装发生在从底部到顶部。也就是说,在挂载最底层的嵌套组件的那一刻,应该从它的父组件那里得到的数据还不可用....如何处理?
需要计算地图
查看区域的查看区域周围描述的圆圈的半径(以米或公里为单位) -地图map.getBounds()
的中心 -map.getCenter()
如何描述周围的圆圈bounds
?
我试图弄清楚 webpack 的动态导入。照我看来。
假设我有一条路线,根据哈希值,应该连接一个或另一个模块:
changeRout(rout) {
const comp = this.routes[rout] || 'error';
import(`../components/${comp}`)
.then(({default: comp}) => {comp.render()})
.catch(err => console.log(err));
}
为此,正如大师在他们的文章中所写,我安装了
'dynamic-import-webpack'
'@babel/plugin-syntax-dynamic-import'
Xs 需要哪一个,但在 webpack 文档中给出了 @babel/plugin-syntax-dynamic-import,在我读到的一些关于 dynamic-import-webpack 的文章中。基本上都离开了。配置中处理js文件的规则如下:
{
test: /\.js$/,
exclude: /node_modules/,
use: {
loader: 'babel-loader',
options: {
presets: [['@babel/preset-env', {modules: false}]],
plugins: ['@babel/plugin-syntax-dynamic-import', 'dynamic-import-webpack']
}
}
}
还发了
optimization: {
splitChunks: {
chunks: 'all'
}
一切似乎都很好,但是,webpack 会生成一个带有模块的通用文件并将其直接连接到页面,但我希望模块块是分开的,并且仅在经过特定路线时才连接。结果,我得到了3个文件
vendors ~ main.js - 这里,据我了解,有各种样式加载器pag等的功能。
0.js - 这是所有模块的代码(我希望每个模块都有自己的块)
main.js - 嗯,主文件(入口点)
给定 2 个圆嵌套在另一个中:有必要实现内部圆与光标的排斥,而它不应超出外部圆的边界。
class Circle {
constructor(node) {
this.DOMElement = node;
this.ctx = this.DOMElement.getContext('2d');
this.dx = 0;
this.dy = 0;
this.x = this.DOMElement.width / 2,
this.y = this.DOMElement.height / 2,
this.ballRadius = 39;
this.cirleRadius = this.DOMElement.width / 2 - 50
}
drawCircle(x, y, radius, fill) {
this.ctx.beginPath();
this.ctx[`${fill.fill}Style`] = fill.color;
this.ctx.lineWidth = 3;
this.ctx.arc(x, y, radius, 0, Math.PI*2, true);
this.ctx[fill.fill]();
this.ctx.closePath();
}
render() {
this.ctx.clearRect(0, 0, this.DOMElement.width, this.DOMElement.height);
this.drawCircle(
this.DOMElement.width / 2,
this.DOMElement.height / 2,
this.cirleRadius,
{fill: 'stroke', color: '#34648e'}
);
this.drawCircle(
this.x,
this.y,
this.ballRadius,
{fill: 'fill', color: '#0294bf'}
);
if(Math.pow(this.x - this.DOMElement.width / 2, 2) + Math.pow(this.y - this.DOMElement.height / 2, 2) >= Math.pow(this.cirleRadius - this.ballRadius, 2) ) {
// ????
}
const frame = requestAnimationFrame(this.render.bind(this))
}
init() {
let currentX = 0;
let currentY = 0;
let distance = 0;
let speed = 10;
this.DOMElement.onmousemove = (event) => {
let mouseX = event.clientX - this.DOMElement.offsetLeft - 10;
let mouseY = event.clientY - this.DOMElement.offsetTop - this.DOMElement.scrollTop + window.pageYOffset - 14;
let xResult = mouseX - currentX;
let yResult = mouseY - currentY;
distance = Math.sqrt(xResult * xResult + yResult * yResult);
if(Math.pow(mouseX - this.x, 2) + Math.pow(mouseY - this.y, 2) <= Math.pow(this.ballRadius + 5, 2) ) {
this.x += xResult / distance * speed;
this.y += yResult / distance * speed;
}
currentX = mouseX;
currentY = mouseY;
}
this.render();
}
}
const circle = new Circle(document.querySelector('#canvas'));
circle.init();
.canvas {
border: 15px solid #ebebeb;
margin: auto;
background-color: #f8f8f8;
}
<canvas id="canvas" class="canvas" width="590" height="600">
告诉我如何通过在一定距离处用光标接触球来实现有计划的“反弹”,同时在碰撞期间从外圆的边界进行同样的平滑“反弹”。
在画布上画了 2 个圆圈,一个在另一个里面。有必要将内圈的运动限制在外圈的边界内
根据答案
中的示例代码
,我对代码进行了一些实验,我将点分散在屏幕上
textGeo.vertices.forEach(function (vertex) {
vertex.x = THREE.Math.randFloat(-20, 20)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
vertex.y = THREE.Math.randFloat(-20, 20)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
vertex.z = THREE.Math.randFloat(-10, 10)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
});
添加了几个功能并更改了渲染功能
function setPosition(vertex, curent, orign, step) {
let curentPoint = Math.round(curent * 10) / 10;
let orignPoint = Math.round(orign * 10) / 10;
if (curentPoint !== orignPoint) {
curent = orign < curent ? curent - step : curent + step;
} else {
curent = orign;
vertex.complate = true;
}
return curent;
}
function isComplated(vertices) {
let result = true;
vertices.forEach(function(vertex, i) {
if(!vertex.complate) {
result = false;
}
});
return result;
}
function render() {
let animationId = requestAnimationFrame(render);
if (!isComplated(textGeo.vertices)) {
textGeo.vertices.forEach(function (vertex) {
vertex.x = setPosition(vertex, vertex.x, vertex.startPoint.x, 0.1);
vertex.y = setPosition(vertex, vertex.y, vertex.startPoint.y, 0.1);
vertex.z = setPosition(vertex, vertex.z, vertex.startPoint.z, 0.1);
});
} else {
cancelAnimationFrame(animationId);
}
textGeo.verticesNeedUpdate = true;
renderer.render(scene, camera);
}
思路如下:
将点分散在屏幕周围,然后开始将它们返回到原来的位置,当所有点都回到初始位置时,通过停止 AnimationFrame 来完成动画。但问题是 cancelAnimationFrame(animationId) 在所有点都回到原位之前被调用。
工作示例:
var scene = new THREE.Scene();
var camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 1, 1000);
camera.position.set(0, 10, 20);
var renderer = new THREE.WebGLRenderer({
antialias: true
});
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
// var controls = new OrbitControls(camera, renderer.domElement);
camera.lookAt(scene.position);
var light = new THREE.DirectionalLight(0xffffff, 2);
light.position.setScalar(100);
scene.add(light);
var textGeo = null;
var textPoints = null;
var loader = new THREE.FontLoader();
loader.load('https://threejs.org/examples/fonts/droid/droid_serif_bold.typeface.json', function (response) {
var font = response;
setText(font);
render();
});
function setText(font) {
textGeo = new THREE.TextGeometry('ABC', {
font: font,
size: 4,
height: 0.5,
curveSegments: 4,
bevelEnabled: false,
bevelSize: 10,
bevelThickness: 50
});
textGeo.computeBoundingBox();
textGeo.computeVertexNormals();
textGeo.center();
fillWithPoints(textGeo, 10);
textGeo.vertices.forEach(function (vertex) {
vertex.startPoint = vertex.clone();
vertex.direction = vertex.clone().normalize();
})
textGeo.vertices.forEach(function (vertex) {
vertex.x = THREE.Math.randFloat(-20, 20)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
vertex.y = THREE.Math.randFloat(-20, 20)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
vertex.z = THREE.Math.randFloat(-10, 10)//.copy(vertex.startPoint).addScaledVector(vertex.direction, 5 + Math.sin(Date.now() * 0.001) * 5);
});
window.p = textGeo.vertices[0]
//console.log(textGeo.vertices[0]);
//textGeo.verticesNeedUpdate = true;
//textGeo.applyMatrix( new THREE.Matrix4().makeTranslation( 1, 1, 1 ) );
textPoints = new THREE.Points(textGeo, new THREE.PointsMaterial({
color: 0xf00008,
size: 0.1
}));
scene.add(textPoints);
}
function fillWithPoints(geometry, pointNumber) {
geometry.computeBoundingBox();
for (var i = 0; i < pointNumber; i++) {
setRandomPoint(geometry);
}
}
function setRandomPoint(geometry) {
var point = new THREE.Vector3(
THREE.Math.randFloat(geometry.boundingBox.min.x, geometry.boundingBox.max.x),
THREE.Math.randFloat(geometry.boundingBox.min.y, geometry.boundingBox.max.y),
THREE.Math.randFloat(geometry.boundingBox.min.z, geometry.boundingBox.max.z)
);
//console.log(point);
if (isPointInside(point, geometry)) {
geometry.vertices.push(point);
} else {
setRandomPoint(geometry);
}
}
var a = new THREE.Vector3();
var b = new THREE.Vector3();
var c = new THREE.Vector3();
var face = new THREE.Face3();
function isPointInside(point, geometry) {
var retVal = false;
for (var i = 0; i < geometry.faces.length; i++) {
face = geometry.faces[i];
a = geometry.vertices[face.a];
b = geometry.vertices[face.b];
c = geometry.vertices[face.c];
//console.log(face, a, b, c);
if (ptInTriangle(point, a, b, c)) {
var retVal = true;
break;
}
}
return retVal;
}
function ptInTriangle(p, p0, p1, p2) {
// credits: http://jsfiddle.net/PerroAZUL/zdaY8/1/
var A = 1 / 2 * (-p1.y * p2.x + p0.y * (-p1.x + p2.x) + p0.x * (p1.y - p2.y) + p1.x * p2.y);
var sign = A < 0 ? -1 : 1;
var s = (p0.y * p2.x - p0.x * p2.y + (p2.y - p0.y) * p.x + (p0.x - p2.x) * p.y) * sign;
var t = (p0.x * p1.y - p0.y * p1.x + (p0.y - p1.y) * p.x + (p1.x - p0.x) * p.y) * sign;
return s > 0 && t > 0 && (s + t) < 2 * A * sign;
}
function setPosition(vertex, curent, orign, step) {
let curentPoint = Math.round(curent * 10) / 10;
let orignPoint = Math.round(orign * 10) / 10;
if (curentPoint !== orignPoint) {
curent = orign < curent ? curent - step : curent + step;
} else {
curent = orign;
vertex.complate = true;
}
return curent;
}
function isComplated(vertices) {
let result = true;
vertices.forEach(function(vertex, i) {
if(!vertex.complate) {
result = false;
}
});
return result;
}
function render() {
let animationId = requestAnimationFrame(render);
if (!isComplated(textGeo.vertices)) {
textGeo.vertices.forEach(function (vertex) {
vertex.x = setPosition(vertex, vertex.x, vertex.startPoint.x, 0.1);
vertex.y = setPosition(vertex, vertex.y, vertex.startPoint.y, 0.1);
vertex.z = setPosition(vertex, vertex.z, vertex.startPoint.z, 0.1);
});
} else {
cancelAnimationFrame(animationId);
}
textGeo.verticesNeedUpdate = true;
/* complated = isComplated(textGeo.vertices);
if (complated) {
//console.log(complated);
cancelAnimationFrame(animationId);
console.log('end')
} */
renderer.render(scene, camera);
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/94/three.min.js"></script>
我走对了吗?还是这些事情做的不同?
这可以通过什么方式实现?是否需要先在一些3D编辑器中实现,然后导出为三个,还是可以使用标准库工具来完成?
我是 3D 图形的新手。
我根据文档中的示例渲染了 3D 文本,但我得到了一个位置,而不是文本。
let scene = new THREE.Scene();
let camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
let renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
renderer.setClearColor(0xEEEEEE);
camera.position.x = -50;
camera.position.y = 30;
camera.position.z = 40;
camera.lookAt(scene.position);
let loader = new THREE.FontLoader();
loader.load('./helvetiker_regular.typeface.json', (font) => {
let geometry = new THREE.TextGeometry('enemy', {
font: font,
size: 1,
height: 5,
curveSegments: 12,
bevelEnabled: true,
bevelThickness: 10,
bevelSize: 8,
bevelSegments: 5
});
let material = new THREE.MeshPhongMaterial({color: 0xcccccc});
let header = new THREE.Mesh(geometry, material);
scene.add(header);
renderer.render(scene, camera);
document.body.appendChild(renderer.domElement);
});
有人可以解释如何计算这些值。
给定两对数字 (1,3) 和 (0,100) 。
第二对取值为0,第一对取值为1,取100分别为3。0到100
之间的值是可以变化的,1到3之间的值变化时如何计算?
我不能输入比例,我要求一个可以理解的解释!
在计算过程中,有时会获得带有大量小数位(大小数部分)的结果。
对根据以下标准对此类数字进行四舍五入的算法感兴趣:有一个数字表示数字的小数部分允许的最大字符数n
,等于4
然后,当收到一个数字时1.6547835
-您可以简单地做1.6547835.toFixed(n)
-我们得到1.6548
.
一切都很好。但是如果在计算过程中得到一个整数,那么这种技术会给出输出1.0000
,这不是很好。
接下来,假设它变成了一个数字4.00000000005
,上面的方法会给出4.0000
,但我想4
。
一般来说,我们需要一个算法来四舍五入,如下所示:
6.400000000000002 // 6.4
1.0000000000000004 // 1
5.3424505674 // 5.3425
5 // 5
6.4560000006 // 6.456
我不要求现成的答案、公式和函数,将我的思想引向正确的方向。
任务是使用javascript绑定2个select,这样满足以下条件:
1.如果select 1中选择了3,则第二个中选择了3,1、2、3option
可以选择,0不可以选择.option
option
option
option
2.如果选择1中选择option
了2,则第二次选择值为2,1option
和option
2可供选择,option
0和option
3不可供选择。
3.如果在select 1中选择了1 - 在第二次select中选择了1 option
,其余的都不能选择。
4.如果第1次选择100,第2次选择0 option
,其余都无法选择。
任务似乎不难,但有些事情不成功....
当第一个选择100时,第二个中0和1都可用...
function roomsSincGuest(param1, param2) {
return function (event) {
var value = param1.value;
var options = param2.options;
var optionsLength = options.length;
for (var i = 0; i < optionsLength; i++) {
options[i].disabled = true;
if (+options[i].value === 0 && +value === 100) {
options[i].selected = true;
options[i].disabled = false;
}
if (options[i].value < value && +options[i].value !== 0) {
options[i].disabled = false;
}
if (options[i].value === value) {
options[i].selected = true;
options[i].disabled = false;
}
}
};
}
var first = document.querySelector('#first');
var second = document.querySelector('#second');
first.addEventListener('change', roomsSincGuest(first, second));
<form>
<select id="first" name="first">
<option value="1" selected="">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="100">100</option>
</select>
<select id="second" name="second">
<option value="3" selected="" >3</option>
<option value="2" >2</option>
<option value="1">1</option>
<option value="0">0</option>
</select>
</form>
实现一个drawNestedSetsTree(data, node)
将两个参数作为输入的函数:
data
- 一个或多个节点的数组0
,其中每个元素都包含字段title
(主机名),left
(左边框)和right
(右边框)。
存储格式 - 嵌套集
node
- DOM节点(你可以认为它会是div
),你需要在其中以树的形式展示最终的结构ul
和li
该函数drawNestedSetsTree()
将位于数据中的树的可视化输出到传递的 DOM 节点。
输入数组数据和函数结果如下所示:
[
{
title: "Одежда",
left: 1,
right: 22
},
{
title: "Мужская",
left: 2,
right: 9
},
{
title: "Женская",
left: 10,
right: 21
},
{
title: "Костюмы",
left: 3,
right: 8
},
{
title: "Платья",
left: 11,
right: 16
},
{
title: "Юбки",
left: 17,
right: 18
},
{
title: "Блузы",
left: 19,
right: 20
},
{
title: "Брюки",
left: 4,
right: 5
},
{
title: "Жакеты",
left: 6,
right: 7
},
{
title: "Вечерние",
left: 12,
right: 13
},
{
title: "Летние",
left: 14,
right: 15
}
];
<ul>
<li>Одежда
<ul>
<li>Мужская
<ul>
<li>Костюмы
<ul>
<li>Брюки</li>
<li>Жакеты</li>
</ul>
</li>
</ul>
</li>
<li>Женская
<ul>
<li>Платья
<ul>
<li>Вечерние</li>
<li>Летние</li>
</ul>
</li>
<li>Юбки</li>
<li>Блузы</li>
</ul>
</li>
</ul>
</li>
</ul>
对解决此类问题的算法感兴趣。
我有原始数组:
[ 'dev/img/sprites/coctail/coc-1.png',
'dev/img/sprites/coctail/coc-2.png',
'dev/img/sprites/coctail/coc-3.png',
'dev/img/sprites/coctail/coc-4.png',
'dev/img/sprites/coctail/coc-5.png',
'dev/img/sprites/social/advan-1.png',
'dev/img/sprites/social/advan-2.png',
'dev/img/sprites/social/advan-3.png',
'dev/img/sprites/social/advan-4.png',
'dev/img/sprites/testSprite1/s19908f1255e3d10,
'dev/img/sprites/testSprite1/shutterstock_106,
'dev/img/sprites/testSprite1/tel.jpg',
'dev/img/sprites/testSprite1/unnamed.png' ]
有必要根据它制作一个对象数组,如下所示:
[ { data:
[ 'dev/img/sprites/coctail/coc-1.png',
'dev/img/sprites/coctail/coc-2.png',
'dev/img/sprites/coctail/coc-3.png',
'dev/img/sprites/coctail/coc-4.png',
'dev/img/sprites/coctail/coc-5.png' ],
fileName: 'coctail',
destPath: 'app/img/' },
{ data:
[ 'dev/img/sprites/social/advan-1.png',
'dev/img/sprites/social/advan-2.png',
'dev/img/sprites/social/advan-3.png',
'dev/img/sprites/social/advan-4.png' ],
fileName: 'social',
destPath: 'app/img/' },
{ data:
[ 'dev/img/sprites/testSprite1/s19908f1255e3d106eca5d.jpg',
'dev/img/sprites/testSprite1/shutterstock_106748483-247x180.jpg',
'dev/img/sprites/testSprite1/tel.jpg',
'dev/img/sprites/testSprite1/unnamed.png' ],
fileName: 'testSprite1',
destPath: 'app/img/' } ]
原则上,任务已经解决,但我自己并不喜欢我写的代码。结果是很多循环,而且不知何故很麻烦。
任何人都可以看一下并指出可以更紧凑地完成的地方吗?
var fileNames = new Set();
var files = [];
var destination = new Set();
//console.log(matches)
matches.forEach((item, i, arr) => {
if (item.includes(config.spritesFolder)) {
var pos = item.indexOf(config.spritesFolder);
var start = item.indexOf('/', pos) + 1;
var end = item.indexOf('/', start);
fileNames.add(item.slice(start, end));
destination.add(item.slice(0, pos));
}
});
var i = 0;
fileNames.forEach((item, it, arr) => {
files[i] = {};
files[i].data = [];
files[i].fileName = item;
for (var j = 0; j < matches.length; j++) {
if (matches[j].indexOf(item) != -1) {
files[i].data.push(matches[j]);
}
}
i++;
});
for (var i = 0; i < files.length; i++) {
files[i].destPath = '';
destination.forEach((item, it, arr) => {
if (files[i].data[0].indexOf(item) != -1) {
files[i].destPath = item.replace(config.path.src.dir, config.path.build.dir);
}
});
}
console.dir(files)
在 ES-2015 标准中,可以设置默认函数参数,如下所示:
function name(name = 'noname') {
console.log(name);
}
name()
然而,同样的效果可以通过 hack 来实现:
function name(name) {
var name = name || 'noname'
console.log(name);
}
name()
在这种情况下,Babel 翻译这样一个函数:
function name() {
var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'noname';
console.log(name);
}
name();
哪个选项更好:如 Babel 所建议或使用 boolean ||
?
如果您需要在调整浏览器窗口大小时执行一些代码,那么我们将在窗口上挂起调整大小事件处理程序:
window.addEventListener('resize', function(e){//код....});
但是如果你不需要在调整大小时执行代码,而是在完成后才执行怎么办?
例如,我们开始调整窗口大小,而大小发生变化时没有任何反应,一旦调整大小结束,就执行代码。
javascript中有一个模仿input type="range"
。
function Range(container) {
this.container = container;
if (!this.container) return;
this.inputMin = container.querySelector('[data-type=input-min]');
this.inputMax = container.querySelector('[data-type=input-max]');
this.minValue = parseFloat(container.querySelector('[data-type=min-val]').textContent.replace(/\s/g, ''));
this.maxValue = parseFloat(container.querySelector('[data-type=max-val]').textContent.replace(/\s/g, ''));
this.inner = container.querySelector('[data-type=range-inner-element]');
this.valuesElem = container.querySelector('[data-type=range-element]');
this.minBtn = container.querySelector('[data-type=min-btn]');
this.maxBtn = container.querySelector('[data-type=max-btn]');
//console.log(this);
this.init();
}
Range.prototype.drag = function(event) {
function move(event) {
var left = event.pageX - elemX - boxX;
if (elem == this.minBtn) {
this.inner.style.left = elem.offsetLeft + elem.offsetWidth / 2 + 'px';
if (left < 0) {
left = 0;
}
if (left > this.maxBtn.offsetLeft - elem.offsetWidth) {
left = this.maxBtn.offsetLeft - elem.offsetWidth;
}
} else if (elem == this.maxBtn) {
this.inner.style.right = elem.offsetLeft - elem.offsetWidth / 2 + 'px';
if (left < this.minBtn.offsetLeft + elem.offsetWidth) {
left = this.minBtn.offsetLeft + elem.offsetWidth;
}
if (left > this.valuesElem.offsetWidth - elem.offsetWidth) {
left = this.valuesElem.offsetWidth - elem.offsetWidth;
}
}
elem.style.left = left + 'px';
this.inner.style.width = this.maxBtn.offsetLeft - this.minBtn.offsetLeft + 'px';
}
function removeMove() {
document.removeEventListener('mousemove', move);
document.removeEventListener('mouseup', removeMove);
}
if (event.target == this.minBtn || event.target == this.maxBtn) {
var elem = event.target;
var elemX = event.pageX - elem.getBoundingClientRect().left;
var boxX = this.valuesElem.getBoundingClientRect().left;
var coord = event.target.offsetLeft;
move = move.bind(this);
document.addEventListener('mousemove', move);
document.addEventListener('mouseup', removeMove);
event.target.ondragstart = function() {
return false;
};
}
}
Range.prototype.setValue = function() {
this.inputMin.value = this.minValue;
this.inputMax.value = this.maxValue;
}
Range.prototype.init = function() {
this.inner.style.left = this.minBtn.offsetLeft + this.minBtn.offsetWidth / 2 + 'px';
this.inner.style.right = this.maxBtn.offsetLeft - this.maxBtn.offsetWidth / 2 + 'px';
this.setValue();
this.valuesElem.addEventListener('mousedown', this.drag.bind(this));
}
var range = new Range(document.querySelector('[data-type=range]'));
.filters_section_list {
width: 300px;
list-style: none
}
.filters_section_item .range {
height: 6px;
background-color: #AEAEAE;
border-radius: 4px;
position: relative;
}
.filters_section_item .range_inner {
height: inherit;
background-color: #FD2016;
}
.filters_section_item .range_btn {
width: 18px;
height: 18px;
border-radius: 50%;
box-shadow: 0 0 3px rgba(0, 0, 0, 0.6);
position: absolute;
top: -7px;
background-color: #fff;
cursor: pointer;
}
.filters_section_item .range_inner {
position: absolute;
width: 100%;
}
.filters_section_item .range_btn[data-type=min-btn] {
left: 0;
}
.filters_section_item .range_btn[data-type=max-btn] {
left: 100%;
}
.filters_section_item .values {
overflow: hidden;
margin-top: 40px;
}
.filters_section_item .values .min-value {
float: left;
width: 35%;
text-align: left;
padding-bottom: 14px;
padding-left: 10px;
padding-right: 10px;
border-bottom: 1px solid #ACACAC;
}
.filters_section_item .values .max-value {
float: right;
width: 35%;
text-align: right;
padding-bottom: 14px;
padding-left: 10px;
padding-right: 10px;
border-bottom: 1px solid #ACACAC;
}
<ul class="filters_section_list" data-type="box-content">
<li class="filters_section_item" data-type="range">
<input id="price-min" type="hidden" name="price-min" value="0" data-type="input-min">
<input id="price-max" type="hidden" name="price-max" value="1000000" data-type="input-max">
<div class="range" data-type="range-element">
<div class="range_inner" data-type="range-inner-element"></div>
<div class="range_btn" data-type="min-btn"></div>
<div class="range_btn" data-type="max-btn"></div>
</div>
<div class="values">
<span class="min-value" data-type="min-val">0</span>
<span class="max-value" data-type="max-val">1000000</span>
</div>
</li>
</ul>
告诉我算法现在如何计算滑块移动时它们之间的值范围?
//соханим начальные настройки
var def = Object.assign({}, this.curSet);
// выберем все брейкпоинты из настроек
var query = [];
for (var key in def.media) {
query.push(def.media[key].point);
}
// фукция устанавливает настройки для запуска
function setNewSettigs(mql) {
var newSet = Object.assign({}, def);
for (var key in newSet.media) {
for (var prop in newSet.media[key]) {
if (newSet.media[key][prop] == mql.media) { // вот здесь в IE10+ всегда false
for (var set in newSet.media[key].settings) {
if (set in newSet) {
newSet[set] = newSet.media[key].settings[set];
}
}
}
}
}
return newSet;
}
// функция производит действия при совпадении медиа выражения
function run(mql) {
if (mql.matches) {
this.curSet = Object.assign({}, setNewSettigs(mql));
console.log(this.curSet)
this.start();
console.log(mql.media)
} else {
this.curSet = Object.assign({}, def);
this.start();
}
}
// создадим медиа запросы и повесим обработчики на них
query.forEach(function(item, i, arr) {
var mql = window.matchMedia(arr[i]);
mql.addListener(run.bind(this));
run.call(this, mql);
}, this);
下午好,剧透下面是我想用新参数重新启动对象初始化的代码,重点是使用 machmedia 的媒体查询。对象创建如下所示:
var obj = new Obj({
elem: document.querySelector('.CSSClass'),
count: 4,
// это объект с контрольными точками и свойствами которые нужно перезаписать
media: {
point1: {
// контрольная точка
point: 'only screen and (max-width: 768px)',
// перезаписываемые свойства
settings: {
count: 3,
}
},
point2: {
point: 'only screen and (max-width: 480px)',
settings: {
count: 1,
}
},
}
});
看起来一切正常(除了一个细微差别,下面是关于它的),但我不得不打开 IE 和唉......setNewSettigs
来自剧透下代码的功能不会覆盖设置对象的参数值 \u200b\u200b 从settigs
上面的代码,和 9 工作正常,但已经从 10 开始这样的事件。问:为什么会这样。谁会帮你弄清楚?
Ps 现在关于上面的细微差别。在设置 2 控制电流中,分别为 768px 和 480px。参数count
- 负责当前屏幕中显示的块数。所以,当屏幕缩小时,在768时一切正常,显示3块,在480时显示1,但是当你在480后再次开始增加窗口时,似乎过了481的阈值后,显示3块,所以这符合 768 的范围。但是如果媒体查询不匹配,脚本应该使用原始设置运行,我怎样才能让脚本记住大屏幕的设置应该在设置之间应用断点?
问题更新。
测试代码后,发现条件不起作用newSet.media[key][prop] === mql.media
,并且在迭代属性时,表达式总是返回false
,因此属性不会被覆盖....为什么 10+ 的行为是这样的?错误或如何正确执行?
为什么需要这种比较 - 当media
设置中参数内的对象被绕过时,其属性的值与进入函数的 mql.media 的值进行比较,如果匹配,则设置中的属性,在其中找到匹配项的对象将被覆盖。
mql
是一个实例window.matchmedia
,它是在循环中创建的query
(剧透下代码中的最后一个循环)。它有一个media
存储媒体查询字符串的属性。
newSet.media[key][prop]
- 这里通过对象的属性media
,这又是具有点属性的对象 - 也是媒体查询的字符串。因此,这正是检查 mql.media 中的字符串与 newSet.media[key].point 中的字符串是否匹配的内容
有一个字符串“14px”,如何在SCSS中将其转换为数字?
例如,对于值的字符串表示,有一个函数inspect($value)
,为了找出与数字相关联的单位,有unit($number)
。可就算type-of(14рх)
回来又怎样string
,却是必须的namber
。
我解释一下:有这么一段代码,看list的值是否有计量单位,如果没有,则追加
@function chekList($list) {
$tmp: ();
@each $key in $list {
@if(unitless($key)) {
$key: inspect($key);
$key: str-insert($key, "px", str-length($key) + 1);
}
$tmp: append($tmp, $key);
}
@return $tmp;
}
现在将接收到的字符串值转换为数字值......
或者建议如何将单位添加到数字中,如果没有的话?
PS 下面我给出了一个关于如何添加度量单位的答案,如果它们不是的话。但仍然对如何将字符串转换为数字感兴趣。
假设输出中的 10 + "px" 将给出字符串 "10px",但你需要它是一个数字。
在哪里可以找到 php 内部常量列表?
代码中有一个常量设置:
define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 )
是什么意思-7
?我了解这些是一些内部 php 值......