Alex10214

Как вы в коде написали, так и сортируется, по убыванию таймстампа:
'Tue Jan 31 2023 10:14:28 GMT+0000 (Coordinated Universal Time)' => 1675160068000
'Tue Jan 31 2023 12:13:13 GMT+0200 (Eastern European Standard Time)' => 1675159993000
'Tue Jan 31 2023 11:47:08 GMT+0200 (Eastern European Standard Time)' => 1675158428000

Сортирует правильно, с учётом временных зон. Именно в таком порядке произойдут эти события.

Если хочется проигнорировать часовые пояса и представить (зачем-то), что время у всех событий указано в одной общей временной зоне, то можно отрезать лишнее — брать часть строки до "GMT":

test.forEach(item => item.tsNoTZ = new Date(item.dateAndTime.substring(0, 24)));
test.sort((a, b) => b.tsNoTZ - a.tsNoTZ);

И лучше только однажды пройти по массиву и добавить каждому объекту новое поле, по которому потом сортировать.

Для работы с датами использовать momentjs.

1. Сначала распарсить даты (иначе при сортировке их придется парсить два-три раза)
   
2. Для сортировки использовать moment().diff()
   

У вас неправильный синтаксис объектов.
Это точно Javascript?

let dataValues = {
id_key: 'A005012',
marginToEquityRate: 0,
leverage: 0,
maxDD: 0,
std: 0,
};

dataValues.std = 1;
alert(`В объекте dataValues свойство std равно ${dataValues.std}`);

const dataValues = { id_key: 'A005012', std: 0 };
const t = 'std';
dataValues[t] = 1;
console.log(dataValues);
// { id_key: "A005012", std: 1 }

Можно попробовать расширить прототип массива своим методом, который будет включать в том числе запуск функции записи. Например, так:

Array.prototype.add_save = function( data ) {
    this.push(data) //вставляем данные в массив
    save_function(data) //вызов вашей функции сохранения данных
}

Потом просто вызываете на этом массиве метод save_add, передавая в него требуемые данные, и все будет работать.

my_array.save_add(data)

Сделайте функцию для добавления в массив, и пополняйте массив из разных обработчиков только через эту функцию. Она и будет той самой, что вам нужно вызывать при каждом добавлении.

Можете даже сделать массив приватным, если хотите. Тогда уж точно придётся добавлять данные через публичную функцию. Но в целом это не обязательно.

Не должно быть проблем

export class Component {
  constructor(
    private _http: HttpClient,
    private _elementRef: ElementRef
  ) {}

  ngOnInit() {
    const json = '{"--background-color": "black", "--text-color": "red"}';
    this._http.get('host')._subscribe(_res => {
      for (let [key, value] of Object.entries(
        JSON.parse(json)
      )) {
        this._elementRef.nativeElement.style.setProperty(
          key,
          value
        );
        console.log({ key, value });
      }
    });
  }
}

• https://tyapk.ru/blog/post/angular-theming-with-cs...
  
• https://netbasal.com/binding-css-variables-in-angu...
  

Да.

let trade_account: Trade_account | null | undefined; // явно указываем, что тип переменной - это undefined или Trade_account или null

Можно, но осторожно. Пока это еще экспериментальная фича (публичные/приватные поля).
https://developer.mozilla.org/ru/docs/Web/JavaScri...

Можно писать и так и так.
Если поля инстанса должны определяться во время создания и по логике приложения у него не может быть дефолтовых значений, тогда первый вариант.
Если логика приложения допускает что у инстанса бывают дефолтовые значения и их при желании можно не переопределять, тогда второй вариант.
Код должен подсказывать разработчикам, которые пишут после тебя, логику твоего приложения.

Непонятен вопрос. Подпишитесь на изменение данных и измените данные в другом.

<mat-slider (ngModelChange)="helpersService.slideValue1$.next(Number($event))"
            [ngModel]="helpersService.slideValue1$.value"
            min="0"
            max="100"></mat-slider>


