в оба компонента переданы обьекты (деструктуриазция) и не знаю как правильно переделать компоненты
onClick = ({ target: { dataset: { shift } } }) => {
this.setState(() => ({ shift }), this.filter);
}
Насколько сложно выполнить мою задачу не прибегая к выше перечисленному, возможно ли это сделать на реакте, и сложно ли это для начинающего. И стоит ли самому вообще это делать, и что посоветуете учитывая мои джуновские знания?
У меня в голове только пройтись через ctrl+shift+f по импортам
max: this.LongCoordinates("right"),this ссылается на объект window, поскольку находится внутри объекта(что никак его не переопределяет), а не метода(метод является функцией), а функция переопределяет this. Но у объекта window нет метода LongCoordinates, отсюда и ошибка.var model = {
LongCoordinates: function (dir) {
let long = document.querySelector(".long");
long.style.left = "8px";
long.style.right = "274px";
if (dir == "right") return "274px";
},
ballCoordinates: function () {
return {
min: 0,
max: this.LongCoordinates("right"), // теперь this ссылается на model
x: "0px"
}
}
};
from functools import reduce
from pathlib import PurePosixPath
paths = [
'E:/folder/maps',
'E:/1/2/3',
'E:/folder/new',
'E:/folder/maps/2',
'D:/papka/echepapka',
'E:/1/path/dir',
]
tree = {}
for path in map(PurePosixPath, paths):
reduce(lambda node, part: node.setdefault(part, {}), path.parts, tree){'E:': {'folder': {'maps': {'2': {}}, 'new': {}},
'1': {'2': {'3': {}}, 'path': {'dir': {}}}},
'D:': {'papka': {'echepapka': {}}}}
С чем это связано?
Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
// ...
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned = null;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