ngOnInit(): void {
    this.helpersService.slideValue1$
        .pipe(
            takeUntil(this.destroy$),
            tap(value => {
                this.helpersService.slideValue2$.next(value);
            )
        )
        .subscribe();
};

// или с методом
updateSliderValue(event: MatSliderChange){
    this.helpersService.slideValue1$.next(Number(event));
}

Получаем одну подходящую строку:

const search = ` ${str}.`;
const item = arr.find(n => n.includes(search));

Все:

const test = RegExp.prototype.test.bind(RegExp(`\\b${str}\\b`));
const items = arr.filter(test);

lodash:

var a = [
  ['1', '2', '3', '4'],
  ['5', '6', '7', '8'],
  ['9', '10', '11', '12']
];

var b = [
  ['a', 'c', 'v', 's'],
  ['l', 'k', 'j', 'h'],
  ['f', 'z', 'b', 'm']
];

zipWith(a, b, concat);

Массивы сложить в массив (const arrs = [ arr1, arr2 ];), дальше есть варианты:

const result = arrs[0].map((_, i) => arrs.flatMap(arr => arr[i]));

или

const result = arrs.reduce((acc, arr) => (
  arr.forEach((n, i) => (acc[i] ??= []).push(...n)),
  acc
), []);

или

const result = [];

for (const arr of arrs) {
  for (const [ i, n ] of arr.entries()) {
    if (!result[i]) {
      result[i] = [];
    }

    for (const m of n) {
      result[i][result[i].length] = m;
    }
  }
}

или

function* zip(data, defaultValue = null) {
  const iterators = Array.from(data, n => n[Symbol.iterator]());

  for (let doneAll = false; (doneAll = !doneAll);) {
    const values = [];

    for (const n of iterators) {
      const { value, done } = n.next();
      values.push(done ? defaultValue : value);
      doneAll &&= done;
    }

    if (!doneAll) {
      yield values;
    }
  }
}


const result = Array.from(zip(arrs), n => n.flat());

const result = [];
for (let i = 1; i < t.length; i += 2) {
  const sub = [];
  for (j = 0; j < t[0].length; j += 1) {
    sub.push([t[0][j], t[i][j], t[i + 1][j]]);
  }
  result.push(sub);
}
console.log(result);

Просто как вариант:

const columns = t[0];
  
  const result = t.reduce((acc, row1, i, arr) => {
    if(!(i & 1)) {
      return acc;
    }
    
    const row2 = arr[i + 1];
    const block = columns.map((c, j) => [c, row1[j], row2[j]]);
    
    acc.push(block);
    return acc;
  }, []);

const chunkedAndTransposed = ([ headers, ...arr ], chunkSize) =>
  arr.reduce((acc, n, i) => (
    (i % chunkSize) || acc.push(headers.map(m => [ m ])),
    n.forEach((m, j) => acc.at(-1)[j].push(m)),
    acc
  ), []);


const result = chunkedAndTransposed(arr, 2);

или, если на последний кусок данных не хватает, а размеры вложенных массивов должны быть одинаковыми, можно добавить null'ов или чего-нибудь ещё:

const chunkedAndTransposed = (arr, chunkSize, defautlValue = null) =>
  Array.from({ length: Math.ceil((arr.length - 1) / chunkSize) }, (_, iChunk) =>
    Array.from({ length: arr[0].length }, (_, iCol) =>
      Array.from({ length: chunkSize + 1 }, (_, iRow) =>
        iRow ? arr[iChunk * chunkSize + iRow]?.[iCol] ?? defautlValue : arr[0][iCol]
      )
    )
  );


const result = chunkedAndTransposed(arr, 5);

Вам поможет Child process

const map = {
  n: "account_name",
  d: "start_deposit",
  c: "client_name",
  b: "ib_account_number",
  l: "leverage",
  e: "description",
  r: "rebalance_model",
  m: "model_settings",
  s: "selected_systems",
  w: "target_weights",
}

let key = "ndcbler";

const hasSettings = this.newAccount.model_settings !== "{}";
const hasWeights = this.newAccount.target_weights !== "{}";

if (hasSettings && hasWeights) {
  key += "swm";
} else if (hasSettings) {
  key += "m";
} else if (hasWeights) {
  key += "sw";
// } else { // что делаем, если ни того ни того нет?
//   key = "";
}

this.objForPost = key.split("")
  .map((key) => `-${key} ${this.newAccount[map[key]]}`)
  .join(" ");